protected virtual void OnEnable()
{
if (GetComponent <Mask>() != null)
{
MaskUtilities.NotifyStencilStateChanged(this);
}
}
public void GetModifiedMaterialReturnsDesiredMaterialWithMultipleMasks()
{
for (int i = 2; i < 8; i++)
{
var nodesMap = CreateMaskHierarchy("subMask", i);
Mask mask = nodesMap["subMask" + i].GetComponent <Mask>();
int stencilDepth = MaskUtilities.GetStencilDepth(mask.transform, nodesMap["root"].transform);
int desiredStencilBit = 1 << stencilDepth;
Material material = new Material(Graphic.defaultGraphicMaterial);
Material modifiedMaterial = mask.GetModifiedMaterial(material);
int stencil = modifiedMaterial.GetInt("_Stencil");
Assert.AreNotEqual(material, modifiedMaterial);
Assert.AreEqual(desiredStencilBit | (desiredStencilBit - 1), stencil);
Assert.AreEqual(StencilOp.Replace, (StencilOp)modifiedMaterial.GetInt("_StencilOp"));
Assert.AreEqual(CompareFunction.Equal, (CompareFunction)modifiedMaterial.GetInt("_StencilComp"));
Assert.AreEqual(desiredStencilBit - 1, modifiedMaterial.GetInt("_StencilReadMask"));
Assert.AreEqual(desiredStencilBit | (desiredStencilBit - 1), modifiedMaterial.GetInt("_StencilWriteMask"));
Assert.AreEqual(ColorWriteMask.All, (ColorWriteMask)modifiedMaterial.GetInt("_ColorMask"));
Assert.AreEqual(1, modifiedMaterial.GetInt("_UseUIAlphaClip"));
Assert.IsTrue(modifiedMaterial.IsKeywordEnabled("UNITY_UI_ALPHACLIP"));
}
}
void SetModifiedMaterial(ScaleInfo info)
{
if (info.ps != null && info.ps.emission.enabled)
{
var toUse = info.renderer.sharedMaterial;
if (m_ShouldRecalculateStencil)
{
if (Maskable)
{
var rootCanvas = MaskUtilities.FindRootSortOverrideCanvas(transform);
m_StencilValue = MaskUtilities.GetStencilDepth(transform, rootCanvas);
}
else
{
m_StencilValue = 0;
}
m_ShouldRecalculateStencil = false;
}
// if we have a Mask component then it will
// generate the mask material. This is an optimisation
// it adds some coupling between components though :(
if (m_StencilValue > 0)
{
var maskMat = StencilMaterial.Add(toUse, (1 << m_StencilValue) - 1, StencilOp.Keep, CompareFunction.Equal, ColorWriteMask.All, (1 << m_StencilValue) - 1, 0);
StencilMaterial.Remove(info.stencilMaterial);
info.stencilMaterial = maskMat;
toUse = info.stencilMaterial;
}
info.renderer.material = toUse;
}
}
/// <summary>
/// Perform material modification in this function.
/// </summary>
/// <returns>Modified material.</returns>
/// <param name="baseMaterial">Configured Material.</param>
public Material GetModifiedMaterial(Material baseMaterial)
{
if (!isActiveAndEnabled)
{
return(baseMaterial);
}
Transform stopAfter = MaskUtilities.FindRootSortOverrideCanvas(transform);
var stencilDepth = MaskUtilities.GetStencilDepth(transform, stopAfter);
StencilMaterial.Remove(_unmaskMaterial);
_unmaskMaterial = StencilMaterial.Add(baseMaterial, (1 << stencilDepth) - 1, StencilOp.Zero, CompareFunction.Always, m_ShowUnmaskGraphic ? ColorWriteMask.All : (ColorWriteMask)0, 0, (1 << stencilDepth) - 1);
// Unmask affects only for children.
var canvasRenderer = graphic.canvasRenderer;
if (m_OnlyForChildren)
{
StencilMaterial.Remove(_revertUnmaskMaterial);
_revertUnmaskMaterial = StencilMaterial.Add(baseMaterial, (1 << stencilDepth) - 1, StencilOp.Replace, CompareFunction.NotEqual, (ColorWriteMask)0);
canvasRenderer.hasPopInstruction = true;
canvasRenderer.popMaterialCount = 1;
canvasRenderer.SetPopMaterial(_revertUnmaskMaterial, 0);
}
else
{
canvasRenderer.hasPopInstruction = false;
canvasRenderer.popMaterialCount = 0;
}
return(_unmaskMaterial);
}
//#endif
//-------------------------------------------------------------------------------------------
// override protected void Awake()
// {
// base.Awake() ;
// }
/// <summary>
/// マテリアルの設定が必要な際に呼び出される
/// </summary>
/// <param name="tBaseMaterial"></param>
/// <returns></returns>
public virtual Material GetModifiedMaterial(Material tBaseMaterial)
{
// if( name == "1" )
// {
// Debug.LogWarning( "-------> GetModifiedMaterial:" + name ) ;
// }
Material tActiveMaterial = ChoiceMaterial(tBaseMaterial);
int tStencilValue = 0;
if (m_ShouldRecalculateStencil == true)
{
Transform tRootCanvas = MaskUtilities.FindRootSortOverrideCanvas(transform);
tStencilValue = MaskUtilities.GetStencilDepth(transform, tRootCanvas);
m_ShouldRecalculateStencil = false;
}
if (tStencilValue > 0)
{
Material tMargedMaskMaterial = StencilMaterial.Add(tActiveMaterial, (1 << tStencilValue) - 1, StencilOp.Keep, CompareFunction.Equal, ColorWriteMask.All, (1 << tStencilValue) - 1, 0);
if (m_UsingMaskMaterial != null)
{
StencilMaterial.Remove(m_UsingMaskMaterial);
}
m_UsingMaskMaterial = tMargedMaskMaterial;
tActiveMaterial = m_UsingMaskMaterial;
}
return(tActiveMaterial);
}
public override 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;
}
// if we have a enabled Mask component then it will
// generate the mask material. This is an optimisation
// it adds some coupling between components though :(
Mask maskComponent = GetComponent <Mask>();
if (m_StencilValue > 0 && (maskComponent == null || !maskComponent.IsActive()))
{
var maskMat = StencilMaterial.Add(toUse, (1 << m_StencilValue) - 1, StencilOp.Keep, CompareFunction.NotEqual, ColorWriteMask.All, (1 << m_StencilValue) - 1, 0);
StencilMaterial.Remove(m_MaskMaterial);
m_MaskMaterial = maskMat;
toUse = m_MaskMaterial;
}
return(toUse);
}
protected override void OnEnable()
{
base.OnEnable();
if (graphic != null)
{
graphic.canvasRenderer.hasPopInstruction = true;
graphic.SetMaterialDirty();
}
MaskUtilities.NotifyStencilStateChanged(this);
}
protected override void OnValidate()
{
base.OnValidate();
m_ShouldRecalculateClipRects = true;
if (!IsActive())
{
return;
}
MaskUtilities.Notify2DMaskStateChanged(this);
}
/// Stencil calculation time!
public virtual Material GetModifiedMaterial(Material baseMaterial)
{
if (!MaskEnabled())
{
return(baseMaterial);
}
var rootSortCanvas = MaskUtilities.FindRootSortOverrideCanvas(transform);
var stencilDepth = MaskUtilities.GetStencilDepth(transform, rootSortCanvas);
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);
}
/// <summary>
/// Perform material modification in this function.
/// </summary>
/// <returns>Modified material.</returns>
/// <param name="baseMaterial">Configured Material.</param>
public Material GetModifiedMaterial(Material baseMaterial)
{
if (!isActiveAndEnabled)
{
return(baseMaterial);
}
Transform stopAfter = MaskUtilities.FindRootSortOverrideCanvas(transform);
var stencilDepth = MaskUtilities.GetStencilDepth(transform, stopAfter);
StencilMaterial.Remove(_unmaskMaterial);
_unmaskMaterial = StencilMaterial.Add(baseMaterial, (1 << stencilDepth) - 1, StencilOp.Zero, CompareFunction.Always, m_ShowUnmaskGraphic ? ColorWriteMask.All : (ColorWriteMask)0, 0, (1 << stencilDepth) - 1);
return(_unmaskMaterial);
}
private void UpdateClipParent()
{
var newParent = MaskUtilities.GetRectMaskForClippable(this);
if (m_ParentMask != null && (newParent != m_ParentMask || !newParent.IsActive()))
{
m_ParentMask.RemoveClippable(this);
}
if (newParent != null && newParent.IsActive())
{
newParent.AddClippable(this);
}
m_ParentMask = newParent;
}
protected override void OnValidate()
{
base.OnValidate();
if (!IsActive())
{
return;
}
if (graphic != null)
{
graphic.SetMaterialDirty();
}
MaskUtilities.NotifyStencilStateChanged(this);
}
private void UpdateClipParent()
{
var newParent = (IsActive()) ? MaskUtilities.GetRectMaskForClippable(this) : null;
if (newParent != m_ParentMask && m_ParentMask != null)
{
m_ParentMask.RemoveClippable(this);
}
if (newParent != null)
{
newParent.AddClippable(this);
}
m_ParentMask = newParent;
}
public static int constructor(IntPtr l)
{
int result;
try
{
MaskUtilities o = new MaskUtilities();
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, o);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
//^^^^^^^^ Unity Callbacks ^^^^^^^^
//vvvvvvvv IClipable Implements vvvvvvvv
/// <summary>
/// Called when the state of a parent IClippable changes.
/// </summary>
public void RecalculateClipping()
{
m_Masks.Clear();
RectMask2D rectMask2D = isActiveAndEnabled && rectTransform?MaskUtilities.GetRectMaskForClippable(this) : null;
if (m_ParentMask != null && (rectMask2D != m_ParentMask || !rectMask2D.IsActive()))
{
m_ParentMask.RemoveClippable(this);
}
if (rectMask2D != null && rectMask2D.IsActive())
{
rectMask2D.AddClippable(this);
MaskUtilities.GetRectMasksForClip(rectMask2D, m_Masks);
}
m_ParentMask = rectMask2D;
}
public static int NotifyStencilStateChanged_s(IntPtr l)
{
int result;
try
{
Component mask;
LuaObject.checkType <Component>(l, 1, out mask);
MaskUtilities.NotifyStencilStateChanged(mask);
LuaObject.pushValue(l, true);
result = 1;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
public static int GetRectMaskForClippable_s(IntPtr l)
{
int result;
try
{
IClippable clippable;
LuaObject.checkType <IClippable>(l, 1, out clippable);
RectMask2D rectMaskForClippable = MaskUtilities.GetRectMaskForClippable(clippable);
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, rectMaskForClippable);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
public static int FindRootSortOverrideCanvas_s(IntPtr l)
{
int result;
try
{
Transform start;
LuaObject.checkType <Transform>(l, 1, out start);
Transform o = MaskUtilities.FindRootSortOverrideCanvas(start);
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, o);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
void OnValidate()
{
if (GetComponent <MaskableGraphic>() != null)
{
mat = GetComponent <MaskableGraphic>().materialForRendering;
matName = mat.name;
stencil = mat.GetFloat("_Stencil");
comp = (CompareFunction)mat.GetFloat("_StencilComp");
compF = (float)comp;
pass = (StencilOp)mat.GetFloat("_StencilOp");
passF = (float)pass;
w = mat.GetFloat("_StencilWriteMask");
r = mat.GetFloat("_StencilReadMask");
GetComponent <MaskableGraphic>().SetAllDirty();
GetComponent <MaskableGraphic>().SetMaterialDirty();
}
stencil_Calc = MaskUtilities.GetStencilDepth(this.transform, MaskUtilities.FindRootSortOverrideCanvas(this.transform));
}
/// <summary>
/// Update all soft mask textures.
/// </summary>
static void UpdateMaskTextures()
{
foreach (var sm in s_ActiveSoftMasks)
{
if (!sm || sm._hasChanged)
{
continue;
}
var rt = sm.rectTransform;
if (rt.hasChanged)
{
rt.hasChanged = false;
sm.hasChanged = true;
}
#if UNITY_EDITOR
if (!Application.isPlaying)
{
sm.hasChanged = true;
}
#endif
}
foreach (var sm in s_ActiveSoftMasks)
{
if (!sm || !sm._hasChanged)
{
continue;
}
sm._hasChanged = false;
if (!sm._parent)
{
sm.UpdateMaskTexture();
if (sm._hasStencilStateChanged)
{
sm._hasStencilStateChanged = false;
MaskUtilities.NotifyStencilStateChanged(sm);
}
}
}
}
public static int GetRectMasksForClip_s(IntPtr l)
{
int result;
try
{
RectMask2D clipper;
LuaObject.checkType <RectMask2D>(l, 1, out clipper);
List <RectMask2D> masks;
LuaObject.checkType <List <RectMask2D> >(l, 2, out masks);
MaskUtilities.GetRectMasksForClip(clipper, masks);
LuaObject.pushValue(l, true);
result = 1;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
protected virtual void UpdateClipabbles()
{
var v_clippables = GetComponentsInChildren <IClippable>(true);
foreach (var v_clipabble in v_clippables)
{
if (ClipInsideOverriddenSortingCanvas)
{
AddClippable(v_clipabble);
}
else
{
RemoveClippable(v_clipabble);
}
}
if (!ClipInsideOverriddenSortingCanvas)
{
MaskUtilities.Notify2DMaskStateChanged(this);
}
}
protected override void OnDisable()
{
// we call base OnDisable first here
// as we need to have the IsActive return the
// correct value when we notify the children
// that the mask state has changed.
base.OnDisable();
if (graphic != null)
{
graphic.SetMaterialDirty();
graphic.canvasRenderer.hasPopInstruction = false;
graphic.canvasRenderer.popMaterialCount = 0;
}
StencilMaterial.Remove(m_MaskMaterial);
m_MaskMaterial = null;
StencilMaterial.Remove(m_UnmaskMaterial);
m_UnmaskMaterial = null;
MaskUtilities.NotifyStencilStateChanged(this);
}
public static int IsDescendantOrSelf_s(IntPtr l)
{
int result;
try
{
Transform father;
LuaObject.checkType <Transform>(l, 1, out father);
Transform child;
LuaObject.checkType <Transform>(l, 2, out child);
bool b = MaskUtilities.IsDescendantOrSelf(father, child);
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, b);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
public static int GetStencilDepth_s(IntPtr l)
{
int result;
try
{
Transform transform;
LuaObject.checkType <Transform>(l, 1, out transform);
Transform stopAfter;
LuaObject.checkType <Transform>(l, 2, out stopAfter);
int stencilDepth = MaskUtilities.GetStencilDepth(transform, stopAfter);
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, stencilDepth);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
public override Material GetModifiedMaterial(Material baseMaterial)
{
Material baseMat = baseMaterial;
if (this.m_ShouldRecalculateStencil)
{
Transform sortOverrideCanvas = MaskUtilities.FindRootSortOverrideCanvas(this.transform);
this.m_StencilValue = !this.maskable ? 0 : MaskUtilities.GetStencilDepth(this.transform, sortOverrideCanvas);
this.m_ShouldRecalculateStencil = false;
}
Mask component = this.GetComponent <Mask>();
if (this.m_StencilValue > 0 && ((UnityEngine.Object)component == (UnityEngine.Object)null || !component.IsActive()))
{
Material material = StencilMaterial.Add(baseMat, (1 << this.m_StencilValue) - 1, StencilOp.Keep, CompareFunction.NotEqual, ColorWriteMask.All, (1 << this.m_StencilValue) - 1, 0);
StencilMaterial.Remove(this.m_MaskMaterial);
this.m_MaskMaterial = material;
baseMat = this.m_MaskMaterial;
}
return(baseMat);
}
/// <summary>
/// Function returning the modified material for masking if necessary.
/// </summary>
/// <param name="baseMaterial"></param>
/// <returns></returns>
public override Material GetModifiedMaterial(Material baseMaterial)
{
Material mat = baseMaterial;
if (m_ShouldRecalculateStencil)
{
var rootCanvas = MaskUtilities.FindRootSortOverrideCanvas(transform);
m_StencilValue = maskable ? MaskUtilities.GetStencilDepth(transform, rootCanvas) : 0;
m_ShouldRecalculateStencil = false;
}
if (m_StencilValue > 0)
{
var maskMat = StencilMaterial.Add(mat, (1 << m_StencilValue) - 1, StencilOp.Keep, CompareFunction.Equal, ColorWriteMask.All, (1 << m_StencilValue) - 1, 0);
StencilMaterial.Remove(m_MaskMaterial);
m_MaskMaterial = maskMat;
mat = m_MaskMaterial;
}
return(mat);
}
public override 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 maskComponent = GetComponent <Mask>();
if (m_StencilValue > 0 && (maskComponent == null || !maskComponent.IsActive()))
{
var maskMat = StencilMaterial.Add(toUse, (1 << m_StencilValue) - 1, StencilOp.Keep, CompareFunction.NotEqual, ColorWriteMask.All, (1 << m_StencilValue) - 1, 0);
StencilMaterial.Remove(m_MaskMaterial);
m_MaskMaterial = maskMat;
toUse = m_MaskMaterial;
}
return(toUse);
}
protected override void UpdateMaterial()
{
// Clear mask materials.
s_PrevMaskMaterials.AddRange(_maskMaterials);
_maskMaterials.Clear();
// Clear modified materials.
s_PrevModifiedMaterials.AddRange(_modifiedMaterials);
_modifiedMaterials.Clear();
// Recalculate stencil value.
if (m_ShouldRecalculateStencil)
{
var rootCanvas = MaskUtilities.FindRootSortOverrideCanvas(transform);
m_StencilValue = maskable ? MaskUtilities.GetStencilDepth(transform, rootCanvas) : 0;
m_ShouldRecalculateStencil = false;
}
// No mesh to render.
var count = activeMeshIndices.CountFast();
if (count == 0 || !isActiveAndEnabled || particles.Count == 0)
{
canvasRenderer.Clear();
foreach (var m in s_PrevMaskMaterials)
{
StencilMaterial.Remove(m);
}
foreach (var m in s_PrevModifiedMaterials)
{
ModifiedMaterial.Remove(m);
}
return;
}
//
var materialCount = Mathf.Max(8, count);
canvasRenderer.materialCount = materialCount;
var j = 0;
for (var i = 0; i < particles.Count; i++)
{
if (materialCount <= j)
{
break;
}
var ps = particles[i];
if (!ps)
{
continue;
}
var r = ps.GetComponent <ParticleSystemRenderer>();
r.GetSharedMaterials(s_TempMaterials);
// Main
var index = i * 2;
if (activeMeshIndices.Count <= index)
{
break;
}
if (activeMeshIndices[index] && 0 < s_TempMaterials.Count)
{
var mat = GetModifiedMaterial(s_TempMaterials[0], ps.GetTextureForSprite());
canvasRenderer.SetMaterial(mat, j);
UpdateMaterialProperties(r, j);
j++;
}
// Trails
index++;
if (activeMeshIndices.Count <= index || materialCount <= j)
{
break;
}
if (activeMeshIndices[index] && 1 < s_TempMaterials.Count)
{
var mat = GetModifiedMaterial(s_TempMaterials[1], null);
canvasRenderer.SetMaterial(mat, j++);
}
}
foreach (var m in s_PrevMaskMaterials)
{
StencilMaterial.Remove(m);
}
foreach (var m in s_PrevModifiedMaterials)
{
ModifiedMaterial.Remove(m);
}
}
/// <summary>
/// Update the mask texture.
/// </summary>
void UpdateMaskTexture()
{
if (!graphic || !graphic.canvas)
{
return;
}
_stencilDepth = MaskUtilities.GetStencilDepth(transform, MaskUtilities.FindRootSortOverrideCanvas(transform));
// Collect children soft masks.
int depth = 0;
s_TmpSoftMasks[0].Add(this);
while (_stencilDepth + depth < 3)
{
int count = s_TmpSoftMasks[depth].Count;
for (int i = 0; i < count; i++)
{
List <SoftMask> children = s_TmpSoftMasks[depth][i]._children;
int childCount = children.Count;
for (int j = 0; j < childCount; j++)
{
var child = children[j];
var childDepth = child.m_PartOfParent ? depth : depth + 1;
s_TmpSoftMasks[childDepth].Add(child);
}
}
depth++;
}
// Clear.
_cb.Clear();
_cb.SetRenderTarget(softMaskBuffer);
_cb.ClearRenderTarget(false, true, s_ClearColors[_stencilDepth]);
// Set view and projection matrices.
var c = graphic.canvas.rootCanvas;
var cam = c.worldCamera ?? Camera.main;
if (c && c.renderMode != RenderMode.ScreenSpaceOverlay && cam)
{
_cb.SetViewProjectionMatrices(cam.worldToCameraMatrix, cam.projectionMatrix);
}
else
{
var pos = c.transform.localPosition;
var vm = Matrix4x4.TRS(new Vector3(-pos.x, -pos.y, -1000), Quaternion.identity, new Vector3(1, 1, -1f));
var pm = Matrix4x4.TRS(new Vector3(0, 0, -1), Quaternion.identity, new Vector3(1 / pos.x, 1 / pos.y, -2 / 10000f));
_cb.SetViewProjectionMatrices(vm, pm);
}
// Draw soft masks.
for (int i = 0; i < s_TmpSoftMasks.Length; i++)
{
int count = s_TmpSoftMasks[i].Count;
for (int j = 0; j < count; j++)
{
var sm = s_TmpSoftMasks[i][j];
if (i != 0)
{
sm._stencilDepth = MaskUtilities.GetStencilDepth(sm.transform, MaskUtilities.FindRootSortOverrideCanvas(sm.transform));
}
// Set material property.
sm.material.SetInt(s_ColorMaskId, (int)1 << (3 - _stencilDepth - i));
sm._mpb.SetTexture(s_MainTexId, sm.graphic.mainTexture);
sm._mpb.SetFloat(s_SoftnessId, sm.m_Softness);
// Draw mesh.
_cb.DrawMesh(sm.mesh, sm.transform.localToWorldMatrix, sm.material, 0, 0, sm._mpb);
}
s_TmpSoftMasks[i].Clear();
}
Graphics.ExecuteCommandBuffer(_cb);
}
