Eliminating dictionary lookups #7

Merged
cosmonaut merged 3 commits from avoid_dictionaries into main 2023-12-20 23:12:06 +00:00
5 changed files with 229 additions and 182 deletions

View File

@ -10,11 +10,13 @@ internal class ComponentStorage : IDisposable
internal readonly NativeArray Components; internal readonly NativeArray Components;
internal readonly NativeArray<Entity> EntityIDs; internal readonly NativeArray<Entity> EntityIDs;
internal readonly TypeId TypeId; internal readonly TypeId TypeId;
internal readonly int ElementSize;
private bool IsDisposed; private bool IsDisposed;
public ComponentStorage(TypeId typeId, int elementSize) public ComponentStorage(TypeId typeId, int elementSize)
{ {
ElementSize = elementSize;
Components = new NativeArray(elementSize); Components = new NativeArray(elementSize);
EntityIDs = new NativeArray<Entity>(); EntityIDs = new NativeArray<Entity>();
TypeId = typeId; TypeId = typeId;

View File

@ -10,6 +10,7 @@ internal class RelationStorage
{ {
internal NativeArray Relations; internal NativeArray Relations;
internal NativeArray RelationDatas; internal NativeArray RelationDatas;
internal int ElementSize;
internal Dictionary<(Entity, Entity), int> Indices = new Dictionary<(Entity, Entity), int>(16); 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>> OutRelationSets = new Dictionary<Entity, IndexableSet<Entity>>(16);
internal Dictionary<Entity, IndexableSet<Entity>> InRelationSets = new Dictionary<Entity, IndexableSet<Entity>>(16); internal Dictionary<Entity, IndexableSet<Entity>> InRelationSets = new Dictionary<Entity, IndexableSet<Entity>>(16);
@ -19,6 +20,7 @@ internal class RelationStorage
public RelationStorage(int relationDataSize) public RelationStorage(int relationDataSize)
{ {
ElementSize = relationDataSize;
Relations = new NativeArray(Unsafe.SizeOf<(Entity, Entity)>()); Relations = new NativeArray(Unsafe.SizeOf<(Entity, Entity)>());
RelationDatas = new NativeArray(relationDataSize); RelationDatas = new NativeArray(relationDataSize);
} }

View File

@ -8,20 +8,20 @@ namespace MoonTools.ECS;
// TODO: we should implement a NativeDictionary that can be memcopied // TODO: we should implement a NativeDictionary that can be memcopied
public class Snapshot : IDisposable public class Snapshot : IDisposable
{ {
private Dictionary<TypeId, ComponentSnapshot> ComponentSnapshots = new Dictionary<TypeId, ComponentSnapshot>(); private List<ComponentSnapshot> ComponentSnapshots = new List<ComponentSnapshot>();
// FIXME: we could just have a filter ID
private Dictionary<FilterSignature, List<Entity>> Filters = new Dictionary<FilterSignature, List<Entity>>(); private Dictionary<FilterSignature, List<Entity>> Filters = new Dictionary<FilterSignature, List<Entity>>();
private Dictionary<TypeId, RelationSnapshot> RelationSnapshots = private List<RelationSnapshot> RelationSnapshots = new List<RelationSnapshot>();
new Dictionary<TypeId, RelationSnapshot>();
private Dictionary<Entity, IndexableSet<TypeId>> EntityRelationIndex = private List<IndexableSet<TypeId>> EntityRelationIndex =
new Dictionary<Entity, IndexableSet<TypeId>>(); new List<IndexableSet<TypeId>>();
private Dictionary<Entity, IndexableSet<TypeId>> EntityComponentIndex = private List<IndexableSet<TypeId>> EntityComponentIndex =
new Dictionary<Entity, IndexableSet<TypeId>>(); new List<IndexableSet<TypeId>>();
private Dictionary<Entity, string> EntityTags = new Dictionary<Entity, string>(); private List<string> EntityTags = new List<string>();
private IdAssigner EntityIdAssigner = new IdAssigner(); private IdAssigner EntityIdAssigner = new IdAssigner();
@ -48,68 +48,71 @@ public class Snapshot : IDisposable
// clear all component storages in case any were created after snapshot // clear all component storages in case any were created after snapshot
// FIXME: this can be eliminated via component discovery // FIXME: this can be eliminated via component discovery
foreach (var (typeId, componentStorage) in world.ComponentIndex) foreach (var componentStorage in world.ComponentIndex)
{ {
componentStorage.Clear(); componentStorage.Clear();
} }
// clear all relation storages in case any were created after snapshot // clear all relation storages in case any were created after snapshot
// FIXME: this can be eliminated via component discovery // FIXME: this can be eliminated via component discovery
foreach (var (typeId, relationStorage) in world.RelationIndex) foreach (var relationStorage in world.RelationIndex)
{ {
relationStorage.Clear(); relationStorage.Clear();
} }
// restore components for (var i = 0; i < ComponentSnapshots.Count; i += 1)
foreach (var (typeId, componentSnapshot) in ComponentSnapshots)
{ {
var componentStorage = world.ComponentIndex[typeId]; var componentStorage = world.ComponentIndex[i];
componentSnapshot.Restore(componentStorage); ComponentSnapshots[i].Restore(componentStorage);
} }
// restore relation state // restore relation state
foreach (var (typeId, relationSnapshot) in RelationSnapshots) for (var i = 0; i < RelationSnapshots.Count; i += 1)
{ {
var relationStorage = world.RelationIndex[typeId]; var relationStorage = world.RelationIndex[i];
relationSnapshot.Restore(relationStorage); RelationSnapshots[i].Restore(relationStorage);
} }
// restore entity relation index state // restore entity relation index state
// FIXME: arghhhh this is so slow // FIXME: arghhhh this is so slow
foreach (var (id, relationTypeSet) in world.EntityRelationIndex) foreach (var relationTypeSet in world.EntityRelationIndex)
{ {
relationTypeSet.Clear(); relationTypeSet.Clear();
} }
foreach (var (id, relationTypeSet) in EntityRelationIndex) for (var i = 0; i < EntityRelationIndex.Count; i += 1)
{ {
var relationTypeSet = EntityRelationIndex[i];
foreach (var typeId in relationTypeSet) foreach (var typeId in relationTypeSet)
{ {
world.EntityRelationIndex[id].Add(typeId); world.EntityRelationIndex[i].Add(typeId);
} }
} }
// restore entity component index state // restore entity component index state
// FIXME: arrghghhh this is so slow // FIXME: arrghghhh this is so slow
foreach (var (id, componentTypeSet) in world.EntityComponentIndex) foreach (var componentTypeSet in world.EntityComponentIndex)
{ {
componentTypeSet.Clear(); componentTypeSet.Clear();
} }
foreach (var (id, componentTypeSet) in EntityComponentIndex) for (var i = 0; i < EntityComponentIndex.Count; i += 1)
{ {
var componentTypeSet = EntityComponentIndex[i];
foreach (var typeId in componentTypeSet) foreach (var typeId in componentTypeSet)
{ {
world.EntityComponentIndex[id].Add(typeId); world.EntityComponentIndex[i].Add(typeId);
} }
} }
// restore entity tags // restore entity tags
foreach (var (id, s) in EntityTags) for (var i = 0; i < EntityTags.Count; i += 1)
{ {
world.EntityTags[id] = s; world.EntityTags[i] = EntityTags[i];
} }
} }
@ -125,55 +128,68 @@ public class Snapshot : IDisposable
} }
// copy components // copy components
foreach (var (typeId, componentStorage) in world.ComponentIndex) for (var i = ComponentSnapshots.Count; i < world.ComponentIndex.Count; i += 1)
{ {
TakeComponentSnapshot(typeId, componentStorage); ComponentSnapshots.Add(new ComponentSnapshot(world.ComponentIndex[i].ElementSize));
}
for (var i = 0; i < world.ComponentIndex.Count; i += 1)
{
ComponentSnapshots[i].Take(world.ComponentIndex[i]);
} }
// copy relations // copy relations
foreach (var (typeId, relationStorage) in world.RelationIndex) for (var i = RelationSnapshots.Count; i < world.RelationIndex.Count; i += 1)
{ {
TakeRelationSnapshot(typeId, relationStorage); RelationSnapshots.Add(new RelationSnapshot(world.RelationIndex[i].ElementSize));
}
for (var i = 0; i < world.RelationIndex.Count; i += 1)
{
RelationSnapshots[i].Take(world.RelationIndex[i]);
}
// fill in missing index structures
for (var i = EntityComponentIndex.Count; i < world.EntityComponentIndex.Count; i += 1)
{
EntityComponentIndex.Add(new IndexableSet<TypeId>());
}
for (var i = EntityRelationIndex.Count; i < world.EntityRelationIndex.Count; i += 1)
{
EntityRelationIndex.Add(new IndexableSet<TypeId>());
} }
// copy entity relation index // copy entity relation index
// FIXME: arghhhh this is so slow // FIXME: arghhhh this is so slow
foreach (var (id, relationTypeSet) in world.EntityRelationIndex) for (var i = 0; i < world.EntityRelationIndex.Count; i += 1)
{ {
if (!EntityRelationIndex.ContainsKey(id)) EntityRelationIndex[i].Clear();
{
EntityRelationIndex.Add(id, new IndexableSet<TypeId>());
}
EntityRelationIndex[id].Clear(); foreach (var typeId in world.EntityRelationIndex[i])
foreach (var typeId in relationTypeSet)
{ {
EntityRelationIndex[id].Add(typeId); EntityRelationIndex[i].Add(typeId);
} }
} }
// copy entity component index // copy entity component index
// FIXME: arghhhh this is so slow // FIXME: arghhhh this is so slow
foreach (var (id, componentTypeSet) in world.EntityComponentIndex) for (var i = 0; i < world.EntityComponentIndex.Count; i += 1)
{ {
if (!EntityComponentIndex.ContainsKey(id)) EntityComponentIndex[i].Clear();
{
EntityComponentIndex.Add(id, new IndexableSet<TypeId>());
}
EntityComponentIndex[id].Clear(); foreach (var typeId in world.EntityComponentIndex[i])
foreach (var typeId in componentTypeSet)
{ {
EntityComponentIndex[id].Add(typeId); EntityComponentIndex[i].Add(typeId);
} }
} }
// copy entity tags // copy entity tags
foreach (var (id, s) in world.EntityTags) EntityTags.Clear();
foreach (var s in world.EntityTags)
{ {
EntityTags[id] = s; EntityTags.Add(s);
} }
} }
@ -193,28 +209,6 @@ public class Snapshot : IDisposable
} }
} }
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 class ComponentSnapshot : IDisposable
{ {
private readonly NativeArray Components; private readonly NativeArray Components;
@ -348,22 +342,22 @@ public class Snapshot : IDisposable
{ {
if (disposing) if (disposing)
{ {
foreach (var componentSnapshot in ComponentSnapshots.Values) foreach (var componentSnapshot in ComponentSnapshots)
{ {
componentSnapshot.Dispose(); componentSnapshot.Dispose();
} }
foreach (var relationSnapshot in RelationSnapshots.Values) foreach (var relationSnapshot in RelationSnapshots)
{ {
relationSnapshot.Dispose(); relationSnapshot.Dispose();
} }
foreach (var componentSet in EntityComponentIndex.Values) foreach (var componentSet in EntityComponentIndex)
{ {
componentSet.Dispose(); componentSet.Dispose();
} }
foreach (var relationSet in EntityRelationIndex.Values) foreach (var relationSet in EntityRelationIndex)
{ {
relationSet.Dispose(); relationSet.Dispose();
} }

View File

@ -1,4 +1,5 @@
using System; using System;
using System.Runtime.CompilerServices;
namespace MoonTools.ECS; namespace MoonTools.ECS;
@ -8,4 +9,74 @@ public readonly record struct TypeId(uint Value) : IComparable<TypeId>
{ {
return Value.CompareTo(other.Value); return Value.CompareTo(other.Value);
} }
public static implicit operator int(TypeId typeId)
{
return (int) typeId.Value;
}
}
public class ComponentTypeIdAssigner
{
protected static ushort Counter;
}
public class ComponentTypeIdAssigner<T> : ComponentTypeIdAssigner
{
public static readonly ushort Id;
public static readonly int Size;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static ComponentTypeIdAssigner()
{
Id = Counter++;
Size = Unsafe.SizeOf<T>();
World.ComponentTypeElementSizes.Add(Size);
#if DEBUG
World.ComponentTypeToId[typeof(T)] = new TypeId(Id);
World.ComponentTypeIdToType.Add(typeof(T));
#endif
}
}
public class RelationTypeIdAssigner
{
protected static ushort Counter;
}
public class RelationTypeIdAssigner<T> : RelationTypeIdAssigner
{
public static readonly ushort Id;
public static readonly int Size;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static RelationTypeIdAssigner()
{
Id = Counter++;
Size = Unsafe.SizeOf<T>();
World.RelationTypeElementSizes.Add(Size);
}
}
public class MessageTypeIdAssigner
{
protected static ushort Counter;
}
public class MessageTypeIdAssigner<T> : MessageTypeIdAssigner
{
public static readonly ushort Id;
public static readonly int Size;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static MessageTypeIdAssigner()
{
Id = Counter++;
Size = Unsafe.SizeOf<T>();
World.MessageTypeElementSizes.Add(Size);
}
} }

View File

@ -7,85 +7,64 @@ namespace MoonTools.ECS;
public class World : IDisposable public class World : IDisposable
{ {
// Get TypeId from a Type
private readonly Dictionary<Type, TypeId> TypeToId = new Dictionary<Type, TypeId>();
#if DEBUG #if DEBUG
private Dictionary<TypeId, Type> IdToType = new Dictionary<TypeId, Type>(); // TODO: is there a smarter way to do this?
internal static Dictionary<Type, TypeId> ComponentTypeToId = new Dictionary<Type, TypeId>();
internal static List<Type> ComponentTypeIdToType = new List<Type>();
#endif #endif
// Get element size from a TypeId internal static List<int> ComponentTypeElementSizes = new List<int>();
private readonly Dictionary<TypeId, int> ElementSizes = new Dictionary<TypeId, int>(); internal static List<int> RelationTypeElementSizes = new List<int>();
internal static List<int> MessageTypeElementSizes = new List<int>();
// Filters // Filters
internal readonly Dictionary<FilterSignature, Filter> FilterIndex = new Dictionary<FilterSignature, Filter>(); internal readonly Dictionary<FilterSignature, Filter> FilterIndex = new Dictionary<FilterSignature, Filter>();
private readonly Dictionary<TypeId, List<Filter>> TypeToFilter = new Dictionary<TypeId, List<Filter>>(); private readonly List<List<Filter>> ComponentTypeToFilter = new List<List<Filter>>();
// TODO: can we make the tag an native array of chars at some point? // TODO: can we make the tag an native array of chars at some point?
internal Dictionary<Entity, string> EntityTags = new Dictionary<Entity, string>(); internal List<string> EntityTags = new List<string>();
// Relation Storages // Relation Storages
internal Dictionary<TypeId, RelationStorage> RelationIndex = new Dictionary<TypeId, RelationStorage>(); internal List<RelationStorage> RelationIndex = new List<RelationStorage>();
internal Dictionary<Entity, IndexableSet<TypeId>> EntityRelationIndex = new Dictionary<Entity, IndexableSet<TypeId>>(); internal List<IndexableSet<TypeId>> EntityRelationIndex = new List<IndexableSet<TypeId>>();
// Message Storages // Message Storages
private Dictionary<TypeId, MessageStorage> MessageIndex = new Dictionary<TypeId, MessageStorage>(); private List<MessageStorage> MessageIndex = new List<MessageStorage>();
public FilterBuilder FilterBuilder => new FilterBuilder(this); public FilterBuilder FilterBuilder => new FilterBuilder(this);
internal readonly Dictionary<TypeId, ComponentStorage> ComponentIndex = new Dictionary<TypeId, ComponentStorage>(); internal readonly List<ComponentStorage> ComponentIndex = new List<ComponentStorage>();
internal Dictionary<Entity, IndexableSet<TypeId>> EntityComponentIndex = new Dictionary<Entity, IndexableSet<TypeId>>(); internal List<IndexableSet<TypeId>> EntityComponentIndex = new List<IndexableSet<TypeId>>();
internal IdAssigner EntityIdAssigner = new IdAssigner(); internal IdAssigner EntityIdAssigner = new IdAssigner();
private IdAssigner TypeIdAssigner = new IdAssigner();
private bool IsDisposed; private bool IsDisposed;
internal TypeId GetTypeId<T>() where T : unmanaged
{
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 internal TypeId GetComponentTypeId<T>() where T : unmanaged
{ {
var typeId = GetTypeId<T>(); var typeId = new TypeId(ComponentTypeIdAssigner<T>.Id);
if (ComponentIndex.TryGetValue(typeId, out var componentStorage)) if (typeId < ComponentIndex.Count)
{ {
return typeId; return typeId;
} }
componentStorage = new ComponentStorage(typeId, ElementSizes[typeId]); // add missing storages, it's possible for there to be multiples in multi-world scenarios
ComponentIndex.Add(typeId, componentStorage); for (var i = ComponentIndex.Count; i <= typeId; i += 1)
TypeToFilter.Add(typeId, new List<Filter>()); {
var missingTypeId = new TypeId((uint) i);
var componentStorage = new ComponentStorage(missingTypeId, ComponentTypeElementSizes[i]);
ComponentIndex.Add(componentStorage);
ComponentTypeToFilter.Add(new List<Filter>());
}
return typeId; return typeId;
} }
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
private ComponentStorage GetComponentStorage<T>() where T : unmanaged private ComponentStorage GetComponentStorage<T>() where T : unmanaged
{ {
var typeId = GetTypeId<T>(); var typeId = GetComponentTypeId<T>();
if (ComponentIndex.TryGetValue(typeId, out var componentStorage)) return ComponentIndex[typeId];
{
return componentStorage;
}
componentStorage = new ComponentStorage(typeId, ElementSizes[typeId]);
ComponentIndex.Add(typeId, componentStorage);
TypeToFilter.Add(typeId, new List<Filter>());
return componentStorage;
} }
// FILTERS // FILTERS
@ -98,12 +77,12 @@ public class World : IDisposable
foreach (var typeId in signature.Included) foreach (var typeId in signature.Included)
{ {
TypeToFilter[typeId].Add(filter); ComponentTypeToFilter[(int) typeId.Value].Add(filter);
} }
foreach (var typeId in signature.Excluded) foreach (var typeId in signature.Excluded)
{ {
TypeToFilter[typeId].Add(filter); ComponentTypeToFilter[(int) typeId.Value].Add(filter);
} }
FilterIndex.Add(signature, filter); FilterIndex.Add(signature, filter);
@ -118,50 +97,52 @@ public class World : IDisposable
{ {
var entity = new Entity(EntityIdAssigner.Assign()); var entity = new Entity(EntityIdAssigner.Assign());
if (!EntityComponentIndex.ContainsKey(entity)) if (entity.ID == EntityComponentIndex.Count)
{ {
EntityRelationIndex.Add(entity, new IndexableSet<TypeId>()); EntityRelationIndex.Add(new IndexableSet<TypeId>());
EntityComponentIndex.Add(entity, new IndexableSet<TypeId>()); EntityComponentIndex.Add(new IndexableSet<TypeId>());
EntityTags.Add(tag);
} }
EntityTags[entity] = tag;
return entity; return entity;
} }
public void Tag(Entity entity, string tag) public void Tag(Entity entity, string tag)
{ {
EntityTags[entity] = tag; EntityTags[(int) entity.ID] = tag;
} }
public string GetTag(Entity entity) public string GetTag(Entity entity)
{ {
return EntityTags[entity]; return EntityTags[(int) entity.ID];
} }
public void Destroy(in Entity entity) public void Destroy(in Entity entity)
{ {
var componentSet = EntityComponentIndex[(int) entity.ID];
var relationSet = EntityRelationIndex[(int) entity.ID];
// remove all components from storages // remove all components from storages
foreach (var componentTypeIndex in EntityComponentIndex[entity]) foreach (var componentTypeIndex in componentSet)
{ {
var componentStorage = ComponentIndex[componentTypeIndex]; var componentStorage = ComponentIndex[componentTypeIndex];
componentStorage.Remove(entity); componentStorage.Remove(entity);
foreach (var filter in TypeToFilter[componentTypeIndex]) foreach (var filter in ComponentTypeToFilter[componentTypeIndex])
{ {
filter.RemoveEntity(entity); filter.RemoveEntity(entity);
} }
} }
// remove all relations from storage // remove all relations from storage
foreach (var relationTypeIndex in EntityRelationIndex[entity]) foreach (var relationTypeIndex in relationSet)
{ {
var relationStorage = RelationIndex[relationTypeIndex]; var relationStorage = RelationIndex[relationTypeIndex];
relationStorage.RemoveEntity(entity); relationStorage.RemoveEntity(entity);
} }
EntityComponentIndex[entity].Clear(); componentSet.Clear();
EntityRelationIndex[entity].Clear(); relationSet.Clear();
// recycle ID // recycle ID
EntityIdAssigner.Unassign(entity.ID); EntityIdAssigner.Unassign(entity.ID);
@ -177,7 +158,7 @@ public class World : IDisposable
internal bool Has(in Entity entity, in TypeId typeId) internal bool Has(in Entity entity, in TypeId typeId)
{ {
return EntityComponentIndex[entity].Contains(typeId); return EntityComponentIndex[(int) entity.ID].Contains(typeId);
} }
public bool Some<T>() where T : unmanaged public bool Some<T>() where T : unmanaged
@ -210,9 +191,9 @@ public class World : IDisposable
if (!componentStorage.Set(entity, component)) if (!componentStorage.Set(entity, component))
{ {
EntityComponentIndex[entity].Add(componentStorage.TypeId); EntityComponentIndex[(int) entity.ID].Add(componentStorage.TypeId);
foreach (var filter in TypeToFilter[componentStorage.TypeId]) foreach (var filter in ComponentTypeToFilter[componentStorage.TypeId])
{ {
filter.Check(entity); filter.Check(entity);
} }
@ -225,9 +206,9 @@ public class World : IDisposable
if (componentStorage.Remove(entity)) if (componentStorage.Remove(entity))
{ {
EntityComponentIndex[entity].Remove(componentStorage.TypeId); EntityComponentIndex[(int) entity.ID].Remove(componentStorage.TypeId);
foreach (var filter in TypeToFilter[componentStorage.TypeId]) foreach (var filter in ComponentTypeToFilter[componentStorage.TypeId])
{ {
filter.Check(entity); filter.Check(entity);
} }
@ -236,31 +217,29 @@ public class World : IDisposable
// RELATIONS // RELATIONS
private RelationStorage RegisterRelationType(TypeId typeId)
{
var relationStorage = new RelationStorage(ElementSizes[typeId]);
RelationIndex.Add(typeId, relationStorage);
return relationStorage;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
private RelationStorage GetRelationStorage<T>() where T : unmanaged private RelationStorage GetRelationStorage<T>() where T : unmanaged
{ {
var typeId = GetTypeId<T>(); var typeId = new TypeId(RelationTypeIdAssigner<T>.Id);
if (RelationIndex.TryGetValue(typeId, out var relationStorage)) if (typeId.Value < RelationIndex.Count)
{ {
return relationStorage; return RelationIndex[typeId];
} }
return RegisterRelationType(typeId); for (var i = RelationIndex.Count; i <= typeId; i += 1)
{
RelationIndex.Add(new RelationStorage(RelationTypeElementSizes[i]));
}
return RelationIndex[typeId];
} }
public void Relate<T>(in Entity entityA, in Entity entityB, in T relation) where T : unmanaged public void Relate<T>(in Entity entityA, in Entity entityB, in T relation) where T : unmanaged
{ {
var relationStorage = GetRelationStorage<T>(); var relationStorage = GetRelationStorage<T>();
relationStorage.Set(entityA, entityB, relation); relationStorage.Set(entityA, entityB, relation);
EntityRelationIndex[entityA].Add(TypeToId[typeof(T)]); EntityRelationIndex[(int) entityA.ID].Add(new TypeId(RelationTypeIdAssigner<T>.Id));
EntityRelationIndex[entityB].Add(TypeToId[typeof(T)]); EntityRelationIndex[(int) entityB.ID].Add(new TypeId(RelationTypeIdAssigner<T>.Id));
} }
public void Unrelate<T>(in Entity entityA, in Entity entityB) where T : unmanaged public void Unrelate<T>(in Entity entityA, in Entity entityB) where T : unmanaged
@ -355,52 +334,52 @@ public class World : IDisposable
// MESSAGES // MESSAGES
private TypeId GetMessageTypeId<T>() where T : unmanaged private MessageStorage GetMessageStorage<T>() where T : unmanaged
{ {
var typeId = GetTypeId<T>(); var typeId = new TypeId(MessageTypeIdAssigner<T>.Id);
if (!MessageIndex.ContainsKey(typeId)) if (typeId < MessageIndex.Count)
{ {
MessageIndex.Add(typeId, new MessageStorage(Unsafe.SizeOf<T>())); return MessageIndex[typeId];
} }
return typeId; for (var i = MessageIndex.Count; i <= typeId; i += 1)
{
MessageIndex.Add(new MessageStorage(MessageTypeElementSizes[i]));
}
return MessageIndex[typeId];
} }
public void Send<T>(in T message) where T : unmanaged public void Send<T>(in T message) where T : unmanaged
{ {
var typeId = GetMessageTypeId<T>(); GetMessageStorage<T>().Add(message);
MessageIndex[typeId].Add(message);
} }
public bool SomeMessage<T>() where T : unmanaged public bool SomeMessage<T>() where T : unmanaged
{ {
var typeId = GetMessageTypeId<T>(); return GetMessageStorage<T>().Some();
return MessageIndex[typeId].Some();
} }
public ReadOnlySpan<T> ReadMessages<T>() where T : unmanaged public ReadOnlySpan<T> ReadMessages<T>() where T : unmanaged
{ {
var typeId = GetMessageTypeId<T>(); return GetMessageStorage<T>().All<T>();
return MessageIndex[typeId].All<T>();
} }
public T ReadMessage<T>() where T : unmanaged public T ReadMessage<T>() where T : unmanaged
{ {
var typeId = GetMessageTypeId<T>(); return GetMessageStorage<T>().First<T>();
return MessageIndex[typeId].First<T>();
} }
public void ClearMessages<T>() where T : unmanaged public void ClearMessages<T>() where T : unmanaged
{ {
var typeId = GetMessageTypeId<T>(); GetMessageStorage<T>().Clear();
MessageIndex[typeId].Clear();
} }
// TODO: temporary component storage? // TODO: temporary component storage?
public void FinishUpdate() public void FinishUpdate()
{ {
foreach (var (_, messageStorage) in MessageIndex) foreach (var messageStorage in MessageIndex)
{ {
messageStorage.Clear(); messageStorage.Clear();
} }
@ -412,18 +391,18 @@ public class World : IDisposable
#if DEBUG #if DEBUG
public ComponentTypeEnumerator Debug_GetAllComponentTypes(Entity entity) public ComponentTypeEnumerator Debug_GetAllComponentTypes(Entity entity)
{ {
return new ComponentTypeEnumerator(this, EntityComponentIndex[entity]); return new ComponentTypeEnumerator(this, EntityComponentIndex[(int) entity.ID]);
} }
public IEnumerable<Entity> Debug_GetEntities(Type componentType) public IEnumerable<Entity> Debug_GetEntities(Type componentType)
{ {
var storage = ComponentIndex[TypeToId[componentType]]; var storage = ComponentIndex[ComponentTypeToId[componentType]];
return storage.Debug_GetEntities(); return storage.Debug_GetEntities();
} }
public IEnumerable<Type> Debug_SearchComponentType(string typeString) public IEnumerable<Type> Debug_SearchComponentType(string typeString)
{ {
foreach (var type in TypeToId.Keys) foreach (var type in ComponentTypeToId.Keys)
{ {
if (type.ToString().ToLower().Contains(typeString.ToLower())) if (type.ToString().ToLower().Contains(typeString.ToLower()))
{ {
@ -456,7 +435,7 @@ public class World : IDisposable
return ComponentIndex < Types.Count; return ComponentIndex < Types.Count;
} }
public Type Current => World.IdToType[Types[ComponentIndex]]; public Type Current => ComponentTypeIdToType[Types[ComponentIndex]];
} }
#endif #endif
@ -466,29 +445,29 @@ public class World : IDisposable
{ {
if (disposing) if (disposing)
{ {
foreach (var componentStorage in ComponentIndex.Values) foreach (var componentStorage in ComponentIndex)
{ {
componentStorage.Dispose(); componentStorage.Dispose();
} }
foreach (var relationStorage in RelationIndex.Values) foreach (var relationStorage in RelationIndex)
{ {
relationStorage.Dispose(); relationStorage.Dispose();
} }
foreach (var messageStorage in MessageIndex.Values) foreach (var messageStorage in MessageIndex)
{ {
messageStorage.Dispose(); messageStorage.Dispose();
} }
foreach (var typeSet in EntityComponentIndex.Values) foreach (var componentSet in EntityComponentIndex)
{ {
typeSet.Dispose(); componentSet.Dispose();
} }
foreach (var typeSet in EntityRelationIndex.Values) foreach (var relationSet in EntityRelationIndex)
{ {
typeSet.Dispose(); relationSet.Dispose();
} }
foreach (var filter in FilterIndex.Values) foreach (var filter in FilterIndex.Values)
@ -497,7 +476,6 @@ public class World : IDisposable
} }
EntityIdAssigner.Dispose(); EntityIdAssigner.Dispose();
TypeIdAssigner.Dispose();
} }
IsDisposed = true; IsDisposed = true;