VertexNormalInputs GetVertexNormalInputs(float3 normalOS, float4 tangentOS)
{
    VertexNormalInputs tbn;

    // mikkts space compliant. only normalize when extracting normal at frag.
    real sign = real(tangentOS.w) * GetOddNegativeScale();
    tbn.normalWS = TransformObjectToWorldNormal(normalOS);
    tbn.tangentWS = real3(TransformObjectToWorldDir(tangentOS.xyz));
    tbn.bitangentWS = real3(cross(tbn.normalWS, float3(tbn.tangentWS))) * sign;
    return tbn;
}

// 把切线空间的三根轴（T/B/N）和法线贴图扰动后的法线显示成颜色，用来检查网格切线是否正确。
Shader "Cookbook/Ch07/TBNDebug"
{
    Properties
    {
        [Enum(Tangent,0,Bitangent,1,Normal,2,MappedNormal,3)] _Mode("Show", Float) = 0
        [NoScaleOffset][Normal] _BumpMap("Normal Map", 2D) = "bump" {}
        _BumpScale("Normal Scale", Range(0, 2)) = 1
        _Tiling("Tiling", Vector) = (1, 1, 0, 0)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" "Queue"="Geometry" }

        HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        CBUFFER_START(UnityPerMaterial)
            float4 _Tiling;
            half _Mode;
            half _BumpScale;
        CBUFFER_END
        ENDHLSL

        Pass
        {
            Name "Unlit"
            Tags { "LightMode"="UniversalForwardOnly" }
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            TEXTURE2D(_BumpMap); SAMPLER(sampler_BumpMap);

            struct Attributes
            {
                float4 positionOS : POSITION;
                float3 normalOS   : NORMAL;
                float4 tangentOS  : TANGENT;     // xyz = 切线，w = 副切线的朝向（±1）
                float2 uv         : TEXCOORD0;
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float2 uv         : TEXCOORD0;
                float3 normalWS   : TEXCOORD1;
                float4 tangentWS  : TEXCOORD2;   // w 保存 sign，副切线在片元里重建
            };

            Varyings vert(Attributes input)
            {
                Varyings o;
                o.positionCS = TransformObjectToHClip(input.positionOS.xyz);
                o.uv = input.uv * _Tiling.xy + _Tiling.zw;
                // GetVertexNormalInputs 会：法线用逆转置矩阵变换、切线按方向变换、
                // 副切线 = cross(N, T) * tangentOS.w * GetOddNegativeScale()
                VertexNormalInputs n = GetVertexNormalInputs(input.normalOS, input.tangentOS);
                o.normalWS = n.normalWS;
                o.tangentWS = float4(n.tangentWS, input.tangentOS.w * GetOddNegativeScale());
                return o;
            }

            half4 frag(Varyings i) : SV_Target
            {
                // 插值之后长度不再为 1，先归一化（MikkTSpace 的约定是在像素里才归一化）
                float3 N = normalize(i.normalWS);
                float3 T = normalize(i.tangentWS.xyz);
                float3 B = i.tangentWS.w * cross(N, T);
                float3 c;
                if (_Mode < 0.5)      c = T;
                else if (_Mode < 1.5) c = B;
                else if (_Mode < 2.5) c = N;
                else
                {
                    half3 nTS = UnpackNormalScale(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, i.uv), _BumpScale);
                    // 行向量 T/B/N 组成的矩阵；mul(向量, 矩阵) = nTS.x*T + nTS.y*B + nTS.z*N
                    c = normalize(TransformTangentToWorld(nTS, half3x3(T, B, N)));
                }
                return half4(c * 0.5 + 0.5, 1);   // [-1,1] 映射到 [0,1] 才能当颜色看
            }
            ENDHLSL
        }

        Pass
        {
            Name "DepthOnly"
            Tags { "LightMode"="DepthOnly" }
            ZWrite On ColorMask R
            HLSLPROGRAM
            #pragma vertex Ch07DepthVert
            #pragma fragment Ch07NullFrag
            #include "Assets/Cookbook/Ch07/Ch07Common.hlsl"
            ENDHLSL
        }
    }
}

Varyings vert(Attributes input)
{
    Varyings o;
    o.positionCS = TransformObjectToHClip(input.positionOS.xyz);
    o.uv = input.uv * _Tiling.xy + _Tiling.zw;
    // GetVertexNormalInputs 会：法线用逆转置矩阵变换、切线按方向变换、
    // 副切线 = cross(N, T) * tangentOS.w * GetOddNegativeScale()
    VertexNormalInputs n = GetVertexNormalInputs(input.normalOS, input.tangentOS);
    o.normalWS = n.normalWS;
    o.tangentWS = float4(n.tangentWS, input.tangentOS.w * GetOddNegativeScale());
    return o;
}

half4 frag(Varyings i) : SV_Target
{
    // 插值之后长度不再为 1，先归一化（MikkTSpace 的约定是在像素里才归一化）
    float3 N = normalize(i.normalWS);
    float3 T = normalize(i.tangentWS.xyz);
    float3 B = i.tangentWS.w * cross(N, T);
    float3 c;
    if (_Mode < 0.5)      c = T;
    else if (_Mode < 1.5) c = B;
    else if (_Mode < 2.5) c = N;
    else
    {
        half3 nTS = UnpackNormalScale(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, i.uv), _BumpScale);
        // 行向量 T/B/N 组成的矩阵；mul(向量, 矩阵) = nTS.x*T + nTS.y*B + nTS.z*N
        c = normalize(TransformTangentToWorld(nTS, half3x3(T, B, N)));
    }
    return half4(c * 0.5 + 0.5, 1);   // [-1,1] 映射到 [0,1] 才能当颜色看
}

real3 UnpackNormalAG(real4 packedNormal, real scale = 1.0)
{
    real3 normal;
    normal.xy = packedNormal.ag * 2.0 - 1.0;
    normal.z = max(1.0e-16, sqrt(1.0 - saturate(dot(normal.xy, normal.xy))));
    // must scale after reconstruction of normal.z ...
    normal.xy *= scale;
    return normal;
}

// Unpack normal as DXT5nm (1, y, 0, x) or BC5 (x, y, 0, 1)
real3 UnpackNormalmapRGorAG(real4 packedNormal, real scale = 1.0)
{
    // Convert to (?, y, 0, x)
    packedNormal.a *= packedNormal.r;
    return UnpackNormalAG(packedNormal, scale);
}

real3 UnpackNormalScale(real4 packedNormal, real bumpScale)
{
#if defined(UNITY_ASTC_NORMALMAP_ENCODING)
    return UnpackNormalAG(packedNormal, bumpScale);
#elif defined(UNITY_NO_DXT5nm)
    return UnpackNormalRGB(packedNormal, bumpScale);
#else
    return UnpackNormalmapRGorAG(packedNormal, bumpScale);
#endif
}

// positionWS/normalWS：世界空间位置与（已经过法线贴图扰动的）法线
// gloss：0~1 映射到高光指数 2~2048；specStrength：高光强度
// extraShadow：额外的阴影系数（视差自阴影会用到），没有就传 1
half3 Ch07Shade(float3 positionWS, half3 normalWS, half3 albedo, half gloss, half specStrength, half extraShadow)
{
    float4 shadowCoord = TransformWorldToShadowCoord(positionWS);
    Light mainLight = GetMainLight(shadowCoord);

    half3 V = GetWorldSpaceNormalizeViewDir(positionWS);
    half3 L = mainLight.direction;
    half3 H = SafeNormalize(L + V);
    half NdotL = saturate(dot(normalWS, L));
    half NdotH = saturate(dot(normalWS, H));

    // URP 的灯光强度已经“乘过 π”，所以 Lambert 不再除 π，
    // 归一化 Blinn-Phong 的 (n+8)/(8π) 同理写成 (n+8)/8
    half n = exp2(gloss * 10.0 + 1.0);
    half spec = specStrength * (n + 8.0) / 8.0 * pow(NdotH, n);

    half atten = mainLight.shadowAttenuation * mainLight.distanceAttenuation * extraShadow;
    half3 direct = (albedo + spec) * NdotL * atten * mainLight.color;
    half3 ambient = SampleSH(normalWS) * albedo;     // 环境光：球谐（第 8 章细讲）
    return direct + ambient;
}

// ShadowCaster 与 DepthOnly：只依赖顶点位置和法线，与表面着色无关。
// _LightDirection/_LightPosition 由 URP 在渲染阴影时设置（见 ShadowUtils.SetupShadowCasterConstantBuffer）
float3 _LightDirection;
float3 _LightPosition;

struct Ch07ShadowAttributes
{
    float4 positionOS : POSITION;
    float3 normalOS   : NORMAL;
};

float4 Ch07ShadowVert(Ch07ShadowAttributes input) : SV_POSITION
{
    float3 positionWS = TransformObjectToWorld(input.positionOS.xyz);
    float3 normalWS = TransformObjectToWorldNormal(input.normalOS);
#if _CASTING_PUNCTUAL_LIGHT_SHADOW
    float3 lightDirectionWS = normalize(_LightPosition - positionWS);
#else
    float3 lightDirectionWS = _LightDirection;
#endif
    float4 positionCS = TransformWorldToHClip(ApplyShadowBias(positionWS, normalWS, lightDirectionWS));
#if UNITY_REVERSED_Z
    positionCS.z = min(positionCS.z, UNITY_NEAR_CLIP_VALUE);
#else
    positionCS.z = max(positionCS.z, UNITY_NEAR_CLIP_VALUE);
#endif
    return positionCS;
}

float4 Ch07DepthVert(Ch07ShadowAttributes input) : SV_POSITION
{
    return TransformObjectToHClip(input.positionOS.xyz);
}

half4 Ch07NullFrag() : SV_Target
{
    return 0;
}

// 标准的切线空间法线贴图：顶点里准备 TBN，片元里解码法线贴图并变换到世界空间。
Shader "Cookbook/Ch07/NormalMap"
{
    Properties
    {
        [MainTexture] _BaseMap("Albedo", 2D) = "white" {}
        [MainColor] _BaseColor("Color", Color) = (1, 1, 1, 1)
        [Toggle(_NORMALMAP)] _UseNormalMap("Use Normal Map", Float) = 1
        [NoScaleOffset][Normal] _BumpMap("Normal Map", 2D) = "bump" {}
        _BumpScale("Normal Scale", Range(0, 3)) = 1
        _Gloss("Gloss", Range(0, 1)) = 0.45
        _SpecStrength("Specular", Range(0, 1)) = 0.15
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" "Queue"="Geometry" }

        HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        CBUFFER_START(UnityPerMaterial)
            float4 _BaseMap_ST;
            half4 _BaseColor;
            half _BumpScale;
            half _Gloss;
            half _SpecStrength;
        CBUFFER_END
        ENDHLSL

        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode"="UniversalForwardOnly" }
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma shader_feature_local _NORMALMAP
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
            #pragma multi_compile_fragment _ _SHADOWS_SOFT _SHADOWS_SOFT_LOW _SHADOWS_SOFT_MEDIUM _SHADOWS_SOFT_HIGH
            #pragma multi_compile_fog
            #include "Assets/Cookbook/Ch07/Ch07Common.hlsl"

            TEXTURE2D(_BaseMap); SAMPLER(sampler_BaseMap);
            TEXTURE2D(_BumpMap); SAMPLER(sampler_BumpMap);

            struct Attributes
            {
                float4 positionOS : POSITION;
                float3 normalOS   : NORMAL;
                float4 tangentOS  : TANGENT;
                float2 uv         : TEXCOORD0;
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float2 uv         : TEXCOORD0;
                float3 positionWS : TEXCOORD1;
                float3 normalWS   : TEXCOORD2;
            #if defined(_NORMALMAP)
                half4  tangentWS  : TEXCOORD3;   // xyz 切线，w 副切线符号
            #endif
                half   fogFactor  : TEXCOORD4;
            };

            Varyings vert(Attributes input)
            {
                Varyings o;
                VertexPositionInputs pos = GetVertexPositionInputs(input.positionOS.xyz);
                VertexNormalInputs nrm = GetVertexNormalInputs(input.normalOS, input.tangentOS);
                o.positionCS = pos.positionCS;
                o.positionWS = pos.positionWS;
                o.uv = TRANSFORM_TEX(input.uv, _BaseMap);
                o.normalWS = nrm.normalWS;
            #if defined(_NORMALMAP)
                // 与 URP Lit 相同：只传 T 和符号，B 在片元里用叉乘重建，省一个插值器
                real sign = input.tangentOS.w * GetOddNegativeScale();
                o.tangentWS = half4(nrm.tangentWS, sign);
            #endif
                o.fogFactor = ComputeFogFactor(pos.positionCS.z);
                return o;
            }

            half4 frag(Varyings i) : SV_Target
            {
                half4 albedo = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv) * _BaseColor;

            #if defined(_NORMALMAP)
                // 1) 解码：自动处理 DXT5nm/BC5（AG/RG 两通道）与 RGB 三通道两种存储
                half3 normalTS = UnpackNormalScale(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, i.uv), _BumpScale);
                // 2) 重建副切线并组装 TBN（行向量 T、B、N）
                float sgn = i.tangentWS.w;
                float3 bitangent = sgn * cross(i.normalWS, i.tangentWS.xyz);
                half3x3 tangentToWorld = half3x3(i.tangentWS.xyz, bitangent, i.normalWS);
                // 3) 切线空间 → 世界空间
                half3 normalWS = TransformTangentToWorld(normalTS, tangentToWorld);
            #else
                half3 normalWS = i.normalWS;
            #endif
                normalWS = NormalizeNormalPerPixel(normalWS);

                half3 color = Ch07Shade(i.positionWS, normalWS, albedo.rgb, _Gloss, _SpecStrength, 1);
                color = MixFog(color, i.fogFactor);
                return half4(color, 1);
            }
            ENDHLSL
        }

        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode"="ShadowCaster" }
            ZWrite On ZTest LEqual ColorMask 0
            HLSLPROGRAM
            #pragma vertex Ch07ShadowVert
            #pragma fragment Ch07NullFrag
            #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW
            #include "Assets/Cookbook/Ch07/Ch07Common.hlsl"
            ENDHLSL
        }

        Pass
        {
            Name "DepthOnly"
            Tags { "LightMode"="DepthOnly" }
            ZWrite On ColorMask R
            HLSLPROGRAM
            #pragma vertex Ch07DepthVert
            #pragma fragment Ch07NullFrag
            #include "Assets/Cookbook/Ch07/Ch07Common.hlsl"
            ENDHLSL
        }
    }
}

Varyings vert(Attributes input)
{
    Varyings o;
    VertexPositionInputs pos = GetVertexPositionInputs(input.positionOS.xyz);
    VertexNormalInputs nrm = GetVertexNormalInputs(input.normalOS, input.tangentOS);
    o.positionCS = pos.positionCS;
    o.positionWS = pos.positionWS;
    o.uv = TRANSFORM_TEX(input.uv, _BaseMap);
    o.normalWS = nrm.normalWS;
#if defined(_NORMALMAP)
    // 与 URP Lit 相同：只传 T 和符号，B 在片元里用叉乘重建，省一个插值器
    real sign = input.tangentOS.w * GetOddNegativeScale();
    o.tangentWS = half4(nrm.tangentWS, sign);
#endif
    o.fogFactor = ComputeFogFactor(pos.positionCS.z);
    return o;
}

half4 frag(Varyings i) : SV_Target
{
    half4 albedo = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv) * _BaseColor;

#if defined(_NORMALMAP)
    // 1) 解码：自动处理 DXT5nm/BC5（AG/RG 两通道）与 RGB 三通道两种存储
    half3 normalTS = UnpackNormalScale(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, i.uv), _BumpScale);
    // 2) 重建副切线并组装 TBN（行向量 T、B、N）
    float sgn = i.tangentWS.w;
    float3 bitangent = sgn * cross(i.normalWS, i.tangentWS.xyz);
    half3x3 tangentToWorld = half3x3(i.tangentWS.xyz, bitangent, i.normalWS);
    // 3) 切线空间 → 世界空间
    half3 normalWS = TransformTangentToWorld(normalTS, tangentToWorld);
#else
    half3 normalWS = i.normalWS;
#endif
    normalWS = NormalizeNormalPerPixel(normalWS);

    half3 color = Ch07Shade(i.positionWS, normalWS, albedo.rgb, _Gloss, _SpecStrength, 1);
    color = MixFog(color, i.fogFactor);
    return half4(color, 1);
}

half4 frag(Varyings i) : SV_Target
{
    half4 packed = SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, i.uv);
    half3 normalTS;
    if (_Mistake > 0.5 && _Mistake < 1.5)
    {
        // 错误 1：照搬“rgb*2-1”。桌面平台法线贴图默认压成 DXT5nm/BC5，
        // 数据在 A/G（或 R/G）通道里，B 通道是 0，这样解出来的向量完全不对
        normalTS = packed.rgb * 2.0 - 1.0;
        normalTS.xy *= _BumpScale;
    }
    else
    {
        normalTS = UnpackNormalScale(packed, _BumpScale);
        // 错误 2：贴图按 DirectX 约定（Y 朝下）烘焙，却直接给 Unity（OpenGL 约定，Y 朝上）用
        if (_Mistake > 1.5 && _Mistake < 2.5) normalTS.y = -normalTS.y;
    }

    float3 bitangent = i.tangentWS.w * cross(i.normalWS, i.tangentWS.xyz);
    half3 normalWS = TransformTangentToWorld(normalTS, half3x3(i.tangentWS.xyz, bitangent, i.normalWS));
    // 错误 3：忘了归一化（插值后的 TBN 和缩放过的 normalTS 都不是单位长度）
    if (_Mistake < 2.5) normalWS = normalize(normalWS);

    half3 albedo = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv).rgb;
    return half4(Ch07Shade(i.positionWS, normalWS, albedo, 0.45, 0.15, 1), 1);
}

// Reoriented Normal Mapping
// Blending when n1 and n2 are already 'unpacked' and normalised
// assume compositing in tangent space
real3 BlendNormalRNM(real3 n1, real3 n2)
{
    real3 t = n1.xyz + real3(0.0, 0.0, 1.0);
    real3 u = n2.xyz * real3(-1.0, -1.0, 1.0);
    real3 r = (t / t.z) * dot(t, u) - u;
    return r;
}

// assume compositing in tangent space
real3 BlendNormal(real3 n1, real3 n2)
{
    return normalize(real3(n1.xy * n2.z + n2.xy * n1.z, n1.z * n2.z));
}

// ① 线性平均：把两个方向直接相加再归一化。最直觉、也最不对——两张图会互相“抹平”。
half3 BlendNormalLinear(half3 n1, half3 n2)
{
    return normalize(n1 + n2);
}

// ② UDN（Unreal Developer Network 流传的写法）：只叠加 xy，z 用基础法线的。
//    便宜，但细节在陡坡上会被压扁。
half3 BlendNormalUDN(half3 n1, half3 n2)
{
    return normalize(half3(n1.xy + n2.xy, n1.z));
}

// ③ Whiteout：xy 相加，z 相乘。相当于把两个“斜率”相加，平地和斜坡上的细节都比较可信。
half3 BlendNormalWhiteout(half3 n1, half3 n2)
{
    return normalize(half3(n1.xy + n2.xy, n1.z * n2.z));
}

// ④ RNM（Reoriented Normal Mapping）：把细节法线当成“相对 +Z 的旋转”，
//    再把这个旋转施加到基础法线上。URP 的 Lit 细节法线用的就是它：
//    BlendNormalRNM(n1, n2)，定义在 core 的 CommonMaterial.hlsl，要求两个输入都已归一化。
half3 BlendNormalReoriented(half3 n1, half3 n2)
{
    return normalize(BlendNormalRNM(normalize(n1), normalize(n2)));
}

half4 frag(Varyings i) : SV_Target
{
    half3 n1 = UnpackNormalScale(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, i.uv.xy), _BumpScale);
    half3 n2 = UnpackNormalScale(SAMPLE_TEXTURE2D(_DetailNormalMap, sampler_DetailNormalMap, i.uv.zw), _DetailNormalScale);
    n1 = normalize(n1);
    n2 = normalize(n2);

    half3 blended;
    if (_BlendMode < 0.5)      blended = BlendNormalLinear(n1, n2);
    else if (_BlendMode < 1.5) blended = BlendNormalUDN(n1, n2);
    else if (_BlendMode < 2.5) blended = BlendNormalWhiteout(n1, n2);
    else if (_BlendMode < 3.5) blended = BlendNormalReoriented(n1, n2);
    else if (_BlendMode < 4.5) blended = n1;
    else                       blended = n2;
    // 遮罩：与 URP Lit 一样在“只有基础法线”和“混合结果”之间插值
    half3 normalTS = normalize(lerp(n1, blended, _DetailMask));

    float3 bitangent = i.tangentWS.w * cross(i.normalWS, i.tangentWS.xyz);
    half3 normalWS = NormalizeNormalPerPixel(
        TransformTangentToWorld(normalTS, half3x3(i.tangentWS.xyz, bitangent, i.normalWS)));

    if (_ShowNormal > 0.5) return half4(normalTS * 0.5 + 0.5, 1);   // 直接看切线空间结果
    half3 albedo = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv.xy).rgb;
    return half4(Ch07Shade(i.positionWS, normalWS, albedo, 0.5, 0.2, 1), 1);
}

// 中心差分：在 U、V 方向各取左右两个邻居。结果与离线烘焙法线贴图的算法一致。
half3 NormalFromHeightCentral(float2 uv)
{
    float2 t = _HeightMap_TexelSize.xy;
    float hL = SampleHeight(uv - float2(t.x, 0));
    float hR = SampleHeight(uv + float2(t.x, 0));
    float hD = SampleHeight(uv - float2(0, t.y));
    float hU = SampleHeight(uv + float2(0, t.y));
    // 每个纹素的高度差 × 强度 = 斜率；法线 = normalize(-dh/du, -dh/dv, 1)
    float dhdu = (hR - hL) * 0.5 * _HeightStrength;
    float dhdv = (hU - hD) * 0.5 * _HeightStrength;
    return normalize(half3(-dhdu, -dhdv, 1));
}

// 屏幕导数：ddx/ddy 给出“相邻像素之间”h 和 uv 的变化量，解一个 2×2 线性方程
// 就能把屏幕空间的变化换算成 dh/du、dh/dv。只采样一次，但精度受 2×2 像素块限制。
half3 NormalFromHeightDerivative(float2 uv)
{
    float h = SampleHeight(uv);
    float2 duvdx = ddx(uv), duvdy = ddy(uv);
    float dhdx = ddx(h), dhdy = ddy(h);
    // [duvdx; duvdy] · (dh/du, dh/dv) = (dhdx, dhdy)，用克拉默法则求解
    float det = duvdx.x * duvdy.y - duvdx.y * duvdy.x;
    float2 grad = float2(dhdx * duvdy.y - dhdy * duvdx.y,
                         duvdx.x * dhdy - duvdy.x * dhdx) / (abs(det) > 1e-12 ? det : 1e-12);
    grad *= _HeightMap_TexelSize.xy * _HeightStrength;   // 每 UV 单位 → 每纹素
    return normalize(half3(-grad, 1));
}