🚀 2023.1.1

CHANGELOG.MD

@@ -4,6 +4,24 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2023.1.1] - 15.10.2024
+### Fixed
+- Fixed ``Stash.IsEmpty`` never being true.
+- Fixed ``Stash.RemoveAll`` breaking the stash.
+- Fixed ``World.Dispose`` throwing on multiple calls.
+- Fixed ``WorldBrowser`` inability to update world view list by @skelitheprogrammer.
+- Fixed ``MigrateTo`` broken enumerator.
+- Fixed ``World.CleanupUpdate`` small allocation.
+### Added
+- Added ``IBoxedAspectFactory`` to allow aspects to be created via DI by @vanifatovvlad.
+- Added ``MORPEH_DISABLE_COMPILATION_REPORT`` and ``MORPEH_DISABLE_COMPONENT_DISPOSE`` defines.
+- Added ``Length`` property to ``Stash``.
+- Added ``Enumerator`` for ``Stash``.
+### Changed
+- [Devirtualize stashes](https://github.com/scellecs/morpeh/pull/221).
+- Changed method signature for ``GetValueRefByKey`` in ``NativeIntHashMap<TNative>``, added ``ref`` keyword to the first parameter.
+- Changed methods signatures for ``Get`` in ``NativeStash<TNative>``, added ``ref`` keyword to the first parameter.
+
 ## [2023.1.0] - 09.10.2023
 ### Fixed
 - Fix `NativeFilter` allocations.

Core/Aspect.cs

@@ -1,11 +1,26 @@
 namespace Scellecs.Morpeh {
+    using System;
+
     public interface IAspect {
         Entity Entity { get; set; }
 
         void OnGetAspectFactory(World world);
     }
 
-    public struct AspectFactory<T> where T : struct, IAspect {
+    public interface IBoxedAspectFactory {
+        Type AspectType { get; }
+
+        IAspect ValueBoxed { get; set; }
+    }
+
+    public struct AspectFactory<T> : IBoxedAspectFactory where T : struct, IAspect {
         internal T value;
+
+        Type IBoxedAspectFactory.AspectType => typeof(T);
+
+        IAspect IBoxedAspectFactory.ValueBoxed {
+            get => this.value;
+            set => this.value = (T) value;
+        }
     }
-}
+}

Core/Collections/HashHelpers.cs

@@ -29,7 +29,7 @@ internal static class HashHelpers {
             67_108_863,
             134_217_727,
             268_435_455,
-            536_870_912,
+            536_870_911,
             1_073_741_823
         };
 
@@ -59,7 +59,7 @@ internal static class HashHelpers {
             67_108_863,
             134_217_727,
             268_435_455,
-            536_870_912,
+            536_870_911,
             1_073_741_823
         };
 

Core/Collections/IntHashMap.cs

@@ -43,6 +43,26 @@ public IntHashMap(in int capacity = 0) {
             this.slots   = new PinnedArray<IntHashMapSlot>(this.capacity);
             this.data    = new T[this.capacity];
         }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public IntHashMap(IntHashMap<T> other) {
+            this.lastIndex = other.lastIndex;
+            this.length    = other.length;
+            this.freeIndex = other.freeIndex;
+
+            this.capacityMinusOne = other.capacityMinusOne;
+            this.capacity         = other.capacity;
+
+            this.buckets = new IntPinnedArray(this.capacity);
+            this.slots   = new PinnedArray<IntHashMapSlot>(this.capacity);
+            this.data    = new T[this.capacity];
+
+            for (int i = 0, len = this.capacity; i < len; i++) {
+                this.buckets.data[i] = other.buckets.data[i];
+                this.slots.data[i] = other.slots.data[i];
+                this.data[i] = other.data[i];
+            }
+        }
 
         ~IntHashMap() {
             this.buckets.Dispose();

Core/Collections/IntHashMapExtensions.cs

@@ -304,6 +304,31 @@ public static void CopyTo<T>(this IntHashMap<T> hashMap, T[] array) {
                 ++num;
             }
         }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void CopyFrom<T>(this IntHashMap<T> hashMap, IntHashMap<T> from) {
+            hashMap.lastIndex = from.lastIndex;
+            hashMap.length    = from.length;
+            hashMap.freeIndex = from.freeIndex;
+
+            var needResize = hashMap.capacity < from.capacity;
+
+            hashMap.capacityMinusOne = from.capacityMinusOne;
+            hashMap.capacity         = from.capacity;
+
+            if (needResize) {
+                hashMap.buckets = new IntPinnedArray(hashMap.capacity);
+                hashMap.slots = new PinnedArray<IntHashMapSlot>(hashMap.capacity);
+                hashMap.data = new T[hashMap.capacity];
+            }
+
+            for (int i = 0, len = hashMap.capacity; i < len; i++) {
+                hashMap.buckets.data[i] = from.buckets.data[i];
+                hashMap.slots.data[i] = from.slots.data[i];
+                hashMap.data[i] = from.data[i];
+            }
+        }
+
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static void Clear<T>(this IntHashMap<T> hashMap) {

Core/Constants.cs

@@ -1,7 +1,7 @@
 namespace Scellecs.Morpeh {
     internal static class Constants {
         internal const int DEFAULT_WORLD_ENTITIES_CAPACITY    = 128;
-        internal const int DEFAULT_WORLD_CACHES_CAPACITY      = 16;
+        internal const int DEFAULT_WORLD_STASHES_CAPACITY      = 16;
         internal const int DEFAULT_STASH_COMPONENTS_CAPACITY  = 16;
     }
 }

Core/EntityExtensions.cs

@@ -134,7 +134,7 @@ public static bool Has<T>(this Entity entity) where T : struct, IComponent {
 #if MORPEH_LEGACY
         [Obsolete("[MORPEH] Use Stash.Migrate() instead.")]
 #endif
-        public static void MigrateTo(this Entity from, Entity to, bool overwrite = true) {
+        public static unsafe void MigrateTo(this Entity from, Entity to, bool overwrite = true) {
 #if MORPEH_DEBUG
             if (from.IsNullOrDisposed() || to.IsNullOrDisposed()) {
                 throw new Exception("[MORPEH] You are trying MigrateTo on null or disposed entities");
@@ -143,9 +143,15 @@ public static void MigrateTo(this Entity from, Entity to, bool overwrite = true)
 
             var world = from.world;
 
+            var components = stackalloc int[from.components.count];
+            var idx = 0;
             foreach (var offset in from.components) {
-                var id = CommonTypeIdentifier.offsetTypeAssociation[offset].id;
-                var stash = Stash.stashes.data[world.stashes.GetValueByKey(id)];
+                components[idx++] = offset;
+            }
+
+            for (int i = 0; i < idx; i++) {
+                var id = CommonTypeIdentifier.offsetTypeAssociation[components[i]].id;
+                var stash = world.stashes.GetValueByKey(id);
                 stash.Migrate(from, to, overwrite);
             }
         }
@@ -271,7 +277,7 @@ public static void Dispose(this Entity entity) {
             if (entity.currentArchetypeLength > 0) {
                 foreach (var offset in entity.components) {
                     var id = CommonTypeIdentifier.offsetTypeAssociation[offset].id;
-                    var stash = Stash.stashes.data[entity.world.stashes.GetValueByKey(id)];
+                    var stash = entity.world.stashes.GetValueByKey(id);
                     stash.Clean(entity);
                 }
             }

Core/Native/NativeIntHashMap.cs

@@ -31,6 +31,9 @@ public struct NativeIntHashMap<TNative> where TNative : unmanaged {
         [NativeDisableParallelForRestriction]
         [NativeDisableUnsafePtrRestriction]
         public unsafe TNative* data;
+
+        [NativeDisableUnsafePtrRestriction]
+        public TNative empty;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Enumerator GetEnumerator() {

Core/Native/NativeIntHashMapExtensions.cs

@@ -32,9 +32,8 @@ internal static NativeIntHashMap<TNative> AsNative<TNative>(this IntHashMap<TNat
             return nativeIntHashMap;
         }
 
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ref TNative GetValueRefByKey<TNative>(this NativeIntHashMap<TNative> nativeIntHashMap, in int key) where TNative : unmanaged {
+        public static ref TNative GetValueRefByKey<TNative>(this ref NativeIntHashMap<TNative> nativeIntHashMap, in int key) where TNative : unmanaged {
             var rem = key & *nativeIntHashMap.capacityMinusOnePtr;
 
             int next;
@@ -47,7 +46,7 @@ public static ref TNative GetValueRefByKey<TNative>(this NativeIntHashMap<TNativ
                 next = slot.next;
             }
 
-            return ref UnsafeUtility.ArrayElementAsRef<TNative>(nativeIntHashMap.data, 0);
+            return ref nativeIntHashMap.empty;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

Core/Native/NativeStashExtensions.cs

@@ -6,11 +6,34 @@ namespace Scellecs.Morpeh.Native {
     [Il2CppSetOption(Option.NullChecks, false)]
     [Il2CppSetOption(Option.ArrayBoundsChecks, false)]
     [Il2CppSetOption(Option.DivideByZeroChecks, false)]
-    public static class NativeStashExtensions {
+    public static unsafe class NativeStashExtensions {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static NativeIntHashMap<TNative> AsNativeIntHashMap<TNative>(this Stash<TNative> hashMap) where TNative : unmanaged, IComponent {
+            var nativeIntHashMap = new NativeIntHashMap<TNative>();
+
+            fixed (int* lengthPtr = &hashMap.map.length)
+            fixed (int* capacityPtr = &hashMap.map.capacity)
+            fixed (int* capacityMinusOnePtr = &hashMap.map.capacityMinusOne)
+            fixed (int* lastIndexPtr = &hashMap.map.lastIndex)
+            fixed (int* freeIndexPtr = &hashMap.map.freeIndex)
+            fixed (TNative* dataPtr = &hashMap.data[0]) {
+                nativeIntHashMap.lengthPtr           = lengthPtr;
+                nativeIntHashMap.capacityPtr         = capacityPtr;
+                nativeIntHashMap.capacityMinusOnePtr = capacityMinusOnePtr;
+                nativeIntHashMap.lastIndexPtr        = lastIndexPtr;
+                nativeIntHashMap.freeIndexPtr        = freeIndexPtr;
+                nativeIntHashMap.data                = dataPtr;
+                nativeIntHashMap.buckets             = hashMap.map.buckets.ptr;
+                nativeIntHashMap.slots               = hashMap.map.slots.ptr;
+            }
+
+            return nativeIntHashMap;
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static NativeStash<TNative> AsNative<TNative>(this Stash<TNative> stash) where TNative : unmanaged, IComponent {
             var nativeCache = new NativeStash<TNative> {
-                components = stash.components.AsNative(),
+                components = stash.AsNativeIntHashMap(),
                 world = stash.world.AsNative(),
             };
             return nativeCache;
@@ -22,12 +45,12 @@ public static bool Has<TNative>(this NativeStash<TNative> nativeStash, in Entity
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ref TNative Get<TNative>(this NativeStash<TNative> nativeStash, in EntityId entityId) where TNative : unmanaged, IComponent {
+        public static ref TNative Get<TNative>(this ref NativeStash<TNative> nativeStash, in EntityId entityId) where TNative : unmanaged, IComponent {
             return ref nativeStash.components.GetValueRefByKey(in entityId.id);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ref TNative Get<TNative>(this NativeStash<TNative> nativeStash, in EntityId entityId, out bool exists) where TNative : unmanaged, IComponent {
+        public static ref TNative Get<TNative>(this ref NativeStash<TNative> nativeStash, in EntityId entityId, out bool exists) where TNative : unmanaged, IComponent {
             exists = nativeStash.world.Has(in entityId) && nativeStash.Has(in entityId);
             return ref nativeStash.components.GetValueRefByKey(in entityId.id);
         }