489 lines
14 KiB
C#
489 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace MoonTools.ECS.Rev2
|
|
{
|
|
public class World : IDisposable
|
|
{
|
|
// Get ComponentId from a Type
|
|
internal static Dictionary<Type, Id> TypeToComponentId = new Dictionary<Type, Id>();
|
|
// Get element size from a ComponentId
|
|
internal static Dictionary<Id, int> ElementSizes = new Dictionary<Id, int>();
|
|
|
|
// Lookup from ArchetypeSignature to Archetype
|
|
internal Dictionary<ArchetypeSignature, Archetype> ArchetypeIndex = new Dictionary<ArchetypeSignature, Archetype>();
|
|
|
|
// Going from EntityId to Archetype and storage row
|
|
Dictionary<Id, Record> EntityIndex = new Dictionary<Id, Record>();
|
|
|
|
// Going from ComponentId to Archetype list
|
|
Dictionary<Id, List<Archetype>> ComponentIndex = new Dictionary<Id, List<Archetype>>();
|
|
|
|
// ID Management
|
|
IdAssigner IdAssigner = new IdAssigner();
|
|
|
|
internal readonly Archetype EmptyArchetype;
|
|
|
|
public FilterBuilder FilterBuilder => new FilterBuilder(this);
|
|
|
|
private bool IsDisposed;
|
|
|
|
public delegate void RefAction<T1, T2>(ref T1 arg1, ref T2 arg2);
|
|
|
|
public World()
|
|
{
|
|
// Create the Empty Archetype
|
|
EmptyArchetype = CreateArchetype(ArchetypeSignature.Empty);
|
|
}
|
|
|
|
internal Archetype CreateArchetype(ArchetypeSignature signature)
|
|
{
|
|
var archetype = new Archetype(this, signature)
|
|
{
|
|
ComponentColumns = new List<Column>(signature.Count)
|
|
};
|
|
|
|
ArchetypeIndex.Add(signature, archetype);
|
|
|
|
for (int i = 0; i < signature.Count; i += 1)
|
|
{
|
|
var componentId = signature[i];
|
|
ComponentIndex[componentId].Add(archetype);
|
|
archetype.ComponentToColumnIndex.Add(componentId, archetype.ComponentColumns.Count);
|
|
archetype.ComponentColumns.Add(new Column(ElementSizes[componentId]));
|
|
}
|
|
|
|
return archetype;
|
|
}
|
|
|
|
public Id CreateEntity()
|
|
{
|
|
var entityId = IdAssigner.Assign();
|
|
EntityIndex.Add(entityId, new Record(EmptyArchetype, EmptyArchetype.Count));
|
|
EmptyArchetype.RowToEntity.Add(entityId);
|
|
return entityId;
|
|
}
|
|
|
|
// used as a fast path by snapshot restore
|
|
internal void CreateEntityOnArchetype(Archetype archetype)
|
|
{
|
|
var entityId = IdAssigner.Assign();
|
|
EntityIndex.Add(entityId, new Record(archetype, archetype.Count));
|
|
archetype.RowToEntity.Add(entityId);
|
|
}
|
|
|
|
// used as a fast path by Archetype.ClearAll and snapshot restore
|
|
internal void FreeEntity(Id entityId)
|
|
{
|
|
EntityIndex.Remove(entityId);
|
|
IdAssigner.Unassign(entityId);
|
|
}
|
|
|
|
private void RegisterTypeId(Id typeId, int elementSize)
|
|
{
|
|
ComponentIndex.Add(typeId, new List<Archetype>());
|
|
ElementSizes.Add(typeId, elementSize);
|
|
}
|
|
|
|
// FIXME: would be much more efficient to do all this at load time somehow
|
|
private void RegisterComponent<T>() where T : unmanaged
|
|
{
|
|
var componentId = IdAssigner.Assign();
|
|
TypeToComponentId.Add(typeof(T), componentId);
|
|
ComponentIndex.Add(componentId, new List<Archetype>());
|
|
ElementSizes.Add(componentId, Unsafe.SizeOf<T>());
|
|
}
|
|
|
|
private void TryRegisterTypeId(Id typeId, int elementSize)
|
|
{
|
|
if (!ComponentIndex.ContainsKey(typeId))
|
|
{
|
|
RegisterTypeId(typeId, elementSize);
|
|
}
|
|
}
|
|
|
|
private void TryRegisterComponentId<T>() where T : unmanaged
|
|
{
|
|
if (!TypeToComponentId.ContainsKey(typeof(T)))
|
|
{
|
|
RegisterComponent<T>();
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private Id GetComponentId<T>() where T : unmanaged
|
|
{
|
|
return TypeToComponentId[typeof(T)];
|
|
}
|
|
|
|
public bool Has<T>(Id entityId) where T : unmanaged
|
|
{
|
|
var componentId = GetComponentId<T>();
|
|
var record = EntityIndex[entityId];
|
|
return record.Archetype.ComponentToColumnIndex.ContainsKey(componentId);
|
|
}
|
|
|
|
// will throw if non-existent
|
|
public unsafe ref T Get<T>(Id entityId) where T : unmanaged
|
|
{
|
|
var componentId = GetComponentId<T>();
|
|
|
|
var record = EntityIndex[entityId];
|
|
var columnIndex = record.Archetype.ComponentToColumnIndex[componentId];
|
|
var column = record.Archetype.ComponentColumns[columnIndex];
|
|
|
|
return ref ((T*) column.Elements)[record.Row];
|
|
}
|
|
|
|
public unsafe void Set<T>(in Id entityId, in T component) where T : unmanaged
|
|
{
|
|
TryRegisterComponentId<T>();
|
|
var componentId = GetComponentId<T>();
|
|
|
|
if (Has<T>(entityId))
|
|
{
|
|
var record = EntityIndex[entityId];
|
|
var columnIndex = record.Archetype.ComponentToColumnIndex[componentId];
|
|
var column = record.Archetype.ComponentColumns[columnIndex];
|
|
|
|
((T*) column.Elements)[record.Row] = component;
|
|
}
|
|
else
|
|
{
|
|
Add(entityId, component);
|
|
}
|
|
}
|
|
|
|
private void Add<T>(Id entityId, in T component) where T : unmanaged
|
|
{
|
|
Archetype? nextArchetype;
|
|
|
|
var componentId = GetComponentId<T>();
|
|
|
|
// move the entity to the new archetype
|
|
var record = EntityIndex[entityId];
|
|
var archetype = record.Archetype;
|
|
|
|
if (archetype.Edges.TryGetValue(componentId, out var edge))
|
|
{
|
|
nextArchetype = edge.Add;
|
|
}
|
|
else
|
|
{
|
|
// FIXME: pool the signatures
|
|
var nextSignature = new ArchetypeSignature(archetype.Signature.Count + 1);
|
|
archetype.Signature.CopyTo(nextSignature);
|
|
nextSignature.Insert(componentId);
|
|
|
|
if (!ArchetypeIndex.TryGetValue(nextSignature, out nextArchetype))
|
|
{
|
|
nextArchetype = CreateArchetype(nextSignature);
|
|
}
|
|
|
|
var newEdge = new ArchetypeEdge(nextArchetype, archetype);
|
|
archetype.Edges.Add(componentId, newEdge);
|
|
nextArchetype.Edges.Add(componentId, newEdge);
|
|
}
|
|
|
|
MoveEntityToHigherArchetype(entityId, record.Row, archetype, nextArchetype);
|
|
|
|
// add the new component to the new archetype
|
|
var columnIndex = nextArchetype.ComponentToColumnIndex[componentId];
|
|
var column = nextArchetype.ComponentColumns[columnIndex];
|
|
column.Append(component);
|
|
}
|
|
|
|
public void Remove<T>(Id entityId) where T : unmanaged
|
|
{
|
|
Archetype? nextArchetype;
|
|
|
|
var componentId = GetComponentId<T>();
|
|
|
|
var (archetype, row) = EntityIndex[entityId];
|
|
|
|
if (archetype.Edges.TryGetValue(componentId, out var edge))
|
|
{
|
|
nextArchetype = edge.Remove;
|
|
}
|
|
else
|
|
{
|
|
// FIXME: pool the signatures
|
|
var nextSignature = new ArchetypeSignature(archetype.Signature.Count + 1);
|
|
archetype.Signature.CopyTo(nextSignature);
|
|
nextSignature.Remove(componentId);
|
|
|
|
if (!ArchetypeIndex.TryGetValue(nextSignature, out nextArchetype))
|
|
{
|
|
nextArchetype = CreateArchetype(nextSignature);
|
|
}
|
|
|
|
var newEdge = new ArchetypeEdge(nextArchetype, archetype);
|
|
archetype.Edges.Add(componentId, newEdge);
|
|
nextArchetype.Edges.Add(componentId, newEdge);
|
|
}
|
|
|
|
MoveEntityToLowerArchetype(entityId, row, archetype, nextArchetype, componentId);
|
|
}
|
|
|
|
private Id Pair(in Id relation, in Id target)
|
|
{
|
|
return new Id(relation.Low, target.Low);
|
|
}
|
|
|
|
public void Relate<T>(in Id entityA, in Id entityB, in T relation) where T : unmanaged
|
|
{
|
|
TryRegisterComponentId<T>();
|
|
var relationDataTypeId = GetComponentId<T>();
|
|
|
|
var typeId = Pair(relationDataTypeId, entityB);
|
|
|
|
TryRegisterTypeId(typeId, Unsafe.SizeOf<T>());
|
|
SetRelationData(entityA, typeId, relation);
|
|
}
|
|
|
|
public bool Related<T>(in Id entityA, in Id entityB) where T : unmanaged
|
|
{
|
|
var relationDataTypeId = GetComponentId<T>();
|
|
var typeId = Pair(relationDataTypeId, entityB);
|
|
return Has(entityA, typeId);
|
|
}
|
|
|
|
public T GetRelationData<T>(in Id entityA, in Id entityB) where T : unmanaged
|
|
{
|
|
var relationDataTypeId = GetComponentId<T>();
|
|
var typeId = Pair(relationDataTypeId, entityB);
|
|
return Get<T>(entityA, typeId);
|
|
}
|
|
|
|
private unsafe ref T Get<T>(Id entityId, Id typeId) where T : unmanaged
|
|
{
|
|
var record = EntityIndex[entityId];
|
|
var columnIndex = record.Archetype.ComponentToColumnIndex[typeId];
|
|
var column = record.Archetype.ComponentColumns[columnIndex];
|
|
|
|
return ref ((T*) column.Elements)[record.Row];
|
|
}
|
|
|
|
private bool Has(Id entityId, Id typeId)
|
|
{
|
|
var record = EntityIndex[entityId];
|
|
return record.Archetype.ComponentToColumnIndex.ContainsKey(typeId);
|
|
}
|
|
|
|
private void Add<T>(Id entityId, Id typeId, in T component) where T : unmanaged
|
|
{
|
|
Archetype? nextArchetype;
|
|
|
|
// move the entity to the new archetype
|
|
var record = EntityIndex[entityId];
|
|
var archetype = record.Archetype;
|
|
|
|
if (archetype.Edges.TryGetValue(typeId, out var edge))
|
|
{
|
|
nextArchetype = edge.Add;
|
|
}
|
|
else
|
|
{
|
|
// FIXME: pool the signatures
|
|
var nextSignature = new ArchetypeSignature(archetype.Signature.Count + 1);
|
|
archetype.Signature.CopyTo(nextSignature);
|
|
nextSignature.Insert(typeId);
|
|
|
|
if (!ArchetypeIndex.TryGetValue(nextSignature, out nextArchetype))
|
|
{
|
|
nextArchetype = CreateArchetype(nextSignature);
|
|
}
|
|
|
|
var newEdge = new ArchetypeEdge(nextArchetype, archetype);
|
|
archetype.Edges.Add(typeId, newEdge);
|
|
nextArchetype.Edges.Add(typeId, newEdge);
|
|
}
|
|
|
|
MoveEntityToHigherArchetype(entityId, record.Row, archetype, nextArchetype);
|
|
|
|
// add the new component to the new archetype
|
|
var columnIndex = nextArchetype.ComponentToColumnIndex[typeId];
|
|
var column = nextArchetype.ComponentColumns[columnIndex];
|
|
column.Append(component);
|
|
}
|
|
|
|
private unsafe void SetRelationData<T>(in Id entityId, in Id typeId, T data) where T : unmanaged
|
|
{
|
|
if (Has(entityId, typeId))
|
|
{
|
|
var record = EntityIndex[entityId];
|
|
var columnIndex = record.Archetype.ComponentToColumnIndex[typeId];
|
|
var column = record.Archetype.ComponentColumns[columnIndex];
|
|
|
|
((T*) column.Elements)[record.Row] = data;
|
|
}
|
|
else
|
|
{
|
|
Add(entityId, typeId, data);
|
|
}
|
|
}
|
|
|
|
public void Destroy(Id entityId)
|
|
{
|
|
var record = EntityIndex[entityId];
|
|
var archetype = record.Archetype;
|
|
var row = record.Row;
|
|
|
|
for (int i = 0; i < archetype.ComponentColumns.Count; i += 1)
|
|
{
|
|
archetype.ComponentColumns[i].Delete(row);
|
|
}
|
|
|
|
if (row != archetype.Count - 1)
|
|
{
|
|
// move last row entity to open spot
|
|
var lastRowEntity = archetype.RowToEntity[archetype.Count - 1];
|
|
archetype.RowToEntity[row] = lastRowEntity;
|
|
EntityIndex[lastRowEntity] = new Record(archetype, row);
|
|
}
|
|
|
|
archetype.RowToEntity.RemoveAt(archetype.Count - 1);
|
|
EntityIndex.Remove(entityId);
|
|
IdAssigner.Unassign(entityId);
|
|
}
|
|
|
|
private void MoveEntityToHigherArchetype(Id entityId, int row, Archetype from, Archetype to)
|
|
{
|
|
for (int i = 0; i < from.ComponentColumns.Count; i += 1)
|
|
{
|
|
var componentId = from.Signature[i];
|
|
var destinationColumnIndex = to.ComponentToColumnIndex[componentId];
|
|
|
|
// copy all components to higher archetype
|
|
from.ComponentColumns[i].CopyElementToEnd(row, to.ComponentColumns[destinationColumnIndex]);
|
|
|
|
// delete row on from archetype
|
|
from.ComponentColumns[i].Delete(row);
|
|
}
|
|
|
|
if (row != from.Count - 1)
|
|
{
|
|
// move last row entity to open spot
|
|
var lastRowEntity = from.RowToEntity[from.Count - 1];
|
|
from.RowToEntity[row] = lastRowEntity;
|
|
EntityIndex[lastRowEntity] = new Record(from, row);
|
|
}
|
|
|
|
from.RowToEntity.RemoveAt(from.Count - 1);
|
|
|
|
// update row to entity lookup on to archetype
|
|
EntityIndex[entityId] = new Record(to, to.Count);
|
|
to.RowToEntity.Add(entityId);
|
|
}
|
|
|
|
private void MoveEntityToLowerArchetype(Id entityId, int row, Archetype from, Archetype to, Id removed)
|
|
{
|
|
for (int i = 0; i < from.ComponentColumns.Count; i += 1)
|
|
{
|
|
var componentId = from.Signature[i];
|
|
|
|
// delete the row
|
|
from.ComponentColumns[i].Delete(row);
|
|
|
|
// if this isn't the removed component, copy to the lower archetype
|
|
if (componentId != removed)
|
|
{
|
|
var destinationColumnIndex = to.ComponentToColumnIndex[componentId];
|
|
from.ComponentColumns[i].CopyElementToEnd(row, to.ComponentColumns[destinationColumnIndex]);
|
|
}
|
|
}
|
|
|
|
if (row != from.Count - 1)
|
|
{
|
|
// update row to entity lookup on from archetype
|
|
var lastRowEntity = from.RowToEntity[from.Count - 1];
|
|
from.RowToEntity[row] = lastRowEntity;
|
|
EntityIndex[lastRowEntity] = new Record(from, row);
|
|
}
|
|
|
|
from.RowToEntity.RemoveAt(from.Count - 1);
|
|
|
|
// update row to entity lookup on to archetype
|
|
EntityIndex[entityId] = new Record(to, to.Count);
|
|
to.RowToEntity.Add(entityId);
|
|
}
|
|
|
|
public unsafe void ForEachEntity<T, T1, T2>(Filter filter,
|
|
T rowForEachContainer) where T : IForEach<T1, T2> where T1 : unmanaged where T2 : unmanaged
|
|
{
|
|
foreach (var archetype in filter.Archetypes)
|
|
{
|
|
var componentIdOne = archetype.Signature[0];
|
|
var columnIndexOne = archetype.ComponentToColumnIndex[componentIdOne];
|
|
var columnOneElements = archetype.ComponentColumns[columnIndexOne].Elements;
|
|
|
|
var componentIdTwo = archetype.Signature[1];
|
|
var columnIndexTwo = archetype.ComponentToColumnIndex[componentIdTwo];
|
|
var columnTwoElements = archetype.ComponentColumns[columnIndexTwo].Elements;
|
|
|
|
for (int i = archetype.Count - 1; i >= 0; i -= 1)
|
|
{
|
|
rowForEachContainer.Update(ref ((T1*) columnOneElements)[i], ref ((T2*) columnTwoElements)[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
public unsafe void ForEachEntity<T1, T2>(Filter filter, RefAction<T1, T2> rowAction) where T1 : unmanaged where T2 : unmanaged
|
|
{
|
|
foreach (var archetype in filter.Archetypes)
|
|
{
|
|
var componentIdOne = archetype.Signature[0];
|
|
var columnIndexOne = archetype.ComponentToColumnIndex[componentIdOne];
|
|
var columnOneElements = archetype.ComponentColumns[columnIndexOne].Elements;
|
|
|
|
var componentIdTwo = archetype.Signature[1];
|
|
var columnIndexTwo = archetype.ComponentToColumnIndex[componentIdTwo];
|
|
var columnTwoElements = archetype.ComponentColumns[columnIndexTwo].Elements;
|
|
|
|
for (int i = archetype.Count - 1; i >= 0; i -= 1)
|
|
{
|
|
rowAction(ref ((T1*) columnOneElements)[i], ref ((T2*) columnTwoElements)[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (!IsDisposed)
|
|
{
|
|
if (disposing)
|
|
{
|
|
// dispose managed state (managed objects)
|
|
foreach (var archetype in ArchetypeIndex.Values)
|
|
{
|
|
for (var i = 0; i < archetype.Signature.Count; i += 1)
|
|
{
|
|
archetype.ComponentColumns[i].Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: free unmanaged resources (unmanaged objects) and override finalizer
|
|
// TODO: set large fields to null
|
|
IsDisposed = true;
|
|
}
|
|
}
|
|
|
|
// TODO: override finalizer only if 'Dispose(bool disposing)' has code to free unmanaged resources
|
|
// ~World()
|
|
// {
|
|
// // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
|
|
// Dispose(disposing: false);
|
|
// }
|
|
|
|
public void Dispose()
|
|
{
|
|
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
|
|
Dispose(disposing: true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
}
|
|
}
|