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