GLSL 编程/Unity/轮廓处的镜面高光

本教程涵盖了镜面高光的菲涅尔系数。

它是关于光照的多个教程之一，这些教程超越了 Phong 反射模型。但是，它基于使用 Phong 反射模型进行的光照，如“镜面高光”部分（针对每个顶点的光照）和“平滑镜面高光”部分（针对每个像素的光照）中所述。如果您还没有阅读这些教程，建议您先阅读。

许多材料（如哑光纸）在光线掠过表面时会显示出强烈的镜面反射；即，当背光从与观察者相反的方向反射时，如左侧的照片所示。菲涅尔系数解释了一些材料的这种强反射。当然，轮廓明亮还有其他原因，例如半透明的头发或织物（见“半透明表面”部分）。

有趣的是，这种效果通常很难察觉，因为它最有可能发生在轮廓背景非常明亮的情况下。但是，在这种情况下，明亮的轮廓将与背景融合，因此几乎无法察觉。

菲涅尔系数的 Schlick 近似

菲涅尔系数 $F_{\lambda }$ 描述了非导电材料对波长为 $\lambda$ 的非偏振光的镜面反射率。Schlick 近似为

$F_{\lambda }=f_{\lambda }+(1-f_{\lambda })(1-\mathbf {H} \cdot \mathbf {V} )^{5}$

其中 V 是归一化的观察者方向，H 是归一化的半程向量：H = (V + L) / |V + L|，其中 L 是归一化的光源方向。 $f_{\lambda }$ 是 H·V = 1 时的反射率，即当光源方向、观察者方向和半程向量都相同时。另一方面， $F_{\lambda }$ 在 H·V = 0 时变为 1，即当半程向量与观察者方向正交时，这意味着光源方向与观察者方向相反（即掠入射光反射的情况）。事实上， $F_{\lambda }$ 在这种情况下与波长无关，材料的行为就像一个完美的镜子。

使用内置的 GLSL 函数 mix(x,y,w) = x*(1-w) + y*w，我们可以将 Schlick 近似改写为

$F_{\lambda }=f_{\lambda }+(1-f_{\lambda })(1-\mathbf {H} \cdot \mathbf {V} )^{5}$ $=f_{\lambda }\left(1-(1-\mathbf {H} \cdot \mathbf {V} )^{5}\right)+(1-\mathbf {H} \cdot \mathbf {V} )^{5}$ $={\text{mix}}\left(f_{\lambda },1,(1-\mathbf {H} \cdot \mathbf {V} )^{5}\right)$

这可能稍微更有效，至少在某些 GPU 上是如此。我们将通过允许不同的 $f_{\lambda }$ 值来考虑对波长的依赖性，每个颜色分量；也就是说，我们将它视为一个 RGB 向量。事实上，我们将它与来自 “镜面高光”部分的常数材质颜色 $k_{\text{specular}}$ 相一致。换句话说，菲涅尔因子增加了材质颜色 $k_{\text{specular}}$ 对观察者方向和半程向量之间角度的依赖性。因此，我们在任何镜面反射计算中用施里克近似值（使用 $f_{\lambda }=k_{\text{specular}}$ ）替换了常数材质颜色 $k_{\text{specular}}$ 。

例如，我们在 Phong 反射模型中对镜面项的方程式是（参见 “镜面高光”部分）

$I_{\text{specular}}=I_{\text{incoming}}\,k_{\text{specular}}\max(0,\mathbf {R} \cdot \mathbf {V} )^{n_{\text{shininess}}}$

用 Schlick 近似值来替换菲涅尔因子中的 $k_{\text{specular}}$ ，其中 $f_{\lambda }=k_{\text{specular}}$ ，得到

$I_{\text{specular}}=I_{\text{incoming}}\,{\text{mix}}\left(k_{\text{specular}},1,(1-\mathbf {H} \cdot \mathbf {V} )^{5}\right)\max(0,\mathbf {R} \cdot \mathbf {V} )^{n_{\text{shininess}}}$

实现

该实现基于来自“平滑镜面高光”部分的着色器代码。它只是计算了半程向量，并包含了菲涅耳因子的近似值

            vec3 specularReflection;
            if (dot(normalDirection, lightDirection) < 0.0) 
               // light source on the wrong side?
            {
               specularReflection = vec3(0.0, 0.0, 0.0); 
                  // no specular reflection
            }
            else // light source on the right side
            {
               vec3 halfwayDirection = 
                  normalize(lightDirection + viewDirection);
               float w = pow(1.0 - max(0.0, 
                  dot(halfwayDirection, viewDirection)), 5.0);
               specularReflection = attenuation * vec3(_LightColor0) 
                  * mix(vec3(_SpecColor), vec3(1.0), w)
                  * pow(max(0.0, dot(
                  reflect(-lightDirection, normalDirection), 
                  viewDirection)), _Shininess);
            }

完整着色器代码

将上面的代码片段放入来自“平滑镜面高光”部分的完整着色器中，会得到这个着色器

Shader "GLSL Fresnel highlights" {
   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 ambient light and first light source

         GLSLPROGRAM

         // User-specified properties
         uniform vec4 _Color; 
         uniform vec4 _SpecColor; 
         uniform float _Shininess;

         // The following built-in uniforms (except _LightColor0) 
         // are also defined in "UnityCG.glslinc", 
         // i.e. one could #include "UnityCG.glslinc" 
         uniform vec3 _WorldSpaceCameraPos; 
            // camera position in world space
         uniform mat4 _Object2World; // model matrix
         uniform mat4 _World2Object; // inverse model matrix
         uniform vec4 _WorldSpaceLightPos0; 
            // direction to or position of light source
         uniform vec4 _LightColor0; 
            // color of light source (from "Lighting.cginc")
         
         varying vec4 position; 
            // position of the vertex (and fragment) in world space 
         varying vec3 varyingNormalDirection; 
            // surface normal vector in world space

         #ifdef VERTEX
         
         void main()
         {				
            mat4 modelMatrix = _Object2World;
            mat4 modelMatrixInverse = _World2Object; // unity_Scale.w 
               // is unnecessary because we normalize vectors
            
            position = modelMatrix * gl_Vertex;
            varyingNormalDirection = normalize(vec3(
               vec4(gl_Normal, 0.0) * modelMatrixInverse));

            gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
         }
         
         #endif

         #ifdef FRAGMENT
         
         void main()
         {
            vec3 normalDirection = normalize(varyingNormalDirection);

            vec3 viewDirection = 
               normalize(_WorldSpaceCameraPos - vec3(position));
            vec3 lightDirection;
            float attenuation;

            if (0.0 == _WorldSpaceLightPos0.w) // directional light?
            {
               attenuation = 1.0; // no attenuation
               lightDirection = normalize(vec3(_WorldSpaceLightPos0));
            } 
            else // point or spot light
            {
               vec3 vertexToLightSource = 
                  vec3(_WorldSpaceLightPos0 - position);
               float distance = length(vertexToLightSource);
               attenuation = 1.0 / distance; // linear attenuation 
               lightDirection = normalize(vertexToLightSource);
            }
            
            vec3 ambientLighting = 
               vec3(gl_LightModel.ambient) * vec3(_Color);

            vec3 diffuseReflection = 
               attenuation * vec3(_LightColor0) * vec3(_Color) 
               * max(0.0, dot(normalDirection, lightDirection));
            
            vec3 specularReflection;
            if (dot(normalDirection, lightDirection) < 0.0) 
               // light source on the wrong side?
            {
               specularReflection = vec3(0.0, 0.0, 0.0); 
                  // no specular reflection
            }
            else // light source on the right side
            {
               vec3 halfwayDirection = 
                  normalize(lightDirection + viewDirection);
               float w = pow(1.0 - max(0.0, 
                  dot(halfwayDirection, viewDirection)), 5.0);
               specularReflection = attenuation * vec3(_LightColor0) 
                  * mix(vec3(_SpecColor), vec3(1.0), w) 
                  * pow(max(0.0, dot(
                  reflect(-lightDirection, normalDirection), 
                  viewDirection)), _Shininess);
            }

            gl_FragColor = vec4(ambientLighting 
               + diffuseReflection + specularReflection, 1.0);
         }
         
         #endif

         ENDGLSL
      }

      Pass {	
         Tags { "LightMode" = "ForwardAdd" } 
            // pass for additional light sources
         Blend One One // additive blending 

         GLSLPROGRAM

         // User-specified properties
         uniform vec4 _Color; 
         uniform vec4 _SpecColor; 
         uniform float _Shininess;

         // The following built-in uniforms (except _LightColor0) 
         // are also defined in "UnityCG.glslinc", 
         // i.e. one could #include "UnityCG.glslinc" 
         uniform vec3 _WorldSpaceCameraPos; 
            // camera position in world space
         uniform mat4 _Object2World; // model matrix
         uniform mat4 _World2Object; // inverse model matrix
         uniform vec4 _WorldSpaceLightPos0; 
            // direction to or position of light source
         uniform vec4 _LightColor0; 
            // color of light source (from "Lighting.cginc")
         
         varying vec4 position; 
            // position of the vertex (and fragment) in world space 
         varying vec3 varyingNormalDirection; 
            // surface normal vector in world space

         #ifdef VERTEX
         
         void main()
         {				
            mat4 modelMatrix = _Object2World;
            mat4 modelMatrixInverse = _World2Object; // unity_Scale.w 
               // is unnecessary because we normalize vectors
            
            position = modelMatrix * gl_Vertex;
            varyingNormalDirection = normalize(vec3(
               vec4(gl_Normal, 0.0) * modelMatrixInverse));

            gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
         }
         
         #endif

         #ifdef FRAGMENT
         
         void main()
         {
            vec3 normalDirection = normalize(varyingNormalDirection);

            vec3 viewDirection = 
               normalize(_WorldSpaceCameraPos - vec3(position));
            vec3 lightDirection;
            float attenuation;

            if (0.0 == _WorldSpaceLightPos0.w) // directional light?
            {
               attenuation = 1.0; // no attenuation
               lightDirection = normalize(vec3(_WorldSpaceLightPos0));
            } 
            else // point or spot light
            {
               vec3 vertexToLightSource = 
                  vec3(_WorldSpaceLightPos0 - position);
               float distance = length(vertexToLightSource);
               attenuation = 1.0 / distance; // linear attenuation 
               lightDirection = normalize(vertexToLightSource);
            }
            
            vec3 diffuseReflection = 
               attenuation * vec3(_LightColor0) * vec3(_Color) 
               * max(0.0, dot(normalDirection, lightDirection));
            
            vec3 specularReflection;
            if (dot(normalDirection, lightDirection) < 0.0) 
               // light source on the wrong side?
            {
               specularReflection = vec3(0.0, 0.0, 0.0); 
                  // no specular reflection
            }
            else // light source on the right side
            {
               vec3 halfwayDirection = 
                  normalize(lightDirection + viewDirection);
               float w = pow(1.0 - max(0.0, 
                  dot(halfwayDirection, viewDirection)), 5.0);
               specularReflection = attenuation * vec3(_LightColor0) 
                  * mix(vec3(_SpecColor), vec3(1.0), w)
                  * pow(max(0.0, dot(
                  reflect(-lightDirection, normalDirection), 
                  viewDirection)), _Shininess);
            }

            gl_FragColor = 
               vec4(diffuseReflection + specularReflection, 1.0);
         }
         
         #endif

         ENDGLSL
      }
   } 
   // The definition of a fallback shader should be commented out 
   // during development:
   // Fallback "Specular"
}

艺术控制

上面实现的一个有用修改是将幂5.0替换为用户指定的着色器属性。这将使 CG 艺术家根据他们的艺术需求来夸大或衰减菲涅耳因子的影响。

对半透明表面的影响

除了影响镜面高光之外，菲涅耳因子还应该影响半透明表面的不透明度 $\alpha$ 。事实上，菲涅耳因子描述了表面如何对掠射光线变得更具反射性，这意味着吸收、折射或透射的光线更少，即透明度 $T$ 降低，因此不透明度 $\alpha =1-T$ 提高。为此，可以使用表面法线向量N而不是半程向量H来计算菲涅耳因子，半透明表面的不透明度可以从用户指定的数值 $\alpha _{0}$ （在表面法线方向的观察中）增加到 1（独立于波长）与

$\alpha _{\text{Fresnel}}=\alpha _{0}+(1-\alpha _{0})(1-\mathbf {N} \cdot \mathbf {V} )^{5}$ .

在“轮廓增强”部分，不透明度被认为是由光线穿过一层半透明材料时衰减引起的。这种不透明度应该与由于反射率增加而导致的不透明度结合起来：总的不透明度 $\alpha _{\text{total}}$ 是 1 减去总透明度 $T_{\text{total}}$ ，它是由于衰减引起的透明度 $T_{\text{attenuation}}$ （即 1 减去 $\alpha _{\text{attenuation}}$ ）和由于菲涅耳因子引起的透明度 $T_{\text{Fresnel}}$ （即 1 减去 $\alpha _{\text{Fresnel}}$ ）的乘积，即

$\alpha _{\text{total}}=1-T_{\text{total}}\,$ $\,=1-T_{\text{attenuation}}T_{\text{Fresnel}}$ $\,=1-(1-\alpha _{\text{attenuation}})(1-\alpha _{\text{Fresnel}})$

$\alpha _{\text{Fresnel}}$ 是不透明度，如上计算，而 $\alpha _{\text{attenuation}}$ 是不透明度，如“轮廓增强”部分中计算的那样。对于平行于表面法向量的视角， $\alpha _{\text{total}}$ 和 $\alpha _{0}$ 可以由用户指定。然后，该方程固定 $\alpha _{\text{attenuation}}$ 用于法线方向，实际上，它固定了所有常数，因此 $\alpha _{\text{total}}$ 可以针对所有视角进行计算。请注意，漫反射或镜面反射都不应与不透明度 $\alpha _{\text{total}}$ 相乘，因为镜面反射已经与菲涅耳因子相乘，而漫反射应该只与由于衰减引起的 $\alpha _{\text{attenuation}}$ 不透明度相乘。

总结

恭喜你完成了其中一个比较高级的教程！我们已经了解了：

什么是菲涅尔系数。
施里克对菲涅尔系数的近似方法。
如何在镜面高光中实现施里克的近似方法。
如何为实现添加更多艺术控制。
如何将菲涅尔系数用于半透明表面。

进一步阅读

如果你还想了解更多

关于使用 Phong 反射模型进行光照，你可以阅读 “镜面高光”部分。
关于逐像素光照（即 Phong 着色），你可以阅读 “平滑镜面高光”部分。
关于施里克的近似方法，你可以阅读他的文章“一种用于物理基础渲染的廉价 BRDF 模型”，作者 Christophe Schlick，计算机图形论坛，13(3):233—246，1994 年。或者你可以阅读书籍“OpenGL 着色语言”（第 3 版）第 14.1 章，作者 Randi Rost 等，2009 年由 Addison-Wesley 出版，或书籍“编程顶点、几何体和像素着色器”（第 2 版，2008 年）的“光照”章节中的第 5 节，作者 Wolfgang Engel、Jack Hoxley、Ralf Kornmann、Niko Suni 和 Jason Zink（可以在网上获得）。

< GLSL 编程/Unity

除非另有说明，本页所有示例源代码均授予公有领域。