PerformCompleteResimulation() private method

private PerformCompleteResimulation ( ) : void
return void
        public void ApplyProperties()
        {
            bool hasModifiedProperties = m_ParticleSystemSerializedObject.hasModifiedProperties;

            // Check the system was not destroyed such as by an Undo operation.
            if (m_ParticleSystemSerializedObject.targetObject != null)
            {
                m_ParticleSystemSerializedObject.ApplyModifiedProperties();
            }
            if (hasModifiedProperties)
            {
                // Resimulate
                foreach (ParticleSystem ps in m_ParticleSystems)
                {
                    ParticleSystem root = ParticleSystemEditorUtils.GetRoot(ps);
                    if (!ParticleEffectUI.IsStopped(root) && ParticleSystemEditorUtils.resimulation)
                    {
                        ParticleSystemEditorUtils.PerformCompleteResimulation();
                    }
                }

                // Refresh procedural supported string
                UpdateParticleSystemInfoString();
            }
            if (m_RendererSerializedObject != null && m_RendererSerializedObject.targetObject != null)
            {
                m_RendererSerializedObject.ApplyModifiedProperties();
            }
        }
        public void ApplyProperties()
        {
            bool hasModifiedProperties = this.m_ParticleSystemSerializedObject.hasModifiedProperties;

            if (this.m_ParticleSystemSerializedObject.targetObject != null)
            {
                this.m_ParticleSystemSerializedObject.ApplyModifiedProperties();
            }
            if (hasModifiedProperties)
            {
                ParticleSystem[] particleSystems = this.m_ParticleSystems;
                for (int i = 0; i < particleSystems.Length; i++)
                {
                    ParticleSystem ps   = particleSystems[i];
                    ParticleSystem root = ParticleSystemEditorUtils.GetRoot(ps);
                    if (!ParticleEffectUI.IsStopped(root) && ParticleSystemEditorUtils.editorResimulation)
                    {
                        ParticleSystemEditorUtils.PerformCompleteResimulation();
                    }
                }
                this.UpdateParticleSystemInfoString();
            }
            if (this.m_RendererSerializedObject != null && this.m_RendererSerializedObject.targetObject != null)
            {
                this.m_RendererSerializedObject.ApplyModifiedProperties();
            }
        }
        public bool InitializeIfNeeded(ParticleSystem shuriken)
        {
            ParticleSystem root = ParticleSystemEditorUtils.GetRoot(shuriken);
            bool           result;

            if (root == null)
            {
                result = false;
            }
            else
            {
                ParticleSystem[] particleSystems = ParticleEffectUI.GetParticleSystems(root);
                if (root == this.GetRoot())
                {
                    if (this.m_ParticleSystemCurveEditor != null && this.m_Emitters != null && particleSystems.Length == this.m_Emitters.Length)
                    {
                        this.m_SelectedParticleSystem = shuriken;
                        if (this.IsShowOnlySelectedMode())
                        {
                            this.RefreshShowOnlySelected();
                        }
                        result = false;
                        return(result);
                    }
                }
                if (this.m_ParticleSystemCurveEditor != null)
                {
                    this.Clear();
                }
                this.m_SelectedParticleSystem = shuriken;
                ParticleSystemEditorUtils.PerformCompleteResimulation();
                this.m_ParticleSystemCurveEditor = new ParticleSystemCurveEditor();
                this.m_ParticleSystemCurveEditor.Init();
                this.m_EmitterAreaWidth      = EditorPrefs.GetFloat("ParticleSystemEmitterAreaWidth", ParticleEffectUI.k_MinEmitterAreaSize.x);
                this.m_CurveEditorAreaHeight = EditorPrefs.GetFloat("ParticleSystemCurveEditorAreaHeight", ParticleEffectUI.k_MinCurveAreaSize.y);
                this.InitAllEmitters(particleSystems);
                this.m_ShowOnlySelectedMode = (this.m_Owner is ParticleSystemWindow && SessionState.GetBool("ShowSelected" + root.GetInstanceID(), false));
                if (this.IsShowOnlySelectedMode())
                {
                    this.RefreshShowOnlySelected();
                }
                this.m_EmitterAreaScrollPos.x = SessionState.GetFloat("CurrentEmitterAreaScroll", 0f);
                if (this.ShouldManagePlaybackState(root))
                {
                    Vector3 vector = SessionState.GetVector3("SimulationState" + root.GetInstanceID(), Vector3.zero);
                    if (root.GetInstanceID() == (int)vector.x)
                    {
                        float z = vector.z;
                        if (z > 0f)
                        {
                            ParticleSystemEditorUtils.editorPlaybackTime = z;
                        }
                    }
                    this.Play();
                }
                result = true;
            }
            return(result);
        }
Beispiel #4
0
        public override void OnSceneGUI(ParticleSystem s, InitialModuleUI initial)
        {
            Event     current = Event.current;
            EventType rawType = current.type;

            if ((current.type == EventType.Ignore) && (current.rawType == EventType.MouseUp))
            {
                rawType = current.rawType;
            }
            Color color  = Handles.color;
            Color color2 = new Color(1f, 1f, 1f, 0.5f);

            Handles.color = color2;
            if (this.m_Type.intValue == 0)
            {
                for (int i = 0; i < this.m_ShownPlanes.Length; i++)
                {
                    UnityEngine.Object objectReferenceValue = this.m_ShownPlanes[i].objectReferenceValue;
                    if (objectReferenceValue != null)
                    {
                        Transform objB = objectReferenceValue as Transform;
                        if (objB != null)
                        {
                            Vector3    position = objB.position;
                            Quaternion rotation = objB.rotation;
                            Vector3    vector2  = (Vector3)(rotation * Vector3.right);
                            Vector3    normal   = (Vector3)(rotation * Vector3.up);
                            Vector3    vector4  = (Vector3)(rotation * Vector3.forward);
                            if (object.ReferenceEquals(s_SelectedTransform, objB))
                            {
                                Tools.s_Hidden = true;
                                EditorGUI.BeginChangeCheck();
                                if (Tools.current == UnityEditor.Tool.Move)
                                {
                                    objB.position = Handles.PositionHandle(position, rotation);
                                }
                                else if (Tools.current == UnityEditor.Tool.Rotate)
                                {
                                    objB.rotation = Handles.RotationHandle(rotation, position);
                                }
                                if (EditorGUI.EndChangeCheck())
                                {
                                    if (this.m_PlaneVisualizationType == PlaneVizType.Solid)
                                    {
                                        GameObject plane = ParticleEffectUtils.GetPlane(i);
                                        plane.transform.position   = position;
                                        plane.transform.rotation   = rotation;
                                        plane.transform.localScale = new Vector3(this.m_ScaleGrid, this.m_ScaleGrid, this.m_ScaleGrid);
                                    }
                                    ParticleSystemEditorUtils.PerformCompleteResimulation();
                                }
                            }
                            else
                            {
                                int   keyboardControl = GUIUtility.keyboardControl;
                                float size            = HandleUtility.GetHandleSize(position) * 0.06f;
                                if (< > f__mg$cache0 == null)
                                {
        private void HandleKeyboardShortcuts(ParticleSystem root)
        {
            Event current = Event.current;

            if (current.type == EventType.KeyDown)
            {
                int num = 0;
                if (current.keyCode == (Event)ParticleEffectUI.kPlay.keyCode)
                {
                    if (EditorApplication.isPlaying)
                    {
                        this.Stop();
                        this.Play();
                    }
                    else if (!ParticleSystemEditorUtils.editorIsPlaying)
                    {
                        this.Play();
                    }
                    else
                    {
                        this.Pause();
                    }
                    current.Use();
                }
                else if (current.keyCode == (Event)ParticleEffectUI.kStop.keyCode)
                {
                    this.Stop();
                    current.Use();
                }
                else if (current.keyCode == (Event)ParticleEffectUI.kReverse.keyCode)
                {
                    num = -1;
                }
                else if (current.keyCode == (Event)ParticleEffectUI.kForward.keyCode)
                {
                    num = 1;
                }
                if (num != 0)
                {
                    ParticleSystemEditorUtils.editorIsScrubbing = true;
                    float editorSimulationSpeed = ParticleSystemEditorUtils.editorSimulationSpeed;
                    ParticleSystemEditorUtils.editorPlaybackTime = Mathf.Max(0.0f, ParticleSystemEditorUtils.editorPlaybackTime + (float)((!current.shift ? 1.0 : 3.0) * (double)this.m_TimeHelper.deltaTime * (num <= 0 ? -3.0 : 3.0)) * editorSimulationSpeed);
                    if (root.isStopped)
                    {
                        root.Play();
                        root.Pause();
                    }
                    ParticleSystemEditorUtils.PerformCompleteResimulation();
                    current.Use();
                }
            }
            if (current.type != EventType.KeyUp || current.keyCode != (Event)ParticleEffectUI.kReverse.keyCode && current.keyCode != (Event)ParticleEffectUI.kForward.keyCode)
            {
                return;
            }
            ParticleSystemEditorUtils.editorIsScrubbing = false;
        }
        private void HandleKeyboardShortcuts(ParticleSystem root)
        {
            Event current = Event.current;

            if (current.type == EventType.KeyDown)
            {
                int num = 0;
                if (current.keyCode == kPlay.keyCode)
                {
                    if (EditorApplication.isPlaying)
                    {
                        this.Stop();
                        this.Play();
                    }
                    else if (!ParticleSystemEditorUtils.editorIsPlaying)
                    {
                        this.Play();
                    }
                    else
                    {
                        this.Pause();
                    }
                    current.Use();
                }
                else if (current.keyCode == kStop.keyCode)
                {
                    this.Stop();
                    current.Use();
                }
                else if (current.keyCode == kReverse.keyCode)
                {
                    num = -1;
                }
                else if (current.keyCode == kForward.keyCode)
                {
                    num = 1;
                }
                if (num != 0)
                {
                    ParticleSystemEditorUtils.editorIsScrubbing = true;
                    float editorSimulationSpeed = ParticleSystemEditorUtils.editorSimulationSpeed;
                    float num3 = ((!current.shift ? 1f : 3f) * this.m_TimeHelper.deltaTime) * ((num <= 0) ? -3f : 3f);
                    ParticleSystemEditorUtils.editorPlaybackTime = Mathf.Max((float)0f, (float)(ParticleSystemEditorUtils.editorPlaybackTime + (num3 * editorSimulationSpeed)));
                    if (root.isStopped)
                    {
                        root.Play();
                        root.Pause();
                    }
                    ParticleSystemEditorUtils.PerformCompleteResimulation();
                    current.Use();
                }
            }
            if ((current.type == EventType.KeyUp) && ((current.keyCode == kReverse.keyCode) || (current.keyCode == kForward.keyCode)))
            {
                ParticleSystemEditorUtils.editorIsScrubbing = false;
            }
        }
Beispiel #7
0
        internal void PlayBackTimeGUI(ParticleSystem root)
        {
            if (root == null)
            {
                root = ParticleSystemEditorUtils.GetRoot(this.m_SelectedParticleSystem);
            }
            EventType type       = Event.current.type;
            int       hotControl = GUIUtility.hotControl;
            string    kFloatFieldFormatString = EditorGUI.kFloatFieldFormatString;

            EditorGUI.BeginChangeCheck();
            EditorGUI.kFloatFieldFormatString = ParticleEffectUI.s_Texts.secondsFloatFieldFormatString;
            float num = EditorGUILayout.FloatField(ParticleEffectUI.s_Texts.previewTime, ParticleSystemEditorUtils.editorPlaybackTime, new GUILayoutOption[0]);

            EditorGUI.kFloatFieldFormatString = kFloatFieldFormatString;
            if (EditorGUI.EndChangeCheck())
            {
                if (type == EventType.MouseDrag)
                {
                    ParticleSystemEditorUtils.editorIsScrubbing = true;
                    float editorSimulationSpeed = ParticleSystemEditorUtils.editorSimulationSpeed;
                    float editorPlaybackTime    = ParticleSystemEditorUtils.editorPlaybackTime;
                    float num2 = num - editorPlaybackTime;
                    num = editorPlaybackTime + num2 * (0.05f * editorSimulationSpeed);
                }
                num = Mathf.Max(num, 0f);
                ParticleSystemEditorUtils.editorPlaybackTime = num;
                if (root.isStopped)
                {
                    root.Play();
                    root.Pause();
                }
                ParticleSystemEditorUtils.PerformCompleteResimulation();
            }
            if (type == EventType.MouseDown && GUIUtility.hotControl != hotControl)
            {
                this.m_IsDraggingTimeHotControlID           = GUIUtility.hotControl;
                ParticleSystemEditorUtils.editorIsScrubbing = true;
            }
            if (this.m_IsDraggingTimeHotControlID != -1 && GUIUtility.hotControl != this.m_IsDraggingTimeHotControlID)
            {
                this.m_IsDraggingTimeHotControlID           = -1;
                ParticleSystemEditorUtils.editorIsScrubbing = false;
            }
            EditorGUILayout.FloatField(ParticleEffectUI.s_Texts.particleCount, (float)this.m_SelectedParticleSystem.particleCount, new GUILayoutOption[0]);
            int num3 = 0;

            if (this.m_SelectedParticleSystem.CountSubEmitterParticles(ref num3))
            {
                EditorGUILayout.FloatField(ParticleEffectUI.s_Texts.subEmitterParticleCount, (float)num3, new GUILayoutOption[0]);
            }
        }
        internal void PlayBackTimeGUI(ParticleSystem root)
        {
            if (root == null)
            {
                root = ParticleSystemEditorUtils.GetRoot(this.m_SelectedParticleSystem);
            }
            EventType type       = Event.current.type;
            int       hotControl = GUIUtility.hotControl;
            string    kFloatFieldFormatString = EditorGUI.kFloatFieldFormatString;

            EditorGUI.BeginChangeCheck();
            EditorGUI.kFloatFieldFormatString = s_Texts.secondsFloatFieldFormatString;
            float a = EditorGUILayout.FloatField(s_Texts.previewTime, ParticleSystemEditorUtils.editorPlaybackTime, new GUILayoutOption[0]);

            EditorGUI.kFloatFieldFormatString = kFloatFieldFormatString;
            if (EditorGUI.EndChangeCheck())
            {
                if (type == EventType.MouseDrag)
                {
                    ParticleSystemEditorUtils.editorIsScrubbing = true;
                    float editorSimulationSpeed = ParticleSystemEditorUtils.editorSimulationSpeed;
                    float editorPlaybackTime    = ParticleSystemEditorUtils.editorPlaybackTime;
                    float num5 = a - editorPlaybackTime;
                    a = editorPlaybackTime + (num5 * (0.05f * editorSimulationSpeed));
                }
                ParticleSystemEditorUtils.editorPlaybackTime = Mathf.Max(a, 0f);
                if (root.isStopped)
                {
                    root.Play();
                    root.Pause();
                }
                ParticleSystemEditorUtils.PerformCompleteResimulation();
            }
            if ((type == EventType.MouseDown) && (GUIUtility.hotControl != hotControl))
            {
                this.m_IsDraggingTimeHotControlID           = GUIUtility.hotControl;
                ParticleSystemEditorUtils.editorIsScrubbing = true;
            }
            if ((this.m_IsDraggingTimeHotControlID != -1) && (GUIUtility.hotControl != this.m_IsDraggingTimeHotControlID))
            {
                this.m_IsDraggingTimeHotControlID           = -1;
                ParticleSystemEditorUtils.editorIsScrubbing = false;
            }
            EditorGUILayout.FloatField(s_Texts.particleCount, (float)root.particleCount, new GUILayoutOption[0]);
        }
Beispiel #9
0
        public void ApplyProperties()
        {
            bool hasModifiedProperties = this.m_ParticleSystemSerializedObject.hasModifiedProperties;

            this.m_ParticleSystemSerializedObject.ApplyModifiedProperties();
            if (hasModifiedProperties)
            {
                if (!ParticleEffectUI.IsStopped(ParticleSystemEditorUtils.GetRoot(this.m_ParticleSystem)) && ParticleSystemEditorUtils.editorResimulation)
                {
                    ParticleSystemEditorUtils.PerformCompleteResimulation();
                }
                this.UpdateParticleSystemInfoString();
            }
            if (this.m_RendererSerializedObject != null)
            {
                this.m_RendererSerializedObject.ApplyModifiedProperties();
            }
        }
        private void CollisionPlanesSceneGUI()
        {
            if (m_ScenePlanes.Count == 0)
            {
                return;
            }

            Event evt = Event.current;

            Color origCol = Handles.color;
            Color col     = new Color(1, 1, 1, 0.5F);

            for (int i = 0; i < m_ScenePlanes.Count; ++i)
            {
                if (m_ScenePlanes[i] == null)
                {
                    continue;
                }

                Transform  transform          = m_ScenePlanes[i];
                Vector3    position           = transform.position;
                Quaternion rotation           = transform.rotation;
                Vector3    right              = rotation * Vector3.right;
                Vector3    up                 = rotation * Vector3.up;
                Vector3    forward            = rotation * Vector3.forward;
                bool       isPlayingAndStatic = EditorApplication.isPlaying && transform.gameObject.isStatic;
                if (editingPlanes)
                {
                    if (Object.ReferenceEquals(s_SelectedTransform, transform))
                    {
                        EditorGUI.BeginChangeCheck();
                        var newPosition = transform.position;
                        var newRotation = transform.rotation;

                        using (new EditorGUI.DisabledScope(isPlayingAndStatic))
                        {
                            if (isPlayingAndStatic)
                            {
                                Handles.ShowStaticLabel(position);
                            }
                            if (EditMode.editMode == EditMode.SceneViewEditMode.ParticleSystemCollisionModulePlanesMove)
                            {
                                newPosition = Handles.PositionHandle(position, rotation);
                            }
                            else if (EditMode.editMode == EditMode.SceneViewEditMode.ParticleSystemCollisionModulePlanesRotate)
                            {
                                newRotation = Handles.RotationHandle(rotation, position);
                            }
                        }
                        if (EditorGUI.EndChangeCheck())
                        {
                            Undo.RecordObject(transform, s_UndoCollisionPlaneString);
                            transform.position = newPosition;
                            transform.rotation = newRotation;
                            ParticleSystemEditorUtils.PerformCompleteResimulation();
                        }
                    }
                    else
                    {
                        float handleSize = HandleUtility.GetHandleSize(position) * 0.6f;

                        EventType oldEventType = evt.type;

                        // we want ignored mouse up events to check for dragging off of scene view
                        if (evt.type == EventType.Ignore && evt.rawType == EventType.MouseUp)
                        {
                            oldEventType = evt.rawType;
                        }

                        Handles.FreeMoveHandle(position, Quaternion.identity, handleSize, Vector3.zero, Handles.RectangleHandleCap);

                        // Detect selected plane (similar to TreeEditor)
                        if (oldEventType == EventType.MouseDown && evt.type == EventType.Used)
                        {
                            s_SelectedTransform   = transform;
                            oldEventType          = EventType.Used;
                            GUIUtility.hotControl = 0; // Reset hot control or the FreeMoveHandle will prevent input to the new Handles. (case 873514)
                        }
                    }
                }

                Handles.color = col;
                Color color = Handles.s_ColliderHandleColor * 0.9f;
                if (isPlayingAndStatic)
                {
                    color.a *= 0.2f;
                }

                if (m_PlaneVisualizationType == PlaneVizType.Grid)
                {
                    DrawGrid(position, right, forward, up, color);
                }
                else
                {
                    DrawSolidPlane(position, rotation, color, Color.yellow);
                }
            }

            Handles.color = origCol;
        }
Beispiel #11
0
 private void CollisionPlanesSceneGUI()
 {
     if (this.m_ScenePlanes.Count != 0)
     {
         Event current = Event.current;
         Color color   = Handles.color;
         Color color2  = new Color(1f, 1f, 1f, 0.5f);
         for (int i = 0; i < this.m_ScenePlanes.Count; i++)
         {
             if (!(this.m_ScenePlanes[i] == null))
             {
                 Transform  transform = this.m_ScenePlanes[i];
                 Vector3    position  = transform.position;
                 Quaternion rotation  = transform.rotation;
                 Vector3    axis      = rotation * Vector3.right;
                 Vector3    normal    = rotation * Vector3.up;
                 Vector3    axis2     = rotation * Vector3.forward;
                 bool       flag      = EditorApplication.isPlaying && transform.gameObject.isStatic;
                 if (this.editingPlanes)
                 {
                     if (object.ReferenceEquals(CollisionModuleUI.s_SelectedTransform, transform))
                     {
                         EditorGUI.BeginChangeCheck();
                         Vector3    position2 = transform.position;
                         Quaternion rotation2 = transform.rotation;
                         using (new EditorGUI.DisabledScope(flag))
                         {
                             if (flag)
                             {
                                 Handles.ShowStaticLabel(position);
                             }
                             if (EditMode.editMode == EditMode.SceneViewEditMode.ParticleSystemCollisionModulePlanesMove)
                             {
                                 position2 = Handles.PositionHandle(position, rotation);
                             }
                             else if (EditMode.editMode == EditMode.SceneViewEditMode.ParticleSystemCollisionModulePlanesRotate)
                             {
                                 rotation2 = Handles.RotationHandle(rotation, position);
                             }
                         }
                         if (EditorGUI.EndChangeCheck())
                         {
                             Undo.RecordObject(transform, "Modified Collision Plane Transform");
                             transform.position = position2;
                             transform.rotation = rotation2;
                             ParticleSystemEditorUtils.PerformCompleteResimulation();
                         }
                     }
                     else
                     {
                         float     num       = HandleUtility.GetHandleSize(position) * 0.6f;
                         EventType eventType = current.type;
                         if (current.type == EventType.Ignore && current.rawType == EventType.MouseUp)
                         {
                             eventType = current.rawType;
                         }
                         Vector3    arg_1F3_0 = position;
                         Quaternion arg_1F3_1 = Quaternion.identity;
                         float      arg_1F3_2 = num;
                         Vector3    arg_1F3_3 = Vector3.zero;
                         if (CollisionModuleUI.< > f__mg$cache0 == null)
                         {
                             CollisionModuleUI.< > f__mg$cache0 = new Handles.CapFunction(Handles.RectangleHandleCap);
                         }
                         Handles.FreeMoveHandle(arg_1F3_0, arg_1F3_1, arg_1F3_2, arg_1F3_3, CollisionModuleUI.< > f__mg$cache0);
                         if (eventType == EventType.MouseDown && current.type == EventType.Used)
                         {
                             CollisionModuleUI.s_SelectedTransform = transform;
                             GUIUtility.hotControl = 0;
                         }
                     }
                 }
                 Handles.color = color2;
                 Color color3 = Handles.s_ColliderHandleColor * 0.9f;
                 if (flag)
                 {
                     color3.a *= 0.2f;
                 }
                 if (CollisionModuleUI.m_PlaneVisualizationType == CollisionModuleUI.PlaneVizType.Grid)
                 {
                     CollisionModuleUI.DrawGrid(position, axis, axis2, normal, color3);
                 }
                 else
                 {
                     CollisionModuleUI.DrawSolidPlane(position, rotation, color3, Color.yellow);
                 }
             }
         }
         Handles.color = color;
     }
 }
Beispiel #12
0
        private void HandleKeyboardShortcuts()
        {
            Event current = Event.current;

            if (current.type == EventType.KeyDown)
            {
                int num = 0;
                if (current.keyCode == ParticleEffectUI.kPlay.keyCode)
                {
                    if (EditorApplication.isPlaying)
                    {
                        this.Stop();
                        this.Play();
                    }
                    else if (!ParticleSystemEditorUtils.editorIsPlaying)
                    {
                        this.Play();
                    }
                    else
                    {
                        this.Pause();
                    }
                    current.Use();
                }
                else if (current.keyCode == ParticleEffectUI.kStop.keyCode)
                {
                    this.Stop();
                    current.Use();
                }
                else if (current.keyCode == ParticleEffectUI.kReverse.keyCode)
                {
                    num = -1;
                }
                else if (current.keyCode == ParticleEffectUI.kForward.keyCode)
                {
                    num = 1;
                }
                if (num != 0)
                {
                    ParticleSystemEditorUtils.editorIsScrubbing = true;
                    float editorSimulationSpeed = ParticleSystemEditorUtils.editorSimulationSpeed;
                    float num2 = ((!current.shift) ? 1f : 3f) * this.m_TimeHelper.deltaTime * ((num <= 0) ? -3f : 3f);
                    ParticleSystemEditorUtils.editorPlaybackTime = Mathf.Max(0f, ParticleSystemEditorUtils.editorPlaybackTime + num2 * editorSimulationSpeed);
                    foreach (ParticleSystem current2 in this.m_SelectedParticleSystems)
                    {
                        ParticleSystem root = ParticleSystemEditorUtils.GetRoot(current2);
                        if (root.isStopped)
                        {
                            root.Play();
                            root.Pause();
                        }
                    }
                    ParticleSystemEditorUtils.PerformCompleteResimulation();
                    current.Use();
                }
            }
            if (current.type == EventType.KeyUp && (current.keyCode == ParticleEffectUI.kReverse.keyCode || current.keyCode == ParticleEffectUI.kForward.keyCode))
            {
                ParticleSystemEditorUtils.editorIsScrubbing = false;
            }
        }
Beispiel #13
0
        internal void PlayBackInfoGUI(bool isPlayMode)
        {
            EventType oldEventType  = Event.current.type;
            int       oldHotControl = GUIUtility.hotControl;
            string    oldFormat     = EditorGUI.kFloatFieldFormatString;

            EditorGUIUtility.labelWidth = 110.0f;

            if (!isPlayMode)
            {
                EditorGUI.kFloatFieldFormatString = s_Texts.secondsFloatFieldFormatString;
                if (Time.timeScale == 0.0f)
                {
                    using (new EditorGUI.DisabledScope(true))
                    {
                        EditorGUILayout.FloatField(s_Texts.previewSpeedDisabled, 0.0f);
                    }
                }
                else
                {
                    ParticleSystemEditorUtils.simulationSpeed = Mathf.Clamp(EditorGUILayout.FloatField(s_Texts.previewSpeed, ParticleSystemEditorUtils.simulationSpeed), 0f, 10f);
                }
                EditorGUI.kFloatFieldFormatString = oldFormat;

                EditorGUI.BeginChangeCheck();
                EditorGUI.kFloatFieldFormatString = s_Texts.secondsFloatFieldFormatString;
                float playbackTime = EditorGUILayout.FloatField(s_Texts.previewTime, ParticleSystemEditorUtils.playbackTime);
                EditorGUI.kFloatFieldFormatString = oldFormat;
                if (EditorGUI.EndChangeCheck())
                {
                    if (oldEventType == EventType.MouseDrag)
                    {
                        ParticleSystemEditorUtils.playbackIsScrubbing = true;
                        float previewSpeed    = ParticleSystemEditorUtils.simulationSpeed;
                        float oldplaybackTime = ParticleSystemEditorUtils.playbackTime;
                        float timeDiff        = playbackTime - oldplaybackTime;
                        playbackTime = oldplaybackTime + timeDiff * (0.05F * previewSpeed);
                    }

                    playbackTime = Mathf.Max(playbackTime, 0.0F);
                    ParticleSystemEditorUtils.playbackTime = playbackTime;

                    foreach (ParticleSystem ps in m_SelectedParticleSystems)
                    {
                        ParticleSystem root = ParticleSystemEditorUtils.GetRoot(ps);
                        if (root.isStopped)
                        {
                            root.Play();
                            root.Pause();
                        }
                    }

                    ParticleSystemEditorUtils.PerformCompleteResimulation();
                }

                // Detect start dragging
                if (oldEventType == EventType.MouseDown && GUIUtility.hotControl != oldHotControl)
                {
                    m_IsDraggingTimeHotControlID = GUIUtility.hotControl;
                    ParticleSystemEditorUtils.playbackIsScrubbing = true;
                }

                // Detect stop dragging
                if (m_IsDraggingTimeHotControlID != -1 && GUIUtility.hotControl != m_IsDraggingTimeHotControlID)
                {
                    m_IsDraggingTimeHotControlID = -1;
                    ParticleSystemEditorUtils.playbackIsScrubbing = false;
                }
            }

            int   particleCount   = 0;
            float fastestParticle = 0.0f;
            float slowestParticle = Mathf.Infinity;

            foreach (ParticleSystem ps in m_SelectedParticleSystems)
            {
                ps.CalculateEffectUIData(ref particleCount, ref fastestParticle, ref slowestParticle);
            }
            EditorGUILayout.LabelField(s_Texts.particleCount, GUIContent.Temp(particleCount.ToString()));

            bool hasSubEmitters      = false;
            int  subEmitterParticles = 0;

            foreach (ParticleSystem ps in m_SelectedParticleSystems)
            {
                int subEmitterParticlesCurrent = 0;
                if (ps.CalculateEffectUISubEmitterData(ref subEmitterParticlesCurrent, ref fastestParticle, ref slowestParticle))
                {
                    hasSubEmitters       = true;
                    subEmitterParticles += subEmitterParticlesCurrent;
                }
            }
            if (hasSubEmitters)
            {
                EditorGUILayout.LabelField(s_Texts.subEmitterParticleCount, GUIContent.Temp(subEmitterParticles.ToString()));
            }

            if (fastestParticle >= slowestParticle)
            {
                EditorGUILayout.LabelField(s_Texts.particleSpeeds, GUIContent.Temp(slowestParticle.ToString(s_Texts.speedFloatFieldFormatString) + " - " + fastestParticle.ToString(s_Texts.speedFloatFieldFormatString)));
            }
            else
            {
                EditorGUILayout.LabelField(s_Texts.particleSpeeds, GUIContent.Temp("0.0 - 0.0"));
            }

            if (!EditorApplication.isPlaying)
            {
                EditorGUILayout.LayerMaskField(ParticleSystemEditorUtils.previewLayers, s_Texts.previewLayers, SetPreviewLayersDelegate);
                ParticleSystemEditorUtils.resimulation = GUILayout.Toggle(ParticleSystemEditorUtils.resimulation, s_Texts.resimulation, EditorStyles.toggle);
            }

            ParticleEffectUI.m_ShowBounds = GUILayout.Toggle(ParticleEffectUI.m_ShowBounds, ParticleEffectUI.texts.showBounds, EditorStyles.toggle);

            EditorGUIUtility.labelWidth = 0.0f;
        }
Beispiel #14
0
        public override void OnSceneGUI(ParticleSystem s, InitialModuleUI initial)
        {
            Event     current = Event.current;
            EventType rawType = current.type;

            if ((current.type == EventType.Ignore) && (current.rawType == EventType.MouseUp))
            {
                rawType = current.rawType;
            }
            Color color  = Handles.color;
            Color color2 = new Color(1f, 1f, 1f, 0.5f);

            Handles.color = color2;
            if (this.m_Type.intValue == 0)
            {
                for (int i = 0; i < this.m_ShownPlanes.Length; i++)
                {
                    Object objectReferenceValue = this.m_ShownPlanes[i].objectReferenceValue;
                    if (objectReferenceValue != null)
                    {
                        Transform objB = objectReferenceValue as Transform;
                        if (objB != null)
                        {
                            Vector3    position = objB.position;
                            Quaternion rotation = objB.rotation;
                            Vector3    vector2  = (Vector3)(rotation * Vector3.right);
                            Vector3    normal   = (Vector3)(rotation * Vector3.up);
                            Vector3    vector4  = (Vector3)(rotation * Vector3.forward);
                            if (object.ReferenceEquals(m_SelectedTransform, objB))
                            {
                                Tools.s_Hidden = true;
                                EditorGUI.BeginChangeCheck();
                                if (Tools.current == Tool.Move)
                                {
                                    objB.position = Handles.PositionHandle(position, rotation);
                                }
                                else if (Tools.current == Tool.Rotate)
                                {
                                    objB.rotation = Handles.RotationHandle(rotation, position);
                                }
                                if (EditorGUI.EndChangeCheck())
                                {
                                    if (this.m_PlaneVisualizationType == PlaneVizType.Solid)
                                    {
                                        GameObject plane = ParticleEffectUtils.GetPlane(i);
                                        plane.transform.position   = position;
                                        plane.transform.rotation   = rotation;
                                        plane.transform.localScale = new Vector3(this.m_ScaleGrid, this.m_ScaleGrid, this.m_ScaleGrid);
                                    }
                                    ParticleSystemEditorUtils.PerformCompleteResimulation();
                                }
                            }
                            else
                            {
                                int   keyboardControl = GUIUtility.keyboardControl;
                                float size            = HandleUtility.GetHandleSize(position) * 0.06f;
                                Handles.FreeMoveHandle(position, Quaternion.identity, size, Vector3.zero, new Handles.DrawCapFunction(Handles.RectangleCap));
                                if (((rawType == EventType.MouseDown) && (current.type == EventType.Used)) && (keyboardControl != GUIUtility.keyboardControl))
                                {
                                    m_SelectedTransform = objB;
                                    rawType             = EventType.Used;
                                }
                            }
                            if (this.m_PlaneVisualizationType == PlaneVizType.Grid)
                            {
                                Color color3 = (Color)(Handles.s_ColliderHandleColor * 0.9f);
                                if (!base.enabled)
                                {
                                    color3 = new Color(0.7f, 0.7f, 0.7f, 0.7f);
                                }
                                this.DrawGrid(position, vector2, vector4, normal, color3, i);
                            }
                            else
                            {
                                this.DrawSolidPlane(position, rotation, i);
                            }
                        }
                        else
                        {
                            Debug.LogError("Not a transform: " + objectReferenceValue.GetType());
                        }
                    }
                }
            }
            Handles.color = color;
        }
        public override void OnSceneGUI(ParticleSystem s, InitialModuleUI initial)
        {
            Event     current   = Event.current;
            EventType eventType = current.type;

            if (current.type == EventType.Ignore && current.rawType == EventType.MouseUp)
            {
                eventType = current.rawType;
            }
            Color color  = Handles.color;
            Color color2 = new Color(1f, 1f, 1f, 0.5f);

            Handles.color = color2;
            if (this.m_Type.intValue == 0)
            {
                for (int i = 0; i < this.m_ShownPlanes.Length; i++)
                {
                    UnityEngine.Object objectReferenceValue = this.m_ShownPlanes[i].objectReferenceValue;
                    if (objectReferenceValue != null)
                    {
                        Transform transform = objectReferenceValue as Transform;
                        if (transform != null)
                        {
                            Vector3    position = transform.position;
                            Quaternion rotation = transform.rotation;
                            Vector3    axis     = rotation * Vector3.right;
                            Vector3    normal   = rotation * Vector3.up;
                            Vector3    axis2    = rotation * Vector3.forward;
                            if (object.ReferenceEquals(CollisionModuleUI.s_SelectedTransform, transform))
                            {
                                Tools.s_Hidden = true;
                                EditorGUI.BeginChangeCheck();
                                if (Tools.current == Tool.Move)
                                {
                                    transform.position = Handles.PositionHandle(position, rotation);
                                }
                                else if (Tools.current == Tool.Rotate)
                                {
                                    transform.rotation = Handles.RotationHandle(rotation, position);
                                }
                                if (EditorGUI.EndChangeCheck())
                                {
                                    if (this.m_PlaneVisualizationType == CollisionModuleUI.PlaneVizType.Solid)
                                    {
                                        GameObject plane = ParticleEffectUtils.GetPlane(i);
                                        plane.transform.position   = position;
                                        plane.transform.rotation   = rotation;
                                        plane.transform.localScale = new Vector3(this.m_ScaleGrid, this.m_ScaleGrid, this.m_ScaleGrid);
                                    }
                                    ParticleSystemEditorUtils.PerformCompleteResimulation();
                                }
                            }
                            else
                            {
                                int        keyboardControl = GUIUtility.keyboardControl;
                                float      num             = HandleUtility.GetHandleSize(position) * 0.06f;
                                Vector3    arg_1EB_0       = position;
                                Quaternion arg_1EB_1       = Quaternion.identity;
                                float      arg_1EB_2       = num;
                                Vector3    arg_1EB_3       = Vector3.zero;
                                if (CollisionModuleUI.< > f__mg$cache0 == null)
                                {
                                    CollisionModuleUI.< > f__mg$cache0 = new Handles.CapFunction(Handles.RectangleHandleCap);
                                }
                                Handles.FreeMoveHandle(arg_1EB_0, arg_1EB_1, arg_1EB_2, arg_1EB_3, CollisionModuleUI.< > f__mg$cache0);
                                if (eventType == EventType.MouseDown && current.type == EventType.Used && keyboardControl != GUIUtility.keyboardControl)
                                {
                                    CollisionModuleUI.s_SelectedTransform = transform;
                                    eventType = EventType.Used;
                                }
                            }
                            if (this.m_PlaneVisualizationType == CollisionModuleUI.PlaneVizType.Grid)
                            {
                                Color color3 = Handles.s_ColliderHandleColor * 0.9f;
                                if (!base.enabled)
                                {
                                    color3 = new Color(0.7f, 0.7f, 0.7f, 0.7f);
                                }
                                this.DrawGrid(position, axis, axis2, normal, color3, i);
                            }
                            else
                            {
                                this.DrawSolidPlane(position, rotation, i);
                            }
                        }
                        else
                        {
                            Debug.LogError("Not a transform: " + objectReferenceValue.GetType());
                        }
                    }
                }
            }
            Handles.color = color;
        }
        internal void PlayBackInfoGUI(bool isPlayMode)
        {
            EventType type       = Event.current.type;
            int       hotControl = GUIUtility.hotControl;
            string    kFloatFieldFormatString = EditorGUI.kFloatFieldFormatString;

            EditorGUIUtility.labelWidth = 110f;
            if (!isPlayMode)
            {
                EditorGUI.kFloatFieldFormatString = ParticleEffectUI.s_Texts.secondsFloatFieldFormatString;
                if (Time.timeScale == 0f)
                {
                    using (new EditorGUI.DisabledScope(true))
                    {
                        EditorGUILayout.FloatField(ParticleEffectUI.s_Texts.previewSpeedDisabled, 0f, new GUILayoutOption[0]);
                    }
                }
                else
                {
                    ParticleSystemEditorUtils.simulationSpeed = Mathf.Clamp(EditorGUILayout.FloatField(ParticleEffectUI.s_Texts.previewSpeed, ParticleSystemEditorUtils.simulationSpeed, new GUILayoutOption[0]), 0f, 10f);
                }
                EditorGUI.kFloatFieldFormatString = kFloatFieldFormatString;
                EditorGUI.BeginChangeCheck();
                EditorGUI.kFloatFieldFormatString = ParticleEffectUI.s_Texts.secondsFloatFieldFormatString;
                float num = EditorGUILayout.FloatField(ParticleEffectUI.s_Texts.previewTime, ParticleSystemEditorUtils.playbackTime, new GUILayoutOption[0]);
                EditorGUI.kFloatFieldFormatString = kFloatFieldFormatString;
                if (EditorGUI.EndChangeCheck())
                {
                    if (type == EventType.MouseDrag)
                    {
                        ParticleSystemEditorUtils.playbackIsScrubbing = true;
                        float simulationSpeed = ParticleSystemEditorUtils.simulationSpeed;
                        float playbackTime    = ParticleSystemEditorUtils.playbackTime;
                        float num2            = num - playbackTime;
                        num = playbackTime + num2 * (0.05f * simulationSpeed);
                    }
                    num = Mathf.Max(num, 0f);
                    ParticleSystemEditorUtils.playbackTime = num;
                    foreach (ParticleSystem current in this.m_SelectedParticleSystems)
                    {
                        ParticleSystem root = ParticleSystemEditorUtils.GetRoot(current);
                        if (root.isStopped)
                        {
                            root.Play();
                            root.Pause();
                        }
                    }
                    ParticleSystemEditorUtils.PerformCompleteResimulation();
                }
                if (type == EventType.MouseDown && GUIUtility.hotControl != hotControl)
                {
                    this.m_IsDraggingTimeHotControlID             = GUIUtility.hotControl;
                    ParticleSystemEditorUtils.playbackIsScrubbing = true;
                }
                if (this.m_IsDraggingTimeHotControlID != -1 && GUIUtility.hotControl != this.m_IsDraggingTimeHotControlID)
                {
                    this.m_IsDraggingTimeHotControlID             = -1;
                    ParticleSystemEditorUtils.playbackIsScrubbing = false;
                }
            }
            int   num3 = 0;
            float num4 = 0f;
            float num5 = float.PositiveInfinity;

            foreach (ParticleSystem current2 in this.m_SelectedParticleSystems)
            {
                current2.CalculateEffectUIData(ref num3, ref num4, ref num5);
            }
            EditorGUILayout.LabelField(ParticleEffectUI.s_Texts.particleCount, GUIContent.Temp(num3.ToString()), new GUILayoutOption[0]);
            bool flag = false;
            int  num6 = 0;

            foreach (ParticleSystem current3 in this.m_SelectedParticleSystems)
            {
                int num7 = 0;
                if (current3.CalculateEffectUISubEmitterData(ref num7, ref num4, ref num5))
                {
                    flag  = true;
                    num6 += num7;
                }
            }
            if (flag)
            {
                EditorGUILayout.LabelField(ParticleEffectUI.s_Texts.subEmitterParticleCount, GUIContent.Temp(num6.ToString()), new GUILayoutOption[0]);
            }
            if (num4 >= num5)
            {
                EditorGUILayout.LabelField(ParticleEffectUI.s_Texts.particleSpeeds, GUIContent.Temp(num5.ToString(ParticleEffectUI.s_Texts.speedFloatFieldFormatString) + " - " + num4.ToString(ParticleEffectUI.s_Texts.speedFloatFieldFormatString)), new GUILayoutOption[0]);
            }
            else
            {
                EditorGUILayout.LabelField(ParticleEffectUI.s_Texts.particleSpeeds, GUIContent.Temp("0.0 - 0.0"), new GUILayoutOption[0]);
            }
            if (!EditorApplication.isPlaying)
            {
                uint       arg_3C2_0 = ParticleSystemEditorUtils.previewLayers;
                GUIContent arg_3C2_1 = ParticleEffectUI.s_Texts.previewLayers;
                if (ParticleEffectUI.< > f__mg$cache0 == null)
                {
                    ParticleEffectUI.< > f__mg$cache0 = new EditorUtility.SelectMenuItemFunction(ParticleEffectUI.SetPreviewLayersDelegate);
                }
                EditorGUILayout.LayerMaskField(arg_3C2_0, arg_3C2_1, ParticleEffectUI.< > f__mg$cache0, new GUILayoutOption[0]);
        public bool InitializeIfNeeded(IEnumerable <ParticleSystem> systems)
        {
            bool flag = false;

            ParticleSystem[] array          = systems.ToArray <ParticleSystem>();
            bool             flag2          = array.Count <ParticleSystem>() > 1;
            bool             flag3          = false;
            ParticleSystem   particleSystem = null;

            ParticleSystem[] array2 = array;
            int i = 0;

            while (i < array2.Length)
            {
                ParticleSystem particleSystem2 = array2[i];
                if (flag2)
                {
                    ParticleSystem[] array3 = new ParticleSystem[]
                    {
                        particleSystem2
                    };
                    particleSystem = particleSystem2;
                    goto IL_11F;
                }
                ParticleSystem root = ParticleSystemEditorUtils.GetRoot(particleSystem2);
                if (!(root == null))
                {
                    ParticleSystem[] array3 = ParticleEffectUI.GetParticleSystems(root);
                    particleSystem = root;
                    if (this.m_SelectedParticleSystems != null && this.m_SelectedParticleSystems.Count > 0)
                    {
                        if (root == ParticleSystemEditorUtils.GetRoot(this.m_SelectedParticleSystems[0]))
                        {
                            if (this.m_ParticleSystemCurveEditor != null && this.m_Emitters != null && array3.Length == this.m_Emitters.Length && particleSystem2.gameObject.activeInHierarchy == this.m_EmittersActiveInHierarchy)
                            {
                                this.m_SelectedParticleSystems = new List <ParticleSystem>();
                                this.m_SelectedParticleSystems.Add(particleSystem2);
                                if (this.IsShowOnlySelectedMode())
                                {
                                    this.RefreshShowOnlySelected();
                                }
                                goto IL_1E6;
                            }
                        }
                    }
                    goto IL_11F;
                }
IL_1E6:
                i++;
                continue;
IL_11F:
                if (this.m_ParticleSystemCurveEditor != null)
                {
                    this.Clear();
                }
                flag3 = true;
                if (!flag)
                {
                    this.m_SelectedParticleSystems = new List <ParticleSystem>();
                    flag = true;
                }
                this.m_SelectedParticleSystems.Add(particleSystem2);
                if (!flag2)
                {
                    this.m_ParticleSystemCurveEditor = new ParticleSystemCurveEditor();
                    this.m_ParticleSystemCurveEditor.Init();
                    ParticleSystem[] array3;
                    int num = array3.Length;
                    if (num > 0)
                    {
                        this.m_Emitters = new ParticleSystemUI[num];
                        for (int j = 0; j < num; j++)
                        {
                            this.m_Emitters[j] = new ParticleSystemUI();
                            this.m_Emitters[j].Init(this, new ParticleSystem[]
                            {
                                array3[j]
                            });
                        }
                        this.m_EmittersActiveInHierarchy = particleSystem2.gameObject.activeInHierarchy;
                    }
                }
                goto IL_1E6;
            }
            if (flag3)
            {
                if (flag2)
                {
                    this.m_ParticleSystemCurveEditor = new ParticleSystemCurveEditor();
                    this.m_ParticleSystemCurveEditor.Init();
                    int count = this.m_SelectedParticleSystems.Count;
                    if (count > 0)
                    {
                        this.m_Emitters    = new ParticleSystemUI[1];
                        this.m_Emitters[0] = new ParticleSystemUI();
                        this.m_Emitters[0].Init(this, this.m_SelectedParticleSystems.ToArray());
                        this.m_EmittersActiveInHierarchy = this.m_SelectedParticleSystems[0].gameObject.activeInHierarchy;
                    }
                }
                ParticleSystemUI[] emitters = this.m_Emitters;
                for (int k = 0; k < emitters.Length; k++)
                {
                    ParticleSystemUI particleSystemUI = emitters[k];
                    ModuleUI[]       modules          = particleSystemUI.m_Modules;
                    for (int l = 0; l < modules.Length; l++)
                    {
                        ModuleUI moduleUI = modules[l];
                        if (moduleUI != null)
                        {
                            moduleUI.Validate();
                        }
                    }
                }
                if (ParticleEffectUI.GetAllModulesVisible())
                {
                    this.SetAllModulesVisible(true);
                }
                this.m_EmitterAreaWidth      = EditorPrefs.GetFloat("ParticleSystemEmitterAreaWidth", ParticleEffectUI.k_MinEmitterAreaSize.x);
                this.m_CurveEditorAreaHeight = EditorPrefs.GetFloat("ParticleSystemCurveEditorAreaHeight", ParticleEffectUI.k_MinCurveAreaSize.y);
                this.SetShowOnlySelectedMode(this.m_Owner is ParticleSystemWindow && SessionState.GetBool("ShowSelected" + particleSystem.GetInstanceID(), false));
                this.m_EmitterAreaScrollPos.x = SessionState.GetFloat("CurrentEmitterAreaScroll", 0f);
                if (this.ShouldManagePlaybackState(particleSystem))
                {
                    Vector3 vector = SessionState.GetVector3("SimulationState" + particleSystem.GetInstanceID(), Vector3.zero);
                    if (particleSystem.GetInstanceID() == (int)vector.x)
                    {
                        float z = vector.z;
                        if (z > 0f)
                        {
                            ParticleSystemEditorUtils.playbackTime = z;
                            ParticleSystemEditorUtils.PerformCompleteResimulation();
                        }
                    }
                    if (ParticleEffectUI.m_MainPlaybackSystem != particleSystem)
                    {
                        this.Play();
                    }
                }
            }
            ParticleEffectUI.m_MainPlaybackSystem = particleSystem;
            return(flag3);
        }
Beispiel #18
0
        private void HandleKeyboardShortcuts()
        {
            Event evt = Event.current;

            if (evt.type == EventType.KeyDown)
            {
                int changeTime = 0;
                if (evt.keyCode == ((Event)kPlay).keyCode)
                {
                    if (EditorApplication.isPlaying)
                    {
                        // If world is playing Pause is not handled, just restart instead
                        Stop();
                        Play();
                    }
                    else
                    {
                        // In Edit mode we have full play/pause functionality
                        if (!ParticleSystemEditorUtils.playbackIsPlaying)
                        {
                            Play();
                        }
                        else
                        {
                            Pause();
                        }
                    }
                    evt.Use();
                }
                else if (evt.keyCode == ((Event)kStop).keyCode)
                {
                    Stop();
                    evt.Use();
                }
                else if (evt.keyCode == ((Event)kReverse).keyCode)
                {
                    changeTime = -1;
                }
                else if (evt.keyCode == ((Event)kForward).keyCode)
                {
                    changeTime = 1;
                }

                if (changeTime != 0)
                {
                    ParticleSystemEditorUtils.playbackIsScrubbing = true;
                    float previewSpeed = ParticleSystemEditorUtils.simulationSpeed;
                    float timeDiff     = (evt.shift ? 3f : 1f) * m_TimeHelper.deltaTime * (changeTime > 0 ? 3f : -3f);
                    ParticleSystemEditorUtils.playbackTime = Mathf.Max(0f, ParticleSystemEditorUtils.playbackTime + timeDiff * (previewSpeed));

                    foreach (ParticleSystem ps in m_SelectedParticleSystems)
                    {
                        ParticleSystem root = ParticleSystemEditorUtils.GetRoot(ps);
                        if (root.isStopped)
                        {
                            root.Play();
                            root.Pause();
                        }
                    }

                    ParticleSystemEditorUtils.PerformCompleteResimulation();
                    evt.Use();
                }
            }

            if (evt.type == EventType.KeyUp)
            {
                if (evt.keyCode == ((Event)kReverse).keyCode || evt.keyCode == ((Event)kForward).keyCode)
                {
                    ParticleSystemEditorUtils.playbackIsScrubbing = false;
                }
            }
        }
Beispiel #19
0
            public override void OnToolGUI(EditorWindow window)
            {
                var firstTransform = SyncScenePlanes();

                if (m_ScenePlanes.Count == 0)
                {
                    return;
                }

                // Clear invalid selection (ie when selecting other system)
                if (s_SelectedTransform != null)
                {
                    if (!m_ScenePlanes.Contains(s_SelectedTransform))
                    {
                        s_SelectedTransform = null;
                    }
                }

                // Always try to select first collider if no selection exists
                if (s_SelectedTransform == null)
                {
                    s_SelectedTransform = firstTransform;
                }

                Event evt = Event.current;

                Color origCol   = Handles.color;
                Color col       = new Color(1, 1, 1, 0.5F);
                bool  isPlaying = EditorApplication.isPlaying;

                foreach (var transform in m_ScenePlanes)
                {
                    Vector3    position           = transform.position;
                    Quaternion rotation           = transform.rotation;
                    Vector3    right              = rotation * Vector3.right;
                    Vector3    up                 = rotation * Vector3.up;
                    Vector3    forward            = rotation * Vector3.forward;
                    bool       isPlayingAndStatic = isPlaying && transform.gameObject.isStatic;

                    if (ReferenceEquals(s_SelectedTransform, transform))
                    {
                        EditorGUI.BeginChangeCheck();
                        var newPosition = transform.position;
                        var newRotation = transform.rotation;

                        using (new EditorGUI.DisabledScope(isPlayingAndStatic))
                        {
                            if (isPlayingAndStatic)
                            {
                                Handles.ShowSceneViewLabel(position, Handles.s_StaticLabel);
                            }
                            Handles.TransformHandle(ref newPosition, ref newRotation);
                        }
                        if (EditorGUI.EndChangeCheck())
                        {
                            Undo.RecordObject(transform, s_UndoCollisionPlaneString);
                            transform.position = newPosition;
                            transform.rotation = newRotation;
                            ParticleSystemEditorUtils.PerformCompleteResimulation();
                        }
                    }
                    else
                    {
                        float handleSize = HandleUtility.GetHandleSize(position) * 0.6f;

                        EventType oldEventType = evt.type;

                        // we want ignored mouse up events to check for dragging off of scene view
                        if (evt.type == EventType.Ignore && evt.rawType == EventType.MouseUp)
                        {
                            oldEventType = evt.rawType;
                        }

                        Handles.FreeMoveHandle(position, handleSize, Vector3.zero, Handles.RectangleHandleCap);

                        // Detect selected plane (similar to TreeEditor)
                        if (oldEventType == EventType.MouseDown && evt.type == EventType.Used)
                        {
                            s_SelectedTransform   = transform;
                            oldEventType          = EventType.Used;
                            GUIUtility.hotControl = 0; // Reset hot control or the FreeMoveHandle will prevent input to the new Handles. (case 873514)
                        }
                    }

                    Handles.color = col;
                    Color color = Handles.s_ColliderHandleColor * 0.9f;
                    if (isPlayingAndStatic)
                    {
                        color.a *= 0.2f;
                    }

                    if (m_PlaneVisualizationType == PlaneVizType.Grid)
                    {
                        DrawGrid(position, right, forward, up, color);
                    }
                    else
                    {
                        DrawSolidPlane(position, rotation, color, Color.yellow);
                    }
                }

                Handles.color = origCol;
            }
        public override void OnSceneGUI(ParticleSystem s, InitialModuleUI initial)
        {
            Event     current   = Event.current;
            EventType eventType = current.type;

            if (current.type == EventType.Ignore && current.rawType == EventType.MouseUp)
            {
                eventType = current.rawType;
            }
            Color color1 = Handles.color;

            Handles.color = new Color(1f, 1f, 1f, 0.5f);
            if (this.m_Type.intValue == 0)
            {
                for (int index = 0; index < this.m_ShownPlanes.Length; ++index)
                {
                    Object objectReferenceValue = this.m_ShownPlanes[index].objectReferenceValue;
                    if (objectReferenceValue != (Object)null)
                    {
                        Transform transform = objectReferenceValue as Transform;
                        if ((Object)transform != (Object)null)
                        {
                            Vector3    position = transform.position;
                            Quaternion rotation = transform.rotation;
                            Vector3    axis1    = rotation * Vector3.right;
                            Vector3    normal   = rotation * Vector3.up;
                            Vector3    axis2    = rotation * Vector3.forward;
                            if (object.ReferenceEquals((object)CollisionModuleUI.m_SelectedTransform, (object)transform))
                            {
                                Tools.s_Hidden = true;
                                EditorGUI.BeginChangeCheck();
                                if (Tools.current == Tool.Move)
                                {
                                    transform.position = Handles.PositionHandle(position, rotation);
                                }
                                else if (Tools.current == Tool.Rotate)
                                {
                                    transform.rotation = Handles.RotationHandle(rotation, position);
                                }
                                if (EditorGUI.EndChangeCheck())
                                {
                                    if (this.m_PlaneVisualizationType == CollisionModuleUI.PlaneVizType.Solid)
                                    {
                                        GameObject plane = ParticleEffectUtils.GetPlane(index);
                                        plane.transform.position   = position;
                                        plane.transform.rotation   = rotation;
                                        plane.transform.localScale = new Vector3(this.m_ScaleGrid, this.m_ScaleGrid, this.m_ScaleGrid);
                                    }
                                    ParticleSystemEditorUtils.PerformCompleteResimulation();
                                }
                            }
                            else
                            {
                                int   keyboardControl = GUIUtility.keyboardControl;
                                float size            = HandleUtility.GetHandleSize(position) * 0.06f;
                                Handles.FreeMoveHandle(position, Quaternion.identity, size, Vector3.zero, new Handles.DrawCapFunction(Handles.RectangleCap));
                                if (eventType == EventType.MouseDown && current.type == EventType.Used && keyboardControl != GUIUtility.keyboardControl)
                                {
                                    CollisionModuleUI.m_SelectedTransform = transform;
                                    eventType = EventType.Used;
                                }
                            }
                            if (this.m_PlaneVisualizationType == CollisionModuleUI.PlaneVizType.Grid)
                            {
                                Color color2 = Handles.s_ColliderHandleColor * 0.9f;
                                if (!this.enabled)
                                {
                                    color2 = new Color(0.7f, 0.7f, 0.7f, 0.7f);
                                }
                                this.DrawGrid(position, axis1, axis2, normal, color2, index);
                            }
                            else
                            {
                                this.DrawSolidPlane(position, rotation, index);
                            }
                        }
                        else
                        {
                            Debug.LogError((object)("Not a transform: " + (object)objectReferenceValue.GetType()));
                        }
                    }
                }
            }
            Handles.color = color1;
        }
Beispiel #21
0
        internal void PlayBackTimeGUI()
        {
            EventType type       = Event.current.type;
            int       hotControl = GUIUtility.hotControl;
            string    kFloatFieldFormatString = EditorGUI.kFloatFieldFormatString;

            EditorGUIUtility.labelWidth       = 110f;
            EditorGUI.kFloatFieldFormatString = ParticleEffectUI.s_Texts.secondsFloatFieldFormatString;
            ParticleSystemEditorUtils.editorSimulationSpeed = Mathf.Clamp(EditorGUILayout.FloatField(ParticleEffectUI.s_Texts.previewSpeed, ParticleSystemEditorUtils.editorSimulationSpeed, new GUILayoutOption[0]), 0f, 10f);
            EditorGUI.kFloatFieldFormatString = kFloatFieldFormatString;
            EditorGUI.BeginChangeCheck();
            EditorGUI.kFloatFieldFormatString = ParticleEffectUI.s_Texts.secondsFloatFieldFormatString;
            float num = EditorGUILayout.FloatField(ParticleEffectUI.s_Texts.previewTime, ParticleSystemEditorUtils.editorPlaybackTime, new GUILayoutOption[0]);

            EditorGUI.kFloatFieldFormatString = kFloatFieldFormatString;
            if (EditorGUI.EndChangeCheck())
            {
                if (type == EventType.MouseDrag)
                {
                    ParticleSystemEditorUtils.editorIsScrubbing = true;
                    float editorSimulationSpeed = ParticleSystemEditorUtils.editorSimulationSpeed;
                    float editorPlaybackTime    = ParticleSystemEditorUtils.editorPlaybackTime;
                    float num2 = num - editorPlaybackTime;
                    num = editorPlaybackTime + num2 * (0.05f * editorSimulationSpeed);
                }
                num = Mathf.Max(num, 0f);
                ParticleSystemEditorUtils.editorPlaybackTime = num;
                foreach (ParticleSystem current in this.m_SelectedParticleSystems)
                {
                    ParticleSystem root = ParticleSystemEditorUtils.GetRoot(current);
                    if (root.isStopped)
                    {
                        root.Play();
                        root.Pause();
                    }
                }
                ParticleSystemEditorUtils.PerformCompleteResimulation();
            }
            if (type == EventType.MouseDown && GUIUtility.hotControl != hotControl)
            {
                this.m_IsDraggingTimeHotControlID           = GUIUtility.hotControl;
                ParticleSystemEditorUtils.editorIsScrubbing = true;
            }
            if (this.m_IsDraggingTimeHotControlID != -1 && GUIUtility.hotControl != this.m_IsDraggingTimeHotControlID)
            {
                this.m_IsDraggingTimeHotControlID           = -1;
                ParticleSystemEditorUtils.editorIsScrubbing = false;
            }
            int   num3 = 0;
            float num4 = 0f;
            float num5 = float.PositiveInfinity;

            foreach (ParticleSystem current2 in this.m_SelectedParticleSystems)
            {
                current2.CalculateEffectUIData(ref num3, ref num4, ref num5);
            }
            EditorGUILayout.LabelField(ParticleEffectUI.s_Texts.particleCount, GUIContent.Temp(num3.ToString()), new GUILayoutOption[0]);
            bool flag = false;
            int  num6 = 0;

            foreach (ParticleSystem current3 in this.m_SelectedParticleSystems)
            {
                int num7 = 0;
                if (current3.CalculateEffectUISubEmitterData(ref num7, ref num4, ref num5))
                {
                    flag  = true;
                    num6 += num7;
                }
            }
            if (flag)
            {
                EditorGUILayout.LabelField(ParticleEffectUI.s_Texts.subEmitterParticleCount, GUIContent.Temp(num6.ToString()), new GUILayoutOption[0]);
            }
            if (num4 >= num5)
            {
                EditorGUILayout.LabelField(ParticleEffectUI.s_Texts.particleSpeeds, GUIContent.Temp(num5.ToString(ParticleEffectUI.s_Texts.speedFloatFieldFormatString) + " - " + num4.ToString(ParticleEffectUI.s_Texts.speedFloatFieldFormatString)), new GUILayoutOption[0]);
            }
            else
            {
                EditorGUILayout.LabelField(ParticleEffectUI.s_Texts.particleSpeeds, GUIContent.Temp("0.0 - 0.0"), new GUILayoutOption[0]);
            }
            EditorGUIUtility.labelWidth = 0f;
        }
Beispiel #22
0
        // Should be called often to ensure we catch if selected Particle System is dragged in/out of root hierarchy
        public bool InitializeIfNeeded(IEnumerable <ParticleSystem> systems)
        {
            bool anyAdded = false;

            ParticleSystem[] allSystems     = systems.ToArray();
            bool             usingMultiEdit = (allSystems.Count() > 1);

            bool           initializeRequired = false;
            ParticleSystem mainSystem         = null;

            foreach (ParticleSystem shuriken in allSystems)
            {
                ParticleSystem[] shurikens;
                if (!usingMultiEdit)
                {
                    ParticleSystem root = ParticleSystemEditorUtils.GetRoot(shuriken);
                    if (root == null)
                    {
                        continue;
                    }

                    shurikens  = GetParticleSystems(root);
                    mainSystem = root;

                    // Check if we need to re-initialize?
                    if (m_SelectedParticleSystems != null && m_SelectedParticleSystems.Count > 0)
                    {
                        if (root == ParticleSystemEditorUtils.GetRoot(m_SelectedParticleSystems[0]))
                        {
                            if (m_ParticleSystemCurveEditor != null && m_Emitters != null && shurikens.Length == m_Emitters.Length && shuriken.gameObject.activeInHierarchy == m_EmittersActiveInHierarchy)
                            {
                                m_SelectedParticleSystems = new List <ParticleSystem>();
                                m_SelectedParticleSystems.Add(shuriken);

                                if (IsShowOnlySelectedMode())
                                {
                                    RefreshShowOnlySelected(); // always refresh
                                }
                                continue;
                            }
                        }
                    }
                }
                else
                {
                    // in multi-edit mode, we explicitly choose the systems to edit, so don't automatically add child systems or search for the root
                    shurikens  = new ParticleSystem[] { shuriken };
                    mainSystem = shuriken;
                }

                // Cleanup before initializing
                if (m_ParticleSystemCurveEditor != null)
                {
                    Clear();
                }

                // Now initialize
                initializeRequired = true;
                if (!anyAdded)
                {
                    m_SelectedParticleSystems = new List <ParticleSystem>();
                    anyAdded = true;
                }
                m_SelectedParticleSystems.Add(shuriken);

                // Single edit emitter setup
                if (!usingMultiEdit)
                {
                    // Init CurveEditor before modules (they may add curves during construction)
                    m_ParticleSystemCurveEditor = new ParticleSystemCurveEditor();
                    m_ParticleSystemCurveEditor.Init();

                    int numEmitters = shurikens.Length;
                    if (numEmitters > 0)
                    {
                        m_Emitters = new ParticleSystemUI[numEmitters];

                        for (int i = 0; i < numEmitters; ++i)
                        {
                            m_Emitters[i] = new ParticleSystemUI();
                            m_Emitters[i].Init(this, new ParticleSystem[] { shurikens[i] });
                        }

                        m_EmittersActiveInHierarchy = shuriken.gameObject.activeInHierarchy;
                    }
                }
            }

            if (initializeRequired)
            {
                // Multi-edit emitter setup
                if (usingMultiEdit)
                {
                    // Init CurveEditor before modules (they may add curves during construction)
                    m_ParticleSystemCurveEditor = new ParticleSystemCurveEditor();
                    m_ParticleSystemCurveEditor.Init();

                    int numEmitters = m_SelectedParticleSystems.Count;
                    if (numEmitters > 0)
                    {
                        m_Emitters    = new ParticleSystemUI[1];
                        m_Emitters[0] = new ParticleSystemUI();
                        m_Emitters[0].Init(this, m_SelectedParticleSystems.ToArray());
                        m_EmittersActiveInHierarchy = m_SelectedParticleSystems[0].gameObject.activeInHierarchy;
                    }
                }

                // Allow modules to validate their state (the user can have moved emitters around in the hierarchy)
                foreach (ParticleSystemUI e in m_Emitters)
                {
                    foreach (ModuleUI m in e.m_Modules)
                    {
                        if (m != null)
                        {
                            m.Validate();
                        }
                    }
                }

                // Sync to state
                if (GetAllModulesVisible())
                {
                    SetAllModulesVisible(true);
                }

                m_EmitterAreaWidth      = EditorPrefs.GetFloat("ParticleSystemEmitterAreaWidth", k_MinEmitterAreaSize.x);
                m_CurveEditorAreaHeight = EditorPrefs.GetFloat("ParticleSystemCurveEditorAreaHeight", k_MinCurveAreaSize.y);

                // For now only allow ShowOnlySelectedMode for ParticleSystemWindow
                SetShowOnlySelectedMode((m_Owner is ParticleSystemWindow) ? SessionState.GetBool(k_ShowSelectedId + mainSystem.GetInstanceID(), false) : false);

                m_EmitterAreaScrollPos.x = SessionState.GetFloat("CurrentEmitterAreaScroll", 0.0f);

                if (ShouldManagePlaybackState(mainSystem))
                {
                    // Restore lastPlayBackTime if available in session cache
                    Vector3 simulationState = SessionState.GetVector3(k_SimulationStateId + mainSystem.GetInstanceID(), Vector3.zero);
                    if (mainSystem.GetInstanceID() == (int)simulationState.x)
                    {
                        float lastPlayBackTime = simulationState.z;
                        if (lastPlayBackTime > 0f)
                        {
                            ParticleSystemEditorUtils.playbackTime = lastPlayBackTime;
                            ParticleSystemEditorUtils.PerformCompleteResimulation();
                        }
                    }

                    // Play when selecting a new particle effect
                    if (m_MainPlaybackSystem != mainSystem)
                    {
                        Play();
                    }
                }
            }

            m_MainPlaybackSystem = mainSystem;

            return(initializeRequired);
        }