From cab282ac4300c6decbee61476f0c1446f0791632 Mon Sep 17 00:00:00 2001 From: Mikhail <99481254+DCFApixels@users.noreply.github.com> Date: Tue, 7 Feb 2023 17:11:56 +0800 Subject: [PATCH] Update WIP --- src/Builtin.meta | 8 ++ src/Builtin/DestroyProcessor.cs | 15 +++ .../DestroyProcessor.cs.meta} | 2 +- src/EcsEntityTableManager.cs | 10 +- src/EcsFilter.cs | 122 ++++++++++++++++++ ...EcsFieldPool.cs.meta => EcsFilter.cs.meta} | 2 +- src/EcsSession.cs | 38 +++--- src/EcsTable.cs | 16 +++ .../IEcsTable.cs.meta => EcsTable.cs.meta} | 0 src/EcsTableCore.cs | 68 ---------- src/EcsWorld.cs | 33 +++-- src/Exceptions.meta | 8 ++ src/Exceptions/EcsFrameworkException.cs | 16 +++ .../EcsFrameworkException.cs.meta} | 2 +- .../{IEcsSystem.cs => IEcsProcessor.cs} | 23 ++-- ...csSystem.cs.meta => IEcsProcessor.cs.meta} | 0 src/Pools.meta | 8 ++ src/{EcsFieldPool.cs => Pools/EcsPool.cs} | 33 +++-- .../EcsPool.cs.meta} | 2 +- src/Pools/EcsTagsPool.cs | 52 ++++++++ src/Pools/EcsTagsPool.cs.meta | 11 ++ src/Pools/IEcsPool.cs | 18 +++ src/Pools/IEcsPool.cs.meta | 11 ++ ...Messenger.cs => EcsProcessorsMessenger.cs} | 16 +-- src/React/EcsProcessorsMessenger.cs.meta | 11 ++ ...ystemsRunner.cs => EcsProcessorsRunner.cs} | 16 +-- src/React/EcsProcessorsRunner.cs.meta | 11 ++ src/TableMembers/EcsField.cs | 54 ++++++-- src/TableMembers/EcsTag.cs | 50 +++++-- src/TableMembers/IEcsTableMember.cs | 4 +- .../IEcsTable.cs => TableMembers/TagType.cs} | 3 +- src/TableMembers/TagType.cs.meta | 11 ++ src/Utils/ComponentTypeID.cs | 12 -- src/Utils/EcsType.cs | 77 +++++++++++ ...omponentTypeID.cs.meta => EcsType.cs.meta} | 0 src/Utils/entityArraysPool.cs | 13 ++ src/Utils/entityArraysPool.cs.meta | 11 ++ src/ent.cs | 5 +- 38 files changed, 608 insertions(+), 184 deletions(-) create mode 100644 src/Builtin.meta create mode 100644 src/Builtin/DestroyProcessor.cs rename src/{React/EcsSystemsMessenger.cs.meta => Builtin/DestroyProcessor.cs.meta} (83%) create mode 100644 src/EcsFilter.cs rename src/{EcsFieldPool.cs.meta => EcsFilter.cs.meta} (83%) create mode 100644 src/EcsTable.cs rename src/{Interfaces/IEcsTable.cs.meta => EcsTable.cs.meta} (100%) delete mode 100644 src/EcsTableCore.cs create mode 100644 src/Exceptions.meta create mode 100644 src/Exceptions/EcsFrameworkException.cs rename src/{React/EcsSystemsRunner.cs.meta => Exceptions/EcsFrameworkException.cs.meta} (83%) rename src/Interfaces/{IEcsSystem.cs => IEcsProcessor.cs} (53%) rename src/Interfaces/{IEcsSystem.cs.meta => IEcsProcessor.cs.meta} (100%) create mode 100644 src/Pools.meta rename src/{EcsFieldPool.cs => Pools/EcsPool.cs} (60%) rename src/{EcsTableCore.cs.meta => Pools/EcsPool.cs.meta} (83%) create mode 100644 src/Pools/EcsTagsPool.cs create mode 100644 src/Pools/EcsTagsPool.cs.meta create mode 100644 src/Pools/IEcsPool.cs create mode 100644 src/Pools/IEcsPool.cs.meta rename src/React/{EcsSystemsMessenger.cs => EcsProcessorsMessenger.cs} (66%) create mode 100644 src/React/EcsProcessorsMessenger.cs.meta rename src/React/{EcsSystemsRunner.cs => EcsProcessorsRunner.cs} (62%) create mode 100644 src/React/EcsProcessorsRunner.cs.meta rename src/{Interfaces/IEcsTable.cs => TableMembers/TagType.cs} (81%) create mode 100644 src/TableMembers/TagType.cs.meta delete mode 100644 src/Utils/ComponentTypeID.cs create mode 100644 src/Utils/EcsType.cs rename src/Utils/{ComponentTypeID.cs.meta => EcsType.cs.meta} (100%) create mode 100644 src/Utils/entityArraysPool.cs create mode 100644 src/Utils/entityArraysPool.cs.meta diff --git a/src/Builtin.meta b/src/Builtin.meta new file mode 100644 index 0000000..7142548 --- /dev/null +++ b/src/Builtin.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: f9f604669d2092e4a92d397e9c7db287 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/src/Builtin/DestroyProcessor.cs b/src/Builtin/DestroyProcessor.cs new file mode 100644 index 0000000..d4a1080 --- /dev/null +++ b/src/Builtin/DestroyProcessor.cs @@ -0,0 +1,15 @@ +namespace DCFApixels.DragonECS +{ + public class DestroyProcessor : IEcsDo<_Run> + { + void IEcsDo<_Run>.Do(EcsSession session) + { + + } + } + + public class DestroyedTable : EcsTable + { + private EcsIncTag _destroyedTag; + } +} diff --git a/src/React/EcsSystemsMessenger.cs.meta b/src/Builtin/DestroyProcessor.cs.meta similarity index 83% rename from src/React/EcsSystemsMessenger.cs.meta rename to src/Builtin/DestroyProcessor.cs.meta index 0d8200d..09a8090 100644 --- a/src/React/EcsSystemsMessenger.cs.meta +++ b/src/Builtin/DestroyProcessor.cs.meta @@ -1,5 +1,5 @@ fileFormatVersion: 2 -guid: dc514cbb93c3f3049adf666ad237c6ee +guid: c48ecb209046a944e9602d18f3fd5237 MonoImporter: externalObjects: {} serializedVersion: 2 diff --git a/src/EcsEntityTableManager.cs b/src/EcsEntityTableManager.cs index f223177..19ed577 100644 --- a/src/EcsEntityTableManager.cs +++ b/src/EcsEntityTableManager.cs @@ -9,29 +9,29 @@ namespace DCFApixels.DragonECS public class EcsEntityTableManager { private int _count; - private IEcsFieldPool[] _fieldPools; + private IEcsPool[] _fieldPools; private int _idIncrement; private Dictionary _ids; public EcsEntityTableManager(int capacity) { - _fieldPools = new IEcsFieldPool[capacity]; + _fieldPools = new IEcsPool[capacity]; _ids = new Dictionary(capacity); _count = 0; } - public EcsFieldPool GetFieldPool(int id) + public EcsPool GetFieldPool(int id) { if(id < _count) - return (EcsFieldPool)_fieldPools[id]; + return (EcsPool)_fieldPools[id]; _count++; if(_fieldPools.Length < _count) { Array.Resize(ref _fieldPools, _fieldPools.Length << 1); } - EcsFieldPool newPool = new EcsFieldPool(7); + EcsPool newPool = null;// new EcsFieldPool(7); _fieldPools[id] = newPool; return newPool; } diff --git a/src/EcsFilter.cs b/src/EcsFilter.cs new file mode 100644 index 0000000..90deec7 --- /dev/null +++ b/src/EcsFilter.cs @@ -0,0 +1,122 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.CompilerServices; +using System.Text; +using System.Threading.Tasks; + +namespace DCFApixels.DragonECS +{ + public interface IEcsFilter + { + public EcsWorld World { get; } + public int EntitiesCount { get; } + } + public class EcsFilter : IEcsFilter + { + private readonly EcsWorld _source; + private readonly EcsWorld.Mask _mask; + private readonly SparseSet _entities; + + private DelayedOp[] _delayedOps; + + private int _lockCount; + + #region Properties + public EcsWorld World => _source; + public int EntitiesCount => _entities.Count; + #endregion + + #region Constrcutors + internal EcsFilter(EcsWorld source, EcsWorld.Mask mask, int capasity) + { + _source = source; + _mask = mask; + _entities = new SparseSet(capasity); + _delayedOps = new DelayedOp[512]; + _lockCount = 0; + } + #endregion + + + internal void Change(int entityID, bool isAdd) + { + if (isAdd) + Add(entityID); + else + Del(entityID); + } + internal void Add(int entityID) + { + if (_lockCount > 0) + AddDelayedOp(entityID, false); + _entities.Add(entityID); + } + + internal void Del(int entityID) + { + if (_lockCount > 0) + AddDelayedOp(entityID, false); + _entities.Remove(entityID); + } + + private void AddDelayedOp(int entityID, bool isAdd) + { + } + + #region GetEnumerator + private void Unlock() + { +#if DEBUG + if (_lockCount <= 0) { throw new Exception($"Invalid lock-unlock balance for {nameof(EcsFilter)}."); } +#endif + _lockCount--; + } + public Enumerator GetEnumerator() + { + _lockCount++; + return new Enumerator(this); + } + #endregion + + #region Utils + public ref struct Enumerator + { + readonly EcsFilter _source; + readonly SparseSet _entities; + int _index; + + public Enumerator(EcsFilter filter) + { + _source = filter; + _entities = filter._entities; + _index = -1; + } + + public int Current + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get => _entities[_index]; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool MoveNext() + { + return ++_index < _entities.Count; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void Dispose() + { + _source.Unlock(); + } + } + + struct DelayedOp + { + public bool Added; + public int Entity; + } + #endregion + } +} diff --git a/src/EcsFieldPool.cs.meta b/src/EcsFilter.cs.meta similarity index 83% rename from src/EcsFieldPool.cs.meta rename to src/EcsFilter.cs.meta index 5bdc538..0190e63 100644 --- a/src/EcsFieldPool.cs.meta +++ b/src/EcsFilter.cs.meta @@ -1,5 +1,5 @@ fileFormatVersion: 2 -guid: 2b523e51b8d5f4c4c969e0ffec1b8b6f +guid: c8a9a76233fda6e478be27aed0079971 MonoImporter: externalObjects: {} serializedVersion: 2 diff --git a/src/EcsSession.cs b/src/EcsSession.cs index 84cd3e7..d6f97e6 100644 --- a/src/EcsSession.cs +++ b/src/EcsSession.cs @@ -10,8 +10,8 @@ namespace DCFApixels.DragonECS public class EcsSession { - private List _allSystems; - private ReadOnlyCollection _ecsSystemsSealed; + private List _allProcessors; + private ReadOnlyCollection _allProcessorsSealed; private bool _isInit = false; private bool _isDestoryed = false; @@ -20,49 +20,49 @@ namespace DCFApixels.DragonECS private Dictionary _worldsDict = new Dictionary(); private List _worlds = new List(); - private Dictionary _runners; - private Dictionary _messengers; - private EcsSystemsRunner<_Run> _runRunnerCache; + private Dictionary _runners; + private Dictionary _messengers; + private EcsProcessorsRunner<_Run> _runRunnerCache; #region Properties - public ReadOnlyCollection AllSystems => _ecsSystemsSealed; + public ReadOnlyCollection AllProcessors => _allProcessorsSealed; #endregion #region React Runners/Messengers - public EcsSystemsRunner GetRunner() + public EcsProcessorsRunner GetRunner() where TDoTag : IEcsDoTag { Type type = typeof(TDoTag); - if (_runners.TryGetValue(type, out IEcsSystemsRunner result)) + if (_runners.TryGetValue(type, out IEcsProcessorsRunner result)) { - return (EcsSystemsRunner)result; + return (EcsProcessorsRunner)result; } - result = new EcsSystemsRunner(this); + result = new EcsProcessorsRunner(this); _runners.Add(type, result); - return (EcsSystemsRunner)result; + return (EcsProcessorsRunner)result; } - public EcsSystemsMessenger GetMessenger() + public EcsProcessorsMessenger GetMessenger() where TMessege : IEcsMessage { Type type = typeof(TMessege); - if (_messengers.TryGetValue(type, out IEcsSystemsMessenger result)) + if (_messengers.TryGetValue(type, out IEcsProcessorsMessenger result)) { - return (EcsSystemsMessenger)result; + return (EcsProcessorsMessenger)result; } - result = new EcsSystemsMessenger(this); + result = new EcsProcessorsMessenger(this); _messengers.Add(type, result); - return (EcsSystemsMessenger)result; + return (EcsProcessorsMessenger)result; } #endregion #region Configuration - public EcsSession Add(IEcsSystem system) + public EcsSession Add(IEcsProcessor system) { CheckInitForMethod(nameof(AddWorld)); - _allSystems.Add(system); + _allProcessors.Add(system); return this; } public EcsSession AddWorld(string name) @@ -79,7 +79,7 @@ namespace DCFApixels.DragonECS public void Init() { CheckInitForMethod(nameof(Init)); - _ecsSystemsSealed = _allSystems.AsReadOnly(); + _allProcessorsSealed = _allProcessors.AsReadOnly(); _isInit = true; GetRunner<_PreInit>().Run(); diff --git a/src/EcsTable.cs b/src/EcsTable.cs new file mode 100644 index 0000000..f1fd971 --- /dev/null +++ b/src/EcsTable.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace DCFApixels.DragonECS +{ + public abstract class EcsTable + { + internal EcsFilter _filter; + public EcsFilter Filter + { + get => _filter; + } + } +} + diff --git a/src/Interfaces/IEcsTable.cs.meta b/src/EcsTable.cs.meta similarity index 100% rename from src/Interfaces/IEcsTable.cs.meta rename to src/EcsTable.cs.meta diff --git a/src/EcsTableCore.cs b/src/EcsTableCore.cs deleted file mode 100644 index 6373008..0000000 --- a/src/EcsTableCore.cs +++ /dev/null @@ -1,68 +0,0 @@ -using System; -using System.Collections.Generic; -using System.ComponentModel; -using System.Linq; -using System.Runtime.CompilerServices; - -namespace DCFApixels.DragonECS -{ - public abstract class EcsTableCore - { - internal EcsWorld _source; - internal ent entity; - - private bool _enabled = false; - - [EditorBrowsable(EditorBrowsableState.Never)] - public ent Entity - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get => entity; - } - - internal void Enable() - { - _enabled = true; - } - - internal void Disable() - { - _enabled = false; - entity = ent.NULL; - } - - internal void MoveToNextEntity() - { - - } - - - public Enumerator GetEnumerator() - { - return new Enumerator(this); - } - - - public ref struct Enumerator - { - private readonly EcsTableCore _source; - - public Enumerator(EcsTableCore source) - { - _source = source; - } - - public EcsTableCore Current => _source; - - public bool MoveNext() - { - throw new NotImplementedException(); - } - - public void Reset() - { - throw new NotImplementedException(); - } - } - } -} diff --git a/src/EcsWorld.cs b/src/EcsWorld.cs index 4597811..c0dc38c 100644 --- a/src/EcsWorld.cs +++ b/src/EcsWorld.cs @@ -13,10 +13,12 @@ namespace DCFApixels.DragonECS private byte _id = DEAD_WORLD_ID; - private Dictionary _pools; + private Dictionary _pools; private SparseSet _entities = new SparseSet(); private short[] _gens; - private byte[] _components; + + private List[] _filtersByIncludedComponents; + private List[] _filtersByExcludedComponents; //private Dictionary _tables; @@ -28,7 +30,7 @@ namespace DCFApixels.DragonECS #region Constructors public EcsWorld() { - _pools = new Dictionary(); + _pools = new Dictionary(); _entities = new SparseSet(); } #endregion @@ -41,17 +43,17 @@ namespace DCFApixels.DragonECS #endregion #region GetPool - public EcsFieldPool GetPool() + public EcsPool GetPool() { Type type = typeof(T); - if (_pools.TryGetValue(type, out IEcsFieldPool pool)) + if (_pools.TryGetValue(type, out IEcsPool pool)) { - return (EcsFieldPool)pool; + return (EcsPool)pool; } //pool = new EcsPool(); _pools.Add(type, pool); - return (EcsFieldPool)pool; + return (EcsPool)pool; } #endregion @@ -60,11 +62,10 @@ namespace DCFApixels.DragonECS { int entityID = _entities.GetFree(); _entities.Normalize(ref _gens); - _entities.Normalize(ref _components); _gens[entityID]++; - return new ent(entityID, _gens[entityID], _id, _components[entityID]); + return new ent(entityID, _gens[entityID], _id); } #endregion @@ -75,7 +76,19 @@ namespace DCFApixels.DragonECS } #endregion - private void Resize() + internal void OnEntityFieldAdd(int entityID, EcsType chaangedField) + { + + } + + + internal void OnEntityFieldDel(int entityID, EcsType chaangedField) + { + + } + + + public class Mask { } diff --git a/src/Exceptions.meta b/src/Exceptions.meta new file mode 100644 index 0000000..874f7ce --- /dev/null +++ b/src/Exceptions.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 4b5f469ccf287fd4294a51cc0bec2ba1 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/src/Exceptions/EcsFrameworkException.cs b/src/Exceptions/EcsFrameworkException.cs new file mode 100644 index 0000000..1b142ec --- /dev/null +++ b/src/Exceptions/EcsFrameworkException.cs @@ -0,0 +1,16 @@ +using System; + +namespace DCFApixels.DragonECS +{ + [Serializable] + public class EcsFrameworkException : Exception + { + private const string MESSAGE_SUFFIX = "[DragonECS] "; + public EcsFrameworkException() { } + public EcsFrameworkException(string message) : base(MESSAGE_SUFFIX + message) { } + public EcsFrameworkException(string message, Exception inner) : base(MESSAGE_SUFFIX + message, inner) { } + protected EcsFrameworkException( + System.Runtime.Serialization.SerializationInfo info, + System.Runtime.Serialization.StreamingContext context) : base(info, context) { } + } +} diff --git a/src/React/EcsSystemsRunner.cs.meta b/src/Exceptions/EcsFrameworkException.cs.meta similarity index 83% rename from src/React/EcsSystemsRunner.cs.meta rename to src/Exceptions/EcsFrameworkException.cs.meta index 0f1370c..f4f83b4 100644 --- a/src/React/EcsSystemsRunner.cs.meta +++ b/src/Exceptions/EcsFrameworkException.cs.meta @@ -1,5 +1,5 @@ fileFormatVersion: 2 -guid: 37fabd05090af0843a67e6c8046ad374 +guid: 309c604e79678054aaa9506dded971da MonoImporter: externalObjects: {} serializedVersion: 2 diff --git a/src/Interfaces/IEcsSystem.cs b/src/Interfaces/IEcsProcessor.cs similarity index 53% rename from src/Interfaces/IEcsSystem.cs rename to src/Interfaces/IEcsProcessor.cs index 1ed138e..67dcc32 100644 --- a/src/Interfaces/IEcsSystem.cs +++ b/src/Interfaces/IEcsProcessor.cs @@ -1,6 +1,6 @@ namespace DCFApixels.DragonECS { - public interface IEcsSystem { } + public interface IEcsProcessor { } public interface IEcsDoTag { } public struct _PreInit : IEcsDoTag { } @@ -8,22 +8,23 @@ public struct _Run : IEcsDoTag { } public struct _Destroy : IEcsDoTag { } public struct _PostDestroy : IEcsDoTag { } - public interface IEcsDo : IEcsSystem + public interface IEcsDo : IEcsProcessor where TTag : IEcsDoTag { - public void Do(EcsSession engine); + public void Do(EcsSession session); } + public interface IEcsSimpleCycleProcessor : + IEcsDo<_Init>, + IEcsDo<_Run>, + IEcsDo<_Destroy> + { } + + public interface IEcsMessage { } - public interface IEcsDoMessege : IEcsSystem + public interface IEcsDoMessege : IEcsProcessor where TMessage : IEcsMessage { - public void Do(EcsSession engine, in TMessage message); + public void Do(EcsSession session, in TMessage message); } - - public interface IEcsSimpleCycleSystem : - IEcsDo<_Init>, - IEcsDo<_Run>, - IEcsDo<_Destroy> - { } } diff --git a/src/Interfaces/IEcsSystem.cs.meta b/src/Interfaces/IEcsProcessor.cs.meta similarity index 100% rename from src/Interfaces/IEcsSystem.cs.meta rename to src/Interfaces/IEcsProcessor.cs.meta diff --git a/src/Pools.meta b/src/Pools.meta new file mode 100644 index 0000000..55cbf0c --- /dev/null +++ b/src/Pools.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 712e0669e3984c0479174a12942e4db6 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/src/EcsFieldPool.cs b/src/Pools/EcsPool.cs similarity index 60% rename from src/EcsFieldPool.cs rename to src/Pools/EcsPool.cs index d0d3881..598910b 100644 --- a/src/EcsFieldPool.cs +++ b/src/Pools/EcsPool.cs @@ -5,31 +5,37 @@ using UnityEngine; namespace DCFApixels.DragonECS { - public interface IEcsFieldPool - { - public bool Has(int index); - public void Add(int index); - } - public class EcsFieldPool : IEcsFieldPool + public class EcsPool : IEcsPool { private int _id; - private SparseSet _sparseSet; + private readonly EcsWorld _source; + private readonly EcsType _type; + private readonly SparseSet _sparseSet; private T[] _denseItems; + #region Properites + public EcsWorld World => _source; public int ID => _id; - + public EcsType Type => _type; public ref T this[int index] { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => ref _denseItems[_sparseSet[index]]; } - public EcsFieldPool(int capacity) + #endregion + + #region Constructors + public EcsPool(EcsWorld source, EcsType type, int capacity) { + _source = source; + _type = type; _denseItems = new T[capacity]; _sparseSet = new SparseSet(capacity); } + #endregion + #region Add/Has/Get/Del [MethodImpl(MethodImplOptions.AggressiveInlining)] public ref T Add(int index) { @@ -44,8 +50,15 @@ namespace DCFApixels.DragonECS return _sparseSet.Contains(index); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void Del(int index) + { + _sparseSet.Remove(index); + } + #endregion + #region IEcsFieldPool - void IEcsFieldPool.Add(int index) + void IEcsPool.Add(int index) { Add(index); } diff --git a/src/EcsTableCore.cs.meta b/src/Pools/EcsPool.cs.meta similarity index 83% rename from src/EcsTableCore.cs.meta rename to src/Pools/EcsPool.cs.meta index c3d7eaa..5e350ed 100644 --- a/src/EcsTableCore.cs.meta +++ b/src/Pools/EcsPool.cs.meta @@ -1,5 +1,5 @@ fileFormatVersion: 2 -guid: 1d395d007b9c7c24c9f1f4c09f16e04c +guid: ea5495513fa22a54987d75f5cc4fea42 MonoImporter: externalObjects: {} serializedVersion: 2 diff --git a/src/Pools/EcsTagsPool.cs b/src/Pools/EcsTagsPool.cs new file mode 100644 index 0000000..66dcf8e --- /dev/null +++ b/src/Pools/EcsTagsPool.cs @@ -0,0 +1,52 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.CompilerServices; +using System.Text; +using System.Threading.Tasks; + +namespace DCFApixels.DragonECS +{ + public class EcsTagsPool : IEcsPool + { + private int _id; + private readonly EcsWorld _source; + private readonly EcsType _type; + private readonly SparseSet _sparseSet; + + #region Properites + public EcsWorld World => _source; + public int ID => _id; + public EcsType Type => _type; + #endregion + + #region Constructors + public EcsTagsPool(EcsWorld source, EcsType type, int capacity) + { + _source = source; + _type = type; + _sparseSet = new SparseSet(capacity); + } + #endregion + + #region Add/Has/Del + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void Add(int index) + { + _sparseSet.Add(index); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void Del(int index) + { + _sparseSet.Add(index); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Has(int index) + { + return _sparseSet.Contains(index); + } + #endregion + } +} diff --git a/src/Pools/EcsTagsPool.cs.meta b/src/Pools/EcsTagsPool.cs.meta new file mode 100644 index 0000000..7b84cc0 --- /dev/null +++ b/src/Pools/EcsTagsPool.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 01fdcaed7dcb78b4eb4560c068cb0b27 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/src/Pools/IEcsPool.cs b/src/Pools/IEcsPool.cs new file mode 100644 index 0000000..da8f614 --- /dev/null +++ b/src/Pools/IEcsPool.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DCFApixels.DragonECS +{ + public interface IEcsPool + { + public EcsWorld World { get; } + public int ID { get; } + public EcsType Type { get; } + public bool Has(int index); + public void Add(int index); + public void Del(int index); + } +} diff --git a/src/Pools/IEcsPool.cs.meta b/src/Pools/IEcsPool.cs.meta new file mode 100644 index 0000000..5be3cde --- /dev/null +++ b/src/Pools/IEcsPool.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 82d72237ee8aeb64c9e5455be807896a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/src/React/EcsSystemsMessenger.cs b/src/React/EcsProcessorsMessenger.cs similarity index 66% rename from src/React/EcsSystemsMessenger.cs rename to src/React/EcsProcessorsMessenger.cs index f76b988..1df771f 100644 --- a/src/React/EcsSystemsMessenger.cs +++ b/src/React/EcsProcessorsMessenger.cs @@ -2,37 +2,37 @@ namespace DCFApixels.DragonECS { - public interface IEcsSystemsMessenger + public interface IEcsProcessorsMessenger { public EcsSession Source { get; } } - public class EcsSystemsMessenger : IEcsSystemsMessenger + public class EcsProcessorsMessenger : IEcsProcessorsMessenger where TMessage : IEcsMessage { private EcsSession _source; - private IEcsDoMessege[] _systems; + private IEcsDoMessege[] _targets; public EcsSession Source => _source; - public IReadOnlyList> Systems => _systems; + public IReadOnlyList> Systems => _targets; - internal EcsSystemsMessenger(EcsSession source) + internal EcsProcessorsMessenger(EcsSession source) { _source = source; List> list = new List>(); - foreach (var item in _source.AllSystems) + foreach (var item in _source.AllProcessors) { if (item is IEcsDoMessege targetItem) { list.Add(targetItem); } } - _systems = list.ToArray(); + _targets = list.ToArray(); } public void Send(in TMessage message) { - foreach (var item in _systems) + foreach (var item in _targets) { item.Do(_source, message); } diff --git a/src/React/EcsProcessorsMessenger.cs.meta b/src/React/EcsProcessorsMessenger.cs.meta new file mode 100644 index 0000000..80d90cd --- /dev/null +++ b/src/React/EcsProcessorsMessenger.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5fb1c6ecbb7c4fd4692f54a92b7d198e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/src/React/EcsSystemsRunner.cs b/src/React/EcsProcessorsRunner.cs similarity index 62% rename from src/React/EcsSystemsRunner.cs rename to src/React/EcsProcessorsRunner.cs index dcdcfc2..3c685e1 100644 --- a/src/React/EcsSystemsRunner.cs +++ b/src/React/EcsProcessorsRunner.cs @@ -2,38 +2,38 @@ namespace DCFApixels.DragonECS { - public interface IEcsSystemsRunner + public interface IEcsProcessorsRunner { public EcsSession Source { get; } public void Run(); } - public class EcsSystemsRunner : IEcsSystemsRunner + public class EcsProcessorsRunner : IEcsProcessorsRunner where TDoTag : IEcsDoTag { private EcsSession _source; - private IEcsDo[] _systems; + private IEcsDo[] _targets; public EcsSession Source => _source; - public IReadOnlyList> Systems => _systems; + public IReadOnlyList> Systems => _targets; - internal EcsSystemsRunner(EcsSession source) + internal EcsProcessorsRunner(EcsSession source) { _source = source; List> list = new List>(); - foreach (var item in _source.AllSystems) + foreach (var item in _source.AllProcessors) { if (item is IEcsDo targetItem) { list.Add(targetItem); } } - _systems = list.ToArray(); + _targets = list.ToArray(); } public void Run() { - foreach (var item in _systems) + foreach (var item in _targets) { item.Do(_source); } diff --git a/src/React/EcsProcessorsRunner.cs.meta b/src/React/EcsProcessorsRunner.cs.meta new file mode 100644 index 0000000..42ddcdd --- /dev/null +++ b/src/React/EcsProcessorsRunner.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c8311d8200e99504693251ecdb1877c8 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/src/TableMembers/EcsField.cs b/src/TableMembers/EcsField.cs index 82bd082..b3be60d 100644 --- a/src/TableMembers/EcsField.cs +++ b/src/TableMembers/EcsField.cs @@ -7,10 +7,10 @@ namespace DCFApixels.DragonECS { public readonly struct EcsField : IEcsMemberCachePool, T> { - private readonly EcsFieldPool _pool; + private readonly EcsPool _pool; private readonly int _poolID; - public EcsFieldPool Pool => _pool; + public EcsPool Pool => _pool; public int PoolID => _poolID; private EcsField(int poolID) @@ -18,7 +18,7 @@ namespace DCFApixels.DragonECS _pool = null; _poolID = poolID; } - internal EcsField(EcsFieldPool pool) + internal EcsField(EcsPool pool) { _pool = pool; _poolID = pool.ID; @@ -32,21 +32,25 @@ namespace DCFApixels.DragonECS } [MethodImpl(MethodImplOptions.AggressiveInlining)] - public bool HasValue(int entityID) + public bool Has(int entityID) { return _pool.Has(entityID); } - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public ref T New(int entityID) + public ref T Add(int entityID) { return ref _pool.Add(entityID); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void Del(int entityID) + { + _pool.Del(entityID); + } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator EcsField(in int poolID) => new EcsField(poolID); - void IEcsMemberCachePool, T>.Inject(out EcsField self, EcsFieldPool pool) + void IEcsMemberCachePool, T>.Inject(out EcsField self, EcsPool pool) { self = new EcsField(pool); } @@ -54,10 +58,10 @@ namespace DCFApixels.DragonECS public readonly struct EcsIncField : IEcsMemberCachePool, T> { - private readonly EcsFieldPool _pool; + private readonly EcsPool _pool; private readonly int _poolID; - public EcsFieldPool Pool => _pool; + public EcsPool Pool => _pool; public int PoolID => _poolID; private EcsIncField(int poolID) @@ -65,7 +69,7 @@ namespace DCFApixels.DragonECS _pool = null; _poolID = poolID; } - internal EcsIncField(EcsFieldPool pool) + internal EcsIncField(EcsPool pool) { _pool = pool; _poolID = pool.ID; @@ -78,26 +82,52 @@ namespace DCFApixels.DragonECS get => ref _pool[entityID]; } + [EditorBrowsable(EditorBrowsableState.Never)] + public void Del(int entityID) + { + _pool.Del(entityID); + } + [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator EcsIncField(in int poolID) => new EcsIncField(poolID); - void IEcsMemberCachePool, T>.Inject(out EcsIncField self, EcsFieldPool pool) + void IEcsMemberCachePool, T>.Inject(out EcsIncField self, EcsPool pool) { self = new EcsIncField(pool); } } - public struct EcsExcField : IEcsTableMember + public struct EcsExcField : IEcsMemberCachePool, T> { + private readonly EcsPool _pool; private readonly int _poolID; + + public EcsPool Pool => _pool; public int PoolID => _poolID; private EcsExcField(int poolID) { + _pool = null; _poolID = poolID; } + internal EcsExcField(EcsPool pool) + { + _pool = pool; + _poolID = pool.ID; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public ref T Add(int entityID) + { + return ref _pool.Add(entityID); + } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator EcsExcField(in int poolID) => new EcsExcField(poolID); + + void IEcsMemberCachePool, T>.Inject(out EcsExcField self, EcsPool pool) + { + self = new EcsExcField(pool); + } } } diff --git a/src/TableMembers/EcsTag.cs b/src/TableMembers/EcsTag.cs index 636069d..7fee0bd 100644 --- a/src/TableMembers/EcsTag.cs +++ b/src/TableMembers/EcsTag.cs @@ -5,12 +5,12 @@ using System.Runtime.CompilerServices; namespace DCFApixels.DragonECS { - public readonly struct EcsTag : IEcsMemberCachePool, T> + public readonly struct EcsTag : IEcsMemberCachePool { - private readonly EcsFieldPool _pool; + private readonly EcsPool _pool; private readonly int _poolID; - public EcsFieldPool Pool => _pool; + public EcsPool Pool => _pool; public int PoolID => _poolID; private EcsTag(int poolID) @@ -18,7 +18,7 @@ namespace DCFApixels.DragonECS _pool = null; _poolID = poolID; } - internal EcsTag(EcsFieldPool pool) + internal EcsTag(EcsPool pool) { _pool = pool; _poolID = pool.ID; @@ -30,37 +30,65 @@ namespace DCFApixels.DragonECS } [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static implicit operator EcsTag(in int poolID) => new EcsTag(poolID); + public static implicit operator EcsTag(in int poolID) => new EcsTag(poolID); - void IEcsMemberCachePool, T>.Inject(out EcsTag self, EcsFieldPool pool) + void IEcsMemberCachePool.Inject(out EcsTag self, EcsPool pool) { - self = new EcsTag(pool); + self = new EcsTag(pool); } } - public readonly struct EcsIncTag : IEcsTableMember + public readonly struct EcsIncTag : IEcsMemberCachePool { + private readonly EcsPool _pool; private readonly int _poolID; + + public EcsPool Pool => _pool; public int PoolID => _poolID; private EcsIncTag(int poolID) { + _pool = null; _poolID = poolID; } + internal EcsIncTag(EcsPool pool) + { + _pool = pool; + _poolID = pool.ID; + } [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static implicit operator EcsIncTag(in int poolID) => new EcsIncTag(poolID); + public static implicit operator EcsIncTag(in int poolID) => new EcsIncTag(poolID); + + void IEcsMemberCachePool.Inject(out EcsIncTag self, EcsPool pool) + { + self = new EcsIncTag(pool); + } } - public readonly struct EcsExcTag : IEcsTableMember + public readonly struct EcsExcTag : IEcsMemberCachePool { + private readonly EcsPool _pool; private readonly int _poolID; + + public EcsPool Pool => _pool; public int PoolID => _poolID; private EcsExcTag(int poolID) { + _pool = null; _poolID = poolID; } + internal EcsExcTag(EcsPool pool) + { + _pool = pool; + _poolID = pool.ID; + } [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static implicit operator EcsExcTag(in int poolID) => new EcsExcTag(poolID); + public static implicit operator EcsExcTag(in int poolID) => new EcsExcTag(poolID); + + void IEcsMemberCachePool.Inject(out EcsExcTag self, EcsPool pool) + { + self = new EcsExcTag(pool); + } } } diff --git a/src/TableMembers/IEcsTableMember.cs b/src/TableMembers/IEcsTableMember.cs index 4a8f2a5..55c21d6 100644 --- a/src/TableMembers/IEcsTableMember.cs +++ b/src/TableMembers/IEcsTableMember.cs @@ -10,7 +10,7 @@ namespace DCFApixels.DragonECS public interface IEcsMemberCachePool : IEcsTableMember where TSelf: struct, IEcsTableMember { - public EcsFieldPool Pool { get; } - public void Inject(out TSelf self, EcsFieldPool pool); + public EcsPool Pool { get; } + public void Inject(out TSelf self, EcsPool pool); } } diff --git a/src/Interfaces/IEcsTable.cs b/src/TableMembers/TagType.cs similarity index 81% rename from src/Interfaces/IEcsTable.cs rename to src/TableMembers/TagType.cs index 41506e6..0b70912 100644 --- a/src/Interfaces/IEcsTable.cs +++ b/src/TableMembers/TagType.cs @@ -6,6 +6,5 @@ using System.Threading.Tasks; namespace DCFApixels.DragonECS { - public interface IEcsTable { } + public struct TagType { } } - diff --git a/src/TableMembers/TagType.cs.meta b/src/TableMembers/TagType.cs.meta new file mode 100644 index 0000000..3018299 --- /dev/null +++ b/src/TableMembers/TagType.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 73f5e1a2319dcb644818c9bd14dcbc5d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/src/Utils/ComponentTypeID.cs b/src/Utils/ComponentTypeID.cs deleted file mode 100644 index dacdb0b..0000000 --- a/src/Utils/ComponentTypeID.cs +++ /dev/null @@ -1,12 +0,0 @@ -namespace DCFApixels.DragonECS -{ - public class ComponentTypeID - { - protected static int _incerement = 0; - } - public class TypeID : ComponentTypeID - where T : struct - { - public static readonly int id = _incerement++; - } -} \ No newline at end of file diff --git a/src/Utils/EcsType.cs b/src/Utils/EcsType.cs new file mode 100644 index 0000000..7600d68 --- /dev/null +++ b/src/Utils/EcsType.cs @@ -0,0 +1,77 @@ +using System.Collections.Generic; +using System; +using System.Runtime.CompilerServices; + +namespace DCFApixels.DragonECS +{ + + public class EcsType : IEquatable + { + private static int _idIncrement = 0; + + //свободно еще 4 байта, возможно можно выделить под айдишники + private string _name; + private int _uniqueID; + + #region Constructors + internal EcsType(string name) + { + _name = name; + _uniqueID = _idIncrement++; + +#if DEBUG + if (_idIncrement == 0) + { + throw new EcsFrameworkException($"The maximum number of identifiers is allocated. Max:{uint.MaxValue}"); + } +#endif + } + #endregion + + #region Equals + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override bool Equals(object obj) + { + return obj is EcsType key && _name == key._name; + } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(EcsType other) + { + return _uniqueID == other._uniqueID; + } + #endregion + + #region GetHashCode/ToString + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() => _uniqueID; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() => "EcsType." + _name; + + #endregion + + #region operators + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool operator ==(in EcsType left, in EcsType right) => left.Equals(right); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool operator !=(in EcsType left, in EcsType right) => !left.Equals(right); + #endregion + } + + + public static class EcsTypeMap + { + private static Dictionary _types = new Dictionary(256); + + public static EcsType GetEcsType(string name) + { + if (_types.TryGetValue(name, out EcsType type)) + return type; + + type = new EcsType(name); + _types.Add(name, type); + return type; + } + } +} \ No newline at end of file diff --git a/src/Utils/ComponentTypeID.cs.meta b/src/Utils/EcsType.cs.meta similarity index 100% rename from src/Utils/ComponentTypeID.cs.meta rename to src/Utils/EcsType.cs.meta diff --git a/src/Utils/entityArraysPool.cs b/src/Utils/entityArraysPool.cs new file mode 100644 index 0000000..437c6e2 --- /dev/null +++ b/src/Utils/entityArraysPool.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DCFApixels.DragonECS +{ + public class entityArraysPool + { + //public int[] + } +} diff --git a/src/Utils/entityArraysPool.cs.meta b/src/Utils/entityArraysPool.cs.meta new file mode 100644 index 0000000..a1657c2 --- /dev/null +++ b/src/Utils/entityArraysPool.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 50cf3219cac6cc84faf71a80230f8539 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/src/ent.cs b/src/ent.cs index 52f89fb..b2de580 100644 --- a/src/ent.cs +++ b/src/ent.cs @@ -14,6 +14,7 @@ namespace DCFApixels.DragonECS // id - 32 bits // gen - 16 bits // world - 8 bits + // empty - 8 bits public readonly long _full; [EditorBrowsable(EditorBrowsableState.Never)] @@ -48,12 +49,12 @@ namespace DCFApixels.DragonECS } [EditorBrowsable(EditorBrowsableState.Never)] - public ent(int id, short gen, byte world, byte com) + public ent(int id, short gen, byte world) { _full = ((long)id) << 32; _full += ((long)gen) << 16; _full += ((long)(++world)) << 8; // сдвиг айдишников + 1 - _full += com; + //_full += ...; } [MethodImpl(MethodImplOptions.AggressiveInlining)]