lcy
2025-01-02 c867ea92cce28ea0ceb312ef8e2f8e7e0888b1d6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
// 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
    }
 
        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"
 
            float2 _LeftBottom;
            float2 _RightTop;
            float2 _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
            }
        }
}