shader程序中光照计算模型中什么时候采用乘法，什么时候采用加法

在Shader程序中，光照计算模型的核心在于如何组合不同的光照贡献（如漫反射、镜面反射、环境光等）来生成最终的像素颜色。乘法和加法在不同的上下文中有不同的用途，下面我们详细讨论一下它们的使用场景。

乘法的使用场景

1. 光照强度与材质颜色的结合：

   • 漫反射光照（Diffuse Lighting）：漫反射光照通常是光源颜色和材质颜色的乘积。光源颜色表示光的强度和颜色，而材质颜色表示物体表面的颜色。

     fixed3 diffuse = lightColor * materialColor * NdotL;
     

     其中，NdotL是法线和光线方向的点积，表示光照的强度。

2. 光照衰减：

   • 光照衰减通常是光源强度与距离的函数。衰减因子通常乘以光源颜色来计算最终的光照强度。

     float attenuation = 1.0 / (distance * distance);
     fixed3 attenuatedLight = lightColor * attenuation;
     

3. 镜面反射光照（Specular Lighting）：

   • 镜面反射光照通常是光源颜色、材质的镜面反射颜色和光照强度的乘积。

     fixed3 specular = lightColor * specularColor * pow(NdotH, shininess);
     

     其中，NdotH是法线和半程向量的点积，shininess是材质的光滑度。

4. 环境光照（Ambient Lighting）：

   • 环境光照通常是环境光颜色和材质颜色的乘积。

     fixed3 ambient = ambientLightColor * materialColor;
     

加法的使用场景

1. 组合不同光照贡献：

   • 最终的光照颜色通常是漫反射、镜面反射和环境光等不同光照贡献的加和。

     fixed3 finalColor = ambient + diffuse + specular;
     

2. 累加多个光源的贡献：

   • 在多光源场景中，每个光源的光照贡献通常是独立计算的，然后累加到最终的光照颜色中。

     fixed3 finalColor = ambient;
     for (int i = 0; i < numLights; i++)
     {
         finalColor += CalculateLightContribution(light[i]);
     }
     

示例代码

以下是一个完整的Shader代码示例，展示了如何使用乘法和加法来计算光照。

Shader "Custom/LightingShader"
{
    Properties
    {
        _MainTex ("Base (RGB)", 2D) = "white" {}
        _NormalMap ("Normal Map", 2D) = "bump" {}
        _SpecColor ("Specular Color", Color) = (1,1,1,1)
        _Shininess ("Shininess", Range(0.03, 1)) = 0.078125
        _AmbientColor ("Ambient Color", Color) = (0.1,0.1,0.1,1)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Standard fullforwardshadows

        sampler2D _MainTex;
        sampler2D _NormalMap;
        fixed4 _SpecColor;
        half _Shininess;
        fixed4 _AmbientColor;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_NormalMap;
            float3 worldPos;
        };

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            // Sample the base texture
            fixed4 texColor = tex2D(_MainTex, IN.uv_MainTex);
            o.Albedo = texColor.rgb;

            // Sample the normal map
            fixed3 normalMap = UnpackNormal(tex2D(_NormalMap, IN.uv_NormalMap));
            o.Normal = normalMap;

            // Set the specular color and smoothness
            o.Specular = _SpecColor.rgb;
            o.Smoothness = _Shininess;

            // Calculate ambient lighting
            fixed3 ambient = _AmbientColor.rgb * texColor.rgb;

            // Calculate diffuse lighting
            fixed3 lightDir = normalize(_WorldSpaceLightPos0.xyz);
            float NdotL = max(dot(o.Normal, lightDir), 0.0);
            fixed3 diffuse = _LightColor0.rgb * texColor.rgb * NdotL;

            // Calculate specular lighting
            fixed3 viewDir = normalize(WorldSpaceViewDir(IN.worldPos));
            fixed3 halfDir = normalize(lightDir + viewDir);
            float NdotH = max(dot(o.Normal, halfDir), 0.0);
            fixed3 specular = _LightColor0.rgb * _SpecColor.rgb * pow(NdotH, _Shininess);

            // Combine all lighting contributions
            fixed3 finalColor = ambient + diffuse + specular;
            o.Emission = finalColor;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

结论

在Shader程序中，乘法和加法的使用取决于具体的光照计算需求。乘法通常用于结合光照强度与材质属性，而加法用于组合不同的光照贡献。通过合理使用乘法和加法，可以实现复杂而逼真的光照效果。

如果你有任何进一步的问题或需要更详细的解释，请随时提问！

好的，我们继续深入探讨光照计算模型中的乘法和加法的使用场景，并进一步优化和扩展Shader代码。

进一步优化和扩展

在实际的Shader开发中，我们可能会遇到更多复杂的光照模型和效果需求。以下是一些常见的优化和扩展方法：

1. 多光源支持：

   • 在实际场景中，通常会有多个光源。我们需要累加每个光源的光照贡献。

2. 阴影计算：

   • 阴影是光照计算中不可或缺的一部分。我们可以使用阴影贴图（Shadow Map）来计算阴影。

3. 法线贴图（Normal Mapping）：

   • 法线贴图用于细化表面细节，使光照效果更加真实。

4. 环境光遮蔽（Ambient Occlusion）：

   • 环境光遮蔽用于模拟环境光在凹陷区域的遮蔽效果。

多光源支持

我们可以通过循环遍历所有光源，并累加每个光源的光照贡献来实现多光源支持。

示例代码

Shader "Custom/AdvancedLightingShader"
{
    Properties
    {
        _MainTex ("Base (RGB)", 2D) = "white" {}
        _NormalMap ("Normal Map", 2D) = "bump" {}
        _SpecColor ("Specular Color", Color) = (1,1,1,1)
        _Shininess ("Shininess", Range(0.03, 1)) = 0.078125
        _AmbientColor ("Ambient Color", Color) = (0.1,0.1,0.1,1)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Standard fullforwardshadows addshadow

        sampler2D _MainTex;
        sampler2D _NormalMap;
        fixed4 _SpecColor;
        half _Shininess;
        fixed4 _AmbientColor;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_NormalMap;
            float3 worldPos;
        };

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            // Sample the base texture
            fixed4 texColor = tex2D(_MainTex, IN.uv_MainTex);
            o.Albedo = texColor.rgb;

            // Sample the normal map
            fixed3 normalMap = UnpackNormal(tex2D(_NormalMap, IN.uv_NormalMap));
            o.Normal = normalMap;

            // Set the specular color and smoothness
            o.Specular = _SpecColor.rgb;
            o.Smoothness = _Shininess;

            // Calculate ambient lighting
            fixed3 ambient = _AmbientColor.rgb * texColor.rgb;

            // Initialize final color with ambient lighting
            fixed3 finalColor = ambient;

            // Loop through all lights
            for (int i = 0; i < _LightCount; i++)
            {
                // Get light direction and color
                fixed3 lightDir = normalize(_WorldSpaceLightPos[i].xyz);
                fixed3 lightColor = _LightColor[i].rgb;

                // Calculate diffuse lighting
                float NdotL = max(dot(o.Normal, lightDir), 0.0);
                fixed3 diffuse = lightColor * texColor.rgb * NdotL;

                // Calculate specular lighting
                fixed3 viewDir = normalize(WorldSpaceViewDir(IN.worldPos));
                fixed3 halfDir = normalize(lightDir + viewDir);
                float NdotH = max(dot(o.Normal, halfDir), 0.0);
                fixed3 specular = lightColor * _SpecColor.rgb * pow(NdotH, _Shininess);

                // Accumulate light contribution
                finalColor += diffuse + specular;
            }

            // Set final color
            o.Emission = finalColor;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

好的，我们继续讨论如何在Shader中实现阴影计算。阴影计算通常通过使用阴影贴图（Shadow Map）来实现。我们需要在Shader中添加阴影采样和计算。

阴影计算

阴影贴图是一种常见的技术，用于确定场景中的哪些部分被光源遮挡。我们需要在Shader中添加对阴影贴图的支持，并在光照计算中考虑阴影的影响。

示例代码

以下是一个包含阴影计算的Shader示例代码：

Shader "Custom/ShadowedLightingShader"
{
    Properties
    {
        _MainTex ("Base (RGB)", 2D) = "white" {}
        _NormalMap ("Normal Map", 2D) = "bump" {}
        _SpecColor ("Specular Color", Color) = (1,1,1,1)
        _Shininess ("Shininess", Range(0.03, 1)) = 0.078125
        _AmbientColor ("Ambient Color", Color) = (0.1,0.1,0.1,1)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Standard fullforwardshadows addshadow

        sampler2D _MainTex;
        sampler2D _NormalMap;
        fixed4 _SpecColor;
        half _Shininess;
        fixed4 _AmbientColor;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_NormalMap;
            float3 worldPos;
            float4 shadowCoord; // 用于阴影贴图的坐标
        };

        // Unity 提供的阴影采样函数
        half4 UnitySampleShadowmap(float4 shadowCoord)
        {
            return tex2Dproj(_ShadowMap, shadowCoord);
        }

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            // Sample the base texture
            fixed4 texColor = tex2D(_MainTex, IN.uv_MainTex);
            o.Albedo = texColor.rgb;

            // Sample the normal map
            fixed3 normalMap = UnpackNormal(tex2D(_NormalMap, IN.uv_NormalMap));
            o.Normal = normalMap;

            // Set the specular color and smoothness
            o.Specular = _SpecColor.rgb;
            o.Smoothness = _Shininess;

            // Calculate ambient lighting
            fixed3 ambient = _AmbientColor.rgb * texColor.rgb;

            // Initialize final color with ambient lighting
            fixed3 finalColor = ambient;

            // Loop through all lights
            for (int i = 0; i < _LightCount; i++)
            {
                // Get light direction and color
                fixed3 lightDir = normalize(_WorldSpaceLightPos[i].xyz);
                fixed3 lightColor = _LightColor[i].rgb;

                // Calculate diffuse lighting
                float NdotL = max(dot(o.Normal, lightDir), 0.0);
                fixed3 diffuse = lightColor * texColor.rgb * NdotL;

                // Calculate specular lighting
                fixed3 viewDir = normalize(WorldSpaceViewDir(IN.worldPos));
                fixed3 halfDir = normalize(lightDir + viewDir);
                float NdotH = max(dot(o.Normal, halfDir), 0.0);
                fixed3 specular = lightColor * _SpecColor.rgb * pow(NdotH, _Shininess);

                // Sample shadow map
                half shadow = UnitySampleShadowmap(IN.shadowCoord).r;

                // Apply shadow to light contribution
                diffuse *= shadow;
                specular *= shadow;

                // Accumulate light contribution
                finalColor += diffuse + specular;
            }

            // Set final color
            o.Emission = finalColor;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

法线贴图（Normal Mapping）

法线贴图用于细化表面细节，使光照效果更加真实。我们已经在前面的代码中展示了如何使用法线贴图。

环境光遮蔽（Ambient Occlusion）

环境光遮蔽用于模拟环境光在凹陷区域的遮蔽效果。我们可以通过预计算的环境光遮蔽贴图来实现这一效果。

示例代码

以下是一个包含环境光遮蔽的Shader示例代码：

Shader "Custom/AmbientOcclusionShader"
{
    Properties
    {
        _MainTex ("Base (RGB)", 2D) = "white" {}
        _NormalMap ("Normal Map", 2D) = "bump" {}
        _SpecColor ("Specular Color", Color) = (1,1,1,1)
        _Shininess ("Shininess", Range(0.03, 1)) = 0.078125
        _AmbientColor ("Ambient Color", Color) = (0.1,0.1,0.1,1)
        _OcclusionMap ("Occlusion Map", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Standard fullforwardshadows addshadow

        sampler2D _MainTex;
        sampler2D _NormalMap;
        sampler2D _OcclusionMap;
        fixed4 _SpecColor;
        half _Shininess;
        fixed4 _AmbientColor;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_NormalMap;
            float2 uv_OcclusionMap;
            float3 worldPos;
            float4 shadowCoord; // 用于阴影贴图的坐标
        };

        // Unity 提供的阴影采样函数
        half4 UnitySampleShadowmap(float4 shadowCoord)
        {
            return tex2Dproj(_ShadowMap, shadowCoord);
        }

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            // Sample the base texture
            fixed4 texColor = tex2D(_MainTex, IN.uv_MainTex);
            o.Albedo = texColor.rgb;

            // Sample the normal map
            fixed3 normalMap = UnpackNormal(tex2D(_NormalMap, IN.uv_NormalMap));
            o.Normal = normalMap;

            // Sample the occlusion map
            half occlusion = tex2D(_OcclusionMap, IN.uv_OcclusionMap).r;

            // Set the specular color and smoothness
            o.Specular = _SpecColor.rgb;
            o.Smoothness = _Shininess;

            // Calculate ambient lighting
            fixed3 ambient = _AmbientColor.rgb * texColor.rgb * occlusion;

            // Initialize final color with ambient lighting
            fixed3 finalColor = ambient;

            // Loop through all lights
            for (int i = 0; i < _LightCount; i++)
            {
                // Get light direction and color
                fixed3 lightDir = normalize(_WorldSpaceLightPos[i].xyz);
                fixed3 lightColor = _LightColor[i].rgb;

                // Calculate diffuse lighting
                float NdotL = max(dot(o.Normal, lightDir), 0.0);
                fixed3 diffuse = lightColor * texColor.rgb * NdotL;

                // Calculate specular lighting
                fixed3 viewDir = normalize(WorldSpaceViewDir(IN.worldPos));
                fixed3 halfDir = normalize(lightDir + viewDir);
                float NdotH = max(dot(o.Normal, halfDir), 0.0);
                fixed3 specular = lightColor * _SpecColor.rgb * pow(NdotH, _Shininess);

                // Sample shadow map
                half shadow = UnitySampleShadowmap(IN.shadowCoord).r;

                // Apply shadow to light contribution
                diffuse *= shadow;
                specular *= shadow;

                // Accumulate light contribution
                finalColor += diffuse + specular;
            }

            // Set final color
            o.Emission = finalColor;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

结论

通过添加多光源支持、阴影计算、法线贴图和环境光遮蔽，我们可以显著提升Shader的视觉效果，使其更加逼真和复杂。这些技术在现代游戏和视觉效果中广泛应用，能够模拟出更加真实的光照和阴影效果。

如果你有任何进一步的问题或需要更详细的解释，请随时提问！

好的，我们继续深入探讨Shader编程中的高级光照技术和优化方法。接下来，我们将讨论一些更高级的光照技术，如基于物理的渲染（PBR）、次表面散射（Subsurface Scattering）和体积光照（Volumetric Lighting）。

基于物理的渲染（PBR）

基于物理的渲染（PBR）是一种更加真实的光照模型，它基于物理定律来模拟光与物体表面的交互。PBR通常使用金属度（Metalness）、粗糙度（Roughness）和环境反射（Environment Reflection）等参数。

示例代码

以下是一个简单的PBR Shader示例代码：

Shader "Custom/PBRShader"
{
    Properties
    {
        _MainTex ("Base (RGB)", 2D) = "white" {}
        _NormalMap ("Normal Map", 2D) = "bump" {}
        _Metallic ("Metallic", Range(0, 1)) = 0.5
        _Roughness ("Roughness", Range(0, 1)) = 0.5
        _AmbientColor ("Ambient Color", Color) = (0.1,0.1,0.1,1)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 300

        CGPROGRAM
        #pragma surface surf Standard fullforwardshadows addshadow

        sampler2D _MainTex;
        sampler2D _NormalMap;
        half _Metallic;
        half _Roughness;
        fixed4 _AmbientColor;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_NormalMap;
            float3 worldPos;
            float4 shadowCoord; // 用于阴影贴图的坐标
        };

        // Unity 提供的阴影采样函数
        half4 UnitySampleShadowmap(float4 shadowCoord)
        {
            return tex2Dproj(_ShadowMap, shadowCoord);
        }

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            // Sample the base texture
            fixed4 texColor = tex2D(_MainTex, IN.uv_MainTex);
            o.Albedo = texColor.rgb;

            // Sample the normal map
            fixed3 normalMap = UnpackNormal(tex2D(_NormalMap, IN.uv_NormalMap));
            o.Normal = normalMap;

            // Set the metallic and roughness
            o.Metallic = _Metallic;
            o.Smoothness = 1.0 - _Roughness;

            // Calculate ambient lighting
            fixed3 ambient = _AmbientColor.rgb * texColor.rgb;

            // Initialize final color with ambient lighting
            fixed3 finalColor = ambient;

            // Loop through all lights
            for (int i = 0; i < _LightCount; i++)
            {
                // Get light direction and color
                fixed3 lightDir = normalize(_WorldSpaceLightPos[i].xyz);
                fixed3 lightColor = _LightColor[i].rgb;

                // Calculate diffuse lighting
                float NdotL = max(dot(o.Normal, lightDir), 0.0);
                fixed3 diffuse = lightColor * texColor.rgb * NdotL;

                // Calculate specular lighting using PBR model
                fixed3 viewDir = normalize(WorldSpaceViewDir(IN.worldPos));
                fixed3 halfDir = normalize(lightDir + viewDir);
                float NdotH = max(dot(o.Normal, halfDir), 0.0);
                float roughnessSquared = _Roughness * _Roughness;
                float D = pow(NdotH, 2.0 / roughnessSquared - 2.0);
                float F = pow(1.0 - NdotH, 5.0);
                float G = 1.0 / (1.0 + roughnessSquared);
                fixed3 specular = lightColor * (D * F * G) / (4.0 * NdotL * max(dot(o.Normal, viewDir), 0.0));

                // Sample shadow map
                half shadow = UnitySampleShadowmap(IN.shadowCoord).r;

                // Apply shadow to light contribution
                diffuse *= shadow;
                specular *= shadow;

                // Accumulate light contribution
                finalColor += diffuse + specular;
            }

            // Set final color
            o.Emission = finalColor;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

次表面散射（Subsurface Scattering）

次表面散射用于模拟光在半透明物体内部的散射效果，如皮肤、蜡烛和大理石等。实现次表面散射通常需要复杂的计算和多次采样。

示例代码

以下是一个简单的次表面散射Shader示例代码：

Shader "Custom/SubsurfaceScatteringShader"
{
    Properties
    {
        _MainTex ("Base (RGB)", 2D) = "white" {}
        _NormalMap ("Normal Map", 2D) = "bump" {}
        _SubsurfaceColor ("Subsurface Color", Color) = (1,0.8,0.6,1)
        _SubsurfaceScale ("Subsurface Scale", Range(0, 1)) = 0.5
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 300

        CGPROGRAM
        #pragma surface surf Standard fullforwardshadows addshadow

        sampler2D _MainTex;
        sampler2D _NormalMap;
        fixed4 _SubsurfaceColor;
        half _SubsurfaceScale;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_NormalMap;
            float3 worldPos;
            float4 shadowCoord; // 用于阴影贴图的坐标
        };

        // Unity 提供的阴影采样函数
        half4 UnitySampleShadowmap(float4 shadowCoord)
        {
            return tex2Dproj(_ShadowMap, shadowCoord);
        }

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            // Sample the base texture
            fixed4 texColor = tex2D(_MainTex, IN.uv_MainTex);
            o.Albedo = texColor.rgb;

            // Sample the normal map
            fixed3 normalMap = UnpackNormal(tex2D(_NormalMap, IN.uv_NormalMap));
            o.Normal = normalMap;

            // Calculate subsurface scattering
            fixed3 subsurface = _SubsurfaceColor.rgb * _SubsurfaceScale;

            // Initialize final color with subsurface scattering
            fixed3 finalColor = subsurface;

            // Loop through all lights
            for (int i = 0; i < _LightCount; i++)
            {
                // Get light direction and color
                fixed3 lightDir = normalize(_WorldSpaceLightPos[i].xyz);
                fixed3 lightColor = _LightColor[i].rgb;

                // Calculate diffuse lighting
                float NdotL = max(dot(o.Normal, lightDir), 0.0);
                fixed3 diffuse = lightColor * texColor.rgb * NdotL;

                // Calculate specular lighting
                fixed3 viewDir = normalize(WorldSpaceViewDir(IN.worldPos));
                fixed3 halfDir = normalize(lightDir + viewDir);
                float NdotH = max(dot(o.Normal, halfDir), 0.0);
                fixed3 specular = lightColor * pow(NdotH, _SubsurfaceScale * 128.0);

                // Sample shadow map
                half shadow = UnitySampleShadowmap(IN.shadowCoord).r;

                // Apply shadow to light contribution
                diffuse *= shadow;
                specular *= shadow;

                // Accumulate light contribution
                finalColor += diffuse + specular;
            }

            // Set final color
            o.Emission = finalColor;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

体积光照（Volumetric Lighting）

体积光照用于模拟光在空气或其他介质中的散射效果，如雾、烟和光束。实现体积光照通常需要在片段着色器中进行多次采样和体积散射计算。

示例代码

以下是一个简单的体积光照Shader示例代码：

Shader "Custom/VolumetricLightingShader"
{
    Properties
    {
        _MainTex ("Base (RGB)", 2D) = "white" {}
        _NormalMap ("Normal Map", 2D) = "bump" {}
        _LightScattering ("Light Scattering", Range(0, 1)) = 0.5
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 300

        CGPROGRAM
        #pragma surface surf Standard fullforwardshadows addshadow

        sampler2D _MainTex;
        sampler2D _NormalMap;
        half _LightScattering;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_NormalMap;
            float3 worldPos;
            float4 shadowCoord; // 用于阴影贴图的坐标
        };

        // Unity 提供的阴影采样函数
        half4 UnitySampleShadowmap(float4 shadowCoord)
        {
            return tex2Dproj(_ShadowMap, shadowCoord);
        }

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            // Sample the base texture
            fixed4 texColor = tex2D(_MainTex, IN.uv_MainTex);
            o.Albedo = texColor.rgb;

            // Sample the normal map
            fixed3 normalMap = UnpackNormal(tex2D(_NormalMap, IN.uv_NormalMap));
            o.Normal = normalMap;

            // Initialize final color
            fixed3 finalColor = texColor.rgb;

            // Loop through all lights
            for (int i = 0; i < _LightCount; i++)
            {
                // Get light direction and color
                fixed3 lightDir = normalize(_WorldSpaceLightPos[i].xyz);
                fixed3 lightColor = _LightColor[i].rgb;

                // Calculate diffuse lighting
                float NdotL = max(dot(o.Normal, lightDir), 0.0);
                fixed3 diffuse = lightColor * texColor.rgb * NdotL;

                // Calculate specular lighting
                fixed3 viewDir = normalize(WorldSpaceViewDir(IN.worldPos));
                fixed3 halfDir = normalize(lightDir + viewDir);
                float NdotH = max(dot(o.Normal, halfDir), 0.0);
                fixed3 specular = lightColor * pow(NdotH, _LightScattering * 128.0);

                // Sample shadow map
                half shadow = UnitySampleShadowmap(IN.shadowCoord).r;

                // Apply shadow to light contribution
                diffuse *= shadow;
                specular *= shadow;

                // Apply volumetric scattering
                fixed3 scattering = lightColor * _LightScattering * shadow;

                // Accumulate light contribution
                finalColor += diffuse + specular + scattering;
            }

            // Set final color
            o.Emission = finalColor;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

结论

通过引入基于物理的渲染（PBR）、次表面散射（Subsurface Scattering）和体积光照（Volumetric Lighting），我们可以进一步提升Shader的视觉效果，使其更加逼真和复杂。这些技术在现代游戏和视觉效果中广泛应用，能够模拟出更加真实的光照和材质效果。

如果你有任何进一步的问题或需要更详细的解释，请随时提问！