// 摘自 URP 14 Runtime/UniversalRenderer.cs（构造函数，节选）
m_RenderOpaqueForwardPass = new DrawObjectsPass(URPProfileId.DrawOpaqueObjects, true,
    RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference);
m_DrawSkyboxPass = new DrawSkyboxPass(RenderPassEvent.BeforeRenderingSkybox);
m_CopyColorPass = new CopyColorPass(RenderPassEvent.AfterRenderingSkybox, m_SamplingMaterial, m_BlitMaterial);
m_RenderTransparentForwardPass = new DrawObjectsPass(URPProfileId.DrawTransparentObjects, false,
    RenderPassEvent.BeforeRenderingTransparents, RenderQueueRange.transparent, data.transparentLayerMask, m_DefaultStencilState, stencilData.stencilReference);

// 摘自 URP 14 Runtime/UniversalRenderPipeline.cs
bool hasHSRGPU = SystemInfo.hasHiddenSurfaceRemovalOnGPU;
bool canSkipFrontToBackSorting = (baseCamera.opaqueSortMode == OpaqueSortMode.Default && hasHSRGPU) || baseCamera.opaqueSortMode == OpaqueSortMode.NoDistanceSort;
cameraData.defaultOpaqueSortFlags = canSkipFrontToBackSorting ? noFrontToBackOpaqueFlags : commonOpaqueFlags;

// 摘自 URP 14 Shaders/Lit.shader（ForwardLit Pass）
Blend[_SrcBlend][_DstBlend], [_SrcBlendAlpha][_DstBlendAlpha]
ZWrite[_ZWrite]
Cull[_Cull]
AlphaToMask[_AlphaToMask]

// 混合模式实验台：源/目标因子和混合运算都做成材质属性，同一个 Shader 切出所有常见模式。
// _Output 决定片元输出的形式：直通（rgb, a）/ 预乘（贴图已预乘）/ 乘法就绪（lerp(1, rgb, a)）。
Shader "Cookbook/Ch16/BlendModes"
{
    Properties
    {
        [MainTexture] _BaseMap ("Base Map (alpha = shape)", 2D) = "white" {}
        [MainColor] _BaseColor ("Color", Color) = (1, 0.3, 0.2, 0.75)
        [Enum(UnityEngine.Rendering.BlendMode)] _SrcBlend ("Src Blend", Float) = 5   // SrcAlpha
        [Enum(UnityEngine.Rendering.BlendMode)] _DstBlend ("Dst Blend", Float) = 10  // OneMinusSrcAlpha
        [Enum(UnityEngine.Rendering.BlendOp)] _BlendOp ("Blend Op", Float) = 0       // Add
        [KeywordEnum(Straight, Premultiply, MultiplyReady)] _Output ("Fragment Output", Float) = 0
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "RenderPipeline"="UniversalPipeline" "Queue"="Transparent" "IgnoreProjector"="True" }

        Pass
        {
            Name "Blend"
            Tags { "LightMode"="UniversalForward" }
            BlendOp [_BlendOp]
            Blend [_SrcBlend] [_DstBlend]
            ZWrite Off
            Cull Off

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma shader_feature_local_fragment _OUTPUT_STRAIGHT _OUTPUT_PREMULTIPLY _OUTPUT_MULTIPLYREADY
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            CBUFFER_START(UnityPerMaterial)
                float4 _BaseMap_ST;
                half4 _BaseColor;
                float _SrcBlend, _DstBlend, _BlendOp;
            CBUFFER_END
            TEXTURE2D(_BaseMap); SAMPLER(sampler_BaseMap);

            struct Attributes { float4 positionOS : POSITION; float2 uv : TEXCOORD0; };
            struct Varyings { float4 positionCS : SV_POSITION; float2 uv : TEXCOORD0; };

            Varyings vert(Attributes v)
            {
                Varyings o;
                o.positionCS = TransformObjectToHClip(v.positionOS.xyz);
                o.uv = TRANSFORM_TEX(v.uv, _BaseMap);
                return o;
            }

            half4 frag(Varyings i) : SV_Target
            {
                half4 tex = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv);
                half3 rgb = tex.rgb * _BaseColor.rgb;
                half  a   = tex.a * _BaseColor.a;
            #if defined(_OUTPUT_PREMULTIPLY)
                // 预乘：贴图的 rgb 已经乘过 alpha（导出时完成），这里只再乘上材质的不透明度。
                // 于是 rgb 可以“大于” alpha——alpha = 0 而 rgb > 0 的像素就是纯叠加的辉光
                return half4(tex.rgb * _BaseColor.rgb * _BaseColor.a, a);
            #elif defined(_OUTPUT_MULTIPLYREADY)
                return half4(lerp(1.0h, rgb, a), a);  // 乘法类：透明处输出白色（乘 1 不变）
            #else
                return half4(rgb, a);                 // 直通
            #endif
            }
            ENDHLSL
        }
    }
}

BlendOp [_BlendOp]
Blend [_SrcBlend] [_DstBlend]
ZWrite Off
Cull Off

half4 frag(Varyings i) : SV_Target
{
    half4 tex = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv);
    half3 rgb = tex.rgb * _BaseColor.rgb;
    half  a   = tex.a * _BaseColor.a;
#if defined(_OUTPUT_PREMULTIPLY)
    // 预乘：贴图的 rgb 已经乘过 alpha（导出时完成），这里只再乘上材质的不透明度。
    // 于是 rgb 可以“大于” alpha——alpha = 0 而 rgb > 0 的像素就是纯叠加的辉光
    return half4(tex.rgb * _BaseColor.rgb * _BaseColor.a, a);
#elif defined(_OUTPUT_MULTIPLYREADY)
    return half4(lerp(1.0h, rgb, a), a);  // 乘法类：透明处输出白色（乘 1 不变）
#else
    return half4(rgb, a);                 // 直通
#endif
}

// 深度/剔除状态实验台：ZTest、ZWrite、Cull 都是材质属性，可在 Inspector 里直接切换。
// 渲染状态写成 [属性名] 的形式，Unity 会在提交绘制时读取材质上的值。
Shader "Cookbook/Ch16/RenderStates"
{
    Properties
    {
        _BaseColor ("Color", Color) = (0.9, 0.5, 0.2, 1)
        [HDR] _BackColor ("Back Face Color", Color) = (0.2, 0.6, 0.9, 1)
        [Enum(UnityEngine.Rendering.CompareFunction)] _ZTest ("ZTest", Float) = 4   // LessEqual
        [Enum(Off, 0, On, 1)] _ZWrite ("ZWrite", Float) = 1
        [Enum(UnityEngine.Rendering.CullMode)] _Cull ("Cull", Float) = 2            // Back
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" "Queue"="Geometry" }

        HLSLINCLUDE
        #include "Assets/Cookbook/Ch16/Ch16Common.hlsl"
        CBUFFER_START(UnityPerMaterial)
            half4 _BaseColor, _BackColor;
            float _ZTest, _ZWrite, _Cull;
        CBUFFER_END
        ENDHLSL

        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode"="UniversalForwardOnly" }
            ZTest [_ZTest]
            ZWrite [_ZWrite]
            Cull [_Cull]
            HLSLPROGRAM
            #pragma vertex Ch16Vert
            #pragma fragment frag
            #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

            half4 frag(Varyings i, FRONT_FACE_TYPE face : FRONT_FACE_SEMANTIC) : SV_Target
            {
                bool front = IS_FRONT_VFACE(face, true, false);
                float3 N = normalize(i.normalWS) * (front ? 1.0 : -1.0);
                half3 albedo = front ? _BaseColor.rgb : _BackColor.rgb;
                return half4(SimpleLighting(albedo, N, i.positionWS, 0.4h), 1);
            }
            ENDHLSL
        }

        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode"="ShadowCaster" }
            ZWrite On ZTest LEqual ColorMask 0 Cull [_Cull]
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            float4 vert(Attributes v) : SV_POSITION { return Ch16ShadowPositionCS(v.positionOS.xyz, v.normalOS); }
            half4 frag() : SV_Target { return 0; }
            ENDHLSL
        }
    }
}

[Enum(UnityEngine.Rendering.CompareFunction)] _ZTest ("ZTest", Float) = 4   // LessEqual
[Enum(Off, 0, On, 1)] _ZWrite ("ZWrite", Float) = 1
[Enum(UnityEngine.Rendering.CullMode)] _Cull ("Cull", Float) = 2            // Back

ZTest [_ZTest]
ZWrite [_ZWrite]
Cull [_Cull]

// 双 Pass 半透明：第一个 Pass 只写深度（不写颜色），第二个 Pass 用 LEqual 正常混合。
// 结果是每个像素只留下“离相机最近的那层表面”，自身前后层次不再错乱。
// URP 的 DrawObjectsPass 按 SRPDefaultUnlit → UniversalForward 的顺序绘制同一物体的多个 Pass，
// 所以把预深度放在 SRPDefaultUnlit 里，就能保证它先于颜色 Pass 执行。
Shader "Cookbook/Ch16/TransparentPrepass"
{
    Properties
    {
        _BaseColor ("Color (A = opacity)", Color) = (0.3, 0.7, 1, 0.45)
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "RenderPipeline"="UniversalPipeline" "Queue"="Transparent" }

        HLSLINCLUDE
        #include "Assets/Cookbook/Ch16/Ch16Common.hlsl"
        CBUFFER_START(UnityPerMaterial)
            half4 _BaseColor;
        CBUFFER_END
        ENDHLSL

        Pass
        {
            Name "DepthPrepass"
            Tags { "LightMode"="SRPDefaultUnlit" }
            ZWrite On
            ColorMask 0          // 只写深度，不动颜色
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            float4 vert(Attributes v) : SV_POSITION { return TransformObjectToHClip(v.positionOS.xyz); }
            half4 frag() : SV_Target { return 0; }
            ENDHLSL
        }

        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode"="UniversalForward" }
            Blend SrcAlpha OneMinusSrcAlpha
            ZWrite Off
            ZTest LEqual         // 深度相等的那层（最前面的表面）才能通过
            HLSLPROGRAM
            #pragma vertex Ch16Vert
            #pragma fragment frag
            #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
            half4 frag(Varyings i) : SV_Target
            {
                return half4(SimpleLighting(_BaseColor.rgb, normalize(i.normalWS), i.positionWS, 0.8h), _BaseColor.a);
            }
            ENDHLSL
        }
    }
}

// 摘自 URP 14 Runtime/Passes/DrawObjectsPass.cs
new ShaderTagId[] { new ShaderTagId("SRPDefaultUnlit"), new ShaderTagId("UniversalForward"), new ShaderTagId("UniversalForwardOnly") }

// 摘自 URP 14 ShaderLibrary/ShaderVariablesFunctions.hlsl
half SharpenAlphaStrict(half alpha, half alphaClipTreshold)
{
    half dAlpha = fwidth(alpha);
    return saturate(((alpha - alphaClipTreshold - (0.5 * dAlpha)) / max(dAlpha, 0.0001)) + 1.0);
}

// 镂空材质的三种做法：
//   Alpha Clip：clip() 硬裁剪，边缘锯齿，远处细线会因 mip 平均而消失；
//   Alpha to Coverage（A2C）：把 alpha 转成 MSAA 的覆盖掩码，边缘有 MSAA 级别的过渡（需要开 MSAA）；
//   A2C + 锐化：用 fwidth 把 alpha 重新拉成“一个像素宽的过渡”，既保住细线又不发虚。
Shader "Cookbook/Ch16/Cutout"
{
    Properties
    {
        [MainTexture] _BaseMap ("Base Map", 2D) = "white" {}
        [MainColor] _BaseColor ("Color", Color) = (1, 1, 1, 1)
        _Cutoff ("Alpha Cutoff", Range(0, 1)) = 0.5
        [Enum(Off, 0, On, 1)] _AlphaToMask ("Alpha To Coverage", Float) = 0
        [Toggle] _Sharpen ("Sharpen Alpha (for A2C)", Float) = 0
        [Toggle] _MipScale ("Preserve Coverage Over Mips", Float) = 0
    }
    SubShader
    {
        Tags { "RenderType"="TransparentCutout" "RenderPipeline"="UniversalPipeline" "Queue"="AlphaTest" }

        HLSLINCLUDE
        #include "Assets/Cookbook/Ch16/Ch16Common.hlsl"
        CBUFFER_START(UnityPerMaterial)
            float4 _BaseMap_ST;
            half4 _BaseColor;
            half  _Cutoff;
            float _AlphaToMask, _Sharpen, _MipScale;
            float4 _BaseMap_TexelSize;
        CBUFFER_END
        TEXTURE2D(_BaseMap); SAMPLER(sampler_BaseMap);

        half CutoutAlpha(float2 uv)
        {
            half a = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv).a * _BaseColor.a;
            if (_MipScale > 0.5)
            {
                // 远处 mip 把细线和透明背景平均成很低的 alpha，裁剪后线条就“断”了。
                // 按 mip 级别把 alpha 放大一些，抵消平均带来的损失（经验做法，系数可调）
                float2 texel = uv * _BaseMap_TexelSize.zw;
                float2 dx = ddx(texel), dy = ddy(texel);
                float mip = max(0.0, 0.5 * log2(max(dot(dx, dx), dot(dy, dy))));
                a *= 1.0 + mip * 0.3;
            }
            return a;
        }
        ENDHLSL

        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode"="UniversalForwardOnly" }
            Cull Off
            AlphaToMask [_AlphaToMask]
            HLSLPROGRAM
            #pragma vertex Ch16Vert
            #pragma fragment frag
            #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

            half4 frag(Varyings i, FRONT_FACE_TYPE face : FRONT_FACE_SEMANTIC) : SV_Target
            {
                float2 uv = TRANSFORM_TEX(i.uv, _BaseMap);
                half4 tex = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv);
                half a = CutoutAlpha(uv);

                if (_AlphaToMask > 0.5)
                {
                    if (_Sharpen > 0.5)
                    {
                        // 以 cutoff 为中心，把 alpha 的过渡压缩到约一个像素宽
                        a = (a - _Cutoff) / max(fwidth(a), 1e-4) + 0.5;
                    }
                    a = saturate(a);
                }
                else
                {
                    clip(a - _Cutoff);    // 经典 Alpha Test
                    a = 1;
                }

                float3 N = normalize(i.normalWS) * IS_FRONT_VFACE(face, 1.0, -1.0);
                half3 col = SimpleLighting(tex.rgb * _BaseColor.rgb, N, i.positionWS, 0.2h);
                return half4(col, a);     // 开启 A2C 时，这个 alpha 决定 MSAA 子样本覆盖了几个
            }
            ENDHLSL
        }

        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode"="ShadowCaster" }
            ZWrite On ZTest LEqual ColorMask 0 Cull Off
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            struct V2F { float4 positionCS : SV_POSITION; float2 uv : TEXCOORD0; };
            V2F vert(Attributes v)
            {
                V2F o;
                o.positionCS = Ch16ShadowPositionCS(v.positionOS.xyz, v.normalOS);
                o.uv = TRANSFORM_TEX(v.uv, _BaseMap);
                return o;
            }
            // 阴影贴图没有 MSAA，只能用硬裁剪
            half4 frag(V2F i) : SV_Target { clip(CutoutAlpha(i.uv) - _Cutoff); return 0; }
            ENDHLSL
        }

        Pass
        {
            Name "DepthOnly"
            Tags { "LightMode"="DepthOnly" }
            ZWrite On ColorMask R Cull Off
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            struct V2F { float4 positionCS : SV_POSITION; float2 uv : TEXCOORD0; };
            V2F vert(Attributes v)
            {
                V2F o;
                o.positionCS = TransformObjectToHClip(v.positionOS.xyz);
                o.uv = TRANSFORM_TEX(v.uv, _BaseMap);
                return o;
            }
            half4 frag(V2F i) : SV_Target { clip(CutoutAlpha(i.uv) - _Cutoff); return 0; }
            ENDHLSL
        }
    }
}

half4 frag(Varyings i, FRONT_FACE_TYPE face : FRONT_FACE_SEMANTIC) : SV_Target
{
    float2 uv = TRANSFORM_TEX(i.uv, _BaseMap);
    half4 tex = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv);
    half a = CutoutAlpha(uv);

    if (_AlphaToMask > 0.5)
    {
        if (_Sharpen > 0.5)
        {
            // 以 cutoff 为中心，把 alpha 的过渡压缩到约一个像素宽
            a = (a - _Cutoff) / max(fwidth(a), 1e-4) + 0.5;
        }
        a = saturate(a);
    }
    else
    {
        clip(a - _Cutoff);    // 经典 Alpha Test
        a = 1;
    }

    float3 N = normalize(i.normalWS) * IS_FRONT_VFACE(face, 1.0, -1.0);
    half3 col = SimpleLighting(tex.rgb * _BaseColor.rgb, N, i.positionWS, 0.2h);
    return half4(col, a);     // 开启 A2C 时，这个 alpha 决定 MSAA 子样本覆盖了几个
}

half CutoutAlpha(float2 uv)
{
    half a = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv).a * _BaseColor.a;
    if (_MipScale > 0.5)
    {
        // 远处 mip 把细线和透明背景平均成很低的 alpha，裁剪后线条就“断”了。
        // 按 mip 级别把 alpha 放大一些，抵消平均带来的损失（经验做法，系数可调）
        float2 texel = uv * _BaseMap_TexelSize.zw;
        float2 dx = ddx(texel), dy = ddy(texel);
        float mip = max(0.0, 0.5 * log2(max(dot(dx, dx), dot(dy, dy))));
        a *= 1.0 + mip * 0.3;
    }
    return a;
}

// 4×4 Bayer 矩阵：16 个阈值均匀分布在 0..1，且相邻像素的阈值尽量“错开”
float Bayer4x4(uint2 p)
{
    const float m[16] = {
         0.0,  8.0,  2.0, 10.0,
        12.0,  4.0, 14.0,  6.0,
         3.0, 11.0,  1.0,  9.0,
        15.0,  7.0, 13.0,  5.0 };
    p %= 4;
    return (m[p.y * 4 + p.x] + 0.5) / 16.0;
}

// opacity 为 0.5 时，正好有一半像素的阈值低于它而被保留
void DitherClip(float2 pixelPos, half opacity)
{
    clip(opacity - Bayer4x4((uint2)pixelPos));
}

// 抖动透明（Dither / Screen-door Transparency）：不混合，而是按屏幕位置的阈值图案丢弃一部分像素。
// 物体仍然是不透明队列、写深度、不需要排序；代价是近看能看到网点。阴影 Pass 用同样的抖动。
Shader "Cookbook/Ch16/DitherFade"
{
    Properties
    {
        _BaseColor ("Color", Color) = (0.9, 0.5, 0.25, 1)
        _Fade ("Opacity", Range(0, 1)) = 0.5
        [Toggle] _DitherShadow ("Dither In Shadow Pass", Float) = 1
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" "Queue"="AlphaTest" }

        HLSLINCLUDE
        #include "Assets/Cookbook/Ch16/Ch16Common.hlsl"
        CBUFFER_START(UnityPerMaterial)
            half4 _BaseColor;
            half  _Fade;
            float _DitherShadow;
        CBUFFER_END

        // 4×4 Bayer 矩阵：16 个阈值均匀分布在 0..1，且相邻像素的阈值尽量“错开”
        float Bayer4x4(uint2 p)
        {
            const float m[16] = {
                 0.0,  8.0,  2.0, 10.0,
                12.0,  4.0, 14.0,  6.0,
                 3.0, 11.0,  1.0,  9.0,
                15.0,  7.0, 13.0,  5.0 };
            p %= 4;
            return (m[p.y * 4 + p.x] + 0.5) / 16.0;
        }

        // opacity 为 0.5 时，正好有一半像素的阈值低于它而被保留
        void DitherClip(float2 pixelPos, half opacity)
        {
            clip(opacity - Bayer4x4((uint2)pixelPos));
        }
        ENDHLSL

        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode"="UniversalForwardOnly" }
            HLSLPROGRAM
            #pragma vertex Ch16Vert
            #pragma fragment frag
            #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
            half4 frag(Varyings i) : SV_Target
            {
                DitherClip(i.positionCS.xy, _Fade);     // SV_POSITION.xy 在片元里就是像素坐标
                return half4(SimpleLighting(_BaseColor.rgb, normalize(i.normalWS), i.positionWS, 0.5h), 1);
            }
            ENDHLSL
        }

        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode"="ShadowCaster" }
            ZWrite On ZTest LEqual ColorMask 0
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            float4 vert(Attributes v) : SV_POSITION { return Ch16ShadowPositionCS(v.positionOS.xyz, v.normalOS); }
            half4 frag(float4 positionCS : SV_POSITION) : SV_Target
            {
                // 阴影贴图里的“像素”是阴影贴图的纹素，抖动后经过 PCF 软阴影过滤，会得到浅一些的阴影
                if (_DitherShadow > 0.5) DitherClip(positionCS.xy, _Fade);
                return 0;
            }
            ENDHLSL
        }

        Pass
        {
            Name "DepthOnly"
            Tags { "LightMode"="DepthOnly" }
            ZWrite On ColorMask R
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            float4 vert(Attributes v) : SV_POSITION { return TransformObjectToHClip(v.positionOS.xyz); }
            half4 frag(float4 positionCS : SV_POSITION) : SV_Target { DitherClip(positionCS.xy, _Fade); return 0; }
            ENDHLSL
        }
    }
}

// 摘自 Core RP 14 ShaderLibrary/API/Metal.hlsl（D3D11.hlsl 中相同）
#define FRONT_FACE_SEMANTIC SV_IsFrontFace
#define FRONT_FACE_TYPE bool
#define IS_FRONT_VFACE(VAL, FRONT, BACK) ((VAL) ? (FRONT) : (BACK))

half4 frag(Varyings i, FRONT_FACE_TYPE face : FRONT_FACE_SEMANTIC) : SV_Target
{
    // IS_FRONT_VFACE 屏蔽了平台差异：D3D/Metal 是 bool，旧的 GL 是 float 符号
    bool isFront = IS_FRONT_VFACE(face, true, false);
    float3 N = normalize(i.normalWS);
    if (!isFront && _FlipBackNormal > 0.5) N = -N;
    half3 albedo = isFront ? _BaseColor.rgb : _BackColor.rgb;
    return half4(SimpleLighting(albedo, N, i.positionWS, 0.3h), 1);
}