GGJ_2019/Assets/ThirdParty/Tayx/Graphy - Ultimate Stats Monitor/Shaders/GraphMobile.shader

Shader "Graphy/Graph Mobile"
{
    Properties
    {
        [PerRendererData] _MainTex("Sprite Texture", 2D) = "white" {}
        _Color("Tint", Color) = (1,1,1,1)
        [MaterialToggle] PixelSnap("Pixel snap", Float) = 0

        _GoodColor("Good Color", Color) = (1,1,1,1)
        _CautionColor("Caution Color", Color) = (1,1,1,1)
        _CriticalColor("Critical Color", Color) = (1,1,1,1)

        _GoodThreshold("Good Threshold", Float) = 0.5
        _CautionThreshold("Caution Threshold", Float) = 0.25
    }

        SubShader
        {
//			Tags
//			{
//				"Queue" = "Overlay"
//				"IgnoreProjector" = "True"
//				"RenderType" = "Transparent"
//				"PreviewType" = "Plane"
//				"CanUseSpriteAtlas" = "True"
//			}

            Cull Off
            Lighting Off
            ZWrite Off
            ZTest Off
            Blend One OneMinusSrcAlpha

            Pass
            {
                CGPROGRAM

                #pragma vertex vert
                #pragma fragment frag
                #pragma multi_compile _ PIXELSNAP_ON
                #include "UnityCG.cginc"

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

                struct v2f
                {
                    float4 vertex    : SV_POSITION;
                    fixed4 color	 : COLOR;
                    float2 texcoord  : TEXCOORD0;
                };

                fixed4 _Color;

                v2f vert(appdata_t IN)
                {
                    v2f OUT;
                    OUT.vertex = UnityObjectToClipPos(IN.vertex);
                    OUT.texcoord = IN.texcoord;
                    OUT.color = IN.color * _Color;
                #ifdef PIXELSNAP_ON
                    OUT.vertex = UnityPixelSnap(OUT.vertex);
                #endif

                    return OUT;
                }

                sampler2D _MainTex;
                sampler2D _AlphaTex;
                float _AlphaSplitEnabled;

                fixed4 SampleSpriteTexture(float2 uv)
                {
                    fixed4 color = tex2D(_MainTex, uv);

                #if UNITY_TEXTURE_ALPHASPLIT_ALLOWED
                    if (_AlphaSplitEnabled)
                        color.a = tex2D(_AlphaTex, uv).r;
                #endif //UNITY_TEXTURE_ALPHASPLIT_ALLOWED

                    return color;
                }

                fixed4 _GoodColor;
                fixed4 _CautionColor;
                fixed4 _CriticalColor;

                fixed  _GoodThreshold;
                fixed  _CautionThreshold;

                uniform float Average;

                // NOTE: The size of this array can break compatibility with some older GPUs
                // This shader is equal to GraphStandard.shader but with a smaller Array size.
                
                uniform float GraphValues[128];

                uniform float GraphValues_Length;

                fixed4 frag(v2f IN) : SV_Target
                {
                    fixed4 color = IN.color;

                    fixed xCoord = IN.texcoord.x;
                    fixed yCoord = IN.texcoord.y;

                    float graphValue = GraphValues[floor(xCoord * GraphValues_Length)];

                    // Define the width of each element of the graph
                    float increment = 1.0f / (GraphValues_Length - 1);

                    // Set as transparent the part on top of the current point value
                    if (yCoord > graphValue)
                    {
                        color.a = 0;
                    }
                    
                    // Assign the corresponding color
                    if (graphValue > _GoodThreshold)
                    {
                        color *= _GoodColor;
                    }
                    else if (graphValue > _CautionThreshold)
                    {
                        color *= _CautionColor;
                    }
                    else
                    {
                        color *= _CriticalColor;
                    }

                    // Point coloring
                    if (graphValue - yCoord > increment * 4)
                    {
                        //color.a = yCoord * graphValue * 0.3;
                        color.a *= yCoord * 0.3 / graphValue;
                    }

                    // Average white bar
                    if (yCoord < Average && yCoord > Average - 0.02)
                    {
                        color = fixed4(1, 1, 1, 1);
                    }

                    // CautionColor bar
                    if (yCoord < _CautionThreshold && yCoord > _CautionThreshold - 0.02)
                    {
                        color = _CautionColor;
                    }

                    // GoodColor bar
                    if (yCoord < _GoodThreshold && yCoord > _GoodThreshold - 0.02)
                    {
                        color = _GoodColor;
                    }

                    // Fade the alpha of the sides of the graph
                    if (xCoord < 0.03)
                    {
                        color.a *= 1 - (0.03 - xCoord) / 0.03;
                    }
                    else if (xCoord > 0.97)
                    {
                        color.a *= (1 - xCoord) / 0.03;
                    }

                    fixed4 c = SampleSpriteTexture(IN.texcoord) * color;

                    c.rgb *= c.a;

                    return c;
                }

                ENDCG
            }
        }
}