详解Unity中Mask和RectMask2D组件的对比与测试

Stencil
{
	Ref [_Stencil]//Ref表示要比较的值；0-255
	Comp [_StencilComp]//Comp表示比较方法（等于/不等于/大于/小于等）；
	Pass [_StencilOp]// Pass/Fail表示当比较通过/不通过时对stencil buffer做什么操作
			// Keep(保留)
			// Replace(替换)
			// Zero(置0)
			// IncrementSaturate(增加)
			// DecrementSaturate(减少)
	ReadMask [_StencilReadMask]//ReadMask/WriteMask表示取stencil buffer的值时用的mask（即可以忽略某些位）；
	WriteMask [_StencilWriteMask]
}

MaskableGraphic.cs
        public virtual Material GetModifiedMaterial(Material baseMaterial)
        {
            var toUse = baseMaterial;
            if (m_ShouldRecalculateStencil)
            {
                var rootCanvas = MaskUtilities.FindRootSortOverrideCanvas(transform);  //获取模板缓冲值
                m_StencilValue = maskable ? MaskUtilities.GetStencilDepth(transform, rootCanvas) : 0;
                m_ShouldRecalculateStencil = false;
            }
            // 如果我们用了Mask，它会生成一个mask材质，
            Mask maskComponent = GetComponent<Mask>();
            if (m_StencilValue > 0 && (maskComponent == null || !maskComponent.IsActive()))
            {
                //设置模板缓冲值，并且设置在该区域内的显示，不在的裁切掉
                var maskMat = StencilMaterial.Add(toUse,  // Material baseMat
                    (1 << m_StencilValue) - 1,            // 参考值
                    StencilOp.Keep,                       // 不修改模板缓存
                    CompareFunction.Equal,                // 相等通过测试
                    ColorWriteMask.All,                   // ColorMask
                    (1 << m_StencilValue) - 1,            // Readmask
                    0);                                   //  WriteMas
                StencilMaterial.Remove(m_MaskMaterial);
                //并且更换新的材质
                m_MaskMaterial = maskMat;
                toUse = m_MaskMaterial;
            }
            return toUse;
        }

Image.cs 
   protected virtual void UpdateMaterial()
   {
       if (!IsActive())
           return;
       //更新刚刚替换的新的模板缓冲的材质
       canvasRenderer.materialCount = 1;
       canvasRenderer.SetMaterial(materialForRendering, 0);
       canvasRenderer.SetTexture(mainTexture);
   }
   public virtual Material materialForRendering
   {
       get
       {
           //遍历UI中的每个Mask组件
           var components = ListPool<Component>.Get();
           GetComponents(typeof(IMaterialModifier), components);
           //并且更新每个Mask组件的模板缓冲材质
           var currentMat = material;
           for (var i = 0; i < components.Count; i++)
               currentMat = (components[i] as IMaterialModifier).GetModifiedMaterial(currentMat);
           ListPool<Component>.Release(components);
           //返回新的材质，用于裁切
           return currentMat;
       }
   }

Mask.cs        
       /// Stencil calculation time!
       public virtual Material GetModifiedMaterial(Material baseMaterial)
       {
           if (!MaskEnabled())
               return baseMaterial;
           var rootSortCanvas = MaskUtilities.FindRootSortOverrideCanvas(transform);
           var stencilDepth = MaskUtilities.GetStencilDepth(transform, rootSortCanvas);
           // stencil只支持最大深度为8的遮罩
           if (stencilDepth >= 8)
           {
               Debug.LogError("Attempting to use a stencil mask with depth > 8", gameObject);
               return baseMaterial;
           }
           int desiredStencilBit = 1 << stencilDepth;
           // if we are at the first level...
           // we want to destroy what is there
           if (desiredStencilBit == 1)
           {
               var maskMaterial = StencilMaterial.Add(baseMaterial, 1, StencilOp.Replace, CompareFunction.Always, m_ShowMaskGraphic ? ColorWriteMask.All : 0);
               StencilMaterial.Remove(m_MaskMaterial);
               m_MaskMaterial = maskMaterial;

               var unmaskMaterial = StencilMaterial.Add(baseMaterial, 1, StencilOp.Zero, CompareFunction.Always, 0);
               StencilMaterial.Remove(m_UnmaskMaterial);
               m_UnmaskMaterial = unmaskMaterial;
               graphic.canvasRenderer.popMaterialCount = 1;
               graphic.canvasRenderer.SetPopMaterial(m_UnmaskMaterial, 0);

               return m_MaskMaterial;
           }
           //otherwise we need to be a bit smarter and set some read / write masks
           var maskMaterial2 = StencilMaterial.Add(baseMaterial, desiredStencilBit | (desiredStencilBit - 1), StencilOp.Replace, CompareFunction.Equal, m_ShowMaskGraphic ? ColorWriteMask.All : 0, desiredStencilBit - 1, desiredStencilBit | (desiredStencilBit - 1));
           StencilMaterial.Remove(m_MaskMaterial);
           m_MaskMaterial = maskMaterial2;

           graphic.canvasRenderer.hasPopInstruction = true;
           var unmaskMaterial2 = StencilMaterial.Add(baseMaterial, desiredStencilBit - 1, StencilOp.Replace, CompareFunction.Equal, 0, desiredStencilBit - 1, desiredStencilBit | (desiredStencilBit - 1));
           StencilMaterial.Remove(m_UnmaskMaterial);
           m_UnmaskMaterial = unmaskMaterial2;
           graphic.canvasRenderer.popMaterialCount = 1;
           graphic.canvasRenderer.SetPopMaterial(m_UnmaskMaterial, 0);

           return m_MaskMaterial;
       }

CanvasUpdateRegistry.cs
        protected CanvasUpdateRegistry()
        {
            Canvas.willRenderCanvases += PerformUpdate;
        }
        private void PerformUpdate()
        {
            //...略
            // 开始裁切Mask2D
            ClipperRegistry.instance.Cull();
            //...略
        }
ClipperRegistry.cs
        public void Cull()
        {
            for (var i = 0; i < m_Clippers.Count; ++i)
            {
                m_Clippers[i].PerformClipping();
            }
        }

RectMask2D.cs
    protected override void OnEnable()
    {
        //注册当前RectMask2D裁切对象，保证下次Rebuild时可进行裁切。
        base.OnEnable();
        m_ShouldRecalculateClipRects = true;
        ClipperRegistry.Register(this);
        MaskUtilities.Notify2DMaskStateChanged(this);
    }
        public virtual void PerformClipping()
        {
            //...略
            bool validRect = true;
            Rect clipRect = Clipping.FindCullAndClipWorldRect(m_Clippers, out validRect);
            bool clipRectChanged = clipRect != m_LastClipRectCanvasSpace;
            if (clipRectChanged || m_ForceClip)
            {
                foreach (IClippable clipTarget in m_ClipTargets)
                    //把裁切区域传到每个UI元素的Shader中[划重点！！！]
                    clipTarget.SetClipRect(clipRect, validRect);
                m_LastClipRectCanvasSpace = clipRect;
                m_LastValidClipRect = validRect;
            }
            foreach (IClippable clipTarget in m_ClipTargets)
            {
                var maskable = clipTarget as MaskableGraphic;
                if (maskable != null && !maskable.canvasRenderer.hasMoved && !clipRectChanged)
                    continue;
                // 调用所有继承IClippable的Cull方法
                clipTarget.Cull(m_LastClipRectCanvasSpace, m_LastValidClipRect);
            }
        }
MaskableGraphic.cs
        public virtual void Cull(Rect clipRect, bool validRect)
        {
            var cull = !validRect || !clipRect.Overlaps(rootCanvasRect, true);
            UpdateCull(cull);
        }
        private void UpdateCull(bool cull)
        {
            var cullingChanged = canvasRenderer.cull != cull;
            canvasRenderer.cull = cull;
            if (cullingChanged)
            {
                UISystemProfilerApi.AddMarker("MaskableGraphic.cullingChanged", this);
                m_OnCullStateChanged.Invoke(cull);
                SetVerticesDirty();
            }
        }