UGUI 图片倒影效果

先贴上效果图

上面这个参数是类似与遮罩的一张 图片：
遮罩的图片不能是完全透明的哦！

图片链接：
链接：https://pan.baidu.com/s/1x4HpC8_Tv3rI6Bnaemcy9Q
提取码：jlyc

注意：倒影的那张图片ImageZ轴要旋转180,代码挂在到倒影Image上面。
代码部分

using UnityEngine;
using UnityEngine.UI;

[ExecuteInEditMode]
[AddComponentMenu("UI/Effects/SoftMaskScript")]
public class bl_GallerySoftMask : MonoBehaviour
{
    Material mat;

    Canvas cachedCanvas = null;
    Transform cachedCanvasTransform = null;
    readonly Vector3[] m_WorldCorners = new Vector3[4];
    readonly Vector3[] m_CanvasCorners = new Vector3[4];

    [Tooltip("The area that is to be used as the container.")]
    public RectTransform MaskArea;

    [Tooltip("Texture to be used to do the soft alpha")]
    public Texture AlphaMask;

    [Tooltip("At what point to apply the alpha min range 0-1")]
    [Range(0, 1)]
    public float CutOff = 0;

    [Tooltip("Implement a hard blend based on the Cutoff")]
    public bool HardBlend = false;

    [Tooltip("Flip the masks alpha value")]
    public bool FlipAlphaMask = false;

    [Tooltip("If a different Mask Scaling Rect is given, and this value is true, the area around the mask will not be clipped")]
    public bool DontClipMaskScalingRect = false;

    Vector2 maskOffset = Vector2.zero;
    Vector2 maskScale = Vector2.one;

    // Use this for initialization
    void Start()
    {
        if (MaskArea == null)
        {
            MaskArea = GetComponent<RectTransform>();
        }

        var text = GetComponent<Text>();
        if (text != null)
        {
            mat = new Material(Shader.Find("Gallery/SoftMaskShader"));
            text.material = mat;
            cachedCanvas = text.canvas;
            cachedCanvasTransform = cachedCanvas.transform;
            // For some reason, having the mask control on the parent and disabled stops the mouse interacting
            // with the texture layer that is not visible.. Not needed for the Image.
            if (transform.parent.GetComponent<Mask>() == null)
                transform.parent.gameObject.AddComponent<Mask>();

            transform.parent.GetComponent<Mask>().enabled = false;
            return;
        }

        var graphic = GetComponent<Graphic>();
        if (graphic != null)
        {
            mat = new Material(Shader.Find("Gallery/SoftMaskShader"));
            graphic.material = mat;
            cachedCanvas = graphic.canvas;
            cachedCanvasTransform = cachedCanvas.transform;
        }
    }

    void Update()
    {
        
        if (cachedCanvas != null)
        {
            SetMask();
        }
    }

    void SetMask()
    {
        var worldRect = GetCanvasRect();
        var size = worldRect.size;
        maskScale.Set(1.0f / size.x, 1.0f / size.y);
        maskOffset = -worldRect.min;
        maskOffset.Scale(maskScale);

        mat.SetTextureOffset("_AlphaMask", maskOffset);
        mat.SetTextureScale("_AlphaMask", maskScale);
        mat.SetTexture("_AlphaMask", AlphaMask);

        mat.SetFloat("_HardBlend", HardBlend ? 1 : 0);
        mat.SetInt("_FlipAlphaMask", FlipAlphaMask ? 1 : 0);
        mat.SetInt("_NoOuterClip", DontClipMaskScalingRect ? 1 : 0);
        mat.SetFloat("_CutOff", CutOff);
    }

    public Rect GetCanvasRect()
    {
        if (cachedCanvas == null)
            return new Rect();

        MaskArea.GetWorldCorners(m_WorldCorners);
        for (int i = 0; i < 4; ++i)
            m_CanvasCorners[i] = cachedCanvasTransform.InverseTransformPoint(m_WorldCorners[i]);

        return new Rect(m_CanvasCorners[0].x, m_CanvasCorners[0].y, m_CanvasCorners[2].x - m_CanvasCorners[0].x, m_CanvasCorners[2].y - m_CanvasCorners[0].y);
    }
}

Shader部分

Shader "Gallery/SoftMaskShader"
{
	Properties
	{
		[PerRendererData] _MainTex("Sprite Texture", 2D) = "white" {}
	_Color("Tint", 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
		_AlphaMask("AlphaMask - Must be Wrapped",2D) = "white"{}
	_CutOff("CutOff",Float) = 0
		[MaterialToggle]
	_HardBlend("HardBlend",Float) = 0
		_FlipAlphaMask("Flip Alpha Mask",int) = 0
		_NoOuterClip("Outer Clip",int) = 0
	}

		SubShader
	{
		Tags
	{
		"Queue" = "Transparent"
		"IgnoreProjector" = "True"
		"RenderType" = "Transparent"
		"PreviewType" = "Plane"
		"CanUseSpriteAtlas" = "True"
	}

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

		LOD 0

		Cull Off
		Lighting Off
		ZWrite Off
		ZTest[unity_GUIZTestMode]
		Blend SrcAlpha OneMinusSrcAlpha
		ColorMask[_ColorMask]

		Pass
	{
		CGPROGRAM
#pragma vertex vert
#pragma fragment frag

#include "UnityCG.cginc"

		struct appdata_t
	{
		float4 vertex   : POSITION;
		float4 color    : COLOR;
		float2 texcoord : TEXCOORD0;
	};

	struct v2f
	{
		float4 vertex   : SV_POSITION;
		fixed4 color : COLOR;
		half2 texcoord  : TEXCOORD0;
		float2 maskTexcoord : TEXCOORD1;
	};

	inline float UnityGet2DClipping(in float2 position, in float4 clipRect)
	{
		float2 inside = step(clipRect.xy, position.xy) * step(position.xy, clipRect.zw);
		return inside.x * inside.y;
	}

	fixed4 _Color;
	fixed4 _TextureSampleAdd;
	sampler2D _MainTex;

	bool _UseAlphaClip;
	int _FlipAlphaMask = 0;
	float4 _AlphaMask_ST;
	sampler2D _AlphaMask;

	v2f vert(appdata_t IN)
	{
		v2f OUT;
		float4 wolrdPos = IN.vertex;
		OUT.maskTexcoord = TRANSFORM_TEX(wolrdPos.xy, _AlphaMask);
		OUT.vertex = UnityObjectToClipPos(IN.vertex);
		OUT.texcoord = IN.texcoord;

#ifdef UNITY_HALF_TEXEL_OFFSET
		OUT.vertex.xy += (_ScreenParams.zw - 1.0)*float2(-1,1);
#endif

		OUT.color = IN.color * _Color;
		return OUT;
	}

	float _CutOff;
	bool _HardBlend = false;
	bool _NoOuterClip = false;

	fixed4 frag(v2f IN) : SV_Target
	{
		half4 color = (tex2D(_MainTex, IN.texcoord) + _TextureSampleAdd) * IN.color;
		float4 inMask = float4(
			step(float2(0.0f, 0.0f), IN.maskTexcoord),
			step(IN.maskTexcoord, float2(1.0f, 1.0f)));

		// Do we want to clip the image to the Mask Rectangle?
		if (_NoOuterClip == false && all(inMask) == false)
		{
			color.a = 0;
		}
		else // It's in the mask rectangle, so apply the alpha of the mask provided.
		{

			float a = tex2D(_AlphaMask, IN.maskTexcoord).a;

			if (a <= _CutOff)
				a = 0;
			else
			{
				if (_HardBlend)
					a = 1;
			}

			if (_FlipAlphaMask == 1)
				a = 1 - a;

			color.a *= a;
		}

		if (_UseAlphaClip)
			clip(color.a - 0.001);
		return color;
	}
		ENDCG
	}
	}
}