【Unity Shaders】初探Surface Shader背后的机制

转载请注明出处：http://blog.csdn.net/candycat1992/article/details/39994049

写在前面

一直以来，Unity Surface Shader背后的机制一直是初学者为之困惑的地方。Unity Surface Shader在Unity 3.0的时候被开放给公众使用，其宣传手段也是号称让所有人都可以轻松地写shader。但由于资料缺乏，很多人知其然不知其所以然，无法理解Unity Surface Shader在背后为我们做了哪些事情。

前几天一直被问到一个问题，为什么我的场景里没有灯光，但物体不是全黑的呢？为什么我把Light的颜色调成黑色，物体还是有一些默认颜色呢？这些问题其实都是因为那些物体使用了Surface Shader的缘故。因此，了解Surface Shader背后的机制是非常重要滴~

虽然Surface Shader一直是一个神秘的存在，但其实Unity给了我们揭开她面纱的方式：查看它生成的CG代码。大家应该都知道，所谓的Surface Shader实际上是封装了CG语言，隐藏了很多光照处理的细节，它的设计初衷是为了让用户仅仅使用一些指令（#pragma）就可以完成很多事情，并且封装了很多常用的光照模型和函数，例如Lambert、Blinn-Phong等。而查看Surface Shader生成的代码也很简单：在每个编译完成的Surface Shader的面板上，都有个“Show generated code”的按钮，像下面这样：

点开后，就可以查看啦~面板上还表明了很多其他的有用信息。而这些方便的功能实际上是Unity 4.5发布出来的。详情可见这篇博文。

使用Surface Shader，很多时候，我们只需要告诉shader，“嘿，使用这些纹理去填充颜色，法线贴图去填充法线，使用Lambert光照模型，其他的不要来烦我！！！”我们不需要考虑是使用forward还是deferred rendering，有多少光源类型、怎样处理这些类型，每个pass需要处理多少个光源！！！（人们总会rant写一个shader是多么的麻烦。。。）So！Unity说，不要急，放着我来~

上面的情景当然对于小白是比较简单的方式，Surface Shader可以让初学者快速实现很多常见的shader，例如漫反射、高光反射、法线贴图等，这些常见的效果也都不错。而对应面就是，由于隐藏了很多细节，如果想要自定义一些比较复杂或特殊的效果，使用Surface Shader就无法达到了（或者非常麻烦）。在学了一段时间的Surface Shader后，我认为：

• 如果你从来没有学习过怎样编写shader，而又想写一些常见的、比较简单的shader，那仅学习Surface Shader是一个不错的选择。
  
  
• 如果你向往那些高品质的游戏画面，那么Surface Shader是远远无法满足你的，而且某种方面来说它会让你变得越来越困惑。

困惑了怎么办呢？老老实实去学习主流的渲染语言吧~比如CG、GLSL、HLSL等。等学了一些上述内容后，再回过头来看Surface Shader就会别有一番理解了。

说教了这么多，本篇的主旨其实是分析下Surface Shader背后做的事情啦！也就是，分析Surface Shader到底是怎样解析我们编写的那些surf、LightingXXX等函数的，又是如何得到像素颜色的。那么，开始吧！

流水线

首先，我们要明白Surface Shader支持哪些特性。详情请见官网。

Surface Shader最重要的部分是两个结构体以及它的编译指令。

两个结构体

两个结构体就是指 struct Input 和 SurfaceOutput 。其中 Input 结构体是允许我们自定义的。它可以包含一些纹理坐标和其他提前定义的变量，例如view direction（float3 viewDir）、world space position（worldPos）、world space reflection vector（float3 worldRefl）等。这些变量只有在真正使用的时候才会被计算生成。比如，在某些Pass里生成而某些就生成。

另一个结构体是SurfaceOutput。我们无法自定义这个结构体内的变量。关于它最难理解的也就是每个变量的具体含义以及工作机制（对像素颜色的影响）。我们来看一下它的定义（在Lighting.cginc里面）：

[cpp]  view plain copy print ?

1. struct SurfaceOutput {  
2.     half3 Albedo;  
3.     half3 Normal;  
4.     half3 Emission;  
5.     half Specular;  
6.     half Gloss;  
7.     half Alpha;  
8. };  

• Albedo：我们通常理解的对光源的反射率。它是通过在Fragment Shader中计算颜色叠加时，和一些变量（如vertex lights）相乘后，叠加到最后的颜色上的。
  
  
• Normal：即其对应的法线方向。只要是受法线影响的计算都会受到影响。
  
  
• Emission：自发光。会在Fragment 最后输出前（调用final函数前，如果定义了的话），使用下面的语句进行简单的颜色叠加：
  
  [cpp]  view plain copy print ?

  1. c.rgb += o.Emission;  
  
  
• Specular：高光反射中的指数部分的系数。影响一些高光反射的计算。按目前的理解，也就是在光照模型里会使用到（如果你没有在光照函数等函数——包括Unity内置的光照函数，中使用它，这个变量就算设置了也没用）。有时候，你只在surf函数里设置了它，但也会影响最后的结果。这是因为，你可能使用了Unity内置的光照模型，如BlinnPhong，它会使用如下语句计算高光反射的强度（在Lighting.cginc里）：
  
  [cpp]  view plain copy print ?

  1. float spec = pow (nh, s.Specular*128.0) * s.Gloss;  
  
  
• Gloss：高光反射中的强度系数。和上面的Specular类似，一般在光照模型里使用。
  
  
• Alpha：通常理解的透明通道。在Fragment Shader中会直接使用下列方式赋值（如果开启了透明通道的话）：
  
  [cpp]  view plain copy print ?

  1. c.a = o.Alpha;  
  
  

上述结论是分析生成的代码所得，若有不对欢迎指出。大家碰到不懂的，也可以像这样分析生成的代码，一般问题都可以理解啦~

编译指令

编译指令的一般格式如下：

[cpp]  view plain copy print ?

1. #pragma surface surfaceFunction lightModel [optionalparams]  

Surface Shader和CG其他部分一样，代码也是要写在CGPROGRAM和ENDCG之间。但区别是，它必须写在SubShader内部，而不能写在Pass内部。Surface Shader自己会自动生成所需的各个Pass。由上面的编译格式可以看出，surfaceFunction和lightModel是必须指定的，而且是可选部分。

surfaceFunction通常就是名为surf的函数（函数名可以任意），它的函数格式是固定的：

[cpp]  view plain copy print ?

1. void surf (Input IN, inout SurfaceOutput o)  

即Input是输入，SurfaceOutput是输出。

lightModel也是必须指定的。由于Unity内置了一些光照函数——Lambert（diffuse）和Blinn-Phong（specular），因此这里在默认情况下会使用内置的Lambert模型。当然我们也可以自定义。

optionalparams包含了很多可用的指令类型，包括开启、关闭一些状态，设置生成的Pass类型，指定可选函数等。这里，我们只关注可指定的函数，其他可去官网自行查看。除了上述的surfaceFuntion和lightModel，我们还可以自定义两种函数：vertex:VertexFunction和finalcolor:ColorFunction。也就是说，Surface Shader允许我们自定义四种函数。

两个结构体+四个函数——它们在整个的render pipeline中的流程如下：

从上图可以看出来，Surface Shader背后的”那些女人“就是vertex shader和fragment shader。除了VertexFunction外，另外两个结构体和三个函数都是在fragment shader中扮演了一些角色。Surface Shader首先根据我们的代码生成了很多Pass，用于forwardbase和forwardadd等，这不在本篇的讨论范围。而每个Pass的代码是基于上述四个函数生成的。

以一个Pass的代码为例，Surface Shader的生成过程简述如下：

1. 直接将CGPROGRAM和ENDCG之间的代码复制过来（其实还是更改了一些编译指令），这些代码包括了我们对Input、surfaceFuntion、LightingXXX等变量和函数的定义。这些函数和变量会在之后的处理过程中当成普通的结构体和函数进行调用，就和在C++中我们会在main函数中调用某些函数一样；
   
   
2. 分析上述代码，生成v2f_surf结构，用于在Vertex Shader和Fragment Shader之间进行数据传递。Unity会分析我们在四个自定义函数中所使用的变量，例如纹理坐标等。如果需要，它会在v2f_surf中生成相应的变量。而且，即便有时我们在Input中定义了某些变量（如某些纹理坐标），但Unity在分析后续代码时发现我们并没有使用这些变量，那么这些变量实际上是不会在v2f_surf中生成的。这也就是说，Unity做了一些优化动作。
   
   
3. 生成Vertex Shader。
   * 如果我们自定义了VertexFunction，Unity会在这里首先调用VertexFunction修改顶点数据；然后分析VertexFunction修改的数据，最后通过Input结构体将修改结果存储到v2f_surf中。
   * 计算v2f_surf中其他默认的变量值。这主要包括了pos、纹理坐标、normal（如果没有使用LightMap）、vlight（如果没有使用LightMap）、lmap（如果使用LightMap）等。
   * 最后，通过内置的TRANSFER_VERTEX_TO_FRAGMENT指令将v2f_surf传递给下面的Fragment Shader。
   
   
4. 生成Fragment Shader。
   * 使用v2f_surf中的对应变量填充Input结构，例如一些纹理坐标等。
   * 调用surfFuntion填充SurfaceOutput结构。
   * 调用LightingXXX函数得到初始的颜色值。
   * 进行其他的颜色叠加。如果没有启用LightMap，这里会使用SurfaceOutput.Albedo和v2f_surf.vlight的乘积和原颜色值进行叠加；否则会进行一些更复杂的颜色叠加。
   * 最后，如果自定了final函数，则调用它进行最后额颜色修改。
   
   

代码分析

我们以一个Surface Shader为例，分析它生成的代码。

Surface Shader如下：

[cpp]  view plain copy print ?

1. Shader "Custom/BasicDiffuse" {  
2.     Properties {  
3.         _EmissiveColor ("Emissive Color", Color) = (1,1,1,1)  
4.         _AmbientColor  ("Ambient Color", Color) = (1,1,1,1)  
5.         _MySliderValue ("This is a Slider", Range(0,10)) = 2.5  
6.         _RampTex ("Ramp Texture", 2D) = "white"{}  
7.     }  
8.     SubShader {  
9.         Tags { "RenderType"="Opaque" "RenderType"="Opaque" }  
10.           
11.         LOD 200  
12.           
13.         CGPROGRAM  
14.         #pragma surface surf BasicDiffuse vertex:vert finalcolor:final noforwardadd   
15.         #pragma debug  
16.           
17.         float4 _EmissiveColor;  
18.         float4 _AmbientColor;  
19.         float _MySliderValue;  
20.         sampler2D _RampTex;  
21.           
22.         struct Input  
23.         {  
24.             float2 uv_RampTex;  
25.             float4 vertColor;   
26.         };  
27.           
28.         void vert(inout appdata_full v, out Input o)    
29.         {    
30.             o.vertColor = v.color;    
31.         }  
32.           
33.         void surf (Input IN, inout SurfaceOutput o)  
34.         {  
35.             float4 c;  
36.             c =  pow((_EmissiveColor + _AmbientColor), _MySliderValue);  
37.             o.Albedo = c.rgb + tex2D(_RampTex, IN.uv_RampTex).rgb;  
38.             o.Alpha = c.a;  
39.         }  
40.           
41.         inline float4 LightingBasicDiffuse (SurfaceOutput s, fixed3 lightDir, fixed atten)  
42.         {         
43.             float difLight = max(0, dot (s.Normal, lightDir));  
44.             float hLambert = difLight * 0.5 + 0.5;  
45.             float3 ramp = tex2D(_RampTex, float2(hLambert)).rgb;  
46.               
47.             float4 col;  
48.             col.rgb = s.Albedo * _LightColor0.rgb * (ramp) * atten;  
49.             col.a = s.Alpha;  
50.             return col;  
51.         }  
52.           
53.         void final(Input IN, SurfaceOutput o, inout fixed4 color) {    
54.             color = color * 0.5 + 0.5;   
55.         }   
56.           
57.         ENDCG  
58.     }   
59.     FallBack "Diffuse"  
60. }  

它包含了全部四个函数，以及一些比较常见的运算。为了只关注一个Pass，我添加了 noforwardadd指令。它所得到的渲染结果不重要（事实上我只是在BasicDiffuse上瞎改了一些。。。）

我们点开查看它生成的代码：

[cpp]  view plain copy print ?

1. Shader "Custom/BasicDiffuse_Gen" {  
2.     Properties {  
3.         _EmissiveColor ("Emissive Color", Color) = (1,1,1,1)  
4.         _AmbientColor  ("Ambient Color", Color) = (1,1,1,1)  
5.         _MySliderValue ("This is a Slider", Range(0,10)) = 2.5  
6.         _RampTex ("Ramp Texture", 2D) = "white"{}  
7.     }  
8.     SubShader {  
9.         Tags { "RenderType"="Opaque" "RenderType"="Opaque" }  
10.           
11.         LOD 200  
12.           
13.           
14.     // ------------------------------------------------------------  
15.     // Surface shader code generated out of a CGPROGRAM block:  
16.       
17.   
18.     // ---- forward rendering base pass:  
19.     Pass {  
20.         Name "FORWARD"  
21.         Tags { "LightMode" = "ForwardBase" }  
22.   
23. CGPROGRAM  
24. // compile directives  
25. #pragma vertex vert_surf  
26. #pragma fragment frag_surf  
27. #pragma multi_compile_fwdbase nodirlightmap  
28. #include "HLSLSupport.cginc"  
29. #include "UnityShaderVariables.cginc"  
30. #define UNITY_PASS_FORWARDBASE  
31. #include "UnityCG.cginc"  
32. #include "Lighting.cginc"  
33. #include "AutoLight.cginc"  
34.   
35. #define INTERNAL_DATA  
36. #define WorldReflectionVector(data,normal) data.worldRefl  
37. #define WorldNormalVector(data,normal) normal  
38.   
39. // Original surface shader snippet:  
40. #line 11 ""  
41. #ifdef DUMMY_PREPROCESSOR_TO_WORK_AROUND_HLSL_COMPILER_LINE_HANDLING  
42. #endif  
43.   
44.         //#pragma surface surf BasicDiffuse vertex:vert finalcolor:final noforwardadd  
45.         #pragma debug  
46.           
47.         float4 _EmissiveColor;  
48.         float4 _AmbientColor;  
49.         float _MySliderValue;  
50.         sampler2D _RampTex;  
51.           
52.         struct Input  
53.         {  
54.             float2 uv_RampTex;  
55.             float4 vertColor;   
56.         };  
57.           
58.         void vert(inout appdata_full v, out Input o)    
59.         {    
60.             o.vertColor = v.color;    
61.         }  
62.           
63.         void surf (Input IN, inout SurfaceOutput o)  
64.         {  
65.             float4 c;  
66.             c =  pow((_EmissiveColor + _AmbientColor), _MySliderValue);  
67.             o.Albedo = c.rgb + tex2D(_RampTex, IN.uv_RampTex).rgb;  
68.             o.Alpha = c.a;  
69.         }  
70.           
71.         inline float4 LightingBasicDiffuse (SurfaceOutput s, fixed3 lightDir, fixed atten)  
72.         {  
73.             float difLight = max(0, dot (s.Normal, lightDir));  
74.             float hLambert = difLight * 0.5 + 0.5;  
75.             float3 ramp = tex2D(_RampTex, float2(hLambert)).rgb;  
76.               
77.             float4 col;  
78.             col.rgb = s.Albedo * _LightColor0.rgb * (ramp);  
79.             col.a = s.Alpha;  
80.             return col;  
81.         }  
82.           
83.         void final(Input IN, SurfaceOutput o, inout fixed4 color) {    
84.             color = color * 0.5 + 0.5;   
85.         }   
86.           
87.           
88.   
89. // vertex-to-fragment interpolation data  
90. #ifdef LIGHTMAP_OFF  
91. struct v2f_surf {  
92.   float4 pos : SV_POSITION;  
93.   float2 pack0 : TEXCOORD0;  
94.   float4 cust_vertColor : TEXCOORD1;  
95.   fixed3 normal : TEXCOORD2;  
96.   fixed3 vlight : TEXCOORD3;  
97.   // LIGHTING_COORDS在AutoLight.cginc里定义  
98.   // 本质上就是一个#define指令  
99.   //  e.g.   
100.   // #define LIGHTING_COORDS(idx1,idx2) float3 _LightCoord : TEXCOORD##idx1; SHADOW_COORDS(idx2)  
101.   // #define SHADOW_COORDS(idx1) float3 _ShadowCoord : TEXCOORD##idx1;  
102.   LIGHTING_COORDS(4,5)  
103. };  
104. #endif  
105. #ifndef LIGHTMAP_OFF  
106. struct v2f_surf {  
107.   float4 pos : SV_POSITION;  
108.   float2 pack0 : TEXCOORD0;  
109.   float4 cust_vertColor : TEXCOORD1;  
110.   float2 lmap : TEXCOORD2;  
111.   LIGHTING_COORDS(3,4)  
112. };  
113. #endif  
114. #ifndef LIGHTMAP_OFF  
115. float4 unity_LightmapST;  
116. #endif  
117. //  定义所需的纹理坐标  
118. float4 _RampTex_ST;  
119.   
120. // vertex shader  
121. v2f_surf vert_surf (appdata_full v) {  
122.   v2f_surf o;  
123.     
124.   //  使用自定义的vert函数填充Input结构  
125.   Input customInputData;  
126.   vert (v, customInputData);  
127.     
128.   //  再赋值给真正所需的v2f_surf结构  
129.   o.cust_vertColor = customInputData.vertColor;  
130.   o.pos = mul (UNITY_MATRIX_MVP, v.vertex);  
131.   //  将顶点的纹理坐标转换到纹理对应坐标  
132.   o.pack0.xy = TRANSFORM_TEX(v.texcoord, _RampTex);  
133.     
134.   #ifndef LIGHTMAP_OFF  
135.   //  如果启用了LightMap，则计算对应的LightMap坐标  
136.   o.lmap.xy = v.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;  
137.   #endif  
138.     
139.   //  计算世界坐标系中法线的方向  
140.   //  SCALED_NORMAL在UnityCG.cginc里定义  
141.   // 本质上就是一个#define指令  
142.   // #define SCALED_NORMAL (v.normal * unity_Scale.w)  
143.   float3 worldN = mul((float3x3)_Object2World, SCALED_NORMAL);  
144.     
145.   //  如果没有开启LightMap，  
146.   // 顶点法线方向就是worldN  
147.   #ifdef LIGHTMAP_OFF  
148.   o.normal = worldN;  
149.   #endif  
150.   
151.   // SH/ambient and vertex lights  
152.   #ifdef LIGHTMAP_OFF  
153.     //  如果没有开启LightMap，  
154.     //  vertex lights就是球面调和函数的结果  
155.     //  球面调和函数ShadeSH9在UnityCG.cginc里定义  
156.     float3 shlight = ShadeSH9 (float4(worldN,1.0));  
157.     o.vlight = shlight;  
158.       
159.     // unity_4LightPosX0等变量在UnityShaderVariables.cginc里定义  
160.     #ifdef VERTEXLIGHT_ON  
161.     float3 worldPos = mul(_Object2World, v.vertex).xyz;  
162.     o.vlight += Shade4PointLights (  
163.       unity_4LightPosX0, unity_4LightPosY0, unity_4LightPosZ0,  
164.       unity_LightColor[0].rgb, unity_LightColor[1].rgb, unity_LightColor[2].rgb, unity_LightColor[3].rgb,  
165.       unity_4LightAtten0, worldPos, worldN );  
166.     #endif // VERTEXLIGHT_ON  
167.   #endif // LIGHTMAP_OFF  
168.   
169.   // pass lighting information to pixel shader  
170.   // TRANSFER_VERTEX_TO_FRAGMENT在AutoLight.cginc里定义，  
171.   // 本质上就是一个#define指令  
172.   // 用于转换v2f_surf中的_LightCoord和_ShadowCoord  
173.   TRANSFER_VERTEX_TO_FRAGMENT(o);  
174.   return o;  
175. }  
176. #ifndef LIGHTMAP_OFF  
177. sampler2D unity_Lightmap;  
178. #ifndef DIRLIGHTMAP_OFF  
179. sampler2D unity_LightmapInd;  
180. #endif  
181. #endif  
182.   
183. // fragment shader  
184. fixed4 frag_surf (v2f_surf IN) : SV_Target {  
185.   // prepare and unpack data  
186.   #ifdef UNITY_COMPILER_HLSL  
187.   Input surfIN = (Input)0;  
188.   #else  
189.   Input surfIN;  
190.   #endif  
191.     
192.   //  使用v2f_surf中的变量给Input中的纹理坐标进行赋值  
193.   surfIN.uv_RampTex = IN.pack0.xy;  
194.   surfIN.vertColor = IN.cust_vertColor;  
195.     
196.   #ifdef UNITY_COMPILER_HLSL  
197.   SurfaceOutput o = (SurfaceOutput)0;  
198.   #else  
199.   SurfaceOutput o;  
200.   #endif  
201.   // 初始化SurfaceOutput结构  
202.   o.Albedo = 0.0;  
203.   o.Emission = 0.0;  
204.   o.Specular = 0.0;  
205.   o.Alpha = 0.0;  
206.   o.Gloss = 0.0;  
207.   #ifdef LIGHTMAP_OFF  
208.   o.Normal = IN.normal;  
209.   #endif  
210.   
211.   // call surface function  
212.   //  调用自定义的surf函数填充SurfaceOutput结构  
213.   surf (surfIN, o);  
214.   
215.   // compute lighting & shadowing factor  
216.   // LIGHT_ATTENUATION在AutoLight.cginc里定义，  
217.   // 本质上就是一个#define指令  
218.   // 用于计算光衰减  
219.   fixed atten = LIGHT_ATTENUATION(IN);  
220.   fixed4 c = 0;  
221.   
222.   // realtime lighting: call lighting function  
223.   #ifdef LIGHTMAP_OFF  
224.   // 如果没有开启LightMap,  
225.   // 调用自定义的LightXXX函数，  
226.   // 使用填充好的SurfaceOutput等变量作为参数，  
227.   // 得到初始的像素值  
228.   c = LightingBasicDiffuse (o, _WorldSpaceLightPos0.xyz, atten);  
229.   #endif // LIGHTMAP_OFF || DIRLIGHTMAP_OFF  
230.     
231.   #ifdef LIGHTMAP_OFF  
232.   // 如果没有开启LightMap,  
233.   // 向像素叠加vertex light的光照颜色  
234.   c.rgb += o.Albedo * IN.vlight;  
235.   #endif // LIGHTMAP_OFF  
236.   
237.   // lightmaps:  
238.   #ifndef LIGHTMAP_OFF  
239.     // 计算LightMap，这部分不懂  
240.     #ifndef DIRLIGHTMAP_OFF  
241.       // directional lightmaps  
242.       fixed4 lmtex = tex2D(unity_Lightmap, IN.lmap.xy);  
243.       fixed4 lmIndTex = tex2D(unity_LightmapInd, IN.lmap.xy);  
244.       half3 lm = LightingLambert_DirLightmap(o, lmtex, lmIndTex, 0).rgb;  
245.     #else // !DIRLIGHTMAP_OFF  
246.       // single lightmap  
247.       fixed4 lmtex = tex2D(unity_Lightmap, IN.lmap.xy);  
248.       fixed3 lm = DecodeLightmap (lmtex);  
249.     #endif // !DIRLIGHTMAP_OFF  
250.   
251.     // combine lightmaps with realtime shadows  
252.     #ifdef SHADOWS_SCREEN  
253.       #if (defined(SHADER_API_GLES) || defined(SHADER_API_GLES3)) && defined(SHADER_API_MOBILE)  
254.       c.rgb += o.Albedo * min(lm, atten*2);  
255.       #else  
256.       c.rgb += o.Albedo * max(min(lm,(atten*2)*lmtex.rgb), lm*atten);  
257.       #endif  
258.     #else // SHADOWS_SCREEN  
259.       c.rgb += o.Albedo * lm;  
260.     #endif // SHADOWS_SCREEN  
261.       
262.   // 给Alpha通道赋值    
263.   c.a = o.Alpha;  
264.   #endif // LIGHTMAP_OFF  
265.   
266.   // 调用自定义的final函数，  
267.   // 对像素值进行最后的更改  
268.   final (surfIN, o, c);  
269.   return c;  
270. }  
271.   
272. ENDCG  
273.   
274. }  
275.   
276.     // ---- end of surface shader generated code  
277.   
278. #LINE 57  
279.   
280.     }   
281.     FallBack "Diffuse"  
282. }  

其中比较重要的部分我都写了注释。

一些问题

回到我们一开始的那个问题：为什么我的场景里没有灯光，但物体不是全黑的呢？这一切都是Fragment Shader中一些颜色叠加计算的结果。

我们仔细观察Fragment Shader中计算颜色的部分。前面说过，它使用LightingXXX对颜色值进行初始化，但后面还进行了一系列颜色叠加计算。其中，在没有使用LightMap的情况下，Unity还计算了vertex lights对颜色的影响，也就是下面这句话：

[cpp]  view plain copy print ?

1. #ifdef LIGHTMAP_OFF  
2. // 如果没有开启LightMap,  
3. // 向像素叠加vertex light的光照颜色  
4. c.rgb += o.Albedo * IN.vlight;  
5. #endif // LIGHTMAP_OFF  

而IN.vlight是在Vertex Shader中计算的：

[cpp]  view plain copy print ?

1. //  如果没有开启LightMap，  
2. //  vertex lights就是球面调和函数的结果  
3. //  球面调和函数ShadeSH9在UnityCG.cginc里定义  
4. float3 shlight = ShadeSH9 (float4(worldN,1.0));  
5. o.vlight = shlight;  

我们可以去查看ShadeSH9函数的实现：

[cpp]  view plain copy print ?

1. // normal should be normalized, w=1.0  
2. half3 ShadeSH9 (half4 normal)  
3. {  
4.     half3 x1, x2, x3;  
5.       
6.     // Linear + constant polynomial terms  
7.     x1.r = dot(unity_SHAr,normal);  
8.     x1.g = dot(unity_SHAg,normal);  
9.     x1.b = dot(unity_SHAb,normal);  
10.       
11.     // 4 of the quadratic polynomials  
12.     half4 vB = normal.xyzz * normal.yzzx;  
13.     x2.r = dot(unity_SHBr,vB);  
14.     x2.g = dot(unity_SHBg,vB);  
15.     x2.b = dot(unity_SHBb,vB);  
16.       
17.     // Final quadratic polynomial  
18.     float vC = normal.x*normal.x - normal.y*normal.y;  
19.     x3 = unity_SHC.rgb * vC;  
20.     return x1 + x2 + x3;  
21. }   

它是一个球面调和函数，但unity_SHAr这些变量具体是什么我还不清楚。。。如果有人知道麻烦告诉我一下，不胜感激~但是，这些变量是和 Unity使用了一个全局环境光（你可以在Edit->RenderSettings->Ambient Light中调整）有关。如果把这个环境光也调成黑色，那么场景就真的全黑了。

呼呼呼，关于这些光源计算的部分就是一开始所说的那些让写shader变得很复杂的原因之一！如果你真的去看那些在UnityCG.cginc、AutoLight.cginc等文件里的关于指令的定义，可以发现Unity是根据定义的光照类型来处理不同的光照的。这部分还没有搞明白，后面会继续探究一下的！

上述内容纯属研究所得，如有错误欢迎指正~