From ed7bb646b6c7f1facd54755b37cee60784a65ff3 Mon Sep 17 00:00:00 2001 From: mob-sakai Date: Fri, 21 Dec 2018 20:48:25 +0900 Subject: [PATCH] fix #21; UIParticle.Scale does not affect the gizmo of shape module --- Editor/UIParticleEditor.cs | 422 ++++++++++++++++++++++++++++++++++++- UIParticle.cs | 11 +- 2 files changed, 425 insertions(+), 8 deletions(-) diff --git a/Editor/UIParticleEditor.cs b/Editor/UIParticleEditor.cs index 12b63df..29109ea 100644 --- a/Editor/UIParticleEditor.cs +++ b/Editor/UIParticleEditor.cs @@ -3,6 +3,9 @@ using UnityEditor.UI; using UnityEngine; using System.Collections.Generic; using System.Linq; +using UnityEditor.IMGUI.Controls; +using System; +using System.Reflection; namespace Coffee.UIExtensions { @@ -13,9 +16,15 @@ namespace Coffee.UIExtensions //################################ // Constant or Static Members. //################################ - static readonly GUIContent contentParticleMaterial = new GUIContent ("Particle Material", "The material for rendering particles"); - static readonly GUIContent contentTrailMaterial = new GUIContent ("Trail Material", "The material for rendering particle trails"); + static readonly GUIContent s_ContentParticleMaterial = new GUIContent ("Particle Material", "The material for rendering particles"); + static readonly GUIContent s_ContentTrailMaterial = new GUIContent ("Trail Material", "The material for rendering particle trails"); static readonly List s_ParticleSystems = new List (); + static readonly Matrix4x4 s_ArcHandleOffsetMatrix = Matrix4x4.TRS (Vector3.zero, Quaternion.AngleAxis (90f, Vector3.right) * Quaternion.AngleAxis (90f, Vector3.up), Vector3.one); + static readonly Dictionary s_InternalMethods = new Dictionary (); + static readonly Color s_GizmoColor = new Color (1f, 0.7f, 0.7f, 0.9f); + static readonly Color s_ShapeGizmoThicknessTint = new Color (0.7f, 0.7f, 0.7f, 1.0f); + static Material s_Material; + //################################ // Public/Protected Members. @@ -30,6 +39,13 @@ namespace Coffee.UIExtensions _spTrailParticle = serializedObject.FindProperty ("m_TrailParticle"); _spScale = serializedObject.FindProperty ("m_Scale"); _spIgnoreParent = serializedObject.FindProperty ("m_IgnoreParent"); + + if (!s_Material) + { + s_Material = Call (typeof (Material), "GetDefaultMaterial"); + } + + _particles = targets.Cast ().ToArray (); } /// @@ -47,8 +63,8 @@ namespace Coffee.UIExtensions var pr = ps.GetComponent (); var sp = new SerializedObject (pr).FindProperty ("m_Materials"); - EditorGUILayout.PropertyField (sp.GetArrayElementAtIndex (0), contentParticleMaterial); - EditorGUILayout.PropertyField (sp.GetArrayElementAtIndex (1), contentTrailMaterial); + EditorGUILayout.PropertyField (sp.GetArrayElementAtIndex (0), s_ContentParticleMaterial); + EditorGUILayout.PropertyField (sp.GetArrayElementAtIndex (1), s_ContentTrailMaterial); sp.serializedObject.ApplyModifiedProperties (); if (!Application.isPlaying && pr.enabled) @@ -98,5 +114,403 @@ namespace Coffee.UIExtensions SerializedProperty _spTrailParticle; SerializedProperty _spScale; SerializedProperty _spIgnoreParent; + UIParticle [] _particles; + ArcHandle _arcHandle = new ArcHandle (); + BoxBoundsHandle _boxBoundsHandle = new BoxBoundsHandle (); + SphereBoundsHandle _sphereBoundsHandle = new SphereBoundsHandle (); + Mesh _spriteMesh; + + static T Call (Type type, string method, params object [] args) + { + MethodInfo mi; + if (!s_InternalMethods.TryGetValue (method, out mi)) + { + mi = type.GetMethod (method, BindingFlags.Static | BindingFlags.NonPublic); + s_InternalMethods.Add (method, mi); + } + return (T)mi.Invoke (null, args); + } + + void OnSceneGUI () + { + Color origCol = Handles.color; + Handles.color = s_GizmoColor; + + Matrix4x4 orgMatrix = Handles.matrix; + + EditorGUI.BeginChangeCheck (); + + foreach (UIParticle current in _particles) + { + ParticleSystem ps = current.GetComponent (); + if (!ps) + { + continue; + } + + var shapeModule = ps.shape; + var mainModule = ps.main; + + ParticleSystemShapeType type = shapeModule.shapeType; + + Matrix4x4 transformMatrix = new Matrix4x4 (); + if (mainModule.scalingMode == ParticleSystemScalingMode.Local) + { + transformMatrix.SetTRS (ps.transform.position, ps.transform.rotation, ps.transform.localScale); + } + else if (mainModule.scalingMode == ParticleSystemScalingMode.Hierarchy) + { + transformMatrix = ps.transform.localToWorldMatrix; + } + else + { + transformMatrix.SetTRS (ps.transform.position, ps.transform.rotation, ps.transform.lossyScale); + } + + bool isBox = (type == ParticleSystemShapeType.Box || type == ParticleSystemShapeType.BoxShell || type == ParticleSystemShapeType.BoxEdge || type == ParticleSystemShapeType.Rectangle); + + Vector3 emitterScale = isBox ? Vector3.one : shapeModule.scale; + Matrix4x4 emitterMatrix = Matrix4x4.TRS (shapeModule.position, Quaternion.Euler (shapeModule.rotation), emitterScale); + transformMatrix *= emitterMatrix; + Handles.matrix = transformMatrix; + + if(current.canvas.renderMode == RenderMode.ScreenSpaceOverlay || ps.main.scalingMode == ParticleSystemScalingMode.Hierarchy) + { + Handles.matrix = Handles.matrix * Matrix4x4.Scale (Vector3.one * current.scale); + } + else + { + Handles.matrix = Handles.matrix * Matrix4x4.Scale (current.canvas.rootCanvas.transform.localScale * current.scale); + } + + if (type == ParticleSystemShapeType.Sphere) + { + // Thickness + Handles.color *= s_ShapeGizmoThicknessTint; + EditorGUI.BeginChangeCheck (); + //float radiusThickness = Handles.DoSimpleRadiusHandle (Quaternion.identity, Vector3.zero, shapeModule.radius * (1.0f - shapeModule.radiusThickness), false, shapeModule.arc); + float radiusThickness = Call (typeof (Handles), "DoSimpleRadiusHandle", Quaternion.identity, Vector3.zero, shapeModule.radius * (1.0f - shapeModule.radiusThickness), false, shapeModule.arc); + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Sphere Thickness Handle Change"); + shapeModule.radiusThickness = 1.0f - (radiusThickness / shapeModule.radius); + } + + // Sphere + Handles.color = s_GizmoColor; + EditorGUI.BeginChangeCheck (); + //float radius = Handles.DoSimpleRadiusHandle (Quaternion.identity, Vector3.zero, shapeModule.radius, false, shapeModule.arc); + float radius = Call (typeof (Handles), "DoSimpleRadiusHandle", Quaternion.identity, Vector3.zero, shapeModule.radius, false, shapeModule.arc); + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Sphere Handle Change"); + shapeModule.radius = radius; + } + + // Texture + //Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS (Vector3.zero, Quaternion.identity, Vector3.one * shapeModule.radius * 2.0f); + //OnSceneViewTextureGUI (shapeModule, s_SphereMesh, false, s_SphereTextureMaterial, textureTransform); + } + else if (type == ParticleSystemShapeType.Circle) + { + // Thickness + EditorGUI.BeginChangeCheck (); + + _arcHandle.angle = shapeModule.arc; + _arcHandle.radius = shapeModule.radius * (1.0f - shapeModule.radiusThickness); + _arcHandle.SetColorWithRadiusHandle (s_ShapeGizmoThicknessTint, 0f); + _arcHandle.angleHandleColor = Color.clear; + + using (new Handles.DrawingScope (Handles.matrix * s_ArcHandleOffsetMatrix)) + _arcHandle.DrawHandle (); + + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Circle Thickness Handle Change"); + shapeModule.radiusThickness = 1.0f - (_arcHandle.radius / shapeModule.radius); + } + + // Circle + EditorGUI.BeginChangeCheck (); + + _arcHandle.radius = shapeModule.radius; + _arcHandle.SetColorWithRadiusHandle (Color.white, 0f); + + using (new Handles.DrawingScope (Handles.matrix * s_ArcHandleOffsetMatrix)) + _arcHandle.DrawHandle (); + + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Circle Handle Change"); + shapeModule.radius = _arcHandle.radius; + shapeModule.arc = _arcHandle.angle; + } + + // Texture + //Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS (Vector3.zero, Quaternion.Euler (90.0f, 0.0f, 180.0f), Vector3.one * shapeModule.radius * 2.0f); + //OnSceneViewTextureGUI (shapeModule, s_CircleMesh, true, s_TextureMaterial, textureTransform); + } + else if (type == ParticleSystemShapeType.Hemisphere) + { + // Thickness + Handles.color *= s_ShapeGizmoThicknessTint; + EditorGUI.BeginChangeCheck (); + //float radiusThickness = Handles.DoSimpleRadiusHandle (Quaternion.identity, Vector3.zero, shapeModule.radius * (1.0f - shapeModule.radiusThickness), true, shapeModule.arc); + float radiusThickness = Call (typeof (Handles), "DoSimpleRadiusHandle", Quaternion.identity, Vector3.zero, shapeModule.radius * (1.0f - shapeModule.radiusThickness), true, shapeModule.arc); + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Hemisphere Thickness Handle Change"); + shapeModule.radiusThickness = 1.0f - (radiusThickness / shapeModule.radius); + } + + // Hemisphere + Handles.color = s_GizmoColor; + EditorGUI.BeginChangeCheck (); + //float radius = Handles.DoSimpleRadiusHandle (Quaternion.identity, Vector3.zero, shapeModule.radius, true, shapeModule.arc); + float radius = Call (typeof (Handles), "DoSimpleRadiusHandle", Quaternion.identity, Vector3.zero, shapeModule.radius, true, shapeModule.arc); + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Hemisphere Handle Change"); + shapeModule.radius = radius; + } + + // Texture + //Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS (Vector3.zero, Quaternion.identity, Vector3.one * shapeModule.radius * 2.0f); + //OnSceneViewTextureGUI (shapeModule, s_HemisphereMesh, false, s_SphereTextureMaterial, textureTransform); + } + else if (type == ParticleSystemShapeType.Cone) + { + // Thickness + Handles.color *= s_ShapeGizmoThicknessTint; + EditorGUI.BeginChangeCheck (); + float angleThickness = Mathf.Lerp (shapeModule.angle, 0.0f, shapeModule.radiusThickness); + Vector3 radiusThicknessAngleRange = new Vector3 (shapeModule.radius * (1.0f - shapeModule.radiusThickness), angleThickness, mainModule.startSpeedMultiplier); + //radiusThicknessAngleRange = Handles.ConeFrustrumHandle (Quaternion.identity, Vector3.zero, radiusThicknessAngleRange, Handles.ConeHandles.Radius); + radiusThicknessAngleRange = Call (typeof (Handles), "ConeFrustrumHandle", Quaternion.identity, Vector3.zero, radiusThicknessAngleRange, 1); + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Cone Thickness Handle Change"); + shapeModule.radiusThickness = 1.0f - (radiusThicknessAngleRange.x / shapeModule.radius); + } + + // Cone + Handles.color = s_GizmoColor; + EditorGUI.BeginChangeCheck (); + Vector3 radiusAngleRange = new Vector3 (shapeModule.radius, shapeModule.angle, mainModule.startSpeedMultiplier); + //radiusAngleRange = Handles.ConeFrustrumHandle (Quaternion.identity, Vector3.zero, radiusAngleRange); + radiusAngleRange = Call (typeof (Handles), "ConeFrustrumHandle", Quaternion.identity, Vector3.zero, radiusAngleRange, 7); + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Cone Handle Change"); + shapeModule.radius = radiusAngleRange.x; + shapeModule.angle = radiusAngleRange.y; + mainModule.startSpeedMultiplier = radiusAngleRange.z; + } + + // Texture + //Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS (Vector3.zero, Quaternion.Euler (90.0f, 0.0f, 180.0f), Vector3.one * shapeModule.radius * 2.0f); + //OnSceneViewTextureGUI (shapeModule, s_CircleMesh, true, s_TextureMaterial, textureTransform); + } + else if (type == ParticleSystemShapeType.ConeVolume) + { + // Thickness + Handles.color *= s_ShapeGizmoThicknessTint; + EditorGUI.BeginChangeCheck (); + float angleThickness = Mathf.Lerp (shapeModule.angle, 0.0f, shapeModule.radiusThickness); + Vector3 radiusThicknessAngleLength = new Vector3 (shapeModule.radius * (1.0f - shapeModule.radiusThickness), angleThickness, shapeModule.length); + //radiusThicknessAngleLength = Handles.ConeFrustrumHandle (Quaternion.identity, Vector3.zero, radiusThicknessAngleLength, Handles.ConeHandles.Radius); + radiusThicknessAngleLength = Call (typeof (Handles), "ConeFrustrumHandle", Quaternion.identity, Vector3.zero, radiusThicknessAngleLength, 1); + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Cone Volume Thickness Handle Change"); + shapeModule.radiusThickness = 1.0f - (radiusThicknessAngleLength.x / shapeModule.radius); + } + + // Cone + Handles.color = s_GizmoColor; + EditorGUI.BeginChangeCheck (); + Vector3 radiusAngleLength = new Vector3 (shapeModule.radius, shapeModule.angle, shapeModule.length); + //radiusAngleLength = Handles.ConeFrustrumHandle (Quaternion.identity, Vector3.zero, radiusAngleLength); + radiusAngleLength = Call (typeof (Handles), "ConeFrustrumHandle", Quaternion.identity, Vector3.zero, radiusAngleLength, 7); + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Cone Volume Handle Change"); + shapeModule.radius = radiusAngleLength.x; + shapeModule.angle = radiusAngleLength.y; + shapeModule.length = radiusAngleLength.z; + } + + // Texture + //Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS (Vector3.zero, Quaternion.Euler (90.0f, 0.0f, 180.0f), Vector3.one * shapeModule.radius * 2.0f); + //OnSceneViewTextureGUI (shapeModule, s_CircleMesh, true, s_TextureMaterial, textureTransform); + } + else if (type == ParticleSystemShapeType.Box || type == ParticleSystemShapeType.BoxShell || type == ParticleSystemShapeType.BoxEdge) + { + EditorGUI.BeginChangeCheck (); + + _boxBoundsHandle.center = Vector3.zero; + _boxBoundsHandle.size = shapeModule.scale; + _boxBoundsHandle.DrawHandle (); + + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Box Handle Change"); + shapeModule.scale = _boxBoundsHandle.size; + } + + //Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS (new Vector3 (0.0f, 0.0f, -m_BoxBoundsHandle.size.z * 0.5f), Quaternion.identity, m_BoxBoundsHandle.size); + //OnSceneViewTextureGUI (shapeModule, s_QuadMesh, true, s_TextureMaterial, textureTransform); + } + else if (type == ParticleSystemShapeType.Donut) + { + // Radius + EditorGUI.BeginChangeCheck (); + + _arcHandle.radius = shapeModule.radius; + _arcHandle.angle = shapeModule.arc; + _arcHandle.SetColorWithRadiusHandle (Color.white, 0f); + _arcHandle.wireframeColor = Color.clear; + + using (new Handles.DrawingScope (Handles.matrix * s_ArcHandleOffsetMatrix)) + _arcHandle.DrawHandle (); + + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Donut Handle Change"); + shapeModule.radius = _arcHandle.radius; + shapeModule.arc = _arcHandle.angle; + } + + // Donut extents + using (new Handles.DrawingScope (Handles.matrix * s_ArcHandleOffsetMatrix)) + { + float excessAngle = shapeModule.arc % 360f; + float angle = Mathf.Abs (shapeModule.arc) >= 360f ? 360f : excessAngle; + + Handles.DrawWireArc (new Vector3 (0.0f, shapeModule.donutRadius, 0.0f), Vector3.up, Vector3.forward, angle, shapeModule.radius); + Handles.DrawWireArc (new Vector3 (0.0f, -shapeModule.donutRadius, 0.0f), Vector3.up, Vector3.forward, angle, shapeModule.radius); + Handles.DrawWireArc (Vector3.zero, Vector3.up, Vector3.forward, angle, shapeModule.radius + shapeModule.donutRadius); + Handles.DrawWireArc (Vector3.zero, Vector3.up, Vector3.forward, angle, shapeModule.radius - shapeModule.donutRadius); + + if (shapeModule.arc != 360.0f) + { + Quaternion arcRotation = Quaternion.AngleAxis (shapeModule.arc, Vector3.up); + Vector3 capCenter = arcRotation * Vector3.forward * shapeModule.radius; + Handles.DrawWireDisc (capCenter, arcRotation * Vector3.right, shapeModule.donutRadius); + } + } + + // Donut thickness + _sphereBoundsHandle.axes = PrimitiveBoundsHandle.Axes.X | PrimitiveBoundsHandle.Axes.Y; + _sphereBoundsHandle.radius = shapeModule.donutRadius * (1.0f - shapeModule.radiusThickness); + _sphereBoundsHandle.center = Vector3.zero; + _sphereBoundsHandle.SetColor (s_ShapeGizmoThicknessTint); + + const float handleInterval = 90.0f; + int numOuterRadii = Mathf.Max (1, (int)Mathf.Ceil (shapeModule.arc / handleInterval)); + Matrix4x4 donutRadiusStartMatrix = Matrix4x4.TRS (new Vector3 (shapeModule.radius, 0.0f, 0.0f), Quaternion.Euler (90.0f, 0.0f, 0.0f), Vector3.one); + + for (int i = 0; i < numOuterRadii; i++) + { + EditorGUI.BeginChangeCheck (); + using (new Handles.DrawingScope (Handles.matrix * (Matrix4x4.Rotate (Quaternion.Euler (0.0f, 0.0f, handleInterval * i)) * donutRadiusStartMatrix))) + _sphereBoundsHandle.DrawHandle (); + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Donut Radius Thickness Handle Change"); + shapeModule.radiusThickness = 1.0f - (_sphereBoundsHandle.radius / shapeModule.donutRadius); + } + } + + // Donut radius + _sphereBoundsHandle.radius = shapeModule.donutRadius; + _sphereBoundsHandle.SetColor (Color.white); + + for (int i = 0; i < numOuterRadii; i++) + { + EditorGUI.BeginChangeCheck (); + using (new Handles.DrawingScope (Handles.matrix * (Matrix4x4.Rotate (Quaternion.Euler (0.0f, 0.0f, handleInterval * i)) * donutRadiusStartMatrix))) + _sphereBoundsHandle.DrawHandle (); + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Donut Radius Handle Change"); + shapeModule.donutRadius = _sphereBoundsHandle.radius; + } + } + + // Texture + //Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS (new Vector3 (shapeModule.radius, 0.0f, 0.0f), Quaternion.Euler (180.0f, 0.0f, 180.0f), Vector3.one * shapeModule.donutRadius * 2.0f); + //OnSceneViewTextureGUI (shapeModule, s_CircleMesh, true, s_TextureMaterial, textureTransform); + } + else if (type == ParticleSystemShapeType.SingleSidedEdge) + { + EditorGUI.BeginChangeCheck (); + //float radius = Handles.DoSimpleEdgeHandle (Quaternion.identity, Vector3.zero, shapeModule.radius); + float radius = Call (typeof (Handles), "DoSimpleEdgeHandle", Quaternion.identity, Vector3.zero, shapeModule.radius); + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Edge Handle Change"); + shapeModule.radius = radius; + } + } + else if (type == ParticleSystemShapeType.Mesh) + { + Mesh mesh = shapeModule.mesh; + if (mesh) + { + bool orgWireframeMode = GL.wireframe; + GL.wireframe = true; + s_Material.SetPass (0); + Graphics.DrawMeshNow (mesh, transformMatrix); + GL.wireframe = orgWireframeMode; + + //OnSceneViewTextureGUI (shapeModule, mesh, false, s_TextureMaterial, transformMatrix); + } + } + else if (type == ParticleSystemShapeType.Rectangle) + { + EditorGUI.BeginChangeCheck (); + + _boxBoundsHandle.center = Vector3.zero; + _boxBoundsHandle.size = new Vector3 (shapeModule.scale.x, shapeModule.scale.y, 0.0f); + _boxBoundsHandle.DrawHandle (); + + if (EditorGUI.EndChangeCheck ()) + { + Undo.RecordObject (ps, "Rectangle Handle Change"); + shapeModule.scale = new Vector3 (_boxBoundsHandle.size.x, _boxBoundsHandle.size.y, 0.0f); + } + + //OnSceneViewTextureGUI (shapeModule, s_QuadMesh, true, s_TextureMaterial, transformMatrix * Matrix4x4.Scale (m_BoxBoundsHandle.size)); + } + else if (type == ParticleSystemShapeType.Sprite) + { + Sprite sprite = shapeModule.sprite; + if (sprite) + { + if (!_spriteMesh) + { + _spriteMesh = new Mesh (); + _spriteMesh.name = "ParticleSpritePreview"; + _spriteMesh.hideFlags |= HideFlags.HideAndDontSave; + } + + _spriteMesh.vertices = Array.ConvertAll (sprite.vertices, i => (Vector3)i); + _spriteMesh.uv = sprite.uv; + _spriteMesh.triangles = Array.ConvertAll (sprite.triangles, i => (int)i); + + bool orgWireframeMode = GL.wireframe; + GL.wireframe = true; + s_Material.SetPass (0); + Graphics.DrawMeshNow (_spriteMesh, transformMatrix); + GL.wireframe = orgWireframeMode; + + //OnSceneViewTextureGUI (shapeModule, m_SpriteMesh, false, s_TextureMaterial, transformMatrix); + } + } + } + Handles.color = origCol; + Handles.matrix = orgMatrix; + } } } \ No newline at end of file diff --git a/UIParticle.cs b/UIParticle.cs index 047b7b1..9cda780 100644 --- a/UIParticle.cs +++ b/UIParticle.cs @@ -44,10 +44,10 @@ namespace Coffee.UIExtensions get { Texture tex = null; - if (!m_IsTrail) + if (!m_IsTrail && particleSystem) { Profiler.BeginSample ("Check TextureSheetAnimation module"); - var textureSheet = m_ParticleSystem.textureSheetAnimation; + var textureSheet = particleSystem.textureSheetAnimation; if (textureSheet.enabled && textureSheet.mode == ParticleSystemAnimationMode.Sprites && 0 < textureSheet.spriteCount) { tex = textureSheet.GetSprite (0).texture; @@ -101,6 +101,10 @@ namespace Coffee.UIExtensions public override bool raycastTarget { get { return false; } set { base.raycastTarget = value; } } + /// + /// ParticleSystem. + /// + new public ParticleSystem particleSystem { get { return m_ParticleSystem ? m_ParticleSystem : (m_ParticleSystem = GetComponent ()); } } public override Material GetModifiedMaterial (Material baseMaterial) { return base.GetModifiedMaterial (_renderer ? _renderer.sharedMaterial : baseMaterial); @@ -123,8 +127,7 @@ namespace Coffee.UIExtensions } s_TempRelatables.Clear (); - m_ParticleSystem = m_ParticleSystem ? m_ParticleSystem : GetComponent (); - _renderer = m_ParticleSystem ? m_ParticleSystem.GetComponent () : null; + _renderer = particleSystem ? particleSystem.GetComponent () : null; // Create objects. _mesh = new Mesh ();