float4 p = float4(1, 2, 3, 4);
float3 a = p.xyz;        // (1,2,3)
float2 b = p.wx;         // (4,1)  换序
float4 c = p.xxxx;       // (1,1,1,1)  重复，等价于 p.x 的“广播”
half4  col = half4(0.2, 0.5, 0.9, 1);
half3  rgb = col.rgb;    // rgba 与 xyzw 是同一组分量的两套名字，但不能混用：col.xg 是错的
p.xy = float2(0, 0);     // 也可以写入部分分量
float3 d = a * 2 + 1;    // 标量与向量运算：逐分量

// 第 1 步：最小可运行的 URP Shader —— 把物体涂成一个纯色。
// 故意保持最少的代码：一个 Pass、一个颜色属性、顶点变换 + 输出颜色。
Shader "Cookbook/Ch03/SolidColor"
{
    Properties
    {
        // 名字 ("Inspector 显示名", 类型) = 默认值
        _BaseColor ("Base Color", Color) = (1, 0.5, 0.2, 1)
    }

    SubShader
    {
        // RenderPipeline 标签：只有 URP 激活时才使用这个 SubShader
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" "Queue"="Geometry" }

        Pass
        {
            Name "Unlit"
            // UniversalForward：URP 前向渲染的主 Pass（不写 LightMode 时按 SRPDefaultUnlit 处理）
            Tags { "LightMode"="UniversalForward" }

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            // URP 的“地基”：矩阵、坐标变换函数、平台宏都在这里
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            // 顶点着色器的输入：由网格提供，语义 POSITION 告诉 GPU 取哪一路顶点数据
            struct Attributes
            {
                float4 positionOS : POSITION;   // OS = Object Space，模型空间
            };

            // 顶点 → 片元的数据：SV_POSITION 是光栅化必须的齐次裁剪空间坐标
            struct Varyings
            {
                float4 positionCS : SV_POSITION; // CS = Clip Space，裁剪空间
            };

            // 第 1 步先不放 CBUFFER，第 6 步再讲为什么必须放进去
            half4 _BaseColor;

            Varyings vert (Attributes input)
            {
                Varyings output;
                // 模型空间 → 世界空间 → 观察空间 → 裁剪空间，一次做完
                output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
                return output;
            }

            half4 frag (Varyings input) : SV_Target
            {
                return _BaseColor;
            }
            ENDHLSL
        }
    }
}

// 顶点着色器的输入：由网格提供，语义 POSITION 告诉 GPU 取哪一路顶点数据
struct Attributes
{
    float4 positionOS : POSITION;   // OS = Object Space，模型空间
};

// 顶点 → 片元的数据：SV_POSITION 是光栅化必须的齐次裁剪空间坐标
struct Varyings
{
    float4 positionCS : SV_POSITION; // CS = Clip Space，裁剪空间
};

Varyings vert (Attributes input)
{
    Varyings output;
    // 模型空间 → 世界空间 → 观察空间 → 裁剪空间，一次做完
    output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
    return output;
}

half4 frag (Varyings input) : SV_Target
{
    return _BaseColor;
}

// 摘自 core 14.0.12 ShaderLibrary/SpaceTransforms.hlsl
float4 TransformObjectToHClip(float3 positionOS)
{
    // More efficient than computing M*VP matrix product
    return mul(GetWorldToHClipMatrix(), mul(GetObjectToWorldMatrix(), float4(positionOS, 1.0)));
}

// 第 2 步：采样一张贴图，支持材质面板上的 Tiling / Offset。
Shader "Cookbook/Ch03/Textured"
{
    Properties
    {
        [MainTexture] _BaseMap ("Base Map", 2D) = "white" {}
        [MainColor]   _BaseColor ("Base Color", Color) = (1, 1, 1, 1)
    }

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

        Pass
        {
            Name "Unlit"
            Tags { "LightMode"="UniversalForward" }

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

            struct Attributes
            {
                float4 positionOS : POSITION;
                float2 uv         : TEXCOORD0;  // 第 0 套 UV
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float2 uv         : TEXCOORD0;  // 插值器：TEXCOORDn 只是“通用槽位”的名字
            };

            // 纹理对象和采样器分开声明（DX11 风格），宏会替各平台展开成正确的写法
            TEXTURE2D(_BaseMap);
            SAMPLER(sampler_BaseMap);    // 命名为 sampler + 纹理名，Unity 会自动使用该纹理的过滤/寻址设置

            float4 _BaseMap_ST;          // Unity 自动填充：xy = Tiling，zw = Offset
            half4  _BaseColor;

            Varyings vert (Attributes input)
            {
                Varyings output;
                output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
                // 等价于 input.uv * _BaseMap_ST.xy + _BaseMap_ST.zw
                output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
                return output;
            }

            half4 frag (Varyings input) : SV_Target
            {
                half4 tex = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv);
                return tex * _BaseColor;
            }
            ENDHLSL
        }
    }
}

// 纹理对象和采样器分开声明（DX11 风格），宏会替各平台展开成正确的写法
TEXTURE2D(_BaseMap);
SAMPLER(sampler_BaseMap);    // 命名为 sampler + 纹理名，Unity 会自动使用该纹理的过滤/寻址设置

float4 _BaseMap_ST;          // Unity 自动填充：xy = Tiling，zw = Offset
half4  _BaseColor;

// 摘自 core 14.0.12 ShaderLibrary/API/Metal.hlsl
#define TEXTURE2D(textureName)                Texture2D textureName
#define SAMPLER(samplerName)                  SamplerState samplerName
#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)  PLATFORM_SAMPLE_TEXTURE2D(textureName, samplerName, coord2)

// 摘自 core 14.0.12 ShaderLibrary/Macros.hlsl
#define TRANSFORM_TEX(tex, name) ((tex.xy) * name##_ST.xy + name##_ST.zw)

struct Attributes
{
    float4 positionOS : POSITION;
    float2 uv         : TEXCOORD0;
    half4  color      : COLOR;      // 顶点色：Mesh.colors，没有顶点色的网格读到 (1,1,1,1)
};

struct Varyings
{
    float4 positionCS : SV_POSITION;
    float2 uv         : TEXCOORD0;
    half4  color      : COLOR;      // 光栅化时在三角形内部线性插值
};

Varyings vert (Attributes input)
{
    Varyings output;
    output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
    output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
    output.color = input.color;     // 原样传下去，插值交给硬件
    return output;
}

half4 frag (Varyings input) : SV_Target
{
    half4 tex = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv);
    // lerp(1, 顶点色, 强度)：强度为 0 时乘以白色，等于不起作用
    half4 vc = lerp(half4(1, 1, 1, 1), input.color, _VertexColorStrength);
    return tex * _BaseColor * vc;
}

// 第 4 步：透明度裁剪（Alpha Clip / Alpha Test）。alpha 低于阈值的像素直接丢弃。
Shader "Cookbook/Ch03/AlphaClip"
{
    Properties
    {
        [MainTexture] _BaseMap ("Base Map", 2D) = "white" {}
        [MainColor]   _BaseColor ("Base Color", Color) = (1, 1, 1, 1)
        _Cutoff ("Alpha Cutoff", Range(0, 1)) = 0.5
        // 剪掉的地方能看到背面，所以通常关掉背面剔除：0=Off 1=Front 2=Back
        [Enum(UnityEngine.Rendering.CullMode)] _Cull ("Cull", Float) = 0
    }

    SubShader
    {
        // AlphaTest 队列（2450）排在普通不透明物体之后，RenderType 让替换着色/工具识别它
        Tags { "RenderType"="TransparentCutout" "RenderPipeline"="UniversalPipeline" "Queue"="AlphaTest" }

        Pass
        {
            Name "Unlit"
            Tags { "LightMode"="UniversalForward" }
            Cull [_Cull]                         // 渲染状态可以引用属性，用方括号

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

            struct Attributes
            {
                float4 positionOS : POSITION;
                float2 uv         : TEXCOORD0;
                half4  color      : COLOR;
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
                float2 uv         : TEXCOORD0;
                half4  color      : COLOR;
            };

            TEXTURE2D(_BaseMap);
            SAMPLER(sampler_BaseMap);
            float4 _BaseMap_ST;
            half4  _BaseColor;
            half   _Cutoff;

            Varyings vert (Attributes input)
            {
                Varyings output;
                output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
                output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
                output.color = input.color;
                return output;
            }

            half4 frag (Varyings input) : SV_Target
            {
                half4 col = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv) * _BaseColor * input.color;
                // clip(x)：x < 0 时丢弃当前片元，不写颜色也不写深度
                clip(col.a - _Cutoff);
                return half4(col.rgb, 1);        // 不透明物体输出 alpha=1
            }
            ENDHLSL
        }
    }
}

// 摘自 URP 14.0.12 ShaderLibrary/ShaderVariablesFunctions.hlsl
real AlphaDiscard(real alpha, real cutoff, real offset = real(0.0))
{
#if defined(_ALPHATEST_ON)
    if (IsAlphaDiscardEnabled())
        alpha = AlphaClip(alpha, cutoff + offset);
#endif
    return alpha;
}

// 生成 无雾 / FOG_LINEAR / FOG_EXP / FOG_EXP2 四个变体，引擎按 Lighting 设置选用
#pragma multi_compile_fog

struct Varyings
{
    float4 positionCS : SV_POSITION;
    float2 uv         : TEXCOORD0;
    half4  color      : COLOR;
    float  fogFactor  : TEXCOORD1;  // 每个顶点算一次雾因子，交给插值器
};

Varyings vert (Attributes input)
{
    Varyings output;
    output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
    output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
    output.color = input.color;
    // 用裁剪空间 z 换算出“离相机多远”，再按雾模式算出因子
    output.fogFactor = ComputeFogFactor(output.positionCS.z);
    return output;
}

half4 frag (Varyings input) : SV_Target
{
    half4 col = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv) * _BaseColor * input.color;
    clip(col.a - _Cutoff);
    // 按因子把颜色往 unity_FogColor 方向混；没开雾时这一行什么都不做
    col.rgb = MixFog(col.rgb, input.fogFactor);
    return half4(col.rgb, 1);
}

// 摘自 URP 14.0.12 ShaderLibrary/ShaderVariablesFunctions.hlsl（节选）
real ComputeFogFactorZ0ToFar(float z)
{
    #if defined(FOG_LINEAR)
    // factor = (end-z)/(end-start) = z * (-1/(end-start)) + (end/(end-start))
    float fogFactor = saturate(z * unity_FogParams.z + unity_FogParams.w);
    return real(fogFactor);
    #elif defined(FOG_EXP) || defined(FOG_EXP2)
    return real(unity_FogParams.x * z);
    #else
        return real(0.0);
    #endif
}

real ComputeFogFactor(float zPositionCS)
{
    float clipZ_0Far = UNITY_Z_0_FAR_FROM_CLIPSPACE(zPositionCS);
    return ComputeFogFactorZ0ToFar(clipZ_0Far);
}

half3 MixFog(half3 fragColor, half fogFactor)
{
    return MixFogColor(fragColor, unity_FogColor.rgb, fogFactor);
}

// HLSLINCLUDE 里的代码会被自动拼到本 SubShader 每个 Pass 的 HLSLPROGRAM 前面。
// 把 CBUFFER 写在这里，所有 Pass 的 UnityPerMaterial 布局天然一致。
HLSLINCLUDE
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

CBUFFER_START(UnityPerMaterial)
    float4 _BaseMap_ST;
    half4  _BaseColor;
    half   _Cutoff;
CBUFFER_END

// 纹理和采样器不是“数值”，不能也不需要放进 CBUFFER
TEXTURE2D(_BaseMap);
SAMPLER(sampler_BaseMap);
ENDHLSL

// Unity 没有公开这两个函数，Shader Inspector 内部就是调用它们显示 “SRP Batcher: compatible / not compatible”
static readonly MethodInfo s_GetCode = typeof(ShaderUtil).GetMethod("GetSRPBatcherCompatibilityCode",
    BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
static readonly MethodInfo s_GetReason = typeof(ShaderUtil).GetMethod("GetSRPBatcherCompatibilityIssueReason",
    BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);

/// 返回 null 表示兼容，否则返回不兼容的原因
public static string Check(Shader shader, int subShader = 0)
{
    if (s_GetCode == null || s_GetReason == null) return "(当前 Unity 版本找不到内部 API)";
    int code = (int)s_GetCode.Invoke(null, new object[] { shader, subShader });
    if (code == 0) return null;
    return (string)s_GetReason.Invoke(null, new object[] { shader, subShader, code });
}

UnityPerMaterial CBuffer inconsistent size inside a SubShader (<Unnamed Pass 0>)
UnityPerMaterial CBuffer inconsistent size inside a SubShader (<Unnamed Pass 1>)

// ---------------- 2. 阴影投射 Pass：把物体画进光源的 Shadow Map ----------------
Pass
{
    Name "ShadowCaster"
    Tags { "LightMode"="ShadowCaster" }
    ZWrite On
    ZTest LEqual
    ColorMask 0          // 只要深度，不写颜色
    Cull [_Cull]

    HLSLPROGRAM
    #pragma vertex ShadowVert
    #pragma fragment ShadowFrag
    // 点光/聚光的阴影要用 _LightPosition 逐顶点求光方向，方向光用 _LightDirection
    #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW
    // Shadows.hlsl 用到了 CommonMaterial.hlsl 里的 LerpWhiteTo，单独引用时要先包含它
    #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
    #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl"

    // 由 URP 在渲染阴影前设置（ShadowUtils.SetupShadowCasterConstantBuffer）
    float3 _LightDirection;
    float3 _LightPosition;

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

    Varyings ShadowVert (Attributes input)
    {
        Varyings output;
        float3 positionWS = TransformObjectToWorld(input.positionOS.xyz);
        float3 normalWS   = TransformObjectToWorldNormal(input.normalOS);
    #if defined(_CASTING_PUNCTUAL_LIGHT_SHADOW)
        float3 lightDirectionWS = normalize(_LightPosition - positionWS);
    #else
        float3 lightDirectionWS = _LightDirection;
    #endif
        // 沿光方向和法线方向各推一点，减轻自阴影条纹（Shadow Acne），细节见第 6 章
        positionWS = ApplyShadowBias(positionWS, normalWS, lightDirectionWS);
        output.positionCS = TransformWorldToHClip(positionWS);
        // 把超出近平面的投射体压回近平面，避免被裁掉导致阴影缺块
    #if UNITY_REVERSED_Z
        output.positionCS.z = min(output.positionCS.z, UNITY_NEAR_CLIP_VALUE);
    #else
        output.positionCS.z = max(output.positionCS.z, UNITY_NEAR_CLIP_VALUE);
    #endif
        output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
        return output;
    }

    half4 ShadowFrag (Varyings input) : SV_Target
    {
        ClipByAlpha(input.uv);   // 镂空的地方不投影
        return 0;
    }
    ENDHLSL
}

// 摘自 URP 14.0.12 ShaderLibrary/Shadows.hlsl
float3 ApplyShadowBias(float3 positionWS, float3 normalWS, float3 lightDirection)
{
    float invNdotL = 1.0 - saturate(dot(lightDirection, normalWS));
    float scale = invNdotL * _ShadowBias.y;

    // normal bias is negative since we want to apply an inset normal offset
    positionWS = lightDirection * _ShadowBias.xxx + positionWS;
    positionWS = normalWS * scale.xxx + positionWS;
    return positionWS;
}

// ---------------- 3. 深度 Pass：深度预渲染（Depth Prepass）时把物体写进 _CameraDepthTexture ----------------
Pass
{
    Name "DepthOnly"
    Tags { "LightMode"="DepthOnly" }
    ZWrite On
    ColorMask R          // URP 自带 Shader 的写法；深度写进深度缓冲，颜色通道基本用不到
    Cull [_Cull]

    HLSLPROGRAM
    #pragma vertex DepthVert
    #pragma fragment DepthFrag

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

    Varyings DepthVert (Attributes input)
    {
        Varyings output;
        output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
        output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
        return output;
    }

    half DepthFrag (Varyings input) : SV_Target
    {
        ClipByAlpha(input.uv);
        return input.positionCS.z;
    }
    ENDHLSL
}

// 演示用 Renderer Feature：声明“我在不透明物体之前就要用深度图”，从而让 URP 走深度预渲染（Depth Prepass）。
// 真实项目里 SSAO（Depth 源）、某些自定义效果都会这样触发 Depth Prepass。
// 这时 _CameraDepthTexture 由各物体的 DepthOnly Pass 画出来——没有 DepthOnly Pass 的物体就不在深度图里。
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

namespace Cookbook.Ch03
{
    public class DepthPrepassFeature : ScriptableRendererFeature
    {
        class RequestDepthPass : ScriptableRenderPass
        {
            public RequestDepthPass()
            {
                renderPassEvent = RenderPassEvent.BeforeRenderingOpaques;
                ConfigureInput(ScriptableRenderPassInput.Depth);
            }
            // 什么都不画，只负责“提需求”
            public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData) { }
        }

        RequestDepthPass m_Pass;

        public override void Create() { m_Pass = new RequestDepthPass(); }

        public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
        {
            renderer.EnqueuePass(m_Pass);
        }
    }
}

// [Toggle(关键字)]：勾选时启用该关键字，属性值同时变成 1
[Toggle(_VERTEX_COLOR_ON)] _UseVertexColor ("Use Vertex Color", Float) = 0
[Toggle(_ALPHATEST_ON)]    _AlphaClip ("Alpha Clip", Float) = 0
_Cutoff ("Alpha Cutoff", Range(0, 1)) = 0.5
// [KeywordEnum(A, B)]：生成关键字 _属性名大写_选项大写，即 _UVSOURCE_MESH / _UVSOURCE_WORLDXZ
[KeywordEnum(Mesh, WorldXZ)] _UVSource ("UV Source", Float) = 0
_WorldUVScale ("World UV Scale", Float) = 0.5
[Enum(UnityEngine.Rendering.CullMode)] _Cull ("Cull", Float) = 2

// 材质开关：shader_feature —— 只编译“有材质用到”的组合；_local 不占用全局关键字名额
#pragma shader_feature_local _VERTEX_COLOR_ON
#pragma shader_feature_local_fragment _ALPHATEST_ON
#pragma shader_feature_local _UVSOURCE_MESH _UVSOURCE_WORLDXZ
// 全局开关：multi_compile —— 运行时可能切换，所有组合都要编译进包
#pragma multi_compile_fog

// 根据关键字选择 UV 来源。#if 在编译期决定，没被选中的分支根本不会进入这个变体
float2 ComputeUV(float2 meshUV, float3 positionWS)
{
#if defined(_UVSOURCE_WORLDXZ)
    float2 uv = positionWS.xz * _WorldUVScale;   // 俯视投影：相邻物体的纹理无缝衔接
#else
    float2 uv = meshUV;
#endif
    return TRANSFORM_TEX(uv, _BaseMap);
}

void ClipByAlpha(float2 uv)
{
#if defined(_ALPHATEST_ON)
    half a = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv).a * _BaseColor.a;
    clip(a - _Cutoff);
#endif
}

half4 frag (Varyings input) : SV_Target
{
    half4 tex = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv);
#if defined(_ALPHATEST_ON)
    clip(tex.a * _BaseColor.a - _Cutoff);
#endif
    half3 rgb = tex.rgb * _BaseColor.rgb;
#if defined(_VERTEX_COLOR_ON)
    rgb *= input.color.rgb;
#endif
    rgb = MixFog(rgb, input.fogFactor);
    return half4(rgb, 1);
}

// 方式一：字符串（简单）
material.EnableKeyword("_VERTEX_COLOR_ON");
material.DisableKeyword("_ALPHATEST_ON");
// 方式二：LocalKeyword（2021.2 起可用，类型安全，可缓存）
var kw = new UnityEngine.Rendering.LocalKeyword(material.shader, "_ALPHATEST_ON");
material.SetKeyword(kw, true);
material.SetFloat("_AlphaClip", 1);              // 让面板显示保持一致
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.AlphaTest;  // 镂空时顺便调整队列

// 摘自 URP 14.0.12 Runtime/UniversalRenderer.cs（节选）
// - If a material can be rendered either forward or deferred, then it should declare a UniversalForward and a UniversalGBuffer pass.
// - If a material cannot be lit in deferred (unlit, bakedLit, special material such as hair, skin shader), then it should declare UniversalForwardOnly pass
ShaderTagId[] forwardOnlyShaderTagIds = new ShaderTagId[]
{
    new ShaderTagId("UniversalForwardOnly"),
    new ShaderTagId("SRPDefaultUnlit"),
    new ShaderTagId("LightweightForward")
};

Shader "Legacy/ScrollUnlit"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Color ("Tint", Color) = (1,1,1,1)
        _ScrollSpeed ("Scroll Speed (xy)", Vector) = (0.2, 0, 0, 0)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_fog
            #include "UnityCG.cginc"

            struct appdata { float4 vertex : POSITION; float2 uv : TEXCOORD0; fixed4 color : COLOR; };
            struct v2f { float4 pos : SV_POSITION; float2 uv : TEXCOORD0; fixed4 color : COLOR; UNITY_FOG_COORDS(1) };

            sampler2D _MainTex; float4 _MainTex_ST;
            fixed4 _Color; float4 _ScrollSpeed;

            v2f vert (appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex) + _ScrollSpeed.xy * _Time.y;
                o.color = v.color;
                UNITY_TRANSFER_FOG(o, o.pos);
                return o;
            }
            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv) * _Color * i.color;
                UNITY_APPLY_FOG(i.fogCoord, col);
                return col;
            }
            ENDCG
        }
    }
    Fallback "Unlit/Texture"
}

Pass
{
    Name "Unlit"
    // Unlit 用 UniversalForwardOnly：切到 Deferred 渲染路径也不会消失（见正文 3.4 节）
    Tags { "LightMode"="UniversalForwardOnly" }

    HLSLPROGRAM                                  // CGPROGRAM → HLSLPROGRAM
    #pragma vertex vert
    #pragma fragment frag
    #pragma multi_compile_fog

    struct Attributes                            // appdata → Attributes
    {
        float4 positionOS : POSITION;            // vertex → positionOS
        float2 uv         : TEXCOORD0;
        half4  color      : COLOR;               // fixed4 → half4（URP 不再有 fixed）
    };

    struct Varyings                              // v2f → Varyings
    {
        float4 positionCS : SV_POSITION;
        float2 uv         : TEXCOORD0;
        half4  color      : COLOR;
        float  fogFactor  : TEXCOORD1;           // UNITY_FOG_COORDS(1) → 自己声明
    };

    Varyings vert (Attributes input)
    {
        Varyings output;
        // UnityObjectToClipPos → TransformObjectToHClip
        output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
        // _Time.y 的含义与 Built-in 相同：游戏开始后的秒数
        float2 scroll = _ScrollSpeed.xy * _Time.y + _ScrollOffset.xy;
        output.uv = TRANSFORM_TEX(input.uv, _BaseMap) + scroll;
        output.color = input.color;
        // UNITY_TRANSFER_FOG(o, o.pos) → ComputeFogFactor
        output.fogFactor = ComputeFogFactor(output.positionCS.z);
        return output;
    }

    half4 frag (Varyings input) : SV_Target
    {
        // tex2D(_MainTex, uv) → SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv)
        half4 col = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv) * _BaseColor * input.color;
        // UNITY_APPLY_FOG(i.fogCoord, col) → MixFog
        col.rgb = MixFog(col.rgb, input.fogFactor);
        return half4(col.rgb, 1);
    }
    ENDHLSL
}