com.elestrago.unity.entitas-redux 3.4.2 → 3.5.1

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ---
 
+## [3.5.1](https://gitlab.com/elestrago-pkg/entitas-redux/-/tags/3.5.1)
+
+### Changed
+
+- Use `Memory<T>` instead `List<T>` in `Systems` for frequently update systems
+
+---
+
+## [3.5.0](https://gitlab.com/elestrago-pkg/entitas-redux/-/tags/3.5.0)
+
+### Changed
+
+- Use `SingleMatcher` for context component matchers
+
+---
+
 ## [3.4.2](https://gitlab.com/elestrago-pkg/entitas-redux/-/tags/3.4.2)
 
 ### Added

package/Core/Libs/ListReflectionExtensions.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace EntitasRedux.Core.Libs
+{
+	public static class ListReflectionExtensions
+	{
+		// We can cache the FieldInfo objects for a slight performance improvement
+		// This avoids looking them up every time the method is called.
+		private static class ListInternals<T>
+		{
+			public static readonly FieldInfo ItemsField =
+				typeof(List<T>).GetField("_items", BindingFlags.NonPublic | BindingFlags.Instance);
+		}
+
+		/// <summary>
+		/// Gets a Span<T> over the internal storage of a List<T> using reflection.
+		/// WARNING: This is highly fragile and depends on the internal implementation of List<T>.
+		/// It may break in future .NET versions. Use with extreme caution.
+		/// </summary>
+		public static Memory<T> AsMemoryReflection<T>(this List<T> list)
+		{
+			if (list == null)
+				return Memory<T>.Empty;
+
+			// Get the internal array and size using the cached reflection info
+			var items = (T[])ListInternals<T>.ItemsField.GetValue(list);
+
+			// Create a span from the internal array, respecting the list's current size
+			return new Memory<T>(items, 0, list.Count);
+		}
+	}
+}

package/Core/Libs/ListReflectionExtensions.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d86ee5f912fa4e468ee172da6bfd7615
+timeCreated: 1754457641

package/Core/Matcher/Interfaces/IMatcher.cs

@@ -28,7 +28,13 @@ namespace JCMG.EntitasRedux
 	public interface IMatcher<TEntity>
 		where TEntity : class, IEntity
 	{
+		/// <summary>
+		/// Initialized in context matcher implementation
+		/// </summary>
+		public static string[] ComponentNames;
+
 		int[] Indices { get; }
+
 		bool Matches(TEntity entity);
 	}
-}
+}

package/Core/Matcher/Matcher.cs

@@ -28,26 +28,13 @@ namespace JCMG.EntitasRedux
 	public partial class Matcher<TEntity> : IAllOfMatcher<TEntity>
 		where TEntity : class, IEntity
 	{
-		public string[] ComponentNames { get; set; }
-
 		private int[] _allOfIndices;
 		private int[] _anyOfIndices;
 
 		private int[] _indices;
 		private int[] _noneOfIndices;
 
-		public int[] Indices
-		{
-			get
-			{
-				if (_indices == null)
-				{
-					_indices = MergeIndices(_allOfIndices, _anyOfIndices, _noneOfIndices);
-				}
-
-				return _indices;
-			}
-		}
+		public int[] Indices => _indices ??= MergeIndices(_allOfIndices, _anyOfIndices, _noneOfIndices);
 
 		public int[] AllOfIndices => _allOfIndices;
 
@@ -84,8 +71,8 @@ namespace JCMG.EntitasRedux
 		public bool Matches(TEntity entity)
 		{
 			return (_allOfIndices == null || entity.HasComponents(_allOfIndices)) &&
-				   (_anyOfIndices == null || entity.HasAnyComponent(_anyOfIndices)) &&
-				   (_noneOfIndices == null || !entity.HasAnyComponent(_noneOfIndices));
+			       (_anyOfIndices == null || entity.HasAnyComponent(_anyOfIndices)) &&
+			       (_noneOfIndices == null || !entity.HasAnyComponent(_noneOfIndices));
 		}
 	}
-}
+}

package/Core/Matcher/MatcherStatic.cs

@@ -33,46 +33,32 @@ namespace JCMG.EntitasRedux
 		/// <summary>
 		/// Lazy-loaded index buffer (ThreadStatic)
 		/// </summary>
-		private static List<int> IndexBuffer => _indexBufferThreadStatic = _indexBufferThreadStatic ?? new List<int>();
+		private static List<int> IndexBuffer => _indexBufferThreadStatic ??= new List<int>();
 
 		/// <summary>
 		/// Lazy-loaded index set buffer (ThreadStatic)
 		/// </summary>
-		private static HashSet<int> IndexSetBuffer => _indexSetBufferThreadStatic = _indexSetBufferThreadStatic ?? new HashSet<int>();
+		private static HashSet<int> IndexSetBuffer => _indexSetBufferThreadStatic ??= new HashSet<int>();
 
-		[ThreadStatic]
-		private static List<int> _indexBufferThreadStatic = new();
+		[ThreadStatic] private static List<int> _indexBufferThreadStatic = new();
 
-		[ThreadStatic]
-		private static HashSet<int> _indexSetBufferThreadStatic = new();
+		[ThreadStatic] private static HashSet<int> _indexSetBufferThreadStatic = new();
 
-		public static IAllOfMatcher<TEntity> AllOf(params int[] indices)
+		public static IAllOfMatcher<TEntity> AllOf(params int[] indices) => new Matcher<TEntity>
 		{
-			var matcher = new Matcher<TEntity>();
-			matcher._allOfIndices = DistinctIndices(indices);
-			return matcher;
-		}
+			_allOfIndices = DistinctIndices(indices)
+		};
 
 		public static IAllOfMatcher<TEntity> AllOf(params IMatcher<TEntity>[] matchers)
-		{
-			var allOfMatcher = (Matcher<TEntity>)AllOf(MergeIndices(matchers));
-			SetComponentNames(ref allOfMatcher, matchers);
-			return allOfMatcher;
-		}
+			=> AllOf(MergeIndices(matchers));
 
-		public static IAnyOfMatcher<TEntity> AnyOf(params int[] indices)
+		public static IAnyOfMatcher<TEntity> AnyOf(params int[] indices) => new Matcher<TEntity>
 		{
-			var matcher = new Matcher<TEntity>();
-			matcher._anyOfIndices = DistinctIndices(indices);
-			return matcher;
-		}
+			_anyOfIndices = DistinctIndices(indices)
+		};
 
 		public static IAnyOfMatcher<TEntity> AnyOf(params IMatcher<TEntity>[] matchers)
-		{
-			var anyOfMatcher = (Matcher<TEntity>)AnyOf(MergeIndices(matchers));
-			SetComponentNames(ref anyOfMatcher, matchers);
-			return anyOfMatcher;
-		}
+			=> AnyOf(MergeIndices(matchers));
 
 		private static int[] MergeIndices(int[] allOfIndices, int[] anyOfIndices, int[] noneOfIndices)
 		{
@@ -115,28 +101,6 @@ namespace JCMG.EntitasRedux
 			return indices;
 		}
 
-		private static string[] GetComponentNames(IMatcher<TEntity>[] matchers)
-		{
-			for (var i = 0; i < matchers.Length; i++)
-			{
-				if (matchers[i] is Matcher<TEntity> matcher && matcher.ComponentNames != null)
-				{
-					return matcher.ComponentNames;
-				}
-			}
-
-			return null;
-		}
-
-		private static void SetComponentNames(ref Matcher<TEntity> matcher, IMatcher<TEntity>[] matchers)
-		{
-			var componentNames = GetComponentNames(matchers);
-			if (componentNames != null)
-			{
-				matcher.ComponentNames = componentNames;
-			}
-		}
-
 		private static int[] DistinctIndices(IList<int> indices)
 		{
 			foreach (var index in indices)
@@ -153,4 +117,4 @@ namespace JCMG.EntitasRedux
 			return uniqueIndices;
 		}
 	}
-}
+}

package/Core/Matcher/MatcherToString.cs

@@ -29,55 +29,36 @@ namespace JCMG.EntitasRedux
 {
 	public partial class Matcher<TEntity>
 	{
-		private StringBuilder _toStringBuilder;
+		private static StringBuilder _toStringBuilder;
 
 		private string _toStringCache;
 
 		public override string ToString()
 		{
-			if (_toStringCache == null)
-			{
-				if (_toStringBuilder == null)
-				{
-					_toStringBuilder = new StringBuilder();
-				}
+			if (_toStringCache != null)
+				return _toStringCache;
 
-				_toStringBuilder.Length = 0;
-				if (_allOfIndices != null)
-				{
-					AppendIndices(
-						_toStringBuilder,
-						"AllOf",
-						_allOfIndices,
-						ComponentNames);
-				}
+			_toStringBuilder ??= new StringBuilder();
+			_toStringBuilder.Length = 0;
 
-				if (_anyOfIndices != null)
-				{
-					if (_allOfIndices != null)
-					{
-						_toStringBuilder.Append(".");
-					}
-
-					AppendIndices(
-						_toStringBuilder,
-						"AnyOf",
-						_anyOfIndices,
-						ComponentNames);
-				}
+			var componentNames = IMatcher<TEntity>.ComponentNames;
 
-				if (_noneOfIndices != null)
-				{
-					AppendIndices(
-						_toStringBuilder,
-						".NoneOf",
-						_noneOfIndices,
-						ComponentNames);
-				}
+			if (_allOfIndices != null)
+				AppendIndices(_toStringBuilder, "AllOf", _allOfIndices, componentNames);
 
-				_toStringCache = _toStringBuilder.ToString();
+			if (_anyOfIndices != null)
+			{
+				if (_allOfIndices != null)
+					_toStringBuilder.Append(".");
+
+				AppendIndices(_toStringBuilder, "AnyOf", _anyOfIndices, componentNames);
 			}
 
+			if (_noneOfIndices != null)
+				AppendIndices(_toStringBuilder, ".NoneOf", _noneOfIndices, componentNames);
+
+			_toStringCache = _toStringBuilder.ToString();
+
 			return _toStringCache;
 		}
 
@@ -108,4 +89,4 @@ namespace JCMG.EntitasRedux
 			sb.Append(")");
 		}
 	}
-}
+}

package/Core/Matcher/SingleMatcher.cs

@@ -0,0 +1,27 @@
+namespace JCMG.EntitasRedux
+{
+	public class SingleMatcher<TEntity> : IMatcher<TEntity>
+		where TEntity : class, IEntity
+	{
+		private readonly int _index;
+
+		private string _toStringCache;
+
+		public SingleMatcher(int index)
+		{
+			_index = index;
+			Indices = new[] { index };
+		}
+
+		public int[] Indices { get; }
+
+		public bool Matches(TEntity entity) => entity.HasComponent(_index);
+
+		public override string ToString()
+		{
+			return string.IsNullOrEmpty(_toStringCache)
+				? _toStringCache = $"AllOf({IMatcher<TEntity>.ComponentNames[_index]})"
+				: _toStringCache;
+		}
+	}
+}

package/Core/Matcher/SingleMatcher.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0de81d27fdf948639fc5064d90d0bd2a
+timeCreated: 1754409881

package/Core/Systems/Systems.cs

@@ -23,7 +23,9 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 */
 
+using System;
 using System.Collections.Generic;
+using EntitasRedux.Core.Libs;
 
 namespace JCMG.EntitasRedux
 {
@@ -51,6 +53,11 @@ namespace JCMG.EntitasRedux
 		protected readonly List<ICleanupSystem> _cleanupSystems;
 		protected readonly List<ITearDownSystem> _tearDownSystems;
 
+		private Memory<IFixedUpdateSystem> _fixedUpdateSystemsMemory;
+		private Memory<IUpdateSystem> _updateSystemsMemory;
+		private Memory<ILateUpdateSystem> _lateUpdateSystemsMemory;
+		private Memory<ICleanupSystem> _cleanupSystemsMemory;
+
 		/// <summary>
 		/// Creates a new Systems instance.
 		/// </summary>
@@ -157,9 +164,9 @@ namespace JCMG.EntitasRedux
 		/// </summary>
 		public virtual void Update()
 		{
-			for (var i = 0; i < _updateSystems.Count; i++)
+			foreach (var system in _updateSystemsMemory.Span)
 			{
-				_updateSystems[i].Update();
+				system.Update();
 			}
 		}
 
@@ -169,9 +176,9 @@ namespace JCMG.EntitasRedux
 		/// </summary>
 		public virtual void FixedUpdate()
 		{
-			for (var i = 0; i < _fixedUpdateSystems.Count; i++)
+			foreach (var system in _fixedUpdateSystemsMemory.Span)
 			{
-				_fixedUpdateSystems[i].FixedUpdate();
+				system.FixedUpdate();
 			}
 		}
 
@@ -181,9 +188,9 @@ namespace JCMG.EntitasRedux
 		/// </summary>
 		public virtual void LateUpdate()
 		{
-			for (var i = 0; i < _lateUpdateSystems.Count; i++)
+			foreach (var system in _lateUpdateSystemsMemory.Span)
 			{
-				_lateUpdateSystems[i].LateUpdate();
+				system.LateUpdate();
 			}
 		}
 
@@ -193,6 +200,8 @@ namespace JCMG.EntitasRedux
 		/// </summary>
 		public virtual void Initialize()
 		{
+			PrepareUpdateSystems();
+
 			for (var i = 0; i < _initializeSystems.Count; i++)
 			{
 				_initializeSystems[i].Initialize();
@@ -205,9 +214,9 @@ namespace JCMG.EntitasRedux
 		/// </summary>
 		public virtual void Cleanup()
 		{
-			for (var i = 0; i < _cleanupSystems.Count; i++)
+			foreach (var system in _cleanupSystemsMemory.Span)
 			{
-				_cleanupSystems[i].Cleanup();
+				system.Cleanup();
 			}
 		}
 
@@ -222,5 +231,13 @@ namespace JCMG.EntitasRedux
 				_tearDownSystems[i].TearDown();
 			}
 		}
+
+		private void PrepareUpdateSystems()
+		{
+			_fixedUpdateSystemsMemory = _fixedUpdateSystems.AsMemoryReflection();
+			_updateSystemsMemory = _updateSystems.AsMemoryReflection();
+			_lateUpdateSystemsMemory = _lateUpdateSystems.AsMemoryReflection();
+			_cleanupSystemsMemory = _cleanupSystems.AsMemoryReflection();
+		}
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.elestrago.unity.entitas-redux",
-  "version": "3.4.2",
+  "version": "3.5.1",
   "displayName": "JCMG Entitas Redux",
   "description": "Entitas Redux is an fast, accessible, and feature-rich ECS framework for Unity. It leverages code generation and an extensible plugin framework to make life easier for developers.",
   "category": "Unity",