碼上歡樂
相關內容    簡體    繁體

Unity Shader （三）Surface Shader機制

本文轉載自   查看原文   2018-03-07 11:10   4124    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
 
  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
     
    1. c.rgb += o.Emission;  
  • Specular：高光反射中的指數部分的系數。影響一些高光反射的計算。按目前的理解，也就是在光照模型里會使用到（如果你沒有在光照函數等函數——包括Unity內置的光照函數，中使用它，這個變量就算設置了也沒用）。有時候，你只在surf函數里設置了它，但也會影響最后的結果。這是因為，你可能使用了Unity內置的光照模型，如BlinnPhong，它會使用如下語句計算高光反射的強度（在Lighting.cginc里）：
    [cpp]  view plain  copy
     
    1. float spec = pow (nh, s.Specular*128.0) * s.Gloss;  
  • Gloss：高光反射中的強度系數。和上面的Specular類似，一般在光照模型里使用。

  • Alpha：通常理解的透明通道。在Fragment Shader中會直接使用下列方式賦值（如果開啟了透明通道的話）：
    [cpp]  view plain  copy
     
    1. c.a = o.Alpha;  
上述結論是分析生成的代碼所得，若有不對歡迎指出。大家碰到不懂的，也可以像這樣分析生成的代碼，一般問題都可以理解啦~
 

編譯指令

 
 
編譯指令的一般格式如下：
[cpp]  view plain  copy
 
  1. #pragma surface surfaceFunction lightModel [optionalparams]  

Surface Shader和CG其他部分一樣，代碼也是要寫在CGPROGRAM和ENDCG之間。但區別是，它必須寫在SubShader內部，而不能寫在Pass內部。Surface Shader自己會自動生成所需的各個Pass。由上面的編譯格式可以看出，surfaceFunction和lightModel是必須指定的，而且是可選部分。
 
surfaceFunction通常就是名為surf的函數（函數名可以任意），它的函數格式是固定的：
[cpp]  view plain  copy
 
  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
 
  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
 
  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
 
  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
 
  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
 
  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中調整）有關。如果把這個環境光也調成黑色，那么場景就真的全黑了。

 


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Unity Shader——Writing Surface Shaders(0) Unity Shader——Writing Surface Shaders(1)——Surface Shader Examples Surface Shader 【Unity Shader】Shader基礎 Shader編程學習筆記（七）—— Surface Shader 1 Shader編程學習筆記（八）—— Surface Shader 2 什么是shader? Unity shader學習之標准的Unity shader Unity Shader （二）Cg語言 Unity光波擴散Shader
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM