unity-shader-tutorial-parallaxMap

buildin效果图

urp效果图

ParallaxMap.shader

ParallaxMap.shader

Shader "HHF/Tutorial/ParallaxMap"
{
    Properties
    {
        [MainTexture]_BaseMap("BaseMap", 2D) = "white" {}
        [Normal]_NormalMap("NormalMap",2D) = "bump"{}
        _ParallaxMap("ParallaxMap",2D) = "white"{}
        [KeywordEnum(Default,Limit,Steep,Relief,POM)]_ParallaxType("ParallaxType",int)=0
        _ParallaxStrength("ParallaxStrength",range(0,1)) = 1
        _ParallaxAmount("ParallaxAmount",int) = 10
    }

    SubShader
    {
        Tags { "Queue"="Geometry" "RenderType" = "Opaque" "IgnoreProjector" = "True" "RenderPipeline" = "UniversalPipeline" }

        Pass
        {
            HLSLPROGRAM
            // Required to compile gles 2.0 with standard srp library
            #pragma prefer_hlslcc gles
            #pragma exclude_renderers d3d11_9x
            #pragma vertex vert
            #pragma fragment frag
            #pragma shader_feature _ _PARALLAXTYPE_DEFAULT _PARALLAXTYPE_LIMIT _PARALLAXTYPE_STEEP _PARALLAXTYPE_RELIEF _PARALLAXTYPE_POM
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/UnityInstancing.hlsl"


            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                half3 normal : NORMAL;
                half4 tangent : TANGENT;
            };

            struct v2f
            {
                float4 positionCS : SV_POSITION;
                float2 uv : TEXCOORD0;
                half4 normalWS : TEXCOORD1;
                half4 tangentWS : TEXCOORD2;
                half4 bitangentWS : TEXCOORD3;
            };

            CBUFFER_START(UnityPerMaterial)
            half4 _BaseColor;
            float4 _BaseMap_ST;
            half _ParallaxStrength;
            half _ParallaxAmount;
            CBUFFER_END
            TEXTURE2D (_BaseMap);SAMPLER(sampler_BaseMap);
            TEXTURE2D (_NormalMap);SAMPLER(sampler_NormalMap);
            TEXTURE2D (_ParallaxMap);SAMPLER(sampler_ParallaxMap);

            v2f vert(appdata v)
            {
                v2f o = (v2f)0;

                float3 positionWS = TransformObjectToWorld(v.vertex.xyz);
                o.positionCS = TransformObjectToHClip(v.vertex.xyz);
                o.uv = TRANSFORM_TEX(v.uv, _BaseMap);
                o.normalWS.xyz = TransformObjectToWorldNormal(v.normal);
                o.tangentWS.xyz = TransformObjectToWorldDir(v.tangent.xyz);
                half sign = v.tangent.w * GetOddNegativeScale();
                o.bitangentWS.xyz = cross(o.normalWS.xyz, o.tangentWS.xyz) * sign;
                o.tangentWS.w = positionWS.x;
                o.bitangentWS.w = positionWS.y;
                o.normalWS.w = positionWS.z;
                
                return o;
            }

            half4 frag(v2f i) : SV_Target
            {
                half4 c;

                float2 offset = 0;
                half3 V = normalize(float3(i.tangentWS.w,i.bitangentWS.w,i.normalWS.w) - _WorldSpaceCameraPos.xyz);
                V = mul(float3x3(i.tangentWS.xyz, i.bitangentWS.xyz, i.normalWS.xyz),V);

                #if _PARALLAXTYPE_DEFAULT
                    // 基本视差映射:T=V.xy*(H/V.z)
                    half parallaxMap = 1 - SAMPLE_TEXTURE2D(_ParallaxMap, sampler_ParallaxMap, i.uv).r;
                    offset = V.xy * (parallaxMap/-V.z) * _ParallaxStrength;
                #elif _PARALLAXTYPE_LIMIT
                    // 带偏移上限的视差映射:T=V.xy*H
                    half parallaxMap = 1 - SAMPLE_TEXTURE2D(_ParallaxMap, sampler_ParallaxMap, i.uv).r;
                    offset = V.xy * parallaxMap * _ParallaxStrength;
                #elif _PARALLAXTYPE_STEEP
                    // 陡峭视差映射
                    half currentDepth = 0;
                    half parallaxDepth = 0;
                    half heightStep = 1/_ParallaxAmount;
                    half2 offsetTemp = V.xy/-V.z * _ParallaxStrength;
                    for(int j=0;j<_ParallaxAmount;j++)
                    {
                        parallaxDepth = 1 - SAMPLE_TEXTURE2D_LOD(_ParallaxMap, sampler_ParallaxMap, i.uv + offset,0).r;
                        // 如果当前迭代的深度值>深度图中的深度值则退出循环
                        if(currentDepth>parallaxDepth)  break;

                        currentDepth += heightStep;
                        offset = offsetTemp * currentDepth;
                    }
                #elif _PARALLAXTYPE_RELIEF
                    // 浮雕视差映射
                    half currentDepth = 0;
                    half parallaxDepth = 0;
                    half heightStep = 1/_ParallaxAmount;
                    half2 offsetTemp = V.xy/-V.z * _ParallaxStrength;
                    for(int j=0;j<_ParallaxAmount;j++)
                    {
                        parallaxDepth = 1 - SAMPLE_TEXTURE2D_LOD(_ParallaxMap, sampler_ParallaxMap, i.uv + offset,0).r;
                        // 如果当前迭代的深度值>深度图中的深度值则退出循环
                        if(currentDepth>parallaxDepth)  break;

                        currentDepth += heightStep;
                        offset = offsetTemp * currentDepth;
                    }

                    for(int j = 0; j < 5; j++)
                    {
                        heightStep/=2;
                        
                        if(currentDepth>parallaxDepth)
                        currentDepth -= heightStep;
                        else
                        currentDepth += heightStep;

                        offset = offsetTemp * currentDepth;
                        parallaxDepth = 1 - SAMPLE_TEXTURE2D_LOD(_ParallaxMap, sampler_ParallaxMap, i.uv + offset,0).r;
                    }
                #elif _PARALLAXTYPE_POM
                    // 视差遮蔽映射
                    half currentDepth = 0;
                    half parallaxDepth = 0;
                    half preParallaxDepth = 0;
                    half heightStep = 1/_ParallaxAmount;
                    half2 offsetTemp = V.xy/-V.z * _ParallaxStrength;
                    for(int j=0;j<_ParallaxAmount;j++)
                    {
                        parallaxDepth = 1 - SAMPLE_TEXTURE2D_LOD(_ParallaxMap, sampler_ParallaxMap, i.uv + offset,0).r;
                        // 如果当前迭代的深度值>深度图中的深度值则退出循环
                        if(currentDepth>parallaxDepth)  break;

                        preParallaxDepth = parallaxDepth;
                        currentDepth += heightStep;
                        offset = offsetTemp * currentDepth;
                    }

                    half preDepth = currentDepth - heightStep;
                    half A_C = preDepth - preParallaxDepth;
                    half D_B = parallaxDepth - currentDepth;
                    half t = A_C/(D_B+A_C);
                    half height = lerp(preDepth,currentDepth,t);
                    offset = offsetTemp * height;
                #endif

                i.uv += offset;

                half4 baseMap = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv);
                c = baseMap;

                half3 normalMap = UnpackNormal(SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, i.uv));
                half3 normalWS = mul(normalMap,float3x3(i.tangentWS.xyz, i.bitangentWS.xyz, i.normalWS.xyz));

                Light mainLight = GetMainLight();
                half3 L = mainLight.direction;
                half NdotL = max(0.5,dot(normalWS,L));
                c *= NdotL;

                return c;
            }
            ENDHLSL
        }
    }

    SubShader
    {
        Tags { "Queue"="Geometry"  }

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma shader_feature _ _PARALLAXTYPE_DEFAULT _PARALLAXTYPE_LIMIT _PARALLAXTYPE_STEEP _PARALLAXTYPE_RELIEF _PARALLAXTYPE_POM
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                half3 normal : NORMAL;
                half4 tangent : TANGENT;
            };

            struct v2f
            {
                float4 positionCS : SV_POSITION;
                float2 uv : TEXCOORD0;
                half4 normalWS : TEXCOORD1;
                half4 tangentWS : TEXCOORD2;
                half4 bitangentWS : TEXCOORD3;
            };

            half4 _BaseColor;
            sampler2D _BaseMap; float4 _BaseMap_ST;
            sampler2D _NormalMap;
            sampler2D _ParallaxMap;
            half _ParallaxStrength;
            half _ParallaxAmount;

            v2f vert(appdata v)
            {
                v2f o = (v2f)0;

                float3 positionWS = mul(UNITY_MATRIX_M, v.vertex);
                o.positionCS = UnityObjectToClipPos(v.vertex.xyz);
                o.uv = TRANSFORM_TEX(v.uv, _BaseMap);
                o.normalWS.xyz = UnityObjectToWorldNormal(v.normal);
                o.tangentWS.xyz = UnityObjectToWorldDir(v.tangent);
                half sign = v.tangent.w * unity_WorldTransformParams.w;
                o.bitangentWS.xyz = cross(o.normalWS.xyz, o.tangentWS.xyz) * sign;
                o.tangentWS.w = positionWS.x;
                o.bitangentWS.w = positionWS.y;
                o.normalWS.w = positionWS.z;
                return o;
            }

            half4 frag(v2f i) : SV_Target
            {
                half4 c;

                float2 offset = 0;
                half3 V = normalize(float3(i.tangentWS.w,i.bitangentWS.w,i.normalWS.w) - _WorldSpaceCameraPos.xyz);
                V = mul(float3x3(i.tangentWS.xyz, i.bitangentWS.xyz, i.normalWS.xyz),V);

                #if _PARALLAXTYPE_DEFAULT
                    // 基本视差映射:T=V.xy*(H/V.z)
                    half parallaxMap = 1 - tex2D(_ParallaxMap, i.uv).r;
                    offset = V.xy * (parallaxMap/-V.z) * _ParallaxStrength;
                #elif _PARALLAXTYPE_LIMIT
                    // 带偏移上限的视差映射:T=V.xy*H
                    half parallaxMap = 1 - tex2D(_ParallaxMap, i.uv).r;
                    offset = V.xy * parallaxMap * _ParallaxStrength;
                #elif _PARALLAXTYPE_STEEP
                    // 陡峭视差映射
                    half currentDepth = 0;
                    half parallaxDepth = 0;
                    half heightStep = 1/_ParallaxAmount;
                    half2 offsetTemp = V.xy/-V.z * _ParallaxStrength;
                    // [unroll(30)]
                    // 不使用tex2Dlod，使用tex2D需要加上unroll进行展开
                    for(int j=0;j<_ParallaxAmount;j++)
                    {
                        float4 uvMipmap = float4(i.uv + offset, 0, 0); 
                        parallaxDepth = 1 - tex2Dlod(_ParallaxMap, uvMipmap).r;
                        // 如果当前迭代的深度值>深度图中的深度值则退出循环
                        if(currentDepth>parallaxDepth)  break;

                        currentDepth += heightStep;
                        offset = offsetTemp * currentDepth;
                    }
                #elif _PARALLAXTYPE_RELIEF
                    // 浮雕视差映射
                    half currentDepth = 0;
                    half parallaxDepth = 0;
                    half heightStep = 1/_ParallaxAmount;
                    half2 offsetTemp = V.xy/-V.z * _ParallaxStrength;
                    for(int j=0;j<_ParallaxAmount;j++)
                    {
                        float4 uvMipmap = float4(i.uv + offset, 0, 0); 
                        parallaxDepth = 1 - tex2Dlod(_ParallaxMap, uvMipmap).r;
                        // 如果当前迭代的深度值>深度图中的深度值则退出循环
                        if(currentDepth>parallaxDepth)  break;

                        currentDepth += heightStep;
                        offset = offsetTemp * currentDepth;
                    }

                    for(int j = 0; j < 5; j++)
                    {
                        heightStep/=2;
                        
                        if(currentDepth>parallaxDepth)
                        currentDepth -= heightStep;
                        else
                        currentDepth += heightStep;

                        offset = offsetTemp * currentDepth;
                        parallaxDepth = 1 - tex2D(_ParallaxMap, i.uv + offset).r;
                    }
                #elif _PARALLAXTYPE_POM
                    // 视差遮蔽映射
                    half currentDepth = 0;
                    half parallaxDepth = 0;
                    half preParallaxDepth = 0;
                    half heightStep = 1/_ParallaxAmount;
                    half2 offsetTemp = V.xy/-V.z * _ParallaxStrength;
                    for(int j=0;j<_ParallaxAmount;j++)
                    {
                        float4 uvMipmap = float4(i.uv + offset, 0, 0); 
                        parallaxDepth = 1 - tex2Dlod(_ParallaxMap, uvMipmap).r;
                        // 如果当前迭代的深度值>深度图中的深度值则退出循环
                        if(currentDepth>parallaxDepth)  break;

                        preParallaxDepth = parallaxDepth;
                        currentDepth += heightStep;
                        offset = offsetTemp * currentDepth;
                    }

                    half preDepth = currentDepth - heightStep;
                    half A_C = preDepth - preParallaxDepth;
                    half D_B = parallaxDepth - currentDepth;
                    half t = A_C/(D_B+A_C);
                    half height = lerp(preDepth,currentDepth,t);
                    offset = offsetTemp * height;
                #endif

                i.uv += offset;

                half4 baseMap = tex2D(_BaseMap, i.uv);
                c = baseMap;

                half3 normalMap = UnpackNormal(tex2D(_NormalMap, i.uv));
                half3 normalWS = mul(normalMap,float3x3(i.tangentWS.xyz, i.bitangentWS.xyz, i.normalWS.xyz));

                half3 L = _WorldSpaceLightPos0;
                half NdotL = max(0.5,dot(normalWS,L));
                c *= NdotL;

                return c;
            }

            ENDCG
        }
    }   
        
}