com.artromskiy.deltaecs.unity 0.0.38 → 0.0.39

package/Runtime/PropertyBagValueAccess.cs

@@ -0,0 +1,258 @@
+using System;
+using System.Collections.Generic;
+using Delta.ECS;
+using Unity.Properties;
+
+namespace Delta.ECS.Unity
+{
+    internal static class PropertyBagValueAccess
+    {
+        internal static bool TryGetValue(object container, Type containerType, string[] path, out object value)
+        {
+            value = null;
+            if (container == null || path == null || path.Length == 0)
+            {
+                return false;
+            }
+
+            IPropertyBag propertyBag = PropertyBag.GetPropertyBag(containerType);
+            if (propertyBag == null)
+            {
+                return false;
+            }
+
+            var visitor = new ReadPathVisitor(path, 0);
+            propertyBag.Accept(visitor, ref container);
+            value = visitor.Value;
+            return visitor.Found;
+        }
+
+        internal static bool TrySetValue(ref object container, Type containerType, string[] path, object value)
+        {
+            if (container == null || path == null || path.Length == 0)
+            {
+                return false;
+            }
+
+            IPropertyBag propertyBag = PropertyBag.GetPropertyBag(containerType);
+            if (propertyBag == null)
+            {
+                return false;
+            }
+
+            var visitor = new WritePathVisitor(path, 0, value);
+            propertyBag.Accept(visitor, ref container);
+            return visitor.Succeeded;
+        }
+
+        internal static string FormatPath(IReadOnlyList<string> path)
+        {
+            return string.Join("/", path);
+        }
+
+        internal static string[] ParsePath(string path)
+        {
+            return string.IsNullOrEmpty(path) ? Array.Empty<string>() : path.Split('/');
+        }
+
+        internal static void CollectEntityReferences(object container, Type containerType,
+            Func<Entity, string> stableIdResolver, IList<EntityReference> references)
+        {
+            if (container == null)
+            {
+                return;
+            }
+
+            IPropertyBag propertyBag = PropertyBag.GetPropertyBag(containerType);
+            if (propertyBag == null)
+            {
+                return;
+            }
+
+            var visitor = new EntityReferenceVisitor(stableIdResolver, references);
+            propertyBag.Accept(visitor, ref container);
+        }
+
+        private sealed class ReadPathVisitor : IPropertyBagVisitor
+        {
+            private readonly string[] _path;
+            private readonly int _pathIndex;
+
+            internal object Value;
+            internal bool Found;
+
+            internal ReadPathVisitor(string[] path, int pathIndex)
+            {
+                _path = path;
+                _pathIndex = pathIndex;
+            }
+
+            public void Visit<TContainer>(IPropertyBag<TContainer> properties, ref TContainer container)
+            {
+                foreach (var property in properties.GetProperties(ref container))
+                {
+                    if (!string.Equals(property.Name, _path[_pathIndex], StringComparison.Ordinal))
+                    {
+                        continue;
+                    }
+
+                    object value = property.GetValue(ref container);
+                    if (_pathIndex == _path.Length - 1)
+                    {
+                        Value = value;
+                        Found = true;
+                    }
+                    else if (value != null)
+                    {
+                        IPropertyBag nestedBag = PropertyBag.GetPropertyBag(value.GetType());
+                        if (nestedBag != null)
+                        {
+                            var nestedVisitor = new ReadPathVisitor(_path, _pathIndex + 1);
+                            nestedBag.Accept(nestedVisitor, ref value);
+                            Value = nestedVisitor.Value;
+                            Found = nestedVisitor.Found;
+                        }
+                    }
+
+                    return;
+                }
+            }
+        }
+
+        private sealed class WritePathVisitor : IPropertyBagVisitor
+        {
+            private readonly string[] _path;
+            private readonly int _pathIndex;
+            private readonly object _value;
+
+            internal bool Succeeded;
+
+            internal WritePathVisitor(string[] path, int pathIndex, object value)
+            {
+                _path = path;
+                _pathIndex = pathIndex;
+                _value = value;
+            }
+
+            public void Visit<TContainer>(IPropertyBag<TContainer> properties, ref TContainer container)
+            {
+                TContainer updated = container;
+                foreach (var property in properties.GetProperties(ref updated))
+                {
+                    if (!string.Equals(property.Name, _path[_pathIndex], StringComparison.Ordinal))
+                    {
+                        continue;
+                    }
+
+                    if (property.IsReadOnly)
+                    {
+                        return;
+                    }
+
+                    if (_pathIndex == _path.Length - 1)
+                    {
+                        property.SetValue(ref updated, _value);
+                        Succeeded = true;
+                    }
+                    else
+                    {
+                        object nestedValue = property.GetValue(ref updated);
+                        if (nestedValue == null)
+                        {
+                            return;
+                        }
+
+                        IPropertyBag nestedBag = PropertyBag.GetPropertyBag(nestedValue.GetType());
+                        if (nestedBag == null)
+                        {
+                            return;
+                        }
+
+                        var nestedVisitor = new WritePathVisitor(_path, _pathIndex + 1, _value);
+                        nestedBag.Accept(nestedVisitor, ref nestedValue);
+                        if (nestedVisitor.Succeeded)
+                        {
+                            property.SetValue(ref updated, nestedValue);
+                            Succeeded = true;
+                        }
+                    }
+
+                    container = updated;
+                    return;
+                }
+            }
+        }
+
+        private sealed class EntityReferenceVisitor : IPropertyBagVisitor, IPropertyVisitor
+        {
+            private readonly Func<Entity, string> _stableIdResolver;
+            private readonly IList<EntityReference> _references;
+            private readonly List<string> _path = new();
+            private readonly HashSet<object> _activeReferences = new HashSet<object>(new ReferenceSet());
+
+            internal EntityReferenceVisitor(Func<Entity, string> stableIdResolver, IList<EntityReference> references)
+            {
+                _stableIdResolver = stableIdResolver;
+                _references = references;
+            }
+
+            public void Visit<TContainer>(IPropertyBag<TContainer> properties, ref TContainer container)
+            {
+                foreach (var property in properties.GetProperties(ref container))
+                {
+                    ((IPropertyAccept<TContainer>)property).Accept(this, ref container);
+                }
+            }
+
+            public void Visit<TContainer, TValue>(Property<TContainer, TValue> property, ref TContainer container)
+            {
+                TValue value = property.GetValue(ref container);
+                _path.Add(property.Name);
+                try
+                {
+                    if (typeof(TValue) == typeof(Entity))
+                    {
+                        string targetId = _stableIdResolver((Entity)(object)value);
+                        if (!string.IsNullOrEmpty(targetId))
+                        {
+                            _references.Add(new EntityReference(FormatPath(_path), targetId));
+                        }
+                    }
+                    else if (_path.Count < 24 && value != null)
+                    {
+                        object activeReference = value;
+                        bool trackReference = !typeof(TValue).IsValueType;
+                        if (!trackReference || _activeReferences.Add(activeReference))
+                        {
+                            try
+                            {
+                                object nestedValue = value;
+                                if (PropertyBag.TryGetPropertyBagForValue(ref nestedValue, out IPropertyBag nestedBag))
+                                {
+                                    nestedBag.Accept(this, ref nestedValue);
+                                }
+                            }
+                            finally
+                            {
+                                if (trackReference)
+                                {
+                                    _activeReferences.Remove(activeReference);
+                                }
+                            }
+                        }
+                    }
+                }
+                finally
+                {
+                    _path.RemoveAt(_path.Count - 1);
+                }
+            }
+        }
+
+        private sealed class ReferenceSet : IEqualityComparer<object>
+        {
+            public new bool Equals(object left, object right) => ReferenceEquals(left, right);
+            public int GetHashCode(object value) => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(value);
+        }
+    }
+}

package/Runtime/PropertyBagValueAccess.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 54aae609d31564e449408ffc4cfe0ffd

package/Runtime/SceneWorld.cs

@@ -212,6 +212,11 @@ namespace Delta.ECS.Unity
                         continue;
                     }
 
+                    if (descriptor.IsTag)
+                    {
+                        continue;
+                    }
+
                     object value = data.CreateValue(descriptor.ValueType, ResolveEntity);
                     if (_integration.TryRead(entity, descriptor.Id, out ComponentSnapshot snapshot, out _)
                         && !_integration.TryWrite(entity, descriptor.Id, value, snapshot.Stamp, out _, out EcsWriteError error))
@@ -341,7 +346,7 @@ namespace Delta.ECS.Unity
         {
             if (TryGetEntity(authoring, out Entity entity))
             {
-                return _integration.TryRead(entity, descriptor.Id, out snapshot, out error);
+                return TryRead(entity, descriptor, out snapshot, out error);
             }
 
             snapshot = default;
@@ -349,13 +354,50 @@ namespace Delta.ECS.Unity
             return false;
         }
 
+        internal bool TryRead(Entity entity, ComponentDescriptor descriptor,
+            out ComponentSnapshot snapshot, out EcsReadError error)
+            => _integration.TryRead(entity, descriptor.Id, out snapshot, out error);
+
+        internal bool TryGetComponents(Entity entity, Span<ComponentId> destination, out int totalCount)
+        {
+            totalCount = 0;
+            if (!_integration.IsAlive(entity))
+            {
+                return false;
+            }
+
+            ReadOnlyMemory<ComponentDescriptor> components = _integration.Catalog.Components;
+            for (int index = 0; index < components.Length; index++)
+            {
+                ComponentId component = components.Span[index].Id;
+                if (!_world.Has(entity, component))
+                {
+                    continue;
+                }
+
+                if (totalCount < destination.Length)
+                {
+                    destination[totalCount] = component;
+                }
+
+                totalCount++;
+            }
+
+            return true;
+        }
+
         internal bool TryWrite(EntityAuthoring authoring, ComponentData data,
             ComponentDescriptor descriptor, object value, out EcsWriteError error)
         {
-            if (!TryGetEntity(authoring, out Entity entity)
-                || !_integration.TryRead(entity, descriptor.Id, out ComponentSnapshot snapshot, out _))
+            if (!TryGetEntity(authoring, out Entity entity) || !_integration.IsAlive(entity))
             {
-                error = default;
+                error = new EcsWriteError(EcsWriteErrorCode.EntityNotAlive);
+                return false;
+            }
+
+            if (!_integration.TryRead(entity, descriptor.Id, out ComponentSnapshot snapshot, out _))
+            {
+                error = new EcsWriteError(EcsWriteErrorCode.ComponentMissing);
                 return false;
             }
 
@@ -364,7 +406,15 @@ namespace Delta.ECS.Unity
                 return false;
             }
 
-            data.StoreValue(value, GetStableIdOrEmpty);
+            if (descriptor.IsTag)
+            {
+                data.StoreDefaultTag();
+            }
+            else
+            {
+                data.StoreValue(value, GetStableIdOrEmpty);
+            }
+
             return true;
         }
 
@@ -395,6 +445,13 @@ namespace Delta.ECS.Unity
                 return false;
             }
 
+            if (descriptor.IsTag)
+            {
+                data.StoreDefaultTag();
+                error = default;
+                return true;
+            }
+
             object value = data.CreateValue(descriptor.ValueType, ResolveEntity);
             if (!_integration.TryRead(entity, descriptor.Id, out ComponentSnapshot snapshot, out EcsReadError readError))
             {

package/Runtime.meta

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.artromskiy.deltaecs.unity",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "displayName": "DeltaECS Unity",
   "description": "Unity scene authoring and editor integration for DeltaECS.",
   "unity": "6000.7",
@@ -23,9 +23,15 @@
   },
   "files": [
     "Runtime/",
+    "Runtime.meta",
     "Editor/",
+    "Editor.meta",
     "README.md",
+    "README.md.meta",
     "CHANGELOG.md",
-    "LICENSE.md"
+    "CHANGELOG.md.meta",
+    "LICENSE.md",
+    "LICENSE.md.meta",
+    "package.json.meta"
   ]
 }

package/package.json.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 97f36ccebac94385907d421b09dd5287