Exemplo n.º 1
0
        public override void OnInspectorGUI()
        {
            var style = new GUIStyle(EditorStyles.toolbar);

            style.fixedHeight   = 0f;
            style.stretchHeight = true;

            var backStyle = new GUIStyle(EditorStyles.label);

            backStyle.normal.background = Texture2D.whiteTexture;

            var dataConfig = (ME.ECS.DataConfigs.DataConfig) this.target;

            if (DataConfigEditor.worldEditors.TryGetValue(this.target, out var worldEditor) == false)
            {
                worldEditor = new WorldsViewerEditor.WorldEditor();
                DataConfigEditor.worldEditors.Add(this.target, worldEditor);
            }

            GUILayoutExt.Padding(8f, () => {
                var usedComponents = new System.Collections.Generic.HashSet <System.Type>();

                var kz               = 0;
                var registries       = dataConfig.structComponents;
                var sortedRegistries = new System.Collections.Generic.SortedDictionary <int, Registry>(new WorldsViewerEditor.DuplicateKeyComparer <int>());
                for (int i = 0; i < registries.Length; ++i)
                {
                    var registry = registries[i];
                    if (registry == null)
                    {
                        continue;
                    }

                    var component = registry;
                    usedComponents.Add(component.GetType());

                    var editor = WorldsViewerEditor.GetEditor(component, out var order);
                    if (editor != null)
                    {
                        sortedRegistries.Add(order, new Registry()
                        {
                            index = i,
                            data  = component
                        });
                    }
                    else
                    {
                        sortedRegistries.Add(0, new Registry()
                        {
                            index = i,
                            data  = component
                        });
                    }
                }

                foreach (var registryKv in sortedRegistries)
                {
                    var registry  = registryKv.Value;
                    var component = registry.data;

                    var backColor       = GUI.backgroundColor;
                    GUI.backgroundColor = new Color(1f, 1f, 1f, kz++ % 2 == 0 ? 0f : 0.05f);

                    GUILayout.BeginVertical(backStyle);
                    {
                        GUI.backgroundColor = backColor;
                        var editor          = WorldsViewerEditor.GetEditor(component);
                        if (editor != null)
                        {
                            EditorGUI.BeginChangeCheck();
                            editor.OnDrawGUI();
                            if (EditorGUI.EndChangeCheck() == true)
                            {
                                component = editor.GetTarget <IStructComponent>();
                                dataConfig.structComponents[registry.index] = component;
                            }
                        }
                        else
                        {
                            var componentName = component.GetType().Name;
                            var fieldsCount   = GUILayoutExt.GetFieldsCount(component);
                            if (fieldsCount == 0)
                            {
                                EditorGUI.BeginDisabledGroup(true);
                                EditorGUILayout.Toggle(componentName, true);
                                EditorGUI.EndDisabledGroup();
                            }
                            else if (fieldsCount == 1)
                            {
                                var changed = GUILayoutExt.DrawFields(worldEditor, component, componentName);
                                if (changed == true)
                                {
                                    dataConfig.structComponents[registry.index] = component;
                                }
                            }
                            else
                            {
                                GUILayout.BeginHorizontal();
                                {
                                    GUILayout.Space(18f);
                                    GUILayout.BeginVertical();
                                    {
                                        var key     = "ME.ECS.WorldsViewerEditor.FoldoutTypes." + component.GetType().FullName;
                                        var foldout = EditorPrefs.GetBool(key, true);
                                        GUILayoutExt.FoldOut(ref foldout, componentName, () => {
                                            var changed = GUILayoutExt.DrawFields(worldEditor, component);
                                            if (changed == true)
                                            {
                                                dataConfig.structComponents[registry.index] = component;
                                            }
                                        });
                                        EditorPrefs.SetBool(key, foldout);
                                    }
                                    GUILayout.EndVertical();
                                }
                                GUILayout.EndHorizontal();
                            }
                        }
                    }
                    GUILayout.EndVertical();

                    GUILayoutExt.Separator();
                }

                GUILayoutExt.DrawAddComponentMenu(usedComponents, (addType, isUsed) => {
                    if (isUsed == true)
                    {
                        usedComponents.Remove(addType);
                        for (int i = 0; i < dataConfig.structComponents.Length; ++i)
                        {
                            if (dataConfig.structComponents[i].GetType() == addType)
                            {
                                var list = dataConfig.structComponents.ToList();
                                list.RemoveAt(i);
                                dataConfig.structComponents = list.ToArray();
                                dataConfig.OnScriptLoad();
                                break;
                            }
                        }
                    }
                    else
                    {
                        usedComponents.Add(addType);
                        System.Array.Resize(ref dataConfig.structComponents, dataConfig.structComponents.Length + 1);
                        dataConfig.structComponents[dataConfig.structComponents.Length - 1] = (IStructComponent)System.Activator.CreateInstance(addType);
                        dataConfig.OnScriptLoad();
                    }
                });
            });

            GUILayoutExt.Padding(8f, () => {
                var usedComponents = new System.Collections.Generic.HashSet <System.Type>();

                var kz               = 0;
                var registries       = dataConfig.components;
                var sortedRegistries = new System.Collections.Generic.SortedDictionary <int, RegistryComponent>(new WorldsViewerEditor.DuplicateKeyComparer <int>());
                for (int i = 0; i < registries.Length; ++i)
                {
                    var registry = registries[i];
                    if (registry == null)
                    {
                        continue;
                    }

                    var component = registry;
                    usedComponents.Add(component.GetType());

                    var editor = WorldsViewerEditor.GetEditor(component, out var order);
                    if (editor != null)
                    {
                        sortedRegistries.Add(order, new RegistryComponent()
                        {
                            index = i,
                            data  = component
                        });
                    }
                    else
                    {
                        sortedRegistries.Add(0, new RegistryComponent()
                        {
                            index = i,
                            data  = component
                        });
                    }
                }

                foreach (var registryKv in sortedRegistries)
                {
                    var registry  = registryKv.Value;
                    var component = registry.data;

                    var backColor       = GUI.backgroundColor;
                    GUI.backgroundColor = new Color(1f, 1f, 1f, kz++ % 2 == 0 ? 0f : 0.05f);

                    GUILayout.BeginVertical(backStyle);
                    {
                        GUI.backgroundColor = backColor;
                        var editor          = WorldsViewerEditor.GetEditor(component);
                        if (editor != null)
                        {
                            EditorGUI.BeginChangeCheck();
                            editor.OnDrawGUI();
                            if (EditorGUI.EndChangeCheck() == true)
                            {
                                component = editor.GetTarget <IComponent>();
                                dataConfig.components[registry.index] = component;
                            }
                        }
                        else
                        {
                            var componentName = component.GetType().Name;
                            var fieldsCount   = GUILayoutExt.GetFieldsCount(component);
                            if (fieldsCount == 0)
                            {
                                EditorGUI.BeginDisabledGroup(true);
                                EditorGUILayout.Toggle(componentName, true);
                                EditorGUI.EndDisabledGroup();
                            }
                            else if (fieldsCount == 1)
                            {
                                var changed = GUILayoutExt.DrawFields(worldEditor, component, componentName);
                                if (changed == true)
                                {
                                    dataConfig.components[registry.index] = component;
                                }
                            }
                            else
                            {
                                GUILayout.BeginHorizontal();
                                {
                                    GUILayout.Space(18f);
                                    GUILayout.BeginVertical();
                                    {
                                        var key     = "ME.ECS.WorldsViewerEditor.FoldoutTypes." + component.GetType().FullName;
                                        var foldout = EditorPrefs.GetBool(key, true);
                                        GUILayoutExt.FoldOut(ref foldout, componentName, () => {
                                            var changed = GUILayoutExt.DrawFields(worldEditor, component);
                                            if (changed == true)
                                            {
                                                dataConfig.components[registry.index] = component;
                                            }
                                        });
                                        EditorPrefs.SetBool(key, foldout);
                                    }
                                    GUILayout.EndVertical();
                                }
                                GUILayout.EndHorizontal();
                            }
                        }
                    }
                    GUILayout.EndVertical();

                    GUILayoutExt.Separator();
                }

                GUILayoutExt.DrawAddComponentMenu(usedComponents, (addType, isUsed) => {
                    if (isUsed == true)
                    {
                        usedComponents.Remove(addType);
                        for (int i = 0; i < dataConfig.components.Length; ++i)
                        {
                            if (dataConfig.components[i].GetType() == addType)
                            {
                                var list = dataConfig.components.ToList();
                                list.RemoveAt(i);
                                dataConfig.components = list.ToArray();
                                dataConfig.OnScriptLoad();
                                break;
                            }
                        }
                    }
                    else
                    {
                        usedComponents.Add(addType);
                        System.Array.Resize(ref dataConfig.components, dataConfig.components.Length + 1);
                        dataConfig.components[dataConfig.components.Length - 1] = (IComponent)System.Activator.CreateInstance(addType);
                        dataConfig.OnScriptLoad();
                    }
                }, drawRefComponents: true);
            });
        }
Exemplo n.º 2
0
        public override void OnInspectorGUI()
        {
            var style = new GUIStyle(EditorStyles.toolbar);

            style.fixedHeight   = 0f;
            style.stretchHeight = true;

            var backStyle = new GUIStyle(EditorStyles.label);

            backStyle.normal.background = Texture2D.whiteTexture;

            var slice      = new ME.ECS.DataConfigs.DataConfigSlice();
            var isMultiple = false;

            if (this.targets.Length > 1)
            {
                slice      = ME.ECS.DataConfigs.DataConfigSlice.Distinct(this.targets.Cast <ME.ECS.DataConfigs.DataConfig>().ToArray());
                isMultiple = true;
            }
            else
            {
                var config = (ME.ECS.DataConfigs.DataConfig) this.target;
                slice = new ME.ECS.DataConfigs.DataConfigSlice()
                {
                    configs = new [] {
                        config
                    },
                    structComponentsDataTypeIds = config.structComponentsDataTypeIds,
                    componentsTypeIds           = config.componentsTypeIds
                };
            }

            var usedComponentsAll = new System.Collections.Generic.HashSet <System.Type>();

            foreach (var cfg in slice.configs)
            {
                var componentTypes = cfg.GetStructComponentTypes();
                foreach (var cType in componentTypes)
                {
                    if (usedComponentsAll.Contains(cType) == false)
                    {
                        usedComponentsAll.Add(cType);
                    }
                }

                if (DataConfigEditor.worldEditors.TryGetValue(cfg, out var worldEditor) == false)
                {
                    worldEditor = new WorldsViewerEditor.WorldEditor();
                    DataConfigEditor.worldEditors.Add(cfg, worldEditor);
                }
            }

            if (isMultiple == true)
            {
                GUILayoutExt.DrawHeader("The same components:");

                GUILayoutExt.Padding(8f, () => {
                    var kz = 0;
                    for (int i = 0; i < slice.structComponentsDataTypeIds.Length; ++i)
                    {
                        var typeId     = slice.structComponentsDataTypeIds[i];
                        var component  = slice.configs[0].GetByTypeId(typeId);
                        var components = slice.configs.Select(x => x.GetByTypeId(typeId)).ToArray();

                        var backColor       = GUI.backgroundColor;
                        GUI.backgroundColor = new Color(1f, 1f, 1f, kz++ % 2 == 0 ? 0f : 0.05f);

                        GUILayout.BeginVertical(backStyle);
                        {
                            GUI.backgroundColor = backColor;
                            var editor          = WorldsViewerEditor.GetEditor(components);
                            if (editor != null)
                            {
                                EditorGUI.BeginChangeCheck();
                                editor.OnDrawGUI();
                                if (EditorGUI.EndChangeCheck() == true)
                                {
                                    slice.Set(typeId, components);
                                    this.Save(slice.configs);
                                }
                            }
                            else
                            {
                                var componentName = GUILayoutExt.GetStringCamelCaseSpace(component.GetType().Name);
                                var fieldsCount   = GUILayoutExt.GetFieldsCount(component);
                                if (fieldsCount == 0)
                                {
                                    EditorGUI.BeginDisabledGroup(true);
                                    EditorGUILayout.Toggle(componentName, true);
                                    EditorGUI.EndDisabledGroup();
                                }
                                else if (fieldsCount == 1)
                                {
                                    var changed = GUILayoutExt.DrawFields(DataConfigEditor.multipleWorldEditor, components, componentName);
                                    if (changed == true)
                                    {
                                        slice.Set(typeId, components);
                                        this.Save(slice.configs);
                                    }
                                }
                                else
                                {
                                    GUILayout.BeginHorizontal();
                                    {
                                        GUILayout.Space(18f);
                                        GUILayout.BeginVertical();
                                        {
                                            var key     = "ME.ECS.WorldsViewerEditor.FoldoutTypes." + component.GetType().FullName;
                                            var foldout = EditorPrefs.GetBool(key, true);
                                            GUILayoutExt.FoldOut(ref foldout, componentName, () => {
                                                var changed = GUILayoutExt.DrawFields(DataConfigEditor.multipleWorldEditor, components);
                                                if (changed == true)
                                                {
                                                    slice.Set(typeId, components);
                                                    this.Save(slice.configs);
                                                }
                                            });
                                            EditorPrefs.SetBool(key, foldout);
                                        }
                                        GUILayout.EndVertical();
                                    }
                                    GUILayout.EndHorizontal();
                                }
                            }

                            GUILayoutExt.DrawComponentHelp(component.GetType());
                        }
                        GUILayout.EndVertical();

                        GUILayoutExt.Separator();
                    }
                });

                GUILayoutExt.DrawAddComponentMenu(usedComponentsAll, (addType, isUsed) => {
                    foreach (var dataConfigInner in slice.configs)
                    {
                        if (isUsed == true)
                        {
                            usedComponentsAll.Remove(addType);
                            for (int i = 0; i < dataConfigInner.structComponents.Length; ++i)
                            {
                                if (dataConfigInner.structComponents[i].GetType() == addType)
                                {
                                    var list = dataConfigInner.structComponents.ToList();
                                    list.RemoveAt(i);
                                    dataConfigInner.structComponents = list.ToArray();
                                    dataConfigInner.OnScriptLoad();
                                    this.Save(dataConfigInner);
                                    break;
                                }
                            }
                        }
                        else
                        {
                            usedComponentsAll.Add(addType);
                            System.Array.Resize(ref dataConfigInner.structComponents, dataConfigInner.structComponents.Length + 1);
                            dataConfigInner.structComponents[dataConfigInner.structComponents.Length - 1] = (IStructComponent)System.Activator.CreateInstance(addType);
                            dataConfigInner.OnScriptLoad();
                            this.Save(dataConfigInner);
                        }
                    }
                });

                return;
            }

            GUILayoutExt.Separator(6f);
            GUILayoutExt.DrawHeader("Add Struct Components:");
            GUILayoutExt.Separator();

            var dataConfig = (ME.ECS.DataConfigs.DataConfig) this.target;

            GUILayoutExt.Padding(8f, () => {
                var usedComponents = new System.Collections.Generic.HashSet <System.Type>();

                var kz               = 0;
                var registries       = dataConfig.structComponents;
                var sortedRegistries = new System.Collections.Generic.SortedDictionary <int, Registry>(new WorldsViewerEditor.DuplicateKeyComparer <int>());
                for (int i = 0; i < registries.Length; ++i)
                {
                    var registry = registries[i];
                    if (registry == null)
                    {
                        continue;
                    }

                    var component = registry;
                    usedComponents.Add(component.GetType());

                    var editor = WorldsViewerEditor.GetEditor(component, out var order);
                    if (editor != null)
                    {
                        sortedRegistries.Add(order, new Registry()
                        {
                            index = i,
                            data  = component
                        });
                    }
                    else
                    {
                        sortedRegistries.Add(0, new Registry()
                        {
                            index = i,
                            data  = component
                        });
                    }
                }

                foreach (var registryKv in sortedRegistries)
                {
                    var registry  = registryKv.Value;
                    var component = registry.data;

                    var backColor       = GUI.backgroundColor;
                    GUI.backgroundColor = new Color(1f, 1f, 1f, kz++ % 2 == 0 ? 0f : 0.05f);

                    GUILayout.BeginVertical(backStyle);
                    {
                        GUI.backgroundColor = backColor;
                        var editor          = WorldsViewerEditor.GetEditor(component);
                        if (editor != null)
                        {
                            EditorGUI.BeginChangeCheck();
                            editor.OnDrawGUI();
                            if (EditorGUI.EndChangeCheck() == true)
                            {
                                component = editor.GetTarget <IStructComponent>();
                                dataConfig.structComponents[registry.index] = component;
                                this.Save(dataConfig);
                            }
                        }
                        else
                        {
                            var componentName = GUILayoutExt.GetStringCamelCaseSpace(component.GetType().Name);
                            var fieldsCount   = GUILayoutExt.GetFieldsCount(component);
                            if (fieldsCount == 0)
                            {
                                EditorGUI.BeginDisabledGroup(true);
                                EditorGUILayout.Toggle(componentName, true);
                                EditorGUI.EndDisabledGroup();
                            }
                            else if (fieldsCount == 1)
                            {
                                var changed = GUILayoutExt.DrawFields(DataConfigEditor.multipleWorldEditor, component, componentName);
                                if (changed == true)
                                {
                                    dataConfig.structComponents[registry.index] = component;
                                    this.Save(dataConfig);
                                }
                            }
                            else
                            {
                                GUILayout.BeginHorizontal();
                                {
                                    GUILayout.Space(18f);
                                    GUILayout.BeginVertical();
                                    {
                                        var key     = "ME.ECS.WorldsViewerEditor.FoldoutTypes." + component.GetType().FullName;
                                        var foldout = EditorPrefs.GetBool(key, true);
                                        GUILayoutExt.FoldOut(ref foldout, componentName, () => {
                                            var changed = GUILayoutExt.DrawFields(DataConfigEditor.multipleWorldEditor, component);
                                            if (changed == true)
                                            {
                                                dataConfig.structComponents[registry.index] = component;
                                                this.Save(dataConfig);
                                            }
                                        });
                                        EditorPrefs.SetBool(key, foldout);
                                    }
                                    GUILayout.EndVertical();
                                }
                                GUILayout.EndHorizontal();
                            }
                        }

                        GUILayoutExt.DrawComponentHelp(component.GetType());
                        this.DrawComponentTemplatesUsage(dataConfig, component);
                    }
                    GUILayout.EndVertical();

                    GUILayoutExt.Separator();
                }

                GUILayoutExt.DrawAddComponentMenu(usedComponents, (addType, isUsed) => {
                    if (isUsed == true)
                    {
                        usedComponents.Remove(addType);
                        for (int i = 0; i < dataConfig.structComponents.Length; ++i)
                        {
                            if (dataConfig.structComponents[i].GetType() == addType)
                            {
                                var list = dataConfig.structComponents.ToList();
                                list.RemoveAt(i);
                                dataConfig.structComponents = list.ToArray();
                                dataConfig.OnScriptLoad();
                                this.Save(dataConfig);
                                break;
                            }
                        }
                    }
                    else
                    {
                        usedComponents.Add(addType);
                        System.Array.Resize(ref dataConfig.structComponents, dataConfig.structComponents.Length + 1);
                        dataConfig.structComponents[dataConfig.structComponents.Length - 1] = (IStructComponent)System.Activator.CreateInstance(addType);
                        dataConfig.OnScriptLoad();
                        this.Save(dataConfig);
                    }
                });
            });

            GUILayoutExt.Separator(6f);
            GUILayoutExt.DrawHeader("Add Managed Components:");
            GUILayoutExt.Separator();

            GUILayoutExt.Padding(8f, () => {
                var usedComponents = new System.Collections.Generic.HashSet <System.Type>();

                var kz               = 0;
                var registries       = dataConfig.components;
                var sortedRegistries = new System.Collections.Generic.SortedDictionary <int, RegistryComponent>(new WorldsViewerEditor.DuplicateKeyComparer <int>());
                for (int i = 0; i < registries.Length; ++i)
                {
                    var registry = registries[i];
                    if (registry == null)
                    {
                        continue;
                    }

                    var component = registry;
                    usedComponents.Add(component.GetType());

                    var editor = WorldsViewerEditor.GetEditor(component, out var order);
                    if (editor != null)
                    {
                        sortedRegistries.Add(order, new RegistryComponent()
                        {
                            index = i,
                            data  = component
                        });
                    }
                    else
                    {
                        sortedRegistries.Add(0, new RegistryComponent()
                        {
                            index = i,
                            data  = component
                        });
                    }
                }

                foreach (var registryKv in sortedRegistries)
                {
                    var registry  = registryKv.Value;
                    var component = registry.data;

                    var backColor       = GUI.backgroundColor;
                    GUI.backgroundColor = new Color(1f, 1f, 1f, kz++ % 2 == 0 ? 0f : 0.05f);

                    GUILayout.BeginVertical(backStyle);
                    {
                        GUI.backgroundColor = backColor;
                        var editor          = WorldsViewerEditor.GetEditor(component);
                        if (editor != null)
                        {
                            EditorGUI.BeginChangeCheck();
                            editor.OnDrawGUI();
                            if (EditorGUI.EndChangeCheck() == true)
                            {
                                component = editor.GetTarget <IComponent>();
                                dataConfig.components[registry.index] = component;
                                this.Save(dataConfig);
                            }
                        }
                        else
                        {
                            var componentName = component.GetType().Name;
                            var fieldsCount   = GUILayoutExt.GetFieldsCount(component);
                            if (fieldsCount == 0)
                            {
                                EditorGUI.BeginDisabledGroup(true);
                                EditorGUILayout.Toggle(componentName, true);
                                EditorGUI.EndDisabledGroup();
                            }
                            else if (fieldsCount == 1)
                            {
                                var changed = GUILayoutExt.DrawFields(DataConfigEditor.multipleWorldEditor, component, componentName);
                                if (changed == true)
                                {
                                    dataConfig.components[registry.index] = component;
                                    this.Save(dataConfig);
                                }
                            }
                            else
                            {
                                GUILayout.BeginHorizontal();
                                {
                                    GUILayout.Space(18f);
                                    GUILayout.BeginVertical();
                                    {
                                        var key     = "ME.ECS.WorldsViewerEditor.FoldoutTypes." + component.GetType().FullName;
                                        var foldout = EditorPrefs.GetBool(key, true);
                                        GUILayoutExt.FoldOut(ref foldout, componentName, () => {
                                            var changed = GUILayoutExt.DrawFields(DataConfigEditor.multipleWorldEditor, component);
                                            if (changed == true)
                                            {
                                                dataConfig.components[registry.index] = component;
                                                this.Save(dataConfig);
                                            }
                                        });
                                        EditorPrefs.SetBool(key, foldout);
                                    }
                                    GUILayout.EndVertical();
                                }
                                GUILayout.EndHorizontal();
                            }
                        }

                        GUILayoutExt.DrawComponentHelp(component.GetType());
                        this.DrawComponentTemplatesUsage(dataConfig, component);
                    }
                    GUILayout.EndVertical();

                    GUILayoutExt.Separator();
                }

                GUILayoutExt.DrawAddComponentMenu(usedComponents, (addType, isUsed) => {
                    if (isUsed == true)
                    {
                        usedComponents.Remove(addType);
                        for (int i = 0; i < dataConfig.components.Length; ++i)
                        {
                            if (dataConfig.components[i].GetType() == addType)
                            {
                                var list = dataConfig.components.ToList();
                                list.RemoveAt(i);
                                dataConfig.components = list.ToArray();
                                dataConfig.OnScriptLoad();
                                this.Save(dataConfig);
                                break;
                            }
                        }
                    }
                    else
                    {
                        usedComponents.Add(addType);
                        System.Array.Resize(ref dataConfig.components, dataConfig.components.Length + 1);
                        dataConfig.components[dataConfig.components.Length - 1] = (IComponent)System.Activator.CreateInstance(addType);
                        dataConfig.OnScriptLoad();
                        this.Save(dataConfig);
                    }
                }, drawRefComponents: true);
            });

            GUILayoutExt.Separator(6f);
            GUILayoutExt.DrawHeader("Remove Struct Components:");
            GUILayoutExt.Separator();

            // Remove struct components
            GUILayoutExt.Padding(8f, () => {
                var usedComponents = new System.Collections.Generic.HashSet <System.Type>();

                var kz         = 0;
                var registries = dataConfig.removeStructComponentsDataTypeIds;
                for (int i = 0; i < registries.Length; ++i)
                {
                    var registry = registries[i];
                    var type     = ComponentTypesRegistry.allTypeId.FirstOrDefault(x => x.Value == registry).Key;

                    if (type == null)
                    {
                        continue;
                    }

                    usedComponents.Add(type);

                    var backColor       = GUI.backgroundColor;
                    GUI.backgroundColor = new Color(1f, 1f, 1f, kz++ % 2 == 0 ? 0f : 0.05f);

                    GUILayout.BeginVertical(backStyle);
                    {
                        GUI.backgroundColor = backColor;
                        var componentName   = GUILayoutExt.GetStringCamelCaseSpace(type.Name);

                        EditorGUI.BeginDisabledGroup(true);
                        EditorGUILayout.Toggle(componentName, true);
                        EditorGUI.EndDisabledGroup();

                        GUILayoutExt.DrawComponentHelp(type);
                        this.DrawComponentTemplatesUsage(dataConfig, dataConfig.removeStructComponents[i]);
                    }
                    GUILayout.EndVertical();

                    GUILayoutExt.Separator();
                }

                GUILayoutExt.DrawAddComponentMenu(usedComponents, (addType, isUsed) => {
                    if (isUsed == true)
                    {
                        usedComponents.Remove(addType);
                        for (int i = 0; i < dataConfig.removeStructComponents.Length; ++i)
                        {
                            if (dataConfig.removeStructComponents[i].GetType() == addType)
                            {
                                var list = dataConfig.removeStructComponents.ToList();
                                list.RemoveAt(i);
                                dataConfig.removeStructComponents = list.ToArray();
                                dataConfig.OnScriptLoad();
                                this.Save(dataConfig);
                                break;
                            }
                        }
                    }
                    else
                    {
                        usedComponents.Add(addType);
                        System.Array.Resize(ref dataConfig.removeStructComponents, dataConfig.removeStructComponents.Length + 1);
                        dataConfig.removeStructComponents[dataConfig.removeStructComponents.Length - 1] = (IStructComponent)System.Activator.CreateInstance(addType);
                        dataConfig.OnScriptLoad();
                        this.Save(dataConfig);
                    }
                });
            });

            if ((dataConfig is ME.ECS.DataConfigs.DataConfigTemplate) == false)
            {
                this.DrawTemplates(dataConfig);
            }
        }
Exemplo n.º 3
0
        private void DrawEntities(WorldEditor world)
        {
            var style = EditorStyles.helpBox;

            this.scrollEntitiesPosition = GUILayout.BeginScrollView(this.scrollEntitiesPosition, style, GUILayout.ExpandHeight(true));
            {
                if (world == null)
                {
                    var centeredStyle = new GUIStyle(EditorStyles.centeredGreyMiniLabel);
                    centeredStyle.stretchHeight = true;
                    centeredStyle.richText      = true;
                    GUILayout.Label("Select world from the left list.", centeredStyle);
                }
                else
                {
                    var padding   = 2f;
                    var margin    = 1f;
                    var dataStyle = new GUIStyle(EditorStyles.label);
                    dataStyle.richText = true;
                    dataStyle.wordWrap = true;

                    var modules = world.GetModules();

                    //var componentsStorage = world.GetComponentsStorage();
                    var entitiesStorage = world.GetEntitiesStorage();
                    foreach (var entityStorage in entitiesStorage)
                    {
                        if (entityStorage == null)
                        {
                            continue;
                        }

                        var storages = entityStorage.Cast <ME.ECS.IStorage>().ToList();
                        foreach (var storage in storages)
                        {
                            if (storage == null)
                            {
                                continue;
                            }

                            GUILayout.BeginVertical();
                            {
                                var foldout = world.IsFoldOut(storage);
                                GUILayoutExt.FoldOut(ref foldout, GUILayoutExt.GetTypeLabel(storage.GetType()), () => {
                                    var list = storage.GetData();
                                    for (var i = list.FromIndex; i < list.SizeCount; ++i)
                                    {
                                        if (list.IsFree(i) == true)
                                        {
                                            continue;
                                        }

                                        var item       = list.Get <ME.ECS.IEntity>(i);
                                        var entityData = item;

                                        GUILayoutExt.Box(
                                            padding,
                                            margin,
                                            () => {
                                            GUILayout.Space(2f);
                                            GUILayout.Label("Entity " + entityData.entity.id.ToString() + " (" + entityData.entity.storageIdx.ToString() + ")");

                                            GUILayoutExt.Box(
                                                padding,
                                                margin,
                                                () => {
                                                #region Data
                                                var foldoutData = world.IsFoldOutData(storage, entityData.entity.id);
                                                GUILayoutExt.FoldOut(ref foldoutData, "Data", () => {
                                                    {         // Draw data table
                                                        GUILayoutExt.DrawFields(item, 120f);
                                                    }
                                                });
                                                world.SetFoldOutData(storage, entityData.entity.id, foldoutData);
                                                #endregion

                                                #region Components
                                                var foldoutComponents = world.IsFoldOutComponents(storage, entityData.entity.id);
                                                GUILayoutExt.FoldOut(ref foldoutComponents, "Components", () => {
                                                    GUILayout.Label("Due to technical issues components list is not supported for now", EditorStyles.miniBoldLabel);

                                                    /*ME.ECS.IComponentsBase components;
                                                     * if (componentsStorage.TryGetValue(entityData.entity.id, out components) == true) {
                                                     *
                                                     *  var componentsDic = components.GetData(entityData.entity.id);
                                                     *  foreach (var component in componentsDic) {
                                                     *
                                                     *      GUILayoutExt.Box(
                                                     *          padding,
                                                     *          margin,
                                                     *          () => {
                                                     *
                                                     *              GUILayout.Space(2f);
                                                     *              GUILayout.BeginHorizontal();
                                                     *              GUILayout.Label(component.GetType().Name, GUILayout.Width(90f));
                                                     *              GUILayoutExt.TypeLabel(component.GetType());
                                                     *              GUILayout.EndHorizontal();
                                                     *
                                                     *              GUILayoutExt.Box(
                                                     *                  padding,
                                                     *                  margin,
                                                     *                  () => {
                                                     *
                                                     *                      GUILayout.Label("Data", EditorStyles.miniBoldLabel);
                                                     *                      GUILayoutExt.DrawFields(component, 120f);
                                                     *
                                                     *                  }, GUIStyle.none);
                                                     *
                                                     *          }, "dragtabdropwindow");
                                                     *
                                                     *  }
                                                     *
                                                     * }*/
                                                });
                                                world.SetFoldOutComponents(storage, entityData.entity.id, foldoutComponents);
                                                #endregion

                                                        #if VIEWS_MODULE_SUPPORT
                                                var foldoutViews = world.IsFoldOutViews(storage, entityData.entity.id);
                                                GUILayoutExt.FoldOut(ref foldoutViews, "Views", () => {
                                                    {         // Draw views table
                                                        var viewsModules = modules.OfType <ME.ECS.Views.IViewModuleBase>().ToArray();
                                                        foreach (var viewsModule in viewsModules)
                                                        {
                                                            if (viewsModule != null)
                                                            {
                                                                var allViews = viewsModule.GetData();
                                                                foreach (DictionaryEntry itemEntry in allViews)
                                                                {
                                                                    var key = (EntityId)itemEntry.Key;
                                                                    if (key == entityData.entity.id)
                                                                    {
                                                                        var listViews = (IList)itemEntry.Value;
                                                                        for (int j = 0; j < listViews.Count; ++j)
                                                                        {
                                                                            var view = (ME.ECS.Views.IViewBase)listViews[j];
                                                                            GUILayoutExt.Box(
                                                                                padding,
                                                                                margin,
                                                                                () => {
                                                                                GUILayout.Label("Prefab Source Id: " + view.prefabSourceId.ToString());
                                                                                var provider = viewsModule.GetViewSourceProvider(view.prefabSourceId);
                                                                                GUILayout.Label("Provider: " + GUILayoutExt.GetTypeLabel(provider.GetType()));
                                                                                GUILayout.Label("Creation Tick: " + view.creationTick.ToString());
                                                                            });
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                });
                                                world.SetFoldOutViews(storage, entityData.entity.id, foldoutViews);
                                                        #endif
                                            }, GUIStyle.none);
                                        },
                                            "dragtabdropwindow");

                                        list.Set(i, entityData);
                                    }
                                });
                                world.SetFoldOut(storage, foldout);
                            }
                            GUILayout.EndVertical();
                        }
                    }
                }
            }
            GUILayout.EndScrollView();
        }
Exemplo n.º 4
0
        public override void OnInspectorGUI()
        {
            var dataConfig = (ME.ECS.DataConfigs.DataConfig) this.target;

            if (dataConfig is ME.ECS.DataConfigs.DataConfigTemplate == false)
            {
                foreach (var target in this.targets)
                {
                    var dc = (ME.ECS.DataConfigs.DataConfig)target;
                    if (dc.sharedGroupId == 0)
                    {
                        dc.sharedGroupId = ME.ECS.MathUtils.GetHash(AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(dc)));
                        this.Save(dc);
                    }
                }

                GUILayout.BeginHorizontal();
                GUILayout.FlexibleSpace();
                this.serializedObject.Update();
                var sharedIdLabelStyle = new GUIStyle(EditorStyles.miniBoldLabel);
                sharedIdLabelStyle.alignment = TextAnchor.MiddleRight;
                EditorGUILayout.LabelField("Shared ID:", sharedIdLabelStyle);
                EditorGUILayout.PropertyField(this.sharedGroupId, new GUIContent(string.Empty), GUILayout.Width(100f));
                this.serializedObject.ApplyModifiedProperties();
                GUILayout.EndHorizontal();
            }

            this.search = GUILayoutExt.SearchField("Search", this.search);

            {
                var style = new GUIStyle(EditorStyles.toolbar);
                style.fixedHeight   = 0f;
                style.stretchHeight = true;

                var backStyle = new GUIStyle(EditorStyles.label);
                backStyle.normal.background = Texture2D.whiteTexture;

                var slice      = new ME.ECS.DataConfigs.DataConfigSlice();
                var isMultiple = false;
                if (this.targets.Length > 1)
                {
                    slice      = ME.ECS.DataConfigs.DataConfigSlice.Distinct(this.targets.Cast <ME.ECS.DataConfigs.DataConfig>().ToArray());
                    isMultiple = true;
                }
                else
                {
                    var config = (ME.ECS.DataConfigs.DataConfig) this.target;
                    slice = new ME.ECS.DataConfigs.DataConfigSlice()
                    {
                        configs = new[] {
                            config
                        },
                        structComponentsTypes = config.structComponents.Where(x => x != null).Select(x => x.GetType()).ToArray(),
                    };
                }

                var usedComponentsAll = new System.Collections.Generic.HashSet <System.Type>();
                foreach (var cfg in slice.configs)
                {
                    var componentTypes = cfg.GetStructComponentTypes();
                    foreach (var cType in componentTypes)
                    {
                        if (usedComponentsAll.Contains(cType) == false)
                        {
                            usedComponentsAll.Add(cType);
                        }
                    }

                    if (DataConfigEditor.worldEditors.TryGetValue(cfg, out var worldEditor) == false)
                    {
                        worldEditor = new WorldsViewerEditor.WorldEditor();
                        DataConfigEditor.worldEditors.Add(cfg, worldEditor);
                    }
                }

                if (isMultiple == true)
                {
                    GUILayoutExt.DrawHeader("The Same Components:");

                    GUILayoutExt.Padding(4f, () => {
                        var kz = 0;
                        for (int i = 0; i < slice.structComponentsTypes.Length; ++i)
                        {
                            var type      = slice.structComponentsTypes[i];
                            var component = slice.configs[0].GetByType(slice.configs[0].structComponents, type);
                            if (GUILayoutExt.IsSearchValid(component, this.search) == false)
                            {
                                continue;
                            }
                            var components = slice.configs.Select(x => x.GetByType(x.structComponents, type)).ToArray();

                            var backColor       = GUI.backgroundColor;
                            GUI.backgroundColor = new Color(1f, 1f, 1f, kz++ % 2 == 0 ? 0f : 0.05f);

                            GUILayout.BeginVertical(backStyle);
                            {
                                GUI.backgroundColor = backColor;
                                var editor          = WorldsViewerEditor.GetEditor(components);
                                if (editor != null)
                                {
                                    EditorGUI.BeginChangeCheck();
                                    editor.OnDrawGUI();
                                    if (EditorGUI.EndChangeCheck() == true)
                                    {
                                        slice.Set(components);
                                        this.Save(slice.configs);
                                    }
                                }
                                else
                                {
                                    var componentName = GUILayoutExt.GetStringCamelCaseSpace(component.GetType().Name);
                                    var fieldsCount   = GUILayoutExt.GetFieldsCount(component);
                                    if (fieldsCount == 0)
                                    {
                                        EditorGUI.BeginDisabledGroup(true);
                                        EditorGUILayout.Toggle(componentName, true);
                                        EditorGUI.EndDisabledGroup();
                                    }
                                    else if (fieldsCount == 1)
                                    {
                                        var changed = GUILayoutExt.DrawFields(DataConfigEditor.multipleWorldEditor, components, componentName);
                                        if (changed == true)
                                        {
                                            slice.Set(components);
                                            this.Save(slice.configs);
                                        }
                                    }
                                    else
                                    {
                                        GUILayout.BeginHorizontal();
                                        {
                                            GUILayout.Space(18f);
                                            GUILayout.BeginVertical();
                                            {
                                                var key     = "ME.ECS.WorldsViewerEditor.FoldoutTypes." + component.GetType().FullName;
                                                var foldout = EditorPrefs.GetBool(key, true);
                                                GUILayoutExt.FoldOut(ref foldout, componentName, () => {
                                                    var changed = GUILayoutExt.DrawFields(DataConfigEditor.multipleWorldEditor, components);
                                                    if (changed == true)
                                                    {
                                                        slice.Set(components);
                                                        this.Save(slice.configs);
                                                    }
                                                });
                                                EditorPrefs.SetBool(key, foldout);
                                            }
                                            GUILayout.EndVertical();
                                        }
                                        GUILayout.EndHorizontal();
                                    }
                                }

                                GUILayoutExt.DrawComponentHelp(component.GetType());
                                this.DrawShared(component);
                            }
                            GUILayout.EndVertical();

                            GUILayoutExt.Separator();
                        }
                    });

                    GUILayoutExt.DrawAddComponentMenu(usedComponentsAll, (addType, isUsed) => {
                        foreach (var dataConfigInner in slice.configs)
                        {
                            if (isUsed == true)
                            {
                                this.OnRemoveComponent(addType);
                                usedComponentsAll.Remove(addType);
                                for (int i = 0; i < dataConfigInner.structComponents.Length; ++i)
                                {
                                    if (dataConfigInner.structComponents[i].GetType() == addType)
                                    {
                                        var list = dataConfigInner.structComponents.ToList();
                                        list.RemoveAt(i);
                                        dataConfigInner.structComponents = list.ToArray();
                                        //dataConfigInner.OnScriptLoad();
                                        this.Save(dataConfigInner);
                                        break;
                                    }
                                }
                            }
                            else
                            {
                                usedComponentsAll.Add(addType);
                                System.Array.Resize(ref dataConfigInner.structComponents, dataConfigInner.structComponents.Length + 1);
                                dataConfigInner.structComponents[dataConfigInner.structComponents.Length - 1] = (IStructComponentBase)System.Activator.CreateInstance(addType);
                                //dataConfigInner.OnScriptLoad();
                                this.Save(dataConfigInner);
                                this.OnAddComponent(addType);
                            }
                        }
                    });

                    return;
                }

                GUILayoutExt.DrawHeader("Add Struct Components:");
                GUILayoutExt.Separator();

                GUILayoutExt.Padding(4f, () => {
                    var usedComponents = new System.Collections.Generic.HashSet <System.Type>();

                    this.serializedObject.Update();
                    if (GUILayoutExt.DrawFieldsSingle(this.search, this, DataConfigEditor.multipleWorldEditor, dataConfig.structComponents,
                                                      (index, component, prop) => {
                        GUILayout.BeginVertical();
                    },
                                                      (index, component, prop) => {
                        if (component == null)
                        {
                            return;
                        }

                        usedComponents.Add(component.GetType());

                        GUILayoutExt.DrawComponentHelp(component.GetType());
                        this.DrawComponentTemplatesUsage(dataConfig, component);
                        this.DrawShared(component);

                        GUILayout.EndVertical();

                        {
                            var lastRect = GUILayoutUtility.GetLastRect();
                            if (Event.current.type == EventType.ContextClick && lastRect.Contains(Event.current.mousePosition) == true)
                            {
                                var menu = new GenericMenu();
                                if (this.CanMove(dataConfig, index, index - 1) == true)
                                {
                                    menu.AddItem(new GUIContent("Move Up"), false, () => { this.MoveElement(dataConfig, index, index - 1); });
                                }
                                else
                                {
                                    menu.AddDisabledItem(new GUIContent("Move Up"));
                                }

                                if (this.CanMove(dataConfig, index, index + 1) == true)
                                {
                                    menu.AddItem(new GUIContent("Move Down"), false, () => { this.MoveElement(dataConfig, index, index + 1); });
                                }
                                else
                                {
                                    menu.AddDisabledItem(new GUIContent("Move Down"));
                                }

                                menu.AddItem(new GUIContent("Delete"), false, () => {
                                    var list = dataConfig.structComponents.ToList();
                                    this.OnRemoveComponent(list[index].GetType());
                                    list.RemoveAt(index);
                                    dataConfig.structComponents = list.ToArray();
                                    //dataConfig.OnScriptLoad();
                                    this.Save(dataConfig);
                                });

                                this.OnComponentMenu(menu, index);

                                menu.ShowAsContext();
                            }
                        }

                        GUILayoutExt.Separator();
                    }) == true)
                    {
                        this.serializedObject.ApplyModifiedProperties();
                        this.Save(dataConfig);
                    }

                    GUILayoutExt.DrawAddComponentMenu(usedComponents, (addType, isUsed) => {
                        if (isUsed == true)
                        {
                            this.OnRemoveComponent(addType);
                            usedComponents.Remove(addType);
                            for (int i = 0; i < dataConfig.structComponents.Length; ++i)
                            {
                                if (dataConfig.structComponents[i].GetType() == addType)
                                {
                                    var list = dataConfig.structComponents.ToList();
                                    list.RemoveAt(i);
                                    dataConfig.structComponents = list.ToArray();
                                    //dataConfig.OnScriptLoad();
                                    this.Save(dataConfig);
                                    break;
                                }
                            }
                        }
                        else
                        {
                            usedComponents.Add(addType);
                            System.Array.Resize(ref dataConfig.structComponents, dataConfig.structComponents.Length + 1);
                            dataConfig.structComponents[dataConfig.structComponents.Length - 1] = (IStructComponentBase)System.Activator.CreateInstance(addType);
                            //dataConfig.OnScriptLoad();
                            this.Save(dataConfig);
                            this.OnAddComponent(addType);
                        }
                    });
                });

                GUILayoutExt.DrawHeader("Remove Struct Components:");
                GUILayoutExt.Separator();

                // Remove struct components
                GUILayoutExt.Padding(4f, () => {
                    var usedComponents = new System.Collections.Generic.HashSet <System.Type>();

                    var kz         = 0;
                    var registries = dataConfig.removeStructComponents;
                    for (int i = 0; i < registries.Length; ++i)
                    {
                        var registry = registries[i];
                        if (GUILayoutExt.IsSearchValid(registry, this.search) == false)
                        {
                            continue;
                        }
                        var type = registry.GetType();

                        usedComponents.Add(type);

                        var backColor       = GUI.backgroundColor;
                        GUI.backgroundColor = new Color(1f, 1f, 1f, kz++ % 2 == 0 ? 0f : 0.05f);

                        GUILayout.BeginVertical(backStyle);
                        {
                            GUI.backgroundColor = backColor;
                            var componentName   = GUILayoutExt.GetStringCamelCaseSpace(type.Name);

                            EditorGUI.BeginDisabledGroup(true);
                            EditorGUILayout.Toggle(componentName, true);
                            EditorGUI.EndDisabledGroup();

                            GUILayoutExt.DrawComponentHelp(type);
                            this.DrawComponentTemplatesUsage(dataConfig, dataConfig.removeStructComponents[i]);
                        }
                        GUILayout.EndVertical();

                        GUILayoutExt.Separator();
                    }

                    GUILayoutExt.DrawAddComponentMenu(usedComponents, (addType, isUsed) => {
                        if (isUsed == true)
                        {
                            this.OnRemoveComponentFromRemoveList(addType);
                            usedComponents.Remove(addType);
                            for (int i = 0; i < dataConfig.removeStructComponents.Length; ++i)
                            {
                                if (dataConfig.removeStructComponents[i].GetType() == addType)
                                {
                                    var list = dataConfig.removeStructComponents.ToList();
                                    list.RemoveAt(i);
                                    dataConfig.removeStructComponents = list.ToArray();
                                    //dataConfig.OnScriptLoad();
                                    this.Save(dataConfig);
                                    break;
                                }
                            }
                        }
                        else
                        {
                            usedComponents.Add(addType);
                            System.Array.Resize(ref dataConfig.removeStructComponents, dataConfig.removeStructComponents.Length + 1);
                            dataConfig.removeStructComponents[dataConfig.removeStructComponents.Length - 1] = (IStructComponentBase)System.Activator.CreateInstance(addType);
                            //dataConfig.OnScriptLoad();
                            this.Save(dataConfig);
                            this.OnAddComponentFromRemoveList(addType);
                        }
                    });
                });

                if ((dataConfig is ME.ECS.DataConfigs.DataConfigTemplate) == false)
                {
                    this.DrawTemplates(dataConfig);
                }
            }
        }