UPM package version 3.4.5

Author: web-flow

CHANGELOG.md

@@ -1,6 +1,19 @@
 # Svelto.ECS Changelog
 All notable changes to this project will be documented in this file. Changes are listed in random order of importance.
 
+## [3.4.5] - 04-2023
+* improved code after internal data refactoring and fixed some bugs
+* Added static DynamicEntityDescriptor method to create a new DynamicEntityDescriptor without passing an array of components
+* factory method to build entities without entity descriptor is now internal
+
+## [3.4.4] - 04-2023
+
+* refactored internal datastructures 
+* added IReactOnDisposeEx interface
+* added code to warmup all the entity descriptors at startup to avoid first time allocations when an entitydescriptor is used for the very first time
+* added the option to iterate transient filters per component like it already happens with persistent filters. Transient filters are tracked optionally. 
+* fixed huge bug in the filter enumerator, truly surprised this never showed up
+
 ## [3.4.2] - 03-2023
 
 * removed static caches used in performance critical paths as they were causing unexpected performance issues (the fetching of static data is slower than i imagined)

Core/ComponentBuilder.cs

@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Reflection;
-using System.Runtime.CompilerServices;
 using System.Threading;
 using DBC.ECS;
 using Svelto.Common;
@@ -26,104 +24,6 @@ public int GetHashCode(IComponentBuilder obj)
         }
     }
 
-    public static class BurstCompatibleCounter
-    {
-        public static int counter;        
-    }
-
-    static public class ComponentTypeMap
-    {
-        static readonly FasterDictionary<RefWrapper<Type>, ComponentID> _componentTypeMap = new FasterDictionary<RefWrapper<Type>, ComponentID>();
-        static readonly FasterDictionary<ComponentID, Type> _reverseComponentTypeMap = new FasterDictionary<ComponentID, Type>();
-
-        public static void Add(Type type, ComponentID idData)
-        {
-            _componentTypeMap.Add(type, idData);
-            _reverseComponentTypeMap.Add(idData, type);
-        }
-
-        public static ComponentID FetchID(Type type)
-        {
-            return _componentTypeMap[type];
-        }
-
-        public static Type FetchType(ComponentID id)
-        {
-            return _reverseComponentTypeMap[id];
-        }
-    }
-
-    public class ComponentTypeID<T> where T : struct, _IInternalEntityComponent
-    {
-        static readonly SharedStaticWrapper<ComponentID, ComponentTypeID<T>> _id;
-
-        public static ComponentID id
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => _id.Data;
-        }
-
-        //todo: any reason to not do this? If I don't, I cannot Create filters in ready functions and
-        //I have to remove the CreateFilter method
-        static ComponentTypeID()
-        {
-            Init();
-        }
-
-#if UNITY_BURST     
-        [Unity.Burst.BurstDiscard] 
-        //SharedStatic values must be initialized from not burstified code
-#endif
-        static void Init()
-        {
-            _id.Data = Interlocked.Increment(ref BurstCompatibleCounter.counter);
-            ComponentTypeMap.Add(typeof(T), id);
-        }
-    }
-
-    sealed class ComponentIDDebugProxy
-    {
-        public ComponentIDDebugProxy(ComponentID id)
-        {
-            this._id = id;
-        }
-        
-        public Type type => ComponentTypeMap.FetchType(_id);
-
-        readonly ComponentID _id;
-    }
-    
-    [DebuggerTypeProxy(typeof(ComponentIDDebugProxy))]
-    public struct ComponentID: IEquatable<ComponentID>
-    {
-        public static implicit operator int(ComponentID id)
-        {
-            return id._id;
-        }
-        
-        public static implicit operator uint(ComponentID id)
-        {
-            return (uint)id._id;
-        }
-        
-        public static implicit operator ComponentID(int id)
-        {
-            return new ComponentID() {_id = id};
-        }
-
-        public bool Equals(ComponentID other)
-        {
-            return _id == other._id;
-        }
-
-        public override int GetHashCode()
-        {
-            return _id;
-        }
-        
-        int _id;
-    }
-
     public class ComponentBuilder<T> : IComponentBuilder where T : struct, _IInternalEntityComponent
     {
         internal static readonly Type ENTITY_COMPONENT_TYPE;

Core/ComponentID.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Diagnostics;
+
+namespace Svelto.ECS
+{
+    sealed class ComponentIDDebugProxy
+    {
+        public ComponentIDDebugProxy(ComponentID id)
+        {
+            this._id = id;
+        }
+
+        public Type type => ComponentTypeMap.FetchType(_id);
+
+        readonly ComponentID _id;
+    }
+
+
+    [DebuggerTypeProxy(typeof(ComponentIDDebugProxy))]
+    public struct ComponentID: IEquatable<ComponentID>
+    {
+        public static implicit operator int(ComponentID id)
+        {
+            return id._id;
+        }
+
+        public static implicit operator uint(ComponentID id)
+        {
+            return (uint)id._id;
+        }
+
+        public static implicit operator ComponentID(int id)
+        {
+            return new ComponentID()
+            {
+                _id = id
+            };
+        }
+
+        public bool Equals(ComponentID other)
+        {
+            return _id == other._id;
+        }
+
+        public override int GetHashCode()
+        {
+            return _id;
+        }
+
+        int _id;
+    }
+}

Core/ComponentID.cs.meta

@@ -0,0 +1,38 @@
+using System.Runtime.CompilerServices;
+using System.Threading;
+using Svelto.Common;
+using Svelto.ECS.Internal;
+
+namespace Svelto.ECS
+{
+    public static class BurstCompatibleCounter
+    {
+        public static int counter;        
+    }
+
+    public class ComponentTypeID<T> where T : struct, _IInternalEntityComponent
+    {
+        static readonly SharedStaticWrapper<ComponentID, ComponentTypeID<T>> _id;
+
+        public static ComponentID id
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _id.Data;
+        }
+
+        static ComponentTypeID()
+        {
+            Init();
+        }
+
+#if UNITY_BURST
+        [Unity.Burst.BurstDiscard] 
+        //SharedStatic values must be initialized from not burstified code
+#endif
+        static void Init()
+        {
+            _id.Data = Interlocked.Increment(ref BurstCompatibleCounter.counter);
+            ComponentTypeMap.Add(typeof(T), id);
+        }
+    }
+}

Core/ComponentTypeID.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Runtime.CompilerServices;
+using Svelto.DataStructures;
+
+namespace Svelto.ECS
+{
+    public static class ComponentTypeMap
+    {
+        static readonly FasterDictionary<RefWrapper<Type>, ComponentID> _componentTypeMap = new FasterDictionary<RefWrapper<Type>, ComponentID>();
+        static readonly FasterDictionary<ComponentID, Type> _reverseComponentTypeMap = new FasterDictionary<ComponentID, Type>();
+
+        public static void Add(Type type, ComponentID idData)
+        {
+            _componentTypeMap.Add(type, idData);
+            _reverseComponentTypeMap.Add(idData, type);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ComponentID FetchID(Type type)
+        {
+            if (_componentTypeMap.TryGetValue(type, out var index) == false)
+            {
+                //if warming up is working correctly, this should never happen
+                  var componentType = typeof(ComponentTypeID<>).MakeGenericType(type);
+                 System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(componentType.TypeHandle);
+                 return _componentTypeMap[type];
+            }
+            
+            return index;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Type FetchType(ComponentID id)
+        {
+            return _reverseComponentTypeMap[id];
+        }
+    }
+}

Core/ComponentTypeID.cs.meta

@@ -7,7 +7,7 @@ namespace Svelto.ECS
 {
     public partial class EnginesRoot
     {
-        class GenericEntityFactory : IEntityFactory
+        class GenericEntityFactory : IEntityFactory, IEntitySerializationFactory
         {
             public GenericEntityFactory(EnginesRoot weakReference)
             {

Core/ComponentTypeMap.cs

@@ -14,40 +14,48 @@ namespace Svelto.ECS
     /// <typeparam name="TType"></typeparam>
     public struct DynamicEntityDescriptor<TType> : IDynamicEntityDescriptor where TType : IEntityDescriptor, new()
     {
-        internal DynamicEntityDescriptor(bool isExtendible) : this()
+        public static DynamicEntityDescriptor<TType> CreateDynamicEntityDescriptor()
         {
+            var entityDescriptor = new DynamicEntityDescriptor<TType>();
+            
             var defaultEntities = EntityDescriptorTemplate<TType>.realDescriptor.componentsToBuild;
             var length          = defaultEntities.Length;
 
             if (FetchEntityInfoComponent(defaultEntities) == -1)
             {
-                _componentsToBuild = new IComponentBuilder[length + 1];
+                entityDescriptor._componentsToBuild = new IComponentBuilder[length + 1];
 
-                Array.Copy(defaultEntities, 0, _componentsToBuild, 0, length);
+                Array.Copy(defaultEntities, 0, entityDescriptor._componentsToBuild, 0, length);
                 //assign it after otherwise the previous copy will overwrite the value in case the item
                 //is already present
-                _componentsToBuild[length] = new ComponentBuilder<EntityInfoComponent>(new EntityInfoComponent
+                entityDescriptor._componentsToBuild[length] = new ComponentBuilder<EntityInfoComponent>(new EntityInfoComponent
                 {
-                    componentsToBuild = _componentsToBuild
+                    componentsToBuild = entityDescriptor._componentsToBuild
                 });
             }
             else
             {
-                _componentsToBuild = new IComponentBuilder[length];
+                entityDescriptor._componentsToBuild = new IComponentBuilder[length];
 
-                Array.Copy(defaultEntities, 0, _componentsToBuild, 0, length);
+                Array.Copy(defaultEntities, 0, entityDescriptor._componentsToBuild, 0, length);
             }
+
+            return entityDescriptor;
         }
 
-        public DynamicEntityDescriptor(IComponentBuilder[] extraEntityBuilders) : this(true)
+        public DynamicEntityDescriptor(IComponentBuilder[] extraEntityBuilders)
         {
+            this = CreateDynamicEntityDescriptor();
+            
             var extraEntitiesLength = extraEntityBuilders.Length;
 
             _componentsToBuild = Construct(extraEntitiesLength, extraEntityBuilders);
         }
 
-        public DynamicEntityDescriptor(FasterList<IComponentBuilder> extraEntityBuilders) : this(true)
+        public DynamicEntityDescriptor(FasterList<IComponentBuilder> extraEntityBuilders) 
         {
+            this = CreateDynamicEntityDescriptor();
+            
             var extraEntities       = extraEntityBuilders.ToArrayFast(out _);
             var extraEntitiesLength = extraEntityBuilders.count;