Shader "TextMeshPro/Bitmap Border"
{

    Properties
    {
        [Header(Text)]
        _MainTex ("Font Atlas", 2D) = "white" {}
        _FaceTex ("Font Texture", 2D) = "white" {}
        [HDR]_FaceColor ("Text Color", Color) = (1,1,1,1)

        [Header(Border)]
        [HDR]_BorderColor1 ("Border Color 1", Color) = (1,0,0,1)
        [HDR]_BorderColor2 ("Border Color 2", Color) = (0,0,1,1)
        _BorderWidth ("Border Width", Range(0, 20)) = 1
        _PixelSize ("Pixel Size", Range(0, 20)) = 1
        _GradientAngle ("Gradient Angle", Range(0, 360)) = 90
        _BorderSharpness ("Border Sharpness", Range(0, 1)) = 1

        _VertexOffsetX ("Vertex OffsetX", float) = 0
        _VertexOffsetY ("Vertex OffsetY", float) = 0
        _MaskSoftnessX ("Mask SoftnessX", float) = 0
        _MaskSoftnessY ("Mask SoftnessY", float) = 0

        _ClipRect("Clip Rect", vector) = (-32767, -32767, 32767, 32767)

        _StencilComp("Stencil Comparison", Float) = 8
        _Stencil("Stencil ID", Float) = 0
        _StencilOp("Stencil Operation", Float) = 0
        _StencilWriteMask("Stencil Write Mask", Float) = 255
        _StencilReadMask("Stencil Read Mask", Float) = 255

        _CullMode("Cull Mode", Float) = 0
        _ColorMask("Color Mask", Float) = 15
    }

    SubShader
    {

        Tags
        {
            "Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Transparent"
        }

        Stencil
        {
            Ref[_Stencil]
            Comp[_StencilComp]
            Pass[_StencilOp]
            ReadMask[_StencilReadMask]
            WriteMask[_StencilWriteMask]
        }

        Lighting Off
        Cull [_CullMode]
        ZTest [unity_GUIZTestMode]
        ZWrite Off
        Fog
        {
            Mode Off
        }
        Blend SrcAlpha OneMinusSrcAlpha
        ColorMask[_ColorMask]

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #pragma multi_compile __ UNITY_UI_CLIP_RECT
            #pragma multi_compile __ UNITY_UI_ALPHACLIP

            #include "UnityCG.cginc"

            struct appdata_t
            {
                float4 vertex : POSITION;
                fixed4 color : COLOR;
                float2 texcoord0 : TEXCOORD0;
                float2 texcoord1 : TEXCOORD1;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                fixed4 color : COLOR;
                float2 texcoord0 : TEXCOORD0;
                float2 texcoord1 : TEXCOORD1;
                float4 mask : TEXCOORD2;
                float4 characterBounds : TEXCOORD3;
            };

            uniform sampler2D _MainTex;
            uniform sampler2D _FaceTex;
            uniform float4 _FaceTex_ST;
            uniform fixed4 _FaceColor;
            uniform fixed4 _BorderColor1;
            uniform fixed4 _BorderColor2;
            uniform float _BorderWidth;
            uniform float _PixelSize;
            uniform float _GradientAngle;

            uniform float _VertexOffsetX;
            uniform float _VertexOffsetY;
            uniform float4 _ClipRect;
            uniform float _MaskSoftnessX;
            uniform float _MaskSoftnessY;

            float2 UnpackUV(float uv)
            {
                float2 output;
                output.x = floor(uv / 4096);
                output.y = uv - 4096 * output.x;

                return output * 0.001953125;
            }

            v2f vert(appdata_t v)
            {
                float4 vert = v.vertex;
                vert.x += _VertexOffsetX;
                vert.y += _VertexOffsetY;

                vert.xy += (vert.w * 0.5) / _ScreenParams.xy;

                float4 vPosition = UnityPixelSnap(UnityObjectToClipPos(vert));

                fixed4 faceColor = v.color;
                faceColor *= _FaceColor;

                v2f OUT;
                OUT.vertex = vPosition;
                OUT.color = faceColor;
                OUT.texcoord0 = v.texcoord0;
                OUT.texcoord1 = TRANSFORM_TEX(UnpackUV(v.texcoord1), _FaceTex);
                float2 pixelSize = vPosition.w;
                pixelSize /= abs(float2(_ScreenParams.x * UNITY_MATRIX_P[0][0],
                                        _ScreenParams.y * UNITY_MATRIX_P[1][1]));

                // Clamp _ClipRect to 16bit.
                float4 clampedRect = clamp(_ClipRect, -2e10, 2e10);
                OUT.mask = float4(vert.xy * 2 - clampedRect.xy - clampedRect.zw,
                                  0.25 / (0.25 * half2(_MaskSoftnessX, _MaskSoftnessY) +
                                      pixelSize.xy));

                OUT.characterBounds = float4(v.texcoord0, v.texcoord0);

                return OUT;
            }

            fixed4 frag(v2f IN) : SV_Target
            {
                float4 color = tex2D(_MainTex, IN.texcoord0);
                float4 faceColor = fixed4(tex2D(_FaceTex, IN.texcoord1).rgb * IN.color.rgb, IN.color.a * color.a);

                // Calculate border
                float2 pixelSize = float2(_PixelSize, _PixelSize) / _ScreenParams.xy;
                float borderWidth = max(_BorderWidth, 1);


                // this was another way to calculate the border, it seems a bit tigher, bnot quite as clean.
                /*float border = 0;
                for (int i = 0; i < 8; i++)
                {
                    float2 offset = float2(cos(i * UNITY_PI / 4), sin(i * UNITY_PI / 4)) * borderWidth * pixelSize;
                    float2 sampleUV = IN.texcoord0 + offset;
                    border = max(border, tex2D(_MainTex, sampleUV).a);
                }
                border = saturate(border - color.a);*/

                float border = 0;
                for (int x = -1; x <= 1; x++)
                {
                    for (int y = -1; y <= 1; y++)
                    {
                        if (x == 0 && y == 0) continue;
                        float2 offset = float2(x, y) * pixelSize;
                        float2 sampleUV = IN.texcoord0 + offset;
                        border = max(border, tex2D(_MainTex, sampleUV).a);
                    }
                }
                border = saturate(border - color.a);

                // Smooth the border
                // float smoothBorder = smoothstep(0, pixelSize.x * borderWidth, border);

                // Calculate gradient border color
                float2 characterUV = (IN.texcoord0 - IN.characterBounds.xy) / (IN.characterBounds.zw - IN.
                    characterBounds.xy);
                float2 gradientUV = float2(cos(_GradientAngle * UNITY_PI / 180), sin(_GradientAngle * UNITY_PI / 180));
                // float2 screenPos = IN.vertex.xy / _ScreenParams.xy;
                // float2 gradientUV = float2(cos(_GradientAngle * UNITY_PI / 180), sin(_GradientAngle * UNITY_PI / 180));
                float gradientT = dot(characterUV - 0.5, gradientUV) + 0.5;
                fixed4 borderColor = lerp(_BorderColor1, _BorderColor2, saturate(gradientT));

                // Combine face and border
                fixed4 finalColor = lerp(faceColor, borderColor, border);

                // Ensure the border doesn't affect transparent areas
                finalColor.a = max(faceColor.a, border);

                // Alternative implementation to UnityGet2DClipping with support for softness.
                #if UNITY_UI_CLIP_RECT
    half2 m = saturate((_ClipRect.zw - _ClipRect.xy - abs(IN.mask.xy)) * IN.mask.zw);
    finalColor *= m.x * m.y;
                #endif

                #if UNITY_UI_ALPHACLIP
    clip(finalColor.a - 0.001);
                #endif

                return finalColor;
            }
            ENDCG
        }
    }

    //    CustomEditor "TMPro.EditorUtilities.TMP_BitmapShaderGUI"
}