WaterFlush/Assets/MPUIKit/Runtime/Resources/Shaders/MPImage.shader

Shader "MPUI/Procedural Image"
{
    Properties
    {
        [PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" { }
        _Color ("Tint", Color) = (1, 1, 1, 1)
        _TextureSize ("Texture Size", Vector) = (1, 1, 1, 1)
        
        _DrawShape ("Draw Shape", int) = 2
        
        _StrokeWidth ("Stroke Width", float) = 0
        _FalloffDistance ("Falloff Distance", float) = 0.5
        _PixelWorldScale ("Pixel world scale", Range(0.01, 5)) = 1
        _ShapeRotation ("shape Rotation", float) = 0
        _ConstrainRotation("Constrained Rotation", int) = 0
        _FlipHorizontal ("Flip Horizontal", int) = 0
        _FlipVertical ("Flip Vertical", int) = 0
        
        _RectangleCornerRadius ("Rectangle Corner Radius", Vector) = (0, 0, 0, 0)
        _CircleRadius ("Circle Radius", float) = 0
        _CircleFitRadius ("Fit Circle Radius", float) = 0
        _PentagonCornerRadius ("Pentagon Corner Radius", Vector) = (0, 0, 0, 0)
        _PentagonTipRadius ("Pentagon Triangle Radius", float) = 0
        _PentagonTipSize ("Pentagon Triangle Size", float) = 0
        _TriangleCornerRadius ("Triangle Radius", Vector) = (0, 0, 0, 0)
        _HexagonTipSize ("Hexagon Tip Size", Vector) = (0, 0, 0, 0)
        _HexagonTipRadius ("Hexagon Tip Radius", Vector) = (0, 0, 0, 0)
        _HexagonCornerRadius ("Hexagon Corner Radius", Vector) = (0, 0, 0, 0)
        _NStarPolygonSideCount ("NStar Polygon Side Count", float) = 3
        _NStarPolygonInset ("Nstar Polygon Inset", float) = 2
        _NStarPolygonCornerRadius ("Nstar Polygon Corner Radius", float) = 0
        _NStarPolygonOffset ("Nstar Polygon Offset", Vector) = (0, 0, 0, 0)
        
        _EnableGradient ("Enable GradientEffect", int) = 0
        _GradientType ("GradientEffect Type", int) = 0
        _GradientInterpolationType ("GradientEffect Interpolation Type", int) = 0
        _GradientRotation ("_GradientRotation", float) = 0
        _GradientColor0 ("GradientColor0", Vector) = (0, 0, 0, 0)
        _GradientColor1 ("GradientColor1", Vector) = (1, 1, 1, 1)
        _GradientColor2 ("GradientColor2", Vector) = (0, 0, 0, 0)
        _GradientColor3 ("GradientColor3", Vector) = (0, 0, 0, 0)
        _GradientColor4 ("GradientColor4", Vector) = (0, 0, 0, 0)
        _GradientColor5 ("GradientColor5", Vector) = (0, 0, 0, 0)
        _GradientColor6 ("GradientColor6", Vector) = (0, 0, 0, 0)
        _GradientColor7 ("GradientColor7", Vector) = (0, 0, 0, 0)
        _GradientColorLength ("GradientColorLength", int) = 0
        _GradientAlpha0 ("GradientAlpha0", Vector) = (1, 0, 0, 0)
        _GradientAlpha1 ("GradientAlpha1", Vector) = (1, 1, 0, 0)
        _GradientAlpha2 ("GradientAlpha2", Vector) = (0, 0, 0, 0)
        _GradientAlpha3 ("GradientAlpha3", Vector) = (0, 0, 0, 0)
        _GradientAlpha4 ("GradientAlpha4", Vector) = (0, 0, 0, 0)
        _GradientAlpha5 ("GradientAlpha5", Vector) = (0, 0, 0, 0)
        _GradientAlpha6 ("GradientAlpha6", Vector) = (0, 0, 0, 0)
        _GradientAlpha7 ("GradientAlpha7", Vector) = (0, 0, 0, 0)
        _GradientAlphaLength ("GradientAlphaLength", int) = 0
        _CornerGradientColor0 ("CornerGradientColor0", Color) = (1, 0, 0, 1)
        _CornerGradientColor1 ("CornerGradientColor1", Color) = (0, 1, 0, 1)
        _CornerGradientColor2 ("CornerGradientColor2", Color) = (0, 0, 1, 1)
        _CornerGradientColor3 ("CornerGradientColor3", Color) = (0, 0, 0, 1)
        
        _OutlineWidth ("Outline Width", float) = 0
        _OutlineColor ("Outline Color", Color) = (0, 0, 0, 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
        
              /* //SOFTMASK_HANDLE_START
         [PerRendererData] _SoftMask ("Mask", 2D) = "white" {}
              */ //SOFTMASK_HANDLE_END
        
        [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
    }
    
    SubShader
    {
        Tags { "Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Transparent" "PreviewType" = "Plane" "CanUseSpriteAtlas" = "True" }
        
        Stencil
        {
            Ref [_Stencil]
            Comp [_StencilComp]
            Pass [_StencilOp]
            ReadMask [_StencilReadMask]
            WriteMask [_StencilWriteMask]
        }
        
        Cull Off
        Lighting Off
        ZWrite Off
        ZTest [unity_GUIZTestMode]
        Blend SrcAlpha OneMinusSrcAlpha
        ColorMask [_ColorMask]
        
        Pass
        {
            Name "Default"
            CGPROGRAM
            
            #pragma vertex vert
            #pragma fragment frag
            
            #include "UnityCG.cginc"
            #include "UnityUI.cginc"
            #include "2D_SDF.cginc"
                  /* //SOFTMASK_HANDLE_START
			#include "Assets/SoftMask/Shaders/SoftMask.cginc" //SOFTMASK_INCLUDE_HANDLE
                  */ //SOFTMASK_HANDLE_END
            
            
            #pragma multi_compile_local _ UNITY_UI_CLIP_RECT
            #pragma multi_compile_local _ UNITY_UI_ALPHACLIP
            
            #pragma multi_compile_local _ CIRCLE TRIANGLE RECTANGLE PENTAGON HEXAGON NSTAR_POLYGON
            
            #pragma multi_compile_local _ STROKE OUTLINED OUTLINED_STROKE
            #pragma multi_compile_local _ GRADIENT_LINEAR GRADIENT_RADIAL GRADIENT_CORNER

                  /* //SOFTMASK_HANDLE_START
            #pragma multi_compile _ SOFTMASK_SIMPLE
                  */ //SOFTMASK_HANDLE_END
            
            struct appdata_t
            {
                float4 vertex: POSITION;
                float4 color: COLOR;
                float2 texcoord: TEXCOORD0;
                float2 uv1: TEXCOORD1;
                float2 size: TEXCOORD2;
                
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };
            
            struct v2f
            {
                float4 vertex: SV_POSITION;
                fixed4 color: COLOR;
                float2 texcoord: TEXCOORD0;
                float4 shapeData: TEXCOORD1;
                float2 effectsUv: TEXCOORD2;
                float4 worldPosition : TEXCOORD3;


                      /* //SOFTMASK_HANDLE_START
                SOFTMASK_COORDS(4)
                      */ //SOFTMASK_HANDLE_END
                
                UNITY_VERTEX_OUTPUT_STEREO
            };
            
            sampler2D _MainTex; float4 _MainTex_ST;
            fixed4 _Color;
            fixed4 _TextureSize;
            fixed4 _TextureSampleAdd;
            float4 _ClipRect;
            half _PixelWorldScale;
            half _StrokeWidth;
            half _OutlineWidth;
            half4 _OutlineColor;
            half _FalloffDistance;
            half _ShapeRotation;
            half _ConstrainRotation;
            half _FlipHorizontal;
            half _FlipVertical;
            
            #if RECTANGLE
                float4 _RectangleCornerRadius;
            #endif
            
            #if CIRCLE
                float _CircleRadius;
                float _CircleFitRadius;
            #endif
            
            #if PENTAGON
                float4 _PentagonCornerRadius;
                float _PentagonTipRadius;
                float _PentagonTipSize;
            #endif
            
            #if TRIANGLE
                float3 _TriangleCornerRadius;
            #endif
            
            #if HEXAGON
                half2 _HexagonTipSize;
                half2 _HexagonTipRadius;
                half4 _HexagonCornerRadius;
            #endif
            
            #if NSTAR_POLYGON
                float _NStarPolygonSideCount;
                float _NStarPolygonCornerRadius;
                float _NStarPolygonInset;
                float2 _NStarPolygonOffset;
            #endif
            
            #if GRADIENT_LINEAR || GRADIENT_RADIAL
                half4 colors[8];
                half4 alphas[8];
                half _GradientInterpolationType;
                half _GradientColorLength;
                half _GradientAlphaLength;
                half _GradientRotation;
                
                half4 _GradientColor0;
                half4 _GradientColor1;
                half4 _GradientColor2;
                half4 _GradientColor3;
                half4 _GradientColor4;
                half4 _GradientColor5;
                half4 _GradientColor6;
                half4 _GradientColor7;
                
                half4 _GradientAlpha0;
                half4 _GradientAlpha1;
                half4 _GradientAlpha2;
                half4 _GradientAlpha3;
                half4 _GradientAlpha4;
                half4 _GradientAlpha5;
                half4 _GradientAlpha6;
                half4 _GradientAlpha7;
            #endif
            
            #if GRADIENT_CORNER
                half4 _CornerGradientColor0;
                half4 _CornerGradientColor1;
                half4 _CornerGradientColor2;
                half4 _CornerGradientColor3;
            #endif
            
            
            
            
            
            #if GRADIENT_LINEAR || GRADIENT_RADIAL
                float4 SampleGradient(float Time)
                {
                    float3 color = colors[0].rgb;
                    [unroll]
                    for (int c = 1; c < 8; c ++)
                    {
                        float colorPos = saturate((Time - colors[c - 1].w) / (colors[c].w - colors[c - 1].w)) * step(c, _GradientColorLength - 1);
                        color = lerp(color, colors[c].rgb, lerp(colorPos, step(0.01, colorPos), _GradientInterpolationType));
                    }
                    
                    float alpha = alphas[0].x;
                    [unroll]
                    for (int a = 1; a < 8; a ++)
                    {
                        float alphaPos = saturate((Time - alphas[a - 1].y) / (alphas[a].y - alphas[a - 1].y)) * step(a, _GradientAlphaLength - 1);
                        alpha = lerp(alpha, alphas[a].x, lerp(alphaPos, step(0.01, alphaPos), _GradientInterpolationType));
                    }
                    return float4(color, alpha);
                }
            #endif
            
            #if RECTANGLE
                half rectangleScene(float4 _additionalData)
                {

                    float2 _texcoord = _additionalData.xy;
                    float2 _size = float2(_additionalData.z, _additionalData.w);
                    float4 radius = _RectangleCornerRadius;
                    half4 c  = half4(_texcoord, _size - _texcoord);
                    half rect = min(min(min(c.x, c.y), c.z), c.w);

                    bool4 cornerRects;
                    cornerRects.x = _texcoord.x < radius.x && _texcoord.y < radius.x;
                    cornerRects.y = _texcoord.x > _size.x - radius.y && _texcoord.y < radius.y;
                    cornerRects.z = _texcoord.x > _size.x - radius.z && _texcoord.y > _size.y - radius.z;
                    cornerRects.w = _texcoord.x < radius.w && _texcoord.y > _size.y - radius.w;

                    half cornerMask = any(cornerRects);

                    half4 cornerCircles;
                    cornerCircles.x = radius.x - length(_texcoord - radius.xx);
                    cornerCircles.y = radius.y - length(_texcoord - half2(_size.x - radius.y, radius.y));
                    cornerCircles.z = radius.z - length(_texcoord - (half2(_size.x, _size.y) - radius.zz));
                    cornerCircles.w = radius.w - length(_texcoord - half2(radius.w, _size.y - radius.w));

                    cornerCircles = min(max(cornerCircles, 0) * cornerRects, rect);
                    half corners = max(max(max(cornerCircles.x, cornerCircles.y), cornerCircles.z), cornerCircles.w);
                    corners = max(corners, 0.0) * cornerMask;

                    return rect*(cornerMask-1) - corners;
                    /*
                    float2 _texcoord = _additionalData.xy;
                    float2 _size = float2(_additionalData.z, _additionalData.w);
                    float4 radius = _RectangleCornerRadius;
                    
                    
                    half rect = rectanlge(_texcoord - half2(_size.x / 2.0, _size.y / 2.0), _size.x, _size.y);
                    half cornerCircle = circle(_texcoord - radius.xx, radius.x);
                    rect = _texcoord.x < radius.x && _texcoord.y < radius.x ? cornerCircle: rect;
                    cornerCircle = circle(_texcoord - half2(_size.x - radius.y, radius.y), radius.y);
                    rect = _texcoord.x > _size.x - radius.y && _texcoord.y < radius.y ? cornerCircle: rect;
                    cornerCircle = circle(_texcoord - (half2(_size.x, _size.y) - radius.zz), radius.z);
                    rect = _texcoord.x > _size.x - radius.z && _texcoord.y > _size.y - radius.z ? cornerCircle: rect;
                    cornerCircle = circle(_texcoord - half2(radius.w, _size.y - radius.w), radius.w);
                    rect = _texcoord.x < radius.w && _texcoord.y > _size.y - radius.w ? cornerCircle: rect;
                    
                    return rect;
                    */
                }
            #endif
            
            #if CIRCLE
                float circleScene(float4 _additionalData)
                {
                    float2 _texcoord = _additionalData.xy;
                    float2 _size = float2(_additionalData.z, _additionalData.w);
                    float width = _size.x;
                    float height = _size.y;
                    float radius = lerp(_CircleRadius, min(width, height) / 2.0, _CircleFitRadius);
                    half sdf = circle(_texcoord - float2(width / 2.0, height / 2.0), radius);
                    return sdf;
                }
            #endif
            
            #if TRIANGLE
                half triangleScene(float4 _additionalData)
                {
                    float2 _texcoord = _additionalData.xy;
                    float2 _size = float2(_additionalData.z, _additionalData.w);
                    float width = _size.x;//_additionalData.z;
                    float height = _size.y;//_additionalData.w;
                    
                    half sdf = sdTriangleIsosceles(_texcoord - half2(width / 2.0, height), half2(width / 2.0, -height));

                    //return sdf;
                    
                    _TriangleCornerRadius = max(_TriangleCornerRadius, half3(0.001, 0.001, 0.001));
                    // Left Corner
                    half halfWidth = width / 2.0;
                    half m = height / halfWidth;
                    half d = sqrt(1.0 + m * m);
                    half c = 0.0;
                    half k = -_TriangleCornerRadius.x * d + c;
                    half x = (_TriangleCornerRadius.x - k) / m;
                    half2 circlePivot = half2(x, _TriangleCornerRadius.x);
                    half cornerCircle = circle(_texcoord - circlePivot, _TriangleCornerRadius.x);
                    //sdf = sdfDifference(sdf, cornerCircle);
                    //return sdf;
                    x = (circlePivot.y + circlePivot.x / m - c) / (m + 1.0 / m);
                    half y = m * x + c;
                    half fy = map(_texcoord.x, x, circlePivot.x, y, circlePivot.y);
                    sdf = _texcoord.y < fy && _texcoord.x < circlePivot.x ? cornerCircle: sdf;
                    //return sdf;
                    // Right Corner
                    m = -m; c = 2.0 * height;
                    k = -_TriangleCornerRadius.y * d + c;
                    x = (_TriangleCornerRadius.y - k) / m;
                    circlePivot = half2(x, _TriangleCornerRadius.y);
                    cornerCircle = circle(_texcoord - circlePivot, _TriangleCornerRadius.y);
                    x = (circlePivot.y + circlePivot.x / m - c) / (m + 1.0 / m); y = m * x + c;
                    fy = map(_texcoord.x, circlePivot.x, x, circlePivot.y, y);
                    sdf = _texcoord.x > circlePivot.x && _texcoord.y < fy ? cornerCircle: sdf;
                    
                    //Top Corner
                    k = -_TriangleCornerRadius.z * sqrt(1.0 + m * m) + c;
                    y = m * (width / 2.0) + k;
                    circlePivot = half2(halfWidth, y);
                    cornerCircle = circle(_texcoord - circlePivot, _TriangleCornerRadius.z);
                    x = (circlePivot.y + circlePivot.x / m - c) / (m + 1.0 / m); y = m * x + c;
                    fy = map(_texcoord.x, width - x, x, -1.0, 1.0);
                    fy = lerp(circlePivot.y, y, abs(fy));
                    sdf = _texcoord.y > fy ? cornerCircle: sdf;
                    
                    return sdf;
                }
            #endif
            
            #if PENTAGON
                half pentagonScene(float4 _additionalData)
                {
                    
                    float2 _texcoord = _additionalData.xy;
                    float2 _size = float2(_additionalData.z, _additionalData.w);
                    float width = _size.x;
                    float height = _size.y;
                    
                    // solid pentagon
                    half baseRect = rectanlge(_texcoord - half2(width / 2.0, height / 2.0), width, height);
                    half scale = height / _PentagonTipSize;
                    half rhombus = sdRhombus(_texcoord - float2(width / 2, _PentagonTipSize * scale), float2(width / 2, _PentagonTipSize) * scale);
                    half sdfPentagon = sdfDifference(baseRect, sdfDifference(baseRect, rhombus));
                    
                    // Bottom rounded corner
                    _PentagonTipRadius = max(_PentagonTipRadius, 0.001);
                    float halfWidth = width / 2;
                    float m = -_PentagonTipSize / halfWidth;
                    float d = sqrt(1 + m * m);
                    float c = _PentagonTipSize;
                    float k = _PentagonTipRadius * d + _PentagonTipSize;
                    
                    half2 circlePivot = half2(halfWidth, m * halfWidth + k);
                    half cornerCircle = circle(_texcoord - circlePivot, _PentagonTipRadius);
                    half x = (circlePivot.y + circlePivot.x / m - c) / (m + 1 / m);
                    half y = m * x + c;
                    half fy = map(_texcoord.x, x, width - x, -1, 1);
                    fy = lerp(_PentagonTipRadius, y, abs(fy));
                    sdfPentagon = _texcoord.y < fy ? cornerCircle: sdfPentagon;
                    
                    // Mid Left rounded corner
                    k = _PentagonCornerRadius.w * d + _PentagonTipSize;
                    circlePivot = half2(_PentagonCornerRadius.w, m * _PentagonCornerRadius.w + k);
                    cornerCircle = circle(_texcoord - circlePivot, _PentagonCornerRadius.w);
                    x = (circlePivot.y + circlePivot.x / m - c) / (m + 1 / m); y = m * x + c;
                    fy = map(_texcoord.x, x, circlePivot.x, y, circlePivot.y);
                    sdfPentagon = _texcoord.y > fy && _texcoord.y < circlePivot.y ? cornerCircle: sdfPentagon;
                    
                    // Mid Right rounded corner
                    m = -m; k = _PentagonCornerRadius.z * d - _PentagonTipSize;
                    circlePivot = half2(width - _PentagonCornerRadius.z, m * (width - _PentagonCornerRadius.z) + k);
                    cornerCircle = circle(_texcoord - circlePivot, _PentagonCornerRadius.z);
                    x = (circlePivot.y + circlePivot.x / m - c) / (m + 1 / m); y = m * x + c;
                    fy = map(_texcoord.x, circlePivot.x, x, circlePivot.y, y);
                    sdfPentagon = _texcoord.y > fy && _texcoord.y < circlePivot.y ? cornerCircle: sdfPentagon;
                    
                    // Top rounded corners
                    cornerCircle = circle(_texcoord - half2(_PentagonCornerRadius.x, height - _PentagonCornerRadius.x), _PentagonCornerRadius.x);
                    bool mask = _texcoord.x < _PentagonCornerRadius.x && _texcoord.y > height - _PentagonCornerRadius.x;
                    sdfPentagon = mask ? cornerCircle: sdfPentagon;
                    cornerCircle = circle(_texcoord - half2(width - _PentagonCornerRadius.y, height - _PentagonCornerRadius.y), _PentagonCornerRadius.y);
                    mask = _texcoord.x > width - _PentagonCornerRadius.y && _texcoord.y > height - _PentagonCornerRadius.y;
                    sdfPentagon = mask ? cornerCircle: sdfPentagon;
                    
                    return sdfPentagon;
                }
            #endif
            
            #if HEXAGON
                half hexagonScene(float4 _additionalData)
                {
                    float2 _texcoord = _additionalData.xy;
                    float2 _size = float2(_additionalData.z, _additionalData.w);
                    float width = _size.x;//_additionalData.z;
                    float height = _size.y;//_additionalData.w;
                    
                    half baseRect = rectanlge(_texcoord - half2(width / 2.0, height / 2.0), width, height);
                    half scale = width / _HexagonTipSize.x;
                    half rhombus1 = sdRhombus(_texcoord - float2(_HexagonTipSize.x * scale, height / 2.0), float2(_HexagonTipSize.x, height / 2.0) * scale);
                    scale = width / _HexagonTipSize.y;
                    half rhombus2 = sdRhombus(_texcoord - float2(width - _HexagonTipSize.y * scale, height / 2.0), float2(_HexagonTipSize.y, height / 2.0) * scale);
                    half sdfHexagon = sdfDifference(sdfDifference(baseRect, -rhombus1), -rhombus2);

                    
                    
                    //Left Rounded Corners
                    float halfHeight = height / 2.0;
                    float m = -halfHeight / _HexagonTipSize.x;
                    float c = halfHeight;
                    float d = sqrt(1.0 + m * m);
                    float k = _HexagonTipRadius.x * d + c;
                    //middle
                    half2 circlePivot = half2((halfHeight - k) / m, halfHeight);
                    half cornerCircle = circle(_texcoord - circlePivot, _HexagonTipRadius.x);
                    half x = (circlePivot.y + circlePivot.x / m - c) / (m + 1.0 / m);
                    half y = m * x + c;
                    half fy = map(_texcoord.x, x, circlePivot.x, y, circlePivot.y);
                    sdfHexagon = _texcoord.y > fy && _texcoord.y < height - fy ? cornerCircle: sdfHexagon;

                    //return sdfHexagon;
                    
                    //bottom
                    k = _HexagonCornerRadius.x * d + c;
                    circlePivot = half2((_HexagonCornerRadius.x - k) / m, _HexagonCornerRadius.x);
                    cornerCircle = circle(_texcoord - circlePivot, _HexagonCornerRadius.x);
                    x = (circlePivot.y + circlePivot.x / m - c) / (m + 1.0 / m); y = m * x + c;
                    fy = map(_texcoord.x, x, circlePivot.x, y, circlePivot.y);
                    sdfHexagon = _texcoord.y < fy && _texcoord.x < circlePivot.x ? cornerCircle: sdfHexagon;

                    //return sdfHexagon;
                    //top
                    k = _HexagonCornerRadius.w * d + c;
                    circlePivot = half2((_HexagonCornerRadius.w - k) / m, height - _HexagonCornerRadius.w);
                    cornerCircle = circle(_texcoord - circlePivot, _HexagonCornerRadius.w);
                    x = (_HexagonCornerRadius.w + circlePivot.x / m - c) / (m + 1.0 / m); y = m * x + c;
                    fy = map(_texcoord.x, x, circlePivot.x, height - y, circlePivot.y);
                    sdfHexagon = _texcoord.y > fy && _texcoord.x < circlePivot.x ? cornerCircle: sdfHexagon;
                    //return sdfHexagon;
                    //Right Rounded Corners
                    m = halfHeight / _HexagonTipSize.y;
                    d = sqrt(1.0 + m * m);
                    c = halfHeight - m * width;
                    k = _HexagonTipRadius.y * d + c;
                    
                    //middle
                    circlePivot = half2((halfHeight - k) / m, halfHeight);
                    cornerCircle = circle(_texcoord - circlePivot, _HexagonTipRadius.y);
                    x = (circlePivot.y + circlePivot.x / m - c) / (m + 1.0 / m); y = m * x + c;
                    fy = map(_texcoord.x, circlePivot.x, x, circlePivot.y, y);
                    sdfHexagon = _texcoord.y > fy && _texcoord.y < height - fy ? cornerCircle: sdfHexagon;
                    //return sdfHexagon;
                    //bottom
                    k = _HexagonCornerRadius.y * d + c;
                    circlePivot = half2((_HexagonCornerRadius.y - k) / m, _HexagonCornerRadius.y);
                    cornerCircle = circle(_texcoord - circlePivot, _HexagonCornerRadius.y);
                    x = (circlePivot.y + circlePivot.x / m - c) / (m + 1.0 / m); y = m * x + c;
                    fy = map(_texcoord.x, circlePivot.x, x, circlePivot.y, y);
                    sdfHexagon = _texcoord.y < fy && _texcoord.x > circlePivot.x ? cornerCircle: sdfHexagon;
                    //return sdfHexagon;
                    //top
                    k = _HexagonCornerRadius.z * d + c;
                    circlePivot = half2((_HexagonCornerRadius.z - k) / m, height - _HexagonCornerRadius.z);
                    cornerCircle = circle(_texcoord - circlePivot, _HexagonCornerRadius.z);
                    x = (_HexagonCornerRadius.z + circlePivot.x / m - c) / (m + 1.0 / m); y = m * x + c;
                    fy = map(_texcoord.x, circlePivot.x, x, circlePivot.y, height - y);
                    sdfHexagon = _texcoord.y > fy && _texcoord.x > circlePivot.x ? cornerCircle: sdfHexagon;
                    
                    return sdfHexagon;
                }
                
            #endif
            
            
            #if NSTAR_POLYGON
                half nStarPolygonScene(float4 _additionalData)
                {
                    float2 _texcoord = _additionalData.xy;
                    float width = _additionalData.z;
                    float height = _additionalData.w;
                    float size = height / 2 - _NStarPolygonCornerRadius;
                    half str = sdNStarPolygon(_texcoord - half2(width / 2, height / 2) - _NStarPolygonOffset, size, _NStarPolygonSideCount, _NStarPolygonInset) - _NStarPolygonCornerRadius;
                    return str;
                }
            #endif
            
            float2 rotateUV(float2 uv, float rotation, float2 mid)
            {
                return float2(
                  cos(rotation) * (uv.x - mid.x) + sin(rotation) * (uv.y - mid.y) + mid.x,
                  cos(rotation) * (uv.y - mid.y) - sin(rotation) * (uv.x - mid.x) + mid.y
                );
            }
            
            v2f vert(appdata_t v)
            {
                v2f OUT;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);
                OUT.worldPosition = v.vertex;
                OUT.vertex = UnityObjectToClipPos(v.vertex);
                OUT.texcoord = v.texcoord;
                OUT.effectsUv = v.uv1;
                
                float2 size = float2(v.size.x + _FalloffDistance, v.size.y + _FalloffDistance);
                float shapeRotation = radians(_ShapeRotation);
                size = _ConstrainRotation > 0.0 && frac(abs(shapeRotation) / 3.14159) > 0.1? float2(size.y, size.x) : size;
                
                float2 shapeUv = _ConstrainRotation > 0 ? v.uv1 : v.uv1 * size;
                shapeUv = rotateUV(shapeUv, shapeRotation, _ConstrainRotation > 0? float2(0.5, 0.5) : size * 0.5);
                shapeUv*= _ConstrainRotation > 0.0? size : 1.0;
                
                shapeUv.x = lerp(shapeUv.x, abs(size.x - shapeUv.x), _FlipHorizontal);
                shapeUv.y = lerp(shapeUv.y, abs(size.y - shapeUv.y), _FlipVertical);
                
                OUT.shapeData = float4(shapeUv.x, shapeUv.y, size.x, size.y);
                
                #ifdef UNITY_HALF_TEXEL_OFFSET
                    OUT.vertex.xy += (_ScreenParams.zw - 1.0) * float2(-1.0, 1.0);
                #endif
                OUT.color = v.color * _Color;


                      /* //SOFTMASK_HANDLE_START
                SOFTMASK_CALCULATE_COORDS(OUT, v.vertex);
                      */ //SOFTMASK_HANDLE_END
                return OUT;
            }
            
            fixed4 frag(v2f IN): SV_Target
            {
                half4 color = IN.color;
                half2 texcoord = IN.texcoord;
                color = (tex2D(_MainTex, texcoord) + _TextureSampleAdd) * color;
                
                
                #if GRADIENT_LINEAR || GRADIENT_RADIAL
                    colors[0] = _GradientColor0;
                    colors[1] = _GradientColor1;
                    colors[2] = _GradientColor2;
                    colors[3] = _GradientColor3;
                    colors[4] = _GradientColor4;
                    colors[5] = _GradientColor5;
                    colors[6] = _GradientColor6;
                    colors[7] = _GradientColor7;
                    
                    alphas[0] = _GradientAlpha0;
                    alphas[1] = _GradientAlpha1;
                    alphas[2] = _GradientAlpha2;
                    alphas[3] = _GradientAlpha3;
                    alphas[4] = _GradientAlpha4;
                    alphas[5] = _GradientAlpha5;
                    alphas[6] = _GradientAlpha6;
                    alphas[7] = _GradientAlpha7;
                #endif
                
                #if GRADIENT_LINEAR
                    half gradientRotation = radians(_GradientRotation);
                    half t = cos(gradientRotation) * (IN.effectsUv.x - 0.5) + 
                             sin(gradientRotation) * (IN.effectsUv.y - 0.5) + 0.5;
                    half4 grad = SampleGradient(t);
                    color *= grad;
                #endif
                #if GRADIENT_RADIAL
                    half fac = saturate(length(IN.effectsUv - float2(.5, .5)) * 2);
                    half4 grad = SampleGradient(clamp(fac, 0, 1));
                    color *= grad;
                #endif
                
                #if GRADIENT_CORNER
                    half4 topCol = lerp(_CornerGradientColor2, _CornerGradientColor3, IN.effectsUv.x);
                    half4 bottomCol = lerp(_CornerGradientColor0, _CornerGradientColor1, IN.effectsUv.x);
                    half4 finalCol = lerp(topCol, bottomCol, IN.effectsUv.y);
                    
                    color *= finalCol;
                #endif
                
                #if RECTANGLE || CIRCLE || PENTAGON || TRIANGLE || HEXAGON || NSTAR_POLYGON
                    float sdfData = 0;
                    float pixelScale = clamp(1.0/_FalloffDistance, 1.0/2048.0, 2048.0);
                    #if RECTANGLE
                        sdfData = rectangleScene(IN.shapeData);
                    #elif CIRCLE
                        sdfData = circleScene(IN.shapeData);
                    #elif PENTAGON
                        sdfData = pentagonScene(IN.shapeData);
                    #elif TRIANGLE
                        sdfData = triangleScene(IN.shapeData);
                    #elif HEXAGON
                        sdfData = hexagonScene(IN.shapeData);
                    #elif NSTAR_POLYGON
                        sdfData = nStarPolygonScene(IN.shapeData);
                    #endif
                
                    #if !OUTLINED && !STROKE && !OUTLINED_STROKE
                        float sdf = sampleSdf(sdfData, pixelScale);
                        color.a *= sdf;
                    #endif
                    #if STROKE
                        float sdf = sampleSdfStrip(sdfData, _StrokeWidth + _OutlineWidth, pixelScale);
                        color.a *= sdf;
                    #endif
                    
                    #if OUTLINED
                        float alpha = sampleSdf(sdfData, pixelScale);
                        float lerpFac = sampleSdf(sdfData + _OutlineWidth, pixelScale);
                        color = half4(lerp(_OutlineColor.rgb, color.rgb, lerpFac), lerp(_OutlineColor.a * color.a, color.a, lerpFac));
                        color.a *= alpha;
                    #endif
                    
                    #if OUTLINED_STROKE
                        float alpha = sampleSdfStrip(sdfData, _OutlineWidth + _StrokeWidth, pixelScale);
                        float lerpFac = sampleSdfStrip(sdfData + _OutlineWidth, _StrokeWidth + _FalloffDistance, pixelScale);
                        lerpFac = clamp(lerpFac, 0, 1);
                        color = half4(lerp(_OutlineColor.rgb, color.rgb, lerpFac), lerp(_OutlineColor.a * color.a, color.a, lerpFac));
                        color.a *= alpha;
                    #endif
                #endif

                      /* //SOFTMASK_HANDLE_START
                color.a *= SOFTMASK_GET_MASK(IN);
                      */ //SOFTMASK_HANDLE_END
                
                #ifdef UNITY_UI_CLIP_RECT
                    color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect);
                #endif
                
                #ifdef UNITY_UI_ALPHACLIP
                    clip(color.a - 0.001);
                #endif
                
                return fixed4(color);
            }
            ENDCG
            
        }
    }
    CustomEditor "MPUIKIT.Editor.MPImageShaderGUI"
}