Merge pull request 'Storage Optimizations' (#3) from component_store_optimize into master
continuous-integration/drone/push Build is passing Details

pull/5/head
cosmonaut 2020-03-25 19:08:04 +00:00
commit 8f200fd56f
46 changed files with 1135 additions and 1078 deletions

View File

@ -5,11 +5,11 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class)]
public class DefaultWritePriority : Attribute
{
public int writePriority;
public int WritePriority { get; }
public DefaultWritePriority(int writePriority)
{
this.writePriority = writePriority;
WritePriority = writePriority;
}
}
}

View File

@ -8,20 +8,13 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class)]
public class QueryWith : Attribute
{
public readonly HashSet<Type> queryWithTypes = new HashSet<Type>();
public readonly HashSet<Type> QueryWithTypes = new HashSet<Type>();
public QueryWith(params Type[] queryWithTypes)
{
foreach (var queryWithType in queryWithTypes)
{
var isComponent = queryWithType.GetInterfaces().Contains(typeof(IComponent));
if (!isComponent)
{
throw new IllegalReadTypeException("{0} must be a Component", queryWithType.Name);
}
this.queryWithTypes.Add(queryWithType);
QueryWithTypes.Add(queryWithType);
}
}
}

View File

@ -8,20 +8,13 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class)]
public class QueryWithout : Attribute
{
public readonly HashSet<Type> queryWithoutTypes = new HashSet<Type>();
public readonly HashSet<Type> QueryWithoutTypes = new HashSet<Type>();
public QueryWithout(params Type[] queryWithoutTypes)
{
foreach (var type in queryWithoutTypes)
{
var isComponent = type.GetInterfaces().Contains(typeof(IComponent));
if (!isComponent)
{
throw new IllegalReadTypeException("{0} must be a Component", type.Name);
}
this.queryWithoutTypes.Add(type);
QueryWithoutTypes.Add(type);
}
}
}

View File

@ -8,20 +8,13 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class)]
public class Reads : Attribute
{
public readonly HashSet<Type> readTypes = new HashSet<Type>();
public readonly HashSet<Type> ReadTypes = new HashSet<Type>();
public Reads(params Type[] readTypes)
{
foreach (var readType in readTypes)
{
var isComponent = readType.GetInterfaces().Contains(typeof(IComponent));
if (!isComponent)
{
throw new IllegalReadTypeException("{0} must be a Component", readType.Name);
}
this.readTypes.Add(readType);
ReadTypes.Add(readType);
}
}
}

View File

@ -1,27 +1,18 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Encompass.Exceptions;
namespace Encompass
{
[AttributeUsage(AttributeTargets.Class)]
public class ReadsImmediate : Attribute
{
public readonly HashSet<Type> readImmediateTypes = new HashSet<Type>();
public readonly HashSet<Type> ReadImmediateTypes = new HashSet<Type>();
public ReadsImmediate(params Type[] readImmediateTypes)
{
foreach (var readImmediateType in readImmediateTypes)
{
var isComponent = readImmediateType.GetInterfaces().Contains(typeof(IComponent));
if (!isComponent)
{
throw new IllegalReadTypeException("{0} must be a Component", readImmediateType.Name);
}
this.readImmediateTypes.Add(readImmediateType);
ReadImmediateTypes.Add(readImmediateType);
}
}
}

View File

@ -8,7 +8,7 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class)]
public class Receives : Attribute
{
public readonly HashSet<Type> receiveTypes;
public readonly HashSet<Type> ReceiveTypes;
public Receives(params Type[] receiveTypes)
{
@ -21,7 +21,7 @@ namespace Encompass
}
}
this.receiveTypes = new HashSet<Type>(receiveTypes);
ReceiveTypes = new HashSet<Type>(receiveTypes);
}
}
}

View File

@ -8,7 +8,7 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class)]
public class Sends : Attribute
{
public readonly HashSet<Type> sendTypes;
public readonly HashSet<Type> SendTypes;
public Sends(params Type[] sendTypes)
{
@ -21,7 +21,7 @@ namespace Encompass
}
}
this.sendTypes = new HashSet<Type>(sendTypes);
this.SendTypes = new HashSet<Type>(sendTypes);
}
}
}

View File

@ -8,33 +8,21 @@ namespace Encompass
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class Writes : Attribute
{
public readonly HashSet<Type> writeTypes = new HashSet<Type>();
public Dictionary<Type, int> priorities = new Dictionary<Type, int>();
public readonly HashSet<Type> WriteTypes = new HashSet<Type>();
public readonly Dictionary<Type, int> Priorities = new Dictionary<Type, int>();
public Writes(params Type[] writeTypes)
{
foreach (var writeType in writeTypes)
{
var isComponent = writeType.GetInterfaces().Contains(typeof(IComponent));
if (!isComponent)
{
throw new IllegalWriteTypeException("{0} must be a Component", writeType.Name);
}
this.writeTypes.Add(writeType);
WriteTypes.Add(writeType);
}
}
public Writes(Type writeType, int priority)
{
var isComponent = writeType.GetInterfaces().Contains(typeof(IComponent));
if (!isComponent)
{
throw new IllegalWriteTypeException("{0} must be a Component", writeType.Name);
}
writeTypes.Add(writeType);
priorities.Add(writeType, priority);
WriteTypes.Add(writeType);
Priorities.Add(writeType, priority);
}
}
}

View File

@ -1,26 +1,18 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Encompass.Exceptions;
namespace Encompass
{
[AttributeUsage(AttributeTargets.Class)]
public class WritesImmediate : Attribute
{
public readonly HashSet<Type> writeImmediateTypes = new HashSet<Type>();
public readonly HashSet<Type> WriteImmediateTypes = new HashSet<Type>();
public WritesImmediate(params Type[] writeImmediateTypes)
{
foreach (var writeImmediateType in writeImmediateTypes)
{
var isComponent = writeImmediateType.GetInterfaces().Contains(typeof(IComponent));
if (!isComponent)
{
throw new IllegalWriteImmediateTypeException("{0} must be a Component", writeImmediateType.Name);
}
this.writeImmediateTypes.Add(writeImmediateType);
WriteImmediateTypes.Add(writeImmediateType);
}
}
}

View File

@ -6,49 +6,49 @@ namespace Encompass
{
internal class ComponentBitSet
{
Dictionary<int, BitSet512> entities = new Dictionary<int, BitSet512>();
Dictionary<Type, int> TypeToIndex { get; }
private readonly Dictionary<int, BitSet512> _entities = new Dictionary<int, BitSet512>();
private readonly Dictionary<Type, int> _typeToIndex;
public ComponentBitSet(Dictionary<Type, int> typeToIndex)
{
TypeToIndex = typeToIndex;
_typeToIndex = typeToIndex;
}
public void Clear()
{
entities.Clear();
_entities.Clear();
}
public void AddEntity(int entityID)
{
entities.Add(entityID, BitSet512.Zero);
_entities.Add(entityID, BitSet512.Zero);
}
public void Set<TComponent>(int entityID) where TComponent : struct, IComponent
public void Set<TComponent>(int entityID) where TComponent : struct
{
if (!entities.ContainsKey(entityID)) { AddEntity(entityID); }
entities[entityID] = entities[entityID].Set(TypeToIndex[typeof(TComponent)]);
if (!_entities.ContainsKey(entityID)) { AddEntity(entityID); }
_entities[entityID] = _entities[entityID].Set(_typeToIndex[typeof(TComponent)]);
}
public void RemoveComponent<TComponent>(int entityID) where TComponent : struct, IComponent
public void RemoveComponent<TComponent>(int entityID) where TComponent : struct
{
if (entities.ContainsKey(entityID))
if (_entities.ContainsKey(entityID))
{
entities[entityID] = entities[entityID].UnSet(TypeToIndex[typeof(TComponent)]);
_entities[entityID] = _entities[entityID].UnSet(_typeToIndex[typeof(TComponent)]);
}
}
public void RemoveEntity(int entityID)
{
if (entities.ContainsKey(entityID))
if (_entities.ContainsKey(entityID))
{
entities.Remove(entityID);
_entities.Remove(entityID);
}
}
public BitSet512 EntityBitArray(int entityID)
{
return entities.ContainsKey(entityID) ? entities[entityID] : BitSet512.Zero;
return _entities.ContainsKey(entityID) ? _entities[entityID] : BitSet512.Zero;
}
}
}

View File

@ -3,39 +3,48 @@ using System.Collections.Generic;
namespace Encompass
{
internal class ComponentDeltaStore : ComponentStore
internal class ComponentDeltaStore
{
private readonly ComponentStore _store;
private readonly Dictionary<Type, Replayer> _replayers = new Dictionary<Type, Replayer>();
private readonly HashSet<Replayer> _currentReplayers = new HashSet<Replayer>();
public IEnumerable<Replayer> CurrentReplayers { get { return _currentReplayers; } }
public ComponentDeltaStore(Dictionary<Type, int> typeToIndex) : base(typeToIndex)
public ComponentDeltaStore(Dictionary<Type, int> typeToIndex)
{
_store = new ComponentStore(typeToIndex);
}
public override void RegisterComponentType<TComponent>()
public void RegisterComponentType<TComponent>() where TComponent : struct
{
base.RegisterComponentType<TComponent>();
_store.RegisterComponentType<TComponent>();
if (!_replayers.ContainsKey(typeof(TComponent)))
{
_replayers.Add(typeof(TComponent), new Replayer<TComponent>(this));
}
}
public override void Set<TComponent>(int entityID, TComponent component)
public ref readonly TComponent GetComponent<TComponent>(int entityID) where TComponent : struct
{
base.Set(entityID, component);
return ref _store.Get<TComponent>(entityID);
}
public void Set<TComponent>(int entityID, in TComponent component) where TComponent : struct
{
_store.Set(entityID, component);
RegisterComponentType<TComponent>();
var replayer = _replayers[typeof(TComponent)];
_currentReplayers.Add(replayer);
replayer.UnMarkRemoval(entityID);
}
public override bool Set<TComponent>(int entityID, TComponent component, int priority)
public bool Set<TComponent>(int entityID, TComponent component, int priority) where TComponent : struct
{
var result = base.Set(entityID, component, priority);
var result = _store.Set(entityID, component, priority);
if (result)
{
RegisterComponentType<TComponent>();
var replayer = _replayers[typeof(TComponent)];
_currentReplayers.Add(replayer);
replayer.UnMarkRemoval(entityID);
@ -43,11 +52,12 @@ namespace Encompass
return result;
}
public override bool Remove<TComponent>(int entityID, int priority)
public bool Remove<TComponent>(int entityID, int priority) where TComponent : struct
{
var result = base.Remove<TComponent>(entityID, priority);
var result = _store.Remove<TComponent>(entityID, priority);
if (result)
{
RegisterComponentType<TComponent>();
var replayer = _replayers[typeof(TComponent)];
_currentReplayers.Add(replayer);
replayer.MarkRemoval(entityID);
@ -55,18 +65,23 @@ namespace Encompass
return result;
}
public override void Remove(int entityID)
public void Remove(int entityID)
{
base.Remove(entityID);
_store.Remove(entityID);
foreach (var replayer in CurrentReplayers)
{
replayer.MarkRemoval(entityID);
}
}
public override void ClearAll()
public Span<Entity> AllEntities<TComponent>() where TComponent : struct
{
base.ClearAll();
return _store.AllEntities<TComponent>();
}
public void ClearAll()
{
_store.ClearAll();
foreach (var replayer in _currentReplayers)
{
replayer.Clear();

View File

@ -4,46 +4,42 @@ using System.Collections.Generic;
namespace Encompass
{
internal class ComponentStore
internal sealed class ComponentStore
{
private Dictionary<Type, TypedComponentStore> Stores = new Dictionary<Type, TypedComponentStore>(512);
private Dictionary<Type, TypedComponentStore> _stores = new Dictionary<Type, TypedComponentStore>(512);
public ComponentBitSet ComponentBitSet { get; private set; }
private readonly Dictionary<Type, int> _typeToIndex;
public ComponentStore(Dictionary<Type, int> typeToIndex)
{
_typeToIndex = typeToIndex;
ComponentBitSet = new ComponentBitSet(typeToIndex);
}
public IEnumerable<(Type, TypedComponentStore)> StoresEnumerable()
public void RegisterComponentType<TComponent>() where TComponent : struct
{
foreach (var entry in Stores)
{
yield return (entry.Key, entry.Value);
}
}
public virtual void RegisterComponentType<TComponent>() where TComponent : struct, IComponent
{
if (!Stores.ContainsKey(typeof(TComponent)))
if (!_stores.ContainsKey(typeof(TComponent)))
{
var store = new TypedComponentStore<TComponent>();
Stores.Add(typeof(TComponent), store);
}
_stores.Add(typeof(TComponent), store);
}
private TypedComponentStore<TComponent> Lookup<TComponent>() where TComponent : struct, IComponent
if (!_typeToIndex.ContainsKey(typeof(TComponent))) { _typeToIndex.Add(typeof(TComponent), _typeToIndex.Count); }
}
private TypedComponentStore<TComponent> Lookup<TComponent>() where TComponent : struct
{
return Stores[typeof(TComponent)] as TypedComponentStore<TComponent>;
return _stores[typeof(TComponent)] as TypedComponentStore<TComponent>;
}
public bool Has<TComponent>(int entityID) where TComponent : struct, IComponent
public bool Has<TComponent>(int entityID) where TComponent : struct
{
return Lookup<TComponent>().Has(entityID);
}
public bool Has(Type type, int entityID)
{
return Stores.ContainsKey(type) && Stores[type].Has(entityID);
return _stores[type].Has(entityID);
}
public BitSet512 EntityBitArray(int entityID)
@ -51,18 +47,28 @@ namespace Encompass
return ComponentBitSet.EntityBitArray(entityID);
}
public TComponent Get<TComponent>(int entityID) where TComponent : struct, IComponent
public ref TComponent Get<TComponent>(int entityID) where TComponent : struct
{
return Lookup<TComponent>().Get(entityID);
return ref Lookup<TComponent>().Get(entityID);
}
public virtual void Set<TComponent>(int entityID, TComponent component) where TComponent : struct, IComponent
public ref readonly TComponent Singular<TComponent>() where TComponent : struct
{
return ref Lookup<TComponent>().Singular();
}
public ref readonly Entity SingularEntity<TComponent>() where TComponent : struct
{
return ref Lookup<TComponent>().SingularEntity();
}
public void Set<TComponent>(int entityID, in TComponent component) where TComponent : struct
{
Lookup<TComponent>().Set(entityID, component);
ComponentBitSet.Set<TComponent>(entityID);
}
public virtual bool Set<TComponent>(int entityID, TComponent component, int priority) where TComponent : struct, IComponent
public bool Set<TComponent>(int entityID, in TComponent component, int priority) where TComponent : struct
{
if (Lookup<TComponent>().Set(entityID, component, priority))
{
@ -72,7 +78,7 @@ namespace Encompass
return false;
}
public virtual bool Remove<TComponent>(int entityID, int priority) where TComponent : struct, IComponent
public bool Remove<TComponent>(int entityID, int priority) where TComponent : struct
{
if (Lookup<TComponent>().Remove(entityID, priority))
{
@ -82,59 +88,53 @@ namespace Encompass
return false;
}
public void ForceRemove<TComponent>(int entityID) where TComponent : struct, IComponent
public void ForceRemove<TComponent>(int entityID) where TComponent : struct
{
Lookup<TComponent>().ForceRemove(entityID);
ComponentBitSet.RemoveComponent<TComponent>(entityID);
}
public virtual void Remove(int entityID)
public void Remove(int entityID)
{
foreach (var entry in Stores.Values)
foreach (var entry in _stores.Values)
{
entry.ForceRemove(entityID);
}
ComponentBitSet.RemoveEntity(entityID);
}
public bool Any<TComponent>() where TComponent : struct, IComponent
public bool Any<TComponent>() where TComponent : struct
{
return Lookup<TComponent>().Count > 0;
}
public IEnumerable<(int, Type, IComponent)> AllInterfaceTyped()
public Span<TComponent> All<TComponent>() where TComponent : struct
{
foreach (var store in Stores.Values)
{
foreach (var thing in store.AllInterfaceTyped())
{
yield return thing;
}
}
return Lookup<TComponent>().AllComponents();
}
public IEnumerable<(TComponent, int)> All<TComponent>() where TComponent : struct, IComponent
public Span<Entity> AllEntities<TComponent>() where TComponent : struct
{
return Lookup<TComponent>().All();
return Lookup<TComponent>().AllEntities();
}
public void Clear<TComponent>() where TComponent : struct, IComponent
public void Clear<TComponent>() where TComponent : struct
{
Lookup<TComponent>().Clear();
}
public virtual void ClearAllPriorities()
public void ClearAllPriorities()
{
foreach (var store in Stores.Values)
foreach (var store in _stores.Values)
{
store.ClearPriorities();
}
}
public virtual void ClearAll()
public void ClearAll()
{
ComponentBitSet.Clear();
foreach (var store in Stores.Values)
foreach (var store in _stores.Values)
{
store.Clear();
}
@ -142,7 +142,7 @@ namespace Encompass
public void SwapWith(ComponentStore other)
{
(Stores, other.Stores) = (other.Stores, Stores);
(_stores, other._stores) = (other._stores, _stores);
(ComponentBitSet, other.ComponentBitSet) = (other.ComponentBitSet, ComponentBitSet);
}

View File

@ -5,40 +5,40 @@ namespace Encompass
{
internal class MessageStore
{
private Dictionary<Type, TypedMessageStore> Stores = new Dictionary<Type, TypedMessageStore>(512);
private readonly Dictionary<Type, TypedMessageStore> _stores = new Dictionary<Type, TypedMessageStore>(512);
private void RegisterMessageType<TMessage>() where TMessage : struct, IMessage
{
Stores.Add(typeof(TMessage), new TypedMessageStore<TMessage>());
_stores.Add(typeof(TMessage), new TypedMessageStore<TMessage>());
}
private TypedMessageStore<TMessage> Lookup<TMessage>() where TMessage : struct, IMessage
{
if (!Stores.ContainsKey(typeof(TMessage))) { RegisterMessageType<TMessage>(); }
return Stores[typeof(TMessage)] as TypedMessageStore<TMessage>;
if (!_stores.ContainsKey(typeof(TMessage))) { RegisterMessageType<TMessage>(); }
return _stores[typeof(TMessage)] as TypedMessageStore<TMessage>;
}
public void AddMessage<TMessage>(TMessage message) where TMessage : struct, IMessage
public void AddMessage<TMessage>(in TMessage message) where TMessage : struct, IMessage
{
Lookup<TMessage>().Add(message);
}
public void AddMessage<TMessage>(TMessage message, double time) where TMessage : struct, IMessage
public void AddMessage<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
{
Lookup<TMessage>().Add(message, time);
}
public void AddMessageIgnoringTimeDilation<TMessage>(TMessage message, double time) where TMessage : struct, IMessage
public void AddMessageIgnoringTimeDilation<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
{
Lookup<TMessage>().AddIgnoringTimeDilation(message, time);
}
public TMessage First<TMessage>() where TMessage : struct, IMessage
public ref readonly TMessage First<TMessage>() where TMessage : struct, IMessage
{
return Lookup<TMessage>().First();
return ref Lookup<TMessage>().First();
}
public IEnumerable<TMessage> All<TMessage>() where TMessage : struct, IMessage
public Span<TMessage> All<TMessage>() where TMessage : struct, IMessage
{
return Lookup<TMessage>().All();
}
@ -53,6 +53,11 @@ namespace Encompass
return Lookup<TMessage>().WithEntity(entityID);
}
public ref readonly TMessage FirstWithEntity<TMessage>(int entityID) where TMessage : struct, IMessage
{
return ref Lookup<TMessage>().FirstWithEntity(entityID);
}
public bool SomeWithEntity<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity
{
return Lookup<TMessage>().SomeWithEntity(entityID);
@ -60,7 +65,7 @@ namespace Encompass
public void ProcessDelayedMessages(double dilatedDelta, double realtimeDelta)
{
foreach (var store in Stores.Values)
foreach (var store in _stores.Values)
{
store.ProcessDelayedMessages(dilatedDelta, realtimeDelta);
}
@ -68,7 +73,7 @@ namespace Encompass
public void ClearAll()
{
foreach (var store in Stores.Values)
foreach (var store in _stores.Values)
{
store.Clear();
}

View File

@ -10,7 +10,7 @@ namespace Encompass
public abstract void Clear();
}
internal class Replayer<TComponent> : Replayer where TComponent : struct, IComponent
internal class Replayer<TComponent> : Replayer where TComponent : struct
{
private readonly ComponentDeltaStore _deltaStore;
private readonly HashSet<int> _removals = new HashSet<int>();
@ -22,9 +22,10 @@ namespace Encompass
public override void Replay(ComponentStore store)
{
foreach (var (component, entityID) in _deltaStore.All<TComponent>())
foreach (ref readonly var entity in _deltaStore.AllEntities<TComponent>())
{
store.Set(entityID, component);
ref readonly var component = ref _deltaStore.GetComponent<TComponent>(entity.ID);
store.Set(entity.ID, component);
}
foreach (var entityID in _removals)

View File

@ -1,12 +1,12 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace Encompass
{
internal abstract class TypedComponentStore
{
public abstract int Count { get; }
public abstract IEnumerable<(int, Type, IComponent)> AllInterfaceTyped();
public abstract bool Has(int entity);
public abstract bool Remove(int entity, int priority);
public abstract void ForceRemove(int entity);
@ -14,43 +14,72 @@ namespace Encompass
public abstract void ClearPriorities();
}
internal class TypedComponentStore<TComponent> : TypedComponentStore where TComponent : struct, IComponent
internal class TypedComponentStore<TComponent> : TypedComponentStore where TComponent : struct
{
private readonly Dictionary<int, TComponent> store = new Dictionary<int, TComponent>(128);
private readonly Dictionary<int, int> priorities = new Dictionary<int, int>(128);
private int _nextID = 0;
private readonly Dictionary<int, int> _entityIDToStorageIndex = new Dictionary<int, int>(128);
private readonly Dictionary<int, int> _priorities = new Dictionary<int, int>(128);
private Entity[] _storageIndexToEntities = new Entity[128];
private TComponent[] _components = new TComponent[128];
public override int Count { get => store.Count; }
public override int Count { get => _entityIDToStorageIndex.Count; }
public TComponent Get(int entityID)
public ref TComponent Get(int entityID)
{
if (!store.ContainsKey(entityID)) { throw new Exceptions.NoComponentOfTypeOnEntityException("No component of type {0} exists on Entity with ID {1}", typeof(TComponent), entityID); }
return store[entityID];
if (!_entityIDToStorageIndex.ContainsKey(entityID)) { throw new Exceptions.NoComponentOfTypeOnEntityException("No component of type {0} exists on Entity with ID {1}", typeof(TComponent), entityID); }
return ref _components[_entityIDToStorageIndex[entityID]];
}
public void Set(int entityID, TComponent component)
public ref TComponent Singular()
{
store[entityID] = component;
return ref _components[0];
}
public bool Set(int entityID, TComponent component, int priority)
public ref Entity SingularEntity()
{
if (!priorities.ContainsKey(entityID) || priority < priorities[entityID])
return ref _storageIndexToEntities[0];
}
public void Set(int entityID, in TComponent component)
{
store[entityID] = component;
priorities[entityID] = priority;
InternalSet(entityID, component);
}
public bool Set(int entityID, in TComponent component, int priority)
{
if (!_priorities.ContainsKey(entityID) || priority <= _priorities[entityID]) // if priorities are equal that means it's the same engine
{
InternalSet(entityID, component);
_priorities[entityID] = priority;
return true;
}
return false;
}
private void InternalSet(int entityID, in TComponent component)
{
if (!_entityIDToStorageIndex.ContainsKey(entityID))
{
var index = _nextID++;
if (index >= _components.Length)
{
System.Array.Resize(ref _components, _components.Length * 2);
System.Array.Resize(ref _storageIndexToEntities, _storageIndexToEntities.Length * 2);
}
_entityIDToStorageIndex[entityID] = index;
_storageIndexToEntities[index] = new Entity(entityID);
}
_components[_entityIDToStorageIndex[entityID]] = component;
}
public override bool Remove(int entityID, int priority)
{
if (!priorities.ContainsKey(entityID) || priority < priorities[entityID])
if (!_priorities.ContainsKey(entityID) || priority <= _priorities[entityID]) // if priorities are equal that means it's the same engine
{
priorities[entityID] = priority;
store.Remove(entityID);
priorities.Remove(entityID);
_priorities[entityID] = priority;
ForceRemove(entityID);
return true;
}
@ -59,40 +88,53 @@ namespace Encompass
public override void ForceRemove(int entityID)
{
store.Remove(entityID);
priorities.Remove(entityID);
if (_entityIDToStorageIndex.ContainsKey(entityID))
{
var storageIndex = _entityIDToStorageIndex[entityID];
_entityIDToStorageIndex.Remove(entityID);
_priorities.Remove(entityID);
// move a component into the hole to maintain contiguous memory
if (_nextID > 1 && storageIndex != _nextID - 1)
{
var lastStorageIndex = _nextID - 1;
ref readonly var lastEntity = ref _storageIndexToEntities[lastStorageIndex];
_entityIDToStorageIndex[lastEntity.ID] = storageIndex;
_storageIndexToEntities[storageIndex] = lastEntity;
_components[storageIndex] = _components[lastStorageIndex];
}
_nextID--;
}
}
public override bool Has(int entityID)
{
return store.ContainsKey(entityID);
return _entityIDToStorageIndex.ContainsKey(entityID);
}
public override void Clear()
{
store.Clear();
priorities.Clear();
_nextID = 0;
_entityIDToStorageIndex.Clear();
_priorities.Clear();
}
public override void ClearPriorities()
{
priorities.Clear();
_priorities.Clear();
}
public IEnumerable<(TComponent, int)> All()
public Span<Entity> AllEntities()
{
foreach (var kvp in store)
{
yield return (kvp.Value, kvp.Key);
}
return new Span<Entity>(_storageIndexToEntities, 0, _nextID);
}
public override IEnumerable<(int, Type, IComponent)> AllInterfaceTyped()
public Span<TComponent> AllComponents()
{
foreach (var kvp in store)
{
yield return (kvp.Key, typeof(TComponent), (IComponent)kvp.Value);
}
return new Span<TComponent>(_components, 0, _nextID);
}
}
}

View File

@ -1,3 +1,4 @@
using System;
using System.Collections.Generic;
namespace Encompass
@ -10,98 +11,117 @@ namespace Encompass
internal class TypedMessageStore<TMessage> : TypedMessageStore where TMessage : struct, IMessage
{
private readonly List<TMessage> store = new List<TMessage>(128);
private readonly List<(TMessage, double)> delayedStore = new List<(TMessage, double)>(128);
private readonly List<(TMessage, double)> delayedStoreIgnoringTimeDilation = new List<(TMessage, double)>(128);
private readonly Dictionary<int, List<TMessage>> entityToMessage = new Dictionary<int, List<TMessage>>();
// messages are placed in a contiguous region
// so we can return the collection as a Span
private int _nextIndex = 0;
private TMessage[] _store = new TMessage[128];
private readonly List<(TMessage, double)> _delayedStore = new List<(TMessage, double)>(128);
private readonly List<(TMessage, double)> _delayedStoreIgnoringTimeDilation = new List<(TMessage, double)>(128);
private readonly Dictionary<int, List<int>> _entityToIndices = new Dictionary<int, List<int>>();
public override void ProcessDelayedMessages(double dilatedDelta, double realtimeDelta)
{
for (int i = delayedStore.Count - 1; i >= 0; i--)
for (var i = _delayedStore.Count - 1; i >= 0; i--)
{
var (message, time) = delayedStore[i];
var (message, time) = _delayedStore[i];
var updatedTime = time - dilatedDelta;
if (updatedTime <= 0)
{
Add(message);
delayedStore.RemoveAt(i);
_delayedStore.RemoveAt(i);
}
else
{
delayedStore[i] = (message, updatedTime);
_delayedStore[i] = (message, updatedTime);
}
}
for (int i = delayedStoreIgnoringTimeDilation.Count - 1; i >= 0; i--)
for (var i = _delayedStoreIgnoringTimeDilation.Count - 1; i >= 0; i--)
{
var (message, time) = delayedStoreIgnoringTimeDilation[i];
var (message, time) = _delayedStoreIgnoringTimeDilation[i];
var updatedTime = time - realtimeDelta;
if (updatedTime <= 0)
{
Add(message);
delayedStoreIgnoringTimeDilation.RemoveAt(i);
_delayedStoreIgnoringTimeDilation.RemoveAt(i);
}
else
{
delayedStoreIgnoringTimeDilation[i] = (message, updatedTime);
_delayedStoreIgnoringTimeDilation[i] = (message, updatedTime);
}
}
}
public void Add(TMessage message)
public void Add(in TMessage message)
{
store.Add(message);
var index = _nextIndex++;
if (index >= _store.Length)
{
Array.Resize(ref _store, _store.Length * 2);
}
_store[index] = message;
if (message is IHasEntity entityMessage)
{
var entityID = entityMessage.Entity.ID;
if (!entityToMessage.ContainsKey(entityID)) { entityToMessage.Add(entityID, new List<TMessage>()); }
entityToMessage[entityID].Add(message);
if (!_entityToIndices.ContainsKey(entityID)) { _entityToIndices.Add(entityID, new List<int>()); }
_entityToIndices[entityID].Add(index);
}
}
public void Add(TMessage message, double time)
public void Add(in TMessage message, double time)
{
delayedStore.Add((message, time));
_delayedStore.Add((message, time));
}
public void AddIgnoringTimeDilation(TMessage message, double time)
public void AddIgnoringTimeDilation(in TMessage message, double time)
{
delayedStoreIgnoringTimeDilation.Add((message, time));
_delayedStoreIgnoringTimeDilation.Add((message, time));
}
public TMessage First()
public ref readonly TMessage First()
{
return store[0];
return ref _store[0];
}
public bool Any()
{
return store.Count > 0;
return _nextIndex != 0;
}
public IEnumerable<TMessage> All()
public Span<TMessage> All()
{
return store;
return new Span<TMessage>(_store, 0, _nextIndex);
}
public IEnumerable<TMessage> WithEntity(int entityID)
{
return entityToMessage.ContainsKey(entityID) ? entityToMessage[entityID] : System.Linq.Enumerable.Empty<TMessage>();
if (_entityToIndices.ContainsKey(entityID))
{
foreach (var index in _entityToIndices[entityID])
{
yield return _store[index];
}
}
}
public ref readonly TMessage FirstWithEntity(int entityID)
{
return ref _store[_entityToIndices[entityID][0]];
}
public bool SomeWithEntity(int entityID)
{
return entityToMessage.ContainsKey(entityID) && entityToMessage[entityID].Count > 0;
return _entityToIndices.ContainsKey(entityID) && _entityToIndices[entityID].Count > 0;
}
public override void Clear()
{
store.Clear();
foreach (var set in entityToMessage.Values)
_nextIndex = 0;
foreach (var set in _entityToIndices.Values)
{
set.Clear();
}

View File

@ -1,272 +1,289 @@
using System;
using System.Collections.Generic;
using MoonTools.FastCollections;
namespace Encompass
{
internal class ComponentManager
{
private readonly DrawLayerManager drawLayerManager;
private readonly DrawLayerManager _drawLayerManager;
private readonly ComponentStore existingComponentStore;
private readonly ComponentStore immediateComponentStore;
private readonly ComponentDeltaStore replayStore;
private ComponentStore upToDateComponentStore;
private readonly ComponentStore _existingComponentStore;
private readonly ComponentStore _immediateComponentStore;
private readonly ComponentDeltaStore _replayStore;
private readonly ComponentStore _upToDateComponentStore;
public Dictionary<Type, int> TypeToIndex { get; }
private readonly HashSet<int> entitiesMarkedForRemoval = new HashSet<int>();
private readonly HashSet<int> _entitiesMarkedForRemoval = new HashSet<int>();
internal ComponentBitSet ImmediateBits { get { return immediateComponentStore.ComponentBitSet; } }
internal ComponentBitSet ExistingBits { get { return existingComponentStore.ComponentBitSet; } }
internal ComponentBitSet ImmediateBits { get { return _immediateComponentStore.ComponentBitSet; } }
internal ComponentBitSet ExistingBits { get { return _existingComponentStore.ComponentBitSet; } }
public ComponentManager(DrawLayerManager drawLayerManager, Dictionary<Type, int> typeToIndex)
{
this.drawLayerManager = drawLayerManager;
existingComponentStore = new ComponentStore(typeToIndex);
immediateComponentStore = new ComponentStore(typeToIndex);
replayStore = new ComponentDeltaStore(typeToIndex);
upToDateComponentStore = new ComponentStore(typeToIndex);
this._drawLayerManager = drawLayerManager;
_existingComponentStore = new ComponentStore(typeToIndex);
_immediateComponentStore = new ComponentStore(typeToIndex);
_replayStore = new ComponentDeltaStore(typeToIndex);
_upToDateComponentStore = new ComponentStore(typeToIndex);
TypeToIndex = typeToIndex;
}
public void RegisterComponentType<TComponent>() where TComponent : struct, IComponent
public void RegisterComponentType<TComponent>() where TComponent : struct
{
existingComponentStore.RegisterComponentType<TComponent>();
immediateComponentStore.RegisterComponentType<TComponent>();
replayStore.RegisterComponentType<TComponent>();
upToDateComponentStore.RegisterComponentType<TComponent>();
_existingComponentStore.RegisterComponentType<TComponent>();
_immediateComponentStore.RegisterComponentType<TComponent>();
_replayStore.RegisterComponentType<TComponent>();
_upToDateComponentStore.RegisterComponentType<TComponent>();
}
internal void SetExistingComponentStore(ComponentStore componentStore)
{
existingComponentStore.SwapWith(componentStore);
_existingComponentStore.SwapWith(componentStore);
}
internal void SetUpToDateComponentStore(ComponentStore componentStore)
{
upToDateComponentStore.SwapWith(componentStore);
_upToDateComponentStore.SwapWith(componentStore);
}
internal void RegisterDrawableComponent<TComponent>(int entityID, TComponent component, int layer) where TComponent : struct, IComponent
internal void RegisterDrawableComponent<TComponent>(int entityID, int layer) where TComponent : struct
{
drawLayerManager.RegisterComponentWithLayer(entityID, component, layer);
_drawLayerManager.RegisterComponentWithLayer<TComponent>(entityID, layer);
}
internal void WriteComponents()
{
existingComponentStore.UpdateUsing(replayStore);
existingComponentStore.ClearAllPriorities();
upToDateComponentStore.ClearAllPriorities();
immediateComponentStore.ClearAll();
replayStore.ClearAll();
_existingComponentStore.UpdateUsing(_replayStore);
_existingComponentStore.ClearAllPriorities();
_upToDateComponentStore.ClearAllPriorities();
_immediateComponentStore.ClearAll();
_replayStore.ClearAll();
}
internal bool AddImmediateComponent<TComponent>(int entityID, TComponent component, int priority) where TComponent : struct, IComponent
internal bool AddImmediateComponent<TComponent>(int entityID, in TComponent component, int priority) where TComponent : struct
{
if (immediateComponentStore.Set(entityID, component, priority))
if (_immediateComponentStore.Set(entityID, component, priority))
{
replayStore.Set(entityID, component);
upToDateComponentStore.Set(entityID, component);
_replayStore.Set(entityID, component);
_upToDateComponentStore.Set(entityID, component);
return true;
}
return false;
}
internal void AddImmediateComponent<TComponent>(int entityID, TComponent component) where TComponent : struct, IComponent
internal void AddImmediateComponent<TComponent>(int entityID, in TComponent component) where TComponent : struct
{
immediateComponentStore.Set(entityID, component);
replayStore.Set(entityID, component);
upToDateComponentStore.Set(entityID, component);
_immediateComponentStore.Set(entityID, component);
_replayStore.Set(entityID, component);
_upToDateComponentStore.Set(entityID, component);
}
internal bool UpdateComponent<TComponent>(int entityID, TComponent component, int priority) where TComponent : struct, IComponent
internal bool UpdateComponent<TComponent>(int entityID, in TComponent component, int priority) where TComponent : struct
{
var result = upToDateComponentStore.Set(entityID, component, priority);
var result = _upToDateComponentStore.Set(entityID, component, priority);
if (result)
{
replayStore.Set(entityID, component);
_replayStore.Set(entityID, component);
}
return result;
}
internal void AddComponent<TComponent>(int entityID, TComponent component) where TComponent : struct, IComponent
internal void AddComponent<TComponent>(int entityID, in TComponent component) where TComponent : struct
{
upToDateComponentStore.Set(entityID, component);
replayStore.Set(entityID, component);
_upToDateComponentStore.Set(entityID, component);
_replayStore.Set(entityID, component);
}
// existing or immediate reads
internal IEnumerable<(TComponent, int)> ReadExistingAndImmediateComponentsByType<TComponent>() where TComponent : struct, IComponent
internal Span<TComponent> ReadExistingAndImmediateComponentsByType<TComponent>() where TComponent : struct
{
return upToDateComponentStore.All<TComponent>();
return _upToDateComponentStore.All<TComponent>();
}
internal (TComponent, int) ReadFirstExistingOrImmediateComponentByType<TComponent>() where TComponent : struct, IComponent
internal ref readonly TComponent ExistingOrImmediateSingular<TComponent>() where TComponent : struct
{
if (!SomeExistingOrImmediateComponent<TComponent>()) { throw new Exceptions.NoComponentOfTypeException($"No Component with type {typeof(TComponent)} exists"); }
var enumerator = ReadExistingAndImmediateComponentsByType<TComponent>().GetEnumerator();
enumerator.MoveNext();
return enumerator.Current;
return ref _upToDateComponentStore.Singular<TComponent>();
}
internal bool SomeExistingOrImmediateComponent<TComponent>() where TComponent : struct, IComponent
internal Span<Entity> GetExistingAndImmediateEntities<TComponent>() where TComponent : struct
{
return upToDateComponentStore.Any<TComponent>();
return _upToDateComponentStore.AllEntities<TComponent>();
}
internal ref readonly Entity ExistingOrImmediateSingularEntity<TComponent>() where TComponent : struct
{
return ref _upToDateComponentStore.SingularEntity<TComponent>();
}
internal bool SomeExistingOrImmediateComponent<TComponent>() where TComponent : struct
{
return _upToDateComponentStore.Any<TComponent>();
}
// existing reads
internal (TComponent, int) ReadFirstExistingComponentByType<TComponent>() where TComponent : struct, IComponent
internal Span<TComponent> GetExistingComponents<TComponent>() where TComponent : struct
{
if (!SomeExistingComponent<TComponent>()) { throw new Exceptions.NoComponentOfTypeException($"No Component with type {typeof(TComponent)} exists"); }
var enumerator = GetComponentsIncludingEntity<TComponent>().GetEnumerator();
enumerator.MoveNext();
return enumerator.Current;
return _existingComponentStore.All<TComponent>();
}
internal bool SomeExistingComponent<TComponent>() where TComponent : struct, IComponent
internal ref readonly TComponent ExistingSingular<TComponent>() where TComponent : struct
{
return existingComponentStore.Any<TComponent>();
return ref _existingComponentStore.Singular<TComponent>();
}
internal Span<Entity> GetExistingEntities<TComponent>() where TComponent : struct
{
return _existingComponentStore.AllEntities<TComponent>();
}
internal ref readonly Entity ExistingSingularEntity<TComponent>() where TComponent : struct
{
return ref _existingComponentStore.SingularEntity<TComponent>();
}
internal bool SomeExistingComponent<TComponent>() where TComponent : struct
{
return _existingComponentStore.Any<TComponent>();
}
// immediate reads
internal IEnumerable<(TComponent, int)> ReadImmediateComponentsByType<TComponent>() where TComponent : struct, IComponent
internal Span<TComponent> ReadImmediateComponentsByType<TComponent>() where TComponent : struct
{
return immediateComponentStore.All<TComponent>();
return _immediateComponentStore.All<TComponent>();
}
internal (TComponent, int) ReadFirstImmediateComponentByType<TComponent>() where TComponent : struct, IComponent
internal ref readonly TComponent ImmediateSingular<TComponent>() where TComponent : struct
{
if (!SomeImmediateComponent<TComponent>()) { throw new Exceptions.NoComponentOfTypeException($"No Component with type {typeof(TComponent)} exists"); }
var enumerator = ReadImmediateComponentsByType<TComponent>().GetEnumerator();
enumerator.MoveNext();
return enumerator.Current;
return ref _immediateComponentStore.Singular<TComponent>();
}
internal bool SomeImmediateComponent<TComponent>() where TComponent : struct, IComponent
internal Span<Entity> GetImmediateEntities<TComponent>() where TComponent : struct
{
return immediateComponentStore.Any<TComponent>();
return _immediateComponentStore.AllEntities<TComponent>();
}
internal ref readonly Entity ImmediateSingularEntity<TComponent>() where TComponent : struct
{
return ref _immediateComponentStore.SingularEntity<TComponent>();
}
internal bool SomeImmediateComponent<TComponent>() where TComponent : struct
{
return _immediateComponentStore.Any<TComponent>();
}
// component getters
internal TComponent ReadImmediateOrExistingComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
internal ref TComponent ReadImmediateOrExistingComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct
{
return upToDateComponentStore.Get<TComponent>(entityID);
return ref _upToDateComponentStore.Get<TComponent>(entityID);
}
internal TComponent ReadExistingComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
internal ref TComponent ReadExistingComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct
{
return existingComponentStore.Get<TComponent>(entityID);
return ref _existingComponentStore.Get<TComponent>(entityID);
}
internal TComponent ReadImmediateComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
internal ref TComponent ReadImmediateComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct
{
return immediateComponentStore.Get<TComponent>(entityID);
return ref _immediateComponentStore.Get<TComponent>(entityID);
}
// has checkers
internal bool HasExistingOrImmediateComponent<TComponent>(int entityID) where TComponent : struct, IComponent
internal bool HasExistingOrImmediateComponent<TComponent>(int entityID) where TComponent : struct
{
return upToDateComponentStore.Has<TComponent>(entityID);
return _upToDateComponentStore.Has<TComponent>(entityID);
}
internal bool HasExistingOrImmediateComponent(int entityID, Type type)
{
return upToDateComponentStore.Has(type, entityID);
return _upToDateComponentStore.Has(type, entityID);
}
internal bool HasExistingComponent<TComponent>(int entityID) where TComponent : struct, IComponent
internal bool HasExistingComponent<TComponent>(int entityID) where TComponent : struct
{
return existingComponentStore.Has<TComponent>(entityID);
return _existingComponentStore.Has<TComponent>(entityID);
}
internal bool HasExistingComponent(int entityID, Type type)
{
return existingComponentStore.Has(type, entityID);
return _existingComponentStore.Has(type, entityID);
}
internal bool HasImmediateComponent<TComponent>(int entityID) where TComponent : struct, IComponent
internal bool HasImmediateComponent<TComponent>(int entityID) where TComponent : struct
{
return immediateComponentStore.Has<TComponent>(entityID);
return _immediateComponentStore.Has<TComponent>(entityID);
}
internal bool HasImmediateComponent(int entityID, Type type)
{
return immediateComponentStore.Has(type, entityID);
return _immediateComponentStore.Has(type, entityID);
}
internal IEnumerable<(TComponent, int)> GetComponentsIncludingEntity<TComponent>() where TComponent : struct, IComponent
internal Span<TComponent> GetComponentsByType<TComponent>() where TComponent : struct
{
return existingComponentStore.All<TComponent>();
return _existingComponentStore.All<TComponent>();
}
internal IEnumerable<TComponent> GetComponentsByType<TComponent>() where TComponent : struct, IComponent
internal ref readonly TComponent GetComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct
{
foreach (var pair in existingComponentStore.All<TComponent>())
{
yield return pair.Item1;
}
return ref _existingComponentStore.Get<TComponent>(entityID);
}
internal TComponent GetComponentByEntityAndType<TComponent>(int entityID) where TComponent : struct, IComponent
internal bool EntityHasComponentOfType<TComponent>(int entityID) where TComponent : struct
{
return existingComponentStore.Get<TComponent>(entityID);
}
internal bool EntityHasComponentOfType<TComponent>(int entityID) where TComponent : struct, IComponent
{
return existingComponentStore.Has<TComponent>(entityID);
return _existingComponentStore.Has<TComponent>(entityID);
}
internal void MarkAllComponentsOnEntityForRemoval(int entityID)
{
entitiesMarkedForRemoval.Add(entityID);
_entitiesMarkedForRemoval.Add(entityID);
}
internal void RemoveMarkedComponents()
{
foreach (var entityID in entitiesMarkedForRemoval)
foreach (var entityID in _entitiesMarkedForRemoval)
{
existingComponentStore.Remove(entityID);
immediateComponentStore.Remove(entityID);
replayStore.Remove(entityID);
upToDateComponentStore.Remove(entityID);
drawLayerManager.UnRegisterEntityWithLayer(entityID);
_existingComponentStore.Remove(entityID);
_immediateComponentStore.Remove(entityID);
_replayStore.Remove(entityID);
_upToDateComponentStore.Remove(entityID);
_drawLayerManager.UnRegisterEntityWithLayer(entityID);
}
entitiesMarkedForRemoval.Clear();
_entitiesMarkedForRemoval.Clear();
}
public bool RemoveImmediate<TComponent>(int entityID, int priority) where TComponent : struct, IComponent
public bool RemoveImmediate<TComponent>(int entityID, int priority) where TComponent : struct
{
if (immediateComponentStore.Remove<TComponent>(entityID, priority))
if (_immediateComponentStore.Remove<TComponent>(entityID, priority))
{
replayStore.Remove<TComponent>(entityID, priority);
upToDateComponentStore.Remove<TComponent>(entityID, priority);
drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entityID);
_replayStore.Remove<TComponent>(entityID, priority);
_upToDateComponentStore.Remove<TComponent>(entityID, priority);
_drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entityID);
return true;
}
return false;
}
public void Remove<TComponent>(int entityID, int priority) where TComponent : struct, IComponent
public void Remove<TComponent>(int entityID, int priority) where TComponent : struct
{
if (upToDateComponentStore.Remove<TComponent>(entityID, priority))
if (_upToDateComponentStore.Remove<TComponent>(entityID, priority))
{
replayStore.Remove<TComponent>(entityID, priority);
drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entityID);
_replayStore.Remove<TComponent>(entityID, priority);
_drawLayerManager.UnRegisterComponentWithLayer<TComponent>(entityID);
}
}
public bool UpToDateEntityIsEmpty(int entityID)
{
return upToDateComponentStore.EntityBitArray(entityID).AllFalse();
return _upToDateComponentStore.EntityBitArray(entityID).AllFalse();
}
}
}

View File

@ -7,112 +7,126 @@ namespace Encompass
{
internal class DrawLayerManager
{
private readonly SortedList<int, int> layerOrder = new SortedList<int, int>();
private readonly SortedList<int, int> _layerOrder = new SortedList<int, int>();
private readonly Dictionary<int, ComponentStore> layerIndexToComponentStore = new Dictionary<int, ComponentStore>(512);
private readonly Dictionary<int, HashSet<GeneralRenderer>> layerIndexToGeneralRenderers = new Dictionary<int, HashSet<GeneralRenderer>>(512);
private readonly Dictionary<int, Dictionary<Type, HashSet<int>>> _layerIndexToTypeToID = new Dictionary<int, Dictionary<Type, HashSet<int>>>();
private readonly Dictionary<int, HashSet<GeneralRenderer>> _layerIndexToGeneralRenderers = new Dictionary<int, HashSet<GeneralRenderer>>(512);
private readonly Dictionary<Type, Dictionary<int, int>> typeToEntityToLayer = new Dictionary<Type, Dictionary<int, int>>(512);
private Dictionary<Type, int> typeToIndex;
public IEnumerable<int> LayerOrder { get { return layerOrder.Values; } }
private readonly Dictionary<Type, Dictionary<int, int>> _typeToEntityToLayer = new Dictionary<Type, Dictionary<int, int>>(512);
public IEnumerable<int> LayerOrder { get { return _layerOrder.Values; } }
public DrawLayerManager(Dictionary<Type, int> typeToIndex)
public DrawLayerManager()
{
this.typeToIndex = typeToIndex;
RegisterDrawLayer(0);
}
public void RegisterDrawLayer(int layer)
{
if (!layerIndexToComponentStore.ContainsKey(layer))
if (!_layerIndexToTypeToID.ContainsKey(layer))
{
layerOrder.Add(layer, layer);
layerIndexToGeneralRenderers.Add(layer, new HashSet<GeneralRenderer>());
layerIndexToComponentStore.Add(layer, new ComponentStore(typeToIndex));
_layerOrder.Add(layer, layer);
_layerIndexToGeneralRenderers.Add(layer, new HashSet<GeneralRenderer>());
_layerIndexToTypeToID.Add(layer, new Dictionary<Type, HashSet<int>>());
}
}
public void RegisterOrderedDrawable<TComponent>() where TComponent : struct, IComponent
public void RegisterOrderedDrawable<TComponent>() where TComponent : struct
{
if (!typeToEntityToLayer.ContainsKey(typeof(TComponent)))
if (!_typeToEntityToLayer.ContainsKey(typeof(TComponent)))
{
typeToEntityToLayer.Add(typeof(TComponent), new Dictionary<int, int>(128));
_typeToEntityToLayer.Add(typeof(TComponent), new Dictionary<int, int>(128));
}
foreach (var pair in layerIndexToComponentStore)
foreach (var pair in _layerIndexToTypeToID)
{
pair.Value.RegisterComponentType<TComponent>();
if (!pair.Value.ContainsKey(typeof(TComponent)))
{
pair.Value.Add(typeof(TComponent), new HashSet<int>());
}
}
}
public void RegisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer)
{
RegisterDrawLayer(layer);
var set = layerIndexToGeneralRenderers[layer];
var set = _layerIndexToGeneralRenderers[layer];
set.Add(renderer);
}
public void UnregisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer)
public void RegisterComponentWithLayer<TComponent>(int entityID, int layer) where TComponent : struct
{
if (layerIndexToGeneralRenderers.ContainsKey(layer))
{
layerIndexToGeneralRenderers[layer].Remove(renderer);
}
}
public void AdjustRendererLayer(GeneralRenderer renderer, int oldLayer, int newLayer)
{
UnregisterGeneralRendererWithLayer(renderer, oldLayer);
RegisterGeneralRendererWithLayer(renderer, newLayer);
}
public void RegisterComponentWithLayer<TComponent>(int entityID, TComponent component, int layer) where TComponent : struct, IComponent
{
if (!layerIndexToComponentStore.ContainsKey(layer))
if (!_layerIndexToTypeToID.ContainsKey(layer))
{
throw new UndefinedLayerException("Layer {0} is not defined. Use WorldBuilder.RegisterDrawLayer to register the layer.", layer);
}
if (typeToEntityToLayer[typeof(TComponent)].ContainsKey(entityID)) { UnRegisterComponentWithLayer<TComponent>(entityID); }
if (_typeToEntityToLayer[typeof(TComponent)].ContainsKey(entityID))
{
if (_typeToEntityToLayer[typeof(TComponent)][entityID] != layer)
{
UnRegisterComponentWithLayer<TComponent>(entityID);
var set = layerIndexToComponentStore[layer];
set.Set<TComponent>(entityID, component);
var set = _layerIndexToTypeToID[layer][typeof(TComponent)];
set.Add(entityID);
typeToEntityToLayer[typeof(TComponent)].Add(entityID, layer);
_typeToEntityToLayer[typeof(TComponent)].Add(entityID, layer);
}
}
else
{
var set = _layerIndexToTypeToID[layer][typeof(TComponent)];
set.Add(entityID);
_typeToEntityToLayer[typeof(TComponent)].Add(entityID, layer);
}
}
public void UnRegisterComponentWithLayer<TComponent>(int entityID) where TComponent : struct, IComponent
public void UnRegisterComponentWithLayer<TComponent>(int entityID) where TComponent : struct
{
if (!typeToEntityToLayer.ContainsKey(typeof(TComponent))) { return; }
if (!_typeToEntityToLayer.ContainsKey(typeof(TComponent))) { return; }
if (typeToEntityToLayer[typeof(TComponent)].ContainsKey(entityID))
if (_typeToEntityToLayer[typeof(TComponent)].ContainsKey(entityID))
{
var layer = typeToEntityToLayer[typeof(TComponent)][entityID];
layerIndexToComponentStore[layer].ForceRemove<TComponent>(entityID);
var layer = _typeToEntityToLayer[typeof(TComponent)][entityID];
_layerIndexToTypeToID[layer][typeof(TComponent)].Remove(entityID);
}
typeToEntityToLayer[typeof(TComponent)].Remove(entityID);
_typeToEntityToLayer[typeof(TComponent)].Remove(entityID);
}
public void UnRegisterEntityWithLayer(int entityID)
{
foreach (var store in layerIndexToComponentStore.Values)
foreach (var store in _layerIndexToTypeToID.Values)
{
store.Remove(entityID);
foreach (var typeToSet in store)
{
var type = typeToSet.Key;
var set = typeToSet.Value;
if (set.Contains(entityID))
{
_typeToEntityToLayer[type].Remove(entityID);
set.Remove(entityID);
}
}
}
}
public IEnumerable<GeneralRenderer> GeneralRenderersByLayer(int layer)
{
return layerIndexToGeneralRenderers.ContainsKey(layer) ?
layerIndexToGeneralRenderers[layer] :
return _layerIndexToGeneralRenderers.ContainsKey(layer) ?
_layerIndexToGeneralRenderers[layer] :
Enumerable.Empty<GeneralRenderer>();
}
public IEnumerable<(int, Type, IComponent)> AllInLayer(int layer)
public IEnumerable<(int, Type)> AllInLayer(int layer)
{
return layerIndexToComponentStore.ContainsKey(layer) ?
layerIndexToComponentStore[layer].AllInterfaceTyped() :
Enumerable.Empty<(int, Type, IComponent)>();
foreach (var kvp in _layerIndexToTypeToID[layer])
{
foreach (var id in kvp.Value)
{
yield return (id, kvp.Key);
}
}
}
}
}

View File

@ -14,104 +14,104 @@ namespace Encompass
/// </summary>
public abstract class Engine : IEquatable<Engine>
{
internal Guid ID;
internal Guid _id;
internal readonly HashSet<Type> readTypes = new HashSet<Type>();
internal readonly HashSet<Type> readImmediateTypes = new HashSet<Type>();
internal readonly HashSet<Type> sendTypes = new HashSet<Type>();
internal readonly HashSet<Type> receiveTypes = new HashSet<Type>();
internal readonly HashSet<Type> writeTypes = new HashSet<Type>();
internal readonly HashSet<Type> writeImmediateTypes = new HashSet<Type>();
internal readonly HashSet<Type> queryWithTypes = new HashSet<Type>();
internal readonly HashSet<Type> queryWithoutTypes = new HashSet<Type>();
internal readonly Dictionary<Type, int> writePriorities = new Dictionary<Type, int>();
internal readonly int defaultWritePriority = 0;
internal readonly HashSet<Type> ReadTypes = new HashSet<Type>();
internal readonly HashSet<Type> ReadImmediateTypes = new HashSet<Type>();
internal readonly HashSet<Type> SendTypes = new HashSet<Type>();
internal readonly HashSet<Type> ReceiveTypes = new HashSet<Type>();
internal readonly HashSet<Type> WriteTypes = new HashSet<Type>();
internal readonly HashSet<Type> WriteImmediateTypes = new HashSet<Type>();
internal readonly HashSet<Type> QueryWithTypes = new HashSet<Type>();
internal readonly HashSet<Type> QueryWithoutTypes = new HashSet<Type>();
internal readonly Dictionary<Type, int> WritePriorities = new Dictionary<Type, int>();
internal readonly int DefaultWritePriority = 0;
/// <summary>
/// If false, the Engine will ignore time dilation.
/// </summary>
internal bool usesTimeDilation = true;
public bool TimeDilationActive { get => usesTimeDilation && timeManager.TimeDilationActive; }
internal bool _usesTimeDilation = true;
public bool TimeDilationActive { get => _usesTimeDilation && _timeManager.TimeDilationActive; }
private EntityManager entityManager;
private MessageManager messageManager;
private ComponentManager componentManager;
private TimeManager timeManager;
private TrackingManager trackingManager;
private EntityManager _entityManager;
private MessageManager _messageManager;
private ComponentManager _componentManager;
private TimeManager _timeManager;
private TrackingManager _trackingManager;
private EntitySetQuery entityQuery;
private EntitySetQuery _entityQuery;
private HashSet<int> _trackedEntities = new HashSet<int>();
private readonly HashSet<int> _trackedEntities = new HashSet<int>();
protected IEnumerable<Entity> TrackedEntities
{
get
{
foreach (var entityID in _trackedEntities)
{
yield return entityManager.GetEntity(entityID);
yield return _entityManager.GetEntity(entityID);
}
}
}
private HashSet<int> _newlyCreatedEntities = new HashSet<int>();
private readonly HashSet<int> _newlyCreatedEntities = new HashSet<int>();
protected Engine()
{
ID = Guid.NewGuid();
_id = Guid.NewGuid();
var sendsAttribute = GetType().GetCustomAttribute<Sends>(false);
if (sendsAttribute != null)
{
sendTypes = sendsAttribute.sendTypes;
SendTypes = sendsAttribute.SendTypes;
}
var activatesAttribute = GetType().GetCustomAttribute<WritesImmediate>(false);
if (activatesAttribute != null)
{
writeImmediateTypes = activatesAttribute.writeImmediateTypes;
WriteImmediateTypes = activatesAttribute.WriteImmediateTypes;
}
var defaultWritePriorityAttribute = GetType().GetCustomAttribute<DefaultWritePriority>(false);
if (defaultWritePriorityAttribute != null)
{
defaultWritePriority = defaultWritePriorityAttribute.writePriority;
DefaultWritePriority = defaultWritePriorityAttribute.WritePriority;
}
foreach (var writesAttribute in GetType().GetCustomAttributes<Writes>(false))
{
writeTypes.UnionWith(writesAttribute.writeTypes);
writePriorities = new Dictionary<Type, int>[2] { writePriorities, writesAttribute.priorities }.SelectMany(dict => dict).ToDictionary(pair => pair.Key, pair => pair.Value);
WriteTypes.UnionWith(writesAttribute.WriteTypes);
WritePriorities = new Dictionary<Type, int>[2] { WritePriorities, writesAttribute.Priorities }.SelectMany(dict => dict).ToDictionary(pair => pair.Key, pair => pair.Value);
}
var receivesAttribute = GetType().GetCustomAttribute<Receives>(false);
if (receivesAttribute != null)
{
receiveTypes = receivesAttribute.receiveTypes;
ReceiveTypes = receivesAttribute.ReceiveTypes;
}
var readsAttribute = GetType().GetCustomAttribute<Reads>(false);
if (readsAttribute != null)
{
readTypes = readsAttribute.readTypes;
ReadTypes = readsAttribute.ReadTypes;
}
var readsImmediateAttribute = GetType().GetCustomAttribute<ReadsImmediate>(false);
if (readsImmediateAttribute != null)
{
readImmediateTypes = readsImmediateAttribute.readImmediateTypes;
ReadImmediateTypes = readsImmediateAttribute.ReadImmediateTypes;
}
var queryWithAttribute = GetType().GetCustomAttribute<QueryWith>(false);
if (queryWithAttribute != null)
{
queryWithTypes = queryWithAttribute.queryWithTypes;
QueryWithTypes = queryWithAttribute.QueryWithTypes;
}
var queryWithoutAttribute = GetType().GetCustomAttribute<QueryWithout>(false);
if (queryWithoutAttribute != null)
{
queryWithoutTypes = queryWithoutAttribute.queryWithoutTypes;
QueryWithoutTypes = queryWithoutAttribute.QueryWithoutTypes;
}
}
@ -127,42 +127,42 @@ namespace Encompass
public bool Equals(Engine other)
{
return other.ID == ID;
return other._id == _id;
}
public override int GetHashCode()
{
return ID.GetHashCode();
return HashCode.Combine(_id);
}
internal void AssignEntityManager(EntityManager entityManager)
{
this.entityManager = entityManager;
_entityManager = entityManager;
}
internal void AssignComponentManager(ComponentManager componentManager)
{
this.componentManager = componentManager;
_componentManager = componentManager;
}
internal void AssignMessageManager(MessageManager messageManager)
{
this.messageManager = messageManager;
_messageManager = messageManager;
}
internal void AssignTimeManager(TimeManager timeManager)
{
this.timeManager = timeManager;
_timeManager = timeManager;
}
internal void AssignTrackingManager(TrackingManager trackingManager)
{
this.trackingManager = trackingManager;
_trackingManager = trackingManager;
}
internal void CheckMessageRead<TMessage>() where TMessage : struct, IMessage
{
if (!receiveTypes.Contains(typeof(TMessage)))
if (!ReceiveTypes.Contains(typeof(TMessage)))
{
throw new IllegalReadException("Engine {0} tried to read undeclared Message {1}", this.GetType().Name, typeof(TMessage).Name);
}
@ -189,7 +189,7 @@ namespace Encompass
/// </summary>
protected Entity CreateEntity()
{
var entity = entityManager.CreateEntity();
var entity = _entityManager.CreateEntity();
_newlyCreatedEntities.Add(entity.ID);
return entity;
}
@ -197,9 +197,9 @@ namespace Encompass
/// <summary>
/// Returns true if an Entity with the specified ID exists.
/// </summary>
protected bool EntityExists(Entity entity)
protected bool EntityExists(in Entity entity)
{
return entityManager.EntityExists(entity.ID);
return _entityManager.EntityExists(entity.ID);
}
/// <summary>
@ -207,50 +207,52 @@ namespace Encompass
/// </summary>
protected bool EntityExists(int entityID)
{
return entityManager.EntityExists(entityID);
}
/// <summary>
/// Returns an Entity containing the specified Component type.
/// </summary>
protected Entity ReadEntity<TComponent>() where TComponent : struct, IComponent
{
return entityManager.GetEntity(ReadComponentHelper<TComponent>().Item2);
return _entityManager.EntityExists(entityID);
}
/// <summary>
/// Returns all Entities containing the specified Component type.
/// </summary>
protected IEnumerable<Entity> ReadEntities<TComponent>() where TComponent : struct, IComponent
protected Span<Entity> ReadEntities<TComponent>() where TComponent : struct, IComponent
{
foreach (var pair in ReadComponentsHelper<TComponent>())
{
yield return entityManager.GetEntity(pair.Item2);
}
}
// these next two are for the ComponentMessageEmitter only
internal IEnumerable<TComponent> ReadComponentsFromWorld<TComponent>() where TComponent : struct, IComponent
{
return componentManager.GetComponentsByType<TComponent>();
}
private IEnumerable<(TComponent, int)> ReadComponentsHelper<TComponent>() where TComponent : struct, IComponent
{
var immediateRead = readImmediateTypes.Contains(typeof(TComponent));
var existingRead = readTypes.Contains(typeof(TComponent));
var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead)
{
return componentManager.ReadExistingAndImmediateComponentsByType<TComponent>();
return _componentManager.GetExistingAndImmediateEntities<TComponent>();
}
else if (existingRead)
{
return componentManager.GetComponentsIncludingEntity<TComponent>();
return _componentManager.GetExistingEntities<TComponent>();
}
else if (immediateRead)
{
return componentManager.ReadImmediateComponentsByType<TComponent>();
return _componentManager.GetImmediateEntities<TComponent>();
}
else
{
throw new IllegalReadException("Engine {0} tried to read undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
}
}
/// <summary>
/// Returns an Entity containing the specified Component type.
/// </summary>
protected ref readonly Entity ReadEntity<TComponent>() where TComponent : struct, IComponent
{
var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead)
{
return ref _componentManager.ExistingOrImmediateSingularEntity<TComponent>();
}
else if (existingRead)
{
return ref _componentManager.ExistingSingularEntity<TComponent>();
}
else if (immediateRead)
{
return ref _componentManager.ImmediateSingularEntity<TComponent>();
}
else
{
@ -261,40 +263,21 @@ namespace Encompass
/// <summary>
/// Returns all of the Components with the specified Component Type.
/// </summary>
protected IEnumerable<TComponent> ReadComponents<TComponent>() where TComponent : struct, IComponent
protected Span<TComponent> ReadComponents<TComponent>() where TComponent : struct, IComponent
{
foreach (var pair in ReadComponentsHelper<TComponent>())
{
yield return pair.Item1;
}
}
/// <summary>
/// Returns all of the components of the specified type including an Entity reference for each Component.
/// </summary>
protected IEnumerable<(TComponent, Entity)> ReadComponentsIncludingEntity<TComponent>() where TComponent : struct, IComponent
{
foreach (var (component, id) in ReadComponentsHelper<TComponent>())
{
yield return (component, entityManager.GetEntity(id));
}
}
private (TComponent, int) ReadComponentHelper<TComponent>() where TComponent : struct, IComponent
{
var immediateRead = readImmediateTypes.Contains(typeof(TComponent));
var existingRead = readTypes.Contains(typeof(TComponent));
var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead)
{
return componentManager.ReadFirstExistingOrImmediateComponentByType<TComponent>();
return _componentManager.ReadExistingAndImmediateComponentsByType<TComponent>();
}
else if (existingRead)
{
return componentManager.ReadFirstExistingComponentByType<TComponent>();
return _componentManager.GetExistingComponents<TComponent>();
}
else if (immediateRead)
{
return componentManager.ReadFirstImmediateComponentByType<TComponent>();
return _componentManager.ReadImmediateComponentsByType<TComponent>();
}
else
{
@ -305,38 +288,21 @@ namespace Encompass
/// <summary>
/// Returns a Component with the specified Component Type. If multiples exist, an arbitrary Component is returned.
/// </summary>
protected TComponent ReadComponent<TComponent>() where TComponent : struct, IComponent
protected ref readonly TComponent ReadComponent<TComponent>() where TComponent : struct, IComponent
{
return ReadComponentHelper<TComponent>().Item1;
}
/// <summary>
/// Returns a component of the specified type including its Entity reference. If multiples exist, an arbitrary Component is returned.
/// </summary>
protected (TComponent, Entity) ReadComponentIncludingEntity<TComponent>() where TComponent : struct, IComponent
{
var (component, id) = ReadComponentHelper<TComponent>();
return (component, entityManager.GetEntity(id));
}
/// <summary>
/// Returns true if any Component with the specified Component Type exists.
/// </summary>
protected bool SomeComponent<TComponent>() where TComponent : struct, IComponent
{
var immediateRead = readImmediateTypes.Contains(typeof(TComponent));
var existingRead = readTypes.Contains(typeof(TComponent));
var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead)
{
return componentManager.SomeExistingOrImmediateComponent<TComponent>();
return ref _componentManager.ExistingOrImmediateSingular<TComponent>();
}
else if (existingRead)
{
return componentManager.SomeExistingComponent<TComponent>();
return ref _componentManager.ExistingSingular<TComponent>();
}
else if (immediateRead)
{
return componentManager.SomeImmediateComponent<TComponent>();
return ref _componentManager.ImmediateSingular<TComponent>();
}
else
{
@ -344,21 +310,46 @@ namespace Encompass
}
}
private TComponent GetComponentHelper<TComponent>(int entityID) where TComponent : struct, IComponent
/// <summary>
/// Returns true if any Component with the specified Component Type exists.
/// </summary>
protected bool SomeComponent<TComponent>() where TComponent : struct, IComponent
{
var immediateRead = readImmediateTypes.Contains(typeof(TComponent));
var existingRead = readTypes.Contains(typeof(TComponent));
var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead)
{
return componentManager.ReadImmediateOrExistingComponentByEntityAndType<TComponent>(entityID);
return _componentManager.SomeExistingOrImmediateComponent<TComponent>();
}
else if (existingRead)
{
return componentManager.ReadExistingComponentByEntityAndType<TComponent>(entityID);
return _componentManager.SomeExistingComponent<TComponent>();
}
else if (immediateRead)
{
return componentManager.ReadImmediateComponentByEntityAndType<TComponent>(entityID);
return _componentManager.SomeImmediateComponent<TComponent>();
}
else
{
throw new IllegalReadException("Engine {0} tried to read undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
}
}
private ref TComponent GetComponentHelper<TComponent>(int entityID) where TComponent : struct, IComponent
{
var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead)
{
return ref _componentManager.ReadImmediateOrExistingComponentByEntityAndType<TComponent>(entityID);
}
else if (existingRead)
{
return ref _componentManager.ReadExistingComponentByEntityAndType<TComponent>(entityID);
}
else if (immediateRead)
{
return ref _componentManager.ReadImmediateComponentByEntityAndType<TComponent>(entityID);
}
else
{
@ -375,9 +366,9 @@ namespace Encompass
/// <exception cref="Encompass.Exceptions.IllegalReadException">
/// Thrown when the Engine does not declare that it reads the given Component Type.
/// </exception>
protected TComponent GetComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
protected ref readonly TComponent GetComponent<TComponent>(in Entity entity) where TComponent : struct, IComponent
{
return GetComponentHelper<TComponent>(entity.ID);
return ref GetComponentHelper<TComponent>(entity.ID);
}
/// <summary>
@ -386,22 +377,22 @@ namespace Encompass
/// <exception cref="Encompass.Exceptions.IllegalReadException">
/// Thrown when the Engine does not declare that is Reads the given Component Type.
/// </exception>
protected bool HasComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
protected bool HasComponent<TComponent>(in Entity entity) where TComponent : struct, IComponent
{
var immediateRead = readImmediateTypes.Contains(typeof(TComponent));
var existingRead = readTypes.Contains(typeof(TComponent));
var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = ReadTypes.Contains(typeof(TComponent));
if (immediateRead && existingRead)
{
return componentManager.HasExistingOrImmediateComponent<TComponent>(entity.ID);
return _componentManager.HasExistingOrImmediateComponent<TComponent>(entity.ID);
}
else if (existingRead)
{
return componentManager.HasExistingComponent<TComponent>(entity.ID);
return _componentManager.HasExistingComponent<TComponent>(entity.ID);
}
else if (immediateRead)
{
return componentManager.HasImmediateComponent<TComponent>(entity.ID);
return _componentManager.HasImmediateComponent<TComponent>(entity.ID);
}
else
{
@ -415,22 +406,22 @@ namespace Encompass
/// <exception cref="Encompass.Exceptions.IllegalReadException">
/// Thrown when the Engine does not declare that is Reads the given Component Type.
/// </exception>
protected bool HasComponent(Entity entity, Type type)
protected bool HasComponent(in Entity entity, Type type)
{
var immediateRead = readImmediateTypes.Contains(type);
var existingRead = readTypes.Contains(type);
var immediateRead = ReadImmediateTypes.Contains(type);
var existingRead = ReadTypes.Contains(type);
if (immediateRead && existingRead)
{
return componentManager.HasExistingOrImmediateComponent(entity.ID, type);
return _componentManager.HasExistingOrImmediateComponent(entity.ID, type);
}
else if (existingRead)
{
return componentManager.HasExistingComponent(entity.ID, type);
return _componentManager.HasExistingComponent(entity.ID, type);
}
else if (immediateRead)
{
return componentManager.HasImmediateComponent(entity.ID, type);
return _componentManager.HasImmediateComponent(entity.ID, type);
}
else
{
@ -444,37 +435,37 @@ namespace Encompass
/// <exception cref="Encompass.Exceptions.IllegalWriteException">
/// Thrown when the Engine does not declare that it Writes the given Component Type.
/// </exception>
protected void SetComponent<TComponent>(Entity entity, TComponent component) where TComponent : struct, IComponent
protected void SetComponent<TComponent>(in Entity entity, in TComponent component) where TComponent : struct, IComponent
{
var priority = writePriorities.ContainsKey(typeof(TComponent)) ? writePriorities[typeof(TComponent)] : defaultWritePriority;
var priority = WritePriorities.ContainsKey(typeof(TComponent)) ? WritePriorities[typeof(TComponent)] : DefaultWritePriority;
if (!writeTypes.Contains(typeof(TComponent)))
if (!WriteTypes.Contains(typeof(TComponent)))
{
throw new IllegalWriteException("Engine {0} tried to update undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
}
bool written;
if (writeImmediateTypes.Contains(typeof(TComponent)))
if (WriteImmediateTypes.Contains(typeof(TComponent)))
{
written = componentManager.AddImmediateComponent(entity.ID, component, priority);
written = _componentManager.AddImmediateComponent(entity.ID, component, priority);
if (written)
{
trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent));
_trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent));
}
}
else
{
written = componentManager.UpdateComponent(entity.ID, component, priority);
written = _componentManager.UpdateComponent(entity.ID, component, priority);
}
if (!componentManager.HasExistingComponent<TComponent>(entity.ID))
if (!_componentManager.HasExistingComponent<TComponent>(entity.ID))
{
trackingManager.RegisterAddition(entity.ID, typeof(TComponent));
_trackingManager.RegisterAddition(entity.ID, typeof(TComponent));
}
if (written && component is IDrawableComponent drawableComponent)
{
componentManager.RegisterDrawableComponent(entity.ID, component, drawableComponent.Layer);
_componentManager.RegisterDrawableComponent<TComponent>(entity.ID, drawableComponent.Layer);
}
}
@ -484,28 +475,28 @@ namespace Encompass
/// <exception cref="Encompass.Exceptions.IllegalWriteException">
/// Thrown when the Engine does not declare that it Writes the given Component Type.
/// </exception>
protected void AddComponent<TComponent>(Entity entity, TComponent component) where TComponent : struct, IComponent
protected void AddComponent<TComponent>(in Entity entity, in TComponent component) where TComponent : struct, IComponent
{
if (!EntityCreatedThisFrame(entity.ID))
{
throw new IllegalWriteException("AddComponent used on Entity that was not created in this context. Use SetComponent instead.");
}
if (writeImmediateTypes.Contains(typeof(TComponent)))
if (WriteImmediateTypes.Contains(typeof(TComponent)))
{
componentManager.AddImmediateComponent(entity.ID, component);
trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent));
_componentManager.AddImmediateComponent(entity.ID, component);
_trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent));
}
else
{
componentManager.AddComponent(entity.ID, component);
_componentManager.AddComponent(entity.ID, component);
}
trackingManager.RegisterAddition(entity.ID, typeof(TComponent));
_trackingManager.RegisterAddition(entity.ID, typeof(TComponent));
if (component is IDrawableComponent drawableComponent)
{
componentManager.RegisterDrawableComponent(entity.ID, component, drawableComponent.Layer);
_componentManager.RegisterDrawableComponent<TComponent>(entity.ID, drawableComponent.Layer);
}
}
@ -515,32 +506,32 @@ namespace Encompass
/// <exception cref="Encompass.Exceptions.IllegalSendException">
/// Thrown when the Engine does not declare that it Sends the Message Type.
/// </exception>
protected void SendMessage<TMessage>(TMessage message) where TMessage : struct, IMessage
protected void SendMessage<TMessage>(in TMessage message) where TMessage : struct, IMessage
{
if (!sendTypes.Contains(typeof(TMessage)))
if (!SendTypes.Contains(typeof(TMessage)))
{
throw new IllegalSendException("Engine {0} tried to send undeclared Message {1}", GetType().Name, typeof(TMessage).Name);
}
messageManager.AddMessage(message);
_messageManager.AddMessage(message);
}
/// <summary>
/// Sends a message after the specified number of seconds, respecting time dilation.
/// </summary>
/// <param name="time">The time in seconds that will elapse before the message is sent.</param>
protected void SendMessage<TMessage>(TMessage message, double time) where TMessage : struct, IMessage
protected void SendMessage<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
{
messageManager.AddMessage(message, time);
_messageManager.AddMessage(message, time);
}
/// <summary>
/// Sends a message after the specified number of seconds, ignoring time dilation.
/// </summary>
/// <param name="time">The time in seconds that will elapse before the message is sent.</param>
protected void SendMessageIgnoringTimeDilation<TMessage>(TMessage message, double time) where TMessage : struct, IMessage
protected void SendMessageIgnoringTimeDilation<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
{
messageManager.AddMessageIgnoringTimeDilation(message, time);
_messageManager.AddMessageIgnoringTimeDilation(message, time);
}
/// <summary>
@ -549,10 +540,10 @@ namespace Encompass
/// <exception cref="Encompass.Exceptions.IllegalReadException">
/// Thrown when the Engine does not declare that it Receives the specified Message Type.
/// </exception>
protected IEnumerable<TMessage> ReadMessages<TMessage>() where TMessage : struct, IMessage
protected Span<TMessage> ReadMessages<TMessage>() where TMessage : struct, IMessage
{
CheckMessageRead<TMessage>();
return messageManager.GetMessagesByType<TMessage>();
return _messageManager.GetMessagesByType<TMessage>();
}
/// <summary>
@ -561,10 +552,10 @@ namespace Encompass
/// <exception cref="Encompass.Exceptions.IllegalReadException">
/// Thrown when the Engine does not declare that it Receives the specified Message Type.
/// </exception>
protected TMessage ReadMessage<TMessage>() where TMessage : struct, IMessage
protected ref readonly TMessage ReadMessage<TMessage>() where TMessage : struct, IMessage
{
CheckMessageRead<TMessage>();
return messageManager.First<TMessage>();
return ref _messageManager.First<TMessage>();
}
/// <summary>
@ -576,16 +567,16 @@ namespace Encompass
protected bool SomeMessage<TMessage>() where TMessage : struct, IMessage
{
CheckMessageRead<TMessage>();
return messageManager.Any<TMessage>();
return _messageManager.Any<TMessage>();
}
/// <summary>
/// Destroys the specified Entity. This also removes all of the Components associated with the Entity.
/// Entity destruction takes place after all the Engines have been processed by World Update.
/// </summary>
protected void Destroy(Entity entity)
protected void Destroy(in Entity entity)
{
entityManager.MarkForDestroy(entity.ID);
_entityManager.MarkForDestroy(entity.ID);
}
/// <summary>
@ -614,30 +605,30 @@ namespace Encompass
/// Note that the Engine must Read the Component type that is being removed.
/// If a Component with the specified type does not exist on the Entity, returns false and does not mutate the Entity.
/// </summary>
protected void RemoveComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
protected void RemoveComponent<TComponent>(in Entity entity) where TComponent : struct, IComponent
{
var priority = writePriorities.ContainsKey(typeof(TComponent)) ? writePriorities[typeof(TComponent)] : defaultWritePriority;
var priority = WritePriorities.ContainsKey(typeof(TComponent)) ? WritePriorities[typeof(TComponent)] : DefaultWritePriority;
if (!writeTypes.Contains(typeof(TComponent)))
if (!WriteTypes.Contains(typeof(TComponent)))
{
throw new IllegalWriteException("Engine {0} tried to remove undeclared Component {1}. Declare with Writes attribute.", GetType().Name, typeof(TComponent).Name);
}
if (writeImmediateTypes.Contains(typeof(TComponent)))
if (WriteImmediateTypes.Contains(typeof(TComponent)))
{
if (componentManager.RemoveImmediate<TComponent>(entity.ID, priority))
if (_componentManager.RemoveImmediate<TComponent>(entity.ID, priority))
{
trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent));
_trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent));
}
}
else
{
componentManager.Remove<TComponent>(entity.ID, priority);
_componentManager.Remove<TComponent>(entity.ID, priority);
}
if (componentManager.HasExistingComponent<TComponent>(entity.ID))
if (_componentManager.HasExistingComponent<TComponent>(entity.ID))
{
trackingManager.RegisterRemoval(entity.ID, typeof(TComponent));
_trackingManager.RegisterRemoval(entity.ID, typeof(TComponent));
}
}
@ -652,7 +643,7 @@ namespace Encompass
/// <param name="easeOutTime">The time that will elapse before time is fully undilated.</param>
protected void ActivateTimeDilation(double factor, double easeInTime, double activeTime, double easeOutTime)
{
timeManager.ActivateTimeDilation(factor, easeInTime, activeTime, easeOutTime);
_timeManager.ActivateTimeDilation(factor, easeInTime, activeTime, easeOutTime);
}
/// <summary>
@ -667,7 +658,7 @@ namespace Encompass
/// <param name="easeOutTime">The time that will elapse before time is fully undilated.</param>
protected void ActivateTimeDilation(double factor, double easeInTime, System.Func<double, double, double, double, double> easeInFunction, double activeTime, double easeOutTime)
{
timeManager.ActivateTimeDilation(factor, easeInTime, easeInFunction, activeTime, easeOutTime);
_timeManager.ActivateTimeDilation(factor, easeInTime, easeInFunction, activeTime, easeOutTime);
}
/// <summary>
@ -682,7 +673,7 @@ namespace Encompass
/// <param name="easeOutFunction">An easing function for the easing out of time dilation.</param>
protected void ActivateTimeDilation(double factor, double easeInTime, double activeTime, double easeOutTime, System.Func<double, double, double, double, double> easeOutFunction)
{
timeManager.ActivateTimeDilation(factor, easeInTime, activeTime, easeOutTime, easeOutFunction);
_timeManager.ActivateTimeDilation(factor, easeInTime, activeTime, easeOutTime, easeOutFunction);
}
/// <summary>
@ -698,7 +689,7 @@ namespace Encompass
/// <param name="easeOutFunction">An easing function for the easing out of time dilation.</param>
protected void ActivateTimeDilation(double factor, double easeInTime, System.Func<double, double, double, double, double> easeInFunction, double activeTime, double easeOutTime, System.Func<double, double, double, double, double> easeOutFunction)
{
timeManager.ActivateTimeDilation(factor, easeInTime, easeInFunction, activeTime, easeOutTime, easeOutFunction);
_timeManager.ActivateTimeDilation(factor, easeInTime, easeInFunction, activeTime, easeOutTime, easeOutFunction);
}
/// <summary>
@ -707,38 +698,38 @@ namespace Encompass
/// <typeparam name="TMessage">The Message subtype.</typeparam>
/// <param name="entity">The entity that all messages in the IEnumerable refer to.</param>
/// <returns></returns>
protected IEnumerable<TMessage> ReadMessagesWithEntity<TMessage>(Entity entity) where TMessage : struct, IMessage, IHasEntity
protected IEnumerable<TMessage> ReadMessagesWithEntity<TMessage>(in Entity entity) where TMessage : struct, IMessage, IHasEntity
{
CheckMessageRead<TMessage>();
return messageManager.WithEntity<TMessage>(entity.ID);
return _messageManager.WithEntity<TMessage>(entity.ID);
}
/// <summary>
/// Efficiently reads a single Message of a given type that references a given Entity.
/// It is recommended to use this method in conjunction with SomeMessageWithEntity to prevent errors.
/// </summary>
protected TMessage ReadMessageWithEntity<TMessage>(Entity entity) where TMessage : struct, IMessage, IHasEntity
protected ref readonly TMessage ReadMessageWithEntity<TMessage>(in Entity entity) where TMessage : struct, IMessage, IHasEntity
{
CheckMessageRead<TMessage>();
return messageManager.WithEntitySingular<TMessage>(entity.ID);
return ref _messageManager.WithEntitySingular<TMessage>(entity.ID);
}
/// <summary>
/// Efficiently checks if any Message of a given type referencing a given Entity exists.
/// </summary>
protected bool SomeMessageWithEntity<TMessage>(Entity entity) where TMessage : struct, IMessage, IHasEntity
protected bool SomeMessageWithEntity<TMessage>(in Entity entity) where TMessage : struct, IMessage, IHasEntity
{
CheckMessageRead<TMessage>();
return messageManager.SomeWithEntity<TMessage>(entity.ID);
return _messageManager.SomeWithEntity<TMessage>(entity.ID);
}
internal void CheckAndUpdateTracking(int entityID)
{
if (_trackedEntities.Contains(entityID) && !entityQuery.CheckEntity(entityID, componentManager.ExistingBits))
if (_trackedEntities.Contains(entityID) && !_entityQuery.CheckEntity(entityID, _componentManager.ExistingBits))
{
_trackedEntities.Remove(entityID);
}
else if (!_trackedEntities.Contains(entityID) && entityQuery.CheckEntity(entityID, componentManager.ExistingBits))
else if (!_trackedEntities.Contains(entityID) && _entityQuery.CheckEntity(entityID, _componentManager.ExistingBits))
{
_trackedEntities.Add(entityID);
}
@ -746,11 +737,11 @@ namespace Encompass
internal void ImmediateCheckAndUpdateTracking(int entityID)
{
if (_trackedEntities.Contains(entityID) && !entityQuery.ImmediateCheckEntity(entityID, componentManager.ImmediateBits, componentManager.ExistingBits))
if (_trackedEntities.Contains(entityID) && !_entityQuery.ImmediateCheckEntity(entityID, _componentManager.ImmediateBits, _componentManager.ExistingBits))
{
_trackedEntities.Remove(entityID);
}
else if (!_trackedEntities.Contains(entityID) && entityQuery.ImmediateCheckEntity(entityID, componentManager.ImmediateBits, componentManager.ExistingBits))
else if (!_trackedEntities.Contains(entityID) && _entityQuery.ImmediateCheckEntity(entityID, _componentManager.ImmediateBits, _componentManager.ExistingBits))
{
_trackedEntities.Add(entityID);
}
@ -762,30 +753,34 @@ namespace Encompass
internal void BuildEntityQuery()
{
var withMask = BitSet512.Zero;
foreach (var type in queryWithTypes)
foreach (var type in QueryWithTypes)
{
withMask = withMask.Set(componentManager.TypeToIndex[type]);
if (!_componentManager.TypeToIndex.ContainsKey(type)) { _componentManager.TypeToIndex.Add(type, _componentManager.TypeToIndex.Count); }
withMask = withMask.Set(_componentManager.TypeToIndex[type]);
}
var withoutMask = BitSet512.Zero;
foreach (var type in queryWithoutTypes)
foreach (var type in QueryWithoutTypes)
{
withoutMask = withoutMask.Set(componentManager.TypeToIndex[type]);
if (!_componentManager.TypeToIndex.ContainsKey(type)) { _componentManager.TypeToIndex.Add(type, _componentManager.TypeToIndex.Count); }
withoutMask = withoutMask.Set(_componentManager.TypeToIndex[type]);
}
var immediateMask = BitSet512.Zero;
foreach (var type in readImmediateTypes)
foreach (var type in ReadImmediateTypes)
{
immediateMask = immediateMask.Set(componentManager.TypeToIndex[type]);
if (!_componentManager.TypeToIndex.ContainsKey(type)) { _componentManager.TypeToIndex.Add(type, _componentManager.TypeToIndex.Count); }
immediateMask = immediateMask.Set(_componentManager.TypeToIndex[type]);
}
var existingMask = BitSet512.Zero;
foreach (var type in readTypes)
foreach (var type in ReadTypes)
{
existingMask = existingMask.Set(componentManager.TypeToIndex[type]);
if (!_componentManager.TypeToIndex.ContainsKey(type)) { _componentManager.TypeToIndex.Add(type, _componentManager.TypeToIndex.Count); }
existingMask = existingMask.Set(_componentManager.TypeToIndex[type]);
}
entityQuery = new EntitySetQuery(
_entityQuery = new EntitySetQuery(
withMask & immediateMask,
withMask & existingMask,
withoutMask & immediateMask,

View File

@ -13,10 +13,10 @@ namespace Encompass
var readsAttribute = GetType().GetCustomAttribute<Reads>(false);
if (readsAttribute != null)
{
readsAttribute.readTypes.Add(typeof(TMessage));
readsAttribute.ReadTypes.Add(typeof(TMessage));
}
receiveTypes.Add(typeof(TMessage));
ReceiveTypes.Add(typeof(TMessage));
}
public override void Update(double dt)

View File

@ -37,7 +37,7 @@ namespace Encompass
public override int GetHashCode()
{
return ID.GetHashCode();
return HashCode.Combine(ID);
}
}
}

View File

@ -5,48 +5,48 @@ namespace Encompass
{
internal class EntityManager
{
private readonly int entityCapacity;
private readonly IDManager idManager = new IDManager();
private readonly HashSet<int> IDs = new HashSet<int>();
private readonly int _entityCapacity;
private readonly IDManager _idManager = new IDManager();
private readonly HashSet<int> _ids = new HashSet<int>();
private readonly HashSet<int> entitiesMarkedForDestroy = new HashSet<int>();
private readonly HashSet<int> _entitiesMarkedForDestroy = new HashSet<int>();
private readonly ComponentManager componentManager;
private readonly ComponentManager _componentManager;
public IEnumerable<int> EntityIDs
{
get { return IDs; }
get { return _ids; }
}
public EntityManager(ComponentManager componentManager, int entityCapacity)
{
this.componentManager = componentManager;
this.entityCapacity = entityCapacity;
_componentManager = componentManager;
_entityCapacity = entityCapacity;
}
private int NextID()
{
return idManager.NextID();
return _idManager.NextID();
}
public Entity CreateEntity()
{
if (IDs.Count < entityCapacity)
if (_ids.Count < _entityCapacity)
{
var id = NextID();
var entity = new Entity(id);
IDs.Add(id);
_ids.Add(id);
return entity;
}
else
{
throw new EntityOverflowException("The number of entities has exceeded the entity capacity of {0}", entityCapacity);
throw new EntityOverflowException("The number of entities has exceeded the entity capacity of {0}", _entityCapacity);
}
}
public bool EntityExists(int id)
{
return IDs.Contains(id);
return _ids.Contains(id);
}
public Entity GetEntity(int id)
@ -61,20 +61,20 @@ namespace Encompass
public void MarkForDestroy(int entityID)
{
entitiesMarkedForDestroy.Add(entityID);
_entitiesMarkedForDestroy.Add(entityID);
}
public void DestroyMarkedEntities(IEnumerable<Engine> engines)
{
foreach (var entityID in entitiesMarkedForDestroy)
foreach (var entityID in _entitiesMarkedForDestroy)
{
foreach (var engine in engines) { engine.RegisterDestroyedEntity(entityID); }
componentManager.MarkAllComponentsOnEntityForRemoval(entityID);
IDs.Remove(entityID);
idManager.Free(entityID);
_componentManager.MarkAllComponentsOnEntityForRemoval(entityID);
_ids.Remove(entityID);
_idManager.Free(entityID);
}
entitiesMarkedForDestroy.Clear();
_entitiesMarkedForDestroy.Clear();
}
// NOTE: this is very suboptimal
@ -82,7 +82,7 @@ namespace Encompass
{
foreach (var id in EntityIDs)
{
if (componentManager.UpToDateEntityIsEmpty(id))
if (_componentManager.UpToDateEntityIsEmpty(id))
{
MarkForDestroy(id);
}

View File

@ -1,12 +0,0 @@
using System;
namespace Encompass.Exceptions
{
public class IllegalReadTypeException : Exception
{
public IllegalReadTypeException(
string format,
params object[] args
) : base(string.Format(format, args)) { }
}
}

View File

@ -1,7 +0,0 @@
namespace Encompass
{
/// <summary>
/// Structs that implement IComponent are considered to be Components.
/// </summary>
public interface IComponent { }
}

View File

@ -4,25 +4,25 @@ namespace Encompass
{
internal class IDManager
{
int nextID = 0;
int _nextID = 0;
private Stack<int> availableIDs = new Stack<int>();
private readonly Stack<int> _availableIDs = new Stack<int>();
public int NextID()
{
if (availableIDs.Count > 0)
if (_availableIDs.Count > 0)
{
return availableIDs.Pop();
return _availableIDs.Pop();
}
else
{
return nextID++;
return _nextID++;
}
}
public void Free(int ID)
public void Free(int id)
{
availableIDs.Push(ID);
_availableIDs.Push(id);
}
}
}

View File

@ -0,0 +1,4 @@
namespace Encompass
{
public interface IComponent { }
}

View File

@ -2,6 +2,6 @@ namespace Encompass
{
public interface IDrawableComponent
{
int Layer { get; set; }
int Layer { get; }
}
}

View File

@ -1,72 +1,71 @@
using System;
using System.Collections.Generic;
namespace Encompass
{
internal class MessageManager
{
private readonly TimeManager timeManager;
private readonly MessageStore messageStore = new MessageStore();
private readonly TimeManager _timeManager;
private readonly MessageStore _messageStore = new MessageStore();
public MessageManager(TimeManager timeManager)
{
this.timeManager = timeManager;
_timeManager = timeManager;
}
internal void AddMessage<TMessage>(TMessage message) where TMessage : struct, IMessage
internal void AddMessage<TMessage>(in TMessage message) where TMessage : struct, IMessage
{
messageStore.AddMessage(message);
_messageStore.AddMessage(message);
}
internal void AddMessage<TMessage>(TMessage message, double time) where TMessage : struct, IMessage
internal void AddMessage<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
{
messageStore.AddMessage(message, time);
_messageStore.AddMessage(message, time);
}
internal void AddMessageIgnoringTimeDilation<TMessage>(TMessage message, double time) where TMessage : struct, IMessage
internal void AddMessageIgnoringTimeDilation<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
{
messageStore.AddMessageIgnoringTimeDilation(message, time);
_messageStore.AddMessageIgnoringTimeDilation(message, time);
}
internal void ClearMessages()
{
messageStore.ClearAll();
_messageStore.ClearAll();
}
internal void ProcessDelayedMessages(double dt)
{
messageStore.ProcessDelayedMessages(dt * timeManager.TimeDilationFactor, dt);
_messageStore.ProcessDelayedMessages(dt * _timeManager.TimeDilationFactor, dt);
}
internal IEnumerable<TMessage> GetMessagesByType<TMessage>() where TMessage : struct, IMessage
internal Span<TMessage> GetMessagesByType<TMessage>() where TMessage : struct, IMessage
{
return messageStore.All<TMessage>();
return _messageStore.All<TMessage>();
}
internal bool Any<TMessage>() where TMessage : struct, IMessage
{
return messageStore.Any<TMessage>();
return _messageStore.Any<TMessage>();
}
internal TMessage First<TMessage>() where TMessage : struct, IMessage
internal ref readonly TMessage First<TMessage>() where TMessage : struct, IMessage
{
return messageStore.First<TMessage>();
return ref _messageStore.First<TMessage>();
}
internal IEnumerable<TMessage> WithEntity<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity
{
return messageStore.WithEntity<TMessage>(entityID);
return _messageStore.WithEntity<TMessage>(entityID);
}
internal TMessage WithEntitySingular<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity
internal ref readonly TMessage WithEntitySingular<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity
{
var enumerator = messageStore.WithEntity<TMessage>(entityID).GetEnumerator();
enumerator.MoveNext();
return enumerator.Current;
return ref _messageStore.FirstWithEntity<TMessage>(entityID);
}
internal bool SomeWithEntity<TMessage>(int entityID) where TMessage : struct, IMessage, IHasEntity
{
return messageStore.SomeWithEntity<TMessage>(entityID);
return _messageStore.SomeWithEntity<TMessage>(entityID);
}
}
}

View File

@ -5,40 +5,40 @@ namespace Encompass
{
internal class RenderManager
{
private readonly EntityManager entityManager;
private readonly DrawLayerManager drawLayerManager;
private readonly EntityManager _entityManager;
private readonly DrawLayerManager _drawLayerManager;
private readonly Dictionary<Type, Action<Entity, IComponent>> drawComponentTypeToOrderedRenderer = new Dictionary<Type, Action<Entity, IComponent>>(256);
private readonly Dictionary<Type, Action<Entity>> _drawComponentTypeToOrderedRenderer = new Dictionary<Type, Action<Entity>>(256);
public RenderManager(EntityManager entityManager, DrawLayerManager drawLayerManager)
{
this.entityManager = entityManager;
this.drawLayerManager = drawLayerManager;
_entityManager = entityManager;
_drawLayerManager = drawLayerManager;
}
public void RegisterOrderedRenderer<TComponent>(Action<Entity, IComponent> renderAction) where TComponent : struct, IComponent
public void RegisterOrderedRenderer<TComponent>(Action<Entity> renderAction) where TComponent : struct
{
drawComponentTypeToOrderedRenderer.Add(typeof(TComponent), renderAction);
drawLayerManager.RegisterOrderedDrawable<TComponent>();
_drawComponentTypeToOrderedRenderer.Add(typeof(TComponent), renderAction);
_drawLayerManager.RegisterOrderedDrawable<TComponent>();
}
public void RegisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer)
{
drawLayerManager.RegisterGeneralRendererWithLayer(renderer, layer);
_drawLayerManager.RegisterGeneralRendererWithLayer(renderer, layer);
}
public void Draw()
{
foreach (var layer in drawLayerManager.LayerOrder)
foreach (var layer in _drawLayerManager.LayerOrder)
{
var generalRendererSet = drawLayerManager.GeneralRenderersByLayer(layer);
var generalRendererSet = _drawLayerManager.GeneralRenderersByLayer(layer);
foreach (var (entityID, componentType, component) in drawLayerManager.AllInLayer(layer))
foreach (var (entityID, componentType) in _drawLayerManager.AllInLayer(layer))
{
if (drawComponentTypeToOrderedRenderer.ContainsKey(componentType))
if (_drawComponentTypeToOrderedRenderer.ContainsKey(componentType))
{
var internalRenderAction = drawComponentTypeToOrderedRenderer[componentType];
internalRenderAction(entityManager.GetEntity(entityID), component);
var internalRenderAction = _drawComponentTypeToOrderedRenderer[componentType];
internalRenderAction(_entityManager.GetEntity(entityID));
}
}

View File

@ -1,75 +1,56 @@
using System.Collections.Generic;
using System;
using System.Collections.Generic;
namespace Encompass
{
public abstract class Renderer
{
internal EntityManager entityManager;
internal ComponentManager componentManager;
internal EntityManager _entityManager;
internal ComponentManager _componentManager;
internal void AssignEntityManager(EntityManager entityManager)
{
this.entityManager = entityManager;
_entityManager = entityManager;
}
internal void AssignComponentManager(ComponentManager componentManager)
{
this.componentManager = componentManager;
_componentManager = componentManager;
}
protected IEnumerable<Entity> ReadEntities<TComponent>() where TComponent : struct, IComponent
protected Span<Entity> ReadEntities<TComponent>() where TComponent : struct, IComponent
{
foreach (var pair in ReadComponentsIncludingEntity<TComponent>())
{
yield return pair.Item2;
}
return _componentManager.GetExistingEntities<TComponent>();
}
protected Entity ReadEntity<TComponent>() where TComponent : struct, IComponent
protected ref readonly Entity ReadEntity<TComponent>() where TComponent : struct, IComponent
{
return ReadComponentIncludingEntity<TComponent>().Item2;
return ref _componentManager.ExistingSingularEntity<TComponent>();
}
protected IEnumerable<TComponent> ReadComponents<TComponent>() where TComponent : struct, IComponent
protected Span<TComponent> ReadComponents<TComponent>() where TComponent : struct, IComponent
{
return componentManager.GetComponentsByType<TComponent>();
return _componentManager.GetComponentsByType<TComponent>();
}
protected IEnumerable<(TComponent, Entity)> ReadComponentsIncludingEntity<TComponent>() where TComponent : struct, IComponent
protected ref readonly TComponent ReadComponent<TComponent>() where TComponent : struct, IComponent
{
foreach (var (component, id) in componentManager.GetComponentsIncludingEntity<TComponent>())
{
yield return (component, entityManager.GetEntity(id));
}
return ref _componentManager.ExistingSingular<TComponent>();
}
protected TComponent ReadComponent<TComponent>() where TComponent : struct, IComponent
protected ref readonly TComponent GetComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
{
var enumerator = ReadComponents<TComponent>().GetEnumerator();
enumerator.MoveNext();
return enumerator.Current;
}
protected (TComponent, Entity) ReadComponentIncludingEntity<TComponent>() where TComponent : struct, IComponent
{
var enumerator = ReadComponentsIncludingEntity<TComponent>().GetEnumerator();
enumerator.MoveNext();
return enumerator.Current;
}
protected TComponent GetComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
{
return componentManager.GetComponentByEntityAndType<TComponent>(entity.ID);
return ref _componentManager.GetComponentByEntityAndType<TComponent>(entity.ID);
}
protected bool HasComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
{
return componentManager.EntityHasComponentOfType<TComponent>(entity.ID);
return _componentManager.EntityHasComponentOfType<TComponent>(entity.ID);
}
protected bool SomeComponent<TComponent>() where TComponent : struct, IComponent
{
return componentManager.SomeExistingComponent<TComponent>();
return _componentManager.SomeExistingComponent<TComponent>();
}
}
}

View File

@ -7,11 +7,12 @@ namespace Encompass
/// </summary>
public abstract class OrderedRenderer<TComponent> : Renderer where TComponent : struct, IComponent, IDrawableComponent
{
public abstract void Render(Entity entity, TComponent drawComponent);
public abstract void Render(Entity entity, in TComponent drawComponent);
internal void InternalRender(Entity entity, IComponent component)
internal void InternalRender(Entity entity)
{
Render(entity, (TComponent)component);
ref readonly var component = ref GetComponent<TComponent>(entity);
Render(entity, component);
}
}
}

View File

@ -1,35 +1,56 @@
using System;
namespace Encompass
{
internal struct TimeDilationData
{
public double elapsedTime;
public double easeInTime;
public System.Func<double, double, double, double, double> easeInFunction;
public double activeTime;
public double easeOutTime;
public System.Func<double, double, double, double, double> easeOutFunction;
public double factor;
private readonly double _factor;
public double Factor
{
get
{
if (elapsedTime < easeInTime)
if (ElapsedTime < EaseInTime)
{
return easeInFunction(elapsedTime, 1, factor - 1, easeInTime);
return EaseInFunction(ElapsedTime, 1, _factor - 1, EaseInTime);
}
else if (elapsedTime < easeInTime + activeTime)
else if (ElapsedTime < EaseInTime + ActiveTime)
{
return factor;
return _factor;
}
else if (elapsedTime < easeInTime + activeTime + easeOutTime)
else if (ElapsedTime < EaseInTime + ActiveTime + EaseOutTime)
{
var elapsedOutTime = elapsedTime - easeInTime - activeTime;
return easeOutFunction(elapsedOutTime, factor, 1 - factor, easeOutTime);
var elapsedOutTime = ElapsedTime - EaseInTime - ActiveTime;
return EaseOutFunction(elapsedOutTime, _factor, 1 - _factor, EaseOutTime);
}
return 1;
}
}
public double ElapsedTime { get; set; }
public double EaseInTime { get; }
public Func<double, double, double, double, double> EaseInFunction { get; }
public double ActiveTime { get; }
public double EaseOutTime { get; }
public Func<double, double, double, double, double> EaseOutFunction { get; }
public TimeDilationData(
double factor,
double easeInTime,
Func<double, double, double, double, double> easeInfunction,
double activeTime,
double easeOutTime,
Func<double, double, double, double, double> easeOutFunction
)
{
_factor = factor;
EaseInTime = easeInTime;
EaseInFunction = easeInfunction;
ActiveTime = activeTime;
EaseOutTime = easeOutTime;
EaseOutFunction = easeOutFunction;
ElapsedTime = 0;
}
}
}

View File

@ -4,7 +4,7 @@ namespace Encompass
{
internal class TimeManager
{
private readonly List<TimeDilationData> timeDilationDatas = new List<TimeDilationData>(32);
private readonly List<TimeDilationData> _timeDilationDatas = new List<TimeDilationData>(32);
private double Linear(double t, double b, double c, double d)
{
@ -15,36 +15,36 @@ namespace Encompass
{
get
{
if (timeDilationDatas.Count == 0) { return 1; }
if (_timeDilationDatas.Count == 0) { return 1; }
var average = 0.0;
foreach (var data in timeDilationDatas)
foreach (var data in _timeDilationDatas)
{
average += data.Factor;
}
return average / timeDilationDatas.Count;
return average / _timeDilationDatas.Count;
}
}
public bool TimeDilationActive
{
get => timeDilationDatas.Count != 0;
get => _timeDilationDatas.Count != 0;
}
public void Update(double dt)
{
for (var i = timeDilationDatas.Count - 1; i >= 0; i--)
for (var i = _timeDilationDatas.Count - 1; i >= 0; i--)
{
var data = timeDilationDatas[i];
var data = _timeDilationDatas[i];
data.elapsedTime += dt;
data.ElapsedTime += dt;
if (data.elapsedTime > data.easeInTime + data.activeTime + data.easeOutTime)
if (data.ElapsedTime > data.EaseInTime + data.ActiveTime + data.EaseOutTime)
{
timeDilationDatas.RemoveAt(i);
_timeDilationDatas.RemoveAt(i);
}
else
{
timeDilationDatas[i] = data;
_timeDilationDatas[i] = data;
}
}
}
@ -66,16 +66,15 @@ namespace Encompass
public void ActivateTimeDilation(double factor, double easeInTime, System.Func<double, double, double, double, double> easeInFunction, double activeTime, double easeOutTime, System.Func<double, double, double, double, double> easeOutFunction)
{
timeDilationDatas.Add(new TimeDilationData
{
elapsedTime = 0,
easeInTime = easeInTime,
easeInFunction = easeInFunction,
activeTime = activeTime,
easeOutTime = easeOutTime,
easeOutFunction = easeOutFunction,
factor = factor
});
_timeDilationDatas.Add(new TimeDilationData
(
factor,
easeInTime,
easeInFunction,
activeTime,
easeOutTime,
easeOutFunction
));
}
}
}

View File

@ -5,13 +5,13 @@ namespace Encompass
{
internal class TrackingManager
{
private Dictionary<Type, HashSet<Engine>> _immediateComponentTypesToEngines = new Dictionary<Type, HashSet<Engine>>();
private Dictionary<Type, HashSet<Engine>> _componentTypesToEngines = new Dictionary<Type, HashSet<Engine>>();
private readonly Dictionary<Type, HashSet<Engine>> _immediateComponentTypesToEngines = new Dictionary<Type, HashSet<Engine>>();
private readonly Dictionary<Type, HashSet<Engine>> _componentTypesToEngines = new Dictionary<Type, HashSet<Engine>>();
private HashSet<(int, Type)> _additions = new HashSet<(int, Type)>();
private HashSet<(int, Type)> _removals = new HashSet<(int, Type)>();
private readonly HashSet<(int, Type)> _additions = new HashSet<(int, Type)>();
private readonly HashSet<(int, Type)> _removals = new HashSet<(int, Type)>();
private HashSet<(int, Engine)> _pairsToCheck = new HashSet<(int, Engine)>();
private readonly HashSet<(int, Engine)> _pairsToCheck = new HashSet<(int, Engine)>();
public void RegisterComponentTypeToEngine(Type type, Engine engine)
{

View File

@ -2,23 +2,24 @@
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
namespace Encompass
{
internal class UberEngine : Engine
{
private IEnumerable<Type> _componentTypes;
private IEnumerable<Type> _messageTypes;
private readonly IEnumerable<Type> _componentTypes;
private readonly IEnumerable<Type> _messageTypes;
public Entity Entity { get; private set; }
public UberEngine(IEnumerable<Type> componentTypes, IEnumerable<Type> messageTypes)
{
_componentTypes = componentTypes;
_messageTypes = messageTypes;
readTypes.UnionWith(componentTypes);
writeTypes.UnionWith(componentTypes);
sendTypes.UnionWith(messageTypes);
receiveTypes.UnionWith(messageTypes);
ReadTypes.UnionWith(componentTypes);
WriteTypes.UnionWith(componentTypes);
SendTypes.UnionWith(messageTypes);
ReceiveTypes.UnionWith(messageTypes);
}
public void Write()
@ -39,17 +40,15 @@ namespace Encompass
foreach (var type in _componentTypes)
{
CallGenericMethod(type, "ReadComponent", null);
CallGenericMethod(type, "ReadComponentIncludingEntity", null);
CallGenericMethod(type, "ReadComponents", null);
CallGenericMethod(type, "ReadComponentsIncludingEntity", null);
CallGenericWrappedMethod(type, "ReadComponentsWrapper", null);
CallGenericMethod(type, "ReadEntity", null);
CallGenericMethod(type, "ReadEntities", null);
CallGenericMethod(type, "GetComponent", new Type[] { typeof(Entity) }, new object[] { Entity });
CallGenericMethod(type, "HasComponent", new Type[] { typeof(Entity) }, new object[] { Entity });
CallGenericWrappedMethod(type, "ReadEntitiesWrapper", null);
CallGenericMethod(type, "GetComponent", new object[] { Entity });
CallGenericMethod(type, "HasComponent", 1, new object[] { Entity });
CallGenericMethod(type, "SomeComponent", null);
CallGenericMethod(type, "DestroyWith", null);
CallGenericMethod(type, "DestroyAllWith", null);
CallGenericMethod(type, "RemoveComponent", new Type[] { typeof(Entity) }, new object[] { Entity });
CallGenericMethod(type, "RemoveComponent", new object[] { Entity });
}
foreach (var type in _messageTypes)
@ -58,20 +57,49 @@ namespace Encompass
CallGenericMethod(type, "SendMessage", 1, new object[] { Activator.CreateInstance(type) });
CallGenericMethod(type, "SendMessage", 2, new object[] { Activator.CreateInstance(type), 1 });
CallGenericMethod(type, "ReadMessage", null);
CallGenericMethod(type, "ReadMessages", null);
CallGenericWrappedMethod(type, "ReadMessagesWrapper", null);
CallGenericMethod(type, "SomeMessage", null);
if (typeof(IHasEntity).IsAssignableFrom(type))
{
CallGenericMethod(type, "ReadMessagesWithEntity", new Type[] { typeof(Entity) }, new object[] { Entity });
CallGenericMethod(type, "ReadMessagesWithEntity", new object[] { Entity });
CallGenericMethod(type, "ReadMessageWithEntity", new object[] { Entity });
CallGenericMethod(type, "SomeMessageWithEntity", new object[] { Entity });
}
}
}
// we can't reflect invoke on Span returns right now... so we have non-return wrapper methods
protected void ReadComponentsWrapper<TComponent>() where TComponent : struct, IComponent
{
ReadComponents<TComponent>();
}
protected void ReadMessagesWrapper<TMessage>() where TMessage : struct, IMessage
{
ReadMessages<TMessage>();
}
protected void ReadEntitiesWrapper<TComponent>() where TComponent : struct, IComponent
{
ReadEntities<TComponent>();
}
// trying to use PrepareMethod because we can't reflect invoke methods that return a span...
private void CallGenericMethod(Type type, string methodName, object[] parameters)
{
var readComponentMethod = typeof(Engine).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
var genericReadComponentMethod = readComponentMethod.MakeGenericMethod(type);
genericReadComponentMethod.Invoke(this, parameters);
// RuntimeHelpers.PrepareMethod(genericReadComponentMethod.MethodHandle);
}
private void CallGenericWrappedMethod(Type type, string methodName, object[] parameters)
{
var readComponentMethod = typeof(UberEngine).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
var genericReadComponentMethod = readComponentMethod.MakeGenericMethod(type);
genericReadComponentMethod.Invoke(this, parameters);
}
private void CallGenericMethod(Type type, string methodName, Type[] types, object[] parameters)
@ -79,6 +107,7 @@ namespace Encompass
var readComponentMethod = typeof(Engine).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance, null, types, null);
var genericReadComponentMethod = readComponentMethod.MakeGenericMethod(type);
genericReadComponentMethod.Invoke(this, parameters);
// RuntimeHelpers.PrepareMethod(genericReadComponentMethod.MethodHandle);
}
private void CallGenericMethod(Type type, string methodName, int argumentNum, object[] parameters)
@ -86,6 +115,7 @@ namespace Encompass
var method = typeof(Engine).GetRuntimeMethods().Where(m => m.Name == methodName && m.GetParameters().Length == argumentNum).First();
var genericMethod = method.MakeGenericMethod(type);
genericMethod.Invoke(this, parameters);
// RuntimeHelpers.PrepareMethod(genericMethod.MethodHandle);
}
}
}

View File

@ -6,7 +6,7 @@ namespace Encompass
{
class UberRenderer : Renderer
{
private IEnumerable<Type> _componentTypes;
private readonly IEnumerable<Type> _componentTypes;
private Entity _entity;
public UberRenderer(IEnumerable<Type> componentTypes)
@ -19,27 +19,43 @@ namespace Encompass
_entity = entity;
}
// can't reflect invoke on Span returns...
public void Render()
{
foreach (var type in _componentTypes)
{
CallGenericMethod(type, "ReadEntities", null);
CallGenericWrappedMethod(type, "ReadEntitiesWrapper", null);
CallGenericMethod(type, "ReadEntity", null);
CallGenericWrappedMethod(type, "ReadComponentsWrapper", null);
CallGenericMethod(type, "ReadComponent", null);
CallGenericMethod(type, "ReadComponentIncludingEntity", null);
CallGenericMethod(type, "ReadComponents", null);
CallGenericMethod(type, "ReadComponentsIncludingEntity", null);
CallGenericMethod(type, "GetComponent", new object[] { _entity });
CallGenericMethod(type, "HasComponent", new object[] { _entity });
CallGenericMethod(type, "SomeComponent", null);
}
}
protected void ReadEntitiesWrapper<TComponent>() where TComponent : struct, IComponent
{
ReadEntities<TComponent>();
}
protected void ReadComponentsWrapper<TComponent>() where TComponent : struct, IComponent
{
ReadComponents<TComponent>();
}
private void CallGenericMethod(Type type, string methodName, object[] parameters)
{
var readComponentMethod = typeof(Renderer).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
var genericReadComponentMethod = readComponentMethod.MakeGenericMethod(type);
genericReadComponentMethod.Invoke(this, parameters);
}
private void CallGenericWrappedMethod(Type type, string methodName, object[] parameters)
{
var readComponentMethod = typeof(UberRenderer).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
var genericReadComponentMethod = readComponentMethod.MakeGenericMethod(type);
genericReadComponentMethod.Invoke(this, parameters);
}
}
}

View File

@ -7,13 +7,13 @@ namespace Encompass
/// </summary>
public class World
{
private readonly List<Engine> enginesInOrder;
private readonly EntityManager entityManager;
private readonly ComponentManager componentManager;
private readonly TrackingManager trackingManager;
private readonly MessageManager messageManager;
private readonly TimeManager timeManager;
private readonly RenderManager renderManager;
private readonly List<Engine> _enginesInOrder;
private readonly EntityManager _entityManager;
private readonly ComponentManager _componentManager;
private readonly TrackingManager _trackingManager;
private readonly MessageManager _messageManager;
private readonly TimeManager _timeManager;
private readonly RenderManager _renderManager;
internal World(
List<Engine> enginesInOrder,
@ -25,13 +25,13 @@ namespace Encompass
RenderManager renderManager
)
{
this.enginesInOrder = enginesInOrder;
this.entityManager = entityManager;
this.componentManager = componentManager;
this.trackingManager = trackingManager;
this.messageManager = messageManager;
this.timeManager = timeManager;
this.renderManager = renderManager;
_enginesInOrder = enginesInOrder;
_entityManager = entityManager;
_componentManager = componentManager;
_trackingManager = trackingManager;
_messageManager = messageManager;
_timeManager = timeManager;
_renderManager = renderManager;
}
/// <summary>
@ -40,15 +40,15 @@ namespace Encompass
/// <param name="dt">The time in seconds that has passed since the previous frame.</param>
public void Update(double dt)
{
trackingManager.UpdateTracking();
messageManager.ProcessDelayedMessages(dt);
timeManager.Update(dt);
_trackingManager.UpdateTracking();
_messageManager.ProcessDelayedMessages(dt);
_timeManager.Update(dt);
foreach (var engine in enginesInOrder)
foreach (var engine in _enginesInOrder)
{
if (engine.usesTimeDilation)
if (engine._usesTimeDilation)
{
engine.Update(dt * timeManager.TimeDilationFactor);
engine.Update(dt * _timeManager.TimeDilationFactor);
}
else
{
@ -58,12 +58,12 @@ namespace Encompass
engine.ClearNewlyCreatedEntities();
}
messageManager.ClearMessages();
entityManager.PruneEmptyEntities();
entityManager.DestroyMarkedEntities(enginesInOrder);
_messageManager.ClearMessages();
_entityManager.PruneEmptyEntities();
_entityManager.DestroyMarkedEntities(_enginesInOrder);
componentManager.RemoveMarkedComponents();
componentManager.WriteComponents();
_componentManager.RemoveMarkedComponents();
_componentManager.WriteComponents();
}
/// <summary>
@ -71,7 +71,7 @@ namespace Encompass
/// </summary>
public void Draw()
{
renderManager.Draw();
_renderManager.Draw();
}
}
}

View File

@ -18,43 +18,43 @@ namespace Encompass
/// </remarks>
public class WorldBuilder
{
private readonly int entityCapacity;
private readonly List<Engine> engines = new List<Engine>();
private readonly DirectedGraph<Engine, Unit> engineGraph = GraphBuilder.DirectedGraph<Engine>();
private readonly ComponentStore startingExistingComponentStore;
private readonly ComponentStore startingUpToDateComponentStore;
private readonly int _entityCapacity;
private readonly List<Engine> _engines = new List<Engine>();
private readonly DirectedGraph<Engine, Unit> _engineGraph = GraphBuilder.DirectedGraph<Engine>();
private readonly ComponentStore _startingExistingComponentStore;
private readonly ComponentStore _startingUpToDateComponentStore;
private readonly ComponentManager componentManager;
private readonly EntityManager entityManager;
private readonly MessageManager messageManager;
private readonly TimeManager timeManager;
private readonly DrawLayerManager drawLayerManager;
private readonly RenderManager renderManager;
private readonly TrackingManager trackingManager;
private readonly ComponentManager _componentManager;
private readonly EntityManager _entityManager;
private readonly MessageManager _messageManager;
private readonly TimeManager _timeManager;
private readonly DrawLayerManager _drawLayerManager;
private readonly RenderManager _renderManager;
private readonly TrackingManager _trackingManager;
private readonly Dictionary<Type, HashSet<Engine>> typeToReaders = new Dictionary<Type, HashSet<Engine>>();
private readonly Dictionary<Type, HashSet<Engine>> _typeToReaders = new Dictionary<Type, HashSet<Engine>>();
private readonly HashSet<Engine> senders = new HashSet<Engine>();
private readonly HashSet<Engine> _senders = new HashSet<Engine>();
private readonly HashSet<Type> componentTypesToPreload = new HashSet<Type>();
private readonly HashSet<Type> _componentTypesToPreload = new HashSet<Type>();
private readonly HashSet<Type> messageTypes = new HashSet<Type>();
private readonly HashSet<Type> _messageTypes = new HashSet<Type>();
private readonly Dictionary<Type, int> typeToIndex = new Dictionary<Type, int>();
private readonly Dictionary<Type, int> _typeToIndex = new Dictionary<Type, int>();
public WorldBuilder(int entityCapacity = 32768)
{
this.entityCapacity = entityCapacity;
drawLayerManager = new DrawLayerManager(typeToIndex);
timeManager = new TimeManager();
trackingManager = new TrackingManager();
componentManager = new ComponentManager(drawLayerManager, typeToIndex);
messageManager = new MessageManager(timeManager);
entityManager = new EntityManager(componentManager, entityCapacity);
renderManager = new RenderManager(entityManager, drawLayerManager);
_entityCapacity = entityCapacity;
_drawLayerManager = new DrawLayerManager();
_timeManager = new TimeManager();
_trackingManager = new TrackingManager();
_componentManager = new ComponentManager(_drawLayerManager, _typeToIndex);
_messageManager = new MessageManager(_timeManager);
_entityManager = new EntityManager(_componentManager, entityCapacity);
_renderManager = new RenderManager(_entityManager, _drawLayerManager);
startingExistingComponentStore = new ComponentStore(typeToIndex);
startingUpToDateComponentStore = new ComponentStore(typeToIndex);
_startingExistingComponentStore = new ComponentStore(_typeToIndex);
_startingUpToDateComponentStore = new ComponentStore(_typeToIndex);
}
/// <summary>
@ -62,56 +62,56 @@ namespace Encompass
/// </summary>
public Entity CreateEntity()
{
return entityManager.CreateEntity();
return _entityManager.CreateEntity();
}
/// <summary>
/// Specifies that the given Message should be sent immediately on the first World Update.
/// </summary>
public void SendMessage<TMessage>(TMessage message) where TMessage : struct, IMessage
public void SendMessage<TMessage>(in TMessage message) where TMessage : struct, IMessage
{
messageManager.AddMessage(message);
_messageManager.AddMessage(message);
}
/// <summary>
/// Specifies that the given Message should be sent after the specified number of seconds after the first World Update.
/// </summary>
public void SendMessage<TMessage>(TMessage message, double time) where TMessage : struct, IMessage
public void SendMessage<TMessage>(in TMessage message, double time) where TMessage : struct, IMessage
{
messageManager.AddMessage<TMessage>(message, time);
_messageManager.AddMessage<TMessage>(message, time);
}
/// <summary>
/// Sets Component data for the specified Component Type on the specified Entity.
/// </summary>
public void SetComponent<TComponent>(Entity entity, TComponent component) where TComponent : struct, IComponent
public void SetComponent<TComponent>(Entity entity, in TComponent component) where TComponent : struct
{
RegisterComponentType<TComponent>();
startingExistingComponentStore.Set(entity.ID, component);
startingUpToDateComponentStore.Set(entity.ID, component);
_startingExistingComponentStore.Set(entity.ID, component);
_startingUpToDateComponentStore.Set(entity.ID, component);
if (component is IDrawableComponent drawableComponent)
{
componentManager.RegisterDrawableComponent(entity.ID, component, drawableComponent.Layer);
drawLayerManager.RegisterOrderedDrawable<TComponent>();
_componentManager.RegisterDrawableComponent<TComponent>(entity.ID, drawableComponent.Layer);
_drawLayerManager.RegisterOrderedDrawable<TComponent>();
}
}
internal void RegisterComponentType<TComponent>() where TComponent : struct, IComponent
internal void RegisterComponentType<TComponent>() where TComponent : struct
{
if (!typeToIndex.ContainsKey(typeof(TComponent)))
if (!_typeToIndex.ContainsKey(typeof(TComponent)))
{
typeToIndex.Add(typeof(TComponent), typeToIndex.Count);
componentTypesToPreload.Add(typeof(TComponent));
componentManager.RegisterComponentType<TComponent>();
startingExistingComponentStore.RegisterComponentType<TComponent>();
startingUpToDateComponentStore.RegisterComponentType<TComponent>();
_typeToIndex.Add(typeof(TComponent), _typeToIndex.Count);
_componentTypesToPreload.Add(typeof(TComponent));
_componentManager.RegisterComponentType<TComponent>();
_startingExistingComponentStore.RegisterComponentType<TComponent>();
_startingUpToDateComponentStore.RegisterComponentType<TComponent>();
}
}
internal void RegisterMessageTypes(IEnumerable<Type> types)
{
messageTypes.UnionWith(types);
_messageTypes.UnionWith(types);
}
/// <summary>
@ -120,21 +120,21 @@ namespace Encompass
/// <param name="engine">An instance of an Engine.</param>
public Engine AddEngine<TEngine>(TEngine engine) where TEngine : Engine
{
engine.AssignEntityManager(entityManager);
engine.AssignComponentManager(componentManager);
engine.AssignMessageManager(messageManager);
engine.AssignTimeManager(timeManager);
engine.AssignTrackingManager(trackingManager);
engine.AssignEntityManager(_entityManager);
engine.AssignComponentManager(_componentManager);
engine.AssignMessageManager(_messageManager);
engine.AssignTimeManager(_timeManager);
engine.AssignTrackingManager(_trackingManager);
engines.Add(engine);
engineGraph.AddNode(engine);
_engines.Add(engine);
_engineGraph.AddNode(engine);
var messageReceiveTypes = engine.receiveTypes;
var messageSendTypes = engine.sendTypes;
var messageReceiveTypes = engine.ReceiveTypes;
var messageSendTypes = engine.SendTypes;
RegisterMessageTypes(engine.receiveTypes.Union(engine.sendTypes));
RegisterMessageTypes(engine.ReceiveTypes.Union(engine.SendTypes));
foreach (var writeImmediateType in engine.writeImmediateTypes.Intersect(engine.readImmediateTypes))
foreach (var writeImmediateType in engine.WriteImmediateTypes.Intersect(engine.ReadImmediateTypes))
{
throw new EngineSelfCycleException("Engine {0} both writes and reads immediate Component {1}", engine.GetType().Name, writeImmediateType.Name);
}
@ -144,28 +144,28 @@ namespace Encompass
throw new EngineSelfCycleException("Engine {0} both receives and sends Message {1}", engine.GetType().Name, messageType.Name);
}
if (messageSendTypes.Count > 0 || engine.writeImmediateTypes.Count > 0)
if (messageSendTypes.Count > 0 || engine.WriteImmediateTypes.Count > 0)
{
senders.Add(engine);
_senders.Add(engine);
}
foreach (var componentType in engine.queryWithTypes.Union(engine.queryWithoutTypes))
foreach (var componentType in engine.QueryWithTypes.Union(engine.QueryWithoutTypes))
{
trackingManager.RegisterComponentTypeToEngine(componentType, engine);
if (engine.readImmediateTypes.Contains(componentType))
_trackingManager.RegisterComponentTypeToEngine(componentType, engine);
if (engine.ReadImmediateTypes.Contains(componentType))
{
trackingManager.RegisterImmediateComponentTypeToEngine(componentType, engine);
_trackingManager.RegisterImmediateComponentTypeToEngine(componentType, engine);
}
}
foreach (var receiveType in engine.receiveTypes.Union(engine.readImmediateTypes))
foreach (var receiveType in engine.ReceiveTypes.Union(engine.ReadImmediateTypes))
{
if (!typeToReaders.ContainsKey(receiveType))
if (!_typeToReaders.ContainsKey(receiveType))
{
typeToReaders.Add(receiveType, new HashSet<Engine>());
_typeToReaders.Add(receiveType, new HashSet<Engine>());
}
typeToReaders[receiveType].Add(engine);
_typeToReaders[receiveType].Add(engine);
}
return engine;
@ -177,7 +177,7 @@ namespace Encompass
/// <param name="layer">The draw layer to register.</param>
public void RegisterDrawLayer(int layer)
{
drawLayerManager.RegisterDrawLayer(layer);
_drawLayerManager.RegisterDrawLayer(layer);
}
/// <summary>
@ -186,9 +186,9 @@ namespace Encompass
public OrderedRenderer<TComponent> AddOrderedRenderer<TComponent>(OrderedRenderer<TComponent> renderer) where TComponent : struct, IComponent, IDrawableComponent
{
RegisterComponentType<TComponent>();
renderer.AssignEntityManager(entityManager);
renderer.AssignComponentManager(componentManager);
renderManager.RegisterOrderedRenderer<TComponent>(renderer.InternalRender);
renderer.AssignEntityManager(_entityManager);
renderer.AssignComponentManager(_componentManager);
_renderManager.RegisterOrderedRenderer<TComponent>(renderer.InternalRender);
return renderer;
}
@ -200,29 +200,29 @@ namespace Encompass
/// <param name="layer">The layer at which the GeneralRenderer should render. Higher numbers draw over lower numbers.</param>
public TRenderer AddGeneralRenderer<TRenderer>(TRenderer renderer, int layer) where TRenderer : GeneralRenderer
{
renderer.AssignEntityManager(entityManager);
renderer.AssignComponentManager(componentManager);
renderer.AssignEntityManager(_entityManager);
renderer.AssignComponentManager(_componentManager);
renderManager.RegisterGeneralRendererWithLayer(renderer, layer);
_renderManager.RegisterGeneralRendererWithLayer(renderer, layer);
return renderer;
}
private void BuildEngineGraph()
{
foreach (var senderEngine in senders)
foreach (var senderEngine in _senders)
{
foreach (var messageType in senderEngine.sendTypes.Union(senderEngine.writeImmediateTypes))
foreach (var messageType in senderEngine.SendTypes.Union(senderEngine.WriteImmediateTypes))
{
if (typeToReaders.ContainsKey(messageType))
if (_typeToReaders.ContainsKey(messageType))
{
foreach (var readerEngine in typeToReaders[messageType])
foreach (var readerEngine in _typeToReaders[messageType])
{
if (senderEngine != readerEngine)
{
if (!engineGraph.Exists(senderEngine, readerEngine))
if (!_engineGraph.Exists(senderEngine, readerEngine))
{
engineGraph.AddEdge(senderEngine, readerEngine);
_engineGraph.AddEdge(senderEngine, readerEngine);
}
}
}
@ -240,9 +240,9 @@ namespace Encompass
{
BuildEngineGraph();
if (engineGraph.Cyclic())
if (_engineGraph.Cyclic())
{
var cycles = engineGraph.SimpleCycles();
var cycles = _engineGraph.SimpleCycles();
var errorString = "Cycle(s) found in Engines: ";
foreach (var cycle in cycles)
{
@ -262,25 +262,25 @@ namespace Encompass
var writePriorities = new Dictionary<Type, HashSet<int>>();
var writeMessageToEngines = new Dictionary<Type, List<Engine>>();
foreach (var engine in engines)
foreach (var engine in _engines)
{
if (engine.GetType().GetCustomAttribute<IgnoresTimeDilation>() != null)
{
engine.usesTimeDilation = false;
engine._usesTimeDilation = false;
}
var defaultWritePriorityAttribute = engine.GetType().GetCustomAttribute<DefaultWritePriority>(false);
foreach (var writeType in engine.writeTypes)
foreach (var writeType in engine.WriteTypes)
{
int? priority = null;
if (engine.writePriorities.ContainsKey(writeType))
if (engine.WritePriorities.ContainsKey(writeType))
{
priority = engine.writePriorities[writeType];
priority = engine.WritePriorities[writeType];
}
else if (defaultWritePriorityAttribute != null)
{
priority = defaultWritePriorityAttribute.writePriority;
priority = defaultWritePriorityAttribute.WritePriority;
}
if (priority.HasValue)
@ -354,25 +354,11 @@ namespace Encompass
throw new EngineWriteConflictException(errorString);
}
// doing reflection to grab all component types, because not all writes need to be declared
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
foreach (var componentType in assembly.GetTypes())
{
if (typeof(IComponent).IsAssignableFrom(componentType) && componentType.IsValueType && !componentType.IsEnum && !componentType.IsPrimitive)
{
var method = typeof(WorldBuilder).GetMethod("RegisterComponentType", BindingFlags.NonPublic | BindingFlags.Instance);
var generic = method.MakeGenericMethod(componentType);
generic.Invoke(this, null);
}
}
}
PreloadJIT(componentTypesToPreload, messageTypes);
PreloadJIT(_messageTypes);
var engineOrder = new List<Engine>();
foreach (var engine in engineGraph.TopologicalSort())
foreach (var engine in _engineGraph.TopologicalSort())
{
engineOrder.Add(engine);
engine.BuildEntityQuery();
@ -380,18 +366,18 @@ namespace Encompass
var world = new World(
engineOrder,
entityManager,
componentManager,
trackingManager,
messageManager,
timeManager,
renderManager
_entityManager,
_componentManager,
_trackingManager,
_messageManager,
_timeManager,
_renderManager
);
componentManager.SetExistingComponentStore(startingExistingComponentStore);
componentManager.SetUpToDateComponentStore(startingUpToDateComponentStore);
_componentManager.SetExistingComponentStore(_startingExistingComponentStore);
_componentManager.SetUpToDateComponentStore(_startingUpToDateComponentStore);
trackingManager.InitializeTracking(entityManager.EntityIDs);
_trackingManager.InitializeTracking(_entityManager.EntityIDs);
return world;
}
@ -402,19 +388,44 @@ namespace Encompass
/// It does so by grabbing all component and message types known to the WorldBuilder and
/// executing every possible generic method that could be executed with those types.
/// </summary>
private void PreloadJIT(IEnumerable<Type> componentTypes, IEnumerable<Type> messageTypes)
private void PreloadJIT(IEnumerable<Type> messageTypes)
{
var dummyTimeManager = new TimeManager();
var dummyMessageManager = new MessageManager(dummyTimeManager);
var dummyDrawLayerManager = new DrawLayerManager(typeToIndex);
var dummyDrawLayerManager = new DrawLayerManager();
var dummyTrackingManager = new TrackingManager();
var dummyComponentManager = new ComponentManager(dummyDrawLayerManager, typeToIndex);
var dummyEntityManager = new EntityManager(dummyComponentManager, entityCapacity);
var dummyComponentManager = new ComponentManager(dummyDrawLayerManager, _typeToIndex);
var dummyEntityManager = new EntityManager(dummyComponentManager, _entityCapacity);
var dummyRenderManager = new RenderManager(dummyEntityManager, dummyDrawLayerManager);
// doing reflection to grab all component types, because not all writes need to be declared
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
foreach (var componentType in assembly.GetTypes())
{
if (typeof(IComponent).IsAssignableFrom(componentType) && componentType.IsValueType && !componentType.IsEnum && !componentType.IsPrimitive)
{
var method = typeof(WorldBuilder).GetMethod("RegisterComponentType", BindingFlags.NonPublic | BindingFlags.Instance);
var generic = method.MakeGenericMethod(componentType);
generic.Invoke(this, null);
var dummyRegisterMethod = typeof(ComponentManager).GetMethod("RegisterComponentType", BindingFlags.Public | BindingFlags.Instance);
var dummyGeneric = dummyRegisterMethod.MakeGenericMethod(componentType);
dummyGeneric.Invoke(dummyComponentManager, null);
}
if (componentType.GetInterface("IDrawableComponent") != null)
{
var drawLayerManagerRegisterMethod = typeof(DrawLayerManager).GetMethod("RegisterOrderedDrawable");
var drawLayerManagerRegisterGenericMethod = drawLayerManagerRegisterMethod.MakeGenericMethod(componentType);
drawLayerManagerRegisterGenericMethod.Invoke(dummyDrawLayerManager, null);
}
}
}
var prepEngineOrder = new List<Engine>();
var uberEngine = new UberEngine(componentTypes, messageTypes);
var uberEngine = new UberEngine(_componentTypesToPreload, messageTypes);
uberEngine.AssignEntityManager(dummyEntityManager);
uberEngine.AssignComponentManager(dummyComponentManager);
@ -422,24 +433,10 @@ namespace Encompass
uberEngine.AssignTimeManager(dummyTimeManager);
uberEngine.AssignTrackingManager(dummyTrackingManager);
var uberRenderer = new UberRenderer(componentTypes);
var uberRenderer = new UberRenderer(_componentTypesToPreload);
uberRenderer.AssignComponentManager(dummyComponentManager);
uberRenderer.AssignEntityManager(dummyEntityManager);
foreach (var type in componentTypes)
{
var componentManagerRegisterMethod = typeof(ComponentManager).GetMethod("RegisterComponentType");
var componentManagerRegisterGenericMethod = componentManagerRegisterMethod.MakeGenericMethod(type);
componentManagerRegisterGenericMethod.Invoke(dummyComponentManager, null);
if (type.GetInterface("IDrawableComponent") != null)
{
var drawLayerManagerRegisterMethod = typeof(DrawLayerManager).GetMethod("RegisterOrderedDrawable");
var drawLayerManagerRegisterGenericMethod = drawLayerManagerRegisterMethod.MakeGenericMethod(type);
drawLayerManagerRegisterGenericMethod.Invoke(dummyDrawLayerManager, null);
}
}
prepEngineOrder.Add(uberEngine);
var dummyWorld = new World(

View File

@ -1,6 +1,8 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>netstandard2.0</TargetFramework>
<LangVersion>8.0</LangVersion>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<RootNamespace>Encompass</RootNamespace>
<PackageId>EncompassECS.Framework</PackageId>
<Version>0.20.0</Version>
@ -26,5 +28,6 @@
<PackageReference Include="MoonTools.Core.Graph" Version="1.0.0" />
<PackageReference Include="MoonTools.FastCollections" Version="1.0.0" />
<PackageReference Include="System.Collections.Immutable" Version="1.7.0" />
<PackageReference Include="Microsoft.Bcl.HashCode" Version="1.1.0" />
</ItemGroup>
</Project>

View File

@ -2,14 +2,14 @@ using NUnit.Framework;
using FluentAssertions;
using Encompass;
using System.Runtime.CompilerServices;
namespace Tests
{
public class ComponentTests
{
struct MockComponent : Encompass.IComponent
struct MockComponent : IComponent
{
public string myString;
public int myInt;
}
@ -26,7 +26,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var entityMessage in ReadMessages<EntityMessage>())
foreach (ref readonly var entityMessage in ReadMessages<EntityMessage>())
{
gottenMockComponent = GetComponent<MockComponent>(entityMessage.entity);
}
@ -45,25 +45,27 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var addComponentTestMessage in ReadMessages<AddComponentTestMessage>())
foreach (ref readonly var addComponentTestMessage in ReadMessages<AddComponentTestMessage>())
{
Assert.IsTrue(HasComponent<MockComponent>(addComponentTestMessage.entity));
Assert.That(GetComponent<MockComponent>(addComponentTestMessage.entity), Is.EqualTo(addComponentTestMessage.mockComponent));
ref readonly var gottenComponent = ref GetComponent<MockComponent>(addComponentTestMessage.entity);
gottenComponent.Should().BeEquivalentTo(addComponentTestMessage.mockComponent);
}
}
}
[Test]
public void AddComponent()
public unsafe void AddComponent()
{
var worldBuilder = new WorldBuilder();
worldBuilder.AddEngine(new AddComponentTestEngine());
var entity = worldBuilder.CreateEntity();
const string MyString = "hello";
MockComponent mockComponent;
mockComponent.myInt = 3;
mockComponent.myString = "hello";
worldBuilder.SetComponent(entity, mockComponent);
@ -85,16 +87,15 @@ namespace Tests
worldBuilder.AddEngine(new ReadMockComponentEngine());
var entity = worldBuilder.CreateEntity();
worldBuilder.SetComponent(entity, new MockComponent { myInt = 20, myString = "what" });
worldBuilder.SetComponent(entity, new MockComponent { myInt = 50, myString = "hi" });
worldBuilder.SetComponent(entity, new MockComponent { myInt = 40, myString = "wassup" });
worldBuilder.SetComponent(entity, new MockComponent { myInt = 20 });
worldBuilder.SetComponent(entity, new MockComponent { myInt = 50 });
worldBuilder.SetComponent(entity, new MockComponent { myInt = 40 });
var world = worldBuilder.Build();
world.Update(0.01);
Assert.That(gottenMockComponent.myInt, Is.EqualTo(40));
Assert.That(gottenMockComponent.myString, Is.EqualTo("wassup"));
}
[Reads(typeof(MockComponent))]
@ -103,8 +104,9 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var (mockComponent, entity) in ReadComponentsIncludingEntity<MockComponent>())
foreach (ref readonly var entity in ReadEntities<MockComponent>())
{
ref readonly var mockComponent = ref GetComponent<MockComponent>(entity);
SetComponent(entity, new MockComponent { myInt = mockComponent.myInt + 1 });
}
}
@ -149,8 +151,9 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var (mockComponent, entity) in ReadComponentsIncludingEntity<MockComponent>())
foreach (ref readonly var entity in ReadEntities<MockComponent>())
{
ref readonly var mockComponent = ref GetComponent<MockComponent>(entity);
SetComponent(entity, mockComponent);
RemoveComponent<MockComponent>(entity);
}
@ -191,7 +194,6 @@ namespace Tests
{
MockComponent mockComponent;
mockComponent.myInt = 10;
mockComponent.myString = "four";
AddMockComponentMessage addMockComponentMessage;
addMockComponentMessage.entity = entity;
@ -207,7 +209,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var message in ReadMessages<AddMockComponentMessage>())
foreach (ref readonly var message in ReadMessages<AddMockComponentMessage>())
{
SetComponent(message.entity, message.mockComponent);
}
@ -255,9 +257,8 @@ namespace Tests
MockComponent mockComponent;
mockComponent.myInt = 3;
mockComponent.myString = "hello";
worldBuilder.SetComponent<MockComponent>(entity, mockComponent);
worldBuilder.SetComponent(entity, mockComponent);
EntityMessage entityMessage;
entityMessage.entity = entity;
@ -281,7 +282,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var hasComponentTestEngine in ReadMessages<HasComponentTestMessage>())
foreach (ref readonly var hasComponentTestEngine in ReadMessages<HasComponentTestMessage>())
{
Assert.IsTrue(HasComponent<MockComponent>(hasComponentTestEngine.entity));
}
@ -298,7 +299,6 @@ namespace Tests
MockComponent mockComponent;
mockComponent.myInt = 3;
mockComponent.myString = "hello";
worldBuilder.SetComponent(entity, mockComponent);
@ -319,7 +319,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var hasComponentTestEngine in ReadMessages<HasComponentTestMessage>())
foreach (ref readonly var hasComponentTestEngine in ReadMessages<HasComponentTestMessage>())
{
hasComponentRuntimeTypeResult = HasComponent(hasComponentTestEngine.entity, typeof(MockComponent));
}
@ -336,7 +336,6 @@ namespace Tests
MockComponent mockComponent;
mockComponent.myInt = 3;
mockComponent.myString = "hello";
worldBuilder.SetComponent(entity, mockComponent);
@ -382,7 +381,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var removeComponentMessage in ReadMessages<RemoveComponentTestMessage>())
foreach (ref readonly var removeComponentMessage in ReadMessages<RemoveComponentTestMessage>())
{
RemoveComponent<MockComponent>(removeComponentMessage.entity);
}
@ -427,7 +426,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var checkHasMockComponentMessage in ReadMessages<CheckHasMockComponentMessage>())
foreach (ref readonly var checkHasMockComponentMessage in ReadMessages<CheckHasMockComponentMessage>())
{
hasComponentResult = HasComponent<MockComponent>(checkHasMockComponentMessage.entity);
}
@ -446,7 +445,6 @@ namespace Tests
MockComponent mockComponent;
mockComponent.myInt = 3;
mockComponent.myString = "hello";
worldBuilder.SetComponent(entity, mockComponent);
@ -477,7 +475,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var checkHasMockComponentMessage in ReadMessages<CheckHasMockComponentMessage>())
foreach (ref readonly var checkHasMockComponentMessage in ReadMessages<CheckHasMockComponentMessage>())
{
Assert.IsTrue(HasComponent<MockComponent>(checkHasMockComponentMessage.entity));
}

View File

@ -13,26 +13,25 @@ namespace Tests
struct MockComponent : IComponent
{
public int myInt;
public string myString;
}
public class EngineTest
{
static List<MockComponent> resultComponents;
static MockComponent[] resultComponents;
static MockComponent resultComponent;
static List<MockMessage> resultMessages = new List<MockMessage>();
static MockMessage[] resultMessages;
[Reads(typeof(MockComponent))]
public class ReadComponentsTestEngine : Engine
{
public override void Update(double dt)
{
resultComponents = ReadComponents<MockComponent>().ToList();
resultComponents = ReadComponents<MockComponent>().ToArray();
}
}
static List<(MockComponent, Entity)> resultComponentsIncludingEntity;
static List<(MockComponent, Entity)> resultComponentsIncludingEntity = new List<(MockComponent, Entity)>();
static (MockComponent, Entity) resultComponentIncludingEntity;
[Reads(typeof(MockComponent))]
@ -40,7 +39,11 @@ namespace Tests
{
public override void Update(double dt)
{
resultComponentsIncludingEntity = ReadComponentsIncludingEntity<MockComponent>().ToList();
foreach (ref readonly var entity in ReadEntities<MockComponent>())
{
ref readonly var mockComponent = ref GetComponent<MockComponent>(entity);
resultComponentsIncludingEntity.Add((mockComponent, entity));
}
}
}
@ -58,7 +61,9 @@ namespace Tests
{
public override void Update(double dt)
{
resultComponentIncludingEntity = ReadComponentIncludingEntity<MockComponent>();
ref readonly var entity = ref ReadEntity<MockComponent>();
ref readonly var mockComponent = ref GetComponent<MockComponent>(entity);
resultComponentIncludingEntity = (mockComponent, entity);
}
}
@ -72,12 +77,10 @@ namespace Tests
var entityB = worldBuilder.CreateEntity();
MockComponent mockComponent;
mockComponent.myInt = 0;
mockComponent.myString = "hello";
mockComponent.myInt = 2;
MockComponent mockComponentB;
mockComponentB.myInt = 1;
mockComponentB.myString = "howdy";
worldBuilder.SetComponent(entity, mockComponent);
worldBuilder.SetComponent(entityB, mockComponentB);
@ -93,6 +96,8 @@ namespace Tests
[Test]
public void ReadComponentsIncludingEntity()
{
resultComponentsIncludingEntity.Clear();
var worldBuilder = new WorldBuilder();
worldBuilder.AddEngine(new ReadComponentsIncludingEntityEngine());
@ -100,12 +105,10 @@ namespace Tests
var entityB = worldBuilder.CreateEntity();
MockComponent mockComponent;
mockComponent.myInt = 0;
mockComponent.myString = "hello";
mockComponent.myInt = 2;
MockComponent mockComponentB;
mockComponentB.myInt = 1;
mockComponentB.myString = "howdy";
worldBuilder.SetComponent(entity, mockComponent);
worldBuilder.SetComponent(entityB, mockComponentB);
@ -135,8 +138,7 @@ namespace Tests
var entity = worldBuilder.CreateEntity();
MockComponent mockComponent;
mockComponent.myInt = 0;
mockComponent.myString = "hello";
mockComponent.myInt = 3;
worldBuilder.SetComponent(entity, mockComponent);
@ -157,12 +159,10 @@ namespace Tests
var entityB = worldBuilder.CreateEntity();
MockComponent mockComponent;
mockComponent.myInt = 0;
mockComponent.myString = "hello";
mockComponent.myInt = 2;
MockComponent mockComponentB;
mockComponentB.myInt = 1;
mockComponentB.myString = "howdy";
worldBuilder.SetComponent(entity, mockComponent);
worldBuilder.SetComponent(entityB, mockComponentB);
@ -183,8 +183,7 @@ namespace Tests
var entity = worldBuilder.CreateEntity();
MockComponent mockComponent;
mockComponent.myInt = 0;
mockComponent.myString = "hello";
mockComponent.myInt = 2;
worldBuilder.SetComponent(entity, mockComponent);
@ -201,11 +200,8 @@ namespace Tests
{
public override void Update(double dt)
{
var (component, entity) = ReadComponentIncludingEntity<MockComponent>();
component.myInt = 420;
component.myString = "blaze it";
SetComponent(entity, component);
ref readonly var entity = ref ReadEntity<MockComponent>();
SetComponent(entity, new MockComponent { myInt = 420 });
}
}
@ -222,8 +218,7 @@ namespace Tests
var entity = worldBuilder.CreateEntity();
MockComponent mockComponent;
mockComponent.myInt = 0;
mockComponent.myString = "hello";
mockComponent.myInt = 3;
worldBuilder.SetComponent(entity, mockComponent);
@ -233,7 +228,6 @@ namespace Tests
world.Update(0.01);
Assert.AreEqual(420, resultComponent.myInt);
Assert.AreEqual("blaze it", resultComponent.myString);
}
[Reads(typeof(MockComponent))]
@ -241,13 +235,8 @@ namespace Tests
{
public override void Update(double dt)
{
var (component, entity) = ReadComponentIncludingEntity<MockComponent>();
component.myInt = 420;
component.myString = "blaze it";
SetComponent(entity, component);
component = ReadComponent<MockComponent>();
ref readonly var entity = ref ReadEntity<MockComponent>();
SetComponent(entity, new MockComponent { myInt = 420 });
}
}
@ -260,8 +249,7 @@ namespace Tests
var entity = worldBuilder.CreateEntity();
MockComponent mockComponent;
mockComponent.myInt = 0;
mockComponent.myString = "hello";
mockComponent.myInt = 3;
worldBuilder.SetComponent(entity, mockComponent);
@ -293,7 +281,7 @@ namespace Tests
{
public override void Update(double dt)
{
resultMessages = this.ReadMessages<MockMessage>().ToList();
resultMessages = ReadMessages<MockMessage>().ToArray();
}
}
@ -322,14 +310,14 @@ namespace Tests
}
}
static IEnumerable<MockMessage> emptyReadMessagesResult;
static MockMessage[] emptyReadMessagesResult;
[Receives(typeof(MockMessage))]
class ReadMessagesWhenNoneExistEngine : Engine
{
public override void Update(double dt)
{
emptyReadMessagesResult = ReadMessages<MockMessage>();
emptyReadMessagesResult = ReadMessages<MockMessage>().ToArray();
}
}
@ -578,10 +566,10 @@ namespace Tests
{
public override void Update(double dt)
{
var components = ReadComponentsIncludingEntity<MockComponent>();
var entities = ReadEntities<MockComponent>();
pairA = components.First();
pairB = components.Last();
pairA = (GetComponent<MockComponent>(entities[0]), entities[0]);
pairB = (GetComponent<MockComponent>(entities[1]), entities[1]);
}
}
@ -594,11 +582,9 @@ namespace Tests
MockComponent componentA;
componentA.myInt = 20;
componentA.myString = "hello";
MockComponent componentB;
componentB.myInt = 20;
componentB.myString = "hello";
var entity = worldBuilder.CreateEntity();
worldBuilder.SetComponent(entity, componentA);
@ -613,14 +599,12 @@ namespace Tests
Assert.That(EngineTest.pairA.Item1, Is.EqualTo(EngineTest.pairB.Item1));
}
static IEnumerable<(MockComponent, Entity)> emptyComponentReadResult;
[Reads(typeof(MockComponent))]
class ReadEmptyMockComponentsEngine : Engine
{
public override void Update(double dt)
{
emptyComponentReadResult = ReadComponentsIncludingEntity<MockComponent>();
ReadEntities<MockComponent>().ToArray().Should().BeEmpty();
}
}
@ -632,8 +616,6 @@ namespace Tests
var world = worldBuilder.Build();
world.Update(0.01f);
Assert.That(emptyComponentReadResult, Is.Empty);
}
struct DestroyerComponent : IComponent { }
@ -643,21 +625,27 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var (component, entity) in ReadComponentsIncludingEntity<DestroyerComponent>())
foreach (ref readonly var entity in ReadEntities<DestroyerComponent>())
{
Destroy(entity);
}
}
}
static List<(MockComponent, Entity)> results;
static List<(MockComponent, Entity)> results = new List<(MockComponent, Entity)>();
[Reads(typeof(MockComponent))]
class ReaderEngine : Engine
{
public override void Update(double dt)
{
results = ReadComponentsIncludingEntity<MockComponent>().ToList();
results.Clear();
foreach (ref readonly var entity in ReadEntities<MockComponent>())
{
ref readonly var mockComponent = ref GetComponent<MockComponent>(entity);
results.Add((mockComponent, entity));
}
}
}
@ -675,7 +663,6 @@ namespace Tests
DestroyerComponent destroyerComponent;
MockComponent mockComponent;
mockComponent.myInt = 2;
mockComponent.myString = "blah";
worldBuilder.SetComponent(entity, destroyerComponent);
worldBuilder.SetComponent(entity, mockComponent);
@ -700,7 +687,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var message in ReadMessages<DestroyComponentMessage>())
foreach (ref readonly var message in ReadMessages<DestroyComponentMessage>())
{
Destroy(message.entity);
}
@ -710,6 +697,8 @@ namespace Tests
[Test]
public void DestroyEntityWithoutID()
{
results.Clear();
var worldBuilder = new WorldBuilder();
worldBuilder.AddEngine(new AddComponentEngine());
worldBuilder.AddEngine(new DestroyEntityEngine());
@ -733,7 +722,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var (componentPair, entity) in ReadComponentsIncludingEntity<DestroyerComponent>())
foreach (ref readonly var entity in ReadEntities<DestroyerComponent>())
{
RemoveComponent<MockComponent>(entity);
Destroy(entity);
@ -765,7 +754,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var (mockComponent, entity) in ReadComponentsIncludingEntity<MockComponent>())
foreach (ref readonly var entity in ReadEntities<MockComponent>())
{
RemoveComponent<MockComponent>(entity);
SetComponent(entity, new MockComponent());
@ -780,7 +769,7 @@ namespace Tests
{
public override void Update(double dt)
{
var (_, entity) = ReadComponentIncludingEntity<MockComponent>();
ref readonly var entity = ref ReadEntity<MockComponent>();
}
}
@ -805,7 +794,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var (component, entity) in ReadComponentsIncludingEntity<MockComponent>())
foreach (ref readonly var entity in ReadEntities<MockComponent>())
{
RemoveComponent<MockComponent>(entity);
SendMessage(new MockMessage { }, 1);
@ -816,7 +805,7 @@ namespace Tests
[Test]
public void EngineSendMessageDelayed()
{
resultMessages.Clear();
Array.Clear(resultMessages, 0, resultMessages.Length);
var worldBuilder = new WorldBuilder();
worldBuilder.AddEngine(new ActivateTimeDilationEngine());
@ -852,7 +841,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var (component, entity) in ReadComponentsIncludingEntity<MockComponent>())
foreach (ref readonly var entity in ReadEntities<MockComponent>())
{
RemoveComponent<MockComponent>(entity);
SendMessageIgnoringTimeDilation(new MockMessage { }, 1);
@ -863,7 +852,7 @@ namespace Tests
[Test]
public void EngineSendMessageDelayedIgnoringTimeDilation()
{
resultMessages.Clear();
Array.Clear(resultMessages, 0, resultMessages.Length);
var worldBuilder = new WorldBuilder();
worldBuilder.AddEngine(new ActivateTimeDilationEngine());
@ -896,7 +885,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var message in ReadMessages<MockMessage>())
foreach (ref readonly var message in ReadMessages<MockMessage>())
{
var entity = CreateEntity();
SetComponent(entity, new MockComponent { });
@ -977,12 +966,12 @@ namespace Tests
struct MockComponentB : IComponent
{
private int value;
public MockComponentB(int value)
{
this.value = value;
}
int value;
}
static MockComponentB getComponentResult;
@ -1134,7 +1123,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var (_, entity) in ReadComponentsIncludingEntity<MockComponent>())
foreach (ref readonly var entity in ReadEntities<MockComponent>())
{
RemoveComponent<MockComponent>(entity);
}
@ -1329,8 +1318,7 @@ namespace Tests
{
public override void Update(double dt)
{
var (component, entity) = ReadComponentIncludingEntity<MockComponent>();
ref readonly var entity = ref ReadEntity<MockComponent>();
AddComponent(entity, new MockComponent());
}
}
@ -1364,8 +1352,7 @@ namespace Tests
{
public override void Update(double dt)
{
var (component, entity) = ReadComponentIncludingEntity<MockComponentB>();
ref readonly var component = ref ReadComponent<MockComponentB>();
getComponentResult = component;
}
}
@ -1811,7 +1798,7 @@ namespace Tests
}
public override void Update(double dt)
{
_components.AddRange(ReadComponents<MockComponentB>());
_components.AddRange(ReadComponents<MockComponentB>().ToArray());
}
}
@ -1847,12 +1834,11 @@ namespace Tests
public override void Update(double dt)
{
foreach (var (component, entity) in ReadComponentsIncludingEntity<MockComponent>())
foreach (ref readonly var entity in ReadEntities<MockComponent>())
{
if (HasComponent<MockComponentB>(entity))
{
_components.Add(GetComponent<MockComponentB>(entity));
}
}
}
@ -1879,12 +1865,12 @@ namespace Tests
struct MockTimerComponent : IComponent
{
public double Timer { get; }
public MockTimerComponent(double time)
{
Timer = time;
}
public double Timer { get; set; }
}
[Reads(typeof(MockTimerComponent))]
@ -1893,19 +1879,18 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var (component, entity) in ReadComponentsIncludingEntity<MockTimerComponent>())
foreach (ref readonly var entity in ReadEntities<MockTimerComponent>())
{
var updatedComponent = component;
updatedComponent.Timer -= dt;
ref readonly var component = ref GetComponent<MockTimerComponent>(entity);
if (updatedComponent.Timer <= 0)
if (component.Timer - dt <= 0)
{
RemoveComponent<MockTimerComponent>(entity);
}
else
{
SetComponent<MockTimerComponent>(entity, updatedComponent);
SetComponent<MockTimerComponent>(entity, new MockTimerComponent(component.Timer - dt));
}
}
}

View File

@ -15,7 +15,8 @@ namespace Tests
{
public override void Render()
{
result = ReadComponentIncludingEntity<AComponent>();
ref readonly var entity = ref ReadEntity<AComponent>();
result = (GetComponent<AComponent>(entity), entity);
}
}

View File

@ -20,13 +20,13 @@ namespace Tests
class TestRenderer : OrderedRenderer<TestDrawComponent>
{
public override void Render(Entity entity, TestDrawComponent testDrawComponent) { }
public override void Render(Entity entity, in TestDrawComponent testDrawComponent) { }
}
static bool called = false;
class DeactivatedRenderer : TestRenderer
{
public override void Render(Entity entity, TestDrawComponent testDrawComponent)
public override void Render(Entity entity, in TestDrawComponent testDrawComponent)
{
called = true;
}
@ -37,7 +37,7 @@ namespace Tests
class CalledRenderer : OrderedRenderer<TestDrawComponent>
{
public override void Render(Entity entity, TestDrawComponent testDrawComponent)
public override void Render(Entity entity, in TestDrawComponent testDrawComponent)
{
resultComponent = (testDrawComponent, entity);
calledOnDraw = true;

View File

@ -5,6 +5,7 @@ using System.Collections.Generic;
using Encompass.Exceptions;
using System.Linq;
using FluentAssertions;
using System;
namespace Tests
{
@ -114,7 +115,7 @@ namespace Tests
public class MultipleEngineWriteConflict
{
struct AComponent : IComponent { }
struct AComponent { }
[Writes(typeof(AComponent))]
class AEngine : Engine
@ -158,7 +159,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var setMessage in ReadMessages<SetMessage>())
foreach (ref readonly var setMessage in ReadMessages<SetMessage>())
{
SetComponent(setMessage.entity, new AComponent { myInt = 0 });
}
@ -172,7 +173,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var setMessage in ReadMessages<SetMessage>())
foreach (ref readonly var setMessage in ReadMessages<SetMessage>())
{
SetComponent(setMessage.entity, new AComponent { myInt = 1 });
}
@ -228,7 +229,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var setMessage in ReadMessages<SetMessage>())
foreach (ref readonly var setMessage in ReadMessages<SetMessage>())
{
SetComponent(setMessage.entity, new AComponent { myInt = 5 });
}
@ -243,7 +244,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var setMessage in ReadMessages<SetMessage>())
foreach (ref readonly var setMessage in ReadMessages<SetMessage>())
{
SetComponent(setMessage.entity, new AComponent { myInt = 1 });
}
@ -257,7 +258,7 @@ namespace Tests
{
public override void Update(double dt)
{
foreach (var setMessage in ReadMessages<SetMessage>())
foreach (ref readonly var setMessage in ReadMessages<SetMessage>())
{
SetComponent(setMessage.entity, new AComponent { myInt = 3 });
}
@ -318,28 +319,6 @@ namespace Tests
}
}
public class IllegalReadType
{
struct ANonMessage { }
[Reads(typeof(ANonMessage))]
class MyEngine : Engine
{
public override void Update(double dt)
{
}
}
[Test]
public void ThrowsError()
{
var worldBuilder = new WorldBuilder();
Assert.Throws<IllegalReadTypeException>(() => worldBuilder.AddEngine(new MyEngine()), "ANonMessage must be a Message or Component");
}
}
public class IllegalWriteType
{
struct ANonMessage { }
@ -501,20 +480,22 @@ namespace Tests
Assert.That(order.IndexOf(engineC), Is.LessThan(order.IndexOf(engineD)));
}
static List<AMessage> resultMessages = new List<AMessage>();
static AMessage[] resultMessages;
[Receives(typeof(AMessage))]
class ReadMessageEngine : Engine
{
public override void Update(double dt)
{
resultMessages = ReadMessages<AMessage>().ToList();
resultMessages = ReadMessages<AMessage>().ToArray();
}
}
[Test]
public void SendMessageDelayed()
{
resultMessages = Array.Empty<AMessage>();
var worldBuilder = new WorldBuilder();
worldBuilder.AddEngine(new ReadMessageEngine());

View File

@ -21,7 +21,7 @@ namespace Tests
class TestEntityRenderer : OrderedRenderer<TestDrawComponent>
{
public override void Render(Entity entity, TestDrawComponent testDrawComponent)
public override void Render(Entity entity, in TestDrawComponent testDrawComponent)
{
drawOrder.Add(entity);
}

View File

@ -5,6 +5,7 @@
<IsPackable>false</IsPackable>
<RootNamespace>Tests</RootNamespace>
<AssemblyName>EncompassECS.Framework.Tests</AssemblyName>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="FluentAssertions" Version="5.7.0" />