com.elestrago.unity.entitas-redux 3.2.5 → 3.3.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ---
 
+## [3.3.0](https://gitlab.com/elestrago-pkg/entitas-redux/-/tags/3.3.0)
+
+### Added
+
+- `Register<TCommand>` method to `ICommandBuffer` for create pool
+
+### Changed
+
+- Create new command only allow for registered commands
+
+---
+
 ## [3.2.5](https://gitlab.com/elestrago-pkg/entitas-redux/-/tags/3.2.5)
 
 ### Fixed

package/Core/Commands/CommandBuffer.cs

@@ -1,56 +1,114 @@
 using System;
-using System.Collections.Generic;
+using System.Threading;
 
 namespace JCMG.EntitasRedux.Commands
 {
-	public abstract class CommandBuffer : ICommandBuffer, IDisposable
+	public abstract class CommandBuffer : ICommandBuffer
 	{
-		private static readonly List<Func<ICommandPool>> PoolFactories = new();
+		// Helper to get a unique, static index for each command type.
+		private static class CommandType
+		{
+			private static int _indexCounter;
 
-		private static int _commandsCounter;
-		private static event Action<Func<ICommandPool>> PoolFactoryRegister;
+			internal static class Index<TCommand> where TCommand : struct
+			{
+				// This value is calculated once per TCommand and cached.
+				public static readonly int Value = Interlocked.Increment(ref _indexCounter) - 1;
+			}
+		}
 
-		private readonly List<ICommandPool> _pools = new();
+		// Use a raw array for performance. It's not readonly because we resize it.
+		private ICommandPool[] _pools = new ICommandPool[4];
 
-		protected CommandBuffer()
+		/// <summary>
+		/// Registers a pool for the specified command type. This must be called
+		/// before creating or accessing commands of this type.
+		/// </summary>
+		public void Register<TCommand>() where TCommand : struct
 		{
-			lock (PoolFactories)
+			var index = CommandType.Index<TCommand>.Value;
+
+			// Ensure the array is large enough, resizing if necessary.
+			if (index >= _pools.Length)
 			{
-				foreach (var poolFactory in PoolFactories)
-					_pools.Add(poolFactory());
+				// Resize to the exact size needed to include the new index.
+				Array.Resize(ref _pools, index + 1);
 			}
 
-			PoolFactoryRegister += OnPoolFactoryRegister;
+			// Create the pool if it doesn't exist for this buffer instance.
+			ref var commandPool = ref _pools[index];
+			commandPool ??= new CommandPool<TCommand>();
 		}
 
-		public void Dispose()
+		public ref TCommand Create<TCommand>() where TCommand : struct
 		{
-			PoolFactoryRegister -= OnPoolFactoryRegister;
-		}
+			var pool = GetPool<TCommand>();
+			if (pool != null)
+				return ref pool.Create();
 
-		private void OnPoolFactoryRegister(Func<ICommandPool> poolFactory) => _pools.Add(poolFactory());
+#if DEBUG
+			throw new Exception($"[CommandBuffer] Command type '{typeof(TCommand).Name}' is not registered. " +
+			                    $"Call Register<{typeof(TCommand).Name}>() first. Command will be ignored.");
+#endif
 
-		public ref TCommand Create<TCommand>() where TCommand : struct
-		{
-			var pool = _pools[CommandPool<TCommand>.Index] as CommandPool<TCommand>;
-			return ref pool.Create();
+			// Return a reference to a dummy variable to satisfy the ref return.
+			return ref Dummy<TCommand>.Value;
 		}
 
 		public void Create<TCommand>(TCommand command) where TCommand : struct
 		{
-			var pool = _pools[CommandPool<TCommand>.Index] as CommandPool<TCommand>;
-			pool.Create(command);
+			var pool = GetPool<TCommand>();
+			if (pool != null)
+			{
+				pool.Create(command);
+				return;
+			}
+
+#if DEBUG
+			throw new Exception($"[CommandBuffer] Command type '{typeof(TCommand).Name}' is not registered. " +
+			                    $"Call Register<{typeof(TCommand).Name}>() first. Command will be ignored.");
+#endif
 		}
 
 		public Span<TCommand> GetCommands<TCommand>() where TCommand : struct
 		{
-			var pool = _pools[CommandPool<TCommand>.Index] as CommandPool<TCommand>;
-			return pool.Read();
+			var pool = GetPool<TCommand>();
+			return pool != null ? pool.Read() : Span<TCommand>.Empty;
+		}
+
+		private CommandPool<TCommand> GetPool<TCommand>() where TCommand : struct
+		{
+			var index = CommandType.Index<TCommand>.Value;
+
+			// Use .Length for array boundary check.
+			if (index >= _pools.Length)
+				return null;
+
+			return _pools[index] as CommandPool<TCommand>;
 		}
 
 		public void Clear<TCommand>() where TCommand : struct
-			=> _pools[CommandPool<TCommand>.Index].Clear();
+		{
+			var index = CommandType.Index<TCommand>.Value;
+
+			// Use .Length for array boundary check.
+			if (index < _pools.Length)
+				_pools[index]?.Clear();
+		}
 
+		public void ClearAll()
+		{
+			for (var i = 0; i < _pools.Length; i++)
+				_pools[i]?.Clear();
+		}
+
+		// A helper to provide a valid ref return when a pool doesn't exist.
+		private static class Dummy<T> where T : struct
+		{
+			public static T Value;
+		}
+
+		// The interface and pool implementation are now much simpler.
 		private interface ICommandPool
 		{
 			void Clear();
@@ -59,23 +117,9 @@ namespace JCMG.EntitasRedux.Commands
 		private class CommandPool<TCommand> : ICommandPool
 			where TCommand : struct
 		{
-			public static readonly int Index;
-
 			private TCommand[] _pool = new TCommand[4];
 			private int _position;
 
-			static CommandPool()
-			{
-				lock (PoolFactories)
-				{
-					Index = _commandsCounter++;
-					PoolFactories.Add(Factory);
-					PoolFactoryRegister?.Invoke(Factory);
-				}
-			}
-
-			private static CommandPool<TCommand> Factory() => new();
-
 			public ref TCommand Create()
 			{
 				var position = _position++;
@@ -98,8 +142,9 @@ namespace JCMG.EntitasRedux.Commands
 
 			public void Clear()
 			{
+				// Clear only the portion of the array that was used.
+				Array.Clear(_pool, 0, _position);
 				_position = 0;
-				Array.Clear(_pool, 0, _pool.Length);
 			}
 		}
 	}

package/Core/Commands/ICommandBuffer.cs

@@ -4,6 +4,12 @@ namespace JCMG.EntitasRedux.Commands
 {
 	public interface ICommandBuffer
 	{
+		/// <summary>
+		/// Registers a pool for the specified command type. This must be called
+		/// before creating or accessing commands of this type.
+		/// </summary>
+		void Register<TCommand>() where TCommand : struct;
+
 		ref TCommand Create<TCommand>() where TCommand : struct;
 
 		void Create<TCommand>(TCommand command) where TCommand : struct;
@@ -11,5 +17,7 @@ namespace JCMG.EntitasRedux.Commands
 		Span<TCommand> GetCommands<TCommand>() where TCommand : struct;
 
 		void Clear<TCommand>() where TCommand : struct;
+
+		void ClearAll();
 	}
 }

package/Core/Systems/Commands/CommandSystem.cs

@@ -6,12 +6,18 @@ namespace JCMG.EntitasRedux.Commands
 		where TCommand : struct
 	{
 		private readonly ICommandBuffer _commandBuffer;
+		private readonly bool _cleanUp;
 
-		protected virtual bool CleanUp => true;
-
-		protected CommandSystem(ICommandBuffer commandBuffer)
+		protected CommandSystem(ICommandBuffer commandBuffer, bool cleanUp = true)
 		{
 			_commandBuffer = commandBuffer;
+			_cleanUp = cleanUp;
+
+			// We only need to register the command type with the buffer if this system
+			// is responsible for cleaning it up. The buffer uses this registration to
+			// know which command types to manage for its internal collections.
+			if (_cleanUp)
+				_commandBuffer.Register<TCommand>();
 		}
 
 		protected void ExecuteCommands()
@@ -21,7 +27,7 @@ namespace JCMG.EntitasRedux.Commands
 				return;
 
 			Execute(commands);
-			if (CleanUp)
+			if (_cleanUp)
 				_commandBuffer.Clear<TCommand>();
 		}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.elestrago.unity.entitas-redux",
-  "version": "3.2.5",
+  "version": "3.3.0",
   "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",