//#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);
}
/// <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);
}
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"));
}
}
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);
}
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;
}
}
/// 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);
}
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));
}
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.
for (var i = 0; i < _maskMaterials.Count; i++)
{
StencilMaterial.Remove(_maskMaterials[i]);
_maskMaterials[i] = null;
}
_maskMaterials.Clear();
// Clear modified materials.
for (var i = 0; i < _modifiedMaterials.Count; i++)
{
DestroyImmediate(_modifiedMaterials[i]);
_modifiedMaterials[i] = null;
}
_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.
if (activeMeshIndices == 0 || !isActiveAndEnabled || particles.Count == 0)
{
_activeMeshIndices = 0;
canvasRenderer.Clear();
return;
}
//
var materialCount = Mathf.Max(8, activeMeshIndices.BitCount());
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 bit = (long)1 << (i * 2);
if (0 < (activeMeshIndices & bit) && 0 < s_TempMaterials.Count)
{
var mat = GetModifiedMaterial(s_TempMaterials[0], ps.GetTextureForSprite());
canvasRenderer.SetMaterial(mat, j);
UpdateMaterialProperties(r, j);
j++;
}
// Trails
if (materialCount <= j)
{
break;
}
bit <<= 1;
if (0 < (activeMeshIndices & bit) && 1 < s_TempMaterials.Count)
{
var mat = GetModifiedMaterial(s_TempMaterials[1], null);
canvasRenderer.SetMaterial(mat, j++);
}
}
}
/// <summary>
/// Update the mask texture.
/// </summary>
void UpdateMaskTexture()
{
if (_parent)
{
return;
}
Transform stopAfter = MaskUtilities.FindRootSortOverrideCanvas(transform);
_stencilDepth = MaskUtilities.GetStencilDepth(transform, stopAfter);
// 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++)
{
s_TmpSoftMasks[depth + 1].AddRange(s_TmpSoftMasks[depth][i]._children);
}
depth++;
}
// Clear.
_cb.Clear();
_cb.SetRenderTarget(softMaskBuffer);
_cb.ClearRenderTarget(false, true, s_ClearColors[_stencilDepth]);
// Set view and projection matrices.
var c = graphic.canvas;
if (c && c.renderMode != RenderMode.ScreenSpaceOverlay && c.worldCamera)
{
_cb.SetViewProjectionMatrices(c.worldCamera.worldToCameraMatrix, c.worldCamera.projectionMatrix);
}
else
{
_cb.SetViewMatrix(Matrix4x4.TRS(new Vector3(-1, -1, 0), Quaternion.identity, new Vector3(2f / Screen.width, 2f / Screen.height, 1f)));
}
// 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];
// 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);
}
/// <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);
}
/// <summary>
/// Update the mask texture.
/// </summary>
private void UpdateMaskTexture()
{
if (!graphic || !graphic.canvas)
{
return;
}
Profiler.BeginSample("UpdateMaskTexture");
_stencilDepth = MaskUtilities.GetStencilDepth(transform, MaskUtilities.FindRootSortOverrideCanvas(transform));
// Collect children soft masks.
Profiler.BeginSample("Collect children soft masks");
var depth = 0;
s_TmpSoftMasks[0].Add(this);
while (_stencilDepth + depth < 3)
{
var count = s_TmpSoftMasks[depth].Count;
for (var i = 0; i < count; i++)
{
var children = s_TmpSoftMasks[depth][i]._children;
var childCount = children.Count;
for (var j = 0; j < childCount; j++)
{
var child = children[j];
var childDepth = child.m_PartOfParent ? depth : depth + 1;
s_TmpSoftMasks[childDepth].Add(child);
}
}
depth++;
}
Profiler.EndSample();
// CommandBuffer.
Profiler.BeginSample("Initialize CommandBuffer");
_cb.Clear();
_cb.SetRenderTarget(softMaskBuffer);
_cb.ClearRenderTarget(false, true, s_ClearColors[_stencilDepth]);
Profiler.EndSample();
// Set view and projection matrices.
Profiler.BeginSample("Set view and projection matrices");
var c = graphic.canvas.rootCanvas;
var cam = c.worldCamera ?? Camera.main;
if (c && c.renderMode != RenderMode.ScreenSpaceOverlay && cam)
{
var p = GL.GetGPUProjectionMatrix(cam.projectionMatrix, false);
_cb.SetViewProjectionMatrices(cam.worldToCameraMatrix, p);
#if UNITY_EDITOR
var pv = p * cam.worldToCameraMatrix;
_cb.SetGlobalMatrix(s_GameVPId, pv);
_cb.SetGlobalMatrix(s_GameTVPId, pv);
#endif
}
else
{
var pos = c.transform.position;
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);
#if UNITY_EDITOR
var scale = c.transform.localScale.x;
var size = (c.transform as RectTransform).sizeDelta;
var gameVp = Matrix4x4.TRS(new Vector3(0, 0, 0.5f), Quaternion.identity, new Vector3(2 / size.x, 2 / size.y, 0.0005f * scale));
var gameTvp = Matrix4x4.TRS(new Vector3(0, 0, 0), Quaternion.identity, new Vector3(1 / pos.x, 1 / pos.y, -2 / 2000f)) * Matrix4x4.Translate(-pos);
_cb.SetGlobalMatrix(s_GameVPId, gameVp);
_cb.SetGlobalMatrix(s_GameTVPId, gameTvp);
#endif
}
Profiler.EndSample();
// Draw soft masks.
Profiler.BeginSample("Draw Mesh");
for (var i = 0; i < s_TmpSoftMasks.Length; i++)
{
var count = s_TmpSoftMasks[i].Count;
for (var 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);
sm._mpb.SetFloat(s_Alpha, sm.m_Alpha);
// Draw mesh.
_cb.DrawMesh(sm.mesh, sm.transform.localToWorldMatrix, sm.material, 0, 0, sm._mpb);
}
s_TmpSoftMasks[i].Clear();
}
Profiler.EndSample();
Graphics.ExecuteCommandBuffer(_cb);
Profiler.EndSample();
}
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);
}
}
