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()))
            {
                //設置模板緩沖值，并且設置在該區(qū)域內的顯示，不在的裁切掉
                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)
                    //把裁切區(qū)域傳到每個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();
            }
        }