Shader "Xibanya/UI/HoloPolygon"
{
    Properties
    {
        [KeywordEnum(Circle,Spiral,Line,Triangle,Square,Pentagon)] _Polygon("Polygon", float) = 0
        _Tex0("Circle", 2D) = "white" {}
        [NoScaleOffset] _Tex1("Spiral", 2D) = "white" {}
        [NoScaleOffset] _Tex2("Line", 2D) = "white" {}
        [NoScaleOffset] _Tex3("Triangle", 2D) = "white" {}
        [NoScaleOffset] _Tex4("Square", 2D) = "white" {}
        [NoScaleOffset] _Tex5("Pentagon", 2D) = "white" {}
        [NoScaleOffset] _Mask0("Circle Mask", 2D) = "white" {}
        [NoScaleOffset] _Mask1("Spiral Mask", 2D) = "white" {}
        [NoScaleOffset] _Mask2("Line Mask", 2D) = "white" {}
        [NoScaleOffset] _Mask3("Triangle Mask", 2D) = "white" {}
        [NoScaleOffset] _Mask4("Square Mask", 2D) = "white" {}
        [NoScaleOffset] _Mask5("Pentagon Mask", 2D) = "white" {}
        [Space]
        [Header(Colors)]
        [PerRendererData] [HDR] _Color("Tint", Color) = (1,1,1,1)
        [HDR]_MColor1("Multiply Color 1", Color) = (1,1,1,1)
        [HDR]_MColor2("Multiply Color 2", Color) = (1,1,1,1)
        [HDR]_MColor3("Multiply Color 3", Color) = (1,1,1,1)
        [Space]
        [Header(Tracking Error)]
        [Toggle] _TRACKING("Tracking Error", float) = 1
        _InterlacingSeverity("Interlacing Severity", float) = 0.001
        _InterlacingFrequency("Interlacing Frequency", float) = 1
        _TrackingHeight("Tracking Height", float) = 0.15
        _TrackingSeverity("Tracking Severity", float) = 0.025
        _TrackingSpeed("Tracking Speed", float) = 0.2
        [Space]
        [Header(Glitch)]
        [Toggle] _GLITCH("Glitch", float) = 1
        _GlitchAlpha("Glitch Alpha", Range(0, 1)) = 0.5
        _Width("Texture Width", float) = 2048
        _Glitchiness("Glitchiness", Range(0, 1)) = 0
        _GlitchSpeed("Glitch Speed", float) = 1
        _Noise("Noise Texture", 2D) = "transparent" {}
        _YSpeed("Y Speed", float) = 0.2
        [Space]
        [Header(RGB Mask)]
        [Toggle] _RGBMASK("RGB Mask", int) = 0
        _ShimmerSpeed("Shimmer Speed", float) = 30.0
        _RGBMaskSize("RGB Mask Size", float) = 2.0
        [Space]
        [Header(Scanlines)]
        [Toggle] _SCANLINES("Scanlines", int) = 1
        _ScanlineCount("Scanline Count", int) = 800
        _ScanlineSpeed("Scanline Move Speed", float) = 200.0
        _ScanlineIntensity("Scanline Intensity", float) = 0.04
        _ScanAlpha("Scanline Alpha", Range(0, 1)) = 1
        [Space]
        [Header(Render Options)]
        [Toggle] _BILLBOARD("Billboard", float) = 1
        [Enum(Off,0,Front,1,Back,2)] _Cull("Cull", float) = 0
        [Enum(UnityEngine.Rendering.BlendMode)] _BlendOp("Blend Op", float) = 5
        [Enum(UnityEngine.Rendering.BlendMode)] _BlendMode("Blend Mode", float) = 10
    }
        SubShader
        {
            Tags
            {
                "RenderType" = "Transparent"
                "Queue" = "Transparent"
                "PreviewType" = "Plane"
                "CanUseSpriteAtlas" = "True"
                "IgnoreProjector" = "True"
            }
            Cull[_Cull]
            ZWrite Off
            LOD 100
            Blend[_BlendOp][_BlendMode]

        Pass
        {
            Name "Glitch"
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_local _POLYGON_CIRCLE _POLYGON_SPIRAL _POLYGON_LINE _POLYGON_TRIANGLE _POLYGON_SQUARE _POLYGON_PENTAGON
            #pragma multi_compile_local __ _RGBMASK_ON
            #pragma multi_compile_local __ _SCANLINES_ON
            #pragma multi_compile_local __ _TRACKING_ON
            #pragma multi_compile_local __ _GLITCH_ON
            #pragma multi_compile_local __ _BILLBOARD_ON
            #define mod(x,y) (x-y*floor(x/y))
            #include "UnityCG.cginc"
            #include "Assets/Scripts/Shaders/XibGlitch.cginc"

            sampler2D _Noise;
            float4 _Noise_ST;

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

            struct v2f
            {
                float2 uv       : TEXCOORD0;
                float4 pos      : SV_POSITION;
                float4 posWorld : TEXCOORD1;
                float2 uv_Noise : TEXCOORD2;
                float3 normal   : TEXCOORD3;
                float4 color    : COLOR;
            };

            Texture2D _Tex0;
            SamplerState sampler_Tex0;
            Texture2D _Tex1;
            Texture2D _Mask1;
            SamplerState SmpClampPoint;
            UNITY_DECLARE_TEX2D_NOSAMPLER(_Tex2);
            UNITY_DECLARE_TEX2D_NOSAMPLER(_Tex3);
            UNITY_DECLARE_TEX2D_NOSAMPLER(_Tex4);
            UNITY_DECLARE_TEX2D_NOSAMPLER(_Tex5);
            UNITY_DECLARE_TEX2D_NOSAMPLER(_Mask0);
            UNITY_DECLARE_TEX2D_NOSAMPLER(_Mask2);
            UNITY_DECLARE_TEX2D_NOSAMPLER(_Mask3);
            UNITY_DECLARE_TEX2D_NOSAMPLER(_Mask4);
            UNITY_DECLARE_TEX2D_NOSAMPLER(_Mask5);
            float4 _Tex0_ST, _Tex0_TexelSize;
            half4 _Color;

            v2f vert(appdata v)
            {
                v2f o;
#if defined(_BILLBOARD_ON)
                //from https://github.com/unitycoder/DoomStyleBillboardTest/blob/master/Assets/Materials/Shaders/DoomSprite.shader
                o.normal = float3(0, 0, -1);
                float3 viewUpW = mul((float3x3)unity_CameraToWorld, float3(0, 1, 0));
                float3 viewRightW = mul((float3x3)unity_CameraToWorld, float3(1, 0, 0));
                float3 viewFrontW = mul((float3x3)unity_CameraToWorld, float3(0, 0, -_ProjectionParams.x));
                float3 vpos = mul((float3x3)unity_ObjectToWorld, v.vertex.xyz);
                float4 worldCoord = float4(unity_ObjectToWorld._m03, unity_ObjectToWorld._m13, unity_ObjectToWorld._m23, 1);
                float4 viewPos = mul(UNITY_MATRIX_V, worldCoord) + float4(vpos, 0);
                float4 outPos = mul(UNITY_MATRIX_P, viewPos);
                o.pos = UnityPixelSnap(outPos);
#else
                o.pos = UnityObjectToClipPos(v.vertex);
#endif
                o.uv = TRANSFORM_TEX(v.uv, _Tex0);
                o.posWorld = mul(unity_ObjectToWorld, v.vertex);
                o.uv_Noise = TRANSFORM_TEX(v.uv, _Noise);
                o.color = v.color * _Color;
                return o;
            }
            float _ShimmerSpeed;
            float _RGBMaskSize;
            half _InterlacingSeverity;
            half _YSpeed;
            half _GlitchSpeed;

            float _TrackingHeight;
            float _TrackingSeverity;
            float _TrackingSpeed;

            float _ScanlineCount;
            float _ScanlineSpeed;
            float _ScanlineIntensity;
            float _ScanAlpha;
            half4 _MColor1, _MColor2, _MColor3;

            half _Width;
            half _Glitchiness, _GlitchAlpha, _InterlacingFrequency;

            half4 frag(v2f i) : SV_Target
            {
                float2 uv = i.uv;
#if defined (_TRACKING_ON)
                uv.x -= sin(uv.y * 500.0 * _InterlacingFrequency + _Time.y) * _InterlacingSeverity;
                float tracking = -_Time.y * _TrackingSpeed;
                float fractionalTime = (tracking - floor(tracking)) * 1.3 - _TrackingHeight;
                half useTrack = step(uv.y, fractionalTime + _TrackingHeight) * step(fractionalTime, uv.y);
                uv.x -= fractionalTime * _TrackingSeverity * useTrack;
#endif
                half4 col;
                half4 mask;
#if defined (_POLYGON_CIRCLE)
                col = _Tex0.Sample(sampler_Tex0, uv * _Tex0_ST.xy);
                mask = _Mask0.Sample(sampler_Tex0, uv * _Tex0_ST.xy);
#elif defined (_POLYGON_SPIRAL)
                col = _Tex1.Sample(SmpClampPoint, uv * _Tex0_ST.xy);
                mask = _Mask1.Sample(SmpClampPoint, uv * _Tex0_ST.xy);
#elif defined (_POLYGON_LINE)
                col = _Tex2.Sample(SmpClampPoint, uv * _Tex0_ST.xy);
                mask = _Mask2.Sample(SmpClampPoint, uv * _Tex0_ST.xy);
#elif defined (_POLYGON_TRIANGLE)
                col = _Tex3.Sample(SmpClampPoint, uv * _Tex0_ST.xy);
                mask = _Mask3.Sample(SmpClampPoint, uv * _Tex0_ST.xy);
#elif defined (_POLYGON_SQUARE)
                col = _Tex4.Sample(SmpClampPoint, uv * _Tex0_ST.xy);
                mask = _Mask4.Sample(SmpClampPoint, uv * _Tex0_ST.xy);
#elif defined (_POLYGON_PENTAGON)
                col = _Tex5.Sample(SmpClampPoint, uv * _Tex0_ST.xy);
                mask = _Mask5.Sample(SmpClampPoint, uv * _Tex0_ST.xy);
#endif
                col.rgb *= i.color.rgb;
                half3 white = half3(1, 1, 1);
                col.rgb *= lerp(white, lerp(col, _MColor1.rgb, _MColor1.a), mask.r);
                col.rgb *= lerp(white, lerp(col, _MColor2.rgb, _MColor2.a), mask.g);
                col.rgb *= lerp(white, lerp(col, _MColor3.rgb, _MColor3.a), mask.b);

                half4 fragColor = col;

#ifdef _RGBMASK_ON
                float yOffset = floor(sin(_Time.y * _ShimmerSpeed));
                float pix = (i.posWorld.y + yOffset) * _Width + i.uv.x;
                pix = floor(pix);

                float4 colMask = float4(mod(pix, _RGBMaskSize), mod((pix + 1.0), _RGBMaskSize), mod((pix + 2.0), _RGBMaskSize), 1.0);
                colMask = colMask / (_RGBMaskSize - 1.0) + 0.5;
                col.rgb = col.rgb * colMask.rgb;
#endif
#ifdef _GLITCH_ON
                float THRESHOLD = 0.1 + uv.x / _Width;
                float time_s = mod(_Time.y * _GlitchSpeed, 32.0);
                float glitch_threshold = 1.0 - THRESHOLD;
                const float max_ofs_siz = 0.1;
                const float yuv_threshold = 0.1; //in the original was 0.5, can also use _yuvThresh;
                const float time_frq = 16.0;
                uv.y = 1.0 - uv.y;
                const float min_change_frq = 4.0;
                float ct = mytrunc(time_s, min_change_frq);
                float change_rnd = rand(mytrunc(uv.yy, float2(16, 16)) + 150.0 * ct);

                float tf = time_frq * change_rnd;

                float t = 5.0 * mytrunc(time_s, tf);
                float vt_rnd = 0.5*rand(mytrunc(uv.yy + t, float2(11, 11)));
                vt_rnd += 0.5 * rand(mytrunc(uv.yy + t, float2(7, 7)));
                vt_rnd = vt_rnd * 2.0 - (1.0 - _Glitchiness);
                vt_rnd = sign(vt_rnd) * saturate((abs(vt_rnd) - glitch_threshold) / (1.0 - glitch_threshold));
                float2 uv_nm = uv;
                uv_nm = saturate(uv_nm + float2(max_ofs_siz*vt_rnd, 0));

                float rnd = rand(float2(mytrunc(time_s, 8.0), mytrunc(time_s, 8.0)));
                uv_nm.y = (rnd > lerp(1.0, 0.975, saturate(THRESHOLD))) ? 1.0 - uv_nm.y : uv_nm.y;

                float3 smpl_yuv = rgb2yuv(col.rgb);
                smpl_yuv.y /= 1.0 - 3.0*abs(vt_rnd) * saturate(yuv_threshold - vt_rnd);
                smpl_yuv.z += 0.125 * vt_rnd * saturate(vt_rnd - yuv_threshold);
                fragColor = float4(yuv2rgb(smpl_yuv), col.a);

                fixed yScroll = _YSpeed * _Time.y;
                float2 uv_Noise = i.uv_Noise + float2(0, yScroll);
                fixed3 noise = tex2D(_Noise, uv_Noise).rgb;

                int useGlitch = step(0.01, abs(col.rgb - fragColor.rgb));

                fragColor.rgb = noise * fragColor.rgb * useGlitch + col.rgb * (1 - useGlitch);
                fragColor.a = _GlitchAlpha * col.a * useGlitch + col.a * (1 - useGlitch);
#endif

#ifdef _SCANLINES_ON
                float scanlineYDelta = sin(_Time.y / _ScanlineSpeed);
                float scanline = sin((uv.y - scanlineYDelta) * _ScanlineCount) * _ScanlineIntensity;
                fragColor.rgb -= min(max(0, scanline), fragColor.rgb);
                fragColor.a -= min(max(0, scanline * (1 - _ScanAlpha)), fragColor.a);
#endif
                return fragColor;
            }
            ENDCG
        }
        }
}