Unity3D Shader实现动态屏幕遮罩

Shader "Peter/DarkEffect"
{
  Properties
  {
    _MainTex ("Texture", 2D) = "white" {}
  }

  SubShader
  {
    // No culling or depth
    Cull Off ZWrite Off ZTest Always

    Pass
    {
      CGPROGRAM
      #pragma vertex vert
      #pragma fragment frag

      #include "UnityCG.cginc"

      //追踪物体最多个数
      #define ItemSize 9

      struct appdata
      {
        float4 vertex : POSITION;
        float2 uv : TEXCOORD0;
      };

      struct v2f
      {
        float2 uv : TEXCOORD0;
        float4 vertex : SV_POSITION;
      };

      sampler2D _MainTex;

      fixed4 _DarkColor;
      float _SmoothLength;
      fixed _ItemCnt;
      float4 _Item[ItemSize];

      v2f vert (appdata v)
      {
        v2f o;
        o.vertex = UnityObjectToClipPos(v.vertex);
        o.uv = v.uv;
        return o;
      }

      fixed CalcAlpha(float4 vt, float4 pt)
      {
        if(pt.z < 0)
        {
          return 1;
        }

        float distPow2 = pow(vt.x - pt.x, 2) + pow(vt.y - pt.y, 2);
        float dist = (distPow2 > 0) ? sqrt(distPow2) : 0;

        float smoothLength = _SmoothLength;
        if(smoothLength < 0)
        {
          smoothLength = 0;
        }

        float maxValue = pt.z;
        float minValue = pt.z - smoothLength;
        if(minValue < 0)
        {
          minValue = 0;
          smoothLength = pt.z;
        }

        if(dist <= minValue)
        {
          return 0;
        }
        else if (dist > maxValue)
        {
          return 1;
        }

        fixed retVal = (dist - minValue) / smoothLength;

        return retVal;
      }

      fixed4 frag (v2f i) : SV_Target
      {
        fixed alphaVal = 1;
        fixed tmpVal = 1;

        for(fixed index = 0; index < _ItemCnt; ++index)
        {
          tmpVal = CalcAlpha(i.vertex, _Item[index]);
          if(tmpVal < alphaVal)
          {
            alphaVal = tmpVal;
          }
        }

        alphaVal *= _DarkColor.a;

        return tex2D(_MainTex, i.uv) * ( 1 - alphaVal) + _DarkColor * alphaVal;
      }

      ENDCG
    }
  }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

[ExecuteInEditMode]
[RequireComponent(typeof(Camera))]
public class DarkEffect : MonoBehaviour
{
  [System.Serializable]
  public class Item
  {
    [SerializeField]
    public Transform target;

    [SerializeField]
    public int radius;

    public Vector3 GetScreenPosition(Camera cam)
    {
      return cam.WorldToScreenPoint(target.position);
    }
  }

  //渐变像素数量
  public int _smoothLength = 20;
  //遮罩混合颜色
  public Color _darkColor = Color.black;
  //目标物体
  public List<Item> _items = new List<Item>();

  protected Material _mainMaterial;
  protected Camera _mainCamera;

  Vector4[] _itemDatas;
  Item _tmpItem;
  Vector4 _tmpVt;
  Vector3 _tmpPos;
  int _tmpScreenHeight;

  private void OnEnable()
  {
    _mainMaterial = new Material(Shader.Find("Peter/DarkEffect"));
    _mainCamera = GetComponent<Camera>();
  }

  private void OnRenderImage(RenderTexture source, RenderTexture destination)
  {

    if (_itemDatas == null || _itemDatas.Length != _items.Count)
    {
      _itemDatas = new Vector4[_items.Count];
    }

    _tmpScreenHeight = Screen.height;

    for (int i = 0; i < _items.Count; i++)
    {
      _tmpItem = _items[i];
      _tmpPos = _tmpItem.GetScreenPosition(_mainCamera);

      _tmpVt.x = _tmpPos.x;
      _tmpVt.y = _tmpScreenHeight - _tmpPos.y;
      _tmpVt.z = _tmpItem.radius;
      _tmpVt.w = 0;

      _itemDatas[i] = _tmpVt;
    }

    _mainMaterial.SetInt("_SmoothLength", _smoothLength);
    _mainMaterial.SetColor("_DarkColor", _darkColor);
    _mainMaterial.SetInt("_ItemCnt", _itemDatas.Length);
    _mainMaterial.SetVectorArray("_Item", _itemDatas);

    Graphics.Blit(source, destination, _mainMaterial);
  }
}