Galgame常用Shader

桶形畸变

Barrel

“桶形畸变”（Barrel Distortion）通常用于模拟相机镜头的畸变效果。着色器的目的是基于给定的纹理（_MainTex）对图像进行扭曲处理，并提供一定的可调参数来控制该效果的强度、色差等。

该着色器实现了一个带有桶形畸变和可调色差的效果，能够根据不同的参数（如曲率、缩放、色差强度等）对图像进行不同程度的扭曲处理。常见的应用场景是模拟相机镜头畸变、镜头效果，或创造类似于镜头变形的视觉效果。

_MainTex: 纹理，用作图像源。默认为白色。

_T: 用于控制时间或动画效果的浮动值（在0到1之间）。

_Sigma: 影响畸变程度的参数，通常称为曲率。

_Aspect: 画面的宽高比，用于调整畸变的形状。

_Scale: 影响纹理的缩放比例。

_Chroma: 色差强度，通常用于模拟颜色的分离效果（类似色差效应）。

_Offset: 色彩偏移，影响颜色的亮度。

_BackColor: 背景色，如果纹理坐标超出[0, 1]范围时使用的颜色。

Shader "Nova/$VARIANT_NAME$/Barrel"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Sigma ("Curvature", Float) = 0.2
        _Aspect ("Aspect Ratio", Float) = 1.77777778
        _Scale ("Scale", Float) = 1.0
        _Chroma ("Chromatic Aberration Strength", Float) = 0.0
        _Offset ("Offset", Float) = 0.0
        _BackColor ("Background Color", Color) = (0, 0, 0, 1)
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            #define PI_HALF 1.5707963

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            // 这个函数是桶形畸变的核心。它根据给定的曲率（sigma）和其他参数，对uv坐标进行扭曲处理。
            // 通过调整uv坐标来模拟镜头的畸变效果。
            // sigma 控制畸变的程度，aspect 控制宽高比，scale 控制纹理坐标的缩放。
            float2 convertUV(float2 uv, float sigma, float aspect, float scale)
            {
                uv -= 0.5;
                uv /= scale;
                float r = sqrt(uv.x * uv.x * aspect * aspect + uv.y * uv.y);

                float ratio;
                float sinTheta = r * sigma * 4.0;
                if (sinTheta < 0.1)
                {
                    ratio = 1.0 + sinTheta * sinTheta / 6.0; // Taylor expansion
                }
                else if (sinTheta > 1.0)
                {
                    ratio = PI_HALF * sinTheta;
                }
                else
                {
                    ratio = asin(sinTheta) / sinTheta;
                }

                uv *= ratio;
                uv += 0.5;
                return uv;
            }

            sampler2D _MainTex;
            float _Aspect, _Scale;
            float4 _BackColor;

            // 该函数通过调用convertUV函数来计算畸变后的纹理坐标，接着根据计算出的坐标从纹理中获取颜色
            // 如果坐标超出了纹理的边界，则返回背景色（_BackColor）。
            float4 getColor(float2 uv, float sigma)
            {
                uv = convertUV(uv, sigma, _Aspect, _Scale);
                if (uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0)
                {
                    return tex2D(_MainTex, uv);
                }
                else
                {
                    return _BackColor;
                }
            }

            float _T, _Sigma, _Chroma, _Offset;

            fixed4 frag(v2f i) : SV_Target
            {
                float sigma = _Sigma * _T;

                float4 col;
                if (_Chroma > 0.0)
                {
                    float r = getColor(i.uv, sigma * (1.0 - _Chroma)).r;
                    float2 ga = getColor(i.uv, sigma).ga;
                    float b = getColor(i.uv, sigma * (1.0 + _Chroma)).b;
                    col = float4(r, ga.x, b, ga.y);
                }
                else
                {
                    col = getColor(i.uv, sigma);
                }

                col *= i.color;
                col.rgb += _Offset * _T;
                col.rgb = saturate(col.rgb);

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Barrel Hyper

这段代码是一个名为“Barrel Hyper”的Unity着色器。它是基于桶形畸变（Barrel Distortion）效果，进一步扩展或增强了畸变效果的强度，可能会产生更为强烈的镜头变形。它的实现和前一个“Barrel”着色器类似，但采用了不同的畸变公式。

Shader "Nova/$VARIANT_NAME$/Barrel Hyper"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Sigma ("Curvature", Float) = 0.2
        _Aspect ("Aspect Ratio", Float) = 1.77777778
        _Scale ("Scale", Float) = 1.0
        _Chroma ("Chromatic Aberration Strength", Float) = 0.0
        _Offset ("Offset", Float) = 0.0
        _BackColor ("Background Color", Color) = (0, 0, 0, 1)
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            // 这是桶形畸变的关键部分。它与前一个着色器的convertUV类似，但公式略有不同。在这里：
            // 先将uv从中心（0.5, 0.5）平移，使其原点对准图像中心。
            // 然后根据sigma（曲率）和r（从中心到当前uv坐标的距离）计算畸变的比例因子ratio
            // 该因子使得距离越远的区域畸变效果越强。
            // 最后，将UV坐标恢复到[0,1]的范围。
            float2 convertUV(float2 uv, float sigma, float aspect, float scale)
            {
                uv -= 0.5;
                uv /= scale;
                float r = sqrt(uv.x * uv.x * aspect * aspect + uv.y * uv.y);
                float ratio = 1.0 - r * sigma;
                uv *= ratio;
                uv += 0.5;
                return uv;
            }

            sampler2D _MainTex;
            float _Aspect, _Scale;
            float4 _BackColor;

            // 该函数使用convertUV来调整uv坐标，然后从_MainTex纹理中采样颜色。
            // 如果uv坐标超出了[0,1]的范围，返回背景色（_BackColor）。
            float4 getColor(float2 uv, float sigma)
            {
                uv = convertUV(uv, sigma, _Aspect, _Scale);
                if (uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0)
                {
                    return tex2D(_MainTex, uv);
                }
                else
                {
                    return _BackColor;
                }
            }

            float _T, _Sigma, _Chroma, _Offset;

            // 片段着色器的核心逻辑是从纹理中获取颜色，并根据时间、曲率、色差等因素进行处理。
            // sigma：根据时间_T和曲率_Sigma计算畸变的强度。
            // 如果_Chroma（色差）大于零，调整红色和蓝色通道的畸变程度，以产生色差效果。
            // 最后颜色会与顶点颜色（i.color）相乘，可能还会加入一个偏移量_Offset，使得图像亮度随时间变化
            // saturate(col.rgb)确保颜色值不超过[0,1]的范围，避免颜色溢出。
            fixed4 frag(v2f i) : SV_Target
            {
                float sigma = _Sigma * _T;

                float4 col;
                if (_Chroma > 0.0)
                {
                    float r = getColor(i.uv, sigma * (1.0 - _Chroma)).r;
                    float2 ga = getColor(i.uv, sigma).ga;
                    float b = getColor(i.uv, sigma * (1.0 + _Chroma)).b;
                    col = float4(r, ga.x, b, ga.y);
                }
                else
                {
                    col = getColor(i.uv, sigma);
                }

                col *= i.color;
                col.rgb += _Offset * _T;
                col.rgb = saturate(col.rgb);

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Blink

Blink 是通过时间和频率参数的控制，使纹理的颜色在屏幕上闪烁或波动，产生类似“眨眼”或闪烁的视觉效果。着色器中使用了噪声和时间控制来动态改变颜色，并通过一些其他参数来控制效果的强度和频率。

创建一个动态变化的“闪烁”效果，常用于视觉上的闪烁或类似眨眼的效果。通过控制时间（_T）、振幅（_Amp）、频率（_Freq）等参数，可以调节颜色的变化幅度和频率。该着色器使用噪声来驱动颜色的变化，从而让图像颜色看起来在某种周期性方式上变化（例如，颜色逐渐变暗、变亮，产生闪烁的效果）。

_MainTex: 主要纹理，默认为白色（"white"），该纹理的颜色会用作基础。

_T: 时间变量，控制着闪烁效果的动态性。通常在渲染时会根据时间传递给着色器，范围从0到1。

_Mul: 颜色乘法因子，用来调整图像的亮度。

_Offset: 用于调整颜色的偏移量，影响整体颜色。

_Amp: 振幅，控制颜色变化的强度。负值表示颜色变暗。

_Freq: 频率，用来控制噪声的变化频率，从而影响颜色的闪烁速度。

Shader "Nova/$VARIANT_NAME$/Blink"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Mul ("Multiplier", Float) = 1.0
        _Offset ("Offset", Float) = 0.0
        _Amp ("Amplitude", Float) = -0.5
        _Freq ("Frequency", Float) = 10.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Assets/Nova/CGInc/Rand.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex;
            float _T, _Mul, _Offset, _Amp, _Freq;

            fixed4 frag(v2f i) : SV_Target
            {
                // 使用 tex2D(_MainTex, i.uv) 从主纹理中获取颜色值。
                // 将顶点传递的颜色 i.color 与其相乘，应用顶点颜色。
                // 然后，通过 _Mul 对颜色的 RGB 通道进行乘法处理，调整图像的亮度。
                // 最后，通过 _Offset 增加颜色偏移，改变图像的亮度和颜色。
                float4 col = tex2D(_MainTex, i.uv) * i.color;
                col.rgb *= _Mul;
                col.rgb += _Offset;

                // noise(_Freq * _Time.y)：生成一个基于时间的噪声值。
                // _Time.y 表示自启动以来的时间（单位为秒），并且乘上了频率 _Freq 来控制噪声的变化速度。
                // n * n 使噪声值的影响更加剧烈，生成一个强烈的闪烁效果。
                // _Amp * n * n * _T：将噪声的振幅（_Amp）与时间 (_T) 相乘，从而控制效果随时间变化。
                // 这里 _T 的值会根据时间或其他控制因素进行变化，通常控制动画的进度。
                float n = noise(_Freq * _Time.y);
                col.rgb += _Amp * n * n * _T;

                // saturate(col.rgb) 确保颜色值在[0, 1]范围内，防止颜色溢出。
                // 这是为了确保颜色值不会超出有效范围，避免出现无效的颜色值。
                col.rgb = saturate(col.rgb);

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Broken TV

Broken TV 效果通常用于在游戏中表现图像破碎、扭曲、噪声等类似旧电视机的效果。它通过一些图像处理技术，例如扫描线、色差、噪声和扭曲来模拟这一效果。下面将详细解释这段代码的每个部分。

_MainTex: 主纹理，用于显示图像，默认为白色。

_T: 时间控制器，通常根据实际时间传递给着色器，控制动态效果的强度（例如图像的破碎程度）。

_Roll: 这个参数控制Y轴方向上的滚动效果，可能会影响图像在竖直方向的扭曲程度。

Shader "Nova/$VARIANT_NAME$/Broken TV"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Roll ("Y Rolling", Range(0.0, 1.0)) = 0.07
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Assets/Nova/CGInc/Rand.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            // power 函数用于生成一个非线性的时间变化
            // 它基于输入的x（在这里是 _T）计算一个“增强”值，使得时间越大，效果越强烈。
            float power(float x)
            {
                x += 1.0;
                x *= x;
                x *= x;
                x -= 1.0;
                return x;
            }

            sampler2D _MainTex;
            float _T, _Roll;

            fixed4 frag(v2f i) : SV_Target
            {
                // 使用前面定义的 power 函数来增强时间的影响，使得随着 _T 逐渐增大，效果会逐渐变得更强烈。
                float2 uv = i.uv;
                float powerT = power(_T);

                // xOffset 是根据时间和纹理坐标的纵向（uv.y）生成的噪声，增加了纹理水平位置的扭曲。
                // srand 和 snoise 都是噪声函数，srand 提供伪随机数，snoise 生成平滑的噪声。
                // 通过这些噪声，纹理的水平坐标会出现细微的扭曲，模拟图像的破碎或滚动效果。
                float2 ty = float2(_Time.y, uv.y * 20.0);
                float xOffset = srand(ty) * 0.01;
                xOffset += snoise(ty) * 0.05;
                float x = uv.x + xOffset * _T;

                // 垂直方向的偏移量 yOffset 会根据 xOffset 以及 _T 来动态变化
                // 同时与 _Roll 参数（控制垂直滚动的强度）相乘。
                // step 函数用来根据噪声生成的值和_Roll值决定是否进行滚动。
                // 使用 frac(uv.y + yOffset) 来确保纵向坐标 y 在 0 到 1 之间循环，从而制造扫描线效果。
                float yOffset = (_Time.y + xOffset) * powerT;
                yOffset *= step(noise(_Time.y), powerT * _Roll);
                float y = frac(uv.y + yOffset);

                // 这里通过水平位移 xOffset 来分别获取红色、绿色和蓝色通道的不同位置，实现色差效应
                // 使图像的颜色出现分离和偏移，模拟破损电视机的视觉效果。
                // Chromatic aberration
                float rbOffset = xOffset * 0.1 * powerT;
                float r = tex2D(_MainTex, float2(x - rbOffset, y)).r;
                float g = tex2D(_MainTex, float2(x, y)).g;
                float b = tex2D(_MainTex, float2(x + rbOffset, y)).b;
                float a = tex2D(_MainTex, float2(x, y)).a;
                float4 col = float4(r, g, b, a);
                col *= i.color;

                // 使用正弦函数生成纵向的扫描线效果，sin 函数产生周期性的波动，模拟电视屏幕的扫描线效果
                // _T 用来控制扫描线的强度。
                // Scan lines
                col.rgb -= sin((uv.y + _Time.x) * 500.0) * 0.1 * _T * col.a;

                // 这部分通过随机噪声在图像上叠加雪花噪声，增加破损的杂点效果。
                // Snow noise
                col.rgb += srand(uv * 100.0 + _Time.y) * 0.04 * powerT * col.a;

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Change Texture With Fade

Change Texture With Fade 通过两个纹理（_PrimaryTex 和 _SubTex）以及 _T 时间参数，创建了一个平滑的纹理过渡效果。_T 控制主纹理和副纹理之间的混合比例，_Offsets 控制纹理的偏移，_Color 和 _SubColor 控制两个纹理的颜色。这个效果可以用来实现纹理切换或渐变效果，常见于 UI 动画、过渡效果或动态场景切换等。

VARIANTS: Default
Shader "Nova/$VARIANT_NAME$/Change Texture With Fade"
{
    Properties
    {
        [HideInInspector] _MainTex ("Dummy Texture Providing Size", 2D) = "white" {}
        [NoScaleOffset] _PrimaryTex ("Primary Texture", 2D) = "white" {}
        [NoScaleOffset] _SubTex ("Secondary Texture", 2D) = "black" {}
        _Offsets ("Offsets (x1, y1, x2, y2)", Vector) = (0, 0, 0, 0)
        _Color ("Primary Texture Color", Color) = (1, 1, 1, 1)
        _SubColor ("Secondary Texture Color", Color) = (1, 1, 1, 1)
        _T ("Time", Range(0.0, 1.0)) = 0.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            #define clamped2D(tex, uv) tex2D((tex), clamp((uv), 0, 1))

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                return o;
            }

            sampler2D _PrimaryTex, _SubTex;
            float4 _Offsets, _Color, _SubColor;
            float _T;

            fixed4 frag(v2f i) : SV_Target
            {
                // lerp 函数用于计算主纹理和副纹理之间的插值
                // 在这里，lerp 的第一个参数是主纹理，第二个参数是副纹理，第三个参数是时间（_T）
                // _T 控制主纹理和副纹理的权重，_T = 0 时显示主纹理，_T = 1 时显示副纹理
                // 通过插值，_T 的值控制纹理的渐变效果

                // clamped2D(tex, uv) 是一个宏，用于从纹理中采样颜色
                // 同时确保 UV 坐标被限制在 [0, 1] 范围内，以防止越界
                // 它通过 clamp(uv, 0, 1) 实现，保证即使 UV 坐标超过边界，也会被“修剪”到有效范围内。
                float4 col = lerp(
                    // 对主纹理进行采样，并根据 _Offsets.xy 对 UV 坐标进行偏移
                    clamped2D(_PrimaryTex, i.uv - _Offsets.xy) * _Color,
	                // 对副纹理进行采样，并根据 _Offsets.zw 对 UV 坐标进行偏移
                    clamped2D(_SubTex, i.uv - _Offsets.zw) * _SubColor,
                    _T
                );

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Color

这段着色器代码实现了一个基于颜色操作的效果，允许用户通过时间参数（_T）动态调整纹理的颜色。

Shader "Nova/$VARIANT_NAME$/Color"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _ColorMul ("Color Multiplier", Color) = (1, 1, 1, 1)
        _ColorAdd ("Color Offset", Vector) = (0, 0, 0, 0)
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            $DEF_IADD_RGBA$

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex;
            float _T;
            float4 _ColorMul, _ColorAdd;

            // 使用 lerp 在原始颜色（col）和调整后的颜色（col2）之间进行线性插值
            // 权重由 _T 控制：
            // _T = 0: 输出为原始颜色。
            // _T = 1: 输出为调整后的颜色。
            fixed4 frag(v2f i) : SV_Target
            {
                float4 col = tex2D(_MainTex, i.uv) * i.color;
                float4 col2 = col * _ColorMul;
                IADD_RGBA(col2, _ColorAdd)
                col = lerp(col, col2, _T);

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Colorless

这段着色器代码实现了一个“去色”（Colorless）效果，它将颜色信息减少，突出明度，并通过噪声引入动态扰动。这种效果可以应用于场景渲染中的特殊视觉风格，例如模拟老旧电视或用于创造复古效果。以下是详细分析：

VARIANTS: PP
Shader "Nova/$VARIANT_NAME$/Colorless"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Assets/Nova/CGInc/Rand.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex;
            float _T;

            fixed4 frag(v2f i) : SV_Target
            {
                float4 col = tex2D(_MainTex, i.uv);

                // 使用简单噪声函数 snoise2 生成一个二维扰动向量。
                // i.uv * 10.0: 提高噪声频率，使得扰动更细致。
                // _Time.y: 动态时间，用于生成随时间变化的噪声。
                float2 v = 0.001 * snoise2(float3(i.uv * 10.0, _Time.y));
                // 将颜色转换为灰度值（明度）
                float gray = Luminance(col.rgb);

                // 使用灰度平方增加对高亮区域的扰动强度。
                // 进一步平方增强对高亮区域的区分度。
                // 乘以 _T，允许通过时间参数控制扰动效果。
                float mask = gray * gray;
                mask = 2.0 * mask * mask * _T;
                v *= mask;

                // 根据掩码调整扰动向量 v 的大小。
                // 在红色通道上向 +v 偏移采样，在绿色通道上向 -v 偏移采样。
                // 蓝色通道保持不变，模拟“去色”效果。
                col.r = tex2D(_MainTex, i.uv + v).r;
                col.g = tex2D(_MainTex, i.uv - v).g;

                col *= i.color;

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Fade

这里需要总结一下各个 Fade 之间的差异

Fade

这段着色器实现了一个渐变过渡效果（Fade），允许主纹理与次纹理之间进行平滑过渡，并使用遮罩图（Mask）定义过渡区域和效果模糊程度。以下是详细分析：

• 场景过渡效果:
  • 场景切换时实现从一种纹理渐变到另一种纹理的视觉过渡。
• 视觉特效:
  • 添加局部变化效果，如图像的动态擦除或显现。
• 高亮或隐蔽区域:
  • 使用遮罩图动态显示或隐藏纹理内容。

Shader "Nova/$VARIANT_NAME$/Fade"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        [NoScaleOffset] _SubTex ("Second Texture", 2D) = "black" {}
        _SubColor ("Second Texture Color", Color) = (1, 1, 1, 1)
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Mask ("Mask", 2D) = "white" {}
        _Vague ("Vagueness", Range(0.0, 0.5)) = 0.25
        _Offset ("Main Texture Luminosity Offset", Float) = 0.0
        _InvertMask ("Invert Mask", Float) = 0.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float2 uvMask : TEXCOORD1;
                float4 color : COLOR;
            };

            sampler2D _Mask;
            float4 _Mask_ST;

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.uvMask = TRANSFORM_TEX(v.uv, _Mask);
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex, _SubTex;
            float4 _SubColor;
            float _T, _Vague, _Offset, _InvertMask;

            fixed4 frag(v2f i) : SV_Target
            {
                // 使用 i.uvMask 从 _Mask 中采样红色通道，获取遮罩值
                // 当 _InvertMask 为 1 时，遮罩值将被反转（1 - t0）
                float t0 = tex2D(_Mask, i.uvMask).r;
                t0 = _InvertMask + t0 - 2 * _InvertMask * t0;
                // 根据 _Vague 参数，缩放遮罩值范围以控制过渡的边界模糊程度
                t0 = t0 * (1.0 - 2.0 * _Vague) + _Vague;
                // 使用 smoothstep 函数生成平滑的过渡边界
                // slope 控制边界梯度，基于 _Vague 的值动态调整。
                float slope = 0.5 / (_Vague + 0.001);
                float mask = smoothstep(0.0, 1.0, 0.5 + slope * (_T - t0));

                // 从主纹理采样颜色
                // 根据 _T 和 _Offset 参数动态调整亮度，并使用 saturate 限制颜色范围到 [0, 1]
                float4 col = tex2D(_MainTex, i.uv) * i.color;
                col.rgb += _Offset * _T;
                col.rgb = saturate(col.rgb);

                // 从次纹理采样颜色，并应用颜色乘数 _SubColor
                // 使用 lerp 函数在主纹理与次纹理之间进行线性插值，权重由 mask 决定
                float4 col2 = tex2D(_SubTex, i.uv) * _SubColor;
                col = lerp(col, col2, mask);

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Fade Global

从应用场景看：

Fade 着色器：用于局部渐变效果，支持基于遮罩（Mask）的渐变控制。适合需要通过遮罩纹理逐步显现或隐藏的效果，如局部区域的纹理切换或动态显示。

Fade Global 着色器：用于全局渐变，直接在两张纹理之间进行线性插值，无需遮罩纹理。适合全屏或整块纹理的渐变切换，如 UI 元素整体过渡或全屏特效

渐变控制方式看：

Fade 着色器：使用了遮罩纹理（_Mask）来控制渐变的范围和形状。提供模糊程度（_Vague）和遮罩反转（_InvertMask）参数，用于灵活调整渐变的细节。

Fade Global 着色器：通过 _T 参数直接控制两张纹理之间的全局线性插值，无需额外的遮罩纹理。偏移参数（_Offsets）可以调整两张纹理的 UV 坐标，实现基础的纹理偏移效果。

参数和灵活性看：

Fade 着色器：参数丰富，适合复杂的局部渐变效果：

• _Mask：遮罩纹理，决定渐变的范围。
• _Vague：模糊范围，影响过渡边缘的柔和程度。
• _InvertMask：控制遮罩的反转，灵活改变渐变的方向。

Fade Global 着色器：参数简单，专注于全局过渡：

• _T：用于控制全局混合的时间参数。
• _Offsets：简单的 UV 偏移调整，用于动态效果。

VARIANTS: Premul
Shader "Nova/$VARIANT_NAME$/Fade Global"
{
    Properties
    {
        [HideInInspector] _MainTex ("Dummy Texture Providing Size", 2D) = "white" {}
        [NoScaleOffset] _PrimaryTex ("Primary Texture", 2D) = "clear" {}
        [NoScaleOffset] _SubTex ("Secondary Texture", 2D) = "clear" {}
        _Offsets ("Offsets (x1, y1, x2, y2)", Vector) = (0, 0, 0, 0)
        _Color ("Primary Texture Color", Color) = (1, 1, 1, 1)
        _SubColor ("Secondary Texture Color", Color) = (1, 1, 1, 1)
        _T ("Time", Range(0.0, 1.0)) = 0.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            #define clamped2D(tex, uv) tex2D((tex), clamp((uv), 0, 1))

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                return o;
            }

            sampler2D _PrimaryTex, _SubTex;
            float4 _Offsets, _Color, _SubColor;
            float _T;

            fixed4 frag(v2f i) : SV_Target
            {
                // 实现较为简单，直接通过 lerp 函数进行两张纹理的线性插值：
                float4 col = lerp(
                    clamped2D(_PrimaryTex, i.uv - _Offsets.xy) * _Color,
                    clamped2D(_SubTex, i.uv - _Offsets.zw) * _SubColor,
                    _T
                );

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Fade Radial Blur

Fade Radial Blur 着色器是在之前渐变效果基础上，加入了径向模糊（Radial Blur）和动态缩放（Zoom）效果的增强版。以下是对其功能、特点和逻辑的详细分析，并与之前的 Fade 和 Fade Global 着色器进行对比。

虽然 Fade Radial Blur 在性能上比其他 Fade 系列着色器开销更大，但效果更具视觉冲击力，适用于对性能要求较低的场景，如过场动画或静态画面展示切换。

Shader "Nova/$VARIANT_NAME$/Fade Radial Blur"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        [NoScaleOffset] _SubTex ("Second Texture", 2D) = "black" {}
        _SubColor ("Second Texture Color", Color) = (1, 1, 1, 1)
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Size ("Size", Float) = 1.0
        _Zoom ("Zoom", Float) = 0.5
        _Dir ("Direction", Float) = 0.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Assets/Nova/CGInc/Blur.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex, _SubTex;
            float4 _MainTex_TexelSize, _SubColor;
            float _T, _Size, _Zoom, _Dir;
            $DEF_GSCALE$

            fixed4 frag(v2f i) : SV_Target
            {
                // 通过 uvShift 计算出以中心点 (0.5, 0.5) 为参考的偏移量
                float2 uvShift = i.uv - 0.5;
                // 根据缩放参数 _Zoom 和渐变时间 _T，动态计算放缩后的 UV 坐标
                float2 uvZoom = uvShift * (1.0 - _Zoom * _T * _Dir) + 0.5;
                // 第二纹理使用反向时间参数（1.0 - _T）计算放缩 UV
                float2 uvZoom2 = uvShift * (1.0 - _Zoom * (1.0 - _T) * (1.0 - _Dir)) + 0.5;
                // 使用模糊函数 tex2DMotionBlur 为主纹理和次纹理分别应用径向模糊
                // tex2DMotionBlur 是一个自定义函数，用于模拟径向模糊效果
                float4 col = tex2DMotionBlur(_MainTex,
                                             _MainTex_TexelSize * $GSCALE$, uvZoom,
                                             uvShift * _Size * _T) * i.color;
                float4 col2 = tex2DMotionBlur(_SubTex,
                                              _MainTex_TexelSize * $GSCALE$, uvZoom2,
                                              uvShift * _Size * (1.0 - _T)) * _SubColor;
                // 最终对主纹理和次纹理进行插值，权重由 _T 控制
                col = lerp(col, col2, _T);

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Final Blit

Final Blit 着色器的作用是在最终渲染阶段对画面进行屏幕空间调整，同时处理超出纹理范围的区域（即边缘部分）。这是一个用于图像后期处理的着色器，常用于对完整画面的最后渲染阶段进行自定义操作。

VARIANTS: Premul
Shader "Nova/$VARIANT_NAME$/Final Blit"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _Color ("Margin Color", Color) = (0, 0, 0, 1)
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                return o;
            }

            sampler2D _MainTex;
            float4 _Color;
            float _GW, _GH;

            fixed4 frag(v2f i) : SV_Target
            {
                float2 pivot = float2(0.5, 0.5);
                float2 uv = (i.uv - pivot) / float2(_GW, _GH) * _ScreenParams.xy + pivot;
                // eps 通常是指一个非常小的数值（epsilon），用于避免计算误差或浮点数比较问题。
                float eps = 1e-6;
                float4 col;

                if (uv.x > -eps && uv.x < 1 + eps && uv.y > -eps && uv.y < 1 + eps)
                {
                    col = tex2D(_MainTex, clamp(uv, 0, 1));
                }
                else
                {
                    col = _Color;
                }

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Flip Grid

着色器实现了一个网格翻转动画效果，其中两个纹理在动画过程中逐步翻转切换，表现为网格单元的动态过渡效果。以下是着色器的详细解读：

顶点着色器 vert

输入：appdata 包含顶点位置、UV 和颜色信息。

输出：v2f 包含屏幕空间顶点位置、UV、颜色和网格信息。

• 计算了网格的对角线总数 gridInfo.x。
• 计算每个单元格的翻转起始时间间隔 gridInfo.y。
• 储存翻转动画的半段时间 gridInfo.z。

片段着色器 frag 实现了动画翻转逻辑，分为三个阶段：

1. 未到翻转时间：网格的翻转还未开始，显示主纹理 _MainTex。

2. 翻转中：动态计算单元格内部的翻转动画。使用 smoothStepIn 实现平滑动画，计算旋转角度 theta。根据 theta 计算像素位置在旋转过程中是否落在当前单元格内，并选择合适的纹理。

3. 翻转完成：翻转结束，显示副纹理 _SubTex。

Shader "Nova/$VARIANT_NAME$/Flip Grid"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        [NoScaleOffset] _SubTex ("Second Texture", 2D) = "black" {}
        _SubColor ("Second Texture Color", Color) = (1, 1, 1, 1)
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _BackColor ("Background Color", Color) = (0, 0, 0, 1)
        _GridSize ("Grid Size", Float) = 64.0
        _FlipDuration ("Flip Duration", Range(0.0, 1.0)) = 0.5
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            #define PI 3.1415927
            #define smoothStepIn(x) ((x) * (x) * (2.0 - x))

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
                float3 gridInfo : TEXCOORD1; // x: max diag num; y: flip start time interval; z: half duration
            };

            sampler2D _MainTex, _SubTex;
            float4 _MainTex_TexelSize, _SubColor, _BackColor;
            float _T, _GridSize, _FlipDuration;

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                float2 gridIndex = _MainTex_TexelSize.zw / _GridSize;
                o.gridInfo.x = round(gridIndex.x) + round(gridIndex.y);
                o.gridInfo.y = (1.0 - _FlipDuration) / o.gridInfo.x;
                o.gridInfo.z = _FlipDuration / 2.0;
                return o;
            }

            fixed4 frag(v2f i) : SV_Target
            {
                float2 pixelPos = i.uv * _MainTex_TexelSize.zw / _GridSize;
                float2 gridIndex = floor(pixelPos); // Left bottom point of grid
                float gridDiagIndex = gridIndex.x + gridIndex.y;
                float flipStartTime = gridDiagIndex * i.gridInfo.y;
                float flipEndTime = flipStartTime + _FlipDuration;

                float4 col = _BackColor;

                if (flipStartTime > _T)
                {
                    // Transition has not arrive here
                    col = tex2D(_MainTex, i.uv) * i.color;
                }
                else if (flipEndTime < _T)
                {
                    // Transition finished
                    col = tex2D(_SubTex, i.uv) * _SubColor;
                }
                else
                {
                    float2 p = frac(pixelPos);
                    float2 intersect = float2(1 + p.x - p.y, 1 - p.x + p.y) / 2.0;
                    float deltaTime = _T - flipStartTime;
                    if (deltaTime < i.gridInfo.z)
                    {
                        float theta = PI / 2.0 * smoothStepIn(deltaTime / i.gridInfo.z);
                        float dis = (1 - p.x - p.y) * 0.5 / (cos(theta) + 0.001);
                        float2 q = intersect - dis;
                        if (q.x < 0.0 || q.y < 0.0 || q.x > 1.0 || q.y > 1.0)
                        {
                            return col;
                        }
                        float2 realUV = (gridIndex + q) * _GridSize * _MainTex_TexelSize.xy;
                        col = tex2D(_MainTex, realUV) * i.color;
                    }
                    else
                    {
                        float theta = PI / 2.0 * smoothStepIn(
                            (_FlipDuration - deltaTime) / i.gridInfo.z);
                        float dis = (1 - p.x - p.y) * 0.5 / (cos(theta) + 0.001);
                        float2 q = intersect - dis;
                        if (q.x < 0.0 || q.y < 0.0 || q.x > 1.0 || q.y > 1.0)
                        {
                            return col;
                        }
                        float2 realUV = (gridIndex + q) * _GridSize * _MainTex_TexelSize.xy;
                        col = tex2D(_SubTex, realUV) * _SubColor;
                    }
                }

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Gaussian Blur

着色器实现了高斯模糊（Gaussian Blur）的效果，并且可以通过一些参数动态调整模糊程度、偏移值以及过渡效果。

Shader "Nova/$VARIANT_NAME$/Gaussian Blur"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Size ("Size", Float) = 1.0
        _Offset ("Offset", Float) = 0.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Assets/Nova/CGInc/Blur.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex;
            float4 _MainTex_TexelSize;
            float _T, _Size, _Offset;
            $DEF_GSCALE$

            fixed4 frag(v2f i) : SV_Target
            {
                float4 col = tex2DGaussianBlur(_MainTex,
                                               _MainTex_TexelSize * $GSCALE$,
                                               i.uv, _Size * _T);
                col *= i.color;
                col.rgb += _Offset * _T;
                col.rgb = saturate(col.rgb);

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Gitch

着色器实现了一个 Glitch 特效，模仿了电子设备显示错误或信号干扰时的视觉效果。它通过噪声函数和动态 UV 偏移来创建这些效果。

Shader "Nova/$VARIANT_NAME$/Glitch"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Assets/Nova/CGInc/Rand.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            float blockNoise(float2 uv, float freqX, float freqY, float freqT)
            {
                float a = floor(noise(_Time.y * freqT) * 100.0);
                a = floor(noise(uv.y * freqY + a) * 100.0);
                a = floor(noise(uv.x * freqX + a) * 100.0);
                a = floor(noise(uv.y * freqY + a) * 100.0);
                a = rand(a);
                return a;
            }

            float power(float x)
            {
                x += 1.0;
                x *= x;
                x *= x;
                x -= 1.0;
                return x;
            }

            float blockOffsetPass(float2 uv, float freqX, float freqY, float freqT,
                                  float threshold, float value)
            {
                float blockOffsetOn = blockNoise(uv, freqX, freqY, freqT);
                if (blockOffsetOn < threshold)
                {
                    return value;
                }
                return 0.0;
            }

            sampler2D _MainTex;
            float _T;

            fixed4 frag(v2f i) : SV_Target
            {
                float2 uv = i.uv;
                float powerT = power(_T);

                // 计算是否启用偏移，如果噪声值小于 _T，则启用偏移
                float uvOffsetOn = blockNoise(uv, 0.2, 0.2, 0.05);
                float2 uvOffset = float2(0.0, 0.0);
                if (uvOffsetOn < _T)
                {
                    // 偏移量基于噪声生成，模拟随机抖动
                    uvOffset.x = srand(uvOffsetOn) * 0.1;
                    uvOffset.y = srand(uvOffset.x) * 0.1;
                }
                // 应用偏移到 UV 坐标
                float2 uv2 = uv + uvOffset;

                // rbOffset 用于后续的颜色错位计算
                float rbOffsetOn = blockNoise(uv, 0.1, 0.1, 0.5);
                float2 rbOffset = float2(0.0, 0.0);
                if (rbOffsetOn < 0.2 * _T)
                {
                    rbOffset.x = srand(rbOffsetOn) * 0.1;
                    rbOffset.y = srand(rbOffset.x) * 0.1;
                }

                // 为了增强 Glitch 效果，着色器对 RGB 三个通道应用不同的 UV 偏移
                // 这种处理方式模仿了图像的 RGB 分量发生错位的视觉现象
                // R 通道：使用负偏移
                // G 通道：无偏移
                // B 通道：使用正偏移
                float r = tex2D(_MainTex, uv2 - rbOffset).r;
                float g = tex2D(_MainTex, uv2).g;
                float b = tex2D(_MainTex, uv2 + rbOffset).b;
                float a = tex2D(_MainTex, uv2).a;
                float4 col = float4(r, g, b, a);
                col *= i.color;

                // blockOffsetPass 函数实现了局部的块状干扰
                // 使用 blockNoise 判断当前区域是否启用块状干扰
                // 如果启用，返回指定的干扰值（如 -0.5 或 1.0）
                // 最终影响 col.rgb，形成随机的局部亮度或颜色突变
                float blockOffset = 0.0;
                blockOffset += blockOffsetPass(uv, 0.5, 5.0, 0.1, 0.06 * powerT, -0.5);
                blockOffset += blockOffsetPass(uv, 2.0, 4.0, 0.1, 0.002 * powerT, 1.0);
                col.rgb += blockOffset;
                // 使用 saturate 限制 RGB 值范围，防止因偏移和干扰导致的颜色溢出或显示异常
                col.rgb = saturate(col.rgb);

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Glow

这段代码实现了一个简单的 Glow（辉光） 特效的 Shader，用于在 Unity 中制作具有发光效果的材质。我们可以从多个方面来理解这个 Shader 的实现，包括它的结构、如何处理顶点数据、如何实现辉光效果、以及如何调整和增强这种效果。下面我会详细讲解每个部分的功能。

Shader "Nova/$VARIANT_NAME$/Glow"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Size ("Size", Float) = 1.0
        _Strength ("Strength", Float) = 1.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Assets/Nova/CGInc/Blur.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex;
            float4 _MainTex_TexelSize;
            float _T, _Size, _Strength;
            $DEF_GSCALE$

            fixed4 frag(v2f i) : SV_Target
            {
                // 1. 从主纹理采样颜色
                float4 col = tex2D(_MainTex, i.uv) * i.color;

                // 2. 计算辉光效果，应用高斯模糊
                float3 glow = tex2DGaussianBlur(_MainTex,
                                                _MainTex_TexelSize * $GSCALE$,
                                                i.uv,
                                                _Size * _T).rgb * i.color.rgb;
                // 3. 强化辉光效果的亮度
                glow *= glow;
                glow *= glow;

                // 4. 根据时间和强度调整辉光的最终亮度
                glow *= _Strength * _T;
                // 5. 保证辉光的亮度值在 [0, 1] 范围内
                glow = saturate(glow);

                // 6. 将辉光与原始颜色合并
                col.rgb = col.rgb + glow - col.rgb * glow;

                $VARIANT_RGB$
                // 8. 返回最终的颜色值
                return col;
            }
            ENDCG
        }
    }
}

Gray Wave

Gray Wave 的 Shader，它根据噪声（noise）和时间控制来生成一种灰度波浪效果。下面我们逐行解析这个 Shader，理解每个部分的作用。

Shader "Nova/$VARIANT_NAME$/Gray Wave"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Freq ("Frequency", Float) = 0.5
        _Size ("Size", Float) = 50.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Assets/Nova/CGInc/Rand.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex;
            float _T, _Freq, _Size;

            fixed4 frag(v2f i) : SV_Target
            {
                // 1. 从主纹理采样颜色
                float4 col = tex2D(_MainTex, i.uv) * i.color;

                // 2. 生成噪声并调整颜色
                float n = noise(_Freq * _Time.y);

                // 3. 计算灰度波浪效果
                float3 delta = col.rgb - n;
                col.rgb /= (1.0 + _Size * delta * delta);

                $VARIANT_RGB$

                // 5. 返回最终的颜色
                return col;
            }
            ENDCG
        }
    }
}

Kaleidoscope

这个 Shader 实现了一个 Kaleidoscope（万花筒） 效果，使用了纹理的重复、旋转和渐变过渡来模拟万花筒的视觉效果。它根据输入的纹理和时间参数，产生一种类似万花筒镜面反射的效果，使得纹理看起来像是反射在多个镜面上的样子。

万花筒（Kaleidoscope） 效果，主要通过以下几个步骤来实现：

• 对称与反射：通过对纹理坐标的操作，使得纹理重复反射，模拟镜面效果。
• 旋转：使用时间和正弦余弦函数控制每次反射时的旋转，模拟动态的万花筒效果。
• 平滑过渡：使用时间 (_T) 进行插值，以实现平滑的效果过渡。

Shader "Nova/$VARIANT_NAME$/Kaleido"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Repeat ("Repeat", Float) = 8.0
        _Freq ("Frequency", Float) = 1.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
                float2 cosSinTime : TEXCOORD1;
            };

            float _Repeat;

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                float t = _Time.y / _Repeat;
                // 这行代码计算时间（_Time.y）的正弦和余弦值，并将其存储在 cosSinTime 中
                o.cosSinTime = float2(cos(t), sin(t));
                return o;
            }

            sampler2D _MainTex;
            float _T, _Freq;

            fixed4 frag(v2f i) : SV_Target
            {
                // 从主纹理采样颜色值
                float4 col = tex2D(_MainTex, i.uv);

                // 将纹理坐标 uv 从 [0, 1] 范围映射到 [-0.5, 0.5] 范围，以便后续进行对称操作
                float2 uv = i.uv - 0.5;
                // 使用循环实现镜面反射的重复效果
                // _Repeat 控制镜面反射的数量
                // 每次迭代中，都会对 uv 进行对称操作，从而实现类似万花筒的镜像效果。
                for (int repeat = 0; repeat < _Repeat; ++repeat)
                {
                    // 将 uv 转换为绝对值，产生对称效果，并且减少一些偏移量以调整对称的位置。
                    uv = abs(uv) - 0.25;
                    // 通过交换 x 和 y 分量并应用符号函数（sign），进一步产生对称效果
                    uv *= sign(uv + uv.yx);
                    // 根据 cosSinTime 对 uv 进行旋转，产生旋转效果，从而实现万花筒效果的视觉旋转
                    uv = i.cosSinTime.x * uv + i.cosSinTime.y * uv.yx * float2(1.0, -1.0);
                }
                // 将 uv 坐标重新映射回 [0, 1] 范围。
                uv += 0.5;
                // 从调整后的 uv 坐标中再次从纹理采样颜色 col2
                float4 col2 = tex2D(_MainTex, uv);

                // 使用 lerp 函数（线性插值）在原始颜色 col 和新采样的颜色 col2 之间进行平滑过渡
                // 过渡程度由 _T 控制。同时，乘以顶点的颜色 i.color，以便影响最终颜色
                col = lerp(col, col2, _T) * i.color;

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Lens Blur

Lens Blur（镜头模糊） 效果，它通过将模糊效果应用于纹理，根据时间和参数来模拟镜头焦外模糊的视觉效果。我们逐行解析这个 Shader，理解每个部分的作用。

Shader "Nova/$VARIANT_NAME$/Lens Blur"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Size ("Size", Float) = 1.0
        _Offset ("Offset", Float) = 0.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Assets/Nova/CGInc/Blur.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex;
            float4 _MainTex_TexelSize;
            float _T, _Size, _Offset;
            $DEF_GSCALE$

            fixed4 frag(v2f i) : SV_Target
            {
                // 这是一个自定义的模糊函数（定义在 Blur.cginc 中），其作用是对纹理应用镜头模糊效果
                float4 col = tex2DLensBlur(_MainTex,
                                           _MainTex_TexelSize * $GSCALE$,
                                           i.uv, _Size * _T);
                col *= i.color;
                col.rgb += _Offset * _T;
                col.rgb = saturate(col.rgb);

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Masked Mosaic

Masked Mosaic（带遮罩的马赛克）效果，它结合了纹理、时间、遮罩以及马赛克效果，通过对像素进行不同强度的采样，来模拟马赛克效果，同时使用遮罩来控制不同区域的效果强度。

• 马赛克效果：通过将纹理坐标对齐到固定的块大小（_Size），并通过随机偏移（srand2）使每个马赛克块有所变化，模拟马赛克效果。
• 遮罩控制：通过遮罩纹理（_Mask）控制哪些区域应用马赛克效果，并通过 _T 参数动态调整遮罩的强度。
• 动态变化：时间参数 _T 控制遮罩效果的动态变化，使得马赛克效果可以随着时间变化

Shader "Nova/$VARIANT_NAME$/Masked Mosaic"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Mask ("Mask", 2D) = "white" {}
        _Size ("Size", Float) = 4.0
        _Strength ("Mosaic Strength", Float) = 8.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Assets/Nova/CGInc/Rand.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex, _Mask;
            float4 _MainTex_TexelSize;
            float _T, _Size, _Strength;
            $DEF_GSCALE$

            fixed4 frag(v2f i) : SV_Target
            {
                float4 col = tex2D(_MainTex, i.uv);

                // 计算当前像素在屏幕上的位置，并通过 floor 函数将其对齐到指定的马赛克块大小（_Size）
                // 这使得每个马赛克块的中心都对齐
                float4 screenPos = ComputeScreenPos(floor(i.vertex / _Size) * _Size);
                // 使用自定义的 srand2 函数生成一个基于屏幕位置和时间的随机偏移量
                // 这样每个像素的偏移是基于位置的，这能够给每个马赛克块引入轻微的随机化，使得效果更自然
                float2 delta = srand2(float3(screenPos.xy, _Time.y));
                // 根据随机偏移量 delta 对当前纹理坐标 uv 进行调整
                // 调整后的 uv2 用来从主纹理中采样一个新的颜色，这个颜色将作为马赛克块的代表颜色
                float2 uv2 = i.uv + delta * _MainTex_TexelSize.xy * $GSCALE$ * _Strength;
                // 从调整后的纹理坐标 uv2 中采样颜色 col2
                float4 col2 = tex2D(_MainTex, uv2);

                // 从遮罩纹理 _Mask 中采样红色分量，值通常在 [0, 1] 范围内，用来控制马赛克效果的应用程度
                // 将遮罩值乘以时间 _T，以便动态地控制遮罩效果的强度
                float mask = tex2D(_Mask, i.uv).r * _T;
                // 根据遮罩值 mask 在原始颜色 col 和采样到的 col2（马赛克块的颜色）之间进行插值
                // mask 越大，col2 的影响就越强，表示遮罩区域内会应用更多的马赛克效果
                col = lerp(col, col2, mask) * i.color;

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Mix Add

混合添加（Mix Add） 的效果，结合了主纹理、遮罩、颜色乘法、颜色加法等多种操作。通过使用这些操作，Shader 将主纹理和额外的效果进行混合，最后生成输出颜色。

• 主纹理采样：根据纹理坐标从主纹理中采样颜色，并结合顶点颜色。
• 遮罩控制：通过遮罩纹理控制哪些区域受到效果影响，反转遮罩的功能由 _InvertMask 控制。
• 颜色乘法和加法：通过 _ColorMul 进行颜色乘法（调整亮度或对比度），并通过 _ColorAdd 对颜色进行偏移（加法）。
• 透明度调整：通过 _AlphaFactor 动态调整颜色的透明度。
• 动态变化：时间参数 _T 动态控制混合效果的强度。

Shader "Nova/$VARIANT_NAME$/Mix Add"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Mask ("Mask", 2D) = "white" {}
        _ColorMul ("Color Multiplier", Color) = (1, 1, 1, 1)
        _ColorAdd ("Color Offset", Vector) = (0, 0, 0, 0)
        _InvertMask ("Invert Mask", Float) = 0.0
        _AlphaFactor ("Alpha Factor", Float) = 0.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            $DEF_IADD_RGBA$

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float2 uvMask : TEXCOORD1;
                float4 color : COLOR;
            };

            sampler2D _Mask;
            float4 _Mask_ST;

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.uvMask = TRANSFORM_TEX(v.uv, _Mask);
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex;
            float4 _ColorMul, _ColorAdd;
            float _T, _InvertMask, _AlphaFactor;

            fixed4 frag(v2f i) : SV_Target
            {
                // 从主纹理中根据纹理坐标 i.uv 采样颜色，乘以顶点颜色 i.color 得到最终颜色 col
                float4 col = tex2D(_MainTex, i.uv) * i.color;
                // 从遮罩纹理中采样红色通道的值，并存储在 mask 变量中
                // 值通常在 [0, 1] 范围内，表示该像素是否应该受到影响
                float mask = tex2D(_Mask, i.uvMask).r;
                // 根据 _InvertMask 参数，决定是否反转遮罩效果
                // 如果 _InvertMask 为 1，则遮罩会被反转（即黑色区域变为白色，白色区域变为黑色）
                mask = _InvertMask + mask - 2 * _InvertMask * mask;

                float4 maskColor;
                // 根据 _InvertMask 参数，决定是否反转遮罩效果
                // 如果 _InvertMask 为 1，则遮罩会被反转（即黑色区域变为白色，白色区域变为黑色）
                maskColor.rgb = mask;
                // 将主纹理的 alpha 通道值赋给 maskColor，确保透明度保持一致
                maskColor.a = col.a;
                // 应用颜色乘法因子 _ColorMul，这会调整颜色的亮度或对比度
                maskColor *= _ColorMul;
                // 通过自定义的宏 IADD_RGBA，将颜色偏移（_ColorAdd）添加到 maskColor 上
                IADD_RGBA(maskColor, _ColorAdd)
                // 通过 _AlphaFactor 参数调整 maskColor 的 alpha 通道值，从而影响透明度
                maskColor.a *= _AlphaFactor;
                // 将处理后的 maskColor 与原始颜色 col 混合。_T 参数控制混合的强度
                col = saturate(col + _T * maskColor);

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Mono

Mono Shader 实现了一个简单的单色化（灰度化）效果，可以通过控制 _T 参数来调整原图和单色效果的过渡。具体而言，它会根据像素的亮度（灰度）生成一个灰度图像，然后通过混合原图和灰度图来创建一个逐渐转换为单色效果的过渡。

Shader "Nova/$VARIANT_NAME$/Mono"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        // 颜色乘法因子，用来调整混合颜色的亮度或对比度
        _ColorMul ("Color Multiplier", Color) = (1, 1, 1, 1)
        // 颜色偏移（加法），将其添加到灰度图的颜色中，用于调整颜色的亮度、饱和度等
        _ColorAdd ("Color Offset", Vector) = (0, 0, 0, 0)
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            $DEF_IADD_RGBA$

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex;
            float _T;
            float4 _ColorMul, _ColorAdd;

            fixed4 frag(v2f i) : SV_Target
            {
                float4 col = tex2D(_MainTex, i.uv) * i.color;
                // 计算当前像素颜色的灰度值
                // Luminance 是根据颜色的加权平均值来计算亮度
                // 通常为 0.299 * R + 0.587 * G + 0.114 * B，人眼对各颜色的敏感度不同，因此加权不同
                float gray = Luminance(col.rgb);

                float4 mono;
                // 将灰度值 gray 赋值给 mono.rgb，这样所有的 RGB 分量都等于灰度值，从而实现灰度图的效果
                mono.rgb = gray;
                // 保持原始颜色的 alpha 通道，确保透明度信息不变
                mono.a = col.a;
                // 将灰度图颜色应用颜色乘法因子 _ColorMul，可以用来调整灰度图的亮度或对比度
                mono *= _ColorMul;
                // 将颜色偏移 _ColorAdd 添加到灰度颜色 mono 上，从而调整最终的颜色
                IADD_RGBA(mono, _ColorAdd)

                // 根据时间参数 _T 混合原图和灰度图
                //如果 _T 为 0，则完全是原图颜色, 如果 _T 为 1，则完全是灰度图
                // lerp 是线性插值函数，计算两个值之间的加权平均
                col = lerp(col, mono, _T);

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Motion Blur

运动模糊（Motion Blur）的效果，主要通过采样和加权周围的像素来模糊当前的像素，从而模拟物体或摄像机的运动轨迹。通过调节 _T（时间），_Size（模糊大小），_Theta（方向角度），和 _Offset（偏移量）来控制效果的强度和方向。

_MainTex：主纹理，通常是场景的渲染图像，默认为白色纹理。

_T：时间控制参数（[0.0, 1.0]），用于控制运动模糊的强度。_T = 0 时没有模糊，_T = 1 时模糊最大。

_Size：模糊的大小，决定了模糊的范围。值越大，模糊效果越强。

_Theta：模糊的方向角度，决定了模糊的朝向。

_Offset：模糊后的颜色偏移量，用来调整最终颜色的亮度。

Shader "Nova/$VARIANT_NAME$/Motion Blur"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Size ("Size", Float) = 1.0
        _Theta ("Theta", Float) = 0.0
        _Offset ("Offset", Float) = 0.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Assets/Nova/CGInc/Blur.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex;
            float4 _MainTex_TexelSize;
            float _T, _Size, _Theta, _Offset;
            $DEF_GSCALE$

            fixed4 frag(v2f i) : SV_Target
            {
                // 这个函数使用纹理采样和偏移来计算模糊的颜色
                // _MainTex 是主纹理
                // _MainTex_TexelSize * $GSCALE$ 是纹理的每个像素的大小
                // i.uv 是当前纹理坐标
                // float2(cos(_Theta), sin(_Theta)) 用于计算模糊方向
                // _Size * _T 控制模糊的大小和强度
                float4 col = tex2DMotionBlur(_MainTex,
                                             _MainTex_TexelSize * $GSCALE$,
                                             i.uv,
                                             float2(cos(_Theta),
                                             sin(_Theta)) * _Size * _T);
                // 将纹理颜色与顶点颜色相乘，以实现顶点颜色对最终结果的影响
                col *= i.color;
                // 将 _Offset 加到颜色的 RGB 分量中，乘以 _T，这样可以根据时间调整偏移量
                col.rgb += _Offset * _T;
                // 将颜色的 RGB 分量限制在 [0, 1] 的范围内，防止颜色溢出
                col.rgb = saturate(col.rgb);

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Overglow

Overglow 的效果，主要是通过根据时间 (_T) 动态调整纹理的缩放和平移，产生一种光晕效果。_Zoom 和 _Mul 控制效果的强度和缩放范围，_CenterX 和 _CenterY 确定光晕的中心位置。

_MainTex：主纹理，用于渲染图像，默认为白色纹理。

_T：时间控制参数，用于控制光晕效果的动态变化。_T = 0 时无变化，_T = 1 时光晕达到最大效果。

_Zoom：光晕缩放值，决定了光晕的缩放范围。值越大，缩放越小，光晕越大。

_Mul：乘法器，用于控制光晕效果的强度。

_CenterX, _CenterY：确定光晕中心的位置。默认为纹理中心 (0.5, 0.5)。

Shader "Nova/$VARIANT_NAME$/Overglow"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Zoom ("Zoom", Float) = 0.5
        _Mul ("Multiplier", Float) = 0.5
        _CenterX ("Center X", Float) = 0.5
        _CenterY ("Center Y", Float) = 0.5
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex;
            float _T, _Zoom, _Mul, _CenterX, _CenterY;

            fixed4 frag(v2f i) : SV_Target
            {
                // 计算光晕效果的中心位置，使用了 _CenterX 和 _CenterY 来决定
                float2 center = float2(_CenterX, _CenterY);
                // 计算新的纹理坐标 uv2，它是基于原始纹理坐标 i.uv 按照中心位置 center 进行缩放和平移的
                // 通过 (1.0 - _Zoom * _T) 来动态缩放纹理坐标
                // _Zoom 控制缩放大小，_T 则是随着时间的推移变化，控制光晕的扩展效果
                float2 uv2 = (i.uv - center) * (1.0 - _Zoom * _T) + center;
                // 获取原始纹理坐标 i.uv 上的颜色值，并与顶点颜色相乘（i.color）
                float4 col = tex2D(_MainTex, i.uv) * i.color;
                // 获取基于新计算的纹理坐标 uv2 的颜色值，模拟偏移后的光晕效果
                float4 col2 = tex2D(_MainTex, uv2) * i.color;
                // 将光晕颜色 col2 加入到原始颜色 col 中
                // _Mul 是强度控制，(1.0 - _T) 是控制光晕随时间的衰减
                // 随着时间的变化，光晕效果的强度逐渐减弱
                col.rgb += col2.rgb * _Mul * (1.0 - _T);
                // 使用 saturate 函数将最终颜色的 RGB 分量限制在 [0, 1] 范围内，避免颜色溢出
                col.rgb = saturate(col.rgb);

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Overlay

Overlay 效果，主要通过一个基本的顶点着色器和片元着色器来将一个纹理渲染到屏幕上，并且使用了 clamp 函数确保纹理坐标在 [0, 1] 范围内。它不做其他复杂的颜色混合或特效，只是将一个纹理应用到物体表面。

这种类型的 Shader 在图像叠加效果、UI 渲染或者背景图像渲染等场景中非常有用。例如，可以用它来叠加一个背景纹理，或者在游戏中特效图像层上叠加纹理，确保纹理总是渲染到屏幕上

VARIANTS: Premul
Shader "Nova/$VARIANT_NAME$/Overlay"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
    }
    SubShader
    {
        $VARIANT_TAGS$
        ZTest Always

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            #define clamped2D(tex, uv) tex2D((tex), clamp((uv), 0, 1))

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
            };

            v2f vert(appdata v)
            {
                v2f o;
                // render directly to clip space
                o.vertex = v.vertex;
                o.uv = v.uv;
            #ifdef UNITY_UV_STARTS_AT_TOP
                o.uv.y = 1.0 - o.uv.y;
            #endif
                return o;
            }

            sampler2D _MainTex;

            fixed4 frag(v2f i) : SV_Target
            {
                return clamped2D(_MainTex, i.uv);
            }
            ENDCG
        }
    }
}

Radial Blur

Radial Blur（径向模糊）效果的 Shader，模糊是基于像素到中心的距离来进行计算的。下面我会详细讲解这段代码的每一部分，帮助你理解其实现原理。

_Size：控制模糊的范围，越大越模糊。

_Offset：控制模糊的偏移量。

_T：时间控制，可能用来实现动画过渡的效果。

Shader "Nova/$VARIANT_NAME$/Radial Blur"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Size ("Size", Float) = 1.0
        _Offset ("Offset", Float) = 0.0
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Assets/Nova/CGInc/Blur.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.color = v.color;
                return o;
            }

            sampler2D _MainTex;
            float4 _MainTex_TexelSize;
            float _T, _Size, _Offset;
            $DEF_GSCALE$

            fixed4 frag(v2f i) : SV_Target
            {
                // 将纹理坐标从 [0, 1] 范围转换到以 (0.5, 0.5) 为中心的范围
                // 这样做的目的是计算像素相对于中心点的偏移量
                float2 uvShift = i.uv - 0.5;
                // 实现模糊效果。根据 uvShift 的大小以及 _Size 和 _T 控制模糊的强度和范围
                float4 col = tex2DMotionBlur(_MainTex,
                                             _MainTex_TexelSize * $GSCALE$,
                                             i.uv, uvShift * _Size * _T);
                col *= i.color;
                // 根据像素离中心点的距离（length(uvShift)），调整颜色的偏移量
                // _Offset 控制了这个偏移的强度
                col.rgb += _Offset * length(uvShift) * _T;
                // 通过 saturate 函数将颜色限制在 [0, 1] 范围内，防止颜色溢出
                col.rgb = saturate(col.rgb);

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}

Rain

一个模拟 雨滴效果 的视觉效果，基于时间和不同层次的降水模拟生成动画效果。

Shader "Nova/$VARIANT_NAME$/Rain"
{
    Properties
    {
        [HideInInspector] _MainTex ("Main Texture", 2D) = "white" {}
        _T ("Time", Range(0.0, 1.0)) = 0.0
        _Size ("Size", Float) = 2.0
        _Aspect ("Aspect Ratio", Float) = 1.77777778
    }
    SubShader
    {
        $VARIANT_TAGS$
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Assets/Nova/CGInc/Blur.cginc"
            #include "Assets/Nova/CGInc/Rand.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float4 color : COLOR;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float2 uvEffect : TEXCOORD1;
                float4 color : COLOR;
            };

            float _Size, _Aspect;

            v2f vert(appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.uvEffect = float2(v.uv.x * _Size * _Aspect, v.uv.y * _Size);
                o.color = v.color;
                return o;
            }

            // 插值函数，让过渡更加自然
            float S(float a, float b, float t)
            {
                t = saturate((t - a) / (b - a));
                return t * t * (3.0 - 2.0 * t);
            }

            // 锯齿波函数
            float saw(float b, float t)
            {
                return S(0.0, b, t) * S(1.0, b, t);
            }

            // 静态雨滴
            float staticDrops(float2 uv, float t)
            {
                // 使用随机函数rand3生成随机雨滴位置
                float3 n = rand3(floor(uv));
                // 计算雨滴距离中心的长度d，决定雨滴大小
                float d = length(frac(uv) - n.xy);
                // 随机生成的z分量用于控制雨滴的出现时机（fade效果）
                float fade = saw(0.5, frac(t + n.z));
                // 输出雨滴亮度c，用于静态背景层的效果
                float c = S(0.3, 0.0, d) * frac(n.z * 1000.0) * fade;
                return c;
            }

            // 动态雨滴层
            float2 dropLayer(float2 uv, float t)
            {
                float2 UV = uv;

                // 表示雨滴的分布密度。横向有12列，纵向有2行
                float2 grid = float2(12.0, 2.0);
                // 为每列雨滴添加随机的偏移量，使其下落时间和速度不同，模拟自然随机性。
                float colShift = rand(floor(uv.x * grid.x));
                // 修改UV的 y 坐标，动态模拟雨滴的下落
                uv.y += t + colShift;

                // 将UV坐标映射到网格单元中
                float2 uvGrid = uv * grid;
                // 为当前网格单元生成随机值 n，其三个分量分别控制
                // n.x：雨滴水平位置。
                // n.y：雨滴拖尾的动态扰动。
                // n.z：雨滴的生成时机。
                float3 n = rand3(floor(uvGrid));
                // 计算当前UV在网格单元内的局部坐标，并偏移到中心点
                float2 st = frac(uvGrid) - float2(0.5, 0.0);

                // 添加水平扰动和下落动画
                // x 方向扰动：
                // 初始的 x=n.x−0.5x=n.x−0.5，将雨滴位置中心化。
                // 通过 wiggle 引入动态扰动，增加雨滴下落时的“左右摇摆”效果。
                // x∗=0.7x∗=0.7：缩小水平移动范围，保持雨滴的自然性。
                float x = n.x - 0.5;
                float wiggle = UV.y * 20.0;
                wiggle = sin(wiggle + sin(wiggle));
                x += wiggle * (0.5 - abs(x)) * (n.y - 0.5);
                x *= 0.7;
                // 使用 saw 函数生成锯齿波模拟雨滴的下落位置，周期性出现新的雨滴
                // frac(t + n.z) 保证每个雨滴的下落时机不同
                float y = saw(0.8, frac(t + n.z));
                // 计算当前点与雨滴中心 (x,y) 的距离 d
                float d = length((st - float2(x, y)) * grid.yx);
                // 使用平滑插值函数 S 渐变控制雨滴的形状，使雨滴看起来圆润且边缘模糊
                float mainDrop = S(0.4, 0.0, d);

                // 添加拖尾效果
                // r：用于限制拖尾的起始位置，只在雨滴下方生成拖尾。
                // trail：控制拖尾的宽度（通过 abs(st.x−x)abs(st.x−x) 计算），拖尾越靠近雨滴中心越强。
                // trailFront：控制拖尾的长度，确保拖尾仅出现在雨滴下方且逐渐消失。
                float r = S(1.0, y, st.y);
                float trail = S(0.2, 0.0, abs(st.x - x));
                float trailFront = S(-0.02, 0.02, st.y - y);
                trail *= trailFront * r;

                // 添加飞溅小雨滴
                // 随机生成小雨滴，分布在主雨滴周围。
                // 使用局部随机扰动（frac(UV.y * 10.0)）生成多个小雨滴。
                // 小雨滴的大小由距离 dddd 决定，靠近雨滴中心的区域更亮。
                y = frac(UV.y * 10.0) + (st.y - 0.5);
                float dd = length(st - float2(x, y));
                float droplets = S(0.3, 0.0, dd);

                // 合成主雨滴与其他效果
                // 将主雨滴、拖尾和飞溅效果整合为一个整体亮度值 cc。
                // 主雨滴 (mainDrop)：主要亮度贡献。
                // 拖尾 (trailFront)：与主雨滴相连的拖尾区域。
                // 飞溅雨滴 (droplets)：细节效果，用于增加雨滴的动态感
                float c = mainDrop + trailFront * droplets * r;

                return float2(c, trail);
            }

            // 合并多个雨滴效果
            // 该函数整合了 staticDrops 和 dropLayer 的效果，生成最终的雨滴效果
            // 使用不同的参数（如 l0, l1, l2）来控制每个层次雨滴的强度
            float2 drops(float2 uv, float t, float l0, float l1, float l2)
            {
                float s = staticDrops(uv * 40.0, t) * l0;
                float2 m1 = dropLayer(uv * 0.5, t) * l1;
                float2 m2 = dropLayer(uv, t) * l2;
                float c = s + m1.x + m2.x;
                c = S(0.0, 1.0, c);
                float trail = m1.y + m2.y;
                return float2(c, trail);
            }

            sampler2D _MainTex;
            float4 _MainTex_TexelSize;
            float _T;
            $DEF_GSCALE$

            fixed4 frag(v2f i) : SV_Target
            {
                float2 UV = i.uv;
                float2 uv = i.uvEffect;
                float t = _Time.y * 0.2;

                float l0 = S(0.0, 1.0, _T) * 2.0;
                float l1 = S(0.25, 0.75, _T);
                float l2 = S(0.0, 0.5, _T);

                float2 c = drops(uv, t, l0, l1, l2);
                float2 e = float2(1e-3, 0.0);
                float cx = drops(uv + e, t, l0, l1, l2).x;
                float cy = drops(uv + e.yx, t, l0, l1, l2).x;
                float2 n = float2(cx - c.x, cy - c.x);

                float4 col = tex2D(_MainTex, UV + n);
                float4 col2 = tex2DGaussianBlur(_MainTex,
                                                _MainTex_TexelSize * $GSCALE$,
                                                UV, 3.0 * _T) * (1.0 - 0.1 * _T);
                col = lerp(col2, col, saturate(c.x + c.y)) * i.color;

                $VARIANT_RGB$

                return col;
            }
            ENDCG
        }
    }
}