Unlit vs lit shaders in Unity - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple unlit shader

What will be the visible color output of this unlit shader applied to a white mesh?

Unity

Shader "Custom/SimpleUnlit" {
  Properties {
    _Color ("Color", Color) = (1,0,0,1)
  }
  SubShader {
    Tags { "RenderType"="Opaque" }
    Pass {
      CGPROGRAM
      #pragma vertex vert
      #pragma fragment frag
      #include "UnityCG.cginc"
      fixed4 _Color;
      struct appdata {
        float4 vertex : POSITION;
      };
      struct v2f {
        float4 pos : SV_POSITION;
      };
      v2f vert (appdata v) {
        v2f o;
        o.pos = UnityObjectToClipPos(v.vertex);
        return o;
      }
      fixed4 frag (v2f i) : SV_Target {
        return _Color;
      }
      ENDCG
    }
  }
}

A The mesh appears solid red, ignoring all lights.

B The mesh appears with a gradient depending on light direction.

C The mesh appears black because no lighting is calculated.

D The mesh appears white, affected by scene lighting.

💡 Hint

Unlit shaders do not calculate lighting, so the color is constant.

Unlit shaders output a fixed color regardless of scene lighting. Here, _Color is set to red, so the mesh appears solid red.

❓ Predict Output

intermediate

Output difference between lit and unlit shaders

Given a lit shader and an unlit shader applied to the same mesh under a directional white light, what is the main visible difference?

A The unlit shader shows shading; the lit shader shows flat color.

B Both shaders show the same flat color without shading.

C Both shaders show dynamic shadows but different colors.

D The lit shader shows shading and highlights; the unlit shader shows flat color.

💡 Hint

Lit shaders calculate lighting, unlit shaders do not.

Lit shaders respond to lights and show shading and highlights. Unlit shaders ignore lights and show a flat color.

🔧 Debug

advanced

Identify the error in this lit shader snippet

What error will this lit shader code cause when compiled?

Unity

Shader "Custom/BrokenLit" {
  Properties {
    _Color ("Color", Color) = (1,1,1,1)
  }
  SubShader {
    Tags { "RenderType"="Opaque" }
    Pass {
      CGPROGRAM
      #pragma vertex vert
      #pragma fragment frag
      #include "UnityCG.cginc"
      fixed4 _Color;
      struct appdata {
        float4 vertex : POSITION;
        float3 normal : NORMAL;
      };
      struct v2f {
        float4 pos : SV_POSITION;
        float3 normalDir : TEXCOORD0;
      };
      v2f vert (appdata v) {
        v2f o;
        o.pos = UnityObjectToClipPos(v.vertex);
        o.normalDir = normalize(v.normal);
        return o;
      }
      fixed4 frag (v2f i) : SV_Target {
        float3 lightDir = normalize(float3(0,1,0));
        float diff = max(dot(i.normalDir, lightDir), 0);
        return fixed4(_Color.rgb * diff, _Color.a);
      }
      ENDCG
    }
  }
}

A The shader compiles and runs correctly, showing diffuse lighting.

B The shader will produce black output because v.normal is not transformed to world space.

C The shader will fail because normalize() cannot be used on v.normal directly.

D The shader will cause a syntax error due to missing semicolons.

💡 Hint

Normals must be transformed to world space for correct lighting.

The normal is used directly from object space without transforming to world space, so lighting calculation is incorrect and results in black output.

📝 Syntax

advanced

Which shader code snippet correctly implements a simple unlit shader?

Select the code snippet that correctly compiles and outputs a fixed color ignoring lighting.

A fixed4 frag(v2f i) { return fixed4(1,0,0,1); }

B fixed4 frag(v2f i) : SV_Target { return fixed4(1,0,0); }

C fixed4 frag(v2f i) : SV_Target { return fixed4(1,0,0,1); }

D fixed4 frag(v2f i) : SV_Target { return float4(1,0,0,1); }

💡 Hint

Fragment shaders must return fixed4 with SV_Target semantic.

Option C correctly returns fixed4 with four components and the SV_Target semantic required for fragment shaders.

🚀 Application

expert

Choosing shader type for a performance-critical UI element

You need to render a large number of 2D UI elements with solid colors and no lighting effects in a mobile game. Which shader type is best and why?

A Use unlit shaders because they do not calculate lighting and are more efficient.

B Use lit shaders to ensure the UI elements respond to scene lighting for realism.

C Use unlit shaders but add expensive lighting calculations manually for better quality.

D Use lit shaders with all lights disabled to simulate unlit behavior.

💡 Hint

Consider performance and visual needs for UI elements.

Unlit shaders are simpler and faster because they skip lighting calculations, making them ideal for many UI elements that do not need lighting.

Practice

1. What is the main difference between Unlit and Lit shaders in Unity?

easy

A. Unlit shaders do not react to lighting, Lit shaders do

B. Unlit shaders are slower than Lit shaders

C. Lit shaders ignore shadows, Unlit shaders show shadows

D. Lit shaders only work on 2D objects

Solution

1. Step 1: Understand Unlit shader behavior

   Unlit shaders display colors without any lighting or shadow effects.

2. Step 2: Understand Lit shader behavior

   Lit shaders calculate lighting and shadows to create realistic visuals.

3. Final Answer:

   Unlit shaders do not react to lighting, Lit shaders do -> Option A

4. Quick Check:

   Lighting reaction = Unlit no, Lit yes [OK]

Hint: Unlit means no light effects, Lit means light and shadows [OK]

Common Mistakes:

• Thinking Unlit shaders are slower
• Believing Lit shaders ignore shadows
• Assuming Lit shaders only work on 2D

2. Which of the following is the correct way to assign an Unlit shader to a material in Unity's Shader dropdown?

easy

A. Shaders > Unlit > Color

B. Shaders > Legacy Shaders > Transparent

C. Shaders > Standard

D. Shaders > Lit > PBR

Solution

1. Step 1: Locate Unlit shaders in Unity

   Unlit shaders are found under the menu path: Shaders > Unlit > Color.

2. Step 2: Confirm correct shader assignment

   Assigning 'Unlit > Color' applies an unlit shader that ignores lighting.

3. Final Answer:

   Shaders > Unlit > Color -> Option A

4. Quick Check:

   Unlit shader path = Shaders > Unlit > Color [OK]

Hint: Unlit shaders are under Shaders > Unlit in dropdown [OK]

Common Mistakes:

• Choosing Standard shader which is lit
• Selecting Legacy shaders unrelated to unlit
• Picking Lit shaders for unlit materials

3. Given this Unity shader code snippet, what will be the visual result on a 3D object?

Shader "Custom/Example" {
  SubShader {
    Tags { "RenderType"="Opaque" }
    Pass {
      CGPROGRAM
      #pragma vertex vert
      #pragma fragment frag
      struct appdata { float4 vertex : POSITION; };
      struct v2f { float4 pos : SV_POSITION; };
      v2f vert(appdata v) { v2f o; o.pos = UnityObjectToClipPos(v.vertex); return o; }
      fixed4 frag(v2f i) : SV_Target { return fixed4(1,0,0,1); }
      ENDCG
    }
  }
}

medium

A. The object will flicker between colors

B. The object will be shaded with light and shadows

C. The object will be invisible

D. The object will appear bright red without lighting effects

Solution

1. Step 1: Analyze the fragment shader output

   The fragment shader returns fixed4(1,0,0,1), which is solid red color.

2. Step 2: Check for lighting calculations

   No lighting or normal calculations exist, so color is unlit and constant.

3. Final Answer:

   The object will appear bright red without lighting effects -> Option D

4. Quick Check:

   Fragment color fixed red, no lighting = unlit red [OK]

Hint: No lighting code means solid color output [OK]

Common Mistakes:

• Assuming lighting affects color here
• Thinking object is invisible without lighting
• Expecting color changes or flickering

4. You wrote a Lit shader but the object appears completely black in your scene. What is the most likely cause?

medium

A. The object has no mesh assigned

B. The shader is missing normal vector calculations

C. The shader is set to Unlit accidentally

D. The camera is disabled

Solution

1. Step 1: Understand Lit shader requirements

   Lit shaders need normal vectors to calculate lighting properly.

2. Step 2: Identify missing normal vector effect

   If normals are missing or incorrect, lighting calculations fail, causing black appearance.

3. Final Answer:

   The shader is missing normal vector calculations -> Option B

4. Quick Check:

   Missing normals = no lighting = black object [OK]

Hint: Lit shaders need normals for lighting; missing normals cause black [OK]

Common Mistakes:

• Blaming mesh or camera instead of shader code
• Confusing Unlit shader with Lit shader issues
• Ignoring normal vector importance

5. You want to optimize a mobile game by reducing lighting calculations but still want some color variation. Which shader approach is best?

hard

A. Use Unlit shaders with no color variation

B. Use fully Lit shaders with multiple lights

C. Use Unlit shaders with vertex colors for variation

D. Use Lit shaders but disable shadows

Solution

1. Step 1: Consider performance needs

   Reducing lighting calculations improves performance on mobile devices.

2. Step 2: Choose shader with color variation but no lighting

   Unlit shaders with vertex colors provide color changes without expensive lighting.

3. Final Answer:

   Use Unlit shaders with vertex colors for variation -> Option C

4. Quick Check:

   Unlit + vertex colors = color variation without lighting cost [OK]

Hint: Unlit + vertex colors = color without lighting cost [OK]

Common Mistakes:

• Using full Lit shaders which are costly
• Choosing Unlit with no color variation loses visual interest
• Disabling shadows alone doesn't reduce lighting cost fully