MoonsideGames
/
MoonTools.ECS
1
0
Fork 0
Code Issues Pull Requests Projects Releases Activity

Storage Rewrite #6

Merged
cosmonaut merged 17 commits from optimization into main 2023-11-21 19:50:17 +00:00
Conversation 0 Commits 17 Files Changed 30
30 changed files with 2197 additions and 2383 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
src/Collections/IndexableSet.cs Normal file
View File

@ -0,0 +1,106 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace MoonTools.ECS.Collections;
public unsafe class IndexableSet<T> : IDisposable where T : unmanaged
{
private Dictionary<T, int> Indices;
private T* Array;
public int Count { get; private set; }
private int Capacity;
private bool IsDisposed;
public Span<T> AsSpan() => new Span<T>(Array, Count);
public ReverseSpanEnumerator<T> GetEnumerator() => new ReverseSpanEnumerator<T>(new Span<T>(Array, Count));
public IndexableSet(int capacity = 32)
{
this.Capacity = capacity;
Count = 0;
Indices = new Dictionary<T, int>(capacity);
Array = (T*) NativeMemory.Alloc((nuint) (capacity * Unsafe.SizeOf<T>()));
}
public T this[int i] => Array[i];
public bool Contains(T element)
{
return Indices.ContainsKey(element);
}
public bool Add(T element)
{
if (!Contains(element))
{
Indices.Add(element, Count);
if (Count >= Capacity)
{
Capacity *= 2;
Array = (T*) NativeMemory.Realloc(Array, (nuint) (Capacity * Unsafe.SizeOf<T>()));
}
Array[Count] = element;
Count += 1;
return true;
}
return false;
}
public bool Remove(T element)
{
if (!Contains(element))
{
return false;
}
var index = Indices[element];
for (var i = index; i < Count - 1; i += 1)
{
Array[i] = Array[i + 1];
Indices[Array[i]] = i;
}
Indices.Remove(element);
Count -= 1;
return true;
}
public void Clear()
{
Indices.Clear();
Count = 0;
}
protected virtual void Dispose(bool disposing)
{
if (!IsDisposed)
{
NativeMemory.Free(Array);
Array = null;
IsDisposed = true;
}
}
~IndexableSet()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: false);
}
public void Dispose()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}

120
src/Collections/NativeArray.cs Normal file
View File

@ -0,0 +1,120 @@
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace MoonTools.ECS.Collections;
public unsafe class NativeArray<T> : IDisposable where T : unmanaged
{
private T* Elements;
public int Count { get; private set;}
private int Capacity;
private int ElementSize;
public Span<T> ToSpan() => new Span<T>(Elements, Count);
public Span<T>.Enumerator GetEnumerator() => new Span<T>(Elements, Count).GetEnumerator();
private bool IsDisposed;
public NativeArray(int capacity = 16)
{
this.Capacity = capacity;
ElementSize = Unsafe.SizeOf<T>();
Elements = (T*) NativeMemory.Alloc((nuint) (capacity * ElementSize));
Count = 0;
}
public ref T this[int i] => ref Elements[i];
public void Append(T item)
{
if (Count >= Capacity)
{
Capacity *= 2;
Elements = (T*) NativeMemory.Realloc(Elements, (nuint) (Capacity * Unsafe.SizeOf<T>()));
}
Elements[Count] = item;
Count += 1;
}
public void RemoveLastElement()
{
Count -= 1;
}
public bool TryPop(out T element)
{
if (Count > 0)
{
element = Elements[Count - 1];
Count -= 1;
return true;
}
element = default;
return false;
}
public void Clear()
{
Count = 0;
}
private void ResizeTo(int size)
{
Capacity = size;
Elements = (T*) NativeMemory.Realloc((void*) Elements, (nuint) (ElementSize * Capacity));
}
// Fills gap by copying final element to the deleted index
public void Delete(int index)
{
if (index != Count - 1)
{
this[index] = this[Count - 1];
}
Count -= 1;
}
public void CopyTo(NativeArray<T> other)
{
if (Count >= other.Capacity)
{
other.ResizeTo(Count);
}
NativeMemory.Copy(
(void*) Elements,
(void*) other.Elements,
(nuint) (ElementSize * Count)
);
other.Count = Count;
}
protected virtual void Dispose(bool disposing)
{
if (!IsDisposed)
{
NativeMemory.Free(Elements);
Elements = null;
IsDisposed = true;
}
}
~NativeArray()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: false);
}
public void Dispose()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}

121
src/Collections/NativeArrayUntyped.cs Normal file
View File

@ -0,0 +1,121 @@
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace MoonTools.ECS.Collections;
internal unsafe class NativeArray : IDisposable
{
private nint Elements;
public int Count { get; private set;}
private int Capacity;
public readonly int ElementSize;
private bool IsDisposed;
public NativeArray(int elementSize)
{
Capacity = 16;
Count = 0;
ElementSize = elementSize;
Elements = (nint) NativeMemory.Alloc((nuint) (ElementSize * Capacity));
}
public Span<T> ToSpan<T>()
{
return new Span<T>((void*) Elements, Count);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public ref T Get<T>(int i) where T : unmanaged
{
return ref ((T*) Elements)[i];
}
public void Set<T>(int i, in T element) where T : unmanaged
{
Unsafe.Write((void*) (Elements + ElementSize * i), element);
}
private void Resize()
{
Capacity *= 2;
Elements = (nint) NativeMemory.Realloc((void*) Elements, (nuint) (ElementSize * Capacity));
}
private void ResizeTo(int capacity)
{
Capacity = capacity;
Elements = (nint) NativeMemory.Realloc((void*) Elements, (nuint) (ElementSize * Capacity));
}
// Fills gap by copying final element to the deleted index
public void Delete(int index)
{
if (index != Count - 1)
{
NativeMemory.Copy(
(void*) (Elements + ((Count - 1) * ElementSize)),
(void*) (Elements + (index * ElementSize)),
(nuint) ElementSize
);
}
Count -= 1;
}
public void Append<T>(T component) where T : unmanaged
{
if (Count >= Capacity)
{
Resize();
}
((T*) Elements)[Count] = component;
Count += 1;
}
public void CopyAllTo(NativeArray other)
{
if (Count >= other.Capacity)
{
other.ResizeTo(Count);
}
NativeMemory.Copy(
(void*) Elements,
(void*) other.Elements,
(nuint) (ElementSize * Count)
);
other.Count = Count;
}
public void Clear()
{
Count = 0;
}
protected virtual void Dispose(bool disposing)
{
if (!IsDisposed)
{
NativeMemory.Free((void*) Elements);
IsDisposed = true;
}
}
~NativeArray()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: false);
}
public void Dispose()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}

139
src/ComponentDepot.cs
View File

@ -1,139 +0,0 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace MoonTools.ECS
{
internal class ComponentDepot
{
private TypeIndices ComponentTypeIndices;
private ComponentStorage[] storages = new ComponentStorage[256];
public ComponentDepot(TypeIndices componentTypeIndices)
{
ComponentTypeIndices = componentTypeIndices;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal void Register<TComponent>(int index) where TComponent : unmanaged
{
if (index >= storages.Length)
{
Array.Resize(ref storages, storages.Length * 2);
}
storages[index] = new ComponentStorage<TComponent>();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private ComponentStorage<TComponent> Lookup<TComponent>() where TComponent : unmanaged
{
var storageIndex = ComponentTypeIndices.GetIndex<TComponent>();
// TODO: is there some way to avoid this null check?
if (storageIndex >= storages.Length || storages[storageIndex] == null)
{
Register<TComponent>(storageIndex);
}
return (ComponentStorage<TComponent>) storages[storageIndex];
}
public bool Some<TComponent>() where TComponent : unmanaged
{
return Lookup<TComponent>().Any();
}
public ref readonly TComponent Get<TComponent>(int entityID) where TComponent : unmanaged
{
return ref Lookup<TComponent>().Get(entityID);
}
public ref readonly TComponent GetFirst<TComponent>() where TComponent : unmanaged
{
return ref Lookup<TComponent>().GetFirst();
}
public void Set<TComponent>(int entityID, in TComponent component) where TComponent : unmanaged
{
Lookup<TComponent>().Set(entityID, component);
}
public Entity GetSingletonEntity<TComponent>() where TComponent : unmanaged
{
return Lookup<TComponent>().FirstEntity();
}
public ReadOnlySpan<TComponent> ReadComponents<TComponent>() where TComponent : unmanaged
{
return Lookup<TComponent>().AllComponents();
}
public void Remove(int entityID, int storageIndex)
{
storages[storageIndex].Remove(entityID);
}
public void Remove<TComponent>(int entityID) where TComponent : unmanaged
{
Lookup<TComponent>().Remove(entityID);
}
public void Clear()
{
for (var i = 0; i < storages.Length; i += 1)
{
if (storages[i] != null)
{
storages[i].Clear();
}
}
}
// these methods used to implement transfers and debugging
internal unsafe void* UntypedGet(int entityID, int componentTypeIndex)
{
return storages[componentTypeIndex].UntypedGet(entityID);
}
internal unsafe void Set(int entityID, int componentTypeIndex, void* component)
{
storages[componentTypeIndex].Set(entityID, component);
}
public void CreateMissingStorages(ComponentDepot other)
{
while (other.ComponentTypeIndices.Count >= storages.Length)
{
Array.Resize(ref storages, storages.Length * 2);
}
while (other.ComponentTypeIndices.Count >= other.storages.Length)
{
Array.Resize(ref other.storages, other.storages.Length * 2);
}
for (var i = 0; i < other.ComponentTypeIndices.Count; i += 1)
{
if (storages[i] == null && other.storages[i] != null)
{
storages[i] = other.storages[i].CreateStorage();
}
}
}
// this method is used to iterate components of an entity, only for use with a debug inspector
#if DEBUG
public object Debug_Get(int entityID, int componentTypeIndex)
{
return storages[componentTypeIndex].Debug_Get(entityID);
}
public IEnumerable<int> Debug_GetEntityIDs(int componentTypeIndex)
{
return storages[componentTypeIndex].Debug_GetEntityIDs();
}
#endif
}
}

180
src/ComponentStorage.cs
View File

@ -1,112 +1,87 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using MoonTools.ECS.Collections;
namespace MoonTools.ECS
namespace MoonTools.ECS;
internal class ComponentStorage : IDisposable
{
internal abstract class ComponentStorage
{
internal abstract unsafe void Set(int entityID, void* component);
public abstract bool Remove(int entityID);
public abstract void Clear();
internal readonly Dictionary<Entity, int> EntityIDToStorageIndex = new Dictionary<Entity, int>(16);
internal readonly NativeArray Components;
internal readonly NativeArray<Entity> EntityIDs;
internal readonly TypeId TypeId;
// used for debugging and template instantiation
internal abstract unsafe void* UntypedGet(int entityID);
// used to create correctly typed storage on snapshot
public abstract ComponentStorage CreateStorage();
#if DEBUG
internal abstract object Debug_Get(int entityID);
internal abstract IEnumerable<int> Debug_GetEntityIDs();
#endif
}
private bool IsDisposed;
internal unsafe class ComponentStorage<TComponent> : ComponentStorage, IDisposable where TComponent : unmanaged
public ComponentStorage(TypeId typeId, int elementSize)
{
private readonly Dictionary<int, int> entityIDToStorageIndex = new Dictionary<int, int>(16);
private TComponent* components;
private int* entityIDs;
private int count = 0;
private int capacity = 16;
private bool disposed;
public ComponentStorage()
{
components = (TComponent*) NativeMemory.Alloc((nuint) (capacity * Unsafe.SizeOf<TComponent>()));
entityIDs = (int*) NativeMemory.Alloc((nuint) (capacity * Unsafe.SizeOf<int>()));
Components = new NativeArray(elementSize);
EntityIDs = new NativeArray<Entity>();
TypeId = typeId;
}
public bool Any()
{
return count > 0;
return Components.Count > 0;
}
public ref readonly TComponent Get(int entityID)
public bool Has(Entity entity)
{
return ref components[entityIDToStorageIndex[entityID]];
return EntityIDToStorageIndex.ContainsKey(entity);
}
internal override unsafe void* UntypedGet(int entityID)
public ref T Get<T>(in Entity entity) where T : unmanaged
{
return &components[entityIDToStorageIndex[entityID]];
return ref Components.Get<T>(EntityIDToStorageIndex[entity]);
}
public ref readonly TComponent GetFirst()
public ref T GetFirst<T>() where T : unmanaged
{
#if DEBUG
if (count == 0)
if (Components.Count == 0)
{
throw new IndexOutOfRangeException("Component storage is empty!");
}
#endif
return ref components[0];
}
public void Set(int entityID, in TComponent component)
{
if (!entityIDToStorageIndex.ContainsKey(entityID))
{
var index = count;
count += 1;
if (index >= capacity)
{
capacity *= 2;
components = (TComponent*) NativeMemory.Realloc(components, (nuint) (capacity * Unsafe.SizeOf<TComponent>()));
entityIDs = (int*) NativeMemory.Realloc(entityIDs, (nuint) (capacity * Unsafe.SizeOf<int>()));
}
entityIDToStorageIndex[entityID] = index;
entityIDs[index] = entityID;
}
components[entityIDToStorageIndex[entityID]] = component;
}
internal override unsafe void Set(int entityID, void* component)
{
Set(entityID, *(TComponent*) component);
return ref Components.Get<T>(0);
}
// Returns true if the entity had this component.
public override bool Remove(int entityID)
public bool Set<T>(in Entity entity, in T component) where T : unmanaged
{
if (entityIDToStorageIndex.TryGetValue(entityID, out int storageIndex))
if (EntityIDToStorageIndex.TryGetValue(entity, out var index))
{
entityIDToStorageIndex.Remove(entityID);
var lastElementIndex = count - 1;
// move a component into the hole to maintain contiguous memory
if (lastElementIndex != storageIndex)
Components.Set(index, component);
return true;
}
else
{
var lastEntityID = entityIDs[lastElementIndex];
entityIDToStorageIndex[lastEntityID] = storageIndex;
components[storageIndex] = components[lastElementIndex];
entityIDs[storageIndex] = lastEntityID;
EntityIDToStorageIndex[entity] = Components.Count;
EntityIDs.Append(entity);
Components.Append(component);
return false;
}
}
count -= 1;
// Returns true if the entity had this component.
public bool Remove(in Entity entity)
{
if (EntityIDToStorageIndex.TryGetValue(entity, out int index))
{
var lastElementIndex = Components.Count - 1;
var lastEntity = EntityIDs[lastElementIndex];
// move a component into the hole to maintain contiguous memory
Components.Delete(index);
EntityIDs.Delete(index);
EntityIDToStorageIndex.Remove(entity);
// update the index if it changed
if (lastElementIndex != index)
{
EntityIDToStorageIndex[lastEntity] = index;
}
return true;
}
@ -114,62 +89,47 @@ namespace MoonTools.ECS
return false;
}
public override void Clear()
public void Clear()
{
count = 0;
entityIDToStorageIndex.Clear();
}
public ReadOnlySpan<TComponent> AllComponents()
{
return new ReadOnlySpan<TComponent>(components, count);
Components.Clear();
EntityIDs.Clear();
EntityIDToStorageIndex.Clear();
}
public Entity FirstEntity()
{
#if DEBUG
if (count == 0)
if (EntityIDs.Count == 0)
{
throw new IndexOutOfRangeException("Component storage is empty!");
}
#endif
return new Entity(entityIDs[0]);
}
public override ComponentStorage<TComponent> CreateStorage()
{
return new ComponentStorage<TComponent>();
return EntityIDs[0];
}
#if DEBUG
internal override object Debug_Get(int entityID)
internal IEnumerable<Entity> Debug_GetEntities()
{
return components[entityIDToStorageIndex[entityID]];
}
internal override IEnumerable<int> Debug_GetEntityIDs()
{
return entityIDToStorageIndex.Keys;
return EntityIDToStorageIndex.Keys;
}
#endif
protected virtual void Dispose(bool disposing)
{
if (!disposed)
if (!IsDisposed)
{
NativeMemory.Free(components);
NativeMemory.Free(entityIDs);
components = null;
entityIDs = null;
Components.Dispose();
EntityIDs.Dispose();
disposed = true;
IsDisposed = true;
}
}
~ComponentStorage()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: false);
}
// ~ComponentStorage()
// {
// // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
// Dispose(disposing: false);
// }
public void Dispose()
{
@ -177,6 +137,4 @@ namespace MoonTools.ECS
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
#endif
}
}

60
src/DebugSystem.cs
View File

@ -1,63 +1,17 @@
// NOTE: these methods are very inefficient
// this class should only be used in debugging contexts!!
#if DEBUG
using System;
using System.Collections.Generic;
namespace MoonTools.ECS
namespace MoonTools.ECS;
public abstract class DebugSystem : System
{
public abstract class DebugSystem : System
{
protected DebugSystem(World world) : base(world)
{
}
protected DebugSystem(World world) : base(world) { }
protected ComponentEnumerator Debug_GetAllComponents(Entity entity)
{
return new ComponentEnumerator(ComponentDepot, entity, EntityStorage.ComponentTypeIndices(entity.ID));
}
protected IEnumerable<Entity> Debug_GetEntities(Type componentType)
{
foreach (var entityID in ComponentDepot.Debug_GetEntityIDs(ComponentTypeIndices.GetIndex(componentType)))
{
yield return new Entity(entityID);
}
}
protected IEnumerable<Type> Debug_SearchComponentType(string typeString)
{
foreach (var type in ComponentTypeIndices.Types)
{
if (type.ToString().ToLower().Contains(typeString.ToLower()))
{
yield return type;
}
}
}
public ref struct ComponentEnumerator
{
private ComponentDepot ComponentDepot;
private Entity Entity;
private ReverseSpanEnumerator<int> ComponentTypeIndices;
public ComponentEnumerator GetEnumerator() => this;
internal ComponentEnumerator(
ComponentDepot componentDepot,
Entity entity,
Collections.IndexableSet<int> componentTypeIndices
) {
ComponentDepot = componentDepot;
Entity = entity;
ComponentTypeIndices = componentTypeIndices.GetEnumerator();
}
public bool MoveNext() => ComponentTypeIndices.MoveNext();
public object Current => ComponentDepot.Debug_Get(Entity.ID, ComponentTypeIndices.Current);
}
}
protected World.ComponentTypeEnumerator Debug_GetAllComponentTypes(Entity entity) => World.Debug_GetAllComponentTypes(entity);
protected IEnumerable<Entity> Debug_GetEntities(Type componentType) => World.Debug_GetEntities(componentType);
protected IEnumerable<Type> Debug_SearchComponentType(string typeString) => World.Debug_SearchComponentType(typeString);
}
#endif

69
src/DynamicArray.cs
View File

@ -1,69 +0,0 @@
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace MoonTools.ECS.Collections
{
public unsafe class NativeArray<T> : IDisposable where T : unmanaged
{
private T* Array;
private int count;
private int capacity;
public int Count => count;
public ReverseSpanEnumerator<T> GetEnumerator() => new ReverseSpanEnumerator<T>(new Span<T>(Array, Count));
private bool disposed;
public NativeArray(int capacity = 16)
{
this.capacity = capacity;
Array = (T*) NativeMemory.Alloc((nuint) (capacity * Unsafe.SizeOf<T>()));
count = 0;
}
public ref T this[int i] => ref Array[i];
public void Add(T item)
{
if (count >= capacity)
{
capacity *= 2;
Array = (T*) NativeMemory.Realloc(Array, (nuint) (capacity * Unsafe.SizeOf<T>()));
}
Array[count] = item;
count += 1;
}
public void Clear()
{
count = 0;
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
NativeMemory.Free(Array);
Array = null;
disposed = true;
}
}
~NativeArray()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: false);
}
public void Dispose()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}
}

50
src/Entity.cs
View File

@ -1,49 +1,3 @@
using System;
namespace MoonTools.ECS;
namespace MoonTools.ECS
{
public struct Entity : IEquatable<Entity>
{
public int ID { get; }
internal Entity(int id)
{
ID = id;
}
public override bool Equals(object? obj)
{
return obj is Entity entity && Equals(entity);
}
public override int GetHashCode()
{
return HashCode.Combine(ID);
}
public bool Equals(Entity other)
{
return ID == other.ID;
}
public static bool operator ==(Entity a, Entity b)
{
return a.Equals(b);
}
public static bool operator !=(Entity a, Entity b)
{
return !a.Equals(b);
}
public static implicit operator int(Entity e)
{
return e.ID;
}
public static implicit operator Entity(int i)
{
return new Entity(i);
}
}
}
public readonly record struct Entity(uint ID);

139
src/EntityComponentReader.cs
View File

@ -1,127 +1,36 @@
using System;
using System.Collections.Generic;
namespace MoonTools.ECS;
namespace MoonTools.ECS
public abstract class EntityComponentReader
{
public abstract class EntityComponentReader
{
internal readonly World World;
internal EntityStorage EntityStorage => World.EntityStorage;
internal ComponentDepot ComponentDepot => World.ComponentDepot;
internal RelationDepot RelationDepot => World.RelationDepot;
protected FilterBuilder FilterBuilder => new FilterBuilder(FilterStorage, ComponentTypeIndices);
internal FilterStorage FilterStorage => World.FilterStorage;
internal TypeIndices ComponentTypeIndices => World.ComponentTypeIndices;
internal TypeIndices RelationTypeIndices => World.RelationTypeIndices;
protected readonly World World;
public FilterBuilder FilterBuilder => World.FilterBuilder;
public EntityComponentReader(World world)
protected EntityComponentReader(World world)
{
World = world;
}
protected string GetTag(in Entity entity)
{
return World.GetTag(entity);
}
protected string GetTag(in Entity entity) => World.GetTag(entity);
protected ReadOnlySpan<TComponent> ReadComponents<TComponent>() where TComponent : unmanaged
{
return ComponentDepot.ReadComponents<TComponent>();
}
protected bool Has<T>(in Entity Entity) where T : unmanaged => World.Has<T>(Entity);
protected bool Some<T>() where T : unmanaged => World.Some<T>();
protected ref T Get<T>(in Entity Entity) where T : unmanaged => ref World.Get<T>(Entity);
protected ref T GetSingleton<T>() where T : unmanaged => ref World.GetSingleton<T>();
protected Entity GetSingletonEntity<T>() where T : unmanaged => World.GetSingletonEntity<T>();
protected bool Has<TComponent>(in Entity entity) where TComponent : unmanaged
{
var storageIndex = ComponentTypeIndices.GetIndex<TComponent>();
return EntityStorage.HasComponent(entity.ID, storageIndex);
}
protected ReverseSpanEnumerator<(Entity, Entity)> Relations<T>() where T : unmanaged => World.Relations<T>();
protected bool Related<T>(in Entity entityA, in Entity entityB) where T : unmanaged => World.Related<T>(entityA, entityB);
protected T GetRelationData<T>(in Entity entityA, in Entity entityB) where T : unmanaged => World.GetRelationData<T>(entityA, entityB);
protected bool Some<TComponent>() where TComponent : unmanaged
{
return ComponentDepot.Some<TComponent>();
}
protected ReverseSpanEnumerator<Entity> OutRelations<T>(in Entity entity) where T : unmanaged => World.OutRelations<T>(entity);
protected Entity OutRelationSingleton<T>(in Entity entity) where T : unmanaged => World.OutRelationSingleton<T>(entity);
protected bool HasOutRelation<T>(in Entity entity) where T : unmanaged => World.HasOutRelation<T>(entity);
protected int OutRelationCount<T>(in Entity entity) where T : unmanaged => World.OutRelationCount<T>(entity);
protected Entity NthOutRelation<T>(in Entity entity, int n) where T : unmanaged => World.NthOutRelation<T>(entity, n);
protected ref readonly TComponent Get<TComponent>(in Entity entity) where TComponent : unmanaged
{
return ref ComponentDepot.Get<TComponent>(entity.ID);
}
protected ref readonly TComponent GetSingleton<TComponent>() where TComponent : unmanaged
{
return ref ComponentDepot.GetFirst<TComponent>();
}
protected Entity GetSingletonEntity<TComponent>() where TComponent : unmanaged
{
return ComponentDepot.GetSingletonEntity<TComponent>();
}
protected ReverseSpanEnumerator<(Entity, Entity)> Relations<TRelationKind>() where TRelationKind : unmanaged
{
return RelationDepot.Relations<TRelationKind>();
}
protected bool Related<TRelationKind>(in Entity a, in Entity b) where TRelationKind : unmanaged
{
return RelationDepot.Related<TRelationKind>(a.ID, b.ID);
}
protected TRelationKind GetRelationData<TRelationKind>(in Entity a, in Entity b) where TRelationKind : unmanaged
{
return RelationDepot.Get<TRelationKind>(a, b);
}
// relations go A->B, so given A, will give all entities in outgoing relations of this kind.
protected ReverseSpanEnumerator<Entity> OutRelations<TRelationKind>(in Entity entity) where TRelationKind : unmanaged
{
return RelationDepot.OutRelations<TRelationKind>(entity.ID);
}
protected Entity OutRelationSingleton<TRelationKind>(in Entity entity) where TRelationKind : unmanaged
{
return RelationDepot.OutRelationSingleton<TRelationKind>(entity.ID);
}
// NOTE: this WILL crash if at least n + 1 relations do not exist!
protected Entity NthOutRelation<TRelationKind>(in Entity entity, int n) where TRelationKind : unmanaged
{
return RelationDepot.NthOutRelation<TRelationKind>(entity.ID, n);
}
protected bool HasOutRelation<TRelationKind>(in Entity entity) where TRelationKind : unmanaged
{
return RelationDepot.HasOutRelation<TRelationKind>(entity.ID);
}
protected int OutRelationCount<TRelationKind>(in Entity entity) where TRelationKind : unmanaged
{
return RelationDepot.OutRelationCount<TRelationKind>(entity.ID);
}
// Relations go A->B, so given B, will give all entities in incoming A relations of this kind.
protected ReverseSpanEnumerator<Entity> InRelations<TRelationKind>(in Entity entity) where TRelationKind : unmanaged
{
return RelationDepot.InRelations<TRelationKind>(entity.ID);
}
protected Entity InRelationSingleton<TRelationKind>(in Entity entity) where TRelationKind : unmanaged
{
return RelationDepot.InRelationSingleton<TRelationKind>(entity.ID);
}
// NOTE: this WILL crash if at least n + 1 relations do not exist!
protected Entity NthInRelation<TRelationKind>(in Entity entity, int n) where TRelationKind : unmanaged
{
return RelationDepot.NthInRelation<TRelationKind>(entity.ID, n);
}
protected bool HasInRelation<TRelationKind>(in Entity entity) where TRelationKind : unmanaged
{
return RelationDepot.HasInRelation<TRelationKind>(entity.ID);
}
protected int InRelationCount<TRelationKind>(in Entity entity) where TRelationKind : unmanaged
{
return RelationDepot.InRelationCount<TRelationKind>(entity.ID);
}
}
protected ReverseSpanEnumerator<Entity> InRelations<T>(in Entity entity) where T : unmanaged => World.InRelations<T>(entity);
protected Entity InRelationSingleton<T>(in Entity entity) where T : unmanaged => World.InRelationSingleton<T>(entity);
protected bool HasInRelation<T>(in Entity entity) where T : unmanaged => World.HasInRelation<T>(entity);
protected int InRelationCount<T>(in Entity entity) where T : unmanaged => World.InRelationCount<T>(entity);
protected Entity NthInRelation<T>(in Entity entity, int n) where T : unmanaged => World.NthInRelation<T>(entity, n);
}

142
src/EntityStorage.cs
View File

@ -1,142 +0,0 @@
using System.Collections.Generic;
using MoonTools.ECS.Collections;
namespace MoonTools.ECS
{
internal class EntityStorage
{
private int nextID = 0;
// FIXME: why is this duplicated?
private readonly Stack<int> availableIDs = new Stack<int>();
// FIXME: this is only needed in debug mode
private readonly HashSet<int> availableIDHash = new HashSet<int>();
private Dictionary<int, IndexableSet<int>> EntityToComponentTypeIndices = new Dictionary<int, IndexableSet<int>>();
private Dictionary<int, IndexableSet<int>> EntityToRelationTypeIndices = new Dictionary<int, IndexableSet<int>>();
public int Count => nextID - availableIDs.Count;
public Dictionary<int, string> Tags = new Dictionary<int, string>();
public Entity Create(string tag)
{
var entity = new Entity(NextID());
if (!EntityToComponentTypeIndices.ContainsKey(entity.ID))
{
EntityToComponentTypeIndices.Add(entity.ID, new IndexableSet<int>());
}
if (!EntityToRelationTypeIndices.ContainsKey(entity.ID))
{
EntityToRelationTypeIndices.Add(entity.ID, new IndexableSet<int>());
}
Tags[entity.ID] = tag;
return entity;
}
public bool Exists(in Entity entity)
{
return Taken(entity.ID);
}
public void Tag(in Entity entity, string tag)
{
Tags[entity.ID] = tag;
}
public void Destroy(in Entity entity)
{
EntityToComponentTypeIndices[entity.ID].Clear();
EntityToRelationTypeIndices[entity.ID].Clear();
Tags.Remove(entity.ID);
Release(entity.ID);
}
// Returns true if the component is new.
public bool SetComponent(int entityID, int componentTypeIndex)
{
return EntityToComponentTypeIndices[entityID].Add(componentTypeIndex);
}
public bool HasComponent(int entityID, int componentTypeIndex)
{
return EntityToComponentTypeIndices[entityID].Contains(componentTypeIndex);
}
// Returns true if the component existed.
public bool RemoveComponent(int entityID, int componentTypeIndex)
{
return EntityToComponentTypeIndices[entityID].Remove(componentTypeIndex);
}
public void AddRelationKind(int entityID, int relationIndex)
{
EntityToRelationTypeIndices[entityID].Add(relationIndex);
}
public void RemoveRelation(int entityId, int relationIndex)
{
EntityToRelationTypeIndices[entityId].Remove(relationIndex);
}
public string Tag(int entityID)
{
return Tags[entityID];
}
public IndexableSet<int> ComponentTypeIndices(int entityID)
{
return EntityToComponentTypeIndices[entityID];
}
public IndexableSet<int> RelationTypeIndices(int entityID)
{
return EntityToRelationTypeIndices[entityID];
}
public void Clear()
{
nextID = 0;
foreach (var componentSet in EntityToComponentTypeIndices.Values)
{
componentSet.Clear();
}
foreach (var relationSet in EntityToRelationTypeIndices.Values)
{
relationSet.Clear();
}
availableIDs.Clear();
availableIDHash.Clear();
}
private int NextID()
{
if (availableIDs.Count > 0)
{
var id = availableIDs.Pop();
availableIDHash.Remove(id);
return id;
}
else
{
var id = nextID;
nextID += 1;
return id;
}
}
private bool Taken(int id)
{
return !availableIDHash.Contains(id) && id < nextID;
}
private void Release(int id)
{
availableIDs.Push(id);
availableIDHash.Add(id);
}
}
}

17
src/Enumerators/ReverseSpanEnumerator.cs
View File

@ -1,23 +1,23 @@
using System;
using System.Runtime.CompilerServices;
namespace MoonTools.ECS
namespace MoonTools.ECS;
public ref struct ReverseSpanEnumerator<T>
{
public ref struct ReverseSpanEnumerator<T>
{
private ReadOnlySpan<T> Span;
private int index;
private int Index;
public ReverseSpanEnumerator<T> GetEnumerator() => this;
public T Current => Span[index];
public T Current => Span[Index];
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool MoveNext()
{
if (index > 0)
if (Index > 0)
{
index -= 1;
Index -= 1;
return true;
}
@ -28,9 +28,8 @@ namespace MoonTools.ECS
public ReverseSpanEnumerator(Span<T> span)
{
Span = span;
index = span.Length;
Index = span.Length;
}
public static ReverseSpanEnumerator<T> Empty => new ReverseSpanEnumerator<T>();
}
}

125
src/Filter.cs
View File

@ -1,38 +1,123 @@
using System;
using System.Collections.Generic;
using MoonTools.ECS.Collections;
namespace MoonTools.ECS
namespace MoonTools.ECS;
public class Filter
{
public class Filter
{
private World World;
internal FilterSignature Signature;
private FilterStorage FilterStorage;
internal Filter(FilterStorage filterStorage, IndexableSet<int> included, IndexableSet<int> excluded)
{
FilterStorage = filterStorage;
Signature = new FilterSignature(included, excluded);
}
internal IndexableSet<Entity> EntitySet = new IndexableSet<Entity>();
public ReverseSpanEnumerator<Entity> Entities => FilterStorage.FilterEntities(Signature);
public RandomEntityEnumerator EntitiesInRandomOrder => FilterStorage.FilterEntitiesRandom(Signature);
public Entity RandomEntity => FilterStorage.FilterRandomEntity(Signature);
private bool IsDisposed;
public int Count => FilterStorage.FilterCount(Signature);
public bool Empty => Count == 0;
public ReverseSpanEnumerator<Entity> Entities => EntitySet.GetEnumerator();
public bool Empty => EntitySet.Count == 0;
public int Count => EntitySet.Count;
// WARNING: this WILL crash if the index is out of range!
public Entity NthEntity(int index) => FilterStorage.FilterNthEntity(Signature, index);
public Entity NthEntity(int index) => EntitySet[index];
public void RegisterAddCallback(Action<Entity> callback)
// WARNING: this WILL crash if the filter is empty!
public Entity RandomEntity => EntitySet[RandomManager.Next(EntitySet.Count)];
public RandomEntityEnumerator EntitiesInRandomOrder => new RandomEntityEnumerator(this);
internal Filter(World world, FilterSignature signature)
{
FilterStorage.RegisterAddCallback(Signature, callback);
World = world;
Signature = signature;
}
public void RegisterRemoveCallback(Action<Entity> callback)
public void DestroyAllEntities()
{
FilterStorage.RegisterRemoveCallback(Signature, callback);
foreach (var entity in EntitySet)
{
World.Destroy(entity);
}
}
internal void Check(Entity entity)
{
foreach (var type in Signature.Included)
{
if (!World.Has(entity, type))
{
EntitySet.Remove(entity);
return;
}
}
foreach (var type in Signature.Excluded)
{
if (World.Has(entity, type))
{
EntitySet.Remove(entity);
return;
}
}
EntitySet.Add(entity);
}
internal void AddEntity(in Entity entity)
{
EntitySet.Add(entity);
}
internal void RemoveEntity(in Entity entity)
{
EntitySet.Remove(entity);
}
internal void Clear()
{
EntitySet.Clear();
}
public ref struct RandomEntityEnumerator
{
private Filter Filter;
private LinearCongruentialEnumerator LinearCongruentialEnumerator;
public RandomEntityEnumerator GetEnumerator() => this;
internal RandomEntityEnumerator(Filter filter)
{
Filter = filter;
LinearCongruentialEnumerator =
RandomManager.LinearCongruentialSequence(filter.Count);
}
public bool MoveNext() => LinearCongruentialEnumerator.MoveNext();
public Entity Current => Filter.NthEntity(LinearCongruentialEnumerator.Current);
}
protected virtual void Dispose(bool disposing)
{
if (!IsDisposed)
{
if (disposing)
{
EntitySet.Dispose();
}
IsDisposed = true;
}
}
// // TODO: override finalizer only if 'Dispose(bool disposing)' has code to free unmanaged resources
// ~Filter()
// {
// // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
// Dispose(disposing: false);
// }
public void Dispose()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}

36
src/FilterBuilder.cs
View File

@ -4,42 +4,40 @@ namespace MoonTools.ECS
{
public struct FilterBuilder
{
private TypeIndices ComponentTypeIndices;
private FilterStorage FilterStorage;
private IndexableSet<int> Included;
private IndexableSet<int> Excluded;
World World;
IndexableSet<TypeId> Included;
IndexableSet<TypeId> Excluded;
internal FilterBuilder(FilterStorage filterStorage, TypeIndices componentTypeIndices)
internal FilterBuilder(World world)
{
FilterStorage = filterStorage;
ComponentTypeIndices = componentTypeIndices;
Included = new IndexableSet<int>();
Excluded = new IndexableSet<int>();
World = world;
Included = new IndexableSet<TypeId>();
Excluded = new IndexableSet<TypeId>();
}
private FilterBuilder(FilterStorage filterStorage, TypeIndices componentTypeIndices, IndexableSet<int> included, IndexableSet<int> excluded)
private FilterBuilder(World world, IndexableSet<TypeId> included, IndexableSet<TypeId> excluded)
{
FilterStorage = filterStorage;
ComponentTypeIndices = componentTypeIndices;
World = world;
Included = included;
Excluded = excluded;
}
public FilterBuilder Include<TComponent>() where TComponent : unmanaged
public FilterBuilder Include<T>() where T : unmanaged
{
Included.Add(ComponentTypeIndices.GetIndex<TComponent>());
return new FilterBuilder(FilterStorage, ComponentTypeIndices, Included, Excluded);
Included.Add(World.GetComponentTypeId<T>());
return new FilterBuilder(World, Included, Excluded);
}
public FilterBuilder Exclude<TComponent>() where TComponent : unmanaged
public FilterBuilder Exclude<T>() where T : unmanaged
{
Excluded.Add(ComponentTypeIndices.GetIndex<TComponent>());
return new FilterBuilder(FilterStorage, ComponentTypeIndices, Included, Excluded);
Excluded.Add(World.GetComponentTypeId<T>());
return new FilterBuilder(World, Included, Excluded);
}
public Filter Build()
{
return FilterStorage.CreateFilter(Included, Excluded);
var signature = new FilterSignature(Included, Excluded);
return World.GetFilter(signature);
}
}
}

16
src/FilterSignature.cs
View File

@ -1,15 +1,14 @@
using System;
using System.Collections.Generic;
using MoonTools.ECS.Collections;
namespace MoonTools.ECS
{
public struct FilterSignature : IEquatable<FilterSignature>
{
public readonly IndexableSet<int> Included;
public readonly IndexableSet<int> Excluded;
namespace MoonTools.ECS;
public FilterSignature(IndexableSet<int> included, IndexableSet<int> excluded)
public struct FilterSignature : IEquatable<FilterSignature>
{
public readonly IndexableSet<TypeId> Included;
public readonly IndexableSet<TypeId> Excluded;
public FilterSignature(IndexableSet<TypeId> included, IndexableSet<TypeId> excluded)
{
Included = included;
Excluded = excluded;
@ -67,5 +66,4 @@ namespace MoonTools.ECS
{
return !(left == right);
}
}
}

273
src/FilterStorage.cs
View File

@ -1,273 +0,0 @@
using System;
using System.Collections.Generic;
using MoonTools.ECS.Collections;
namespace MoonTools.ECS
{
internal class FilterStorage
{
private EntityStorage EntityStorage;
private TypeIndices ComponentTypeIndices;
private Dictionary<FilterSignature, IndexableSet<Entity>> filterSignatureToEntityIDs = new Dictionary<FilterSignature, IndexableSet<Entity>>();
private Dictionary<int, List<FilterSignature>> typeToFilterSignatures = new Dictionary<int, List<FilterSignature>>();
private Dictionary<FilterSignature, Action<Entity>> addCallbacks = new Dictionary<FilterSignature, Action<Entity>>();
private Dictionary<FilterSignature, Action<Entity>> removeCallbacks = new Dictionary<FilterSignature, Action<Entity>>();
public FilterStorage(EntityStorage entityStorage, TypeIndices componentTypeIndices)
{
EntityStorage = entityStorage;
ComponentTypeIndices = componentTypeIndices;
}
private void CopyTypeCache(Dictionary<int, List<FilterSignature>> typeCache)
{
foreach (var type in typeCache.Keys)
{
if (!typeToFilterSignatures.ContainsKey(type))
{
typeToFilterSignatures.Add(type, new List<FilterSignature>());
foreach (var signature in typeCache[type])
{
typeToFilterSignatures[type].Add(signature);
}
}
}
}
public void CreateMissingStorages(FilterStorage other)
{
foreach (var filterSignature in other.filterSignatureToEntityIDs.Keys)
{
if (!filterSignatureToEntityIDs.ContainsKey(filterSignature))
{
filterSignatureToEntityIDs.Add(filterSignature, new IndexableSet<Entity>());
}
}
CopyTypeCache(other.typeToFilterSignatures);
}
public Filter CreateFilter(IndexableSet<int> included, IndexableSet<int> excluded)
{
var filterSignature = new FilterSignature(included, excluded);
if (!filterSignatureToEntityIDs.ContainsKey(filterSignature))
{
filterSignatureToEntityIDs.Add(filterSignature, new IndexableSet<Entity>());
foreach (var type in included)
{
if (!typeToFilterSignatures.ContainsKey(type))
{
typeToFilterSignatures.Add(type, new List<FilterSignature>());
}
typeToFilterSignatures[type].Add(filterSignature);
}
foreach (var type in excluded)
{
if (!typeToFilterSignatures.ContainsKey(type))
{
typeToFilterSignatures.Add(type, new List<FilterSignature>());
}
typeToFilterSignatures[type].Add(filterSignature);
}
}
return new Filter(this, included, excluded);
}
public ReverseSpanEnumerator<Entity> FilterEntities(FilterSignature filterSignature)
{
return filterSignatureToEntityIDs[filterSignature].GetEnumerator();
}
public RandomEntityEnumerator FilterEntitiesRandom(FilterSignature filterSignature)
{
return new RandomEntityEnumerator(
this,
filterSignature,
RandomManager.LinearCongruentialSequence(FilterCount(filterSignature)));
}
public Entity FilterNthEntity(FilterSignature filterSignature, int index)
{
return new Entity(filterSignatureToEntityIDs[filterSignature][index]);
}
public Entity FilterRandomEntity(FilterSignature filterSignature)
{
var randomIndex = RandomManager.Next(FilterCount(filterSignature));
return new Entity(filterSignatureToEntityIDs[filterSignature][randomIndex]);
}
public int FilterCount(FilterSignature filterSignature)
{
return filterSignatureToEntityIDs[filterSignature].Count;
}
public void Check(int entityID, int componentTypeIndex)
{
if (typeToFilterSignatures.TryGetValue(componentTypeIndex, out var filterSignatures))
{
foreach (var filterSignature in filterSignatures)
{
CheckFilter(entityID, filterSignature);
}
}
}
public void Check<TComponent>(int entityID) where TComponent : unmanaged
{
Check(entityID, ComponentTypeIndices.GetIndex<TComponent>());
}
public bool CheckSatisfied(int entityID, FilterSignature filterSignature)
{
foreach (var type in filterSignature.Included)
{
if (!EntityStorage.HasComponent(entityID, type))
{
return false;
}
}
foreach (var type in filterSignature.Excluded)
{
if (EntityStorage.HasComponent(entityID, type))
{
return false;
}
}
return true;
}
private void CheckFilter(int entityID, FilterSignature filterSignature)
{
foreach (var type in filterSignature.Included)
{
if (!EntityStorage.HasComponent(entityID, type))
{
if (filterSignatureToEntityIDs[filterSignature].Remove(entityID))
{
if (removeCallbacks.TryGetValue(filterSignature, out var removeCallback))
{
removeCallback(entityID);
}
}
return;
}
}
foreach (var type in filterSignature.Excluded)
{
if (EntityStorage.HasComponent(entityID, type))
{
if (filterSignatureToEntityIDs[filterSignature].Remove(entityID))
{
if (removeCallbacks.TryGetValue(filterSignature, out var removeCallback))
{
removeCallback(entityID);
}
}
return;
}
}
if (filterSignatureToEntityIDs[filterSignature].Add(entityID))
{
if (addCallbacks.TryGetValue(filterSignature, out var addCallback))
{
addCallback(entityID);
}
}
}
public void RemoveEntity(int entityID, int componentTypeIndex)
{
if (typeToFilterSignatures.TryGetValue(componentTypeIndex, out var filterSignatures))
{
foreach (var filterSignature in filterSignatures)
{
if (filterSignatureToEntityIDs[filterSignature].Remove(entityID))
{
if (removeCallbacks.TryGetValue(filterSignature, out var removeCallback))
{
removeCallback(entityID);
}
}
}
}
}
// Used by TransferEntity
public void AddEntity(FilterSignature signature, int entityID)
{
filterSignatureToEntityIDs[signature].Add(entityID);
}
public void TransferStorage(Dictionary<int, int> worldToTransferID, FilterStorage other)
{
foreach (var (filterSignature, entityIDs) in filterSignatureToEntityIDs)
{
foreach (var entity in entityIDs)
{
if (worldToTransferID.ContainsKey(entity))
{
var otherEntityID = worldToTransferID[entity];
other.AddEntity(filterSignature, otherEntityID);
if (other.addCallbacks.TryGetValue(filterSignature, out var addCallback))
{
addCallback(otherEntityID);
}
}
}
}
}
// used by World.Clear, ignores callbacks
public void Clear()
{
foreach (var (filterSignature, entityIDs) in filterSignatureToEntityIDs)
{
entityIDs.Clear();
}
}
public void RegisterAddCallback(FilterSignature filterSignature, Action<Entity> callback)
{
addCallbacks.Add(filterSignature, callback);
}
public void RegisterRemoveCallback(FilterSignature filterSignature, Action<Entity> callback)
{
removeCallbacks.Add(filterSignature, callback);
}
}
public ref struct RandomEntityEnumerator
{
public RandomEntityEnumerator GetEnumerator() => this;
private FilterStorage FilterStorage;
private FilterSignature FilterSignature;
private LinearCongruentialEnumerator LinearCongruentialEnumerator;
internal RandomEntityEnumerator(
FilterStorage filterStorage,
FilterSignature filterSignature,
LinearCongruentialEnumerator linearCongruentialEnumerator)
{
FilterStorage = filterStorage;
FilterSignature = filterSignature;
LinearCongruentialEnumerator = linearCongruentialEnumerator;
}
public bool MoveNext() => LinearCongruentialEnumerator.MoveNext();
public Entity Current => FilterStorage.FilterNthEntity(FilterSignature, LinearCongruentialEnumerator.Current);
}
}

62
src/IdAssigner.cs Normal file
View File

@ -0,0 +1,62 @@
using System;
using MoonTools.ECS.Collections;
namespace MoonTools.ECS;
internal class IdAssigner : IDisposable
{
uint Next;
NativeArray<uint> AvailableIds = new NativeArray<uint>();
private bool IsDisposed;
public uint Assign()
{
if (AvailableIds.TryPop(out var id))
{
return id;
}
id = Next;
Next += 1;
return id;
}
public void Unassign(uint id)
{
AvailableIds.Append(id);
}
public void CopyTo(IdAssigner other)
{
AvailableIds.CopyTo(other.AvailableIds);
other.Next = Next;
}
protected virtual void Dispose(bool disposing)
{
if (!IsDisposed)
{
if (disposing)
{
AvailableIds.Dispose();
}
IsDisposed = true;
}
}
// // TODO: override finalizer only if 'Dispose(bool disposing)' has code to free unmanaged resources
// ~IdAssigner()
// {
// // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
// Dispose(disposing: false);
// }
public void Dispose()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}

103
src/IndexableSet.cs
View File

@ -1,103 +0,0 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace MoonTools.ECS.Collections
{
public unsafe class IndexableSet<T> : IDisposable where T : unmanaged
{
private Dictionary<T, int> indices;
private T* array;
private int count;
private int capacity;
private bool disposed;
public int Count => count;
public ReverseSpanEnumerator<T> GetEnumerator() => new ReverseSpanEnumerator<T>(new Span<T>(array, count));
public IndexableSet(int capacity = 32)
{
this.capacity = capacity;
count = 0;
indices = new Dictionary<T, int>(capacity);
array = (T*) NativeMemory.Alloc((nuint) (capacity * Unsafe.SizeOf<T>()));
}
public T this[int i] => array[i];
public bool Contains(T element)
{
return indices.ContainsKey(element);
}
public bool Add(T element)
{
if (!Contains(element))
{
indices.Add(element, count);
if (count >= capacity)
{
capacity *= 2;
array = (T*) NativeMemory.Realloc(array, (nuint) (capacity * Unsafe.SizeOf<T>()));
}
array[count] = element;
count += 1;
return true;
}
return false;
}
public bool Remove(T element)
{
if (!Contains(element))
{
return false;
}
var lastElement = array[Count - 1];
var index = indices[element];
array[index] = lastElement;
indices[lastElement] = index;
count -= 1;
indices.Remove(element);
return true;
}
public void Clear()
{
indices.Clear();
count = 0;
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
NativeMemory.Free(array);
array = null;
disposed = true;
}
}
~IndexableSet()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: false);
}
public void Dispose()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}
}

8
src/Manipulator.cs
View File

@ -1,7 +1,7 @@
namespace MoonTools.ECS
namespace MoonTools.ECS;
public abstract class Manipulator : EntityComponentReader
{
public abstract class Manipulator : EntityComponentReader
{
public Manipulator(World world) : base(world)
{
}
@ -10,9 +10,9 @@ namespace MoonTools.ECS
protected void Tag(Entity entity, string tag) => World.Tag(entity, tag);
protected void Set<TComponent>(in Entity entity, in TComponent component) where TComponent : unmanaged => World.Set<TComponent>(entity, component);
protected void Remove<TComponent>(in Entity entity) where TComponent : unmanaged => World.Remove<TComponent>(entity);
protected void Relate<TRelationKind>(in Entity entityA, in Entity entityB, TRelationKind relationData) where TRelationKind : unmanaged => World.Relate(entityA, entityB, relationData);
protected void Unrelate<TRelationKind>(in Entity entityA, in Entity entityB) where TRelationKind : unmanaged => World.Unrelate<TRelationKind>(entityA, entityB);
protected void UnrelateAll<TRelationKind>(in Entity entity) where TRelationKind : unmanaged => World.UnrelateAll<TRelationKind>(entity);
protected void Destroy(in Entity entity) => World.Destroy(entity);
}
}

68
src/MessageDepot.cs
View File

@ -1,68 +0,0 @@
using System;
using System.Collections.Generic;
namespace MoonTools.ECS
{
internal class MessageDepot
{
private Dictionary<Type, MessageStorage> storages = new Dictionary<Type, MessageStorage>();
private MessageStorage<TMessage> Lookup<TMessage>() where TMessage : unmanaged
{
if (!storages.ContainsKey(typeof(TMessage)))
{
storages.Add(typeof(TMessage), new MessageStorage<TMessage>());
}
return storages[typeof(TMessage)] as MessageStorage<TMessage>;
}
public void Add<TMessage>(in TMessage message) where TMessage : unmanaged
{
Lookup<TMessage>().Add(message);
}
public void Add<TMessage>(int entityID, in TMessage message) where TMessage : unmanaged
{
Lookup<TMessage>().Add(entityID, message);
}
public bool Some<TMessage>() where TMessage : unmanaged
{
return Lookup<TMessage>().Some();
}
public ReadOnlySpan<TMessage> All<TMessage>() where TMessage : unmanaged
{
return Lookup<TMessage>().All();
}
public TMessage First<TMessage>() where TMessage : unmanaged
{
return Lookup<TMessage>().First();
}
public ReverseSpanEnumerator<TMessage> WithEntity<TMessage>(int entityID) where TMessage : unmanaged
{
return Lookup<TMessage>().WithEntity(entityID);
}
public ref readonly TMessage FirstWithEntity<TMessage>(int entityID) where TMessage : unmanaged
{
return ref Lookup<TMessage>().FirstWithEntity(entityID);
}
public bool SomeWithEntity<TMessage>(int entityID) where TMessage : unmanaged
{
return Lookup<TMessage>().SomeWithEntity(entityID);
}
public void Clear()
{
foreach (var storage in storages.Values)
{
storage.Clear();
}
}
}
}

126
src/MessageStorage.cs
View File

@ -1,125 +1,58 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using MoonTools.ECS.Collections;
namespace MoonTools.ECS
namespace MoonTools.ECS;
public class MessageStorage : IDisposable
{
internal abstract class MessageStorage
private NativeArray Messages;
private bool IsDisposed;
public MessageStorage(int elementSize)
{
public abstract void Clear();
Messages = new NativeArray(elementSize);
}
internal unsafe class MessageStorage<TMessage> : MessageStorage, IDisposable where TMessage : unmanaged
public void Add<T>(in T message) where T : unmanaged
{
private int count = 0;
private int capacity = 128;
private TMessage* messages;
// duplicating storage here for fast iteration
private Dictionary<int, NativeArray<TMessage>> entityToMessages = new Dictionary<int, NativeArray<TMessage>>();
private bool disposed;
public MessageStorage()
{
messages = (TMessage*) NativeMemory.Alloc((nuint) (capacity * Unsafe.SizeOf<TMessage>()));
}
public void Add(in TMessage message)
{
if (count == capacity)
{
capacity *= 2;
messages = (TMessage*) NativeMemory.Realloc(messages, (nuint) (capacity * Unsafe.SizeOf<TMessage>()));
}
messages[count] = message;
count += 1;
}
public void Add(int entityID, in TMessage message)
{
if (!entityToMessages.ContainsKey(entityID))
{
entityToMessages.Add(entityID, new NativeArray<TMessage>());
}
entityToMessages[entityID].Add(message);
Add(message);
Messages.Append(message);
}
public bool Some()
{
return count > 0;
return Messages.Count > 0;
}
public ReadOnlySpan<TMessage> All()
public ReadOnlySpan<T> All<T>() where T : unmanaged
{
return new ReadOnlySpan<TMessage>(messages, count);
return Messages.ToSpan<T>();
}
public TMessage First()
public T First<T>() where T : unmanaged
{
return messages[0];
return Messages.Get<T>(0);
}
public ReverseSpanEnumerator<TMessage> WithEntity(int entityID)
public void Clear()
{
if (entityToMessages.TryGetValue(entityID, out var messages))
{
return messages.GetEnumerator();
Messages.Clear();
}
else
private void Dispose(bool disposing)
{
return ReverseSpanEnumerator<TMessage>.Empty;
if (!IsDisposed)
{
Messages.Dispose();
IsDisposed = true;
}
}
public ref readonly TMessage FirstWithEntity(int entityID)
{
return ref entityToMessages[entityID][0];
}
public bool SomeWithEntity(int entityID)
{
return entityToMessages.ContainsKey(entityID) && entityToMessages[entityID].Count > 0;
}
public override void Clear()
{
count = 0;
foreach (var set in entityToMessages.Values)
{
set.Clear();
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
Clear();
if (disposing)
{
foreach (var array in entityToMessages.Values)
{
array.Dispose();
}
}
NativeMemory.Free(messages);
messages = null;
disposed = true;
}
}
~MessageStorage()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: false);
}
// ~MessageStorage()
// {
// // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
// Dispose(disposing: false);
// }
public void Dispose()
{
@ -127,5 +60,4 @@ namespace MoonTools.ECS
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}
}

23
src/Random.cs
View File

@ -1,14 +1,14 @@
using System;
using System.Runtime.CompilerServices;
namespace MoonTools.ECS
namespace MoonTools.ECS;
/// <summary>
/// This class implements the well equidistributed long-period linear pseudorandom number generator.
/// Code taken from Chris Lomont: http://lomont.org/papers/2008/Lomont_PRNG_2008.pdf
/// </summary>
public class Random
{
/// <summary>
/// This class implements the well equidistributed long-period linear pseudorandom number generator.
/// Code taken from Chris Lomont: http://lomont.org/papers/2008/Lomont_PRNG_2008.pdf
/// </summary>
public class Random
{
public const int STATE_BYTE_COUNT = 68; // 16 state ints + 1 index int
uint[] State = new uint[16];
@ -67,12 +67,12 @@ namespace MoonTools.ECS
/// <exception cref="ArgumentException">Thrown if the byte span is too short.</exception>
public unsafe void SaveState(Span<byte> bytes)
{
#if DEBUG
#if DEBUG
if (bytes.Length < STATE_BYTE_COUNT)
{
throw new ArgumentException("Byte span too short!");
}
#endif
#endif
fixed (byte* ptr = bytes)
{
@ -94,12 +94,12 @@ namespace MoonTools.ECS
/// <exception cref="ArgumentException">Thrown if the byte span is too short.</exception>
public unsafe void LoadState(Span<byte> bytes)
{
#if DEBUG
#if DEBUG
if (bytes.Length < STATE_BYTE_COUNT)
{
throw new ArgumentException("Byte span too short!");
}
#endif
#endif
fixed (byte* ptr = bytes)
{
@ -205,5 +205,4 @@ namespace MoonTools.ECS
var n = NextInternal();
return ((double) n) / uint.MaxValue;
}
}
}

13
src/RandomManager.cs
View File

@ -1,9 +1,9 @@
using System.Runtime.CompilerServices;
namespace MoonTools.ECS
namespace MoonTools.ECS;
public static class RandomManager
{
public static class RandomManager
{
private static Random Random = new Random();
private static int[] Primes =
@ -41,10 +41,10 @@ namespace MoonTools.ECS
return new LinearCongruentialEnumerator(Random.Next(n), x, n);
}
}
}
public struct LinearCongruentialEnumerator
{
public struct LinearCongruentialEnumerator
{
private readonly int start;
private readonly int count;
private readonly int prime;
@ -78,5 +78,4 @@ namespace MoonTools.ECS
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => (current * prime) % count;
}
}
}

193
src/RelationDepot.cs
View File

@ -1,193 +0,0 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace MoonTools.ECS
{
internal class RelationDepot
{
private EntityStorage EntityStorage;
private TypeIndices RelationTypeIndices;
private RelationStorage[] storages = new RelationStorage[256];
public RelationDepot(EntityStorage entityStorage, TypeIndices relationTypeIndices)
{
EntityStorage = entityStorage;
RelationTypeIndices = relationTypeIndices;
}
private void Register<TRelationKind>(int index) where TRelationKind : unmanaged
{
if (index >= storages.Length)
{
Array.Resize(ref storages, storages.Length * 2);
}
storages[index] = new RelationStorage<TRelationKind>();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private RelationStorage<TRelationKind> Lookup<TRelationKind>() where TRelationKind : unmanaged
{
var storageIndex = RelationTypeIndices.GetIndex<TRelationKind>();
// TODO: is there some way to avoid this null check?
if (storages[storageIndex] == null)
{
Register<TRelationKind>(storageIndex);
}
return (RelationStorage<TRelationKind>) storages[storageIndex];
}
public void Set<TRelationKind>(in Entity entityA, in Entity entityB, TRelationKind relationData) where TRelationKind : unmanaged
{
Lookup<TRelationKind>().Set(entityA, entityB, relationData);
}
public TRelationKind Get<TRelationKind>(in Entity entityA, in Entity entityB) where TRelationKind : unmanaged
{
return Lookup<TRelationKind>().Get(entityA, entityB);
}
public (bool, bool) Remove<TRelationKind>(in Entity entityA, in Entity entityB) where TRelationKind : unmanaged
{
return Lookup<TRelationKind>().Remove(entityA, entityB);
}
public void UnrelateAll<TRelationKind>(int entityID) where TRelationKind : unmanaged
{
Lookup<TRelationKind>().UnrelateAll(entityID);
}
public ReverseSpanEnumerator<(Entity, Entity)> Relations<TRelationKind>() where TRelationKind : unmanaged
{
return Lookup<TRelationKind>().All();
}
public bool Related<TRelationKind>(int idA, int idB) where TRelationKind : unmanaged
{
return Lookup<TRelationKind>().Has((idA, idB));
}
public ReverseSpanEnumerator<Entity> OutRelations<TRelationKind>(int entityID) where TRelationKind : unmanaged
{
return Lookup<TRelationKind>().OutRelations(entityID);
}
public Entity OutRelationSingleton<TRelationKind>(int entityID) where TRelationKind : unmanaged
{
return Lookup<TRelationKind>().OutFirst(entityID);
}
public Entity NthOutRelation<TRelationKind>(int entityID, int n) where TRelationKind : unmanaged
{
return Lookup<TRelationKind>().OutNth(entityID, n);
}
public int OutRelationCount<TRelationKind>(int entityID) where TRelationKind : unmanaged
{
return Lookup<TRelationKind>().OutRelationCount(entityID);
}
public bool HasOutRelation<TRelationKind>(int entityID) where TRelationKind : unmanaged
{
return Lookup<TRelationKind>().HasOutRelation(entityID);
}
public ReverseSpanEnumerator<Entity> InRelations<TRelationKind>(int entityID) where TRelationKind : unmanaged
{
return Lookup<TRelationKind>().InRelations(entityID);
}
public Entity NthInRelation<TRelationKind>(int entityID, int n) where TRelationKind : unmanaged
{
return Lookup<TRelationKind>().InNth(entityID, n);
}
public Entity InRelationSingleton<TRelationKind>(int entityID) where TRelationKind : unmanaged
{
return Lookup<TRelationKind>().InFirst(entityID);
}
public bool HasInRelation<TRelationKind>(int entityID) where TRelationKind : unmanaged
{
return Lookup<TRelationKind>().HasInRelation(entityID);
}
public int InRelationCount<TRelationKind>(int entityID) where TRelationKind : unmanaged
{
return Lookup<TRelationKind>().InRelationCount(entityID);
}
// untyped methods used for destroying and snapshots
public unsafe void Set(int entityA, int entityB, int relationTypeIndex, void* relationData)
{
storages[relationTypeIndex].Set(entityA, entityB, relationData);
}
public void UnrelateAll(int entityID, int relationTypeIndex)
{
storages[relationTypeIndex].UnrelateAll(entityID);
}
public void Clear()
{
for (var i = 0; i < storages.Length; i += 1)
{
if (storages[i] != null)
{
storages[i].Clear();
}
}
}
public void CreateMissingStorages(RelationDepot other)
{
while (other.RelationTypeIndices.Count >= storages.Length)
{
Array.Resize(ref storages, storages.Length * 2);
}
while (other.RelationTypeIndices.Count >= other.storages.Length)
{
Array.Resize(ref other.storages, other.storages.Length * 2);
}
for (var i = 0; i < other.RelationTypeIndices.Count; i += 1)
{
if (storages[i] == null && other.storages[i] != null)
{
storages[i] = other.storages[i].CreateStorage();
}
}
}
public unsafe void TransferStorage(Dictionary<int, int> worldToTransferID, RelationDepot other)
{
for (var i = 0; i < storages.Length; i += 1)
{
if (storages[i] != null)
{
foreach (var (a, b) in storages[i].All())
{
if (worldToTransferID.TryGetValue(a, out var otherA))
{
if (worldToTransferID.TryGetValue(b, out var otherB))
{
var storageIndex = storages[i].GetStorageIndex(a, b);
var relationData = storages[i].Get(storageIndex);
other.Set(otherA, otherB, i, relationData);
other.EntityStorage.AddRelationKind(otherA, i);
other.EntityStorage.AddRelationKind(otherB, i);
}
else
{
throw new InvalidOperationException($"Missing transfer entity! {EntityStorage.Tag(a.ID)} related to {EntityStorage.Tag(b.ID)}");
}
}
}
}
}
}
}
}

292
src/RelationStorage.cs
View File

@ -1,99 +1,74 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using MoonTools.ECS.Collections;
namespace MoonTools.ECS
namespace MoonTools.ECS;
// TODO: implement this entire class with NativeMemory equivalents, can just memcpy for snapshots
internal class RelationStorage
{
internal abstract class RelationStorage
internal NativeArray Relations;
internal NativeArray RelationDatas;
internal Dictionary<(Entity, Entity), int> Indices = new Dictionary<(Entity, Entity), int>(16);
internal Dictionary<Entity, IndexableSet<Entity>> OutRelationSets = new Dictionary<Entity, IndexableSet<Entity>>(16);
internal Dictionary<Entity, IndexableSet<Entity>> InRelationSets = new Dictionary<Entity, IndexableSet<Entity>>(16);
private Stack<IndexableSet<Entity>> ListPool = new Stack<IndexableSet<Entity>>();
private bool IsDisposed;
public RelationStorage(int relationDataSize)
{
public abstract unsafe void Set(int entityA, int entityB, void* relationData);
public abstract int GetStorageIndex(int entityA, int entityB);
public abstract unsafe void* Get(int relationStorageIndex);
public abstract void UnrelateAll(int entityID);
public abstract ReverseSpanEnumerator<(Entity, Entity)> All();
public abstract RelationStorage CreateStorage();
public abstract void Clear();
Relations = new NativeArray(Unsafe.SizeOf<(Entity, Entity)>());
RelationDatas = new NativeArray(relationDataSize);
}
// Relation is the two entities, A related to B.
// TRelation is the data attached to the relation.
internal unsafe class RelationStorage<TRelation> : RelationStorage, IDisposable where TRelation : unmanaged
public ReverseSpanEnumerator<(Entity, Entity)> All()
{
private int count = 0;
private int capacity = 16;
private (Entity, Entity)* relations;
private TRelation* relationDatas;
private Dictionary<(Entity, Entity), int> indices = new Dictionary<(Entity, Entity), int>(16);
private Dictionary<int, IndexableSet<Entity>> outRelations = new Dictionary<int, IndexableSet<Entity>>(16);
private Dictionary<int, IndexableSet<Entity>> inRelations = new Dictionary<int, IndexableSet<Entity>>(16);
private Stack<IndexableSet<Entity>> listPool = new Stack<IndexableSet<Entity>>();
private bool disposed;
public RelationStorage()
{
relations = ((Entity, Entity)*) NativeMemory.Alloc((nuint) (capacity * Unsafe.SizeOf<(Entity, Entity)>()));
relationDatas = (TRelation*) NativeMemory.Alloc((nuint) (capacity * Unsafe.SizeOf<TRelation>()));
return new ReverseSpanEnumerator<(Entity, Entity)>(Relations.ToSpan<(Entity, Entity)>());
}
public override ReverseSpanEnumerator<(Entity, Entity)> All()
{
return new ReverseSpanEnumerator<(Entity, Entity)>(new Span<(Entity, Entity)>(relations, count));
}
public void Set(in Entity entityA, in Entity entityB, TRelation relationData)
public unsafe void Set<T>(in Entity entityA, in Entity entityB, in T relationData) where T : unmanaged
{
var relation = (entityA, entityB);
if (indices.TryGetValue(relation, out var index))
if (Indices.TryGetValue(relation, out var index))
{
relationDatas[index] = relationData;
RelationDatas.Set(index, relationData);
return;
}
var idA = entityA.ID;
var idB = entityB.ID;
if (!outRelations.ContainsKey(idA))
if (!OutRelationSets.ContainsKey(entityA))
{
outRelations[idA] = AcquireHashSetFromPool();
OutRelationSets[entityA] = AcquireHashSetFromPool();
}
outRelations[idA].Add(idB);
OutRelationSets[entityA].Add(entityB);
if (!inRelations.ContainsKey(idB))
if (!InRelationSets.ContainsKey(entityB))
{
inRelations[idB] = AcquireHashSetFromPool();
InRelationSets[entityB] = AcquireHashSetFromPool();
}
inRelations[idB].Add(idA);
InRelationSets[entityB].Add(entityA);
if (count >= capacity)
{
capacity *= 2;
relations = ((Entity, Entity)*) NativeMemory.Realloc(relations, (nuint) (capacity * Unsafe.SizeOf<(Entity, Entity)>()));
relationDatas = (TRelation*) NativeMemory.Realloc(relationDatas, (nuint) (capacity * Unsafe.SizeOf<TRelation>()));
Relations.Append(relation);
RelationDatas.Append(relationData);
Indices.Add(relation, Relations.Count - 1);
}
relations[count] = relation;
relationDatas[count] = relationData;
indices.Add(relation, count);
count += 1;
public ref T Get<T>(in Entity entityA, in Entity entityB) where T : unmanaged
{
var relationIndex = Indices[(entityA, entityB)];
return ref RelationDatas.Get<T>(relationIndex);
}
public TRelation Get(in Entity entityA, in Entity entityB)
public bool Has(Entity entityA, Entity entityB)
{
return relationDatas[indices[(entityA, entityB)]];
return Indices.ContainsKey((entityA, entityB));
}
public bool Has((Entity, Entity) relation)
public ReverseSpanEnumerator<Entity> OutRelations(Entity Entity)
{
return indices.ContainsKey(relation);
}
public ReverseSpanEnumerator<Entity> OutRelations(int entityID)
{
if (outRelations.TryGetValue(entityID, out var entityOutRelations))
if (OutRelationSets.TryGetValue(Entity, out var entityOutRelations))
{
return entityOutRelations.GetEnumerator();
}
@ -103,35 +78,35 @@ namespace MoonTools.ECS
}
}
public Entity OutFirst(int entityID)
public Entity OutFirst(Entity Entity)
{
return OutNth(entityID, 0);
return OutNth(Entity, 0);
}
public Entity OutNth(int entityID, int n)
public Entity OutNth(Entity Entity, int n)
{
#if DEBUG
if (!outRelations.ContainsKey(entityID) || outRelations[entityID].Count == 0)
if (!OutRelationSets.ContainsKey(Entity) || OutRelationSets[Entity].Count == 0)
{
throw new KeyNotFoundException("No out relations to this entity!");
}
#endif
return outRelations[entityID][n];
return OutRelationSets[Entity][n];
}
public bool HasOutRelation(int entityID)
public bool HasOutRelation(Entity Entity)
{
return outRelations.ContainsKey(entityID) && outRelations[entityID].Count > 0;
return OutRelationSets.ContainsKey(Entity) && OutRelationSets[Entity].Count > 0;
}
public int OutRelationCount(int entityID)
public int OutRelationCount(Entity Entity)
{
return outRelations.TryGetValue(entityID, out var entityOutRelations) ? entityOutRelations.Count : 0;
return OutRelationSets.TryGetValue(Entity, out var entityOutRelations) ? entityOutRelations.Count : 0;
}
public ReverseSpanEnumerator<Entity> InRelations(int entityID)
public ReverseSpanEnumerator<Entity> InRelations(Entity Entity)
{
if (inRelations.TryGetValue(entityID, out var entityInRelations))
if (InRelationSets.TryGetValue(Entity, out var entityInRelations))
{
return entityInRelations.GetEnumerator();
}
@ -141,31 +116,31 @@ namespace MoonTools.ECS
}
}
public Entity InFirst(int entityID)
public Entity InFirst(Entity Entity)
{
return InNth(entityID, 0);
return InNth(Entity, 0);
}
public Entity InNth(int entityID, int n)
public Entity InNth(Entity Entity, int n)
{
#if DEBUG
if (!inRelations.ContainsKey(entityID) || inRelations[entityID].Count == 0)
if (!InRelationSets.ContainsKey(Entity) || InRelationSets[Entity].Count == 0)
{
throw new KeyNotFoundException("No in relations to this entity!");
}
#endif
return inRelations[entityID][n];
return InRelationSets[Entity][n];
}
public bool HasInRelation(int entityID)
public bool HasInRelation(Entity Entity)
{
return inRelations.ContainsKey(entityID) && inRelations[entityID].Count > 0;
return InRelationSets.ContainsKey(Entity) && InRelationSets[Entity].Count > 0;
}
public int InRelationCount(int entityID)
public int InRelationCount(Entity Entity)
{
return inRelations.TryGetValue(entityID, out var entityInRelations) ? entityInRelations.Count : 0;
return InRelationSets.TryGetValue(Entity, out var entityInRelations) ? entityInRelations.Count : 0;
}
public (bool, bool) Remove(in Entity entityA, in Entity entityB)
@ -174,153 +149,131 @@ namespace MoonTools.ECS
var bEmpty = false;
var relation = (entityA, entityB);
if (outRelations.TryGetValue(entityA.ID, out var entityOutRelations))
if (OutRelationSets.TryGetValue(entityA, out var entityOutRelations))
{
entityOutRelations.Remove(entityB.ID);
if (outRelations[entityA.ID].Count == 0)
entityOutRelations.Remove(entityB);
if (OutRelationSets[entityA].Count == 0)
{
aEmpty = true;
}
}
if (inRelations.TryGetValue(entityB.ID, out var entityInRelations))
if (InRelationSets.TryGetValue(entityB, out var entityInRelations))
{
entityInRelations.Remove(entityA.ID);
if (inRelations[entityB.ID].Count == 0)
entityInRelations.Remove(entityA);
if (InRelationSets[entityB].Count == 0)
{
bEmpty = true;
}
}
if (indices.TryGetValue(relation, out var index))
if (Indices.TryGetValue(relation, out var index))
{
var lastElementIndex = count - 1;
var lastElementIndex = Relations.Count - 1;
// move an element into the hole
if (index != lastElementIndex)
{
var lastRelation = relations[lastElementIndex];
indices[lastRelation] = index;
relationDatas[index] = relationDatas[lastElementIndex];
relations[index] = lastRelation;
var lastRelation = Relations.Get<(Entity, Entity)>(lastElementIndex);
Indices[lastRelation] = index;
}
count -= 1;
indices.Remove(relation);
RelationDatas.Delete(index);
Relations.Delete(index);
Indices.Remove(relation);
}
return (aEmpty, bEmpty);
}
private IndexableSet<Entity> AcquireHashSetFromPool()
public void RemoveEntity(in Entity entity)
{
if (listPool.Count == 0)
if (OutRelationSets.TryGetValue(entity, out var entityOutRelations))
{
listPool.Push(new IndexableSet<Entity>());
foreach (var entityB in entityOutRelations)
{
Remove(entity, entityB);
}
return listPool.Pop();
ReturnHashSetToPool(entityOutRelations);
OutRelationSets.Remove(entity);
}
if (InRelationSets.TryGetValue(entity, out var entityInRelations))
{
foreach (var entityA in entityInRelations)
{
Remove(entityA, entity);
}
ReturnHashSetToPool(entityInRelations);
InRelationSets.Remove(entity);
}
}
internal IndexableSet<Entity> AcquireHashSetFromPool()
{
if (ListPool.Count == 0)
{
ListPool.Push(new IndexableSet<Entity>());
}
return ListPool.Pop();
}
private void ReturnHashSetToPool(IndexableSet<Entity> hashSet)
{
hashSet.Clear();
listPool.Push(hashSet);
ListPool.Push(hashSet);
}
// untyped methods used for internal implementation
public override unsafe void Set(int entityA, int entityB, void* relationData)
public void Clear()
{
Set(entityA, entityB, *(TRelation*) relationData);
}
Indices.Clear();
public override int GetStorageIndex(int entityA, int entityB)
{
return indices[(entityA, entityB)];
}
public override unsafe void* Get(int relationStorageIndex)
{
return &relationDatas[relationStorageIndex];
}
public override void UnrelateAll(int entityID)
{
if (outRelations.TryGetValue(entityID, out var entityOutRelations))
{
foreach (var entityB in entityOutRelations)
{
Remove(entityID, entityB);
}
ReturnHashSetToPool(entityOutRelations);
outRelations.Remove(entityID);
}
if (inRelations.TryGetValue(entityID, out var entityInRelations))
{
foreach (var entityA in entityInRelations)
{
Remove(entityA, entityID);
}
ReturnHashSetToPool(entityInRelations);
inRelations.Remove(entityID);
}
}
public override RelationStorage<TRelation> CreateStorage()
{
return new RelationStorage<TRelation>();
}
public override void Clear()
{
count = 0;
indices.Clear();
foreach (var set in inRelations.Values)
foreach (var set in InRelationSets.Values)
{
ReturnHashSetToPool(set);
}
inRelations.Clear();
InRelationSets.Clear();
foreach (var set in outRelations.Values)
foreach (var set in OutRelationSets.Values)
{
ReturnHashSetToPool(set);
}
outRelations.Clear();
OutRelationSets.Clear();
Relations.Clear();
RelationDatas.Clear();
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
if (!IsDisposed)
{
Clear();
if (disposing)
{
foreach (var set in listPool)
foreach (var set in ListPool)
{
set.Dispose();
}
Relations.Dispose();
RelationDatas.Dispose();
}
NativeMemory.Free(relations);
NativeMemory.Free(relationDatas);
relations = null;
relationDatas = null;
disposed = true;
IsDisposed = true;
}
}
~RelationStorage()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: false);
}
// ~RelationStorage()
// {
// // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
// Dispose(disposing: false);
// }
public void Dispose()
{
@ -328,5 +281,4 @@ namespace MoonTools.ECS
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}
}

7
src/Renderer.cs
View File

@ -1,7 +1,6 @@
namespace MoonTools.ECS
namespace MoonTools.ECS;
public abstract class Renderer : EntityComponentReader
{
public abstract class Renderer : EntityComponentReader
{
public Renderer(World world) : base(world) { }
}
}

384
src/Snapshot.cs Normal file
View File

@ -0,0 +1,384 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using MoonTools.ECS.Collections;
namespace MoonTools.ECS;
// TODO: we should implement a NativeDictionary that can be memcopied
public class Snapshot : IDisposable
{
private Dictionary<TypeId, ComponentSnapshot> ComponentSnapshots = new Dictionary<TypeId, ComponentSnapshot>();
private Dictionary<FilterSignature, List<Entity>> Filters = new Dictionary<FilterSignature, List<Entity>>();
private Dictionary<TypeId, RelationSnapshot> RelationSnapshots =
new Dictionary<TypeId, RelationSnapshot>();
private Dictionary<Entity, IndexableSet<TypeId>> EntityRelationIndex =
new Dictionary<Entity, IndexableSet<TypeId>>();
private Dictionary<Entity, IndexableSet<TypeId>> EntityComponentIndex =
new Dictionary<Entity, IndexableSet<TypeId>>();
private Dictionary<Entity, string> EntityTags = new Dictionary<Entity, string>();
private IdAssigner EntityIdAssigner = new IdAssigner();
private bool IsDisposed;
public void Restore(World world)
{
// restore id assigner state
EntityIdAssigner.CopyTo(world.EntityIdAssigner);
// restore filter states
// this could be sped up if we figured out a direct IndexableSet copy
foreach (var (signature, entityList) in Filters)
{
var filter = world.FilterIndex[signature];
filter.Clear();
foreach (var entity in entityList)
{
filter.AddEntity(entity);
}
}
// clear all component storages in case any were created after snapshot
// FIXME: this can be eliminated via component discovery
foreach (var (typeId, componentStorage) in world.ComponentIndex)
{
componentStorage.Clear();
}
// clear all relation storages in case any were created after snapshot
// FIXME: this can be eliminated via component discovery
foreach (var (typeId, relationStorage) in world.RelationIndex)
{
relationStorage.Clear();
}
// restore components
foreach (var (typeId, componentSnapshot) in ComponentSnapshots)
{
var componentStorage = world.ComponentIndex[typeId];
componentSnapshot.Restore(componentStorage);
}
// restore relation state
foreach (var (typeId, relationSnapshot) in RelationSnapshots)
{
var relationStorage = world.RelationIndex[typeId];
relationSnapshot.Restore(relationStorage);
}
// restore entity relation index state
// FIXME: arghhhh this is so slow
foreach (var (id, relationTypeSet) in world.EntityRelationIndex)
{
relationTypeSet.Clear();
}
foreach (var (id, relationTypeSet) in EntityRelationIndex)
{
foreach (var typeId in relationTypeSet)
{
world.EntityRelationIndex[id].Add(typeId);
}
}
// restore entity component index state
// FIXME: arrghghhh this is so slow
foreach (var (id, componentTypeSet) in world.EntityComponentIndex)
{
componentTypeSet.Clear();
}
foreach (var (id, componentTypeSet) in EntityComponentIndex)
{
foreach (var typeId in componentTypeSet)
{
world.EntityComponentIndex[id].Add(typeId);
}
}
// restore entity tags
foreach (var (id, s) in EntityTags)
{
world.EntityTags[id] = s;
}
}
public void Take(World world)
{
// copy id assigner state
world.EntityIdAssigner.CopyTo(EntityIdAssigner);
// copy filter states
foreach (var (_, filter) in world.FilterIndex)
{
TakeFilterSnapshot(filter);
}
// copy components
foreach (var (typeId, componentStorage) in world.ComponentIndex)
{
TakeComponentSnapshot(typeId, componentStorage);
}
// copy relations
foreach (var (typeId, relationStorage) in world.RelationIndex)
{
TakeRelationSnapshot(typeId, relationStorage);
}
// copy entity relation index
// FIXME: arghhhh this is so slow
foreach (var (id, relationTypeSet) in world.EntityRelationIndex)
{
if (!EntityRelationIndex.ContainsKey(id))
{
EntityRelationIndex.Add(id, new IndexableSet<TypeId>());
}
EntityRelationIndex[id].Clear();
foreach (var typeId in relationTypeSet)
{
EntityRelationIndex[id].Add(typeId);
}
}
// copy entity component index
// FIXME: arghhhh this is so slow
foreach (var (id, componentTypeSet) in world.EntityComponentIndex)
{
if (!EntityComponentIndex.ContainsKey(id))
{
EntityComponentIndex.Add(id, new IndexableSet<TypeId>());
}
EntityComponentIndex[id].Clear();
foreach (var typeId in componentTypeSet)
{
EntityComponentIndex[id].Add(typeId);
}
}
// copy entity tags
foreach (var (id, s) in world.EntityTags)
{
EntityTags[id] = s;
}
}
private void TakeFilterSnapshot(Filter filter)
{
if (!Filters.TryGetValue(filter.Signature, out var entities))
{
entities = new List<Entity>();
Filters.Add(filter.Signature, entities);
}
entities.Clear();
foreach (var entity in filter.EntitySet.AsSpan())
{
entities.Add(entity);
}
}
private void TakeComponentSnapshot(TypeId typeId, ComponentStorage componentStorage)
{
if (!ComponentSnapshots.TryGetValue(typeId, out var componentSnapshot))
{
componentSnapshot = new ComponentSnapshot(componentStorage.Components.ElementSize);
ComponentSnapshots.Add(typeId, componentSnapshot);
}
componentSnapshot.Take(componentStorage);
}
private void TakeRelationSnapshot(TypeId typeId, RelationStorage relationStorage)
{
if (!RelationSnapshots.TryGetValue(typeId, out var snapshot))
{
snapshot = new RelationSnapshot(relationStorage.RelationDatas.ElementSize);
RelationSnapshots.Add(typeId, snapshot);
}
snapshot.Take(relationStorage);
}
private class ComponentSnapshot : IDisposable
{
private readonly NativeArray Components;
private readonly NativeArray<Entity> EntityIDs;
private bool IsDisposed;
public ComponentSnapshot(int elementSize)
{
Components = new NativeArray(elementSize);
EntityIDs = new NativeArray<Entity>();
}
public void Take(ComponentStorage componentStorage)
{
componentStorage.Components.CopyAllTo(Components);
componentStorage.EntityIDs.CopyTo(EntityIDs);
}
public void Restore(ComponentStorage componentStorage)
{
Components.CopyAllTo(componentStorage.Components);
EntityIDs.CopyTo(componentStorage.EntityIDs);
componentStorage.EntityIDToStorageIndex.Clear();
for (int i = 0; i < EntityIDs.Count; i += 1)
{
var entityID = EntityIDs[i];
componentStorage.EntityIDToStorageIndex[entityID] = i;
}
}
protected virtual void Dispose(bool disposing)
{
if (!IsDisposed)
{
if (disposing)
{
Components.Dispose();
EntityIDs.Dispose();
}
IsDisposed = true;
}
}
public void Dispose()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}
private class RelationSnapshot : IDisposable
{
private NativeArray Relations;
private NativeArray RelationDatas;
private bool IsDisposed;
public RelationSnapshot(int elementSize)
{
Relations = new NativeArray(Unsafe.SizeOf<(Entity, Entity)>());
RelationDatas = new NativeArray(elementSize);
}
public void Take(RelationStorage relationStorage)
{
relationStorage.Relations.CopyAllTo(Relations);
relationStorage.RelationDatas.CopyAllTo(RelationDatas);
}
public void Restore(RelationStorage relationStorage)
{
relationStorage.Clear();
Relations.CopyAllTo(relationStorage.Relations);
RelationDatas.CopyAllTo(relationStorage.RelationDatas);
for (int index = 0; index < Relations.Count; index += 1)
{
var relation = Relations.Get<(Entity, Entity)>(index);
relationStorage.Indices[relation] = index;
relationStorage.Indices[relation] = index;
if (!relationStorage.OutRelationSets.ContainsKey(relation.Item1))
{
relationStorage.OutRelationSets[relation.Item1] =
relationStorage.AcquireHashSetFromPool();
}
relationStorage.OutRelationSets[relation.Item1].Add(relation.Item2);
if (!relationStorage.InRelationSets.ContainsKey(relation.Item2))
{
relationStorage.InRelationSets[relation.Item2] =
relationStorage.AcquireHashSetFromPool();
}
relationStorage.InRelationSets[relation.Item2].Add(relation.Item1);
}
}
protected virtual void Dispose(bool disposing)
{
if (!IsDisposed)
{
if (disposing)
{
Relations.Dispose();
RelationDatas.Dispose();
}
IsDisposed = true;
}
}
public void Dispose()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}
protected virtual void Dispose(bool disposing)
{
if (!IsDisposed)
{
if (disposing)
{
foreach (var componentSnapshot in ComponentSnapshots.Values)
{
componentSnapshot.Dispose();
}
foreach (var relationSnapshot in RelationSnapshots.Values)
{
relationSnapshot.Dispose();
}
foreach (var componentSet in EntityComponentIndex.Values)
{
componentSet.Dispose();
}
foreach (var relationSet in EntityRelationIndex.Values)
{
relationSet.Dispose();
}
EntityIdAssigner.Dispose();
}
IsDisposed = true;
}
}
public void Dispose()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}

50
src/System.cs
View File

@ -1,47 +1,15 @@
using System;
namespace MoonTools.ECS
namespace MoonTools.ECS;
public abstract class System : Manipulator
{
public abstract class System : Manipulator
{
internal MessageDepot MessageDepot => World.MessageDepot;
protected System(World world) : base(world) { }
public System(World world) : base(world) { }
public abstract void Update();
public abstract void Update(TimeSpan delta);
protected ReadOnlySpan<TMessage> ReadMessages<TMessage>() where TMessage : unmanaged
{
return MessageDepot.All<TMessage>();
}
protected TMessage ReadMessage<TMessage>() where TMessage : unmanaged
{
return MessageDepot.First<TMessage>();
}
protected bool SomeMessage<TMessage>() where TMessage : unmanaged
{
return MessageDepot.Some<TMessage>();
}
protected ReverseSpanEnumerator<TMessage> ReadMessagesWithEntity<TMessage>(in Entity entity) where TMessage : unmanaged
{
return MessageDepot.WithEntity<TMessage>(entity.ID);
}
protected ref readonly TMessage ReadMessageWithEntity<TMessage>(in Entity entity) where TMessage : unmanaged
{
return ref MessageDepot.FirstWithEntity<TMessage>(entity.ID);
}
protected bool SomeMessageWithEntity<TMessage>(in Entity entity) where TMessage : unmanaged
{
return MessageDepot.SomeWithEntity<TMessage>(entity.ID);
}
protected void Send<TMessage>(in TMessage message) where TMessage : unmanaged => World.Send(message);
protected void Send<TMessage>(in Entity entity, in TMessage message) where TMessage : unmanaged => World.Send(entity, message);
}
protected ReadOnlySpan<T> ReadMessages<T>() where T : unmanaged => World.ReadMessages<T>();
protected T ReadMessage<T>() where T : unmanaged => World.ReadMessage<T>();
protected bool SomeMessage<T>() where T : unmanaged => World.SomeMessage<T>();
protected void Send<T>(T message) where T : unmanaged => World.Send(message);
}

11
src/TypeId.cs Normal file
View File

@ -0,0 +1,11 @@
using System;
namespace MoonTools.ECS;
public readonly record struct TypeId(uint Value) : IComparable<TypeId>
{
public int CompareTo(TypeId other)
{
return Value.CompareTo(other.Value);
}
}

33
src/TypeIndices.cs
View File

@ -1,33 +0,0 @@
using System;
using System.Collections.Generic;
namespace MoonTools.ECS
{
public class TypeIndices
{
Dictionary<Type, int> TypeToIndex = new Dictionary<Type, int>();
int nextID = 0;
public int Count => TypeToIndex.Count;
public int GetIndex<T>() where T : unmanaged
{
if (!TypeToIndex.ContainsKey(typeof(T)))
{
TypeToIndex.Add(typeof(T), nextID);
nextID += 1;
}
return TypeToIndex[typeof(T)];
}
public int GetIndex(Type type)
{
return TypeToIndex[type];
}
#if DEBUG
public Dictionary<Type, int>.KeyCollection Types => TypeToIndex.Keys;
#endif
}
}

614
src/World.cs
View File

@ -1,194 +1,520 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using MoonTools.ECS.Collections;
namespace MoonTools.ECS
namespace MoonTools.ECS;
public class World : IDisposable
{
public class World
{
internal readonly static TypeIndices ComponentTypeIndices = new TypeIndices();
internal readonly static TypeIndices RelationTypeIndices = new TypeIndices();
internal readonly EntityStorage EntityStorage = new EntityStorage();
internal readonly ComponentDepot ComponentDepot;
internal readonly MessageDepot MessageDepot = new MessageDepot();
internal readonly RelationDepot RelationDepot;
internal readonly FilterStorage FilterStorage;
public FilterBuilder FilterBuilder => new FilterBuilder(FilterStorage, ComponentTypeIndices);
// Get TypeId from a Type
private readonly Dictionary<Type, TypeId> TypeToId = new Dictionary<Type, TypeId>();
public World()
#if DEBUG
private Dictionary<TypeId, Type> IdToType = new Dictionary<TypeId, Type>();
#endif
// Get element size from a TypeId
private readonly Dictionary<TypeId, int> ElementSizes = new Dictionary<TypeId, int>();
// Filters
internal readonly Dictionary<FilterSignature, Filter> FilterIndex = new Dictionary<FilterSignature, Filter>();
private readonly Dictionary<TypeId, List<Filter>> TypeToFilter = new Dictionary<TypeId, List<Filter>>();
// TODO: can we make the tag an native array of chars at some point?
internal Dictionary<Entity, string> EntityTags = new Dictionary<Entity, string>();
// Relation Storages
internal Dictionary<TypeId, RelationStorage> RelationIndex = new Dictionary<TypeId, RelationStorage>();
internal Dictionary<Entity, IndexableSet<TypeId>> EntityRelationIndex = new Dictionary<Entity, IndexableSet<TypeId>>();
// Message Storages
private Dictionary<TypeId, MessageStorage> MessageIndex = new Dictionary<TypeId, MessageStorage>();
public FilterBuilder FilterBuilder => new FilterBuilder(this);
internal readonly Dictionary<TypeId, ComponentStorage> ComponentIndex = new Dictionary<TypeId, ComponentStorage>();
internal Dictionary<Entity, IndexableSet<TypeId>> EntityComponentIndex = new Dictionary<Entity, IndexableSet<TypeId>>();
internal IdAssigner EntityIdAssigner = new IdAssigner();
private IdAssigner TypeIdAssigner = new IdAssigner();
private bool IsDisposed;
internal TypeId GetTypeId<T>() where T : unmanaged
{
ComponentDepot = new ComponentDepot(ComponentTypeIndices);
RelationDepot = new RelationDepot(EntityStorage, RelationTypeIndices);
FilterStorage = new FilterStorage(EntityStorage, ComponentTypeIndices);
if (TypeToId.ContainsKey(typeof(T)))
{
return TypeToId[typeof(T)];
}
var typeId = new TypeId(TypeIdAssigner.Assign());
TypeToId.Add(typeof(T), typeId);
ElementSizes.Add(typeId, Unsafe.SizeOf<T>());
#if DEBUG
IdToType.Add(typeId, typeof(T));
#endif
return typeId;
}
internal TypeId GetComponentTypeId<T>() where T : unmanaged
{
var typeId = GetTypeId<T>();
if (ComponentIndex.TryGetValue(typeId, out var componentStorage))
{
return typeId;
}
componentStorage = new ComponentStorage(typeId, ElementSizes[typeId]);
ComponentIndex.Add(typeId, componentStorage);
TypeToFilter.Add(typeId, new List<Filter>());
return typeId;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private ComponentStorage GetComponentStorage<T>() where T : unmanaged
{
var typeId = GetTypeId<T>();
if (ComponentIndex.TryGetValue(typeId, out var componentStorage))
{
return componentStorage;
}
componentStorage = new ComponentStorage(typeId, ElementSizes[typeId]);
ComponentIndex.Add(typeId, componentStorage);
TypeToFilter.Add(typeId, new List<Filter>());
return componentStorage;
}
// FILTERS
internal Filter GetFilter(FilterSignature signature)
{
if (!FilterIndex.TryGetValue(signature, out var filter))
{
filter = new Filter(this, signature);
foreach (var typeId in signature.Included)
{
TypeToFilter[typeId].Add(filter);
}
foreach (var typeId in signature.Excluded)
{
TypeToFilter[typeId].Add(filter);
}
FilterIndex.Add(signature, filter);
}
return filter;
}
// ENTITIES
public Entity CreateEntity(string tag = "")
{
return EntityStorage.Create(tag);
var entity = new Entity(EntityIdAssigner.Assign());
if (!EntityComponentIndex.ContainsKey(entity))
{
EntityRelationIndex.Add(entity, new IndexableSet<TypeId>());
EntityComponentIndex.Add(entity, new IndexableSet<TypeId>());
}
EntityTags[entity] = tag;
return entity;
}
public void Tag(Entity entity, string tag)
{
EntityStorage.Tag(entity, tag);
EntityTags[entity] = tag;
}
public string GetTag(Entity entity)
{
return EntityStorage.Tag(entity);
}
public void Set<TComponent>(Entity entity, in TComponent component) where TComponent : unmanaged
{
#if DEBUG
// check for use after destroy
if (!EntityStorage.Exists(entity))
{
throw new InvalidOperationException("This entity is not valid!");
}
#endif
ComponentDepot.Set<TComponent>(entity.ID, component);
if (EntityStorage.SetComponent(entity.ID, ComponentTypeIndices.GetIndex<TComponent>()))
{
FilterStorage.Check<TComponent>(entity.ID);
}
}
// untyped version for Transfer
// no filter check because filter state is copied directly
internal unsafe void Set(Entity entity, int componentTypeIndex, void* component)
{
ComponentDepot.Set(entity.ID, componentTypeIndex, component);
EntityStorage.SetComponent(entity.ID, componentTypeIndex);
}
public void Remove<TComponent>(in Entity entity) where TComponent : unmanaged
{
if (EntityStorage.RemoveComponent(entity.ID, ComponentTypeIndices.GetIndex<TComponent>()))
{
// Run filter storage update first so that the entity state is still valid in the remove callback.
FilterStorage.Check<TComponent>(entity.ID);
ComponentDepot.Remove<TComponent>(entity.ID);
}
}
public void Relate<TRelationKind>(in Entity entityA, in Entity entityB, TRelationKind relationData) where TRelationKind : unmanaged
{
RelationDepot.Set(entityA, entityB, relationData);
var relationTypeIndex = RelationTypeIndices.GetIndex<TRelationKind>();
EntityStorage.AddRelationKind(entityA.ID, relationTypeIndex);
EntityStorage.AddRelationKind(entityB.ID, relationTypeIndex);
}
public void Unrelate<TRelationKind>(in Entity entityA, in Entity entityB) where TRelationKind : unmanaged
{
var (aEmpty, bEmpty) = RelationDepot.Remove<TRelationKind>(entityA, entityB);
if (aEmpty)
{
EntityStorage.RemoveRelation(entityA.ID, RelationTypeIndices.GetIndex<TRelationKind>());
}
if (bEmpty)
{
EntityStorage.RemoveRelation(entityB.ID, RelationTypeIndices.GetIndex<TRelationKind>());
}
}
public void UnrelateAll<TRelationKind>(in Entity entity) where TRelationKind : unmanaged
{
RelationDepot.UnrelateAll<TRelationKind>(entity.ID);
EntityStorage.RemoveRelation(entity.ID, RelationTypeIndices.GetIndex<TRelationKind>());
}
public void Send<TMessage>(in TMessage message) where TMessage : unmanaged
{
MessageDepot.Add(message);
}
public void Send<TMessage>(in Entity entity, in TMessage message) where TMessage : unmanaged
{
MessageDepot.Add(entity.ID, message);
return EntityTags[entity];
}
public void Destroy(in Entity entity)
{
foreach (var componentTypeIndex in EntityStorage.ComponentTypeIndices(entity.ID))
// remove all components from storages
foreach (var componentTypeIndex in EntityComponentIndex[entity])
{
// Run filter storage update first so that the entity state is still valid in the remove callback.
FilterStorage.RemoveEntity(entity.ID, componentTypeIndex);
ComponentDepot.Remove(entity.ID, componentTypeIndex);
}
var componentStorage = ComponentIndex[componentTypeIndex];
componentStorage.Remove(entity);
foreach (var relationTypeIndex in EntityStorage.RelationTypeIndices(entity.ID))
foreach (var filter in TypeToFilter[componentTypeIndex])
{
RelationDepot.UnrelateAll(entity.ID, relationTypeIndex);
EntityStorage.RemoveRelation(entity.ID, relationTypeIndex);
filter.RemoveEntity(entity);
}
}
EntityStorage.Destroy(entity);
// remove all relations from storage
foreach (var relationTypeIndex in EntityRelationIndex[entity])
{
var relationStorage = RelationIndex[relationTypeIndex];
relationStorage.RemoveEntity(entity);
}
EntityComponentIndex[entity].Clear();
EntityRelationIndex[entity].Clear();
// recycle ID
EntityIdAssigner.Unassign(entity.ID);
}
// COMPONENTS
public bool Has<T>(in Entity entity) where T : unmanaged
{
var storage = GetComponentStorage<T>();
return storage.Has(entity);
}
internal bool Has(in Entity entity, in TypeId typeId)
{
return EntityComponentIndex[entity].Contains(typeId);
}
public bool Some<T>() where T : unmanaged
{
var storage = GetComponentStorage<T>();
return storage.Any();
}
public ref T Get<T>(in Entity entity) where T : unmanaged
{
var storage = GetComponentStorage<T>();
return ref storage.Get<T>(entity);
}
public ref T GetSingleton<T>() where T : unmanaged
{
var storage = GetComponentStorage<T>();
return ref storage.GetFirst<T>();
}
public Entity GetSingletonEntity<T>() where T : unmanaged
{
var storage = GetComponentStorage<T>();
return storage.FirstEntity();
}
public void Set<T>(in Entity entity, in T component) where T : unmanaged
{
var componentStorage = GetComponentStorage<T>();
if (!componentStorage.Set(entity, component))
{
EntityComponentIndex[entity].Add(componentStorage.TypeId);
foreach (var filter in TypeToFilter[componentStorage.TypeId])
{
filter.Check(entity);
}
}
}
public void Remove<T>(in Entity entity) where T : unmanaged
{
var componentStorage = GetComponentStorage<T>();
if (componentStorage.Remove(entity))
{
EntityComponentIndex[entity].Remove(componentStorage.TypeId);
foreach (var filter in TypeToFilter[componentStorage.TypeId])
{
filter.Check(entity);
}
}
}
// RELATIONS
private RelationStorage RegisterRelationType(TypeId typeId)
{
var relationStorage = new RelationStorage(ElementSizes[typeId]);
RelationIndex.Add(typeId, relationStorage);
return relationStorage;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private RelationStorage GetRelationStorage<T>() where T : unmanaged
{
var typeId = GetTypeId<T>();
if (RelationIndex.TryGetValue(typeId, out var relationStorage))
{
return relationStorage;
}
return RegisterRelationType(typeId);
}
public void Relate<T>(in Entity entityA, in Entity entityB, in T relation) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
relationStorage.Set(entityA, entityB, relation);
EntityRelationIndex[entityA].Add(TypeToId[typeof(T)]);
EntityRelationIndex[entityB].Add(TypeToId[typeof(T)]);
}
public void Unrelate<T>(in Entity entityA, in Entity entityB) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
relationStorage.Remove(entityA, entityB);
}
public void UnrelateAll<T>(in Entity entity) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
relationStorage.RemoveEntity(entity);
}
public bool Related<T>(in Entity entityA, in Entity entityB) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
return relationStorage.Has(entityA, entityB);
}
public T GetRelationData<T>(in Entity entityA, in Entity entityB) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
return relationStorage.Get<T>(entityA, entityB);
}
public ReverseSpanEnumerator<(Entity, Entity)> Relations<T>() where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
return relationStorage.All();
}
public ReverseSpanEnumerator<Entity> OutRelations<T>(Entity entity) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
return relationStorage.OutRelations(entity);
}
public Entity OutRelationSingleton<T>(in Entity entity) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
return relationStorage.OutFirst(entity);
}
public bool HasOutRelation<T>(in Entity entity) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
return relationStorage.HasOutRelation(entity);
}
public int OutRelationCount<T>(in Entity entity) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
return relationStorage.OutRelationCount(entity);
}
public Entity NthOutRelation<T>(in Entity entity, int n) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
return relationStorage.OutNth(entity, n);
}
public ReverseSpanEnumerator<Entity> InRelations<T>(Entity entity) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
return relationStorage.InRelations(entity);
}
public Entity InRelationSingleton<T>(in Entity entity) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
return relationStorage.InFirst(entity);
}
public bool HasInRelation<T>(in Entity entity) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
return relationStorage.HasInRelation(entity);
}
public int InRelationCount<T>(in Entity entity) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
return relationStorage.InRelationCount(entity);
}
public Entity NthInRelation<T>(in Entity entity, int n) where T : unmanaged
{
var relationStorage = GetRelationStorage<T>();
return relationStorage.InNth(entity, n);
}
// MESSAGES
private TypeId GetMessageTypeId<T>() where T : unmanaged
{
var typeId = GetTypeId<T>();
if (!MessageIndex.ContainsKey(typeId))
{
MessageIndex.Add(typeId, new MessageStorage(Unsafe.SizeOf<T>()));
}
return typeId;
}
public void Send<T>(in T message) where T : unmanaged
{
var typeId = GetMessageTypeId<T>();
MessageIndex[typeId].Add(message);
}
public bool SomeMessage<T>() where T : unmanaged
{
var typeId = GetMessageTypeId<T>();
return MessageIndex[typeId].Some();
}
public ReadOnlySpan<T> ReadMessages<T>() where T : unmanaged
{
var typeId = GetMessageTypeId<T>();
return MessageIndex[typeId].All<T>();
}
public T ReadMessage<T>() where T : unmanaged
{
var typeId = GetMessageTypeId<T>();
return MessageIndex[typeId].First<T>();
}
public void ClearMessages<T>() where T : unmanaged
{
var typeId = GetMessageTypeId<T>();
MessageIndex[typeId].Clear();
}
// TODO: temporary component storage?
public void FinishUpdate()
{
MessageDepot.Clear();
}
public void Clear()
foreach (var (_, messageStorage) in MessageIndex)
{
EntityStorage.Clear();
MessageDepot.Clear();
RelationDepot.Clear();
ComponentDepot.Clear();
FilterStorage.Clear();
messageStorage.Clear();
}
}
private Dictionary<int, int> WorldToTransferID = new Dictionary<int, int>();
/// <summary>
/// If you are using the World Transfer feature, call this once after your systems/filters have all been initialized.
/// </summary>
public void PrepareTransferTo(World other)
// DEBUG
// NOTE: these methods are very inefficient
// they should only be used in debugging contexts!!
#if DEBUG
public ComponentTypeEnumerator Debug_GetAllComponentTypes(Entity entity)
{
other.FilterStorage.CreateMissingStorages(FilterStorage);
return new ComponentTypeEnumerator(this, EntityComponentIndex[entity]);
}
// FIXME: there's probably a better way to handle Filters so they are not world-bound
public unsafe void Transfer(World other, Filter filter, Filter otherFilter)
public IEnumerable<Entity> Debug_GetEntities(Type componentType)
{
WorldToTransferID.Clear();
other.ComponentDepot.CreateMissingStorages(ComponentDepot);
other.RelationDepot.CreateMissingStorages(RelationDepot);
var storage = ComponentIndex[TypeToId[componentType]];
return storage.Debug_GetEntities();
}
// destroy all entities matching the filter
foreach (var entity in otherFilter.Entities)
public IEnumerable<Type> Debug_SearchComponentType(string typeString)
{
other.Destroy(entity);
}
// create entities
foreach (var entity in filter.Entities)
foreach (var type in TypeToId.Keys)
{
var otherWorldEntity = other.CreateEntity(GetTag(entity));
WorldToTransferID.Add(entity.ID, otherWorldEntity.ID);
}
// transfer relations
RelationDepot.TransferStorage(WorldToTransferID, other.RelationDepot);
// set components
foreach (var entity in filter.Entities)
if (type.ToString().ToLower().Contains(typeString.ToLower()))
{
var otherWorldEntity = WorldToTransferID[entity.ID];
yield return type;
}
}
}
foreach (var componentTypeIndex in EntityStorage.ComponentTypeIndices(entity.ID))
public ref struct ComponentTypeEnumerator
{
other.Set(otherWorldEntity, componentTypeIndex, ComponentDepot.UntypedGet(entity.ID, componentTypeIndex));
private World World;
private IndexableSet<TypeId> Types;
private int ComponentIndex;
public ComponentTypeEnumerator GetEnumerator() => this;
internal ComponentTypeEnumerator(
World world,
IndexableSet<TypeId> types
)
{
World = world;
Types = types;
ComponentIndex = -1;
}
public bool MoveNext()
{
ComponentIndex += 1;
return ComponentIndex < Types.Count;
}
public Type Current => World.IdToType[Types[ComponentIndex]];
}
#endif
protected virtual void Dispose(bool disposing)
{
if (!IsDisposed)
{
if (disposing)
{
foreach (var componentStorage in ComponentIndex.Values)
{
componentStorage.Dispose();
}
foreach (var relationStorage in RelationIndex.Values)
{
relationStorage.Dispose();
}
foreach (var messageStorage in MessageIndex.Values)
{
messageStorage.Dispose();
}
foreach (var typeSet in EntityComponentIndex.Values)
{
typeSet.Dispose();
}
foreach (var typeSet in EntityRelationIndex.Values)
{
typeSet.Dispose();
}
foreach (var filter in FilterIndex.Values)
{
filter.Dispose();
}
EntityIdAssigner.Dispose();
TypeIdAssigner.Dispose();
}
IsDisposed = true;
}
}
// transfer filters last so callbacks trigger correctly
FilterStorage.TransferStorage(WorldToTransferID, other.FilterStorage);
}
// // TODO: override finalizer only if 'Dispose(bool disposing)' has code to free unmanaged resources
// ~World()
// {
// // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
// Dispose(disposing: false);
// }
public void Dispose()
{
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
}