IsDirty() private method

private IsDirty ( int instanceID ) : bool
instanceID int
return bool
 protected override void OnDisable()
 {
     base.OnDisable();
     if ((!EditorApplication.isPlaying && !InternalEditorUtility.ignoreInspectorChanges) && this.m_MightHaveModified)
     {
         this.m_MightHaveModified = false;
         string[] strArray = new string[base.targets.GetLength(0)];
         int      num      = 0;
         foreach (ProceduralTexture texture in base.targets)
         {
             SubstanceImporter atPath = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(texture)) as SubstanceImporter;
             if (atPath != null)
             {
                 atPath.OnTextureInformationsChanged(texture);
             }
             string assetPath = AssetDatabase.GetAssetPath(texture.GetProceduralMaterial());
             bool   flag      = false;
             for (int j = 0; j < num; j++)
             {
                 if (strArray[j] == assetPath)
                 {
                     flag = true;
                     break;
                 }
             }
             if (!flag)
             {
                 strArray[num++] = assetPath;
             }
         }
         for (int i = 0; i < num; i++)
         {
             SubstanceImporter importer2 = AssetImporter.GetAtPath(strArray[i]) as SubstanceImporter;
             if ((importer2 != null) && EditorUtility.IsDirty(importer2.GetInstanceID()))
             {
                 AssetDatabase.ImportAsset(strArray[i], ImportAssetOptions.ForceUncompressedImport);
             }
         }
     }
 }
        public void OnGUI(ParticleSystem root, float width, bool fixedWidth)
        {
            if (ParticleSystemUI.s_Texts == null)
            {
                ParticleSystemUI.s_Texts = new ParticleSystemUI.Texts();
            }
            bool   flag = Event.current.type == EventType.Repaint;
            string text = (!this.m_ParticleSystem) ? null : this.m_ParticleSystem.gameObject.name;

            if (fixedWidth)
            {
                EditorGUIUtility.labelWidth = width * 0.4f;
                EditorGUILayout.BeginVertical(new GUILayoutOption[]
                {
                    GUILayout.Width(width)
                });
            }
            else
            {
                EditorGUIUtility.labelWidth  = 0f;
                EditorGUIUtility.labelWidth -= 4f;
                EditorGUILayout.BeginVertical(new GUILayoutOption[0]);
            }
            for (int i = 0; i < this.m_Modules.Length; i++)
            {
                ModuleUI moduleUI = this.m_Modules[i];
                if (moduleUI != null)
                {
                    bool flag2 = moduleUI == this.m_Modules[0];
                    if (moduleUI.visibleUI || flag2)
                    {
                        GUIContent gUIContent = new GUIContent();
                        Rect       rect;
                        GUIStyle   style;
                        if (flag2)
                        {
                            rect  = GUILayoutUtility.GetRect(width, 25f);
                            style = ParticleSystemStyles.Get().emitterHeaderStyle;
                        }
                        else
                        {
                            rect  = GUILayoutUtility.GetRect(width, 15f);
                            style = ParticleSystemStyles.Get().moduleHeaderStyle;
                        }
                        if (moduleUI.foldout)
                        {
                            using (new EditorGUI.DisabledScope(!moduleUI.enabled))
                            {
                                Rect position = EditorGUILayout.BeginVertical(ParticleSystemStyles.Get().modulePadding, new GUILayoutOption[0]);
                                position.y      -= 4f;
                                position.height += 4f;
                                GUI.Label(position, GUIContent.none, ParticleSystemStyles.Get().moduleBgStyle);
                                moduleUI.OnInspectorGUI(this.m_ParticleSystem);
                                EditorGUILayout.EndVertical();
                            }
                        }
                        if (flag2)
                        {
                            ParticleSystemRenderer particleSystemRenderer = this.GetParticleSystemRenderer();
                            float num       = 21f;
                            Rect  position2 = new Rect(rect.x + 4f, rect.y + 2f, num, num);
                            if (flag && particleSystemRenderer != null)
                            {
                                bool             flag3            = false;
                                int              num2             = 0;
                                RendererModuleUI rendererModuleUI = this.m_Modules[this.m_Modules.Length - 1] as RendererModuleUI;
                                if (rendererModuleUI != null)
                                {
                                    if (rendererModuleUI.IsMeshEmitter())
                                    {
                                        if (particleSystemRenderer.mesh != null)
                                        {
                                            num2 = particleSystemRenderer.mesh.GetInstanceID();
                                        }
                                    }
                                    else if (particleSystemRenderer.sharedMaterial != null)
                                    {
                                        num2 = particleSystemRenderer.sharedMaterial.GetInstanceID();
                                    }
                                    if (EditorUtility.IsDirty(num2))
                                    {
                                        AssetPreview.ClearTemporaryAssetPreviews();
                                    }
                                }
                                if (num2 != 0)
                                {
                                    Texture2D assetPreview = AssetPreview.GetAssetPreview(num2);
                                    if (assetPreview != null)
                                    {
                                        GUI.DrawTexture(position2, assetPreview, ScaleMode.StretchToFill, true);
                                        flag3 = true;
                                    }
                                }
                                if (!flag3)
                                {
                                    GUI.Label(position2, GUIContent.none, ParticleSystemStyles.Get().moduleBgStyle);
                                }
                            }
                            if (EditorGUI.ButtonMouseDown(position2, GUIContent.none, FocusType.Passive, GUIStyle.none))
                            {
                                if (EditorGUI.actionKey)
                                {
                                    List <int> list       = new List <int>();
                                    int        instanceID = this.m_ParticleSystem.gameObject.GetInstanceID();
                                    list.AddRange(Selection.instanceIDs);
                                    if (!list.Contains(instanceID) || list.Count != 1)
                                    {
                                        if (list.Contains(instanceID))
                                        {
                                            list.Remove(instanceID);
                                        }
                                        else
                                        {
                                            list.Add(instanceID);
                                        }
                                    }
                                    Selection.instanceIDs = list.ToArray();
                                }
                                else
                                {
                                    Selection.instanceIDs      = new int[0];
                                    Selection.activeInstanceID = this.m_ParticleSystem.gameObject.GetInstanceID();
                                }
                            }
                        }
                        Rect position3 = new Rect(rect.x + 2f, rect.y + 1f, 13f, 13f);
                        if (!flag2 && GUI.Button(position3, GUIContent.none, GUIStyle.none))
                        {
                            moduleUI.enabled = !moduleUI.enabled;
                        }
                        Rect position4 = new Rect(rect.x + rect.width - 10f, rect.y + rect.height - 10f, 10f, 10f);
                        Rect position5 = new Rect(position4.x - 4f, position4.y - 4f, position4.width + 4f, position4.height + 4f);
                        Rect position6 = new Rect(position4.x - 23f, position4.y - 3f, 16f, 16f);
                        if (flag2 && EditorGUI.ButtonMouseDown(position5, ParticleSystemUI.s_Texts.addModules, FocusType.Passive, GUIStyle.none))
                        {
                            this.ShowAddModuleMenu();
                        }
                        if (!string.IsNullOrEmpty(text))
                        {
                            gUIContent.text = ((!flag2) ? moduleUI.displayName : text);
                        }
                        else
                        {
                            gUIContent.text = moduleUI.displayName;
                        }
                        gUIContent.tooltip = moduleUI.toolTip;
                        bool flag4 = GUI.Toggle(rect, moduleUI.foldout, gUIContent, style);
                        if (flag4 != moduleUI.foldout)
                        {
                            int button = Event.current.button;
                            if (button != 0)
                            {
                                if (button == 1)
                                {
                                    if (flag2)
                                    {
                                        this.ShowEmitterMenu();
                                    }
                                    else
                                    {
                                        this.ShowModuleMenu(i);
                                    }
                                }
                            }
                            else
                            {
                                bool foldout = !moduleUI.foldout;
                                if (Event.current.control)
                                {
                                    ModuleUI[] modules = this.m_Modules;
                                    for (int j = 0; j < modules.Length; j++)
                                    {
                                        ModuleUI moduleUI2 = modules[j];
                                        if (moduleUI2 != null && moduleUI2.visibleUI)
                                        {
                                            moduleUI2.foldout = foldout;
                                        }
                                    }
                                }
                                else
                                {
                                    moduleUI.foldout = foldout;
                                }
                            }
                        }
                        if (!flag2)
                        {
                            GUI.Toggle(position3, moduleUI.enabled, GUIContent.none, ParticleSystemStyles.Get().checkmark);
                        }
                        if (flag)
                        {
                            if (flag2)
                            {
                                GUI.Label(position4, GUIContent.none, ParticleSystemStyles.Get().plus);
                            }
                        }
                        ParticleSystemUI.s_Texts.supportsCullingText.tooltip = this.m_SupportsCullingText;
                        if (flag2 && ParticleSystemUI.s_Texts.supportsCullingText.tooltip != null)
                        {
                            GUI.Label(position6, ParticleSystemUI.s_Texts.supportsCullingText);
                        }
                        GUILayout.Space(1f);
                    }
                }
            }
            GUILayout.Space(-1f);
            EditorGUILayout.EndVertical();
            this.ApplyProperties();
        }
        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;
                            int  instanceID   = 0;

                            if (!multiEdit)
                            {
                                if (renderer.renderMode == ParticleSystemRenderMode.Mesh)
                                {
                                    if (renderer.mesh != null)
                                    {
                                        instanceID = renderer.mesh.GetInstanceID();
                                    }
                                }
                                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 (EditorUtility.IsDirty(instanceID))
                                {
                                    AssetPreview.ClearTemporaryAssetPreviews();
                                }

                                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().checkmarkMixed : ParticleSystemStyles.Get().checkmark;
                        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();
        }
示例#4
0
        public void OnGUI(ParticleSystem root, float width, bool fixedWidth)
        {
            if (s_Texts == null)
            {
                s_Texts = new Texts();
            }
            bool   flag = Event.current.type == EventType.Repaint;
            string str  = (this.m_ParticleSystem == null) ? null : this.m_ParticleSystem.gameObject.name;

            if (fixedWidth)
            {
                EditorGUIUtility.labelWidth = width * 0.55f;
                GUILayoutOption[] options = new GUILayoutOption[] { GUILayout.Width(width) };
                EditorGUILayout.BeginVertical(options);
            }
            else
            {
                EditorGUIUtility.labelWidth  = 0f;
                EditorGUIUtility.labelWidth -= 4f;
                EditorGUILayout.BeginVertical(new GUILayoutOption[0]);
            }
            for (int i = 0; i < this.m_Modules.Length; i++)
            {
                GUIStyle emitterHeaderStyle;
                Rect     rect;
                bool     flag5;
                ModuleUI eui = this.m_Modules[i];
                if (eui == null)
                {
                    continue;
                }
                bool flag2 = eui == this.m_Modules[0];
                if (!eui.visibleUI && !flag2)
                {
                    continue;
                }
                GUIContent content = new GUIContent();
                if (flag2)
                {
                    rect = GUILayoutUtility.GetRect(width, 25f);
                    emitterHeaderStyle = ParticleSystemStyles.Get().emitterHeaderStyle;
                }
                else
                {
                    rect = GUILayoutUtility.GetRect(width, 15f);
                    emitterHeaderStyle = ParticleSystemStyles.Get().moduleHeaderStyle;
                }
                if (eui.foldout)
                {
                    EditorGUI.BeginDisabledGroup(!eui.enabled);
                    Rect rect2 = EditorGUILayout.BeginVertical(ParticleSystemStyles.Get().modulePadding, new GUILayoutOption[0]);
                    rect2.y      -= 4f;
                    rect2.height += 4f;
                    GUI.Label(rect2, GUIContent.none, ParticleSystemStyles.Get().moduleBgStyle);
                    eui.OnInspectorGUI(this.m_ParticleSystem);
                    EditorGUILayout.EndVertical();
                    EditorGUI.EndDisabledGroup();
                }
                if (flag2)
                {
                    ParticleSystemRenderer particleSystemRenderer = this.GetParticleSystemRenderer();
                    float num2  = 21f;
                    Rect  rect3 = new Rect(rect.x + 4f, rect.y + 2f, num2, num2);
                    if (flag && (particleSystemRenderer != null))
                    {
                        bool             flag3      = false;
                        int              instanceID = 0;
                        RendererModuleUI eui2       = this.m_Modules[this.m_Modules.Length - 1] as RendererModuleUI;
                        if (eui2 != null)
                        {
                            if (eui2.IsMeshEmitter())
                            {
                                if (particleSystemRenderer.mesh != null)
                                {
                                    instanceID = particleSystemRenderer.mesh.GetInstanceID();
                                }
                            }
                            else if (particleSystemRenderer.sharedMaterial != null)
                            {
                                instanceID = particleSystemRenderer.sharedMaterial.GetInstanceID();
                            }
                            if (EditorUtility.IsDirty(instanceID))
                            {
                                AssetPreview.ClearTemporaryAssetPreviews();
                            }
                        }
                        if (instanceID != 0)
                        {
                            Texture2D assetPreview = AssetPreview.GetAssetPreview(instanceID);
                            if (assetPreview != null)
                            {
                                GUI.DrawTexture(rect3, assetPreview, ScaleMode.StretchToFill, true);
                                flag3 = true;
                            }
                        }
                        if (!flag3)
                        {
                            GUI.Label(rect3, GUIContent.none, ParticleSystemStyles.Get().moduleBgStyle);
                        }
                    }
                    if (EditorGUI.ButtonMouseDown(rect3, GUIContent.none, FocusType.Passive, GUIStyle.none))
                    {
                        if (EditorGUI.actionKey)
                        {
                            List <int> list = new List <int>();
                            int        item = this.m_ParticleSystem.gameObject.GetInstanceID();
                            list.AddRange(Selection.instanceIDs);
                            if (!list.Contains(item) || (list.Count != 1))
                            {
                                if (list.Contains(item))
                                {
                                    list.Remove(item);
                                }
                                else
                                {
                                    list.Add(item);
                                }
                            }
                            Selection.instanceIDs = list.ToArray();
                        }
                        else
                        {
                            Selection.instanceIDs      = new int[0];
                            Selection.activeInstanceID = this.m_ParticleSystem.gameObject.GetInstanceID();
                        }
                    }
                }
                Rect position = new Rect(rect.x + 2f, rect.y + 1f, 13f, 13f);
                if (!flag2 && GUI.Button(position, GUIContent.none, GUIStyle.none))
                {
                    eui.enabled = !eui.enabled;
                }
                Rect rect5 = new Rect((rect.x + rect.width) - 10f, (rect.y + rect.height) - 10f, 10f, 10f);
                Rect rect6 = new Rect(rect5.x - 4f, rect5.y - 4f, rect5.width + 4f, rect5.height + 4f);
                Rect rect7 = new Rect(rect5.x - 23f, rect5.y - 3f, 16f, 16f);
                if (flag2 && EditorGUI.ButtonMouseDown(rect6, s_Texts.addModules, FocusType.Passive, GUIStyle.none))
                {
                    this.ShowAddModuleMenu();
                }
                if (!string.IsNullOrEmpty(str))
                {
                    content.text = !flag2 ? eui.displayName : str;
                }
                else
                {
                    content.text = eui.displayName;
                }
                content.tooltip = eui.toolTip;
                if (GUI.Toggle(rect, eui.foldout, content, emitterHeaderStyle) != eui.foldout)
                {
                    switch (Event.current.button)
                    {
                    case 0:
                        flag5 = !eui.foldout;
                        if (!Event.current.control)
                        {
                            goto Label_057E;
                        }
                        foreach (ModuleUI eui3 in this.m_Modules)
                        {
                            if ((eui3 != null) && eui3.visibleUI)
                            {
                                eui3.foldout = flag5;
                            }
                        }
                        break;

                    case 1:
                        if (flag2)
                        {
                            this.ShowEmitterMenu();
                        }
                        else
                        {
                            this.ShowModuleMenu(i);
                        }
                        break;
                    }
                }
                goto Label_05A9;
Label_057E:
                eui.foldout = flag5;
Label_05A9:
                if (!flag2)
                {
                    GUI.Toggle(position, eui.enabled, GUIContent.none, ParticleSystemStyles.Get().checkmark);
                }
                if (flag && flag2)
                {
                    GUI.Label(rect5, GUIContent.none, ParticleSystemStyles.Get().plus);
                }
                s_Texts.supportsCullingText.tooltip = m_SupportsCullingText;
                if (flag2 && (s_Texts.supportsCullingText.tooltip != null))
                {
                    GUI.Label(rect7, s_Texts.supportsCullingText);
                }
                GUILayout.Space(1f);
            }
            GUILayout.Space(-1f);
            EditorGUILayout.EndVertical();
            this.ApplyProperties();
        }
        public void OnGUI(ParticleSystem root, float width, bool fixedWidth)
        {
            if (ParticleSystemUI.s_Texts == null)
            {
                ParticleSystemUI.s_Texts = new ParticleSystemUI.Texts();
            }
            bool   flag1 = Event.current.type == EventType.Repaint;
            string str   = !(bool)((Object)this.m_ParticleSystem) ? (string)null : this.m_ParticleSystem.gameObject.name;

            if (fixedWidth)
            {
                EditorGUIUtility.labelWidth = width * 0.55f;
                EditorGUILayout.BeginVertical(GUILayout.Width(width));
            }
            else
            {
                EditorGUIUtility.labelWidth  = 0.0f;
                EditorGUIUtility.labelWidth -= 4f;
                EditorGUILayout.BeginVertical();
            }
            for (int moduleIndex = 0; moduleIndex < this.m_Modules.Length; ++moduleIndex)
            {
                ModuleUI module1 = this.m_Modules[moduleIndex];
                if (module1 != null)
                {
                    bool flag2 = module1 == this.m_Modules[0];
                    if (module1.visibleUI || flag2)
                    {
                        GUIContent content = new GUIContent();
                        Rect       rect;
                        GUIStyle   style;
                        if (flag2)
                        {
                            rect  = GUILayoutUtility.GetRect(width, 25f);
                            style = ParticleSystemStyles.Get().emitterHeaderStyle;
                        }
                        else
                        {
                            rect  = GUILayoutUtility.GetRect(width, 15f);
                            style = ParticleSystemStyles.Get().moduleHeaderStyle;
                        }
                        if (module1.foldout)
                        {
                            EditorGUI.BeginDisabledGroup(!module1.enabled);
                            Rect position = EditorGUILayout.BeginVertical(ParticleSystemStyles.Get().modulePadding, new GUILayoutOption[0]);
                            position.y      -= 4f;
                            position.height += 4f;
                            GUI.Label(position, GUIContent.none, ParticleSystemStyles.Get().moduleBgStyle);
                            module1.OnInspectorGUI(this.m_ParticleSystem);
                            EditorGUILayout.EndVertical();
                            EditorGUI.EndDisabledGroup();
                        }
                        if (flag2)
                        {
                            ParticleSystemRenderer particleSystemRenderer = this.GetParticleSystemRenderer();
                            float num      = 21f;
                            Rect  position = new Rect(rect.x + 4f, rect.y + 2f, num, num);
                            if (flag1 && (Object)particleSystemRenderer != (Object)null)
                            {
                                bool             flag3      = false;
                                int              instanceID = 0;
                                RendererModuleUI module2    = this.m_Modules[this.m_Modules.Length - 1] as RendererModuleUI;
                                if (module2 != null)
                                {
                                    if (module2.IsMeshEmitter())
                                    {
                                        if ((Object)particleSystemRenderer.mesh != (Object)null)
                                        {
                                            instanceID = particleSystemRenderer.mesh.GetInstanceID();
                                        }
                                    }
                                    else if ((Object)particleSystemRenderer.sharedMaterial != (Object)null)
                                    {
                                        instanceID = particleSystemRenderer.sharedMaterial.GetInstanceID();
                                    }
                                    if (EditorUtility.IsDirty(instanceID))
                                    {
                                        AssetPreview.ClearTemporaryAssetPreviews();
                                    }
                                }
                                if (instanceID != 0)
                                {
                                    Texture2D assetPreview = AssetPreview.GetAssetPreview(instanceID);
                                    if ((Object)assetPreview != (Object)null)
                                    {
                                        GUI.DrawTexture(position, (Texture)assetPreview, ScaleMode.StretchToFill, true);
                                        flag3 = true;
                                    }
                                }
                                if (!flag3)
                                {
                                    GUI.Label(position, GUIContent.none, ParticleSystemStyles.Get().moduleBgStyle);
                                }
                            }
                            if (EditorGUI.ButtonMouseDown(position, GUIContent.none, FocusType.Passive, GUIStyle.none))
                            {
                                if (EditorGUI.actionKey)
                                {
                                    List <int> intList    = new List <int>();
                                    int        instanceId = this.m_ParticleSystem.gameObject.GetInstanceID();
                                    intList.AddRange((IEnumerable <int>)Selection.instanceIDs);
                                    if (!intList.Contains(instanceId) || intList.Count != 1)
                                    {
                                        if (intList.Contains(instanceId))
                                        {
                                            intList.Remove(instanceId);
                                        }
                                        else
                                        {
                                            intList.Add(instanceId);
                                        }
                                    }
                                    Selection.instanceIDs = intList.ToArray();
                                }
                                else
                                {
                                    Selection.instanceIDs      = new int[0];
                                    Selection.activeInstanceID = this.m_ParticleSystem.gameObject.GetInstanceID();
                                }
                            }
                        }
                        Rect position1 = new Rect(rect.x + 2f, rect.y + 1f, 13f, 13f);
                        if (!flag2 && GUI.Button(position1, GUIContent.none, GUIStyle.none))
                        {
                            module1.enabled = !module1.enabled;
                        }
                        Rect position2 = new Rect((float)((double)rect.x + (double)rect.width - 10.0), (float)((double)rect.y + (double)rect.height - 10.0), 10f, 10f);
                        Rect position3 = new Rect(position2.x - 4f, position2.y - 4f, position2.width + 4f, position2.height + 4f);
                        Rect position4 = new Rect(position2.x - 23f, position2.y - 3f, 16f, 16f);
                        if (flag2 && EditorGUI.ButtonMouseDown(position3, ParticleSystemUI.s_Texts.addModules, FocusType.Passive, GUIStyle.none))
                        {
                            this.ShowAddModuleMenu();
                        }
                        content.text    = string.IsNullOrEmpty(str) ? module1.displayName : (!flag2 ? module1.displayName : str);
                        content.tooltip = module1.toolTip;
                        if (GUI.Toggle(rect, module1.foldout, content, style) != module1.foldout)
                        {
                            switch (Event.current.button)
                            {
                            case 0:
                                bool flag4 = !module1.foldout;
                                if (Event.current.control)
                                {
                                    foreach (ModuleUI module2 in this.m_Modules)
                                    {
                                        if (module2 != null && module2.visibleUI)
                                        {
                                            module2.foldout = flag4;
                                        }
                                    }
                                    break;
                                }
                                module1.foldout = flag4;
                                break;

                            case 1:
                                if (flag2)
                                {
                                    this.ShowEmitterMenu();
                                    break;
                                }
                                this.ShowModuleMenu(moduleIndex);
                                break;
                            }
                        }
                        if (!flag2)
                        {
                            GUI.Toggle(position1, module1.enabled, GUIContent.none, ParticleSystemStyles.Get().checkmark);
                        }
                        if (flag1 && flag2)
                        {
                            GUI.Label(position2, GUIContent.none, ParticleSystemStyles.Get().plus);
                        }
                        ParticleSystemUI.s_Texts.supportsCullingText.tooltip = ParticleSystemUI.m_SupportsCullingText;
                        if (flag2 && ParticleSystemUI.s_Texts.supportsCullingText.tooltip != null)
                        {
                            GUI.Label(position4, ParticleSystemUI.s_Texts.supportsCullingText);
                        }
                        GUILayout.Space(1f);
                    }
                }
            }
            GUILayout.Space(-1f);
            EditorGUILayout.EndVertical();
            this.ApplyProperties();
        }
 public void OnDisable()
 {
     DevDeviceList.Changed -= OnDeviceListChanged;
     if (m_EditorUserSettings.targetObject != null && EditorUtility.IsDirty(m_EditorUserSettings.targetObject))
         InternalEditorUtility.SaveToSerializedFileAndForget(new[] { m_EditorUserSettings.targetObject }, kEditorUserSettingsPath, true);
 }