shader程序中UnityLightModel函数

于 2024-09-15 19:27:04 发布
阅读量562 收藏 4
点赞数 16
分类专栏： 渲染管线 文章标签： 游戏引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33060405/article/details/140700804
版权

好的，虽然Unity引擎中的UnityLightModel函数是一个内部实现的函数，我们无法直接查看其源码，但我们可以通过了解其功能和行为，模仿其实现来创建一个类似的光照模型函数。以下是一个模仿Unity标准光照模型的Shader代码示例，包含了基本的光照计算，包括环境光、漫反射光和镜面反射光。

1. Shader代码结构

我们将创建一个自定义的光照模型函数，并在Shader中使用它。以下是Shader代码的结构：

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

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 pos : SV_POSITION;
                float4 color : COLOR;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            sampler2D _NormalMap;
            float4 _NormalMap_ST;
            float4 _AmbientColor;
            float4 _DiffuseColor;
            float4 _SpecularColor;
            float _Shininess;

            // 自定义光照模型函数
            float4 CustomLightModel(float3 worldPos, float3 worldNormal, float3 viewDir)
            {
                float4 ambient = _AmbientColor;
                float4 diffuse = 0;
                float4 specular = 0;

                for (int i = 0; i < unity_LightCount; i++)
                {
                    float3 lightDir = normalize(_WorldSpaceLightPos[i].xyz);
                    float4 lightColor = _LightColor[i];

                    // Diffuse lighting
                    float diff = max(dot(worldNormal, lightDir), 0.0);
                    diffuse += _DiffuseColor * diff * lightColor;

                    // Specular lighting
                    float3 reflectDir = reflect(-lightDir, worldNormal);
                    float spec = pow(max(dot(viewDir, reflectDir), 0.0), _Shininess * 128.0);
                    specular += _SpecularColor * spec * lightColor;
                }

                return ambient + diffuse + specular;
            }

            v2f vert (appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);

                // Transform normal to world space
                float3 worldNormal = normalize(mul(v.normal, (float3x3)unity_WorldToObject));

                // Sample normal map
                float3 normalMap = UnpackNormal(tex2D(_NormalMap, TRANSFORM_TEX(v.uv, _NormalMap)));
                worldNormal = normalize(mul(normalMap, (float3x3)unity_WorldToObject));

                // Calculate world position and view direction
                float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                float3 viewDir = normalize(_WorldSpaceCameraPos - worldPos);

                // Calculate lighting
                o.color = CustomLightModel(worldPos, worldNormal, viewDir);

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // Sample the texture
                fixed4 texColor = tex2D(_MainTex, i.uv);

                // Apply the interpolated color
                return texColor * i.color;
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

好的，我们继续解释自定义光照模型函数的实现。

2. 代码解释（续）

2.1 自定义光照模型函数

我们定义了一个名为CustomLightModel的函数，用于计算光照效果。这个函数接受世界坐标、世界法线和视线方向作为输入，并返回计算后的光照颜色。

float4 CustomLightModel(float3 worldPos, float3 worldNormal, float3 viewDir)
{
    float4 ambient = _AmbientColor;
    float4 diffuse = 0;
    float4 specular = 0;

    for (int i = 0; i < unity_LightCount; i++)
    {
        float3 lightDir = normalize(_WorldSpaceLightPos[i].xyz);
        float4 lightColor = _LightColor[i];

        // Diffuse lighting
        float diff = max(dot(worldNormal, lightDir), 0.0);
        diffuse += _DiffuseColor * diff * lightColor;

        // Specular lighting
        float3 reflectDir = reflect(-lightDir, worldNormal);
        float spec = pow(max(dot(viewDir, reflectDir), 0.0), _Shininess * 128.0);
        specular += _SpecularColor * spec * lightColor;
    }

    return ambient + diffuse + specular;
}
  • 环境光：直接使用预定义的环境光颜色_AmbientColor。
  • 漫反射光：通过计算法线和光线方向的点积来获得漫反射强度，并乘以漫反射颜色_DiffuseColor和光源颜色lightColor。
  • 镜面反射光：通过计算视线方向和反射方向的点积来获得镜面反射强度，并乘以镜面反射颜色_SpecularColor和光源颜色lightColor。镜面反射强度还受光滑度（_Shininess）的影响。
2.2 顶点着色器

在顶点着色器中，我们计算了世界法线、世界坐标和视线方向，并调用自定义的光照模型函数来计算光照颜色。

v2f vert (appdata v)
{
    v2f o;
    o.pos = UnityObjectToClipPos(v.vertex);
    o.uv = TRANSFORM_TEX(v.uv, _MainTex);

    // Transform normal to world space
    float3 worldNormal = normalize(mul(v.normal, (float3x3)unity_WorldToObject));

    // Sample normal map
    float3 normalMap = UnpackNormal(tex2D(_NormalMap, TRANSFORM_TEX(v.uv, _NormalMap)));
    worldNormal = normalize(mul(normalMap, (float3x3)unity_WorldToObject));

    // Calculate world position and view direction
    float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
    float3 viewDir = normalize(_WorldSpaceCameraPos - worldPos);

    // Calculate lighting
    o.color = CustomLightModel(worldPos, worldNormal, viewDir);

    return o;
}
  • 法线变换：将法线从对象空间变换到世界空间。
  • 法线贴图：采样法线贴图，并将其变换到世界空间。
  • 世界坐标和视线方向：计算顶点的世界坐标和视线方向。
  • 光照计算：调用CustomLightModel函数计算光照颜色。
2.3 片段着色器

在片段着色器中，我们采样纹理颜色，并将其与顶点着色器计算的光照颜色相乘。

fixed4 frag (v2f i) : SV_Target
{
    // Sample the texture
    fixed4 texColor = tex2D(_MainTex, i.uv);

    // Apply the interpolated color
    return texColor * i.color;
}
  • 纹理采样：采样纹理颜色。
  • 颜色应用：将纹理颜色与光照颜色相乘，得到最终的片段颜色。

3. 测试和调试

为了确保这个自定义光照模型的Shader在不同场景下表现良好，可以进行以下测试和调试：

  1. 多种材质测试：

    • 使用不同的纹理、法线贴图、环境光、漫反射光和镜面反射光参数进行测试。

  2. 多种光源测试：

    • 设置不同方向、颜色和强度的光源，观察光照效果。

  3. 阴影测试：

    • 在场景中添加阴影投射物体，确保阴影效果正确。

  4. 法线贴图测试：

    • 使用不同的法线贴图，观察表面细节的变化。

  5. 性能测试：

    • 在不同的硬件平台上测试Shader的性能，确保其在目标平台上运行流畅。

通过以上步骤，我们实现了一个模仿Unity标准光照模型的Shader。这个Shader支持多光源、法线贴图和基本的光照计算，并且在不同场景下表现良好。希望这个示例代码和解释对你有所帮助！如果你有任何进一步的问题或需要更多的优化建议，请随时告诉我。

好的，我们继续深入探讨如何进一步优化和扩展这个自定义光照模型的Shader，以达到商业化级别的效果。

4. 进一步优化和扩展

4.1 支持更多光源

在实际的商业项目中，可能需要支持更多的光源。Unity的内置光源数量是有限的，但我们可以通过使用延迟渲染（Deferred Rendering）或其他技术来支持更多的光源。

4.2 添加阴影支持

阴影是光照模型中非常重要的一部分。我们可以通过添加阴影映射（Shadow Mapping）来实现阴影效果。

4.3 支持环境光遮蔽（AO）

环境光遮蔽（Ambient Occlusion）可以增加场景的深度感和真实感。我们可以通过预计算的AO贴图或屏幕空间环境光遮蔽（SSAO）来实现这一效果。

4.4 支持反射和折射

反射和折射可以增加材质的真实感。我们可以通过环境反射贴图（Cubemap）和折射计算来实现这些效果。

4.1 支持更多光源

为了支持更多的光源，我们可以使用延迟渲染技术。以下是一个简单的延迟渲染的示例：

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

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 pos : SV_POSITION;
                float3 worldPos : TEXCOORD1;
                float3 worldNormal : TEXCOORD2;
                float3 viewDir : TEXCOORD3;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            sampler2D _NormalMap;
            float4 _NormalMap_ST;
            float4 _AmbientColor;
            float4 _DiffuseColor;
            float4 _SpecularColor;
            float _Shininess;

            v2f vert (appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);

                // Transform normal to world space
                float3 worldNormal = normalize(mul(v.normal, (float3x3)unity_WorldToObject));

                // Sample normal map
                float3 normalMap = UnpackNormal(tex2D(_NormalMap, TRANSFORM_TEX(v.uv, _NormalMap)));
                worldNormal = normalize(mul(normalMap, (float3x3)unity_WorldToObject));

                // Calculate world position and view direction
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                o.worldNormal = worldNormal;
                o.viewDir = normalize(_WorldSpaceCameraPos - o.worldPos);

                return o;
            }

            float4 frag (v2f i) : SV_Target
            {
                // Sample the texture
                float4 texColor = tex2D(_MainTex, i.uv);

                // Initialize lighting
                float4 ambient = _AmbientColor;
                float4 diffuse = 0;
                float4 specular = 0;

                // Loop through all lights
                for (int i = 0; i < unity_LightCount; i++)
                {
                    float3 lightDir = normalize(_WorldSpaceLightPos[i].xyz);
                    float4 lightColor = _LightColor[i];

                    // Diffuse lighting
                    float diff = max(dot(i.worldNormal, lightDir), 0.0);
                    diffuse += _DiffuseColor * diff * lightColor;

                    // Specular lighting
                    float3 reflectDir = reflect(-lightDir, i.worldNormal);
                    float spec = pow(max(dot(i.viewDir, reflectDir), 0.0), _Shininess * 128.0);
                    specular += _SpecularColor * spec * lightColor;
                }

                // Combine lighting
                float4 lighting = ambient + diffuse + specular;

                // Apply the interpolated color
                return texColor * lighting;
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

4.2 添加阴影支持

为了添加阴影支持，我们需要使用阴影映射技术。以下是一个简单的阴影映射示例：

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

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
            #include "AutoLight.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 pos : SV_POSITION;
                float3 worldPos : TEXCOORD1;
                float3 worldNormal : TEXCOORD2;
                float3 viewDir : TEXCOORD3;
                float4 shadowCoord : TEXCOORD4;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            sampler2D _NormalMap;
            float4 _NormalMap_ST;
            float4 _AmbientColor;
            float4 _DiffuseColor;
            float4 _SpecularColor;
            float _Shininess;

            v2f vert (appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);

                // Transform normal to world space
                float3 worldNormal = normalize(mul(v.normal, (float3x3)unity_WorldToObject));

                // Sample normal map
                float3 normalMap = UnpackNormal(tex2D(_NormalMap, TRANSFORM_TEX(v.uv, _NormalMap)));
                worldNormal = normalize(mul(normalMap, (float3x3)unity_WorldToObject));

                // Calculate world position and view direction
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                o.worldNormal = worldNormal;
                o.viewDir = normalize(_WorldSpaceCameraPos - o.worldPos);

                // Calculate shadow coordinates
                o.shadowCoord = ComputeScreenPos(o.pos);

                return o;
            }

            float4 frag (v2f i) : SV_Target
            {
                // Sample the texture
                float4 texColor = tex2D(_MainTex, i.uv);

                // Initialize lighting
                float4 ambient = _AmbientColor;
                float4 diffuse = 0;
                float4 specular = 0;

                // Loop through all lights
                for (int i = 0; i < unity_LightCount; i++)
                {
                    float3 lightDir = normalize(_WorldSpaceLightPos[i].xyz);
                    float4 lightColor = _LightColor[i];

                    // Diffuse lighting
                    float diff = max(dot(i.worldNormal, lightDir), 0.0);
                    diffuse += _DiffuseColor * diff * lightColor;

                    // Specular lighting
                    float3 reflectDir = reflect(-lightDir, i.worldNormal);
                    float spec = pow(max(dot(i.viewDir, reflectDir), 0.0), _Shininess * 128.0);
                    specular += _SpecularColor * spec * lightColor;
                }

                // Calculate shadow factor
                float shadow = SHADOW_ATTENUATION(i.shadowCoord);

                // Combine lighting
                float4 lighting = ambient + (diffuse + specular) * shadow;

                // Apply the interpolated color
                return texColor * lighting;
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

4.3 支持环境光遮蔽（AO）

为了支持环境光遮蔽，我们可以使用预计算的AO贴图或屏幕空间环境光遮蔽（SSAO）。以下是一个简单的AO贴图示例：

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

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 pos : SV_POSITION;
                float3 worldPos : TEXCOORD1;
                float3 worldNormal : TEXCOORD2;
                float3 viewDir : TEXCOORD3;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            sampler2D _NormalMap;
            float4 _NormalMap_ST;
            sampler2D _AOMap;
            float4 _AOMap_ST;
            float4 _AmbientColor;
            float4 _DiffuseColor;
            float4 _SpecularColor;
            float _Shininess;

            v2f vert (appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);

                // Transform normal to world space
                float3 worldNormal = normalize(mul(v.normal, (float3x3)unity_WorldToObject));

                // Sample normal map
                float3 normalMap = UnpackNormal(tex2D(_NormalMap, TRANSFORM_TEX(v.uv, _NormalMap)));
                worldNormal = normalize(mul(normalMap, (float3x3)unity_WorldToObject));

                // Calculate world position and view direction
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                o.worldNormal = worldNormal;
                o.viewDir = normalize(_WorldSpaceCameraPos - o.worldPos);

                return o;
            }

            float4 frag (v2f i) : SV_Target
            {
                // Sample the texture
                float4 texColor = tex2D(_MainTex, i.uv);

                // Sample the AO map
                float ao = tex2D(_AOMap, i.uv).r;

                // Initialize lighting
                float4 ambient = _AmbientColor * ao;
                float4 diffuse = 0;
                float4 specular = 0;

                // Loop through all lights
                for (int i = 0; i < unity_LightCount; i++)
                {
                    float3 lightDir = normalize(_WorldSpaceLightPos[i].xyz);
                    float4 lightColor = _LightColor[i];

                    // Diffuse lighting
                    float diff = max(dot(i.worldNormal, lightDir), 0.0);
                    diffuse += _DiffuseColor * diff * lightColor;

                    // Specular lighting
                    float3 reflectDir = reflect(-lightDir, i.worldNormal);
                    float spec = pow(max(dot(i.viewDir, reflectDir), 0.0), _Shininess * 128.0);
                    specular += _SpecularColor * spec * lightColor;
                }

                // Combine lighting
                float4 lighting = ambient + diffuse + specular;

                // Apply the interpolated color
                return texColor * lighting;
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

好的，我们继续完成这个包含次表面散射（SSS）效果的 Shader。

                // Transform normal to world space
                float3 worldNormal = normalize(mul(v.normal, (float3x3)unity_WorldToObject));

                // Sample normal map
                float3 normalMap = UnpackNormal(tex2D(_NormalMap, TRANSFORM_TEX(v.uv, _NormalMap)));
                worldNormal = normalize(mul(normalMap, (float3x3)unity_WorldToObject));

                // Calculate world position and view direction
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                o.worldNormal = worldNormal;
                o.viewDir = normalize(_WorldSpaceCameraPos - o.worldPos);

                return o;
            }

            float4 frag (v2f i) : SV_Target
            {
                // Sample the texture
                float4 texColor = tex2D(_MainTex, i.uv);

                // Initialize lighting
                float4 ambient = _AmbientColor;
                float4 diffuse = 0;
                float4 specular = 0;
                float4 subsurface = 0;

                // Loop through all lights
                for (int j = 0; j < unity_LightCount; j++)
                {
                    float3 lightDir = normalize(_WorldSpaceLightPos[j].xyz);
                    float4 lightColor = _LightColor[j];

                    // Diffuse lighting
                    float diff = max(dot(i.worldNormal, lightDir), 0.0);
                    diffuse += _DiffuseColor * diff * lightColor;

                    // Specular lighting
                    float3 reflectDir = reflect(-lightDir, i.worldNormal);
                    float spec = pow(max(dot(i.viewDir, reflectDir), 0.0), _Shininess * 128.0);
                    specular += _SpecularColor * spec * lightColor;

                    // Subsurface scattering
                    float3 lightToSurface = normalize(i.worldPos - _WorldSpaceLightPos[j].xyz);
                    float subsurfaceFactor = max(dot(i.worldNormal, lightToSurface), 0.0);
                    subsurface += _SubsurfaceColor * subsurfaceFactor * lightColor * _SubsurfaceScale;
                }

                // Combine lighting
                float4 lighting = ambient + diffuse + specular + subsurface;

                // Apply the interpolated color
                return texColor * lighting;
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

4.7 支持环境光遮蔽（AO）

环境光遮蔽（Ambient Occlusion, AO）是模拟环境光在凹陷区域被遮挡的效果。以下是一个包含环境光遮蔽的 Shader 示例：

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

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 pos : SV_POSITION;
                float3 worldPos : TEXCOORD1;
                float3 worldNormal : TEXCOORD2;
                float3 viewDir : TEXCOORD3;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            sampler2D _NormalMap;
            float4 _NormalMap_ST;
            sampler2D _OcclusionMap;
            float4 _OcclusionMap_ST;
            float4 _AmbientColor;
            float4 _DiffuseColor;
            float4 _SpecularColor;
            float _Shininess;

            v2f vert (appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);

                // Transform normal to world space
                float3 worldNormal = normalize(mul(v.normal, (float3x3)unity_WorldToObject));

                // Sample normal map
                float3 normalMap = UnpackNormal(tex2D(_NormalMap, TRANSFORM_TEX(v.uv, _NormalMap)));
                worldNormal = normalize(mul(normalMap, (float3x3)unity_WorldToObject));

                // Calculate world position and view direction
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                o.worldNormal = worldNormal;
                o.viewDir = normalize(_WorldSpaceCameraPos - o.worldPos);

                return o;
            }

            float4 frag (v2f i) : SV_Target
            {
                // Sample the texture
                float4 texColor = tex2D(_MainTex, i.uv);

                // Sample the occlusion map
                float occlusion = tex2D(_OcclusionMap, i.uv).r;

                // Initialize lighting
                float4 ambient = _AmbientColor * occlusion;
                float4 diffuse = 0;
                float4 specular = 0;

                // Loop through all lights
                for (int j = 0; j < unity_LightCount; j++)
                {
                    float3 lightDir = normalize(_WorldSpaceLightPos[j].xyz);
                    float4 lightColor = _LightColor[j];

                    // Diffuse lighting
                    float diff = max(dot(i.worldNormal, lightDir), 0.0);
                    diffuse += _DiffuseColor * diff * lightColor;

                    // Specular lighting
                    float3 reflectDir = reflect(-lightDir, i.worldNormal);
                    float spec = pow(max(dot(i.viewDir, reflectDir), 0.0), _Shininess * 128.0);
                    specular += _SpecularColor * spec * lightColor;
                }

                // Combine lighting
                float4 lighting = ambient + diffuse + specular;

                // Apply the interpolated color
                return texColor * lighting;
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

总结

通过以上步骤，我们已经实现了一个包含多种高级光照效果的自定义 Shader，包括反射和折射、法线贴图和视差映射、次表面散射以及环境光遮蔽。这些技术可以显著提升材质的真实感和细节表现，使其达到商业化级别的效果。

希望这些示例对你有所帮助！如果你有任何进一步的问题或需要更多的示例，请随时告诉我。

你一身傲骨怎能输
关注
专栏目录
shader中的常用函数
SW_29的博客
06-03 1021
1.Step(a,x) 如果x<a返回0；如果x>或=a返回1 2.lerp(a,b,f)
Unity Shader 自定义函数
成长ing中的w的专栏
01-07 1465
为了避免混乱，使代码结构清晰明朗，需要自定义一些函数模块 Shader "Unlit/FunctionShader" { Properties { _Color("Color",Color) = (1,1,1,1) } SubShader { Pass { CGPROGRAM #pragma vertex vert #pragma fragment
一文掌握OpenGL的shader内置函数
徐福记456
10-24 4573
OpenGL ES有大量的GLSL内置函数，包括：三角函数、指数函数、通用函数、浮点函数、几何函数、矩阵函数、矢量关系函数、纹理函数、原子函数、图像函数、插值函数、着色器函数等。
unity shader中一些常用函数总结
小孔明的专栏
04-29 1481
参考网址：http://www.manew.com/forum.php?mod=viewthread&tid=97247&extra=page%3D2%26filter%3Dtypeid%26typeid%3D132 蛮牛的专栏可以常看看： http://www.manew.com/forum-47-132-2.html 第1个函数：step函数 Shader "MyShader/...
shader函数整理
qq_34863873的博客
11-11 3649
1 pow 即x的几次方 使用： pow(x,1) 后面的参数一般会暴露出去 后面参数越大增长速率越高 例子： pow(x,1) pow(x,2) pow(x,3) 2 sqrt 开根号 sqrt(x) 等同于 pow(x,0.5) 也是后面的参数越大增长速率越快 3 sin 周期函数（如小球来回移动） 3*sin(x*2+1)+4 *2波动频率会加快 +1往右偏移 *3整个波动幅度增大 +4整个波动往上移动 ...
shader 编程中常用函数
IT_ZB的博客
11-03 1136
1  角度和三角函数          标识为angle的函数参数假定以弧度为单位。这些函数不可能出现被0除的情况，如果被除数为0，结果是未定义的。   radian函数是将角度转换为弧度，degrees函数是将弧度转换为角度。sin, cos, tan都是标准的三角函数。asin, acos, atan是反三角函数。genType有点像面向对象中泛型，即如果genType
Shader中的 mul()函数解释
Sevol_Y
09-09 5084
查阅资料可得到下面信息，通常用来矩阵转换 mul(M, N) 计算两个矩阵相乘，如果M为AxB阶矩阵，N为BxC阶矩阵，则返回AxC阶矩阵。下面两个函数为其重载函数 mul(M, v) 计算矩阵和向量相乘 mul(v, M) 计算向量和矩阵相乘 例子： v2f vert(appdata v) { v2f o; float3 worldPos = mul(UNITY_MATRIX_MVP, v.vertex);//从模型...
Shader 常用函数总结
sinat_34014668的博客
10-30 6177
Shader 常用函数总结
Shader内置函数（方便自己看）
SnoopyNa2Co3的博客
01-02 2666
一、内置包含文件 　　Unity中有类似于C++的包含文件.cginc，在编写Shader时我们可以使用#include指令把这些文件包含进来 这样我们就可以使用Unity为我们提供的一些非常好用的函数、宏和变量。 例如：#include"UnityCG.cginc" 包含文件的位置：根目录\Editor\Data\CGIncludes 知识点1：以下是Unity中常用包含文件： 　　文件...
Unity Shader常用内置函数
men_tou的博客
12-09 3212
函数 功能 示例 abs 绝对值 frac 取小数 floor 向下取整 ceil 向上取整 max 取最大值 min 取最小值 power 次方 power(a, 3) rcp 倒数 exp ene^nen exp2 2n2^n2n fmod 取余 fmod(5, 2) saturate 把值限制在0-1 clamp 把值限制在起始值和结束值之间 clamp(x, start, end) sqrt 平方根 rsq...
GLSL language integration.rar vs2017shader程序高亮显示
10-14
在“GLSL language integration.rar vs2017 shader程序高亮显示”中，我们关注的是如何在VS2017中为GLSL代码提供更好的编辑支持。这个压缩包文件可能包含一个插件或扩展，它为VS2017添加了特定的功能，如GLSL代码的...
【Unity】学习Shader中常用的函数方法
热门推荐
天生爱赞美的博客
10-31 2万+
今天给大家列出来shader中常用的一些函数，函数后面有释义，大家可以打印出来，或者在写shader的时候来这篇文章查阅，看看你需要用到哪些。 Cg提供了一系列内建的标准函数。这些函数用于执行数学上的通用计算或通用算法（纹理映射等）， 有些函数直接和 GPU 指令相对应，所以执行效率非常高。 这些函数来源于文档，我为大家筛选出了常用的，去掉了基本用不到的函数。 数
Shader中使用距离函数（Distance Function）绘制二维图形
王王王渣渣的博客
04-16 4838
https://blog.csdn.net/lanchunhui/article/details/50887417 https://blog.csdn.net/qq_41368247/article/details/106194092 https://blog.csdn.net/xiaowo123456/article/details/89204203 https://zhuanlan.zhihu.com/p/345227118 https://zhuanlan.zhihu....
【UnityShader】常用函数（数学函数、纹理映射函数）
小蜗牛
05-23 1516
数学函数 函数 描述 abs(x) 返回输入参数的绝对值 acos(x) 反余切函数，输入参数范围为[-1,1]， 返回[0,π]区间的角度值 all(x) 如果输入参数均不为0，则返回ture； 否则返回flase。&&运算 any(x) 输入参数只要有其中一个不为0，则返回true asin(x) 反正弦函数,输入参数取值区间为，返回角度值范围为[−π/2,π/2] atan(x) 反正切函数，返回角度值范围为[−π/2,π/2] atan2(y,
谷歌的 GameNGen：无需游戏引擎，人工智能模拟 “毁灭战士“，开辟新天地
weixin_41446370的博客
08-30 4429
谷歌公司的研究人员创建了一个神经网络，可以在不使用传统游戏引擎的情况下生成经典射击游戏《毁灭战士》的实时游戏，从而实现了人工智能领域的一个重要里程碑。这个名为 GameNGen 的系统标志着人工智能向前迈出了重要一步，它能在单芯片上以每秒 20 帧的速度生成可玩的游戏，每一帧都由扩散模型预测。"研究人员在发表在预印本服务器上的论文中写道："我们展示了 GameNGen，这是第一个完全由神经模型驱动的游戏引擎，它能在长轨迹上与复杂环境进行高质量的实时交互。
考研复习-英语二真题考试题集-带答案
09-14
英语二考研真题复习资料，带答案版
2024中美独角兽公司发展分析报告.pdf
09-14
全球各大洲独角兽企业分布、中美独角兽企业对比（数量、估值、新增及退榜情况、行业分布、所在城市）、
C++ 中的异步编程模型是什么
09-14
在C++中，异步编程模型是处理并发任务、提高程序性能和响应性的关键技术。以下是C++中实现异步编程的几种主要方式： 每种异步编程模型都有其适用场景和优缺点。选择合适的模型可以提高代码的可读性、可维护性和性能。随着C++标准的不断发展，异步编程模型也在不断进化，为开发者提供了更多的工具和选择。 在实际开发中，应根据具体需求选择合适的异步编程模型。例如，对于简单的异步任务，回调函数可能是最直接的选择；而对于需要结构化错误处理和结果获取的复杂异步任务，std::async和std::future可能更合适；在需要高效资源管理的场景下，线程池是一个不错的选择；而对于需要编写大量异步代码的现代应用程序，协程提供了一种更简洁、更直观的解决方案。 总之，C++中的异步编程模型是多核和高并发环境下提高程序性能的重要工具。通过合理使用这些模型，开发者可以构建出更高效、更可靠的软件系统。
正则表达式Regex是一种文本模式.docx
最新发布
09-14
正则表达式（Regular Expression，简称Regex或Regexp）是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。正则表达式是强大的文本处理工具，广泛用于搜索、编辑或操作文本和数据。 基本组成 普通字符：大多数字符，包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号，都是普通字符。正则表达式中的普通字符表示它们自身。例如，正则表达式test会匹配字符串"test"。 特殊字符（元字符）：一些字符在正则表达式中具有特殊的意义，如^、$、.、*、+、?、{、}、[、]、|、\等。这些特殊字符用于表示在搜索文本时要匹配的一个或多个字符。例如，.匹配除换行符之外的任何单个字符。 字符类：字符类允许你指定一组字符中的任何一个字符。例如，[abc]匹配"a"、"b"或"c"中的任意一个字符。你也可以使用范围，如[a-z]匹配任何小写字母。 预定义字符类：正则表达式提供了一些预定义字符类，用于匹配常见的字符集合。例如，\d匹配任何数字（等价于[0-9]），\s匹配任
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你一身傲骨怎能输

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值