private bool ValidateSubemitter(ParticleSystem subEmitter)
{
if (subEmitter == null)
{
return(false);
}
ParticleSystem root = ParticleSystemEditorUtils.GetRoot(m_ParticleSystemUI.m_ParticleSystems[0]);
if (root.gameObject.activeInHierarchy && !subEmitter.gameObject.activeInHierarchy)
{
string kReparentText = "The assigned sub emitter is part of a prefab and can therefore not be assigned.";
EditorUtility.DisplayDialog("Invalid Sub Emitter", kReparentText, "Ok");
return(false);
}
if (!root.gameObject.activeInHierarchy && subEmitter.gameObject.activeInHierarchy)
{
string kReparentText = "The assigned sub emitter is part of a scene object and can therefore not be assigned to a prefab.";
EditorUtility.DisplayDialog("Invalid Sub Emitter", kReparentText, "Ok");
return(false);
}
return(true);
}
public void Clear()
{
ParticleSystem root = ParticleSystemEditorUtils.GetRoot(this.m_SelectedParticleSystems[0]);
if (this.ShouldManagePlaybackState(root))
{
if (root != null)
{
ParticleEffectUI.PlayState playState;
if (this.IsPlaying())
{
playState = ParticleEffectUI.PlayState.Playing;
}
else if (this.IsPaused())
{
playState = ParticleEffectUI.PlayState.Paused;
}
else
{
playState = ParticleEffectUI.PlayState.Stopped;
}
int instanceID = root.GetInstanceID();
SessionState.SetVector3("SimulationState" + instanceID, new Vector3((float)instanceID, (float)playState, ParticleSystemEditorUtils.playbackTime));
}
}
this.m_ParticleSystemCurveEditor.OnDisable();
Tools.s_Hidden = false;
if (root != null)
{
SessionState.SetBool("ShowSelected" + root.GetInstanceID(), this.m_ShowOnlySelectedMode);
}
this.SetShowOnlySelectedMode(false);
GameView.RepaintAll();
SceneView.RepaintAll();
}
internal static void StopEffect()
{
bool clear = true;
bool stop = true;
ParticleSystemEditorUtils.StopEffect(stop, clear);
}
private void MultiParticleSystemGUI(bool verticalLayout)
{
ParticleSystem root = ParticleSystemEditorUtils.GetRoot(this.m_SelectedParticleSystem);
GUILayout.BeginVertical(ParticleSystemStyles.Get().effectBgStyle, new GUILayoutOption[0]);
this.m_EmitterAreaScrollPos = EditorGUILayout.BeginScrollView(this.m_EmitterAreaScrollPos, new GUILayoutOption[0]);
Rect position = EditorGUILayout.BeginVertical(new GUILayoutOption[0]);
this.m_EmitterAreaScrollPos -= EditorGUI.MouseDeltaReader(position, Event.current.alt);
GUILayout.Space(3f);
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
GUILayout.Space(3f);
Color color = GUI.color;
bool flag = Event.current.type == EventType.Repaint;
bool flag2 = this.IsShowOnlySelectedMode();
List <ParticleSystemUI> selectedParticleSystemUIs = this.GetSelectedParticleSystemUIs();
for (int i = 0; i < this.m_Emitters.Length; i++)
{
if (i != 0)
{
GUILayout.Space(ModuleUI.k_SpaceBetweenModules);
}
bool flag3 = selectedParticleSystemUIs.Contains(this.m_Emitters[i]);
ModuleUI particleSystemRendererModuleUI = this.m_Emitters[i].GetParticleSystemRendererModuleUI();
if (flag && particleSystemRendererModuleUI != null && !particleSystemRendererModuleUI.enabled)
{
GUI.color = ParticleEffectUI.GetDisabledColor();
}
if (flag && flag2 && !flag3)
{
GUI.color = ParticleEffectUI.GetDisabledColor();
}
Rect rect = EditorGUILayout.BeginVertical(new GUILayoutOption[0]);
if (flag && flag3 && this.m_Emitters.Length > 1)
{
this.DrawSelectionMarker(rect);
}
this.m_Emitters[i].OnGUI(root, ModuleUI.k_CompactFixedModuleWidth, true);
EditorGUILayout.EndVertical();
GUI.color = color;
}
GUILayout.Space(5f);
if (GUILayout.Button(ParticleEffectUI.s_Texts.addParticleSystem, "OL Plus", new GUILayoutOption[]
{
GUILayout.Width(20f)
}))
{
this.CreateParticleSystem(root, SubModuleUI.SubEmitterType.None);
}
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
GUILayout.Space(4f);
this.m_EmitterAreaScrollPos -= EditorGUI.MouseDeltaReader(position, true);
GUILayout.FlexibleSpace();
EditorGUILayout.EndVertical();
EditorGUILayout.EndScrollView();
GUILayout.EndVertical();
this.HandleKeyboardShortcuts(root);
}
internal void Stop()
{
ParticleSystemEditorUtils.editorIsScrubbing = false;
ParticleSystemEditorUtils.editorPlaybackTime = 0f;
ParticleSystemEditorUtils.StopEffect();
this.m_Owner.Repaint();
}
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();
}
}
private void ShowBounds(ParticleSystem ps)
{
if (ps.particleCount > 0)
{
ParticleSystemRenderer particleSystemRenderer = ps.GetComponent <ParticleSystemRenderer>();
var oldCol = Handles.color;
Handles.color = Color.yellow;
var worldBounds = particleSystemRenderer.bounds;
Handles.DrawWireCube(worldBounds.center, worldBounds.size);
Handles.color = oldCol;
}
// In multi-edit, children are not stored, so render thir bounds manually
if (multiEdit)
{
ParticleSystem[] children = ps.transform.GetComponentsInChildren <ParticleSystem>();
foreach (ParticleSystem child in children)
{
if (child != ps)
{
bool alreadySelected = m_ParticleSystems.FirstOrDefault(o => ParticleSystemEditorUtils.GetRoot(o) == child) != null;
if (!alreadySelected)
{
ShowBounds(child);
}
}
}
}
}
public bool ValidateParticleSystemProperty(SerializedProperty shurikenProperty)
{
bool result;
if (shurikenProperty != null)
{
ParticleSystem particleSystem = shurikenProperty.objectReferenceValue as ParticleSystem;
if (particleSystem != null)
{
if (this.GetParticleSystemUIForParticleSystem(particleSystem) == null)
{
EditorUtility.DisplayDialog("ParticleSystem Warning", string.Concat(new string[]
{
"The SubEmitter module cannot reference a ParticleSystem that is not a child of the root ParticleSystem.\n\nThe ParticleSystem '",
particleSystem.name,
"' must be a child of the ParticleSystem '",
ParticleSystemEditorUtils.GetRoot(this.m_SelectedParticleSystem).name,
"'."
}), "Ok");
shurikenProperty.objectReferenceValue = null;
result = false;
return(result);
}
}
}
result = true;
return(result);
}
private bool ValidateSubemitter(ParticleSystem subEmitter)
{
bool result;
if (subEmitter == null)
{
result = false;
}
else
{
ParticleSystem root = ParticleSystemEditorUtils.GetRoot(this.m_ParticleSystemUI.m_ParticleSystems[0]);
if (root.gameObject.activeInHierarchy && !subEmitter.gameObject.activeInHierarchy)
{
string message = string.Format("The assigned sub emitter is part of a prefab and can therefore not be assigned.", new object[0]);
EditorUtility.DisplayDialog("Invalid Sub Emitter", message, "Ok");
result = false;
}
else if (!root.gameObject.activeInHierarchy && subEmitter.gameObject.activeInHierarchy)
{
string message2 = string.Format("The assigned sub emitter is part of a scene object and can therefore not be assigned to a prefab.", new object[0]);
EditorUtility.DisplayDialog("Invalid Sub Emitter", message2, "Ok");
result = false;
}
else
{
result = true;
}
}
return(result);
}
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);
}
internal static bool IsChild(ParticleSystem subEmitter, ParticleSystem root)
{
if ((Object)subEmitter == (Object)null || (Object)root == (Object)null)
{
return(false);
}
return((Object)ParticleSystemEditorUtils.GetRoot(subEmitter) == (Object)root);
}
internal static bool IsChild(ParticleSystem subEmitter, ParticleSystem root)
{
if ((subEmitter == null) || (root == null))
{
return(false);
}
return(ParticleSystemEditorUtils.GetRoot(subEmitter) == root);
}
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;
}
}
internal static bool IsChild(ParticleSystem subEmitter, ParticleSystem root)
{
if (subEmitter == null || root == null)
{
return false;
}
ParticleSystem root2 = ParticleSystemEditorUtils.GetRoot(subEmitter);
return root2 == root;
}
internal void PlayStopGUI()
{
if (ParticleEffectUI.s_Texts == null)
{
ParticleEffectUI.s_Texts = new ParticleEffectUI.Texts();
}
ParticleSystem root = ParticleSystemEditorUtils.GetRoot(this.m_SelectedParticleSystem);
Event current = Event.current;
if (current.type == EventType.Layout)
{
this.m_TimeHelper.Update();
}
if (!EditorApplication.isPlaying)
{
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
bool flag = ParticleSystemEditorUtils.editorIsPlaying && !ParticleSystemEditorUtils.editorIsPaused;
if (GUILayout.Button((!flag) ? ParticleEffectUI.s_Texts.play : ParticleEffectUI.s_Texts.pause, "ButtonLeft", new GUILayoutOption[0]))
{
if (flag)
{
this.Pause();
}
else
{
this.Play();
}
}
if (GUILayout.Button(ParticleEffectUI.s_Texts.stop, "ButtonRight", new GUILayoutOption[0]))
{
this.Stop();
}
GUILayout.EndHorizontal();
string kFloatFieldFormatString = EditorGUI.kFloatFieldFormatString;
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;
this.PlayBackTimeGUI(root);
}
else
{
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
if (GUILayout.Button(ParticleEffectUI.s_Texts.play, new GUILayoutOption[0]))
{
this.Stop();
this.Play();
}
if (GUILayout.Button(ParticleEffectUI.s_Texts.stop, new GUILayoutOption[0]))
{
this.Stop();
}
GUILayout.EndHorizontal();
}
this.HandleKeyboardShortcuts(root);
}
internal void Pause()
{
ParticleSystem root = ParticleSystemEditorUtils.GetRoot(this.m_SelectedParticleSystem);
if (root)
{
root.Pause();
ParticleSystemEditorUtils.editorIsScrubbing = true;
this.m_Owner.Repaint();
}
}
internal void Play()
{
ParticleSystem root = ParticleSystemEditorUtils.GetRoot(this.m_SelectedParticleSystem);
if (root != null)
{
root.Play();
ParticleSystemEditorUtils.editorIsScrubbing = false;
this.m_Owner.Repaint();
}
}
private bool CheckIfChild(Object subEmitter)
{
ParticleSystem root = ParticleSystemEditorUtils.GetRoot(m_ParticleSystemUI.m_ParticleSystems[0]);
ParticleSystem ps = subEmitter as ParticleSystem;
if (IsChild(ps, root))
{
return(true);
}
if (PrefabUtility.IsPartOfAnyPrefab(ps.gameObject) && !PrefabUtility.IsAnyPrefabInstanceRoot(ps.gameObject))
{
string kPrefabReparentWarn = $"The assigned sub emitter is not part of the current effect because it is not a child of the current root Particle System GameObject: '{root.gameObject.name}'. The Particle System cannot be moved because it is a child of a Prefab instance.";
EditorUtility.WarnPrefab(ps.gameObject, "Reparent GameObjects", kPrefabReparentWarn, "OK");
return(false);
}
string kReparentText = string.Format("The assigned sub emitter is not a child of the current root particle system GameObject: '{0}' and is therefore NOT considered a part of the current effect. Do you want to reparent it?", root.gameObject.name);
if (EditorUtility.DisplayDialog(
"Reparent GameObjects",
kReparentText,
"Yes, Reparent",
"No, Remove"))
{
if (EditorUtility.IsPersistent(subEmitter))
{
var newGo = Object.Instantiate(subEmitter) as GameObject;
if (newGo != null)
{
newGo.transform.parent = m_ParticleSystemUI.m_ParticleSystems[0].transform;
newGo.transform.localPosition = Vector3.zero;
newGo.transform.localRotation = Quaternion.identity;
}
}
else
{
if (ps != null)
{
Undo.SetTransformParent(ps.gameObject.transform.transform, m_ParticleSystemUI.m_ParticleSystems[0].transform, "Reparent sub emitter");
}
}
return(true);
}
else if (ps != null)
{
// Clear sub-emitters that have been deselected, to avoid having their particles left paused in the Scene View (case 946999)
ps.Clear(true);
}
return(false);
}
internal void Pause()
{
ParticleSystem root = ParticleSystemEditorUtils.GetRoot(this.m_SelectedParticleSystem);
if (!(bool)((UnityEngine.Object)root))
{
return;
}
root.Pause();
ParticleSystemEditorUtils.editorIsScrubbing = true;
this.m_Owner.Repaint();
}
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]);
}
}
public void OnSceneViewGUI()
{
ParticleSystem root = ParticleSystemEditorUtils.GetRoot(m_SelectedParticleSystems[0]);
if (root && root.gameObject.activeInHierarchy)
{
SceneViewOverlay.Window(ParticleSystemInspector.playBackTitle, SceneViewGUICallback, (int)SceneViewOverlay.Ordering.ParticleEffect, SceneViewOverlay.WindowDisplayOption.OneWindowPerTitle);
}
foreach (ParticleSystemUI e in m_Emitters)
{
e.OnSceneViewGUI();
}
}
public void OnSceneViewGUI()
{
ParticleSystem root = ParticleSystemEditorUtils.GetRoot(this.m_SelectedParticleSystems[0]);
if (root && root.gameObject.activeInHierarchy)
{
SceneViewOverlay.Window(ParticleSystemInspector.playBackTitle, new SceneViewOverlay.WindowFunction(this.SceneViewGUICallback), 600, SceneViewOverlay.WindowDisplayOption.OneWindowPerTitle);
}
ParticleSystemUI[] emitters = this.m_Emitters;
for (int i = 0; i < emitters.Length; i++)
{
ParticleSystemUI particleSystemUI = emitters[i];
particleSystemUI.OnSceneViewGUI();
}
}
internal static bool IsChild(ParticleSystem subEmitter, ParticleSystem root)
{
bool result;
if (subEmitter == null || root == null)
{
result = false;
}
else
{
ParticleSystem root2 = ParticleSystemEditorUtils.GetRoot(subEmitter);
result = (root2 == root);
}
return(result);
}
private void Update()
{
if (this.m_CheckObjectIndex >= 0)
{
if (!ObjectSelector.isVisible)
{
SerializedProperty arrayElementAtIndex = this.m_SubEmitters.GetArrayElementAtIndex(this.m_CheckObjectIndex);
SerializedProperty serializedProperty = arrayElementAtIndex.FindPropertyRelative("emitter");
UnityEngine.Object objectReferenceValue = serializedProperty.objectReferenceValue;
ParticleSystem particleSystem = objectReferenceValue as ParticleSystem;
if (particleSystem != null)
{
bool flag = true;
if (this.ValidateSubemitter(particleSystem))
{
string text = ParticleSystemEditorUtils.CheckCircularReferences(particleSystem);
if (text.Length == 0)
{
if (!this.CheckIfChild(objectReferenceValue))
{
flag = false;
}
}
else
{
string message = string.Format("'{0}' could not be assigned as subemitter on '{1}' due to circular referencing!\nBacktrace: {2} \n\nReference will be removed.", particleSystem.gameObject.name, this.m_ParticleSystemUI.m_ParticleSystem.gameObject.name, text);
EditorUtility.DisplayDialog("Circular References Detected", message, "Ok");
flag = false;
}
}
else
{
flag = false;
}
if (!flag)
{
serializedProperty.objectReferenceValue = null;
this.m_ParticleSystemUI.ApplyProperties();
this.m_ParticleSystemUI.m_ParticleEffectUI.m_Owner.Repaint();
}
}
this.m_CheckObjectIndex = -1;
EditorApplication.update = (EditorApplication.CallbackFunction)Delegate.Remove(EditorApplication.update, new EditorApplication.CallbackFunction(this.Update));
}
}
}
private void Update()
{
if ((this.m_CheckObjectIndex >= 0) && !ObjectSelector.isVisible)
{
SerializedProperty property2 = this.m_SubEmitters.GetArrayElementAtIndex(this.m_CheckObjectIndex).FindPropertyRelative("emitter");
UnityEngine.Object objectReferenceValue = property2.objectReferenceValue;
ParticleSystem subEmitter = objectReferenceValue as ParticleSystem;
if (subEmitter != null)
{
bool flag = true;
if (this.ValidateSubemitter(subEmitter))
{
string str = ParticleSystemEditorUtils.CheckCircularReferences(subEmitter);
if (str.Length == 0)
{
if (!this.CheckIfChild(objectReferenceValue))
{
flag = false;
}
}
else
{
string message = $"'{subEmitter.gameObject.name}' could not be assigned as subemitter on '{base.m_ParticleSystemUI.m_ParticleSystem.gameObject.name}' due to circular referencing!
Backtrace: {str}
Reference will be removed.";
EditorUtility.DisplayDialog("Circular References Detected", message, "Ok");
flag = false;
}
}
else
{
flag = false;
}
if (!flag)
{
property2.objectReferenceValue = null;
base.m_ParticleSystemUI.ApplyProperties();
base.m_ParticleSystemUI.m_ParticleEffectUI.m_Owner.Repaint();
}
}
this.m_CheckObjectIndex = -1;
EditorApplication.update = (EditorApplication.CallbackFunction)Delegate.Remove(EditorApplication.update, new EditorApplication.CallbackFunction(this.Update));
}
}
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]);
}
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();
}
}
