//#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); } }