Jump to content

Cg Programming/Unity/Multiple Lights

From Wikibooks, open books for an open world
Multiple subway lights of limited range in a tunnel.

This tutorial covers lighting by multiple light sources in one pass. In particular, it covers Unity's so-called “vertex lights” in the ForwardBase pass.

This tutorial is an extension of Section “Smooth Specular Highlights”. If you haven't read that tutorial, you should read it first.

Multiple Lights in One Pass

[edit | edit source]

As discussed in Section “Diffuse Reflection”, Unity's forward rendering path uses separate passes for the most important light sources. These are called “pixel lights” because the built-in shaders render them with per-pixel lighting. All light sources with the Render Mode set to Important are rendered as pixel lights. If the Pixel Light Count of the Quality project settings allows for more pixel lights, then some of the light sources with Render Mode set to Auto are also rendered as pixel lights. What happens to the other light sources? The built-in shaders of Unity render four additional lights as vertex lights in the ForwardBase pass. As the name indicates, the built-in shaders render these lights with per-vertex lighting. This is what this tutorial is about. (Further lights are approximated by spherical harmonic lighting, which is not covered here.)

In the ForwardBase pass, the four vertex lights (i.e. their positions and colors) are specified by the following built-in uniforms (see Unity's documentation of built-in shader variables):

  // Built-in uniforms for "vertex lights"
  uniform half4 unity_LightColor[4];
   // array of the colors of the 4 light sources 
  uniform float4 unity_4LightPosX0; 
   // x coordinates of the 4 light sources in world space
  uniform float4 unity_4LightPosY0; 
   // y coordinates of the 4 light sources in world space
  uniform float4 unity_4LightPosZ0; 
   // z coordinates of the 4 light sources in world space
  uniform float4 unity_4LightAtten0; 
   // scale factors for attenuation with squared distance

We follow Unity's built-in shaders and only compute the diffuse reflection by vertex lights (assuming they are point lights) using per-vertex lighting. This can be computed with the following for-loop inside the vertex shader:

      // Diffuse reflection by four "vertex lights"      
      float3 vertexLighting = float3(0.0, 0.0, 0.0);
      #ifdef VERTEXLIGHT_ON
      for (int index = 0; index < 4; index++)
      {  
        float4 lightPosition = float4(unity_4LightPosX0[index], 
         unity_4LightPosY0[index], 
         unity_4LightPosZ0[index], 1.0);
 
        float3 vertexToLightSource = 
         lightPosition.xyz - output.posWorld.xyz;    
        float3 lightDirection = normalize(vertexToLightSource);
        float squaredDistance = 
         dot(vertexToLightSource, vertexToLightSource);
        float attenuation = 1.0 / (1.0 + 
         unity_4LightAtten0[index] * squaredDistance);
        float3 diffuseReflection = attenuation 
         * unity_LightColor[index].rgb * _Color.rgb 
         * max(0.0, dot(output.normalDir, lightDirection));     
 
        vertexLighting = vertexLighting + diffuseReflection;
      }
      #endif

The total diffuse lighting by all vertex lights is accumulated in vertexLighting by initializing it to black and then adding the diffuse reflection of each vertex light to the previous value of vertexLighting at the end of the for-loop. A for-loop should be familiar to any C/C++/Java/JavaScript programmer. Note that for-loops in Cg are severely limited for some GPUs; in particular the limits (here: 0 and 4) have to be constants for some GPUs, i.e. you cannot even use uniforms to determine the limits. (The technical reason is that the limits have to be known at compile time in order to “un-roll” the loop.)

This is more or less how vertex lights are computed in Unity's built-in shaders. However, remember that nothing would stop you from computing specular reflection or per-pixel lighting with these “vertex lights”.

Complete Shader Code

[edit | edit source]

In the context of the shader code from Section “Smooth Specular Highlights”, the complete shader code is:

Shader "Cg per-pixel lighting with vertex lights" {
  Properties {
   _Color ("Diffuse Material Color", Color) = (1,1,1,1) 
   _SpecColor ("Specular Material Color", Color) = (1,1,1,1) 
   _Shininess ("Shininess", Float) = 10
  }
  SubShader {
   Pass {   
     Tags { "LightMode" = "ForwardBase" } // pass for 
      // 4 vertex lights, ambient light & first pixel light
 
     CGPROGRAM
     #pragma multi_compile_fwdbase 
     #pragma vertex vert
     #pragma fragment frag
 
     #include "UnityCG.cginc" 
     uniform float4 _LightColor0; 
      // color of light source (from "Lighting.cginc")
 
     // User-specified properties
     uniform float4 _Color; 
     uniform float4 _SpecColor; 
     uniform float _Shininess;
 
     struct vertexInput {
      float4 vertex : POSITION;
      float3 normal : NORMAL;
     };
     struct vertexOutput {
      float4 pos : SV_POSITION;
      float4 posWorld : TEXCOORD0;
      float3 normalDir : TEXCOORD1;
      float3 vertexLighting : TEXCOORD2;
     };
 
     vertexOutput vert(vertexInput input)
     {     
      vertexOutput output;
 
      float4x4 modelMatrix = unity_ObjectToWorld;
      float4x4 modelMatrixInverse = unity_WorldToObject; 
 
      output.posWorld = mul(modelMatrix, input.vertex);
      output.normalDir = normalize(
        mul(float4(input.normal, 0.0), modelMatrixInverse).xyz);
      output.pos = UnityObjectToClipPos(input.vertex);
 
      // Diffuse reflection by four "vertex lights"      
      output.vertexLighting = float3(0.0, 0.0, 0.0);
      #ifdef VERTEXLIGHT_ON
      for (int index = 0; index < 4; index++)
      {  
        float4 lightPosition = float4(unity_4LightPosX0[index], 
         unity_4LightPosY0[index], 
         unity_4LightPosZ0[index], 1.0);
 
        float3 vertexToLightSource = 
         lightPosition.xyz - output.posWorld.xyz;    
        float3 lightDirection = normalize(vertexToLightSource);
        float squaredDistance = 
         dot(vertexToLightSource, vertexToLightSource);
        float attenuation = 1.0 / (1.0 + 
         unity_4LightAtten0[index] * squaredDistance);
        float3 diffuseReflection = attenuation 
         * unity_LightColor[index].rgb * _Color.rgb 
         * max(0.0, dot(output.normalDir, lightDirection));     
 
        output.vertexLighting = 
         output.vertexLighting + diffuseReflection;
      }
      #endif
      return output;
     }
 
     float4 frag(vertexOutput input) : COLOR
     {
      float3 normalDirection = normalize(input.normalDir); 
      float3 viewDirection = normalize(
        _WorldSpaceCameraPos - input.posWorld.xyz);
      float3 lightDirection;
      float attenuation;
 
      if (0.0 == _WorldSpaceLightPos0.w) // directional light?
      {
        attenuation = 1.0; // no attenuation
        lightDirection = 
         normalize(_WorldSpaceLightPos0.xyz);
      } 
      else // point or spot light
      {
        float3 vertexToLightSource = 
         _WorldSpaceLightPos0.xyz - input.posWorld.xyz;
        float distance = length(vertexToLightSource);
        attenuation = 1.0 / distance; // linear attenuation 
        lightDirection = normalize(vertexToLightSource);
      }
 
      float3 ambientLighting = 
        UNITY_LIGHTMODEL_AMBIENT.rgb * _Color.rgb;
 
      float3 diffuseReflection = 
        attenuation * _LightColor0.rgb * _Color.rgb 
        * max(0.0, dot(normalDirection, lightDirection));
 
      float3 specularReflection;
      if (dot(normalDirection, lightDirection) < 0.0) 
        // light source on the wrong side?
      {
        specularReflection = float3(0.0, 0.0, 0.0); 
         // no specular reflection
      }
      else // light source on the right side
      {
        specularReflection = attenuation * _LightColor0.rgb 
         * _SpecColor.rgb * pow(max(0.0, dot(
         reflect(-lightDirection, normalDirection), 
         viewDirection)), _Shininess);
      }
 
      return float4(input.vertexLighting + ambientLighting 
        + diffuseReflection + specularReflection, 1.0);
     }
     ENDCG
   }
 
   Pass {  
     Tags { "LightMode" = "ForwardAdd" } 
      // pass for additional light sources
     Blend One One // additive blending 
 
     CGPROGRAM
 
     #pragma vertex vert 
     #pragma fragment frag 
 
     #include "UnityCG.cginc" 
     uniform float4 _LightColor0; 
      // color of light source (from "Lighting.cginc")
 
     // User-specified properties
     uniform float4 _Color; 
     uniform float4 _SpecColor; 
     uniform float _Shininess;
 
     struct vertexInput {
      float4 vertex : POSITION;
      float3 normal : NORMAL;
     };
     struct vertexOutput {
      float4 pos : SV_POSITION;
      float4 posWorld : TEXCOORD0;
      float3 normalDir : TEXCOORD1;
     };
 
     vertexOutput vert(vertexInput input) 
     {
      vertexOutput output;
 
      float4x4 modelMatrix = unity_ObjectToWorld;
      float4x4 modelMatrixInverse = unity_WorldToObject; 
 
      output.posWorld = mul(modelMatrix, input.vertex);
      output.normalDir = normalize(
        mul(float4(input.normal, 0.0), modelMatrixInverse).xyz);
      output.pos = UnityObjectToClipPos(input.vertex);
      return output;
     }
 
     float4 frag(vertexOutput input) : COLOR
     {
      float3 normalDirection = normalize(input.normalDir);
 
      float3 viewDirection = normalize(
        _WorldSpaceCameraPos.xyz - input.posWorld.xyz);
      float3 lightDirection;
      float attenuation;
 
      if (0.0 == _WorldSpaceLightPos0.w) // directional light?
      {
        attenuation = 1.0; // no attenuation
        lightDirection = 
         normalize(_WorldSpaceLightPos0.xyz);
      } 
      else // point or spot light
      {
        float3 vertexToLightSource = 
         _WorldSpaceLightPos0.xyz - input.posWorld.xyz;
        float distance = length(vertexToLightSource);
        attenuation = 1.0 / distance; // linear attenuation 
        lightDirection = normalize(vertexToLightSource);
      }
 
      float3 diffuseReflection = 
        attenuation * _LightColor0.rgb * _Color.rgb
        * max(0.0, dot(normalDirection, lightDirection));
 
      float3 specularReflection;
      if (dot(normalDirection, lightDirection) < 0.0) 
        // light source on the wrong side?
      {
        specularReflection = float3(0.0, 0.0, 0.0); 
         // no specular reflection
      }
      else // light source on the right side
      {
        specularReflection = attenuation * _LightColor0.rgb 
         * _SpecColor.rgb * pow(max(0.0, dot(
         reflect(-lightDirection, normalDirection), 
         viewDirection)), _Shininess);
      }
 
      return float4(diffuseReflection 
        + specularReflection, 1.0);
        // no ambient lighting in this pass
     }
 
     ENDCG
   }
 
  } 
  Fallback "Specular"
}

The use of #pragma multi_compile_fwdbase and #ifdef VERTEXLIGHT_ON ... #endif is necessary to make sure that no vertex lighting is computed when Unity doesn't provide the data; see also Unity's documentation of multi_compile directives.

Summary

[edit | edit source]

Congratulations, you have reached the end of this tutorial. We have seen:

  • How Unity's vertex lights are specified.
  • How a for-loop can be used in Cg to compute the lighting of multiple lights in one pass.

Further reading

[edit | edit source]

If you still want to know more

< Cg Programming/Unity

Unless stated otherwise, all example source code on this page is granted to the public domain.