3D.ru

    Shader "Custom/RadialOpacity" {
        Properties {
            [PerRendererData]_MainTex ("MainTex", 2D) = "white" {}
            _Color ("Color", Color) = (1,1,1,1)
            _OpacityRotator ("Opacity Rotator", Range(-360, 360)) = -360 //  2 full circles
            [HideInInspector]_Cutoff ("Alpha cutoff", Range(0,1)) = 0.5
            [MaterialToggle] PixelSnap ("Pixel snap", Float) = 0          
        }
 
        SubShader {
            Tags {
                "IgnoreProjector"="True"
                "Queue"="Transparent"
                "RenderType"="Transparent"
                "CanUseSpriteAtlas"="True"
                "PreviewType"="Plane"
            }
 
            Pass {
                Name "FORWARD"
                Tags {
                    "LightMode"="ForwardBase"
                }
 
                Blend One OneMinusSrcAlpha
                         
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag          
                #pragma multi_compile _ PIXELSNAP_ON
             
                #include "UnityCG.cginc"                    
                #pragma target 3.0
                uniform sampler2D _MainTex;
                uniform float4 _MainTex_ST;
                uniform float4 _Color;
                uniform float _OpacityRotator;          
             
                static const float TAU = float(6.283185); // это 2 * PI
 
                struct VertexInput {
                    float4 vertex : POSITION;                            
                    float2 texcoord0 : TEXCOORD0;
                };
 
                struct VertexOutput {
                    float4 pos : SV_POSITION;
                    float2 uv0 : TEXCOORD0;              
                    float3 normalDir : TEXCOORD2;                              
                };
 
                VertexOutput vert (VertexInput v) {
                    VertexOutput o = (VertexOutput)0;
                    o.uv0 = v.texcoord0;
                    o.pos = mul(UNITY_MATRIX_MVP, v.vertex );
                    #ifdef PIXELSNAP_ON
                        o.pos = UnityPixelSnap(o.pos);
                    #endif
 
                    return o;
                }
 
                float4 frag(VertexOutput i) : COLOR {
                    i.normalDir = normalize(i.normalDir);              
                    float4 _MainTex_var = tex2D(_MainTex,TRANSFORM_TEX(i.uv0, _MainTex));              
                 
                    float2 oStart = (i.uv0 - 0.5);
                    float2 oVector = float2(-1, -1);
                    float oRotatorNormalized = _OpacityRotator / 360.0;
 
                    float oRotator_ang = oRotatorNormalized * -TAU;
                    float oRotator_cos = cos(oRotator_ang);
                    float oRotator_sin = sin(oRotator_ang);              
                    float2x2 oRotationMatrix = float2x2(oRotator_cos, -oRotator_sin, oRotator_sin, oRotator_cos);              
 
                    float2 oRotatorComponent = mul(oVector * oStart, oRotationMatrix);
 
                    /* generating opacity mask BEGIN_SECTION */
                    float2 oMaskHorizOrVert = atan2(oRotatorComponent.g, oRotatorComponent.r);        
                    float oAtan2MaskNormalized = (oMaskHorizOrVert / TAU) + 0.5;              
                    float oAtan2MaskRotatable = oRotatorNormalized - oAtan2MaskNormalized;
                    float oWhiteToBlackMask = ceil(oAtan2MaskRotatable);              
                    /* generating opacity mask END_SECTION */                
 
                    float oFinalMultiply = _MainTex_var.a * max(oAtan2MaskNormalized, ceil(oWhiteToBlackMask));
 
                    /*** (Emissive) ***/              
                    float3 finalColor = _MainTex_var.rgb * _Color.rgb * oFinalMultiply;              
                    return fixed4(finalColor, oFinalMultiply);
                }
 
                ENDCG
            }      
        }
 
        FallBack "Diffuse"  
    }
 

Properties {
        ...
        _OpacityMask ("OpacityMask", 2D) = "white" {}
        ...
    }
 
    ...
 
    float oWhiteToBlackMask = ceil(OpacityMask);
    float oFinalMultiply = _MainTex_var.a * max(oAtan2MaskNormalized, ceil(oWhiteToBlackMask));
 
    ...
 

                        float _Angle;  //в градусах
                        float _Offset; // defaut: 45
                        fixed4 frag (v2f i) : SV_Target
                        {
                                float s, c;
                                sincos(radians(_Angle), s, c);
                                float2 vAngle = float2(c, s);
                                float2 vFrag = normalize(i.uv - 0.5);

                                s = vFrag.x * vAngle.y - vFrag.y * vAngle.x;
                                c = dot(vAngle, vFrag);

                                float lerpSinStart = sin(radians(_Offset));
                                float t = (s > 0) && (s < lerpSinStart) && (c > 0);
                                t *= 1 - s / lerpSinStart;
                                t *= t; // for better visual interpolation

                                // sample the texture
                                fixed4 col = tex2D(_MainTex, i.uv);                            
                                col.rgb = lerp(col.rgb, fixed3(0, 1, 0), t);
               
                                return col;
                        }