// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)' 
 | 
  
 | 
  
 | 
Shader "GUI/TextSmoothMask" 
 | 
{ 
 | 
    Properties 
 | 
    { 
 | 
        _MainTex("Font Texture", 2D) = "white" {} 
 | 
        _Color("Text Color", Color) = (1,1,1,1) 
 | 
  
 | 
        _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 
 | 
  
 | 
        _ColorMask("Color Mask", Float) = 15 
 | 
        _LeftBottom("Left Bottom", Vector) = (0, 0, 0, 0) 
 | 
        _RightTop("Right Top", Vector) = (0, 0, 0, 0) 
 | 
        _SmoothRect("SmoothRect", Vector) = (0, 0, 0, 0) 
 | 
    } 
 | 
  
 | 
        SubShader 
 | 
        { 
 | 
  
 | 
            Tags 
 | 
            { 
 | 
                "Queue" = "Transparent" 
 | 
                "IgnoreProjector" = "True" 
 | 
                "RenderType" = "Transparent" 
 | 
                "PreviewType" = "Plane" 
 | 
            } 
 | 
  
 | 
            Stencil 
 | 
            { 
 | 
                Ref[_Stencil] 
 | 
                Comp[_StencilComp] 
 | 
                Pass[_StencilOp] 
 | 
                ReadMask[_StencilReadMask] 
 | 
                WriteMask[_StencilWriteMask] 
 | 
            } 
 | 
  
 | 
            Lighting Off 
 | 
            Cull Off 
 | 
            ZTest[unity_GUIZTestMode] 
 | 
            ZWrite Off 
 | 
            Blend SrcAlpha OneMinusSrcAlpha 
 | 
            ColorMask[_ColorMask] 
 | 
  
 | 
            Pass 
 | 
            { 
 | 
                CGPROGRAM 
 | 
                #pragma target 3.0 
 | 
                #pragma vertex vert 
 | 
                #pragma fragment frag 
 | 
                #include "UnityCG.cginc" 
 | 
  
 | 
            float4 _LeftBottom; 
 | 
            float4 _RightTop; 
 | 
            float4 _SmoothRect; 
 | 
  
 | 
            float2 SelfUVCalculate(float2 vertex) 
 | 
            { 
 | 
                float length = abs((_LeftBottom - _RightTop).x); 
 | 
                float height = abs((_LeftBottom - _RightTop).y); 
 | 
                float2 pos = vertex - _LeftBottom; 
 | 
  
 | 
                return float2(pos.x / length, pos.y / height); 
 | 
            } 
 | 
            float MaskCalculate(float a, float2 uv) 
 | 
            { 
 | 
                a *= uv.x < _SmoothRect.x ? smoothstep(0, 1, uv.x / _SmoothRect.x) : 1; 
 | 
                a *= uv.x >(1 - _SmoothRect.x) ? smoothstep(0, 1, (1 - uv.x) / _SmoothRect.x) : 1; 
 | 
                a *= uv.y > (1 - _SmoothRect.y) ? smoothstep(0, 1, (1 - uv.y) / _SmoothRect.y) : 1; 
 | 
                a *= uv.y < _SmoothRect.y ? smoothstep(0, 1, uv.y / _SmoothRect.y) : 1; 
 | 
  
 | 
                return a; 
 | 
            } 
 | 
  
 | 
                struct appdata_t 
 | 
                { 
 | 
                    float4 vertex : POSITION; 
 | 
                    fixed4 color : COLOR; 
 | 
                    float2 texcoord : TEXCOORD0; 
 | 
                }; 
 | 
  
 | 
                struct v2f 
 | 
                { 
 | 
                    float4 vertex : SV_POSITION; 
 | 
                    fixed4 color : COLOR; 
 | 
                    float2 texcoord : TEXCOORD0; 
 | 
                    float2 texcoord1:TEXCOORD1; 
 | 
                }; 
 | 
  
 | 
                sampler2D _MainTex; 
 | 
                uniform float4 _MainTex_ST; 
 | 
                uniform fixed4 _Color; 
 | 
  
 | 
                v2f vert(appdata_t v) 
 | 
                { 
 | 
                    v2f o; 
 | 
                    o.vertex = UnityObjectToClipPos(v.vertex); 
 | 
                    o.texcoord1 = v.vertex; 
 | 
                    o.color = v.color * _Color; 
 | 
                    o.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex); 
 | 
    #ifdef UNITY_HALF_TEXEL_OFFSET 
 | 
                    o.vertex.xy += (_ScreenParams.zw - 1.0)*float2(-1,1); 
 | 
    #endif 
 | 
                    return o; 
 | 
                } 
 | 
  
 | 
                fixed4 frag(v2f i) : SV_Target 
 | 
                { 
 | 
                    fixed4 col = i.color; 
 | 
                    col.a *= tex2D(_MainTex, i.texcoord).a; 
 | 
                    col.a = MaskCalculate(col.a, SelfUVCalculate(i.texcoord1)); 
 | 
                    clip(col.a - 0.01); 
 | 
                    return col; 
 | 
                } 
 | 
                ENDCG 
 | 
            } 
 | 
        } 
 | 
} 
 |