Shader "Unlit/Flaring"
{
    Properties
    {
        _MainTex("Noise Texture", 2D) = "white" {}
        _Brightness("Brightness", Float) = 3.0
        _RayBrightness("Ray Brightness", Float) = 5.0
        _Gamma("Gamma", Float) = 6.0
        _SpotBrightness("Spot Brightness", Float) = 1.5
        _RayDensity("Ray Density", Float) = 6.0
        _Curvature("Curvature", Float) = 90.0
        _Red("Red", Float) = 1.8
        _Green("Green", Float) = 3.0
        _Blue("Blue", Float) = 0.5
        _SinFreq("Sin Frequency", Float) = 6.0
    }
    SubShader
    {
        Tags { "Queue"="Transparent" "RenderType"="Transparent" }
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            sampler2D _MainTex;
            float _Brightness;
            float _RayBrightness;
            float _Gamma;
            float _SpotBrightness;
            float _RayDensity;
            float _Curvature;
            float _Red, _Green, _Blue;
            float _SinFreq;

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

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

            float hash(float n) { return frac(sin(n) * 43758.5453); }

            float noise(float2 x)
            {
                return tex2D(_MainTex, x * 0.01).r; // Using texture-based noise
            }

            float fbm(float2 p)
            {
                float z = 2.0;
                float rz = 0.0;
                p *= 0.25;
                float2 m2 = float2(0.80, 0.60);
                float2 m2n = float2(-0.60, 0.80);
                for (int i = 0; i < 5; i++)
                {
                    rz += abs((noise(p) - 0.5) * 2.0) / z;
                    z *= 2.0;
                    p = float2(p.x * m2.x + p.y * m2.y, p.x * m2n.x + p.y * m2n.y) * 2.0;
                }
                return rz;
            }

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

            fixed4 frag(v2f i) : SV_Target
            {
                float2 uv = i.uv * _ScreenParams.xy / _ScreenParams.y - 0.5f;
                uv.x *= _ScreenParams.x / _ScreenParams.y;
                uv *= _Curvature * 0.05f + 0.0001f;

                float r = sqrt(dot(uv, uv));
                float t = -_Time.y * 0.03f; // 시간 변화 적용
                float x = dot(normalize(uv), float2(0.5f, 0.0f)) + t;
                float y = dot(normalize(uv), float2(0.0f, 0.5f)) + t;

                x = fbm(float2(y * _RayDensity * 0.5f, r + x * _RayDensity * 0.2f));
                y = fbm(float2(r + y * _RayDensity * 0.1f, x * _RayDensity * 0.5f));

                float val = fbm(float2(r + y * _RayDensity, r + x * _RayDensity - y));
                val = smoothstep(_Gamma * 0.02f - 0.1f, _RayBrightness + (_Gamma * 0.02f - 0.1f) + 0.001f, val);
                val = sqrt(val);

                float3 col = val / float3(_Red, _Green, _Blue);
                col = clamp(1.0f - col, 0.0f, 1.0f);
                col = lerp(col, float3(1.0f, 1.0f, 1.0f), _SpotBrightness - r / 0.1f / _Curvature * 200.0f / _Brightness);
                col = clamp(col, 0.0f, 1.0f);
                col = pow(col, float3(1.7f, 1.7f, 1.7f));

                //float debugColor = frac(_Time.y * 0.1f); // 시간 변화 확인용
                
                return float4(col, 1.0f);
            }
            ENDCG
        }
    }
}