视差映射优化—陡峭视差映射

陡峭视差映射原理

朴素的陡峭视差只采样一次，陡峭视差映射基本想法是多次检测来获得比较精确的值。
主要方法是按照朴素采样得到一个总偏移量（因为交点一定不会超过这个偏移量）之后，将高度按步进次数分层数，计算每一步的偏移量，从得到的初始UV值，每一步原始UV值加上每一步的偏移量，原始高度加上每一步的分层值，然后采样得到贴图上的高度值，比较当前层数和高度值，可以发现当高度值小于层数一定是不相交的，靠这样步进可以得到一个较为精确的偏移值。

Shader代码实现

[title] [lang:Shaderlap] [url] [link text] [additional options]

Shader "Unlit/Steep Parallax Normal"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Bump("Normal Map",2D) = "bump"{}
        _High("High Map",2D) = "white"{}

        _BumpScale("Normal Scale",Range(0,2)) = 1 
        _HighScale("High Scale",Range(0,1)) = 0.15

        _SteepNum("SteepNum",Range(0,24)) = 10

        _Specular("Specular",Color) = (1,1,1,1)
        _Gloss("Gloss",Range(0,1)) = 0.5
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        Pass
        {
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            #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.universal/ShaderLibrary/NormalReconstruction.hlsl"

            TEXTURE2D(_MainTex);  SAMPLER(sampler_MainTex);
            TEXTURE2D(_Bump);  SAMPLER(sampler_Bump);
            TEXTURE2D(_High);  SAMPLER(sampler_High);

            CBUFFER_START(UnityPerMaterial)
            float4 _MainTex_ST;
            float4 _Bump_ST;
            float4 _High_ST;
            float _BumpScale;
            float _HighScale;
            int _SteepNum;
            float4 _Specular;
            float _Gloss;
            CBUFFER_END

            struct Attributes{
                float4 positionOS : POSITION;
                float3 normalOS : NORMAL;
                float4 tangentOS : TANGENT;
                float2 uv : TEXCOORD0;
            
            };
            struct Varyings{
                float4 positionCS : SV_POSITION;
                float2 uv : TEXCOORD0;
                float3 normalWS : TEXCOORD1;
                float3 viewdirTS : TEXCOORD2;
                float4 tangentWS : TEXCOORD3;
                float3 binormalWS : TEXCOORD4;
                float3 worldpos : TEXCOORD5;
            };
				//核心算法
            float2 SteepParallaxMapping(float2 uv,real3 viewdirTS,float HighScale){
                viewdirTS = normalize(viewdirTS);
				//得到每一层的高度
                float SteepHigh = 1.0 / float(_SteepNum);
                //设定最上层为0；
                float CurLayerHigh = 0.0;
                //得到总偏移
                float TotalOffset = (HighScale * viewdirTS.xy) / (abs(viewdirTS.z) + 0.001);
                //计算每一步的偏移值
                float PerSteep = TotalOffset / _SteepNum;
                //限制循环次数最大为24
                [unroll(24)] 
	                //主循环
                for(int i=0; i<_SteepNum ; i++){
			        //先得到现在的高度值然后比较
                    float CurHighVale = SAMPLE_TEXTURE2D(_High,sampler_High,uv).r;

                    if(CurHighVale > CurLayerHigh){
	                    //如果成功了表示撞墙了，需要退回一步
                        uv = uv - PerSteep;
                        //返回结束函数
                        return uv;
                    }
                    //不通过不是近似值就继续偏移继续走到下一步
                    CurLayerHigh += SteepHigh;
                    uv += PerSteep;               
                }
                return uv;
            }

            Varyings vert (Attributes v)
            {
                Varyings o;

                o.uv = TRANSFORM_TEX(v.uv,_MainTex);

                o.positionCS = TransformObjectToHClip(v.positionOS);
                o.normalWS = TransformObjectToWorldNormal(v.normalOS);
                o.tangentWS.xyz = TransformObjectToWorldDir(v.tangentOS).xyz;
                o.binormalWS = cross(o.tangentWS.xyz,o.normalWS) * v.tangentOS.w;
                o.worldpos = TransformObjectToWorld(v.positionOS);

                float3x3 TBN = float3x3(o.tangentWS.xyz,o.binormalWS,o.normalWS);
                float3 viewdirWS = GetCameraPositionWS() - o.worldpos;
                o.viewdirTS = mul(viewdirWS,TBN);
                return o;
            }
            float4 frag(Varyings i) : SV_Target
            {
                float2 UVoffset = SteepParallaxMapping(i.uv,i.viewdirTS,_HighScale);
//UnpackNormalScale（）函数下面是它内部写法
//fixed3 UnpackScaleNormal (fixed4 packednormal, float bumpScale)
//{
    // 1. 判断平台：如果不是使用 DXT5nm 压缩格式（如部分OpenGL ES平台），直接返回RGB法线
    //#if defined(UNITY_NO_DXT5nm)
        return packednormal.xyz * 2 - 1;
    //#else
        // 2. 解码 DXT5nm / BC5 格式（主流PC和主机平台）
        // 这种格式将法线的 X 存储在 W 通道(A)，Y 存储在 Y 通道(G)
        // 注意：这里根据引擎版本不同，可能是 unpacked.wy 或 packednormal.xy * //packednormal.w
        // 以下是最常见的实现方式：
        
        // 重构法线的 X 和 Y，将 [0,1] 范围映射回 [-1,1]
        //fixed3 normal;
        //normal.xy = (packednormal.wy * 2 - 1);
        
        // 3. 应用缩放（仅Shader Model 3.0及以上支持）
        //#if (SHADER_TARGET >= 30)
            normal.xy *= bumpScale;
        //#endif
        
        // 4. 重建 Z 分量（由于法线是单位向量，Z = sqrt(1 - X^2 - Y^2)）
        //normal.z = sqrt(1.0 - saturate(dot(normal.xy, normal.xy)));
        
        //return normal;
    //#endif
//}

				//用得到的UV采样
                float3 normalTS = UnpackNormalScale(SAMPLE_TEXTURE2D(_Bump,sampler_Bump,UVoffset),_BumpScale);
                float3x3 TBN = float3x3(i.tangentWS.xyz,i.binormalWS,i.normalWS);
                float3 worldnormal = normalize(mul(TBN,normalTS));

                float3 albedo = SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,UVoffset);

                Light mainlight = GetMainLight();
                float3 lightdir = mainlight.direction;
                float3 lightcolor = mainlight.color;
                float3 viewdirWS = GetCameraPositionWS() - i.worldpos;

                float3 ambient = SampleSH(worldnormal) * albedo;

                float3 NdotL = saturate(dot(worldnormal,lightdir));
                float3 diffuse = lightcolor * albedo * NdotL;

                float3 halfdir = normalize(viewdirWS+lightdir);
                float3 HdotN = saturate(dot(halfdir,worldnormal));
                float3 specular = lightcolor * _Specular.rgb * pow(HdotN,_Gloss*256);

                float4 finalcolor = float4(specular + diffuse + ambient,1.0);

                return finalcolor;
            }

            ENDHLSL
        }
    }
}

疑点解析

Scale控制实现原理

法线贴图控制实现：normal.xy *= bumpScale;
为什么是XY方向乘以呢？
我们在黑色的模型平面上的一点A，采样法线贴图，我们知道法线贴图存储的法线是在A点的切线空间下的，我们可以知道当我们给XY加权，因为法线是要归一化使用的，于是法线就从绿色的变成了黄色的，可以表示的深度就更深。

高度贴图是实现：TotalOffset = (HighScale * viewdirTS.xy) / (abs(viewdirTS.z) + 0.001);
由公式可以知道我们还是给XY加权，这样可以降低V.z的值，这样偏移值就增大。（可以看视差映射那一张查看详细的推到）

$$\text{Offset} = V_{xy} \times \frac{H}{V.z}$$

UV偏移后，采样到的颜色像素发生了“错位”。高区域（height高）的像素向视线方向滑动，低区域的像素反向滑动。这种像素错位欺骗你的眼睛，让你**“感觉”表面有高低起伏（深度）。
所以，_HeightScale 控制的不是真正的几何深度，而是视觉上错觉强烈的程度**。_HeightScale = 0 时无错位，表面看起来就是平的；_HeightScale 越大，错位越大，“看起来”凹陷越深或凸起越高。