switch (m_Settings.technique)
{
    case DecalTechniqueOption.Automatic:
        if (IsAutomaticDBuffer() || isDeferred && needsGBufferAccurateNormals)
            technique = DecalTechnique.DBuffer;
        else if (isDeferred)
            technique = DecalTechnique.GBuffer;
        else
            technique = DecalTechnique.ScreenSpace;
        break;
    case DecalTechniqueOption.ScreenSpace:
        if (isDeferred)
            technique = DecalTechnique.GBuffer;
        else
            technique = DecalTechnique.ScreenSpace;
        break;
    case DecalTechniqueOption.DBuffer:
        technique = DecalTechnique.DBuffer;
        break;
}

#if defined(_DBUFFER)
    ApplyDecalToSurfaceData(input.positionCS, surfaceData, inputData);
#endif

// DecalRendererFeature 及其设置类在 URP 14 里是 internal 的：编辑器里在 Renderer 资源上点 Add Renderer Feature › Decal 即可；
// 代码里只能用反射创建，再通过 SerializedObject 改它的序列化字段（与 Inspector 改的是同一份数据）。
// technique: 0 Automatic / 1 DBuffer / 2 ScreenSpace；surfaceData: 0 Albedo / 1 AlbedoNormal / 2 AlbedoNormalMAOS
static ScriptableRendererFeature AddDecalFeature(Shot s, int technique, int surfaceData = 2, int normalBlend = 1)
{
    var type = typeof(ScriptableRendererFeature).Assembly.GetType("UnityEngine.Rendering.Universal.DecalRendererFeature");
    var feature = (ScriptableRendererFeature)ScriptableObject.CreateInstance(type);
    feature.name = "Decal";
    var so = new SerializedObject(feature);
    so.FindProperty("m_Settings.technique").enumValueIndex = technique;
    so.FindProperty("m_Settings.dBufferSettings.surfaceData").enumValueIndex = surfaceData;
    so.FindProperty("m_Settings.screenSpaceSettings.normalBlend").enumValueIndex = normalBlend;
    so.ApplyModifiedPropertiesWithoutUndo();
    s.Temp.Add(feature);
    s.Renderer.rendererFeatures.Add(feature);
    s.Renderer.SetDirty();
    return feature;
}

static Material UrpDecalMat(Shot s, Texture2D baseMap, Texture2D normal = null, bool angleFadeGraph = false)
{
    // URP 包自带的 Decal Shader Graph（Packages/.../Shaders/Decal.shadergraph），属性：Base_Map / Normal_Map / Normal_Blend
    var m = s.Mat(angleFadeGraph ? "Cookbook/Ch22/DecalAngleFade" : "Shader Graphs/Decal");
    m.SetTexture("Base_Map", baseMap);
    if (normal != null) { m.SetTexture("Normal_Map", normal); m.SetFloat("Normal_Blend", 1f); }
    else m.SetFloat("Normal_Blend", 0f);
    m.enableInstancing = true;    // Decal 系统按材质分批用 GPU Instancing 绘制
    return m;
}

static DecalProjector UrpDecal(Material m, Vector3 pos, Vector3 euler, Vector3 size, float opacity = 1f)
{
    var go = new GameObject("Decal Projector");
    go.transform.SetPositionAndRotation(pos, Quaternion.Euler(euler));
    var d = go.AddComponent<DecalProjector>();
    d.material = m;
    d.size = size;                          // x/y = 贴花宽高，z = 投影深度
    d.pivot = new Vector3(0, 0, size.z * 0.5f);  // 默认：盒子从投影器位置向前延伸
    d.fadeFactor = opacity;
    return d;
}

// In the shader to remap from cosine -1 to 1 to new range 0..1  (with 0 - 0 degree and 1 - 180 degree)
// we do 1.0 - (dot() * 0.5 + 0.5) => 0.5 * (1 - dot())
// we actually square that to get smoother result => x = (0.5 - 0.5 * dot())^2
// Do a remap in the shader. 1.0 - saturate((x - start) / (end - start))
// After simplification => saturate(a + b * dot() * (dot() - 2.0))
float angleStart = startAngleFade / 180.0f;
float angleEnd = endAngleFade / 180.0f;
var range = Mathf.Max(0.0001f, angleEnd - angleStart);
cachedChunk.angleFades[arrayIndex] = new Vector2(1.0f - (0.25f - angleStart) / range, -0.25f / range);

Cull Front        // 画盒子的“背面”：相机钻进盒子里也不会丢
ZTest Greater     // 背面比场景表面“更远”才通过 = 场景表面在盒子里（或盒子前方）
ZWrite Off
Blend [_SrcBlend] [_DstBlend]

    // 1) 屏幕 UV → 场景深度 → 世界坐标
    float2 screenUV = GetNormalizedScreenSpaceUV(i.positionCS);
    float rawDepth = SampleSceneDepth(screenUV);
#if !UNITY_REVERSED_Z
    rawDepth = lerp(UNITY_NEAR_CLIP_VALUE, 1, rawDepth);   // OpenGL 类平台：[0,1] → [-1,1]
#endif
    float3 positionWS = ComputeWorldSpacePosition(screenUV, rawDepth, UNITY_MATRIX_I_VP);

    // 2) 世界坐标 → 贴花盒子的本地空间；盒子外的像素直接丢掉
    float3 positionOS = TransformWorldToObject(positionWS);
    clip(0.5 - abs(positionOS));

/// 屏幕空间贴花就是一个挂着贴花材质的单位立方体：位置/旋转/缩放 = 投影盒
static GameObject SSD(Shot s, Material m, Vector3 pos, Vector3 euler, Vector3 size)
{
    var go = s.Cube(m, pos);
    go.name = "Screen Space Decal";
    go.transform.rotation = Quaternion.Euler(euler);
    go.transform.localScale = size;
    var r = go.GetComponent<MeshRenderer>();
    r.shadowCastingMode = ShadowCastingMode.Off;   // 投影盒本身不投影、不接收
    r.receiveShadows = false;
    return go;
}

// 3) 用屏幕空间导数重建表面法线（平面法线，物体轮廓处会有噪点）
float3 normalWS = normalize(cross(ddx(positionWS), ddy(positionWS)));
normalWS *= sign(dot(normalWS, GetWorldSpaceViewDir(positionWS)));   // 统一朝向相机，免去平台 Y 方向差异

// 4) 角度衰减：表面越“侧”对投影方向，贴花越淡，避免在侧壁上拉出长条
float3 projDirWS = normalize(TransformObjectToWorldDir(float3(0, 0, 1)));
float facing = dot(normalWS, -projDirWS);                            // 1 = 正对投影器
float cosStart = cos(radians(_AngleStart)), cosEnd = cos(radians(_AngleEnd));
half angleFade = saturate((facing - cosEnd) / max(cosStart - cosEnd, 1e-4));
// 盒子前后两端也淡出，贴花不会在投影深度的尽头被一刀切断
half depthFade = saturate((0.5 - abs(positionOS.z)) / _DepthFade);

    float2 boxUV = positionOS.xy + 0.5;              // 盒子本地 xy → 0..1 的贴花 UV
    float2 uv = TRANSFORM_TEX(boxUV, _BaseMap);
    half4 decal = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv) * _BaseColor;
    half alpha = decal.a * angleFade * depthFade;

    half3 color = decal.rgb;
#if defined(_DECAL_LIT)
    half3 n = normalWS;
    #if defined(_NORMALMAP)
        // 贴花自己的法线贴图：切线空间就是投影器的 X/Y 轴，“上”是 -投影方向
        half3 nTS = UnpackNormalScale(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, uv), _BumpScale);
        float3 T = normalize(TransformObjectToWorldDir(float3(1, 0, 0)));
        float3 B = normalize(TransformObjectToWorldDir(float3(0, 1, 0)));
        // 把法线贴图的扰动量（xy）叠加到重建的表面法线上（UDN 式混合）
        n = normalize(n + (T * nTS.x + B * nTS.y) * decal.a);
    #endif
    InputData inputData = (InputData)0;
    inputData.positionWS = positionWS;
    inputData.normalWS = n;
    inputData.viewDirectionWS = GetWorldSpaceNormalizeViewDir(positionWS);
    inputData.shadowCoord = TransformWorldToShadowCoord(positionWS);
    inputData.bakedGI = SampleSH(n);
    inputData.normalizedScreenSpaceUV = screenUV;
    inputData.shadowMask = half4(1, 1, 1, 1);
    SurfaceData surface = (SurfaceData)0;
    surface.albedo = decal.rgb;
    surface.smoothness = _Smoothness;
    surface.occlusion = 1;
    surface.alpha = alpha;
    color = UniversalFragmentPBR(inputData, surface).rgb;
#endif
    // 正片叠底模式：alpha 折算进颜色（透明处 = 白 = 不改变背景）
    color = lerp(color, lerp(1.0, decal.rgb, alpha), _Modulate);
    return half4(color, alpha);

Blend SrcAlpha OneMinusSrcAlpha
ZWrite Off
ZTest LEqual
// 深度偏移：depth += factor × 斜率 + units × 最小可分辨深度单位
// 负值 = 往相机方向拉一点，让与底面共面的贴花稳定地赢下深度测试
Offset [_OffsetFactor], [_OffsetUnits]

/// 保留 sign × pos[axis] ≤ 0.5 的部分。src → dst
static void ClipAgainstPlane(List<Vert> src, List<Vert> dst, int axis, float sign)
{
    dst.Clear();
    int n = src.Count;
    for (int i = 0; i < n; i++)
    {
        Vert a = src[i], b = src[(i + 1) % n];
        float da = 0.5f - sign * a.pos[axis];      // ≥ 0 表示在盒子这一侧
        float db = 0.5f - sign * b.pos[axis];
        if (da >= 0) dst.Add(a);
        if ((da >= 0) != (db >= 0))                 // 跨过平面：插入交点
            dst.Add(Vert.Lerp(a, b, da / (da - db)));
    }
}

/// <param name="box">贴花盒子（用它的 Transform 的位置/旋转/缩放）</param>
/// <param name="targets">要贴上去的网格</param>
/// <param name="maxAngle">表面法线与“逆投影方向”的夹角超过它就不贴（避免侧壁拉伸）</param>
/// <param name="pushOut">沿法线外推的距离（米），配合 Shader 的 Offset 进一步防止 Z-Fighting</param>
/// <returns>世界空间网格（挂到一个位于原点、无旋转缩放的物体上）</returns>
public static Mesh Build(Transform box, IEnumerable<MeshFilter> targets, float maxAngle = 80f, float pushOut = 0.002f)
{
    var worldToBox = box.worldToLocalMatrix;
    var boxToWorld = box.localToWorldMatrix;
    Vector3 backDir = -box.forward;                  // “逆投影方向”，正对投影器的表面法线与它一致
    float minFacing = Mathf.Cos(maxAngle * Mathf.Deg2Rad);

    var outPos = new List<Vector3>(); var outNrm = new List<Vector3>();
    var outUV = new List<Vector2>(); var outIdx = new List<int>();
    var poly = new List<Vert>(9); var tmp = new List<Vert>(9);

    foreach (var mf in targets)
    {
        var mesh = mf.sharedMesh;
        var l2w = mf.transform.localToWorldMatrix;
        var nrmMat = l2w.inverse.transpose;          // 法线用逆转置矩阵变换
        var verts = mesh.vertices; var normals = mesh.normals; var tris = mesh.triangles;
        for (int t = 0; t < tris.Length; t += 3)
        {
            Vector3 w0 = l2w.MultiplyPoint3x4(verts[tris[t]]);
            Vector3 w1 = l2w.MultiplyPoint3x4(verts[tris[t + 1]]);
            Vector3 w2 = l2w.MultiplyPoint3x4(verts[tris[t + 2]]);
            // 1) 背向投影器（或太斜）的三角形不要
            Vector3 faceN = Vector3.Cross(w1 - w0, w2 - w0).normalized;
            if (Vector3.Dot(faceN, backDir) < minFacing) continue;

            poly.Clear();
            for (int k = 0; k < 3; k++)
            {
                int vi = tris[t + k];
                Vector3 w = k == 0 ? w0 : (k == 1 ? w1 : w2);
                Vector3 n = nrmMat.MultiplyVector(normals[vi]).normalized;
                poly.Add(new Vert(worldToBox.MultiplyPoint3x4(w), n));
            }
            // 2) 依次用盒子的 6 个面裁剪（Sutherland–Hodgman）
            for (int axis = 0; axis < 3 && poly.Count >= 3; axis++)
            {
                ClipAgainstPlane(poly, tmp, axis, +1f);
                ClipAgainstPlane(tmp, poly, axis, -1f);
            }
            if (poly.Count < 3) continue;

            // 3) 剩下的凸多边形扇形三角化，输出世界坐标 + 盒子 UV
            int baseIdx = outPos.Count;
            foreach (var v in poly)
            {
                Vector3 n = v.normal.normalized;
                outPos.Add(boxToWorld.MultiplyPoint3x4(v.pos) + n * pushOut);
                outNrm.Add(n);
                outUV.Add(new Vector2(v.pos.x + 0.5f, v.pos.y + 0.5f));
            }
            for (int k = 1; k < poly.Count - 1; k++)
            {
                outIdx.Add(baseIdx); outIdx.Add(baseIdx + k); outIdx.Add(baseIdx + k + 1);
            }
        }
    }
    var m = new Mesh { name = "DecalMesh", indexFormat = IndexFormat.UInt32 };
    m.SetVertices(outPos); m.SetNormals(outNrm); m.SetUVs(0, outUV); m.SetTriangles(outIdx, 0);
    m.RecalculateTangents();   // 有了 UV 才能算切线，供法线贴图使用
    m.RecalculateBounds();
    return m;
}

// 投影盒：一个空物体的 Transform（也可以直接用 DecalProjector 所在的物体）
var boxGo = new GameObject("Decal Box");
boxGo.transform.SetPositionAndRotation(new Vector3(-0.85f, 0.65f, -0.5f), Quaternion.identity);   // 沿 +Z 朝球投影
boxGo.transform.localScale = new Vector3(0.8f, 0.8f, 1.0f);
var mesh = DecalMeshBuilder.Build(boxGo.transform, targets, 80f, 0.002f);