﻿Shader "Grinlin/Shadertoy Convert/HaleyHalcyon/InOut"
{ // Converted and edited by Koda, jzody. From ->> https://www.shadertoy.com/view/Nd3SzX by HaleyHalcyon
    Properties
    {
		[ToggleUI] _GammaCorrect("Gamma Correction", Float) = 1
		_Speed("Speed of shit", Range(0.0, 1.0)) = 0.0
		_Col0L("Color L 0", Color) = (0.52,0.05,0.68,1)
		_Col1L("Color L 1", Color) = (0.23,0.81,0.67,1)
		_Col2L("Color L 2", Color) = (1.00,0.82,0.25,1)
		_Col3L("Color L 3", Color) = (0.93,0.26,0.40,1)
		_Col0D("Color D 0", Color) = (0.94,0.28,0.44,1)
		_Col1D("Color D 1", Color) = (1.00,0.82,0.40,1)
		_Col2D("Color D 2", Color) = (0.02,0.84,0.63,1)
		_Col3D("Color D 3", Color) = (0.07,0.54,0.70,1)

		[IntRange] _StencilRef("Stencil Reference Value", Range(0, 255)) = 0
		[Enum(UnityEngine.Rendering.CompareFunction)] _StencilCompareFunction("Stencil Compare Function", Float) = 8
    }
        SubShader
        { 
			Stencil
			{
				Ref[_StencilRef]
				Comp[_StencilCompareFunction]
			}
            Pass
            {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag

                #include "UnityCG.cginc"

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

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

                // Built-in properties
                float _GammaCorrect;
				float3 _Col0L;
				float3 _Col1L;
				float3 _Col2L;
				float3 _Col3L;
				float3 _Col0D;
				float3 _Col1D;
				float3 _Col2D;
				float3 _Col3D;

                // GLSL Compatability macros
                #define glsl_mod(x,y) (((x)-(y)*floor((x)/(y))))
                #define texelFetch(ch, uv, lod) tex2Dlod(ch, float4((uv).xy * ch##_TexelSize.xy + ch##_TexelSize.xy * 0.5, 0, lod))
                #define textureLod(ch, uv, lod) tex2Dlod(ch, float4(uv, 0, lod))
                #define iFrame (floor(_Time.y / 60))
                #define iChannelTime float4(_Time.y, _Time.y, _Time.y, _Time.y)
                #define iDate float4(2020, 6, 18, 30)
                #define iSampleRate (44100)
                #define iChannelResolution float4x4(                      \
                    _MainTex_TexelSize.z,   _MainTex_TexelSize.w,   0, 0, \
                    _SecondTex_TexelSize.z, _SecondTex_TexelSize.w, 0, 0, \
                    _ThirdTex_TexelSize.z,  _ThirdTex_TexelSize.w,  0, 0, \
                    _FourthTex_TexelSize.z, _FourthTex_TexelSize.w, 0, 0)

                // Global access to uv data
                static v2f vertex_output;

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

    #define TAU (6.2831855)
    #define HEX(x) (float3(x>>16&255, x>>8&255, x&255)/255.)
    #define STRIPECOUNT 14.
                float4 frag(v2f __vertex_output) : SV_Target
                {
                    vertex_output = __vertex_output;
                    float4 fragColor = 0;
                    float2 fragCoord = vertex_output.uv;
                    float time = frac(_Time.y / 4.);
                    float scale = min(1.0, 1.0);
                    float2 uv = ((vertex_output.uv).xy - 0.5) / scale;
                    float dist = length(uv);
                    float angle = atan2(uv.y, uv.x);
                    float stripeAngle = 0.3 * sin(time * TAU) + (0.5 + floor(angle * STRIPECOUNT / TAU - 2. * time) + 2. * time) * TAU / STRIPECOUNT;
                    float2 angleVec = float2(cos(stripeAngle), sin(stripeAngle));
                    float dark = floor(glsl_mod(angle * STRIPECOUNT / TAU - 2. * time, 2.));
					const float3 col0L = float3(_Col0L[0], _Col0L[1], _Col0L[2]);
                    const float3 col1L = float3(_Col1L[0], _Col1L[1], _Col1L[2]);
                    const float3 col2L = float3(_Col2L[0], _Col2L[1], _Col2L[2]);
                    const float3 col3L = float3(_Col3L[0], _Col3L[1], _Col3L[2]);
					const float3 col0D = float3(_Col0D[0], _Col0D[1], _Col0D[2]);
                    const float3 col1D = float3(_Col1D[0], _Col1D[1], _Col1D[2]);
                    const float3 col2D = float3(_Col2D[0], _Col2D[1], _Col2D[2]);
                    const float3 col3D = float3(_Col3D[0], _Col3D[1], _Col3D[2]);
                    float3 col0 = lerp(col0L, col0D, dark);
                    float3 col1 = lerp(col1L, col1D, dark);
                    float3 col2 = lerp(col2L, col2D, dark);
                    float3 col3 = lerp(col3L, col3D, dark);
                    float spiral = frac(3. * log(dot(uv, angleVec) * 2. + 0.05) + 8. * (2. * dark - 1.) * time);
                    float3 col = lerp(lerp(col0, col1, step(spiral, 0.75)), lerp(col2, col3, step(spiral, 0.25)), step(spiral, 0.5));
                    fragColor = float4(col, 1.);
                    if (_GammaCorrect) fragColor.rgb = pow(fragColor.rgb, 2.2);
                    return fragColor;
                }
                ENDCG
            }
        }
}
