com.artromskiy.deltaecs.unity 0.0.37

package/Editor/HierarchyNodeHandler.cs.meta

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

package/Editor/HierarchySelection.cs

@@ -0,0 +1,171 @@
+using System;
+using Delta.ECS;
+using Unity.Hierarchy;
+using UnityEditor;
+
+namespace Delta.ECS.Unity.Editor
+{
+    internal static class HierarchySelection
+    {
+        internal static EntityInspectorTarget Current { get; private set; }
+        internal static SceneAuthoring Authoring => Current.Authoring;
+        internal static string StableId => Current.StableId;
+        internal static SceneWorld RuntimeWorld => Current.RuntimeWorld;
+        internal static Entity RuntimeEntity => Current.RuntimeEntity;
+        internal static event Action Changed;
+
+        private static HierarchyNodeHandler _handler;
+        private static HierarchyNode _node;
+        private static HierarchyView _view;
+        private static bool _selectionCheckScheduled;
+
+        internal static void SetFromHierarchy(
+            HierarchyNodeHandler handler,
+            HierarchyView view,
+            SceneAuthoring authoring,
+            string stableId,
+            SceneWorld runtimeWorld,
+            Entity runtimeEntity,
+            HierarchyNode node)
+        {
+            bool changed = Current.Authoring != authoring
+                || !string.Equals(Current.StableId, stableId, StringComparison.Ordinal)
+                || Current.RuntimeWorld != runtimeWorld
+                || Current.RuntimeEntity != runtimeEntity;
+
+            Current = new EntityInspectorTarget(authoring, stableId, runtimeWorld, runtimeEntity);
+            _handler = handler;
+            _node = node;
+            _view = view;
+
+            if (changed)
+            {
+                Changed?.Invoke();
+            }
+        }
+
+        internal static void UpdateSelectedTarget(
+            HierarchyNodeHandler handler,
+            HierarchyNode node,
+            SceneAuthoring authoring,
+            string stableId,
+            SceneWorld runtimeWorld,
+            Entity runtimeEntity)
+        {
+            if (_handler != handler || _node != node)
+            {
+                return;
+            }
+
+            bool changed = Current.Authoring != authoring
+                || !string.Equals(Current.StableId, stableId, StringComparison.Ordinal)
+                || Current.RuntimeWorld != runtimeWorld
+                || Current.RuntimeEntity != runtimeEntity;
+            Current = new EntityInspectorTarget(authoring, stableId, runtimeWorld, runtimeEntity);
+            SelectionProxyBridge.UpdateTarget(handler, node, Current);
+            if (changed)
+            {
+                Changed?.Invoke();
+            }
+        }
+
+        internal static void Clear(HierarchyView view)
+        {
+            if (_view == view)
+            {
+                SetEmpty();
+            }
+        }
+
+        internal static void DeferClear(HierarchyView view)
+        {
+            if (_view == view)
+            {
+                ScheduleSelectionValidation();
+            }
+        }
+
+        internal static void ClearHandler(HierarchyNodeHandler handler)
+        {
+            if (_handler == handler)
+            {
+                SetEmpty();
+            }
+        }
+
+        internal static void ClearIfSelected(
+            HierarchyNodeHandler handler,
+            SceneAuthoring authoring,
+            string stableId)
+        {
+            if (_handler == handler && Authoring == authoring
+                && string.Equals(StableId, stableId, StringComparison.Ordinal))
+            {
+                SetEmpty();
+            }
+        }
+
+        internal static void ClearIfSelected(SceneWorld runtimeWorld, Entity runtimeEntity)
+        {
+            if (Current.RuntimeWorld == runtimeWorld && Current.RuntimeEntity == runtimeEntity)
+            {
+                SetEmpty();
+            }
+        }
+
+        internal static void RenameSelected(SceneAuthoring authoring, string stableId)
+        {
+            if (Authoring == authoring && string.Equals(StableId, stableId, StringComparison.Ordinal))
+            {
+                Changed?.Invoke();
+            }
+        }
+
+        private static void SetEmpty()
+        {
+            if (Authoring == null && string.IsNullOrEmpty(StableId))
+            {
+                _handler = null;
+                _node = default;
+                _view = null;
+                return;
+            }
+
+            Current = default;
+            _handler = null;
+            _node = default;
+            _view = null;
+            Changed?.Invoke();
+        }
+
+        private static void ScheduleSelectionValidation()
+        {
+            if (_selectionCheckScheduled)
+            {
+                return;
+            }
+
+            _selectionCheckScheduled = true;
+            EditorApplication.delayCall += ValidateHierarchySelection;
+        }
+
+        private static void ValidateHierarchySelection()
+        {
+            _selectionCheckScheduled = false;
+            if (_view == null)
+            {
+                return;
+            }
+
+            foreach (ref readonly HierarchyNode selectedNode in _view.ViewModel.EnumerateNodesWithFlags(HierarchyNodeFlags.Selected))
+            {
+                if (selectedNode == _node)
+                {
+                    return;
+                }
+            }
+
+            SetEmpty();
+        }
+    }
+}

package/Editor/HierarchySelection.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d7f4c45d26784e3581934de656dab780
+timeCreated: 1790675335

package/Editor/InspectorState.cs

@@ -0,0 +1,220 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace Delta.ECS.Unity.Editor
+{
+    [FilePath("Library/InspectorState.asset", FilePathAttribute.Location.ProjectFolder)]
+    internal sealed class InspectorState : ScriptableSingleton<InspectorState>
+    {
+        private const string LegacyOrderPreferencePrefix = "DeltaEcs.Inspector.ComponentOrder.";
+        private const string LegacyCollapsePreferencePrefix = "DeltaEcs.Inspector.ComponentCollapsed.";
+
+        [Serializable]
+        private struct ComponentFoldout
+        {
+            public string Schema;
+            public bool Expanded;
+        }
+
+        [SerializeField] private List<string> _componentOrder = new();
+        [SerializeField] private List<ComponentFoldout> _componentFoldouts = new();
+
+        [NonSerialized] private bool _legacyOrderLoaded;
+        [NonSerialized] private Dictionary<ulong, int> _componentOrderIndices;
+
+        internal int GetComponentOrder(ulong schema)
+        {
+            EnsureLegacyOrderLoaded();
+            EnsureOrderIndices();
+            return _componentOrderIndices.TryGetValue(schema, out int index) ? index : int.MaxValue;
+        }
+
+        internal List<ulong> GetComponentOrderSnapshot()
+        {
+            EnsureLegacyOrderLoaded();
+            var order = new List<ulong>(_componentOrder.Count);
+            for (int i = 0; i < _componentOrder.Count; i++)
+            {
+                if (TryParseSchema(_componentOrder[i], out ulong schema))
+                {
+                    order.Add(schema);
+                }
+            }
+
+            return order;
+        }
+
+        internal void SetComponentOrder(IEnumerable<ulong> schemas)
+        {
+            EnsureLegacyOrderLoaded();
+            var nextOrder = schemas
+                .Distinct()
+                .Select(schema => schema.ToString("X16", CultureInfo.InvariantCulture))
+                .ToList();
+
+            if (_componentOrder.SequenceEqual(nextOrder, StringComparer.Ordinal))
+            {
+                return;
+            }
+
+            _componentOrder = nextOrder;
+            _componentOrderIndices = null;
+            Save(true);
+        }
+
+        internal void EnsureComponentOrder(IEnumerable<ulong> schemas)
+        {
+            List<ulong> order = GetComponentOrderSnapshot();
+            HashSet<ulong> knownSchemas = order.ToHashSet();
+            bool changed = false;
+            foreach (ulong schema in schemas)
+            {
+                if (knownSchemas.Add(schema))
+                {
+                    order.Add(schema);
+                    changed = true;
+                }
+            }
+
+            if (changed)
+            {
+                SetComponentOrder(order);
+            }
+        }
+
+        internal bool MoveComponent(ulong schema, int direction, IReadOnlyList<ulong> visibleOrder)
+        {
+            List<ulong> order = GetComponentOrderSnapshot();
+            var visibleSchemas = visibleOrder.Distinct().ToList();
+            int index = visibleSchemas.IndexOf(schema);
+            int nextIndex = index + direction;
+            if (index < 0 || nextIndex < 0 || nextIndex >= visibleSchemas.Count)
+            {
+                return false;
+            }
+
+            (visibleSchemas[index], visibleSchemas[nextIndex]) = (visibleSchemas[nextIndex], visibleSchemas[index]);
+            var visibleSet = visibleSchemas.ToHashSet();
+            int nextVisibleIndex = 0;
+            for (int i = 0; i < order.Count && nextVisibleIndex < visibleSchemas.Count; i++)
+            {
+                if (visibleSet.Contains(order[i]))
+                {
+                    order[i] = visibleSchemas[nextVisibleIndex++];
+                }
+            }
+
+            SetComponentOrder(order);
+            return true;
+        }
+
+        internal bool IsComponentExpanded(ulong schema)
+        {
+            int index = FindFoldout(schema);
+            if (index >= 0)
+            {
+                return _componentFoldouts[index].Expanded;
+            }
+
+            bool expanded = EditorPrefs.GetBool(GetLegacyCollapseKey(schema), true);
+            _componentFoldouts.Add(new ComponentFoldout { Schema = FormatSchema(schema), Expanded = expanded });
+            Save(true);
+            return expanded;
+        }
+
+        internal void SetComponentExpanded(ulong schema, bool expanded)
+        {
+            int index = FindFoldout(schema);
+            if (index >= 0)
+            {
+                ComponentFoldout foldout = _componentFoldouts[index];
+                if (foldout.Expanded == expanded)
+                {
+                    return;
+                }
+
+                foldout.Expanded = expanded;
+                _componentFoldouts[index] = foldout;
+            }
+            else
+            {
+                _componentFoldouts.Add(new ComponentFoldout { Schema = FormatSchema(schema), Expanded = expanded });
+            }
+
+            Save(true);
+        }
+
+        private int FindFoldout(ulong schema)
+        {
+            string schemaText = FormatSchema(schema);
+            for (int i = 0; i < _componentFoldouts.Count; i++)
+            {
+                if (string.Equals(_componentFoldouts[i].Schema, schemaText, StringComparison.Ordinal))
+                {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        private void EnsureLegacyOrderLoaded()
+        {
+            if (_legacyOrderLoaded)
+            {
+                return;
+            }
+
+            _legacyOrderLoaded = true;
+            if (_componentOrder.Count > 0)
+            {
+                return;
+            }
+
+            string legacyOrder = EditorPrefs.GetString($"{LegacyOrderPreferencePrefix}{Application.dataPath}", string.Empty);
+            string[] schemas = legacyOrder.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
+            for (int i = 0; i < schemas.Length; i++)
+            {
+                if (TryParseSchema(schemas[i], out ulong schema))
+                {
+                    _componentOrder.Add(FormatSchema(schema));
+                }
+            }
+
+            if (_componentOrder.Count > 0)
+            {
+                _componentOrderIndices = null;
+                Save(true);
+            }
+        }
+
+        private void EnsureOrderIndices()
+        {
+            if (_componentOrderIndices != null)
+            {
+                return;
+            }
+
+            _componentOrderIndices = new Dictionary<ulong, int>(_componentOrder.Count);
+            for (int i = 0; i < _componentOrder.Count; i++)
+            {
+                if (TryParseSchema(_componentOrder[i], out ulong schema))
+                {
+                    _componentOrderIndices.TryAdd(schema, i);
+                }
+            }
+        }
+
+        private static string GetLegacyCollapseKey(ulong schema) =>
+            $"{LegacyCollapsePreferencePrefix}{Application.dataPath}:{FormatSchema(schema)}";
+
+        private static string FormatSchema(ulong schema) => schema.ToString("X16", CultureInfo.InvariantCulture);
+
+        private static bool TryParseSchema(string value, out ulong schema) =>
+            ulong.TryParse(value, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out schema);
+    }
+}

package/Editor/InspectorState.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4b1e9a56e74c4e8b9a6d3c1f0e2a7b5d

package/Editor/Resources/Inspector/BoundEntityRootEditor.uss

@@ -0,0 +1,28 @@
+.deltaecs-bound-entity-foldout > .unity-foldout__toggle {
+    min-height: 22px;
+    -unity-font-style: bold;
+}
+
+.deltaecs-bound-entity-foldout > .unity-foldout__content {
+    padding-left: 0;
+}
+
+.deltaecs-unity-component-foldout {
+    margin-top: 1px;
+    margin-bottom: 1px;
+    border-top-width: 1px;
+    border-top-color: var(--unity-colors-inspector_titlebar-border_accent);
+}
+
+.deltaecs-unity-component-foldout > .unity-foldout__toggle {
+    min-height: 22px;
+    background-color: var(--unity-colors-inspector_titlebar-background);
+}
+
+.deltaecs-unity-component-foldout > .unity-foldout__toggle > .unity-foldout__text {
+    -unity-font-style: bold;
+}
+
+.deltaecs-unity-component-foldout > .unity-foldout__content {
+    padding-left: 0;
+}

package/Editor/Resources/Inspector/BoundEntityRootEditor.uss.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5bb65147946940e88f56a792f5f08fbb

package/Editor/Resources/Inspector/SceneAuthoringEditor.uss

@@ -0,0 +1,282 @@
+.ecs-inspector-root {
+    flex-grow: 1;
+    min-height: 0;
+    margin: 0;
+    padding: 0;
+}
+
+.ecs-bound-inspector .ecs-inspector-root {
+    flex-grow: 0;
+}
+
+.ecs-bound-inspector .ecs-component-list {
+    flex-grow: 0;
+    max-height: 480px;
+}
+
+.ecs-inspector-header,
+.ecs-inspector-footer {
+    flex-shrink: 0;
+    padding-left: 5px;
+    padding-right: 5px;
+}
+
+.ecs-inspector-header {
+    padding-top: 8px;
+    padding-bottom: 8px;
+    padding-left: 8px;
+    padding-right: 8px;
+}
+
+.ecs-inspector-footer {
+    padding-bottom: 8px;
+}
+
+.ecs-component-list {
+    flex-grow: 1;
+    flex-shrink: 1;
+    min-height: 0;
+    margin: 0;
+    padding: 0;
+}
+
+.ecs-component-row {
+    width: 100%;
+    min-width: 0;
+    flex-direction: row;
+    align-items: stretch;
+    margin: 0;
+    padding: 0;
+}
+
+.ecs-component-list .unity-list-view__reorderable-handle {
+    width: 22px;
+    min-width: 22px;
+    flex-shrink: 0;
+    align-items: center;
+    justify-content: center;
+    margin: 0;
+    padding: 0;
+    background-color: var(--unity-colors-inspector_titlebar-background);
+}
+
+.ecs-component-list .unity-list-view__reorderable-item__container {
+    margin: 0;
+    padding: 0;
+    flex-grow: 1;
+}
+
+.ecs-component-list .unity-list-view__item,
+.ecs-component-list .unity-list-view__item:hover,
+.ecs-component-list .unity-list-view__item:selected {
+    background-color: transparent;
+    border-width: 0;
+    margin: 0;
+}
+
+.ecs-component-list .unity-list-view__reorderable-item,
+.ecs-component-list .unity-list-view__reorderable-item:hover,
+.ecs-component-list .unity-list-view__reorderable-item:selected {
+    border-bottom-width: 1px;
+    border-bottom-color: var(--unity-colors-inspector_titlebar-border_accent);
+}
+
+.ecs-component-list .ecs-add-component-row,
+.ecs-component-list .ecs-add-component-row:hover,
+.ecs-component-list .ecs-add-component-row:selected {
+    border-bottom-width: 0;
+}
+
+.ecs-component-list .ecs-component-last-bound-row,
+.ecs-component-list .ecs-component-last-bound-row:hover,
+.ecs-component-list .ecs-component-last-bound-row:selected {
+    border-bottom-width: 0;
+}
+
+.ecs-component-list .unity-list-view__reorderable-handle:hover {
+    background-color: var(--unity-colors-inspector_titlebar-background-hover);
+}
+
+.ecs-add-component-row > .unity-list-view__reorderable-handle {
+    display: none;
+}
+
+.ecs-entity-header {
+    margin-bottom: 4px;
+}
+
+.ecs-entity-title-row,
+.ecs-entity-id-row {
+    flex-direction: row;
+    align-items: center;
+    min-height: 20px;
+}
+
+.ecs-entity-icon {
+    width: 18px;
+    height: 18px;
+    margin-right: 4px;
+    color: var(--unity-colors-label-text);
+    -unity-text-align: middle-center;
+}
+
+.ecs-entity-name,
+.ecs-runtime-entity-name {
+    flex-grow: 1;
+    min-width: 0;
+    -unity-font-style: bold;
+}
+
+.ecs-entity-id-row {
+    margin-top: 4px;
+}
+
+.ecs-view-binding {
+    flex-direction: row;
+    align-items: center;
+    margin-top: 6px;
+}
+
+.ecs-view-binding > .ecs-value-field {
+    flex-grow: 1;
+    min-width: 0;
+}
+
+.ecs-view-binding > .unity-button {
+    margin-left: 4px;
+}
+
+.ecs-entity-metadata {
+    flex-grow: 1;
+    min-width: 0;
+    color: var(--unity-colors-label-text);
+    white-space: normal;
+}
+
+.ecs-runtime-id,
+.ecs-schema-label,
+.ecs-empty-component,
+.ecs-unsupported-field {
+    margin-top: 4px;
+    color: rgb(174, 177, 183);
+}
+
+.ecs-component-card {
+    width: auto;
+    min-width: 0;
+    flex-grow: 1;
+    margin: 0;
+    padding: 0;
+    background-color: var(--unity-colors-window-background);
+}
+
+.ecs-component-card-header {
+    width: 100%;
+    height: 20px;
+    min-height: 20px;
+    max-height: 20px;
+    align-items: center;
+    margin: 0;
+    padding-top: 0;
+    padding-left: 5px;
+    padding-bottom: 0;
+    padding-right: 5px;
+    background-color: var(--unity-colors-inspector_titlebar-background);
+}
+
+.ecs-component-card-header:hover {
+    background-color: var(--unity-colors-inspector_titlebar-background-hover);
+}
+
+.ecs-component-title {
+    flex-grow: 1;
+    -unity-font-style: bold;
+}
+
+.ecs-component-body {
+    padding-top: 2px;
+    padding-bottom: 4px;
+}
+
+.ecs-value-field > .unity-base-field__label {
+    min-width: 96px;
+    flex-basis: 36%;
+    flex-shrink: 0;
+    margin-right: 4px;
+}
+
+.ecs-value-field > .unity-base-field__input {
+    min-width: 0;
+    flex-grow: 1;
+}
+
+.ecs-component-menu,
+.ecs-component-remove {
+    width: 18px;
+    min-width: 18px;
+    max-width: 18px;
+    height: 18px;
+    min-height: 18px;
+    max-height: 18px;
+    flex-shrink: 0;
+    align-self: center;
+    margin: 0;
+    padding: 0;
+    -unity-text-align: middle-center;
+    color: var(--unity-colors-label-text);
+    background-color: transparent;
+    border-width: 0;
+    border-radius: 0;
+}
+
+.ecs-component-menu:hover,
+.ecs-component-remove:hover {
+    background-color: var(--unity-colors-button-background-hover);
+}
+
+.ecs-component-menu:active,
+.ecs-component-remove:active {
+    background-color: var(--unity-colors-button-background-pressed);
+}
+
+.ecs-component-menu {
+    align-items: center;
+    justify-content: center;
+    margin-right: 2px;
+    color: var(--unity-colors-label-text);
+    font-size: 13px;
+}
+
+.ecs-component-menu > .unity-toolbar-menu__text {
+    flex-grow: 1;
+    width: 100%;
+    height: 100%;
+    min-width: 0;
+    margin: 0;
+    padding: 0;
+    -unity-text-align: middle-center;
+}
+
+.ecs-component-menu-arrow {
+    display: none;
+}
+
+.ecs-component-menu .unity-toolbar-menu__arrow {
+    display: none;
+}
+
+.ecs-component-remove {
+    font-size: 14px;
+}
+
+.ecs-add-component {
+    width: 230px;
+    height: 24px;
+    align-self: center;
+    margin-top: 5px;
+    margin-bottom: 4px;
+}
+
+.ecs-delete-entity {
+    margin-top: 2px;
+}