Shader "Custom/UI_TiledTriangleWave"
{
    Properties
    {
        [PerRendererData] _MainTex ("Sprite Texture (Your Triangle)", 2D) = "white" {}
        
        // Tiling properties
        _TilingX ("Tiling X", Float) = 30
        _TilingY ("Tiling Y", Float) = 10
        
        // Animation properties
        _Speed ("Animation Speed", Float) = 2.0
        _MinAlpha ("Min Alpha", Range(0, 1)) = 0.1
        _MaxAlpha ("Max Alpha", Range(0, 1)) = 1.0
        
        // Randomness control
        _RandomScale ("Random Phase Scale", Float) = 10.0 // 用来放大随机种子的影响
        
        // --- UI Shader properties ---
        _StencilComp ("Stencil Comparison", Float) = 8
        _Stencil ("Stencil ID", Float) = 0
        _StencilOp ("Stencil Operation", Float) = 0
        _StencilWriteMask ("Stencil Write Mask", Float) = 255
        _StencilReadMask ("Stencil Read Mask", Float) = 255
        _ColorMask ("Color Mask", Float) = 15
        [Toggle(UNITY_UI_CLIP_RECT)] _UseClipRect ("Use Clip Rect", Float) = 0
    }

    SubShader
    {
        // ... (Stencil, Cull, Blend等设置保持不变, 这里省略) ...
        Tags
        {
            "Queue"="Transparent"
            "RenderType"="Transparent"
            "PreviewType"="Plane"
            "CanUseSpriteAtlas"="True"
        }

        Stencil
        {
            Ref [_Stencil]
            Comp [_StencilComp]
            Pass [_StencilOp]
            ReadMask [_StencilReadMask]
            WriteMask [_StencilWriteMask]
        }

        Cull Off
        Lighting Off
        ZWrite Off
        ZTest [unity_GUIZTestMode]
        Blend SrcAlpha OneMinusSrcAlpha
        ColorMask [_ColorMask]

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma target 2.0

            #include "UnityCG.cginc"
            #include "UnityUI.cginc"

            #pragma multi_compile __ UNITY_UI_CLIP_RECT

            struct appdata_t
            {
                float4 vertex   : POSITION;
                float4 color    : COLOR;
                float2 texcoord : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct v2f
            {
                float4 vertex   : SV_POSITION;
                fixed4 color    : COLOR;
                float2 uv       : TEXCOORD0;
                float4 worldPosition : TEXCOORD1;
                UNITY_VERTEX_OUTPUT_STEREO
            };
            
            sampler2D _MainTex;
            float4 _MainTex_ST;
            
            float _TilingX;
            float _TilingY;
            float _Speed;
            float _MinAlpha;
            float _MaxAlpha;
            float _RandomScale; // 新增
            
            float4 _ClipRect;

            v2f vert(appdata_t v)
            {
                v2f o;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
                o.worldPosition = v.vertex;
                o.vertex = UnityObjectToClipPos(o.worldPosition);
                o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
                o.color = v.color;
                return o;
            }

            // 简单的伪随机哈希函数
            // 输入一个2D ID, 输出一个 0 到 1 之间的伪随机值
            float randomHash(float2 uv)
            {
                // 一个常用且简单的哈希函数
                return frac(sin(dot(uv, float2(12.9898, 78.233))) * 43758.5453);
            }

            fixed4 frag(v2f i) : SV_Target
            {
                float2 tiledUV = i.uv * float2(_TilingX, _TilingY);
                float2 tileID = floor(tiledUV);
                float2 localUV = frac(tiledUV);
                
                fixed4 col = tex2D(_MainTex, localUV);

                // --- 这是修改的核心 ---
                // 1. 使用 tileID 生成一个 0-1 之间的随机哈希值
                float randomValue = randomHash(tileID);
                
                // 2. 将随机值乘以 _RandomScale 作为相位偏移
                // 这样每个块的起始时间点就是离散且随机的
                float phaseOffset = randomValue * _RandomScale;
                
                // -----------------------

                float sineWave = sin(_Time.y * _Speed + phaseOffset);
                float normalizedAlpha = (sineWave * 0.5) + 0.5;
                float targetAlpha = lerp(_MinAlpha, _MaxAlpha, normalizedAlpha);

                col.a *= targetAlpha * i.color.a;
                col.rgb *= i.color.rgb;

                #ifdef UNITY_UI_CLIP_RECT
                col.a *= UnityGet2DClipping(i.worldPosition.xy, _ClipRect);
                #endif
                
                return col;
            }
            ENDCG
        }
    }
}