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.