com.artromskiy.deltaecs.unity 0.0.37

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## 0.0.37
+
+- Initial UPM package for the DeltaECS Unity scene authoring and editor integration.
+- Requires Unity 6.7 (`6000.7`) or newer.

package/Editor/BoundEntityRootEditor.cs

@@ -0,0 +1,288 @@
+using System;
+using System.Collections.Generic;
+using Delta.ECS;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace Delta.ECS.Unity.Editor
+{
+    internal static class BoundEntityRootEditorSelector
+    {
+        private static bool _creatingDefaultGameObjectEditor;
+
+        [RootEditor(supportsAddComponent: true)]
+        private static Type SelectRootEditor(UnityEngine.Object[] objects)
+        {
+            if (_creatingDefaultGameObjectEditor)
+            {
+                return null;
+            }
+
+            if (objects == null || objects.Length != 1 || objects[0] is not GameObject gameObject)
+            {
+                return null;
+            }
+
+            if (SceneWorld.TryFindLiveWorld(gameObject, out _, out _))
+            {
+                return typeof(BoundEntityRootEditor);
+            }
+
+            if (EditorApplication.isPlayingOrWillChangePlaymode)
+            {
+                return null;
+            }
+
+            SceneAuthoring authoring = SceneAuthoring.FindForScene(gameObject.scene);
+            return authoring != null && authoring.TryGetStableId(gameObject, out _)
+                ? typeof(BoundEntityRootEditor)
+                : null;
+        }
+
+        internal static UnityEditor.Editor CreateDefaultGameObjectEditor(GameObject gameObject)
+        {
+            _creatingDefaultGameObjectEditor = true;
+            try
+            {
+                return UnityEditor.Editor.CreateEditor(gameObject);
+            }
+            finally
+            {
+                _creatingDefaultGameObjectEditor = false;
+            }
+        }
+    }
+
+    internal sealed class BoundEntityRootEditor : UnityEditor.Editor
+    {
+        private const string ComponentHeadersStyleResourcePath =
+            "Inspector/BoundEntityRootEditor";
+
+        private readonly List<UnityEditor.Editor> _componentEditors = new();
+        private readonly List<Component> _componentTargets = new();
+        private UnityEditor.Editor _gameObjectEditor;
+        private SceneEntityInspectorView _view;
+        private VisualElement _componentInspectorRoot;
+
+        private void OnEnable()
+        {
+            if (target is GameObject gameObject)
+            {
+                _gameObjectEditor = BoundEntityRootEditorSelector.CreateDefaultGameObjectEditor(gameObject);
+            }
+
+            _view = new SceneEntityInspectorView(ResolveTarget, embedded: true);
+            EditorApplication.hierarchyChanged += RefreshComponentInspectors;
+            Undo.undoRedoPerformed += RefreshComponentInspectors;
+        }
+
+        private void OnDisable()
+        {
+            _view?.Dispose();
+            _view = null;
+            if (_gameObjectEditor != null)
+            {
+                DestroyImmediate(_gameObjectEditor);
+                _gameObjectEditor = null;
+            }
+
+            EditorApplication.hierarchyChanged -= RefreshComponentInspectors;
+            Undo.undoRedoPerformed -= RefreshComponentInspectors;
+            _componentInspectorRoot = null;
+            DisposeComponentEditors();
+        }
+
+        protected override void OnHeaderGUI()
+        {
+            // The root editor's generic object header is replaced by the native
+            // GameObjectInspector header embedded at the top of CreateInspectorGUI.
+        }
+
+        private void DisposeComponentEditors()
+        {
+            foreach (UnityEditor.Editor componentEditor in _componentEditors)
+            {
+                if (componentEditor != null)
+                {
+                    DestroyImmediate(componentEditor);
+                }
+            }
+
+            _componentEditors.Clear();
+            _componentTargets.Clear();
+        }
+
+        public override bool UseDefaultMargins() => false;
+
+        public override bool RequiresConstantRepaint()
+        {
+            if (EditorApplication.isPlaying)
+                return true;
+
+            foreach (UnityEditor.Editor componentEditor in _componentEditors)
+            {
+                if (componentEditor != null && componentEditor.RequiresConstantRepaint())
+                    return true;
+            }
+
+            return false;
+        }
+
+        public override VisualElement CreateInspectorGUI()
+        {
+            var root = new VisualElement();
+            StyleSheet componentStyles = Resources.Load<StyleSheet>(ComponentHeadersStyleResourcePath);
+            if (componentStyles != null)
+            {
+                root.styleSheets.Add(componentStyles);
+            }
+
+            if (_gameObjectEditor != null)
+            {
+                root.Add(new IMGUIContainer(() =>
+                {
+                    if (_gameObjectEditor != null)
+                    {
+                        _gameObjectEditor.DrawHeader();
+                    }
+                }));
+            }
+
+            VisualElement ecsContent = _view.CreateGUI();
+            bool ecsExpanded = SessionState.GetBool("DeltaECS.EntityInspector.Expanded", true);
+            ecsContent.style.display = ecsExpanded ? DisplayStyle.Flex : DisplayStyle.None;
+            root.Add(new IMGUIContainer(() =>
+            {
+                GUIStyle titlebar = GUI.skin.GetStyle("IN Title");
+                GUIStyle foldoutStyle = GUI.skin.GetStyle("Titlebar Foldout");
+                Rect headerRect = GUILayoutUtility.GetRect(GUIContent.none, titlebar,
+                    GUILayout.ExpandWidth(true));
+                bool expanded = GUI.Toggle(headerRect, ecsExpanded, GUIContent.none, GUIStyle.none);
+                if (Event.current.type == EventType.Repaint)
+                {
+                    titlebar.Draw(headerRect, GUIContent.none, false, false, false, false);
+                    Rect arrowRect = new Rect(headerRect.x + foldoutStyle.margin.left + 1f,
+                        headerRect.y + (headerRect.height - 13) / 2 + titlebar.padding.top, 13, 13);
+                    foldoutStyle.Draw(arrowRect, false, false, expanded, false);
+                }
+                Rect textRect = new Rect(headerRect.x + 28, headerRect.y,
+                    headerRect.width - 28, headerRect.height);
+                GUI.Label(textRect, "Delta ECS Entity", GUI.skin.GetStyle("IN TitleText"));
+                if (expanded == ecsExpanded) return;
+                ecsExpanded = expanded;
+                SessionState.SetBool("DeltaECS.EntityInspector.Expanded", expanded);
+                ecsContent.style.display = expanded ? DisplayStyle.Flex : DisplayStyle.None;
+            }));
+            root.Add(ecsContent);
+            _componentInspectorRoot = new VisualElement();
+            root.Add(_componentInspectorRoot);
+            RebuildComponentInspectors();
+            return root;
+        }
+
+        private void RefreshComponentInspectors()
+        {
+            if (_componentInspectorRoot != null && !HaveSameComponents())
+            {
+                RebuildComponentInspectors();
+            }
+        }
+
+        private bool HaveSameComponents()
+        {
+            if (target is not GameObject gameObject || gameObject == null)
+            {
+                return _componentTargets.Count == 0;
+            }
+
+            int index = 0;
+            foreach (Component component in gameObject.GetComponents<Component>())
+            {
+                if (!ShouldDrawComponent(component))
+                {
+                    continue;
+                }
+
+                if (index >= _componentTargets.Count || _componentTargets[index] != component)
+                {
+                    return false;
+                }
+
+                index++;
+            }
+
+            return index == _componentTargets.Count;
+        }
+
+        private void RebuildComponentInspectors()
+        {
+            DisposeComponentEditors();
+            _componentInspectorRoot.Clear();
+            if (target is not GameObject gameObject || gameObject == null)
+            {
+                return;
+            }
+
+            foreach (Component component in gameObject.GetComponents<Component>())
+            {
+                if (!ShouldDrawComponent(component))
+                {
+                    continue;
+                }
+
+                UnityEditor.Editor componentEditor = CreateEditor(component);
+                if (componentEditor == null)
+                {
+                    continue;
+                }
+
+                _componentEditors.Add(componentEditor);
+                _componentTargets.Add(component);
+                var inspector = new InspectorElement(componentEditor);
+                string expandedKey = $"DeltaECS.ComponentInspector.{component.GetEntityId()}.Expanded";
+                bool expanded = SessionState.GetBool(expandedKey, true);
+                inspector.style.display = expanded ? DisplayStyle.Flex : DisplayStyle.None;
+                _componentInspectorRoot.Add(new IMGUIContainer(() =>
+                {
+                    if (component == null) return;
+                    bool next = EditorGUILayout.InspectorTitlebar(expanded, component);
+                    if (next == expanded) return;
+                    expanded = next;
+                    SessionState.SetBool(expandedKey, next);
+                    inspector.style.display = next ? DisplayStyle.Flex : DisplayStyle.None;
+                }));
+                _componentInspectorRoot.Add(inspector);
+            }
+        }
+
+        private static bool ShouldDrawComponent(Component component) => component != null
+            && (component.hideFlags & HideFlags.HideInInspector) == 0;
+
+        private EntityInspectorTarget ResolveTarget()
+        {
+            if (target is not GameObject gameObject || gameObject == null)
+            {
+                return default;
+            }
+
+            if (SceneWorld.TryFindLiveWorld(gameObject, out SceneWorld world, out Entity entity))
+            {
+                SceneAuthoring liveAuthoring = SceneAuthoring.FindForScene(gameObject.scene);
+                return new EntityInspectorTarget(liveAuthoring, null, world, entity);
+            }
+
+            if (!EditorApplication.isPlayingOrWillChangePlaymode)
+            {
+                SceneAuthoring authoring = SceneAuthoring.FindForScene(gameObject.scene);
+                if (authoring != null && authoring.TryGetStableId(gameObject, out string stableId))
+                {
+                    return new EntityInspectorTarget(authoring, stableId);
+                }
+            }
+
+            return default;
+        }
+    }
+}

package/Editor/BoundEntityRootEditor.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7378c953e20147a1bb2b3214561054e6

package/Editor/ComponentDropdown.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Delta.ECS.Integration;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+namespace Delta.ECS.Unity.Editor
+{
+    internal sealed class ComponentDropdown : AdvancedDropdown
+    {
+        private readonly ComponentDescriptor[] _components;
+        private readonly Func<ComponentDescriptor, string> _getMenuPath;
+        private readonly Action<ComponentDescriptor> _add;
+        private readonly Dictionary<int, ComponentDescriptor> _items = new();
+
+        public ComponentDropdown(ComponentDescriptor[] components,
+            Func<ComponentDescriptor, string> getMenuPath, Action<ComponentDescriptor> add)
+            : base(new AdvancedDropdownState())
+        {
+            _components = components;
+            _getMenuPath = getMenuPath;
+            _add = add;
+            minimumSize = new Vector2(230, 320);
+            // Unity keeps this bound internal; set it before Show captures the popup bounds.
+            typeof(AdvancedDropdown).GetProperty("maximumSize", BindingFlags.Instance | BindingFlags.NonPublic)
+                ?.SetValue(this, new Vector2(4000, 400));
+        }
+
+        protected override AdvancedDropdownItem BuildRoot()
+        {
+            var root = new AdvancedDropdownItem("Component");
+            var folders = new Dictionary<string, AdvancedDropdownItem> { [string.Empty] = root };
+            int id = 0;
+
+            foreach (var entry in _components
+                .Select(component => (Component: component, Path: _getMenuPath(component)))
+                .OrderBy(entry => entry.Path, StringComparer.Ordinal))
+            {
+                string[] path = entry.Path.Split('/');
+                string folderPath = string.Empty;
+                AdvancedDropdownItem parent = root;
+                foreach (string folder in path.Take(path.Length - 1))
+                {
+                    folderPath += "/" + folder;
+                    if (!folders.TryGetValue(folderPath, out AdvancedDropdownItem item))
+                    {
+                        item = new AdvancedDropdownItem(folder) { id = ++id };
+                        folders.Add(folderPath, item);
+                        parent.AddChild(item);
+                    }
+
+                    parent = item;
+                }
+
+                var componentItem = new AdvancedDropdownItem(path[path.Length - 1]) { id = ++id };
+                parent.AddChild(componentItem);
+                _items.Add(componentItem.id, entry.Component);
+            }
+
+            return root;
+        }
+
+        protected override void ItemSelected(AdvancedDropdownItem item)
+        {
+            if (_items.TryGetValue(item.id, out ComponentDescriptor descriptor))
+            {
+                _add(descriptor);
+            }
+        }
+    }
+}

package/Editor/ComponentDropdown.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: cabed0bc7e964c17829f6e89738d3b1b

package/Editor/ComponentListController.cs

@@ -0,0 +1,26 @@
+using UnityEditor.UIElements;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace Delta.ECS.Unity.Editor
+{
+    internal sealed class ComponentListController : ListViewController
+    {
+        private readonly SceneEntityInspectorView _view;
+
+        public ComponentListController(SceneEntityInspectorView view) => _view = view;
+
+        public override void Move(int index, int newIndex)
+        {
+            int componentCount = _view.ComponentCount;
+            if (index < 0 || index >= componentCount || componentCount == 0)
+            {
+                return;
+            }
+
+            base.Move(index, Mathf.Clamp(newIndex, 0, componentCount - 1));
+            _view.ScheduleRefreshContent();
+        }
+    }
+}

package/Editor/ComponentListController.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 91147ca0e95244c787a993a847c31c2a

package/Editor/DeltaECS.Unity.Editor.asmdef

@@ -0,0 +1,18 @@
+{
+    "name": "DeltaECS.Unity.Editor",
+    "rootNamespace": "Delta.ECS.Unity.Editor",
+    "references": [
+        "DeltaECS.Unity"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Editor/DeltaECS.Unity.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: c0286b8c5453b9f77454004c35a47bc7
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Editor/EditorLifecycle.cs

@@ -0,0 +1,143 @@
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Delta.ECS.Unity.Editor
+{
+    [InitializeOnLoad]
+    internal static class EditorLifecycle
+    {
+        private static bool _sceneAuthoringSetupScheduled;
+
+        static EditorLifecycle()
+        {
+            Undo.undoRedoPerformed += OnUndoRedo;
+            EditorSceneManager.sceneOpened += OnSceneOpened;
+            EditorSceneManager.sceneClosed += OnSceneClosed;
+            EditorSceneManager.newSceneCreated += OnNewSceneCreated;
+            ScheduleSceneAuthoringSetup();
+        }
+
+        private static void OnUndoRedo()
+        {
+            HierarchyNodeHandler.RefreshAll();
+        }
+
+        private static void OnSceneOpened(UnityEngine.SceneManagement.Scene scene, OpenSceneMode mode)
+        {
+            ScheduleSceneAuthoringSetup();
+        }
+
+        private static void OnSceneClosed(Scene scene)
+        {
+            HierarchyNodeHandler.RefreshAll();
+        }
+
+        private static void OnNewSceneCreated(Scene scene, NewSceneSetup setup, NewSceneMode mode)
+        {
+            ScheduleSceneAuthoringSetup();
+        }
+
+        private static void ScheduleSceneAuthoringSetup()
+        {
+            if (_sceneAuthoringSetupScheduled)
+            {
+                return;
+            }
+
+            _sceneAuthoringSetupScheduled = true;
+            EditorApplication.delayCall += EnsureAuthoringForLoadedScenes;
+        }
+
+        private static void EnsureAuthoringForLoadedScenes()
+        {
+            _sceneAuthoringSetupScheduled = false;
+            if (EditorApplication.isPlayingOrWillChangePlaymode)
+            {
+                return;
+            }
+
+            for (int i = 0; i < SceneManager.sceneCount; i++)
+            {
+                EnsureSceneAuthoring(SceneManager.GetSceneAt(i));
+            }
+
+            HierarchyNodeHandler.RefreshAll();
+        }
+
+        private static void EnsureSceneAuthoring(Scene scene)
+        {
+            if (!scene.IsValid() || !scene.isLoaded || EditorSceneManager.IsPreviewScene(scene))
+            {
+                return;
+            }
+
+            SceneAuthoring existing = SceneAuthoring.FindForScene(scene);
+            if (existing != null && IsDedicatedAuthoringObject(existing.gameObject))
+            {
+                GameObject existingObject = existing.gameObject;
+                bool changed = false;
+                if (!string.Equals(existingObject.name, SceneAuthoring.AuthoringObjectName, System.StringComparison.Ordinal))
+                {
+                    existingObject.name = SceneAuthoring.AuthoringObjectName;
+                    changed = true;
+                }
+
+                if ((existingObject.hideFlags & HideFlags.HideInHierarchy) == 0)
+                {
+                    existingObject.hideFlags |= HideFlags.HideInHierarchy;
+                    changed = true;
+                }
+
+                if (changed)
+                {
+                    EditorUtility.SetDirty(existingObject);
+                    EditorSceneManager.MarkSceneDirty(scene);
+                }
+
+                return;
+            }
+
+            var authoringObject = new GameObject(SceneAuthoring.AuthoringObjectName);
+            SceneManager.MoveGameObjectToScene(authoringObject, scene);
+            SceneAuthoring replacement = authoringObject.AddComponent<SceneAuthoring>();
+
+            if (existing != null)
+            {
+                EditorUtility.CopySerialized(existing, replacement);
+                replacement.SceneData.EnsureStableIds();
+                UnityEngine.Object.DestroyImmediate(existing);
+            }
+
+            authoringObject.hideFlags |= HideFlags.HideInHierarchy;
+
+            if (existing != null)
+            {
+                EditorUtility.SetDirty(replacement);
+                EditorUtility.SetDirty(authoringObject);
+            }
+
+            EditorSceneManager.MarkSceneDirty(scene);
+        }
+
+        private static bool IsDedicatedAuthoringObject(GameObject gameObject)
+        {
+            Component[] components = gameObject.GetComponents<Component>();
+            if (components.Length != 2)
+            {
+                return false;
+            }
+
+            bool hasAuthoring = false;
+            bool hasTransform = false;
+            for (int i = 0; i < components.Length; i++)
+            {
+                hasAuthoring |= components[i] is SceneAuthoring;
+                hasTransform |= components[i] is Transform;
+            }
+
+            return hasAuthoring && hasTransform;
+        }
+    }
+}

package/Editor/EditorLifecycle.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6b33bd95ec1b4077b588251454b2d5fe

package/Editor/EntityInspectorTarget.cs

@@ -0,0 +1,26 @@
+using Delta.ECS;
+
+namespace Delta.ECS.Unity.Editor
+{
+    internal readonly struct EntityInspectorTarget
+    {
+        internal readonly SceneAuthoring Authoring;
+        internal readonly string StableId;
+        internal readonly SceneWorld RuntimeWorld;
+        internal readonly Entity RuntimeEntity;
+
+        internal EntityInspectorTarget(
+            SceneAuthoring authoring,
+            string stableId,
+            SceneWorld runtimeWorld = null,
+            Entity runtimeEntity = default)
+        {
+            Authoring = authoring;
+            StableId = stableId;
+            RuntimeWorld = runtimeWorld;
+            RuntimeEntity = runtimeEntity;
+        }
+
+        internal bool IsRuntime => RuntimeWorld != null && RuntimeEntity.IsValid;
+    }
+}

package/Editor/EntityInspectorTarget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 37e1f33b80b347bbb192b6ef0b30de22
+timeCreated: 1790675350