com.artromskiy.deltaecs.unity 0.0.37

package/Editor/SceneEntityInspectorView.cs.meta

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

package/Editor/SelectionProxy.cs

@@ -0,0 +1,19 @@
+using UnityEngine;
+
+namespace Delta.ECS.Unity.Editor
+{
+    internal sealed class SelectionProxy : ScriptableObject
+    {
+        internal EntityInspectorTarget Target { get; private set; }
+
+        internal void SetTarget(EntityInspectorTarget target)
+        {
+            Target = target;
+            name = target.Authoring != null
+                ? target.Authoring.SceneData.TryGetEntity(target.StableId, out EntityAuthoring authoring)
+                    ? authoring.Name
+                    : "ECS Entity"
+                : $"Entity {target.RuntimeEntity.Index}";
+        }
+    }
+}

package/Editor/SelectionProxy.cs.meta

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

package/Editor/SelectionProxyBridge.cs

@@ -0,0 +1,64 @@
+using System.Collections.Generic;
+using Unity.Hierarchy;
+using UnityEditor;
+using UnityEngine;
+
+namespace Delta.ECS.Unity.Editor
+{
+    [InitializeOnLoad]
+    internal static class SelectionProxyBridge
+    {
+        private static readonly Dictionary<(HierarchyNodeHandler Handler, HierarchyNode Node), SelectionProxy> Proxies = new();
+
+        static SelectionProxyBridge()
+        {
+            AssemblyReloadEvents.beforeAssemblyReload += DisposeAll;
+        }
+
+        internal static EntityId GetEntityId(HierarchyNodeHandler handler, HierarchyNode node, EntityInspectorTarget target)
+        {
+            var key = (handler, node);
+            if (!Proxies.TryGetValue(key, out var proxy))
+            {
+                proxy = ScriptableObject.CreateInstance<SelectionProxy>();
+                proxy.hideFlags = HideFlags.DontSaveInEditor | HideFlags.DontSaveInBuild;
+                Proxies.Add(key, proxy);
+            }
+            proxy.SetTarget(target);
+            return proxy.GetEntityId();
+        }
+
+        internal static HierarchyNode GetNode(HierarchyNodeHandler handler, EntityId entityId)
+        {
+            foreach (var pair in Proxies)
+                if (pair.Key.Handler == handler && pair.Value.GetEntityId() == entityId)
+                    return pair.Key.Node;
+            return HierarchyNode.Null;
+        }
+
+        internal static void UpdateTarget(HierarchyNodeHandler handler, HierarchyNode node, EntityInspectorTarget target)
+        {
+            if (Proxies.TryGetValue((handler, node), out var proxy))
+                proxy.SetTarget(target);
+        }
+
+        internal static void Select(HierarchyNodeHandler handler, HierarchyNode node, EntityInspectorTarget target)
+        {
+            GetEntityId(handler, node, target);
+            var proxy = Proxies[(handler, node)];
+            if (Selection.activeObject != proxy) Selection.activeObject = proxy;
+        }
+
+        internal static void Remove(HierarchyNodeHandler handler, HierarchyNode node)
+        {
+            if (Proxies.Remove((handler, node), out var proxy))
+                Object.DestroyImmediate(proxy);
+        }
+
+        private static void DisposeAll()
+        {
+            foreach (var proxy in Proxies.Values) Object.DestroyImmediate(proxy);
+            Proxies.Clear();
+        }
+    }
+}

package/Editor/SelectionProxyBridge.cs.meta

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

package/Editor/SelectionProxyEditor.cs

@@ -0,0 +1,33 @@
+using UnityEditor;
+using UnityEngine.UIElements;
+
+namespace Delta.ECS.Unity.Editor
+{
+    [CustomEditor(typeof(SelectionProxy))]
+    internal sealed class SelectionProxyEditor : UnityEditor.Editor
+    {
+        private SceneEntityInspectorView _view;
+
+        public override bool UseDefaultMargins() => false;
+
+        public override bool RequiresConstantRepaint() => EditorApplication.isPlaying;
+
+        private void OnEnable()
+        {
+            _view?.Dispose();
+            _view = new SceneEntityInspectorView(ResolveTarget);
+        }
+
+        private EntityInspectorTarget ResolveTarget() => target is SelectionProxy proxy && proxy != null
+            ? proxy.Target
+            : default;
+
+        private void OnDisable()
+        {
+            _view?.Dispose();
+            _view = null;
+        }
+
+        public override VisualElement CreateInspectorGUI() => _view.CreateGUI();
+    }
+}

package/Editor/SelectionProxyEditor.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 00aa700f5c4e4b4aa1e9482b37f4a0bc

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Artromskiy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LICENSE.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 3e6daaa2fa564365859d2fa9bcb117c4
+TextScriptImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/README.md

@@ -0,0 +1,66 @@
+# DeltaECS Unity
+
+Unity scene authoring and editor integration for DeltaECS. This package
+requires Unity 6.7 (`6000.7`) or newer.
+
+## Install
+
+Add the npm-compatible registry and package to the Unity project's
+`Packages/manifest.json`:
+
+```json
+{
+  "scopedRegistries": [
+    {
+      "name": "Artromskiy",
+      "url": "https://registry.npmjs.org",
+      "scopes": ["com.artromskiy"]
+    }
+  ],
+  "dependencies": {
+    "com.artromskiy.deltaecs.unity": "0.0.37"
+  }
+}
+```
+
+Keep the project's existing `dependencies` and `scopedRegistries` entries when
+adding these values. The core `DeltaECS` runtime and `DeltaECS.Generators` are
+separate NuGet packages and are not included in this UPM package.
+
+## Register components
+
+Install `DeltaECS.Generators` in the assembly that declares components, then
+mark component structs with `DeltaEcsComponentAttribute`:
+
+```csharp
+using Delta.ECS;
+
+[DeltaEcsComponent]
+public struct Health
+{
+    public float Value;
+}
+```
+
+Generated module initializers register typed component factories. Create a
+world with the generated layout catalog:
+
+```csharp
+using var world = new World(GeneratedComponentCatalog.CreateLayoutRegistry());
+```
+
+The generator reports the stable schema ID for each component. Set
+`SchemaId` explicitly when a component's serialized identity must remain
+unchanged after a type rename:
+
+```csharp
+[DeltaEcsComponent(SchemaId = 0x1234UL)]
+public struct Position
+{
+    public float X;
+    public float Y;
+}
+```
+
+See the [DeltaECS documentation](https://github.com/Artromskiy/DeltaECS/wiki)
+for the runtime and generator APIs.

package/README.md.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 664213c7fff44a7b8136ecf8a78f0f7a

package/Runtime/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("DeltaECS.Unity.Editor")]

package/Runtime/AssemblyInfo.cs.meta

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

package/Runtime/ComponentData.cs

@@ -0,0 +1,120 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Delta.ECS;
+using Delta.ECS.Integration;
+using UnityEngine;
+
+namespace Delta.ECS.Unity
+{
+    [Serializable]
+    internal sealed class ComponentData
+    {
+        [SerializeField] private string _schemaId;
+        [SerializeField, TextArea(2, 8)] private string _json;
+        [SerializeField] private List<EntityReference> _entityReferences = new();
+
+        public string SchemaIdText => _schemaId;
+        public string Json => _json;
+        public IReadOnlyList<EntityReference> EntityReferences => _entityReferences ??= new List<EntityReference>();
+
+        public ComponentData(ulong schemaId, string json)
+        {
+            _schemaId = schemaId.ToString("X16");
+            _json = json;
+        }
+
+        public bool TryGetSchemaId(out SchemaId schemaId)
+        {
+            if (ulong.TryParse(_schemaId, System.Globalization.NumberStyles.HexNumber, null, out ulong value))
+            {
+                schemaId = new SchemaId(value);
+                return true;
+            }
+
+            schemaId = default;
+            return false;
+        }
+
+        public object CreateValue(Type componentType, Func<string, Entity> resolveEntity)
+        {
+            object value = string.IsNullOrEmpty(_json)
+                ? Activator.CreateInstance(componentType)
+                : JsonUtility.FromJson(_json, componentType);
+
+            if (value == null)
+            {
+                value = Activator.CreateInstance(componentType);
+            }
+
+            FieldInfo[] fields = componentType.GetFields(BindingFlags.Instance | BindingFlags.Public);
+            List<EntityReference> references = EntityReferenceList;
+            for (int i = 0; i < references.Count; i++)
+            {
+                EntityReference reference = references[i];
+                for (int fieldIndex = 0; fieldIndex < fields.Length; fieldIndex++)
+                {
+                    FieldInfo field = fields[fieldIndex];
+                    if (field.Name == reference.FieldName && field.FieldType == typeof(Entity))
+                    {
+                        field.SetValue(value, resolveEntity(reference.TargetEntityId));
+                        break;
+                    }
+                }
+            }
+
+            return value;
+        }
+
+        public void StoreValue(object value, Func<Entity, string> stableIdResolver)
+        {
+            if (value == null)
+            {
+                UnityThrowHelpers.ThrowArgumentNull(nameof(value));
+            }
+
+            _json = JsonUtility.ToJson(value);
+            EntityReferenceList.Clear();
+
+            FieldInfo[] fields = value.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public);
+            for (int i = 0; i < fields.Length; i++)
+            {
+                FieldInfo field = fields[i];
+                if (field.FieldType != typeof(Entity))
+                {
+                    continue;
+                }
+
+                Entity target = (Entity)field.GetValue(value);
+                string targetId = stableIdResolver(target) ?? string.Empty;
+                if (!string.IsNullOrEmpty(targetId))
+                {
+                    EntityReferenceList.Add(new EntityReference(field.Name, targetId));
+                }
+            }
+        }
+
+        public string GetEntityReference(string fieldName)
+        {
+            List<EntityReference> references = EntityReferenceList;
+            for (int i = 0; i < references.Count; i++)
+            {
+                if (string.Equals(references[i].FieldName, fieldName, StringComparison.Ordinal))
+                {
+                    return references[i].TargetEntityId;
+                }
+            }
+
+            return string.Empty;
+        }
+
+        private List<EntityReference> EntityReferenceList =>
+            _entityReferences ??= new List<EntityReference>();
+
+        public static ComponentData CreateDefault(ComponentDescriptor descriptor)
+        {
+            object value = Activator.CreateInstance(descriptor.ValueType);
+            return new ComponentData(descriptor.Schema.Value, JsonUtility.ToJson(value));
+        }
+    }
+}

package/Runtime/ComponentData.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 87f1a4659d8d42d286312f0d0c72248e

package/Runtime/DeltaECS.Unity.asmdef

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

package/Runtime/DeltaECS.Unity.asmdef.meta

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

package/Runtime/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e46a551e30de4d1383d31cd87e391b28
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Runtime/EntityAuthoring.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Delta.ECS.Unity
+{
+    [Serializable]
+    internal sealed class EntityAuthoring
+    {
+        [SerializeField] private string _stableId;
+        [SerializeField] private string _name = "Entity";
+        [SerializeField] private List<ComponentData> _components = new();
+
+        public string StableId
+        {
+            get
+            {
+                EnsureStableId();
+                return _stableId;
+            }
+        }
+
+        public string Name
+        {
+            get => string.IsNullOrEmpty(_name) ? "Entity" : _name;
+            set => _name = string.IsNullOrWhiteSpace(value) ? "Entity" : value;
+        }
+
+        public IList<ComponentData> Components => _components ??= new List<ComponentData>();
+
+        internal bool EnsureStableId()
+        {
+            if (!string.IsNullOrEmpty(_stableId))
+            {
+                return false;
+            }
+
+            _stableId = Guid.NewGuid().ToString("N");
+            return true;
+        }
+
+        internal void ReplaceStableId()
+        {
+            _stableId = Guid.NewGuid().ToString("N");
+        }
+    }
+}

package/Runtime/EntityAuthoring.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 862a594bb6d04e46901300e28f45e4f8

package/Runtime/EntityReference.cs

@@ -0,0 +1,21 @@
+using System;
+using UnityEngine;
+
+namespace Delta.ECS.Unity
+{
+    [Serializable]
+    internal sealed class EntityReference
+    {
+        [SerializeField] private string _fieldName;
+        [SerializeField] private string _targetEntityId;
+
+        public string FieldName => _fieldName;
+        public string TargetEntityId => _targetEntityId;
+
+        public EntityReference(string fieldName, string targetEntityId)
+        {
+            _fieldName = fieldName;
+            _targetEntityId = targetEntityId;
+        }
+    }
+}

package/Runtime/EntityReference.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 671e0ab0af8a4eb0a9e62dcb7b3048aa

package/Runtime/SceneAuthoring.cs

@@ -0,0 +1,202 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Delta.ECS.Unity
+{
+    /// <summary>
+    /// Stores entities authored for a Delta ECS scene. The Unity editor integration
+    /// creates a hidden scene object for it automatically; it does not own a Delta ECS World.
+    /// </summary>
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Delta ECS/Scene Authoring")]
+    public sealed class SceneAuthoring : MonoBehaviour
+    {
+        internal const string AuthoringObjectName = "Delta ECS Scene Authoring";
+
+        [SerializeField, HideInInspector]
+        private SceneData _sceneData = new();
+        [SerializeField, HideInInspector]
+        private List<SceneViewBinding> _viewBindings = new();
+
+        [NonSerialized] private Dictionary<string, GameObject> _viewsByStableId;
+        [NonSerialized] private Dictionary<UnityEngine.EntityId, string> _stableIdsByView;
+
+        internal SceneData SceneData => _sceneData ??= new SceneData();
+
+        internal bool TryGetView(string stableId, out GameObject view)
+        {
+            EnsureBindingIndex();
+            if (!string.IsNullOrEmpty(stableId) && _viewsByStableId.TryGetValue(stableId, out view) && view != null)
+            {
+                return true;
+            }
+
+            view = null;
+            return false;
+        }
+
+        internal bool TryGetStableId(GameObject view, out string stableId)
+        {
+            EnsureBindingIndex();
+            if (view != null && _stableIdsByView.TryGetValue(view.GetEntityId(), out stableId))
+            {
+                return true;
+            }
+
+            stableId = null;
+            return false;
+        }
+
+        /// <summary>Persists a same-scene Unity view binding for an authored ECS entity.</summary>
+        internal bool SetView(string stableId, GameObject view)
+        {
+            if (string.IsNullOrEmpty(stableId)
+                || (view != null && !SceneData.TryGetEntity(stableId, out _))
+                || (view != null && view.scene != gameObject.scene))
+            {
+                return false;
+            }
+
+            EnsureBindingIndex();
+            UnityEngine.EntityId viewId = view != null ? view.GetEntityId() : UnityEngine.EntityId.None;
+            for (int i = _viewBindings.Count - 1; i >= 0; i--)
+            {
+                SceneViewBinding binding = _viewBindings[i];
+                bool sameEntity = string.Equals(binding.StableId, stableId, StringComparison.Ordinal);
+                bool sameView = view != null && binding.View != null && binding.View.GetEntityId() == viewId;
+                if (sameEntity || sameView)
+                {
+                    _viewBindings.RemoveAt(i);
+                }
+            }
+
+            if (view != null)
+            {
+                _viewBindings.Add(new SceneViewBinding(stableId, view));
+            }
+
+            InvalidateBindingIndex();
+            EnsureBindingIndex();
+            return true;
+        }
+
+        internal bool RemoveView(string stableId) => SetView(stableId, null);
+
+        internal static SceneAuthoring FindForScene(Scene scene)
+        {
+            if (!scene.IsValid())
+            {
+                return null;
+            }
+
+            SceneAuthoring[] authorings = Resources.FindObjectsOfTypeAll<SceneAuthoring>();
+            for (int i = 0; i < authorings.Length; i++)
+            {
+                SceneAuthoring authoring = authorings[i];
+                if (authoring != null && authoring.gameObject.scene == scene)
+                {
+                    return authoring;
+                }
+            }
+
+            return null;
+        }
+
+        internal static SceneAuthoring GetOrCreateForScene(Scene scene)
+        {
+            if (!scene.IsValid() || !scene.isLoaded)
+            {
+                UnityThrowHelpers.ThrowArgument("Scene authoring requires a valid, loaded scene.", nameof(scene));
+            }
+
+            SceneAuthoring existing = FindForScene(scene);
+            if (existing != null)
+            {
+                return existing;
+            }
+
+            var authoringObject = new GameObject(AuthoringObjectName);
+            SceneManager.MoveGameObjectToScene(authoringObject, scene);
+            SceneAuthoring authoring = authoringObject.AddComponent<SceneAuthoring>();
+            authoringObject.hideFlags |= HideFlags.HideInHierarchy;
+            return authoring;
+        }
+
+        private void OnValidate()
+        {
+            SceneData.EnsureStableIds();
+            InvalidateBindingIndex();
+        }
+
+        private void OnEnable()
+        {
+            SceneData.Changed -= OnSceneDataChanged;
+            SceneData.Changed += OnSceneDataChanged;
+            InvalidateBindingIndex();
+        }
+
+        private void OnDisable()
+        {
+            if (_sceneData != null)
+            {
+                _sceneData.Changed -= OnSceneDataChanged;
+            }
+        }
+
+        private void OnSceneDataChanged(SceneDataChange change)
+        {
+            if (change.Kind == SceneDataChangeKind.EntityDestroyed)
+            {
+                RemoveView(change.StableId);
+            }
+        }
+
+        private void EnsureBindingIndex()
+        {
+            if (_viewsByStableId != null && _stableIdsByView != null)
+            {
+                return;
+            }
+
+            _viewsByStableId = new Dictionary<string, GameObject>(StringComparer.Ordinal);
+            _stableIdsByView = new Dictionary<UnityEngine.EntityId, string>();
+            _viewBindings ??= new List<SceneViewBinding>();
+            for (int i = 0; i < _viewBindings.Count; i++)
+            {
+                SceneViewBinding binding = _viewBindings[i];
+                if (string.IsNullOrEmpty(binding.StableId) || binding.View == null)
+                {
+                    continue;
+                }
+
+                UnityEngine.EntityId viewId = binding.View.GetEntityId();
+                _viewsByStableId[binding.StableId] = binding.View;
+                _stableIdsByView[viewId] = binding.StableId;
+            }
+        }
+
+        private void InvalidateBindingIndex()
+        {
+            _viewsByStableId = null;
+            _stableIdsByView = null;
+        }
+    }
+
+    [Serializable]
+    internal struct SceneViewBinding
+    {
+        [SerializeField] private string _stableId;
+        [SerializeField] private GameObject _view;
+
+        public string StableId => _stableId;
+        public GameObject View => _view;
+
+        public SceneViewBinding(string stableId, GameObject view)
+        {
+            _stableId = stableId;
+            _view = view;
+        }
+    }
+}

package/Runtime/SceneAuthoring.cs.meta

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