MoonsideGames
/
encompass-cs
4
0
Fork 0
Code Issues Pull Requests Releases 7 Wiki Activity

replace entity storage with int

pull/5/head
Evan Hemsley 2019-12-29 13:54:08 -08:00
parent f7095ffdfb
commit 1eb72874c1
8 changed files with 125 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
encompass-cs/ComponentManager.cs
View File

@ -39,9 +39,9 @@ namespace Encompass
existingComponentStore.SwapWith(componentStore); existingComponentStore.SwapWith(componentStore);
} }
internal void RegisterDrawableComponent<TComponent>(Entity entity, TComponent component, int layer) where TComponent : struct, IComponent internal void RegisterDrawableComponent<TComponent>(int entityID, TComponent component, int layer) where TComponent : struct, IComponent
{ {
drawLayerManager.RegisterComponentWithLayer(entity.ID, component, layer); drawLayerManager.RegisterComponentWithLayer(entityID, component, layer);
} }
internal void WriteComponents() internal void WriteComponents()
@ -51,25 +51,25 @@ namespace Encompass
immediateComponentStore.ClearAll(); immediateComponentStore.ClearAll();
} }
internal void AddExistingComponent<TComponent>(Entity entity, TComponent component) where TComponent : struct, IComponent internal void AddExistingComponent<TComponent>(int entityID, TComponent component) where TComponent : struct, IComponent
{ {
upToDateComponentStore.Set(entity.ID, component); upToDateComponentStore.Set(entityID, component);
} }
internal bool AddImmediateComponent<TComponent>(Entity entity, TComponent component, int priority) where TComponent : struct, IComponent internal bool AddImmediateComponent<TComponent>(int entityID, TComponent component, int priority) where TComponent : struct, IComponent
{ {
if (immediateComponentStore.Set(entity.ID, component, priority)) if (immediateComponentStore.Set(entityID, component, priority))
{ {
upToDateComponentStore.Set(entity.ID, component); upToDateComponentStore.Set(entityID, component);
return true; return true;
} }
return false; return false;
} }
public bool UpdateComponent<TComponent>(Entity entity, TComponent component, int priority) where TComponent : struct, IComponent public bool UpdateComponent<TComponent>(int entityID, TComponent component, int priority) where TComponent : struct, IComponent
{ {
return upToDateComponentStore.Set(entity.ID, component, priority); return upToDateComponentStore.Set(entityID, component, priority);
} }
// existing or immediate reads // existing or immediate reads
@ -129,51 +129,51 @@ namespace Encompass
// component getters // component getters
internal TComponent ReadImmediateOrExistingComponentByEntityAndType<TComponent>(Entity entity) where TComponent : struct, IComponent internal TComponent ReadImmediateOrExistingComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return upToDateComponentStore.Get<TComponent>(entity.ID); return upToDateComponentStore.Get<TComponent>(entityID);
} }
internal TComponent ReadExistingComponentByEntityAndType<TComponent>(Entity entity) where TComponent : struct, IComponent internal TComponent ReadExistingComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return existingComponentStore.Get<TComponent>(entity.ID); return existingComponentStore.Get<TComponent>(entityID);
} }
internal TComponent ReadImmediateComponentByEntityAndType<TComponent>(Entity entity) where TComponent : struct, IComponent internal TComponent ReadImmediateComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return immediateComponentStore.Get<TComponent>(entity.ID); return immediateComponentStore.Get<TComponent>(entityID);
} }
// has checkers // has checkers
internal bool HasExistingOrImmediateComponent<TComponent>(Entity entity) where TComponent : struct, IComponent internal bool HasExistingOrImmediateComponent<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return upToDateComponentStore.Has<TComponent>(entity.ID); return upToDateComponentStore.Has<TComponent>(entityID);
} }
internal bool HasExistingOrImmediateComponent(Entity entity, Type type) internal bool HasExistingOrImmediateComponent(int entityID, Type type)
{ {
return upToDateComponentStore.Has(type, entity.ID); return upToDateComponentStore.Has(type, entityID);
} }
internal bool HasExistingComponent<TComponent>(Entity entity) where TComponent : struct, IComponent internal bool HasExistingComponent<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return existingComponentStore.Has<TComponent>(entity.ID); return existingComponentStore.Has<TComponent>(entityID);
} }
internal bool HasExistingComponent(Entity entity, Type type) internal bool HasExistingComponent(int entityID, Type type)
{ {
return existingComponentStore.Has(type, entity.ID); return existingComponentStore.Has(type, entityID);
} }
internal bool HasImmediateComponent<TComponent>(Entity entity) where TComponent : struct, IComponent internal bool HasImmediateComponent<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return immediateComponentStore.Has<TComponent>(entity.ID); return immediateComponentStore.Has<TComponent>(entityID);
} }
internal bool HasImmediateComponent(Entity entity, Type type) internal bool HasImmediateComponent(int entityID, Type type)
{ {
return immediateComponentStore.Has(type, entity.ID); return immediateComponentStore.Has(type, entityID);
} }
internal IEnumerable<(TComponent, int)> GetComponentsIncludingEntity<TComponent>() where TComponent : struct, IComponent internal IEnumerable<(TComponent, int)> GetComponentsIncludingEntity<TComponent>() where TComponent : struct, IComponent
@ -189,19 +189,19 @@ namespace Encompass
} }
} }
internal TComponent GetComponentByEntityAndType<TComponent>(Entity entity) where TComponent : struct, IComponent internal TComponent GetComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return existingComponentStore.Get<TComponent>(entity.ID); return existingComponentStore.Get<TComponent>(entityID);
} }
internal bool EntityHasComponentOfType<TComponent>(Entity entity) where TComponent : struct, IComponent internal bool EntityHasComponentOfType<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
return existingComponentStore.Has<TComponent>(entity.ID); return existingComponentStore.Has<TComponent>(entityID);
} }
internal void MarkAllComponentsOnEntityForRemoval(Entity entity) internal void MarkAllComponentsOnEntityForRemoval(int entityID)
{ {
entitiesMarkedForRemoval.Add(entity.ID); entitiesMarkedForRemoval.Add(entityID);
} }
internal void RemoveMarkedComponents() internal void RemoveMarkedComponents()
@ -216,22 +216,22 @@ namespace Encompass
entitiesMarkedForRemoval.Clear(); entitiesMarkedForRemoval.Clear();
} }
public bool RemoveImmediate<TComponent>(Entity entity, int priority) where TComponent : struct, IComponent public bool RemoveImmediate<TComponent>(int entityID, int priority) where TComponent : struct, IComponent
{ {
if (immediateComponentStore.Remove<TComponent>(entity.ID, priority)) if (immediateComponentStore.Remove<TComponent>(entityID, priority))
{ {
upToDateComponentStore.Remove<TComponent>(entity.ID, priority); upToDateComponentStore.Remove<TComponent>(entityID, priority);
drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entity.ID); drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entityID);
return true; return true;
} }
return false; return false;
} }
public void Remove<TComponent>(Entity entity, int priority) where TComponent : struct, IComponent public void Remove<TComponent>(int entityID, int priority) where TComponent : struct, IComponent
{ {
if (upToDateComponentStore.Remove<TComponent>(entity.ID, priority)) if (upToDateComponentStore.Remove<TComponent>(entityID, priority))
{ {
drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entity.ID); drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entityID);
} }
} }
} }

87
encompass-cs/Engine.cs
View File

@ -41,8 +41,17 @@ namespace Encompass
private EntitySetQuery entityQuery; private EntitySetQuery entityQuery;
private HashSet<Entity> _trackedEntities = new HashSet<Entity>(); private HashSet<int> _trackedEntities = new HashSet<int>();
protected IEnumerable<Entity> TrackedEntities { get { return _trackedEntities; } } protected IEnumerable<Entity> TrackedEntities
{
get
{
foreach (var entityID in _trackedEntities)
{
yield return entityManager.GetEntity(entityID);
}
}
}
protected Engine() protected Engine()
{ {
@ -313,21 +322,21 @@ namespace Encompass
} }
} }
private TComponent GetComponentHelper<TComponent>(Entity entity) where TComponent : struct, IComponent private TComponent GetComponentHelper<TComponent>(int entityID) where TComponent : struct, IComponent
{ {
var immediateRead = readImmediateTypes.Contains(typeof(TComponent)); var immediateRead = readImmediateTypes.Contains(typeof(TComponent));
var existingRead = readTypes.Contains(typeof(TComponent)); var existingRead = readTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead) if (existingRead && immediateRead)
{ {
return componentManager.ReadImmediateOrExistingComponentByEntityAndType<TComponent>(entity); return componentManager.ReadImmediateOrExistingComponentByEntityAndType<TComponent>(entityID);
} }
else if (existingRead) else if (existingRead)
{ {
return componentManager.ReadExistingComponentByEntityAndType<TComponent>(entity); return componentManager.ReadExistingComponentByEntityAndType<TComponent>(entityID);
} }
else if (immediateRead) else if (immediateRead)
{ {
return componentManager.ReadImmediateComponentByEntityAndType<TComponent>(entity); return componentManager.ReadImmediateComponentByEntityAndType<TComponent>(entityID);
} }
else else
{ {
@ -346,7 +355,7 @@ namespace Encompass
/// </exception> /// </exception>
protected TComponent GetComponent<TComponent>(Entity entity) where TComponent : struct, IComponent protected TComponent GetComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
{ {
return GetComponentHelper<TComponent>(entity); return GetComponentHelper<TComponent>(entity.ID);
} }
/// <summary> /// <summary>
@ -362,15 +371,15 @@ namespace Encompass
if (immediateRead && existingRead) if (immediateRead && existingRead)
{ {
return componentManager.HasExistingOrImmediateComponent<TComponent>(entity); return componentManager.HasExistingOrImmediateComponent<TComponent>(entity.ID);
} }
else if (existingRead) else if (existingRead)
{ {
return componentManager.HasExistingComponent<TComponent>(entity); return componentManager.HasExistingComponent<TComponent>(entity.ID);
} }
else if (immediateRead) else if (immediateRead)
{ {
return componentManager.HasImmediateComponent<TComponent>(entity); return componentManager.HasImmediateComponent<TComponent>(entity.ID);
} }
else else
{ {
@ -391,15 +400,15 @@ namespace Encompass
if (immediateRead && existingRead) if (immediateRead && existingRead)
{ {
return componentManager.HasExistingOrImmediateComponent(entity, type); return componentManager.HasExistingOrImmediateComponent(entity.ID, type);
} }
else if (existingRead) else if (existingRead)
{ {
return componentManager.HasExistingComponent(entity, type); return componentManager.HasExistingComponent(entity.ID, type);
} }
else if (immediateRead) else if (immediateRead)
{ {
return componentManager.HasImmediateComponent(entity, type); return componentManager.HasImmediateComponent(entity.ID, type);
} }
else else
{ {
@ -425,25 +434,25 @@ namespace Encompass
bool written; bool written;
if (writeImmediateTypes.Contains(typeof(TComponent))) if (writeImmediateTypes.Contains(typeof(TComponent)))
{ {
written = componentManager.AddImmediateComponent(entity, component, priority); written = componentManager.AddImmediateComponent(entity.ID, component, priority);
if (written) if (written)
{ {
trackingManager.ImmediateUpdateTracking(entity, typeof(TComponent)); trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent));
} }
} }
else else
{ {
written = componentManager.UpdateComponent(entity, component, priority); written = componentManager.UpdateComponent(entity.ID, component, priority);
} }
if (!componentManager.HasExistingComponent<TComponent>(entity)) if (!componentManager.HasExistingComponent<TComponent>(entity.ID))
{ {
trackingManager.RegisterAddition(entity, typeof(TComponent)); trackingManager.RegisterAddition(entity.ID, typeof(TComponent));
} }
if (written && component is IDrawableComponent drawableComponent) if (written && component is IDrawableComponent drawableComponent)
{ {
componentManager.RegisterDrawableComponent(entity, component, drawableComponent.Layer); componentManager.RegisterDrawableComponent(entity.ID, component, drawableComponent.Layer);
} }
} }
@ -481,9 +490,9 @@ namespace Encompass
messageManager.AddMessageIgnoringTimeDilation(message, time); messageManager.AddMessageIgnoringTimeDilation(message, time);
} }
internal void AddExistingComponent<TComponent>(Entity entity, TComponent component) where TComponent : struct, IComponent internal void AddExistingComponent<TComponent>(int entityID, TComponent component) where TComponent : struct, IComponent
{ {
componentManager.AddExistingComponent(entity, component); componentManager.AddExistingComponent(entityID, component);
} }
/// <summary> /// <summary>
@ -535,7 +544,7 @@ namespace Encompass
/// </summary> /// </summary>
protected void Destroy(Entity entity) protected void Destroy(Entity entity)
{ {
entityManager.MarkForDestroy(entity); entityManager.MarkForDestroy(entity.ID);
} }
/// <summary> /// <summary>
@ -575,19 +584,19 @@ namespace Encompass
if (writeImmediateTypes.Contains(typeof(TComponent))) if (writeImmediateTypes.Contains(typeof(TComponent)))
{ {
if (componentManager.RemoveImmediate<TComponent>(entity, priority)) if (componentManager.RemoveImmediate<TComponent>(entity.ID, priority))
{ {
trackingManager.ImmediateUpdateTracking(entity, typeof(TComponent)); trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent));
} }
} }
else else
{ {
componentManager.Remove<TComponent>(entity, priority); componentManager.Remove<TComponent>(entity.ID, priority);
} }
if (componentManager.HasExistingComponent<TComponent>(entity)) if (componentManager.HasExistingComponent<TComponent>(entity.ID))
{ {
trackingManager.RegisterRemoval(entity, typeof(TComponent)); trackingManager.RegisterRemoval(entity.ID, typeof(TComponent));
} }
} }
@ -651,27 +660,27 @@ namespace Encompass
timeManager.ActivateTimeDilation(factor, easeInTime, easeInFunction, activeTime, easeOutTime, easeOutFunction); timeManager.ActivateTimeDilation(factor, easeInTime, easeInFunction, activeTime, easeOutTime, easeOutFunction);
} }
internal void CheckAndUpdateTracking(Entity entity) internal void CheckAndUpdateTracking(int entityID)
{ {
if (_trackedEntities.Contains(entity) && !entityQuery.CheckEntity(entity, componentManager.ExistingBits)) if (_trackedEntities.Contains(entityID) && !entityQuery.CheckEntity(entityID, componentManager.ExistingBits))
{ {
_trackedEntities.Remove(entity); _trackedEntities.Remove(entityID);
} }
else if (!_trackedEntities.Contains(entity) && entityQuery.CheckEntity(entity, componentManager.ExistingBits)) else if (!_trackedEntities.Contains(entityID) && entityQuery.CheckEntity(entityID, componentManager.ExistingBits))
{ {
_trackedEntities.Add(entity); _trackedEntities.Add(entityID);
} }
} }
internal void ImmediateCheckAndUpdateTracking(Entity entity) internal void ImmediateCheckAndUpdateTracking(int entityID)
{ {
if (_trackedEntities.Contains(entity) && !entityQuery.ImmediateCheckEntity(entity, componentManager.ImmediateBits, componentManager.ExistingBits)) if (_trackedEntities.Contains(entityID) && !entityQuery.ImmediateCheckEntity(entityID, componentManager.ImmediateBits, componentManager.ExistingBits))
{ {
_trackedEntities.Remove(entity); _trackedEntities.Remove(entityID);
} }
else if (!_trackedEntities.Contains(entity) && entityQuery.ImmediateCheckEntity(entity, componentManager.ImmediateBits, componentManager.ExistingBits)) else if (!_trackedEntities.Contains(entityID) && entityQuery.ImmediateCheckEntity(entityID, componentManager.ImmediateBits, componentManager.ExistingBits))
{ {
_trackedEntities.Add(entity); _trackedEntities.Add(entityID);
} }
} }
@ -713,9 +722,9 @@ namespace Encompass
); );
} }
internal void RegisterDestroyedEntity(Entity entity) internal void RegisterDestroyedEntity(int entityID)
{ {
_trackedEntities.Remove(entity); _trackedEntities.Remove(entityID);
} }
} }
} }

2
encompass-cs/Engines/ComponentEmitter.cs
View File

@ -6,7 +6,7 @@
{ {
foreach (var (component, entity) in InternalRead<TComponent>()) foreach (var (component, entity) in InternalRead<TComponent>())
{ {
AddExistingComponent(entity, component); AddExistingComponent(entity.ID, component);
} }
} }
} }

30
encompass-cs/EntityManager.cs
View File

@ -7,15 +7,15 @@ namespace Encompass
{ {
private readonly int entityCapacity; private readonly int entityCapacity;
private readonly IDManager idManager = new IDManager(); private readonly IDManager idManager = new IDManager();
private readonly Dictionary<int, Entity> IDs = new Dictionary<int, Entity>(32768); private readonly HashSet<int> IDs = new HashSet<int>();
private readonly HashSet<Entity> entitiesMarkedForDestroy = new HashSet<Entity>(); private readonly HashSet<int> entitiesMarkedForDestroy = new HashSet<int>();
private readonly ComponentManager componentManager; private readonly ComponentManager componentManager;
public IEnumerable<Entity> Entities public IEnumerable<int> EntityIDs
{ {
get { return IDs.Values; } get { return IDs; }
} }
public EntityManager(ComponentManager componentManager, int entityCapacity) public EntityManager(ComponentManager componentManager, int entityCapacity)
@ -35,7 +35,7 @@ namespace Encompass
{ {
var id = NextID(); var id = NextID();
var entity = new Entity(id); var entity = new Entity(id);
IDs.Add(id, entity); IDs.Add(id);
return entity; return entity;
} }
else else
@ -46,7 +46,7 @@ namespace Encompass
public bool EntityExists(int id) public bool EntityExists(int id)
{ {
return IDs.ContainsKey(id); return IDs.Contains(id);
} }
public Entity GetEntity(int id) public Entity GetEntity(int id)
@ -56,22 +56,22 @@ namespace Encompass
throw new Encompass.Exceptions.EntityNotFoundException("Entity with id {0} does not exist.", id); throw new Encompass.Exceptions.EntityNotFoundException("Entity with id {0} does not exist.", id);
} }
return IDs[id]; return new Entity(id);
} }
public void MarkForDestroy(Entity entity) public void MarkForDestroy(int entityID)
{ {
entitiesMarkedForDestroy.Add(entity); entitiesMarkedForDestroy.Add(entityID);
} }
public void DestroyMarkedEntities(IEnumerable<Engine> engines) public void DestroyMarkedEntities(IEnumerable<Engine> engines)
{ {
foreach (var entity in entitiesMarkedForDestroy) foreach (var entityID in entitiesMarkedForDestroy)
{ {
foreach (var engine in engines) { engine.RegisterDestroyedEntity(entity); } foreach (var engine in engines) { engine.RegisterDestroyedEntity(entityID); }
componentManager.MarkAllComponentsOnEntityForRemoval(entity); componentManager.MarkAllComponentsOnEntityForRemoval(entityID);
IDs.Remove(entity.ID); IDs.Remove(entityID);
idManager.Free(entity.ID); idManager.Free(entityID);
} }
entitiesMarkedForDestroy.Clear(); entitiesMarkedForDestroy.Clear();

10
encompass-cs/EntitySetQuery.cs
View File

@ -19,9 +19,9 @@ namespace Encompass
NotWithMask = notWithMask; NotWithMask = notWithMask;
} }
public bool CheckEntity(Entity entity, ComponentBitSet componentBitSet) public bool CheckEntity(int entityID, ComponentBitSet componentBitSet)
{ {
var existingBits = componentBitSet.EntityBitArray(entity.ID); var existingBits = componentBitSet.EntityBitArray(entityID);
var existing = (WithExistingMask & existingBits) | NotWithMask; var existing = (WithExistingMask & existingBits) | NotWithMask;
var existingForbidden = ~(WithoutExistingMask & existingBits); var existingForbidden = ~(WithoutExistingMask & existingBits);
@ -29,10 +29,10 @@ namespace Encompass
return (existing & existingForbidden).AllTrue(); return (existing & existingForbidden).AllTrue();
} }
public bool ImmediateCheckEntity(Entity entity, ComponentBitSet immediateBitLookup, ComponentBitSet existingBitLookup) public bool ImmediateCheckEntity(int entityID, ComponentBitSet immediateBitLookup, ComponentBitSet existingBitLookup)
{ {
var immediateBits = immediateBitLookup.EntityBitArray(entity.ID); var immediateBits = immediateBitLookup.EntityBitArray(entityID);
var existingBits = existingBitLookup.EntityBitArray(entity.ID); var existingBits = existingBitLookup.EntityBitArray(entityID);
var immediate = WithImmediateMask & immediateBits; var immediate = WithImmediateMask & immediateBits;
var existing = WithExistingMask & existingBits; var existing = WithExistingMask & existingBits;

4
encompass-cs/Renderer.cs
View File

@ -59,12 +59,12 @@ namespace Encompass
protected TComponent GetComponent<TComponent>(Entity entity) where TComponent : struct, IComponent protected TComponent GetComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
{ {
return componentManager.GetComponentByEntityAndType<TComponent>(entity); return componentManager.GetComponentByEntityAndType<TComponent>(entity.ID);
} }
protected bool HasComponent<TComponent>(Entity entity) where TComponent : struct, IComponent protected bool HasComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
{ {
return componentManager.EntityHasComponentOfType<TComponent>(entity); return componentManager.EntityHasComponentOfType<TComponent>(entity.ID);
} }
protected bool SomeComponent<TComponent>() where TComponent : struct, IComponent protected bool SomeComponent<TComponent>() where TComponent : struct, IComponent

24
encompass-cs/TrackingManager.cs
View File

@ -8,10 +8,10 @@ namespace Encompass
private Dictionary<Type, HashSet<Engine>> _immediateComponentTypesToEngines = new Dictionary<Type, HashSet<Engine>>(); private Dictionary<Type, HashSet<Engine>> _immediateComponentTypesToEngines = new Dictionary<Type, HashSet<Engine>>();
private Dictionary<Type, HashSet<Engine>> _componentTypesToEngines = new Dictionary<Type, HashSet<Engine>>(); private Dictionary<Type, HashSet<Engine>> _componentTypesToEngines = new Dictionary<Type, HashSet<Engine>>();
private HashSet<(Entity, Type)> _additions = new HashSet<(Entity, Type)>(); private HashSet<(int, Type)> _additions = new HashSet<(int, Type)>();
private HashSet<(Entity, Type)> _removals = new HashSet<(Entity, Type)>(); private HashSet<(int, Type)> _removals = new HashSet<(int, Type)>();
private HashSet<(Entity, Engine)> _pairsToCheck = new HashSet<(Entity, Engine)>(); private HashSet<(int, Engine)> _pairsToCheck = new HashSet<(int, Engine)>();
public void RegisterComponentTypeToEngine(Type type, Engine engine) public void RegisterComponentTypeToEngine(Type type, Engine engine)
{ {
@ -25,37 +25,37 @@ namespace Encompass
_immediateComponentTypesToEngines[type].Add(engine); _immediateComponentTypesToEngines[type].Add(engine);
} }
public void RegisterAddition(Entity entity, Type type) public void RegisterAddition(int entityID, Type type)
{ {
_additions.Add((entity, type)); _additions.Add((entityID, type));
} }
public void RegisterRemoval(Entity entity, Type type) public void RegisterRemoval(int entityID, Type type)
{ {
_removals.Add((entity, type)); _removals.Add((entityID, type));
} }
public void InitializeTracking(IEnumerable<Entity> entities) public void InitializeTracking(IEnumerable<int> entityIDs)
{ {
foreach (var entity in entities) foreach (var entityID in entityIDs)
{ {
foreach (var engineSet in _componentTypesToEngines.Values) foreach (var engineSet in _componentTypesToEngines.Values)
{ {
foreach (var engine in engineSet) foreach (var engine in engineSet)
{ {
engine.CheckAndUpdateTracking(entity); engine.CheckAndUpdateTracking(entityID);
} }
} }
} }
} }
public void ImmediateUpdateTracking(Entity entity, Type componentType) public void ImmediateUpdateTracking(int entityID, Type componentType)
{ {
if (_immediateComponentTypesToEngines.ContainsKey(componentType)) if (_immediateComponentTypesToEngines.ContainsKey(componentType))
{ {
foreach (var engine in _componentTypesToEngines[componentType]) foreach (var engine in _componentTypesToEngines[componentType])
{ {
engine.ImmediateCheckAndUpdateTracking(entity); engine.ImmediateCheckAndUpdateTracking(entityID);
} }
} }
} }

4
encompass-cs/WorldBuilder.cs
View File

@ -94,7 +94,7 @@ namespace Encompass
if (component is IDrawableComponent drawableComponent) if (component is IDrawableComponent drawableComponent)
{ {
componentManager.RegisterDrawableComponent(entity, component, drawableComponent.Layer); componentManager.RegisterDrawableComponent(entity.ID, component, drawableComponent.Layer);
drawLayerManager.RegisterOrderedDrawable<TComponent>(); drawLayerManager.RegisterOrderedDrawable<TComponent>();
} }
} }
@ -397,7 +397,7 @@ namespace Encompass
componentManager.SetComponentStore(startingComponentStoreForComponentManager); componentManager.SetComponentStore(startingComponentStoreForComponentManager);
trackingManager.InitializeTracking(entityManager.Entities); trackingManager.InitializeTracking(entityManager.EntityIDs);
return world; return world;
} }