[Shader] 3.Shader中常见光照模型

最新推荐文章于 2025-03-04 22:16:41 发布

原创最新推荐文章于 2025-03-04 22:16:41 发布 · 62 阅读

CC 4.0 BY-SA版权

本文深入探讨Unity中常见的光照模型，从基础的Lambert模型开始，介绍HalfLambert的改进，然后过渡到Phong模型，包括其镜面反射的计算。进一步，我们讨论了Blinn-Phong模型，它通过半角向量简化计算，以及如何实现逐像素光照以提高渲染质量。

基于Lambert光照模型的Shader

Lambert模型

Lambert光照模型计算公式为：

使用入射光颜色和漫反射颜色相乘再乘以saturate裁剪后的光线方向(从入射点到光源方向)和法线方向夹角大小(点乘cos值)。

Shader "Custom/Lambert"
{
    Properties
    {
        _MainColor("MainColor",Color) = (1, 1, 1, 1)
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "UnityLightingCommon.cginc"

            struct v2f
            {
                float4 pos : SV_POSITION;
                fixed4 dif : COLOR0;
            };

            fixed4 _MainColor;

            v2f vert (appdata_base v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                //法线向量 由模型空间变换到世界空间并标准化
                float3 n = UnityObjectToWorldNormal(v.normal);
                n = normalize(n);

                //灯光法向向量
                fixed3 l = normalize(_WorldSpaceLightPos0.xyz);

                //按照公式计算漫反射
                fixed ndotl = dot(n,l);
                o.dif = _LightColor0 * _MainColor * saturate(ndotl);

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                return i.dif;
            }
            ENDCG
        }
    }
}

HalfLambert模型

修改公式将夹角值映射到[0.5,1]避免背面全黑。

            v2f vert (appdata_base v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                //法线向量 由模型空间变换到世界空间并标准化
                float3 n = UnityObjectToWorldNormal(v.normal);
                n = normalize(n);

                //灯光法向向量
                fixed3 l = normalize(_WorldSpaceLightPos0.xyz);

                //按照公式计算漫反射
                fixed ndotl = dot(n,l);
                o.dif = _LightColor0 * _MainColor * (0.5 * ndotl+0.5);

                return o;
            }

基于Phong光照模型的Shader

Phong

Phong光照理论：物体表面反射光由三部分组成：环境光，漫反射，镜面反射(高光)。

漫反射的计算即Lambert光照模型，镜面反射的计算如下。

与Lambert公式类似，不同之处在于，这里和法线点乘的向量有入射光方向变成了视线方向(人直接看到的地方才高亮)，并加以光泽度约束(实际约束了高光部分的范围，越小高光区域越大)。

Shader "Custom/Phong"
{
    Properties
    {
        _MainColor("MainColor",Color) = (1, 1, 1, 1)
        _Shininess("Shininess",Range(1,100)) = 1
        _SpecularColor("Specular Color",Color) = (0, 0, 0, 0)
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "UnityLightingCommon.cginc"

            struct v2f
            {
                float4 pos : SV_POSITION;
                fixed4 color : COLOR0;
            };

            fixed4 _MainColor;
            fixed4 _SpecularColor;
            half _Shininess;

            v2f vert (appdata_base v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                //法线向量 由模型空间变换到世界空间并标准化
                float3 n = UnityObjectToWorldNormal(v.normal);
                n = normalize(n);

                //灯光法向向量
                fixed3 l = normalize(_WorldSpaceLightPos0.xyz);

                //视线方向向量
                fixed3 view = normalize(WorldSpaceViewDir(v.vertex));

                //漫反射
                fixed ndotl = dot(n,l);
                fixed4 dif = _LightColor0 * _MainColor * saturate(ndotl);

                //镜面反射 光线方向取负，输入Reflect函数为光源到顶点的方向
                float3 ref = reflect(-l, n);
                ref = normalize(ref);
                fixed rdotv = saturate(dot(ref,view));
                fixed4 spec = _LightColor0 * _SpecularColor * pow(rdotv, _Shininess);

                //环境光 + 漫反射 +镜面反射
                o.color = unity_AmbientSky + dif + spec;
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                return i.color;
            }
            ENDCG
        }
    }
}

Blinn-Phong

为减少计算量，将Phong光照模型中的v替换成半角向量h(视角方向和灯光方向角平分方向)，视觉效果差距不大，但当观察者和灯光离物体很远时镜面反射近似为常数。

半角向量计算公式：

Blinn-Phong 镜面反射计算公式：

修改镜面反射部分代码。

            fixed4 frag (v2f i) : SV_Target
            {
                 //法线向量 由模型空间变换到世界空间并标准化
                float3 n = UnityObjectToWorldNormal(i.normal);
                n = normalize(n);

                //灯光法向向量
                fixed3 l = normalize(_WorldSpaceLightPos0.xyz);

                //视线方向向量
                fixed3 view = normalize(WorldSpaceViewDir(i.vertex));

                //漫反射
                fixed ndotl = dot(n,l);
                fixed4 dif = _LightColor0 * _MainColor * saturate(ndotl);

                //镜面反射 光线方向取负，输入Reflect函数为光源到顶点的方向
                float3 h = normalize(l + view);
                fixed ndoth = saturate(dot(h, n));
                fixed4 spec = _LightColor0 * _SpecularColor * pow(ndoth, _Shininess);

                //环境光 + 漫反射 +镜面反射
                return unity_AmbientSky + dif + spec;
            }

逐像素光照

对于顶点数量较少的Sphere类型，可以很明显的看到光照范围边缘并不光滑，可以通过增加曲面细分等级或者改由片段着色器逐像素计算光照，这里采用第二种。

Shader "Custom/Phong_Pixel"
{
    Properties
    {
        _MainColor("MainColor",Color) = (1, 1, 1, 1)
        _Shininess("Shininess",Range(1,100)) = 1
        _SpecularColor("Specular Color",Color) = (0, 0, 0, 0)
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "UnityLightingCommon.cginc"

            struct v2f
            {
                float4 pos : SV_POSITION;
                float3 normal : TEXCOORD0;
                float4 vertex : TEXCOORD1;
            };

            fixed4 _MainColor;
            fixed4 _SpecularColor;
            half _Shininess;

            v2f vert (appdata_base v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.normal = v.normal;
                o.vertex = v.vertex;              
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                 //法线向量 由模型空间变换到世界空间并标准化
                float3 n = UnityObjectToWorldNormal(i.normal);
                n = normalize(n);

                //灯光法向向量
                fixed3 l = normalize(_WorldSpaceLightPos0.xyz);

                //视线方向向量
                fixed3 view = normalize(WorldSpaceViewDir(i.vertex));

                //漫反射
                fixed ndotl = dot(n,l);
                fixed4 dif = _LightColor0 * _MainColor * saturate(ndotl);

                //镜面反射 光线方向取负，输入Reflect函数为光源到顶点的方向
                float3 ref = reflect(-l, n);
                ref = normalize(ref);
                fixed rdotv = saturate(dot(ref,view));
                fixed4 spec = _LightColor0 * _SpecularColor * pow(rdotv, _Shininess);

                //环境光 + 漫反射 +镜面反射
                return unity_AmbientSky + dif + spec;
            }
            ENDCG
        }
    }
}