private static ModuleUI[] CreateUIModules(ParticleSystemUI e, SerializedObject so)
{
int num = 0;
ModuleUI[] euiArray1 = new ModuleUI[0x16];
euiArray1[0] = new InitialModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[1] = new EmissionModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[2] = new ShapeModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[3] = new VelocityModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[4] = new ClampVelocityModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[5] = new InheritVelocityModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[6] = new ForceModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[7] = new ColorModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[8] = new ColorByVelocityModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[9] = new SizeModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[10] = new SizeByVelocityModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[11] = new RotationModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[12] = new RotationByVelocityModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[13] = new ExternalForcesModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[14] = new NoiseModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[15] = new CollisionModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[0x10] = new TriggerModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[0x11] = new SubModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[0x12] = new UVModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[0x13] = new LightsModuleUI(e, so, s_ModuleNames[num++]);
euiArray1[20] = new TrailModuleUI(e, so, s_ModuleNames[num++]);
return euiArray1;
}
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;
}
override public void OnInspectorGUI(InitialModuleUI initial)
{
var renderer = serializedObject.targetObject as Renderer;
EditorGUI.BeginChangeCheck();
RenderMode renderMode = (RenderMode)GUIPopup(s_Texts.renderMode, m_RenderMode, s_Texts.particleTypes);
bool renderModeChanged = EditorGUI.EndChangeCheck();
if (!m_RenderMode.hasMultipleDifferentValues)
{
if (renderMode == RenderMode.Mesh)
{
EditorGUI.indentLevel++;
DoListOfMeshesGUI();
EditorGUI.indentLevel--;
if (renderModeChanged && m_Meshes[0].objectReferenceInstanceIDValue == 0 && !m_Meshes[0].hasMultipleDifferentValues)
{
m_Meshes[0].objectReferenceValue = Resources.GetBuiltinResource(typeof(Mesh), "Cube.fbx");
}
}
else if (renderMode == RenderMode.Stretch3D)
{
EditorGUI.indentLevel++;
GUIFloat(s_Texts.cameraSpeedScale, m_CameraVelocityScale);
GUIFloat(s_Texts.speedScale, m_VelocityScale);
GUIFloat(s_Texts.lengthScale, m_LengthScale);
GUIToggle(s_Texts.freeformStretching, m_FreeformStretching);
if (m_FreeformStretching.boolValue && !m_FreeformStretching.hasMultipleDifferentValues)
{
GUIToggle(s_Texts.rotateWithStretchDirection, m_RotateWithStretchDirection);
}
else
{
using (new EditorGUI.DisabledScope(true))
{
GUIToggle(s_Texts.rotateWithStretchDirection, true);
}
}
EditorGUI.indentLevel--;
}
if (renderMode != RenderMode.None)
{
if (renderMode != RenderMode.Mesh)
{
GUIFloat(s_Texts.normalDirection, m_NormalDirection);
}
}
}
if (renderMode != RenderMode.None)
{
if (m_Material != null) // The renderer's material list could be empty
{
GUIObject(s_Texts.material, m_Material);
}
}
var trailMaterial = serializedObject.FindProperty("m_Materials.Array.data[1]"); // Optional - may fail
if (trailMaterial != null) // Only show if the system has a second material slot
{
GUIObject(s_Texts.trailMaterial, trailMaterial);
}
if (renderMode != RenderMode.None)
{
if (!m_RenderMode.hasMultipleDifferentValues)
{
GUIPopup(s_Texts.sortMode, m_SortMode, s_Texts.sortTypes);
if (renderer != null && SortingGroup.invalidSortingGroupID != renderer.sortingGroupID)
{
using (new EditorGUI.DisabledScope(true))
GUIFloat(s_Texts.sortingFudgeDisabledDueToSortingGroup, m_SortingFudge);
}
else
{
GUIFloat(s_Texts.sortingFudge, m_SortingFudge);
}
if (renderMode != RenderMode.Mesh)
{
GUIFloat(s_Texts.minParticleSize, m_MinParticleSize);
GUIFloat(s_Texts.maxParticleSize, m_MaxParticleSize);
}
if (renderMode == RenderMode.Billboard || renderMode == RenderMode.Mesh)
{
bool anyAlignToDirection = m_ParticleSystemUI.m_ParticleSystems.FirstOrDefault(o => o.shape.enabled && o.shape.alignToDirection) != null;
if (anyAlignToDirection)
{
using (new EditorGUI.DisabledScope(true))
{
GUIPopup(s_Texts.space, 0, s_Texts.localSpace); // force to "Local"
}
GUIContent info = EditorGUIUtility.TrTextContent("Using Align to Direction in the Shape Module forces the system to be rendered using Local Render Alignment.");
EditorGUILayout.HelpBox(info.text, MessageType.Info, true);
}
else
{
GUIPopup(s_Texts.space, m_RenderAlignment, s_Texts.spaces);
}
}
if (renderMode == RenderMode.Mesh)
{
GUIVector3Field(s_Texts.flipMeshes, m_Flip);
}
else
{
GUIVector3Field(s_Texts.flip, m_Flip);
}
if (renderMode == RenderMode.Billboard)
{
GUIToggle(s_Texts.allowRoll, m_AllowRoll);
}
if (renderMode == RenderMode.Mesh)
{
GUIToggle(s_Texts.enableGPUInstancing, m_EnableGPUInstancing);
}
}
GUIVector3Field(s_Texts.pivot, m_Pivot);
EditorGUI.BeginChangeCheck();
s_VisualizePivot = GUIToggle(s_Texts.visualizePivot, s_VisualizePivot);
if (EditorGUI.EndChangeCheck())
{
EditorPrefs.SetBool("VisualizePivot", s_VisualizePivot);
}
GUIPopup(s_Texts.maskingMode, m_MaskInteraction, s_Texts.maskInteractions);
GUIToggle(s_Texts.applyActiveColorSpace, m_ApplyActiveColorSpace);
if (GUIToggle(s_Texts.useCustomVertexStreams, m_UseCustomVertexStreams))
{
DoVertexStreamsGUI(renderMode);
}
}
EditorGUILayout.Space();
GUIPopup(s_Texts.castShadows, m_CastShadows, EditorGUIUtility.TempContent(m_CastShadows.enumDisplayNames));
if (SupportedRenderingFeatures.active.receiveShadows)
{
// Disable ReceiveShadows options for Deferred rendering path
if (SceneView.IsUsingDeferredRenderingPath())
{
using (new EditorGUI.DisabledScope(true)) { GUIToggle(s_Texts.receiveShadows, true); }
}
else
{
GUIToggle(s_Texts.receiveShadows, m_ReceiveShadows);
}
}
if (renderMode != RenderMode.Mesh)
{
GUIFloat(s_Texts.shadowBias, m_ShadowBias);
}
if (SupportedRenderingFeatures.active.motionVectors)
{
GUIPopup(s_Texts.motionVectors, m_MotionVectors, s_Texts.motionVectorOptions);
}
GUISortingLayerField(s_Texts.sortingLayer, m_SortingLayerID);
GUIInt(s_Texts.sortingOrder, m_SortingOrder);
List <ParticleSystemRenderer> renderers = new List <ParticleSystemRenderer>();
foreach (ParticleSystem ps in m_ParticleSystemUI.m_ParticleSystems)
{
renderers.Add(ps.GetComponent <ParticleSystemRenderer>());
}
var renderersArray = renderers.ToArray();
m_Probes.OnGUI(renderersArray, renderers.FirstOrDefault(), true);
RendererEditorBase.DrawRenderingLayer(m_RenderingLayerMask, renderer, renderersArray, true);
RendererEditorBase.DrawRendererPriority(m_RendererPriority, true);
}
public abstract void OnInspectorGUI(InitialModuleUI initial);
public void OnGUI(float width, bool fixedWidth)
{
bool isRepaintEvent = Event.current.type == EventType.Repaint;
// Name of current emitter
string selectedEmitterName = null;
if (m_ParticleSystems.Length > 1)
{
selectedEmitterName = "Multiple Particle Systems";
}
else if (m_ParticleSystems.Length > 0)
{
selectedEmitterName = m_ParticleSystems[0].gameObject.name;
}
if (fixedWidth)
{
EditorGUIUtility.labelWidth = width * 0.4f;
EditorGUILayout.BeginVertical(GUILayout.Width(width));
}
else
{
// First make sure labelWidth is at default width, then subtract
EditorGUIUtility.labelWidth = 0;
EditorGUIUtility.labelWidth = EditorGUIUtility.labelWidth - 4;
EditorGUILayout.BeginVertical();
}
{
InitialModuleUI initial = (InitialModuleUI)m_Modules[0];
for (int i = 0; i < m_Modules.Length; ++i)
{
ModuleUI module = m_Modules[i];
if (module == null)
{
continue;
}
bool initialModule = (module == m_Modules[0]);
// Skip if not visible (except initial module which should always be visible)
if (!module.visibleUI && !initialModule)
{
continue;
}
// Module header size
GUIContent headerLabel = new GUIContent();
Rect moduleHeaderRect;
if (initialModule)
{
moduleHeaderRect = GUILayoutUtility.GetRect(width, 25);
}
else
{
moduleHeaderRect = GUILayoutUtility.GetRect(width, 15);
}
// Module content here to render it below the the header
if (module.foldout)
{
using (new EditorGUI.DisabledScope(!module.enabled))
{
Rect moduleSize = EditorGUILayout.BeginVertical(ParticleSystemStyles.Get().modulePadding);
{
moduleSize.y -= 4; // pull background 'up' behind title to fill rounded corners.
moduleSize.height += 4;
GUI.Label(moduleSize, GUIContent.none, ParticleSystemStyles.Get().moduleBgStyle);
module.OnInspectorGUI(initial);
}
EditorGUILayout.EndVertical();
}
}
// TODO: Get Texture instead of static preview. Render Icon (below titlebar due to rounded corners)
if (initialModule)
{
// Get preview of material or mesh
ParticleSystemRenderer renderer = m_ParticleSystems[0].GetComponent <ParticleSystemRenderer>();
float iconSize = 21;
Rect iconRect = new Rect(moduleHeaderRect.x + 4, moduleHeaderRect.y + 2, iconSize, iconSize);
if (isRepaintEvent && renderer != null)
{
bool iconRendered = false;
if (!multiEdit)
{
int instanceID = 0;
if (renderer.renderMode == ParticleSystemRenderMode.Mesh)
{
if (renderer.mesh != null)
{
instanceID = renderer.mesh.GetInstanceID();
// If the asset is dirty we ensure to get a updated one by clearing cache of temporary previews
if (m_CachedMeshInstanceID != instanceID)
{
m_CachedMeshInstanceID = instanceID;
m_CachedMeshDirtyCount = -1;
}
if (EditorUtility.GetDirtyCount(instanceID) != m_CachedMeshDirtyCount)
{
AssetPreview.ClearTemporaryAssetPreviews();
m_CachedMeshDirtyCount = EditorUtility.GetDirtyCount(instanceID);
}
}
}
else if (renderer.sharedMaterial != null)
{
instanceID = renderer.sharedMaterial.GetInstanceID();
// If the asset is dirty we ensure to get a updated one by clearing cache of temporary previews
if (m_CachedMaterialInstanceID != instanceID)
{
m_CachedMaterialInstanceID = instanceID;
m_CachedMaterialDirtyCount = -1;
}
if (EditorUtility.GetDirtyCount(instanceID) != m_CachedMaterialDirtyCount)
{
AssetPreview.ClearTemporaryAssetPreviews();
m_CachedMaterialDirtyCount = EditorUtility.GetDirtyCount(instanceID);
}
}
if (instanceID != 0)
{
Texture2D icon = AssetPreview.GetAssetPreview(instanceID);
if (icon != null)
{
GUI.DrawTexture(iconRect, icon, ScaleMode.StretchToFill, true);
iconRendered = true;
}
}
}
// Fill so we do not see the background when we have no icon (eg multi-edit)
if (!iconRendered)
{
GUI.Label(iconRect, GUIContent.none, ParticleSystemStyles.Get().moduleBgStyle);
}
}
// Select gameObject when clicking on icon
if (!multiEdit && EditorGUI.DropdownButton(iconRect, GUIContent.none, FocusType.Passive, GUIStyle.none))
{
// Toggle selected particle system from selection
if (EditorGUI.actionKey)
{
List <int> newSelection = new List <int>();
int instanceID = m_ParticleSystems[0].gameObject.GetInstanceID();
newSelection.AddRange(Selection.instanceIDs);
if (!newSelection.Contains(instanceID) || newSelection.Count != 1)
{
if (newSelection.Contains(instanceID))
{
newSelection.Remove(instanceID);
}
else
{
newSelection.Add(instanceID);
}
}
Selection.instanceIDs = newSelection.ToArray();
}
else
{
Selection.instanceIDs = new int[0];
Selection.activeInstanceID = m_ParticleSystems[0].gameObject.GetInstanceID();
}
}
}
// Button logic for enabledness (see below for UI)
Rect checkMarkRect = new Rect(moduleHeaderRect.x + 2, moduleHeaderRect.y + 1, 13, 13);
if (!initialModule && GUI.Button(checkMarkRect, GUIContent.none, GUIStyle.none))
{
module.enabled = !module.enabled;
}
// Button logic for plus/minus (see below for UI)
Rect plusRect = new Rect(moduleHeaderRect.x + moduleHeaderRect.width - 10, moduleHeaderRect.y + moduleHeaderRect.height - 10, 10, 10);
Rect plusRectInteract = new Rect(plusRect.x - 4, plusRect.y - 4, plusRect.width + 4, plusRect.height + 4);
Rect infoRect = new Rect(plusRect.x - 23, plusRect.y - 8, 20, 20);
if (initialModule && EditorGUI.DropdownButton(plusRectInteract, s_Texts.addModules, FocusType.Passive, GUIStyle.none))
{
ShowAddModuleMenu();
}
// Module header (last to become top most renderered)
if (!string.IsNullOrEmpty(selectedEmitterName))
{
headerLabel.text = initialModule ? selectedEmitterName : module.displayName;
}
else
{
headerLabel.text = module.displayName;
}
headerLabel.tooltip = module.toolTip;
bool newToggleState = module.DrawHeader(moduleHeaderRect, headerLabel);
if (newToggleState != module.foldout)
{
switch (Event.current.button)
{
case 0:
bool newFoldoutState = !module.foldout;
if (Event.current.control)
{
foreach (var moduleUi in m_Modules)
{
if (moduleUi != null && moduleUi.visibleUI)
{
moduleUi.foldout = newFoldoutState;
}
}
}
else
{
module.foldout = newFoldoutState;
}
break;
case 1:
if (initialModule)
{
ShowEmitterMenu();
}
else
{
ShowModuleMenu(i);
}
break;
}
}
// Render checkmark on top (logic: see above)
if (!initialModule)
{
EditorGUI.showMixedValue = module.enabledHasMultipleDifferentValues;
GUIStyle style = EditorGUI.showMixedValue ? ParticleSystemStyles.Get().toggleMixed : ParticleSystemStyles.Get().toggle;
GUI.Toggle(checkMarkRect, module.enabled, GUIContent.none, style);
EditorGUI.showMixedValue = false;
}
// Render plus/minus on top
if (isRepaintEvent && initialModule)
{
GUI.Label(plusRect, GUIContent.none, ParticleSystemStyles.Get().plus);
}
if (initialModule && !string.IsNullOrEmpty(m_SupportsCullingTextLabel))
{
var supportsCullingText = new GUIContent("", ParticleSystemStyles.Get().warningIcon, m_SupportsCullingTextLabel);
GUI.Label(infoRect, supportsCullingText);
}
GUILayout.Space(1); // dist to next module
} // foreach module
GUILayout.Space(-1);
}
EditorGUILayout.EndVertical(); // end fixed moduleWidth
// Apply the property, handle undo
ApplyProperties();
}
override public void OnInspectorGUI(InitialModuleUI initial)
{
GUIMinMaxCurve(s_Texts.speed, m_Curve);
GUIMinMaxRange(s_Texts.speedRange, m_Range);
}
public override void OnSceneGUI(ParticleSystem s, InitialModuleUI initial)
{
Color color = Handles.color;
Handles.color = s_ShapeGizmoColor;
Matrix4x4 matrix = Handles.matrix;
Matrix4x4 transform = new Matrix4x4();
transform.SetTRS(s.transform.position, s.transform.rotation, s.transform.lossyScale);
Handles.matrix = transform;
EditorGUI.BeginChangeCheck();
int intValue = this.m_Type.intValue;
switch (intValue)
{
case 0:
case 1:
this.m_Radius.floatValue = Handles.DoSimpleRadiusHandle(Quaternion.identity, Vector3.zero, this.m_Radius.floatValue, false);
break;
}
if ((intValue == 10) || (intValue == 11))
{
float floatValue = this.m_Radius.floatValue;
float arc = this.m_Arc.floatValue;
Handles.DoSimpleRadiusArcHandleXY(Quaternion.identity, Vector3.zero, ref floatValue, ref arc);
this.m_Radius.floatValue = floatValue;
this.m_Arc.floatValue = arc;
}
else if ((intValue == 2) || (intValue == 3))
{
this.m_Radius.floatValue = Handles.DoSimpleRadiusHandle(Quaternion.identity, Vector3.zero, this.m_Radius.floatValue, true);
}
else if ((intValue == 4) || (intValue == 7))
{
Vector3 radiusAngleRange = new Vector3(this.m_Radius.floatValue, this.m_Angle.floatValue, initial.m_Speed.scalar.floatValue);
radiusAngleRange = Handles.ConeFrustrumHandle(Quaternion.identity, Vector3.zero, radiusAngleRange);
this.m_Radius.floatValue = radiusAngleRange.x;
this.m_Angle.floatValue = radiusAngleRange.y;
initial.m_Speed.scalar.floatValue = radiusAngleRange.z;
}
else if ((intValue == 8) || (intValue == 9))
{
Vector3 vector2 = new Vector3(this.m_Radius.floatValue, this.m_Angle.floatValue, this.m_Length.floatValue);
vector2 = Handles.ConeFrustrumHandle(Quaternion.identity, Vector3.zero, vector2);
this.m_Radius.floatValue = vector2.x;
this.m_Angle.floatValue = vector2.y;
this.m_Length.floatValue = vector2.z;
}
else
{
switch (intValue)
{
case 5:
{
Vector3 zero = Vector3.zero;
Vector3 size = new Vector3(this.m_BoxX.floatValue, this.m_BoxY.floatValue, this.m_BoxZ.floatValue);
if (this.m_BoxEditor.OnSceneGUI(transform, s_ShapeGizmoColor, false, ref zero, ref size))
{
this.m_BoxX.floatValue = size.x;
this.m_BoxY.floatValue = size.y;
this.m_BoxZ.floatValue = size.z;
}
break;
}
case 12:
this.m_Radius.floatValue = Handles.DoSimpleEdgeHandle(Quaternion.identity, Vector3.zero, this.m_Radius.floatValue);
break;
case 6:
{
Mesh objectReferenceValue = (Mesh) this.m_Mesh.objectReferenceValue;
if (objectReferenceValue != null)
{
bool wireframe = GL.wireframe;
GL.wireframe = true;
this.m_Material.SetPass(0);
Graphics.DrawMeshNow(objectReferenceValue, s.transform.localToWorldMatrix);
GL.wireframe = wireframe;
}
break;
}
}
}
if (EditorGUI.EndChangeCheck())
{
base.m_ParticleSystemUI.m_ParticleEffectUI.m_Owner.Repaint();
}
Handles.color = color;
Handles.matrix = matrix;
}
private static ModuleUI[] CreateUIModules(ParticleSystemUI e, SerializedObject so)
{
int num = 0;
ModuleUI[] expr_09 = new ModuleUI[17];
expr_09[0] = new InitialModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[1] = new EmissionModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[2] = new ShapeModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[3] = new VelocityModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[4] = new ClampVelocityModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[5] = new ForceModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[6] = new ColorModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[7] = new ColorByVelocityModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[8] = new SizeModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[9] = new SizeByVelocityModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[10] = new RotationModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[11] = new RotationByVelocityModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[12] = new ExternalForcesModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[13] = new CollisionModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[14] = new SubModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
expr_09[15] = new UVModuleUI(e, so, ParticleSystemUI.s_ModuleNames[num++]);
return expr_09;
}
public override void OnInspectorGUI(InitialModuleUI initial)
{
if (UVModuleUI.s_Texts == null)
{
UVModuleUI.s_Texts = new UVModuleUI.Texts();
}
int num = ModuleUI.GUIPopup(UVModuleUI.s_Texts.mode, this.m_Mode, UVModuleUI.s_Texts.modes, new GUILayoutOption[0]);
if (!this.m_Mode.hasMultipleDifferentValues)
{
if (num == 0)
{
ModuleUI.GUIIntDraggableX2(UVModuleUI.s_Texts.tiles, UVModuleUI.s_Texts.tilesX, this.m_TilesX, UVModuleUI.s_Texts.tilesY, this.m_TilesY, new GUILayoutOption[0]);
int num2 = ModuleUI.GUIPopup(UVModuleUI.s_Texts.animation, this.m_AnimationType, UVModuleUI.s_Texts.types, new GUILayoutOption[0]);
if (num2 == 1)
{
ModuleUI.GUIToggle(UVModuleUI.s_Texts.randomRow, this.m_RandomRow, new GUILayoutOption[0]);
if (!this.m_RandomRow.boolValue)
{
ModuleUI.GUIInt(UVModuleUI.s_Texts.row, this.m_RowIndex, new GUILayoutOption[0]);
}
this.m_FrameOverTime.m_RemapValue = (float)this.m_TilesX.intValue;
this.m_StartFrame.m_RemapValue = (float)this.m_TilesX.intValue;
}
else
{
this.m_FrameOverTime.m_RemapValue = (float)(this.m_TilesX.intValue * this.m_TilesY.intValue);
this.m_StartFrame.m_RemapValue = (float)(this.m_TilesX.intValue * this.m_TilesY.intValue);
}
}
else
{
this.DoListOfSpritesGUI();
this.ValidateSpriteList();
this.m_FrameOverTime.m_RemapValue = (float)this.m_Sprites.arraySize;
this.m_StartFrame.m_RemapValue = (float)this.m_Sprites.arraySize;
}
ModuleUI.GUIMinMaxCurve(UVModuleUI.s_Texts.frameOverTime, this.m_FrameOverTime, new GUILayoutOption[0]);
ModuleUI.GUIMinMaxCurve(UVModuleUI.s_Texts.startFrame, this.m_StartFrame, new GUILayoutOption[0]);
}
ModuleUI.GUIFloat(UVModuleUI.s_Texts.cycles, this.m_Cycles, new GUILayoutOption[0]);
bool disabled = false;
ParticleSystem[] particleSystems = this.m_ParticleSystemUI.m_ParticleSystems;
for (int i = 0; i < particleSystems.Length; i++)
{
ParticleSystem particleSystem = particleSystems[i];
ParticleSystemRenderer component = particleSystem.GetComponent <ParticleSystemRenderer>();
if (component != null && component.renderMode == ParticleSystemRenderMode.Mesh)
{
disabled = true;
break;
}
}
using (new EditorGUI.DisabledScope(disabled))
{
ModuleUI.GUIFloat(UVModuleUI.s_Texts.flipU, this.m_FlipU, new GUILayoutOption[0]);
ModuleUI.GUIFloat(UVModuleUI.s_Texts.flipV, this.m_FlipV, new GUILayoutOption[0]);
}
this.m_UVChannelMask.intValue = (int)((UVChannelFlags)ModuleUI.GUIEnumMask(UVModuleUI.s_Texts.uvChannelMask, (UVChannelFlags)this.m_UVChannelMask.intValue, new GUILayoutOption[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(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;
}
override public void OnInspectorGUI(InitialModuleUI initial)
{
EditorGUI.BeginChangeCheck();
CollisionTypes type = (CollisionTypes)GUIPopup(s_Texts.collisionType, m_Type, s_Texts.collisionTypes);
if (EditorGUI.EndChangeCheck())
{
ToolManager.RefreshAvailableTools();
}
if (type == CollisionTypes.Plane)
{
DoListOfPlanesGUI();
}
else
{
GUIPopup(s_Texts.collisionMode, m_CollisionMode, s_Texts.collisionModes);
}
GUIMinMaxCurve(s_Texts.dampen, m_Dampen);
GUIMinMaxCurve(s_Texts.bounce, m_Bounce);
GUIMinMaxCurve(s_Texts.lifetimeLoss, m_LifetimeLossOnCollision);
GUIFloat(s_Texts.minKillSpeed, m_MinKillSpeed);
GUIFloat(s_Texts.maxKillSpeed, m_MaxKillSpeed);
GUIFloat(s_Texts.radiusScale, m_RadiusScale);
if (type == CollisionTypes.World)
{
GUIPopup(s_Texts.quality, m_Quality, s_Texts.qualitySettings);
EditorGUI.indentLevel++;
GUILayerMask(s_Texts.collidesWith, m_CollidesWith);
GUIInt(s_Texts.maxCollisionShapes, m_MaxCollisionShapes);
if (m_Quality.intValue == 0)
{
GUIToggle(s_Texts.collidesWithDynamic, m_CollidesWithDynamic);
}
else
{
GUIFloat(s_Texts.voxelSize, m_VoxelSize);
}
EditorGUI.indentLevel--;
GUIFloat(s_Texts.colliderForce, m_ColliderForce);
EditorGUI.indentLevel++;
GUIToggle(s_Texts.multiplyColliderForceByCollisionAngle, m_MultiplyColliderForceByCollisionAngle);
GUIToggle(s_Texts.multiplyColliderForceByParticleSpeed, m_MultiplyColliderForceByParticleSpeed);
GUIToggle(s_Texts.multiplyColliderForceByParticleSize, m_MultiplyColliderForceByParticleSize);
EditorGUI.indentLevel--;
}
GUIToggle(s_Texts.collisionMessages, m_CollisionMessages);
if (EditorGUIUtility.comparisonViewMode == EditorGUIUtility.ComparisonViewMode.None)
{
EditorGUILayout.BeginVertical("GroupBox");
if (type == CollisionTypes.Plane)
{
var editorTools = new List <EditorTool>(2);
EditorToolManager.GetComponentTools(x => x.GetEditor <EditorTool>() is CollisionModuleTransformTool, editorTools, true);
GUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel(s_Texts.sceneTools, ParticleSystemStyles.Get().label, ParticleSystemStyles.Get().label);
EditorGUILayout.EditorToolbar(editorTools);
GUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUI.BeginChangeCheck();
m_PlaneVisualizationType = (PlaneVizType)GUIPopup(s_Texts.visualization, (int)m_PlaneVisualizationType, s_Texts.planeVizTypes);
if (EditorGUI.EndChangeCheck())
{
EditorPrefs.SetInt("PlaneColisionVizType", (int)m_PlaneVisualizationType);
}
EditorGUI.BeginChangeCheck();
m_ScaleGrid = GUIFloat(s_Texts.scalePlane, m_ScaleGrid, "f2");
if (EditorGUI.EndChangeCheck())
{
m_ScaleGrid = Mathf.Max(0f, m_ScaleGrid);
EditorPrefs.SetFloat("ScalePlaneColision", m_ScaleGrid);
}
}
else
{
GUILayout.Label(s_Texts.sceneTools, ParticleSystemStyles.Get().label);
}
EditorGUI.BeginChangeCheck();
s_VisualizeBounds = GUIToggle(s_Texts.visualizeBounds, s_VisualizeBounds);
if (EditorGUI.EndChangeCheck())
{
EditorPrefs.SetBool("VisualizeBounds", s_VisualizeBounds);
}
EditorGUILayout.EndVertical();
}
}
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;
}
public override void OnInspectorGUI(InitialModuleUI initial)
{
ModuleUI.GUIPopup(InheritVelocityModuleUI.s_Texts.mode, this.m_Mode, InheritVelocityModuleUI.s_Texts.modes, new GUILayoutOption[0]);
ModuleUI.GUIMinMaxCurve(InheritVelocityModuleUI.s_Texts.velocity, this.m_Curve, new GUILayoutOption[0]);
}
override public void OnInspectorGUI(InitialModuleUI initial)
{
GUIFloat(s_Texts.duration, m_LengthInSec, "f2");
EditorGUI.BeginChangeCheck();
bool looping = GUIToggle(s_Texts.looping, m_Looping);
if (EditorGUI.EndChangeCheck() && looping)
{
foreach (ParticleSystem ps in m_ParticleSystemUI.m_ParticleSystems)
{
if (ps.time >= ps.main.duration)
{
ps.time = 0.0f;
}
}
}
using (new EditorGUI.DisabledScope(!m_Looping.boolValue))
{
GUIToggle(s_Texts.prewarm, m_Prewarm);
}
using (new EditorGUI.DisabledScope(m_Prewarm.boolValue && m_Looping.boolValue))
{
GUIMinMaxCurve(s_Texts.startDelay, m_StartDelay);
}
GUIMinMaxCurve(s_Texts.lifetime, m_LifeTime);
GUIMinMaxCurve(s_Texts.speed, m_Speed);
// Size
EditorGUI.BeginChangeCheck();
bool size3D = GUIToggle(s_Texts.size3D, m_Size3D);
if (EditorGUI.EndChangeCheck())
{
// Remove old curves from curve editor
if (!size3D)
{
m_SizeY.RemoveCurveFromEditor();
m_SizeZ.RemoveCurveFromEditor();
}
}
// Keep states in sync
if (!m_SizeX.stateHasMultipleDifferentValues)
{
m_SizeZ.SetMinMaxState(m_SizeX.state, size3D);
m_SizeY.SetMinMaxState(m_SizeX.state, size3D);
}
if (size3D)
{
m_SizeX.m_DisplayName = s_Texts.x;
GUITripleMinMaxCurve(GUIContent.none, s_Texts.x, m_SizeX, s_Texts.y, m_SizeY, s_Texts.z, m_SizeZ, null);
}
else
{
m_SizeX.m_DisplayName = s_Texts.size;
GUIMinMaxCurve(s_Texts.size, m_SizeX);
}
// Rotation
EditorGUI.BeginChangeCheck();
bool rotation3D = GUIToggle(s_Texts.rotation3D, m_Rotation3D);
if (EditorGUI.EndChangeCheck())
{
// Remove old curves from curve editor
if (!rotation3D)
{
m_RotationX.RemoveCurveFromEditor();
m_RotationY.RemoveCurveFromEditor();
}
}
// Keep states in sync
if (!m_RotationZ.stateHasMultipleDifferentValues)
{
m_RotationX.SetMinMaxState(m_RotationZ.state, rotation3D);
m_RotationY.SetMinMaxState(m_RotationZ.state, rotation3D);
}
if (rotation3D)
{
m_RotationZ.m_DisplayName = s_Texts.z;
GUITripleMinMaxCurve(GUIContent.none, s_Texts.x, m_RotationX, s_Texts.y, m_RotationY, s_Texts.z, m_RotationZ, null);
}
else
{
m_RotationZ.m_DisplayName = s_Texts.rotation;
GUIMinMaxCurve(s_Texts.rotation, m_RotationZ);
}
GUIFloat(s_Texts.randomizeRotationDirection, m_RandomizeRotationDirection);
GUIMinMaxGradient(s_Texts.color, m_Color, false);
GUIMinMaxCurve(s_Texts.gravity, m_GravityModifier);
int space = GUIPopup(s_Texts.simulationSpace, m_SimulationSpace, s_Texts.simulationSpaces);
if (space == 2 && m_CustomSimulationSpace != null)
{
GUIObject(s_Texts.customSimulationSpace, m_CustomSimulationSpace);
}
GUIFloat(s_Texts.simulationSpeed, m_SimulationSpeed);
GUIBoolAsPopup(s_Texts.deltaTime, m_UseUnscaledTime, new string[] { "Scaled", "Unscaled" });
bool anyNonMesh = m_ParticleSystemUI.m_ParticleSystems.FirstOrDefault(o => !o.shape.enabled || (o.shape.shapeType != ParticleSystemShapeType.SkinnedMeshRenderer && o.shape.shapeType != ParticleSystemShapeType.MeshRenderer)) != null;
if (anyNonMesh)
{
GUIPopup(s_Texts.scalingMode, m_ScalingMode, s_Texts.scalingModes);
}
bool oldPlayOnAwake = m_PlayOnAwake.boolValue;
bool newPlayOnAwake = GUIToggle(s_Texts.autoplay, m_PlayOnAwake);
if (oldPlayOnAwake != newPlayOnAwake)
{
m_ParticleSystemUI.m_ParticleEffectUI.PlayOnAwakeChanged(newPlayOnAwake);
}
GUIBoolAsPopup(s_Texts.emitterVelocity, m_EmitterVelocity, new string[] { "Transform", "Rigidbody" });
GUIInt(s_Texts.maxParticles, m_MaxNumParticles);
bool autoRandomSeed = GUIToggle(s_Texts.autoRandomSeed, m_AutoRandomSeed);
if (!autoRandomSeed)
{
bool isInspectorView = m_ParticleSystemUI.m_ParticleEffectUI.m_Owner is ParticleSystemInspector;
if (isInspectorView)
{
GUILayout.BeginHorizontal();
GUIInt(s_Texts.randomSeed, m_RandomSeed);
if (!m_ParticleSystemUI.multiEdit && GUILayout.Button("Reseed", EditorStyles.miniButton, GUILayout.Width(60)))
{
m_RandomSeed.intValue = (int)m_ParticleSystemUI.m_ParticleSystems[0].GenerateRandomSeed();
}
GUILayout.EndHorizontal();
}
else
{
GUIInt(s_Texts.randomSeed, m_RandomSeed);
if (!m_ParticleSystemUI.multiEdit && GUILayout.Button("Reseed", EditorStyles.miniButton))
{
m_RandomSeed.intValue = (int)m_ParticleSystemUI.m_ParticleSystems[0].GenerateRandomSeed();
}
}
}
GUIPopup(s_Texts.stopAction, m_StopAction, s_Texts.stopActions);
GUIPopup(s_Texts.cullingMode, m_CullingMode, s_Texts.cullingModes);
ParticleSystemRingBufferMode ringBufferMode = (ParticleSystemRingBufferMode)GUIPopup(s_Texts.ringBufferMode, m_RingBufferMode, s_Texts.ringBufferModes);
if (!m_RingBufferMode.hasMultipleDifferentValues && ringBufferMode == ParticleSystemRingBufferMode.LoopUntilReplaced)
{
EditorGUI.indentLevel++;
GUIMinMaxRange(s_Texts.ringBufferLoopRange, m_RingBufferLoopRange);
EditorGUI.indentLevel--;
}
}
public override void OnSceneGUI(ParticleSystem s, InitialModuleUI initial)
{
Color color = Handles.color;
Handles.color = ShapeModuleUI.s_ShapeGizmoColor;
Matrix4x4 matrix = Handles.matrix;
Matrix4x4 transform = new Matrix4x4();
transform.SetTRS(s.transform.position, s.transform.rotation, s.transform.lossyScale);
Handles.matrix = transform;
EditorGUI.BeginChangeCheck();
int intValue = this.m_Type.intValue;
if (intValue == 0 || intValue == 1)
this.m_Radius.floatValue = Handles.DoSimpleRadiusHandle(Quaternion.identity, Vector3.zero, this.m_Radius.floatValue, false);
if (intValue == 10 || intValue == 11)
{
float floatValue1 = this.m_Radius.floatValue;
float floatValue2 = this.m_Arc.floatValue;
Handles.DoSimpleRadiusArcHandleXY(Quaternion.identity, Vector3.zero, ref floatValue1, ref floatValue2);
this.m_Radius.floatValue = floatValue1;
this.m_Arc.floatValue = floatValue2;
}
else if (intValue == 2 || intValue == 3)
this.m_Radius.floatValue = Handles.DoSimpleRadiusHandle(Quaternion.identity, Vector3.zero, this.m_Radius.floatValue, true);
else if (intValue == 4 || intValue == 7)
{
Vector3 vector3 = Handles.ConeFrustrumHandle(Quaternion.identity, Vector3.zero, new Vector3(this.m_Radius.floatValue, this.m_Angle.floatValue, initial.m_Speed.scalar.floatValue));
this.m_Radius.floatValue = vector3.x;
this.m_Angle.floatValue = vector3.y;
initial.m_Speed.scalar.floatValue = vector3.z;
}
else if (intValue == 8 || intValue == 9)
{
Vector3 vector3 = Handles.ConeFrustrumHandle(Quaternion.identity, Vector3.zero, new Vector3(this.m_Radius.floatValue, this.m_Angle.floatValue, this.m_Length.floatValue));
this.m_Radius.floatValue = vector3.x;
this.m_Angle.floatValue = vector3.y;
this.m_Length.floatValue = vector3.z;
}
else if (intValue == 5)
{
Vector3 zero = Vector3.zero;
Vector3 size = new Vector3(this.m_BoxX.floatValue, this.m_BoxY.floatValue, this.m_BoxZ.floatValue);
if (this.m_BoxEditor.OnSceneGUI(transform, ShapeModuleUI.s_ShapeGizmoColor, false, ref zero, ref size))
{
this.m_BoxX.floatValue = size.x;
this.m_BoxY.floatValue = size.y;
this.m_BoxZ.floatValue = size.z;
}
}
else if (intValue == 12)
this.m_Radius.floatValue = Handles.DoSimpleEdgeHandle(Quaternion.identity, Vector3.zero, this.m_Radius.floatValue);
else if (intValue == 6)
{
Mesh objectReferenceValue = (Mesh) this.m_Mesh.objectReferenceValue;
if ((bool) ((Object) objectReferenceValue))
{
bool wireframe = GL.wireframe;
GL.wireframe = true;
this.m_Material.SetPass(0);
Graphics.DrawMeshNow(objectReferenceValue, s.transform.localToWorldMatrix);
GL.wireframe = wireframe;
}
}
if (EditorGUI.EndChangeCheck())
this.m_ParticleSystemUI.m_ParticleEffectUI.m_Owner.Repaint();
Handles.color = color;
Handles.matrix = matrix;
}
private static ModuleUI[] CreateUIModules(ParticleSystemUI e, SerializedObject so)
{
int num1 = 0;
ModuleUI[] moduleUiArray = new ModuleUI[18];
int index1 = 0;
ParticleSystemUI owner1 = e;
SerializedObject o1 = so;
string[] moduleNames1 = ParticleSystemUI.s_ModuleNames;
int index2 = num1;
int num2 = 1;
int num3 = index2 + num2;
string displayName1 = moduleNames1[index2];
InitialModuleUI initialModuleUi = new InitialModuleUI(owner1, o1, displayName1);
moduleUiArray[index1] = (ModuleUI) initialModuleUi;
int index3 = 1;
ParticleSystemUI owner2 = e;
SerializedObject o2 = so;
string[] moduleNames2 = ParticleSystemUI.s_ModuleNames;
int index4 = num3;
int num4 = 1;
int num5 = index4 + num4;
string displayName2 = moduleNames2[index4];
EmissionModuleUI emissionModuleUi = new EmissionModuleUI(owner2, o2, displayName2);
moduleUiArray[index3] = (ModuleUI) emissionModuleUi;
int index5 = 2;
ParticleSystemUI owner3 = e;
SerializedObject o3 = so;
string[] moduleNames3 = ParticleSystemUI.s_ModuleNames;
int index6 = num5;
int num6 = 1;
int num7 = index6 + num6;
string displayName3 = moduleNames3[index6];
ShapeModuleUI shapeModuleUi = new ShapeModuleUI(owner3, o3, displayName3);
moduleUiArray[index5] = (ModuleUI) shapeModuleUi;
int index7 = 3;
ParticleSystemUI owner4 = e;
SerializedObject o4 = so;
string[] moduleNames4 = ParticleSystemUI.s_ModuleNames;
int index8 = num7;
int num8 = 1;
int num9 = index8 + num8;
string displayName4 = moduleNames4[index8];
VelocityModuleUI velocityModuleUi1 = new VelocityModuleUI(owner4, o4, displayName4);
moduleUiArray[index7] = (ModuleUI) velocityModuleUi1;
int index9 = 4;
ParticleSystemUI owner5 = e;
SerializedObject o5 = so;
string[] moduleNames5 = ParticleSystemUI.s_ModuleNames;
int index10 = num9;
int num10 = 1;
int num11 = index10 + num10;
string displayName5 = moduleNames5[index10];
ClampVelocityModuleUI velocityModuleUi2 = new ClampVelocityModuleUI(owner5, o5, displayName5);
moduleUiArray[index9] = (ModuleUI) velocityModuleUi2;
int index11 = 5;
ParticleSystemUI owner6 = e;
SerializedObject o6 = so;
string[] moduleNames6 = ParticleSystemUI.s_ModuleNames;
int index12 = num11;
int num12 = 1;
int num13 = index12 + num12;
string displayName6 = moduleNames6[index12];
InheritVelocityModuleUI velocityModuleUi3 = new InheritVelocityModuleUI(owner6, o6, displayName6);
moduleUiArray[index11] = (ModuleUI) velocityModuleUi3;
int index13 = 6;
ParticleSystemUI owner7 = e;
SerializedObject o7 = so;
string[] moduleNames7 = ParticleSystemUI.s_ModuleNames;
int index14 = num13;
int num14 = 1;
int num15 = index14 + num14;
string displayName7 = moduleNames7[index14];
ForceModuleUI forceModuleUi = new ForceModuleUI(owner7, o7, displayName7);
moduleUiArray[index13] = (ModuleUI) forceModuleUi;
int index15 = 7;
ParticleSystemUI owner8 = e;
SerializedObject o8 = so;
string[] moduleNames8 = ParticleSystemUI.s_ModuleNames;
int index16 = num15;
int num16 = 1;
int num17 = index16 + num16;
string displayName8 = moduleNames8[index16];
ColorModuleUI colorModuleUi = new ColorModuleUI(owner8, o8, displayName8);
moduleUiArray[index15] = (ModuleUI) colorModuleUi;
int index17 = 8;
ParticleSystemUI owner9 = e;
SerializedObject o9 = so;
string[] moduleNames9 = ParticleSystemUI.s_ModuleNames;
int index18 = num17;
int num18 = 1;
int num19 = index18 + num18;
string displayName9 = moduleNames9[index18];
ColorByVelocityModuleUI velocityModuleUi4 = new ColorByVelocityModuleUI(owner9, o9, displayName9);
moduleUiArray[index17] = (ModuleUI) velocityModuleUi4;
int index19 = 9;
ParticleSystemUI owner10 = e;
SerializedObject o10 = so;
string[] moduleNames10 = ParticleSystemUI.s_ModuleNames;
int index20 = num19;
int num20 = 1;
int num21 = index20 + num20;
string displayName10 = moduleNames10[index20];
SizeModuleUI sizeModuleUi = new SizeModuleUI(owner10, o10, displayName10);
moduleUiArray[index19] = (ModuleUI) sizeModuleUi;
int index21 = 10;
ParticleSystemUI owner11 = e;
SerializedObject o11 = so;
string[] moduleNames11 = ParticleSystemUI.s_ModuleNames;
int index22 = num21;
int num22 = 1;
int num23 = index22 + num22;
string displayName11 = moduleNames11[index22];
SizeByVelocityModuleUI velocityModuleUi5 = new SizeByVelocityModuleUI(owner11, o11, displayName11);
moduleUiArray[index21] = (ModuleUI) velocityModuleUi5;
int index23 = 11;
ParticleSystemUI owner12 = e;
SerializedObject o12 = so;
string[] moduleNames12 = ParticleSystemUI.s_ModuleNames;
int index24 = num23;
int num24 = 1;
int num25 = index24 + num24;
string displayName12 = moduleNames12[index24];
RotationModuleUI rotationModuleUi = new RotationModuleUI(owner12, o12, displayName12);
moduleUiArray[index23] = (ModuleUI) rotationModuleUi;
int index25 = 12;
ParticleSystemUI owner13 = e;
SerializedObject o13 = so;
string[] moduleNames13 = ParticleSystemUI.s_ModuleNames;
int index26 = num25;
int num26 = 1;
int num27 = index26 + num26;
string displayName13 = moduleNames13[index26];
RotationByVelocityModuleUI velocityModuleUi6 = new RotationByVelocityModuleUI(owner13, o13, displayName13);
moduleUiArray[index25] = (ModuleUI) velocityModuleUi6;
int index27 = 13;
ParticleSystemUI owner14 = e;
SerializedObject o14 = so;
string[] moduleNames14 = ParticleSystemUI.s_ModuleNames;
int index28 = num27;
int num28 = 1;
int num29 = index28 + num28;
string displayName14 = moduleNames14[index28];
ExternalForcesModuleUI externalForcesModuleUi = new ExternalForcesModuleUI(owner14, o14, displayName14);
moduleUiArray[index27] = (ModuleUI) externalForcesModuleUi;
int index29 = 14;
ParticleSystemUI owner15 = e;
SerializedObject o15 = so;
string[] moduleNames15 = ParticleSystemUI.s_ModuleNames;
int index30 = num29;
int num30 = 1;
int num31 = index30 + num30;
string displayName15 = moduleNames15[index30];
CollisionModuleUI collisionModuleUi = new CollisionModuleUI(owner15, o15, displayName15);
moduleUiArray[index29] = (ModuleUI) collisionModuleUi;
int index31 = 15;
ParticleSystemUI owner16 = e;
SerializedObject o16 = so;
string[] moduleNames16 = ParticleSystemUI.s_ModuleNames;
int index32 = num31;
int num32 = 1;
int num33 = index32 + num32;
string displayName16 = moduleNames16[index32];
SubModuleUI subModuleUi = new SubModuleUI(owner16, o16, displayName16);
moduleUiArray[index31] = (ModuleUI) subModuleUi;
int index33 = 16;
ParticleSystemUI owner17 = e;
SerializedObject o17 = so;
string[] moduleNames17 = ParticleSystemUI.s_ModuleNames;
int index34 = num33;
int num34 = 1;
int num35 = index34 + num34;
string displayName17 = moduleNames17[index34];
UVModuleUI uvModuleUi = new UVModuleUI(owner17, o17, displayName17);
moduleUiArray[index33] = (ModuleUI) uvModuleUi;
return moduleUiArray;
}
override public void OnInspectorGUI(InitialModuleUI initial)
{
int mode = GUIPopup(s_Texts.mode, m_Mode, s_Texts.modes);
if (!m_Mode.hasMultipleDifferentValues)
{
if (mode == (int)ParticleSystemAnimationMode.Grid)
{
GUIIntDraggableX2(s_Texts.tiles, s_Texts.tilesX, m_TilesX, s_Texts.tilesY, m_TilesY);
int type = GUIPopup(s_Texts.animation, m_AnimationType, s_Texts.types);
if (type == (int)ParticleSystemAnimationType.SingleRow)
{
GUIPopup(s_Texts.rowMode, m_RowMode, s_Texts.rowModes);
if (!m_RowMode.hasMultipleDifferentValues && m_RowMode.intValue == (int)ParticleSystemAnimationRowMode.Custom)
{
GUIInt(s_Texts.row, m_RowIndex);
}
m_FrameOverTime.m_RemapValue = (float)(m_TilesX.intValue);
m_StartFrame.m_RemapValue = (float)(m_TilesX.intValue);
}
else
{
m_FrameOverTime.m_RemapValue = (float)(m_TilesX.intValue * m_TilesY.intValue);
m_StartFrame.m_RemapValue = (float)(m_TilesX.intValue * m_TilesY.intValue);
}
}
else
{
DoListOfSpritesGUI();
ValidateSpriteList();
m_FrameOverTime.m_RemapValue = (float)(m_Sprites.arraySize);
m_StartFrame.m_RemapValue = (float)(m_Sprites.arraySize);
}
}
ParticleSystemAnimationTimeMode timeMode = (ParticleSystemAnimationTimeMode)GUIPopup(s_Texts.timeMode, m_TimeMode, s_Texts.timeModes);
if (!m_TimeMode.hasMultipleDifferentValues)
{
if (timeMode == ParticleSystemAnimationTimeMode.FPS)
{
GUIFloat(s_Texts.fps, m_FPS);
foreach (ParticleSystem ps in m_ParticleSystemUI.m_ParticleSystems)
{
if (ps.main.startLifetimeMultiplier == Mathf.Infinity)
{
EditorGUILayout.HelpBox("FPS mode does not work when using infinite particle lifetimes.", MessageType.Error, true);
break;
}
}
}
else if (timeMode == ParticleSystemAnimationTimeMode.Speed)
{
GUIMinMaxRange(s_Texts.speedRange, m_SpeedRange);
}
else
{
GUIMinMaxCurve(s_Texts.frameOverTime, m_FrameOverTime);
}
}
GUIMinMaxCurve(s_Texts.startFrame, m_StartFrame);
if (!m_TimeMode.hasMultipleDifferentValues && timeMode != ParticleSystemAnimationTimeMode.FPS)
{
GUIFloat(s_Texts.cycles, m_Cycles);
}
GUIEnumMaskUVChannelFlags(s_Texts.uvChannelMask, m_UVChannelMask);
}
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(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;
}
override public void OnInspectorGUI(InitialModuleUI initial)
{
EditorGUI.BeginChangeCheck();
CollisionTypes type = (CollisionTypes)GUIPopup(s_Texts.collisionType, m_Type, s_Texts.collisionTypes);
if (EditorGUI.EndChangeCheck())
{
SyncVisualization();
}
if (type == CollisionTypes.Plane)
{
DoListOfPlanesGUI();
EditorGUI.BeginChangeCheck();
m_PlaneVisualizationType = (PlaneVizType)GUIPopup(s_Texts.visualization, (int)m_PlaneVisualizationType, s_Texts.planeVizTypes);
if (EditorGUI.EndChangeCheck())
{
EditorPrefs.SetInt("PlaneColisionVizType", (int)m_PlaneVisualizationType);
}
EditorGUI.BeginChangeCheck();
m_ScaleGrid = GUIFloat(s_Texts.scalePlane, m_ScaleGrid, "f2");
if (EditorGUI.EndChangeCheck())
{
m_ScaleGrid = Mathf.Max(0f, m_ScaleGrid);
EditorPrefs.SetFloat("ScalePlaneColision", m_ScaleGrid);
}
GUIButtonGroup(s_Texts.sceneViewEditModes, s_Texts.toolContents, GetBounds, m_ParticleSystemUI.m_ParticleEffectUI.m_Owner.customEditor);
}
else
{
GUIPopup(s_Texts.collisionMode, m_CollisionMode, s_Texts.collisionModes);
}
GUIMinMaxCurve(s_Texts.dampen, m_Dampen);
GUIMinMaxCurve(s_Texts.bounce, m_Bounce);
GUIMinMaxCurve(s_Texts.lifetimeLoss, m_LifetimeLossOnCollision);
GUIFloat(s_Texts.minKillSpeed, m_MinKillSpeed);
GUIFloat(s_Texts.maxKillSpeed, m_MaxKillSpeed);
GUIFloat(s_Texts.radiusScale, m_RadiusScale);
if (type == CollisionTypes.World)
{
GUIPopup(s_Texts.quality, m_Quality, s_Texts.qualitySettings);
EditorGUI.indentLevel++;
GUILayerMask(s_Texts.collidesWith, m_CollidesWith);
GUIInt(s_Texts.maxCollisionShapes, m_MaxCollisionShapes);
if (m_Quality.intValue == 0)
{
GUIToggle(s_Texts.collidesWithDynamic, m_CollidesWithDynamic);
}
else
{
GUIFloat(s_Texts.voxelSize, m_VoxelSize);
}
EditorGUI.indentLevel--;
GUIFloat(s_Texts.colliderForce, m_ColliderForce);
EditorGUI.indentLevel++;
GUIToggle(s_Texts.multiplyColliderForceByCollisionAngle, m_MultiplyColliderForceByCollisionAngle);
GUIToggle(s_Texts.multiplyColliderForceByParticleSpeed, m_MultiplyColliderForceByParticleSpeed);
GUIToggle(s_Texts.multiplyColliderForceByParticleSize, m_MultiplyColliderForceByParticleSize);
EditorGUI.indentLevel--;
}
GUIToggle(s_Texts.collisionMessages, m_CollisionMessages);
EditorGUI.BeginChangeCheck();
s_VisualizeBounds = GUIToggle(s_Texts.visualizeBounds, s_VisualizeBounds);
if (EditorGUI.EndChangeCheck())
{
EditorPrefs.SetBool("VisualizeBounds", s_VisualizeBounds);
}
}
public virtual void OnSceneGUI(ParticleSystem s, InitialModuleUI initial)
{
}
public override void OnSceneGUI(ParticleSystem s, InitialModuleUI initial)
{
Color color = Handles.color;
Handles.color = s_ShapeGizmoColor;
Matrix4x4 matrix = Handles.matrix;
Matrix4x4 transform = new Matrix4x4();
transform.SetTRS(s.transform.position, s.transform.rotation, s.transform.lossyScale);
Handles.matrix = transform;
EditorGUI.BeginChangeCheck();
int intValue = this.m_Type.intValue;
switch (intValue)
{
case 0:
case 1:
this.m_Radius.floatValue = Handles.DoSimpleRadiusHandle(Quaternion.identity, Vector3.zero, this.m_Radius.floatValue, false);
break;
}
if ((intValue == 10) || (intValue == 11))
{
float floatValue = this.m_Radius.floatValue;
float arc = this.m_Arc.floatValue;
Handles.DoSimpleRadiusArcHandleXY(Quaternion.identity, Vector3.zero, ref floatValue, ref arc);
this.m_Radius.floatValue = floatValue;
this.m_Arc.floatValue = arc;
}
else if ((intValue == 2) || (intValue == 3))
{
this.m_Radius.floatValue = Handles.DoSimpleRadiusHandle(Quaternion.identity, Vector3.zero, this.m_Radius.floatValue, true);
}
else if ((intValue == 4) || (intValue == 7))
{
Vector3 radiusAngleRange = new Vector3(this.m_Radius.floatValue, this.m_Angle.floatValue, initial.m_Speed.scalar.floatValue);
radiusAngleRange = Handles.ConeFrustrumHandle(Quaternion.identity, Vector3.zero, radiusAngleRange);
this.m_Radius.floatValue = radiusAngleRange.x;
this.m_Angle.floatValue = radiusAngleRange.y;
initial.m_Speed.scalar.floatValue = radiusAngleRange.z;
}
else if ((intValue == 8) || (intValue == 9))
{
Vector3 vector2 = new Vector3(this.m_Radius.floatValue, this.m_Angle.floatValue, this.m_Length.floatValue);
vector2 = Handles.ConeFrustrumHandle(Quaternion.identity, Vector3.zero, vector2);
this.m_Radius.floatValue = vector2.x;
this.m_Angle.floatValue = vector2.y;
this.m_Length.floatValue = vector2.z;
}
else
{
switch (intValue)
{
case 5:
{
Vector3 zero = Vector3.zero;
Vector3 size = new Vector3(this.m_BoxX.floatValue, this.m_BoxY.floatValue, this.m_BoxZ.floatValue);
if (this.m_BoxEditor.OnSceneGUI(transform, s_ShapeGizmoColor, false, ref zero, ref size))
{
this.m_BoxX.floatValue = size.x;
this.m_BoxY.floatValue = size.y;
this.m_BoxZ.floatValue = size.z;
}
break;
}
case 12:
this.m_Radius.floatValue = Handles.DoSimpleEdgeHandle(Quaternion.identity, Vector3.zero, this.m_Radius.floatValue);
break;
case 6:
{
Mesh objectReferenceValue = (Mesh)this.m_Mesh.objectReferenceValue;
if (objectReferenceValue != null)
{
bool wireframe = GL.wireframe;
GL.wireframe = true;
this.m_Material.SetPass(0);
Graphics.DrawMeshNow(objectReferenceValue, s.transform.localToWorldMatrix);
GL.wireframe = wireframe;
}
break;
}
}
}
if (EditorGUI.EndChangeCheck())
{
base.m_ParticleSystemUI.m_ParticleEffectUI.m_Owner.Repaint();
}
Handles.color = color;
Handles.matrix = matrix;
}
