CapersProject/Assets/09.Shaders/Ink.shader

Shader "Unlit/Ink"
{
    Properties
    {
        _MainTex("Sprite Texture", 2D) = "white" {}
        _InkColor("Ink Color", Color) = (0.01, 0.01, 0.1, 1.0)
        _Speed("Speed", Float) = 0.1175
        _ShadeContrast("Shade Contrast", Float) = 0.11
        _Resolution("Resolution", Vector) = (1920, 1080, 0, 0)
        _CustomTime("Time", Float) = 0
        _Position("Position" , Range(0, 1)) = 0.1
        _Opacity("Opacity" , Range(0, 1)) = 1.0
    }
    SubShader
    {
        Tags { "Queue"="Transparent" "RenderType"="Transparent" }
        LOD 100

        Blend SrcAlpha OneMinusSrcAlpha
        ZWrite Off
        Cull Off

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            sampler2D _MainTex;
            float4 _InkColor;
            float4 _GreenScreen;
            float _Speed;
            float _Position;
            float _ShadeContrast;
            float4 _Resolution;
            float _Opacity;
            float _CustomTime;

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

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

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

            float F3 = 0.333333;
            float G3 = 0.1666667;

            float3 random3(float3 c) {
                float j = 4096.0 * sin(dot(c, float3(17.0, 59.4, 15.0)));
                float3 r;
                r.z = frac(512.0 * j);
                j *= .125;
                r.x = frac(512.0 * j);
                j *= .125;
                r.y = frac(512.0 * j);
                return r - 0.5;
            }

            float simplex3d(float3 p) {
                float3 s = floor(p + dot(p, float3(F3,F3,F3)));
                float3 x = p - s + dot(s, float3(G3,G3,G3));
                
                float3 e = step(float3(0.0,0.0,0.0), x - x.yzx);
                float3 i1 = e * (1.0 - e.zxy);
                float3 i2 = 1.0 - e.zxy * (1.0 - e);
                
                float3 x1 = x - i1 + G3;
                float3 x2 = x - i2 + 2.0 * G3;
                float3 x3 = x - 1.0 + 3.0 * G3;
                
                float4 w, d;
                
                w.x = dot(x, x);
                w.y = dot(x1, x1);
                w.z = dot(x2, x2);
                w.w = dot(x3, x3);
                
                w = max(0.6 - w, 0.0);
                
                d.x = dot(random3(s), x);
                d.y = dot(random3(s + i1), x1);
                d.z = dot(random3(s + i2), x2);
                d.w = dot(random3(s + 1.0), x3);
                
                w *= w;
                w *= w;
                d *= w;
                
                return dot(d, float4(52.0,52.0,52.0,52.0));
            }

            float fbm(float3 p)
            {
                float f = 0.0;    
                float frequency = 1.0;
                float amplitude = 0.5;
                for (int i = 0; i < 5; i++)
                {
                    f += simplex3d(p * frequency) * amplitude;
                    amplitude *= 0.5;
                    frequency *= 2.0 + float(i) / 100.0;
                }
                return min(f, 1.0);
            }

            fixed4 frag(v2f i) : SV_Target
            {
                float2 uv = 1.0 - i.uv;

                float mappedFloat = lerp(-4.0, 1.5, _Position);
                uv.x = uv.x * 3.5 + mappedFloat;

               // float uvx = uv.x;
               // uv.x = uv.y;
               // uv.y = uvx;
                
                float timeValue = _CustomTime * _Speed; // 시간 값

                // 명시적으로 float3 생성
                float3 p = float3(uv.x, uv.y, timeValue);
                
                float blot = fbm(p * 2.0 + 4.0) - 0.1;
                float shade = fbm(p * 3.0 + 16.0) - 0.2;
                
                blot = (blot + (sqrt(uv.x) - abs(0.5 - uv.y)));
                blot = smoothstep(0.0, 0.05, blot) * max(1.0 - shade * _ShadeContrast, 0.0);

                _GreenScreen = _InkColor;
                float3 color = lerp(_GreenScreen.rgb, _InkColor.rgb, blot);

                // 반대 부분을 완전 투명하게 처리
                // blot 값을 기준으로 그려지는 부분만 알파를 설정하고 나머지는 완전 투명
                float alpha = blot > 0.01 ? 1.0 : 0.0;

                alpha *= _Opacity;
                return float4(color , alpha);
            }
            ENDCG
        }
    }
}