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

sparse set

storage_conversion
cosmonaut 2023-12-19 15:31:10 -08:00
parent cbdcca5bbf
commit 94c195e920
5 changed files with 63 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Collections/NativeArray.cs
View File

@ -8,7 +8,7 @@ public unsafe class NativeArray<T> : IDisposable where T : unmanaged
{
private T* Elements;
public int Count { get; private set; }
private int Capacity;
public int Capacity { get; private set; }
private int ElementSize;
public Span<T> ToSpan() => new Span<T>(Elements, Count);

71
src/ComponentStorage.cs
View File

@ -1,4 +1,6 @@
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using MoonTools.ECS.Collections;
namespace MoonTools.ECS;
@ -6,36 +8,34 @@ namespace MoonTools.ECS;
public class ComponentStorage : IDisposable
{
internal readonly NativeArray<Entity> DenseArray = new NativeArray<Entity>();
internal readonly NativeArray<Entity> SparseArray = new NativeArray<Entity>();
internal readonly NativeArray ElementArray;
internal readonly NativeArray<int> SparseArray = new NativeArray<int>();
internal nint ElementArray;
internal int ElementArrayCapacity;
private bool IsDisposed;
public int ElementSize { get; private set; }
public int Count => DenseArray.Count;
public ComponentStorage(int elementSize)
public unsafe ComponentStorage(int elementSize)
{
for (var i = 0; i < 16; i += 1)
{
SparseArray.Append(Entity.Null); // sentinel value
SparseArray.Append(Entity.Null.ID); // sentinel value
}
ElementArray = new NativeArray(elementSize);
ElementArrayCapacity = 16;
ElementArray = (nint) NativeMemory.Alloc((nuint) (elementSize * ElementArrayCapacity));
ElementSize = elementSize;
}
public bool Any() => DenseArray.Count > 0;
public ref T Get<T>(Entity entity) where T : unmanaged
public unsafe ref T Get<T>(Entity entity) where T : unmanaged
{
if (entity.ID >= ElementArray.Capacity)
{
throw new Exception("oh noes");
}
return ref ElementArray.Get<T>(entity.ID);
return ref ((T*) ElementArray)[SparseArray[entity.ID]];
}
public ref T GetFirst<T>() where T : unmanaged
public unsafe ref T GetFirst<T>() where T : unmanaged
{
#if DEBUG
if (DenseArray.Count == 0)
@ -43,12 +43,12 @@ public class ComponentStorage : IDisposable
throw new IndexOutOfRangeException("Component storage is empty!");
}
#endif
return ref ElementArray.Get<T>(DenseArray[0].ID);
return ref ((T*) ElementArray)[0];
}
public bool Set<T>(Entity entity, T component) where T : unmanaged
public unsafe bool Set<T>(Entity entity, T component) where T : unmanaged
{
var newEntity = SparseArray[entity.ID] == Entity.Null;
var newEntity = entity.ID >= SparseArray.Count || SparseArray[entity.ID] == Entity.Null.ID;
if (newEntity)
{
// the entity is being added! let's do some record keeping
@ -58,40 +58,47 @@ public class ComponentStorage : IDisposable
{
var oldCount = SparseArray.Count;
SparseArray.ResizeTo(entity.ID + 1);
for (var i = oldCount; i < SparseArray.Count; i += 1)
for (var i = oldCount; i < SparseArray.Capacity; i += 1)
{
SparseArray.Append(Entity.Null); // sentinel value
SparseArray.Append(Entity.Null.ID); // sentinel value
}
}
SparseArray[entity.ID] = entity;
SparseArray[entity.ID] = index;
// FIXME: something is not right here
if (entity.ID >= ElementArray.Count)
if (entity.ID >= ElementArrayCapacity)
{
ElementArray.ResizeTo(entity.ID + 1);
ElementArrayCapacity = entity.ID + 1;
ElementArray = (nint) NativeMemory.Realloc((void*) ElementArray, (nuint) (ElementArrayCapacity * ElementSize));
}
}
ElementArray.Set(entity.ID, component);
Unsafe.Write((void*) (ElementArray + ElementSize * SparseArray[entity.ID]), component);
return !newEntity;
}
public bool Has(Entity entity)
{
return SparseArray[entity.ID] != Entity.Null;
return entity.ID < SparseArray.Count && SparseArray[entity.ID] != Entity.Null.ID;
}
public bool Remove(Entity entity)
public unsafe bool Remove(Entity entity)
{
if (Has(entity))
{
var denseIndex = SparseArray[entity.ID];
var lastItem = DenseArray[DenseArray.Count - 1];
DenseArray[denseIndex.ID] = lastItem;
DenseArray[denseIndex] = lastItem;
SparseArray[lastItem.ID] = denseIndex;
SparseArray[entity.ID] = Entity.Null; // sentinel value
SparseArray[entity.ID] = Entity.Null.ID; // sentinel value
if (denseIndex != DenseArray.Count - 1)
{
NativeMemory.Copy((void*) (ElementArray + ElementSize * (DenseArray.Count - 1)), (void*) (ElementArray + ElementSize * denseIndex), (nuint) ElementSize);
}
DenseArray.RemoveLastElement();
ElementArray.RemoveLastElement();
return true;
}
@ -102,10 +109,9 @@ public class ComponentStorage : IDisposable
public void Clear()
{
DenseArray.Clear();
ElementArray.Clear();
for (var i = 0; i < SparseArray.Count; i += 1)
for (var i = 0; i < SparseArray.Capacity; i += 1)
{
SparseArray[i] = Entity.Null;
SparseArray[i] = Entity.Null.ID;
}
}
@ -127,7 +133,7 @@ public class ComponentStorage : IDisposable
}
#endif
protected virtual void Dispose(bool disposing)
protected unsafe virtual void Dispose(bool disposing)
{
if (!IsDisposed)
{
@ -135,9 +141,10 @@ public class ComponentStorage : IDisposable
{
DenseArray.Dispose();
SparseArray.Dispose();
ElementArray.Dispose();
}
NativeMemory.Free((void*) ElementArray);
IsDisposed = true;
}
}

32
src/Snapshot.cs
View File

@ -1,6 +1,7 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using MoonTools.ECS.Collections;
namespace MoonTools.ECS;
@ -206,34 +207,40 @@ public class Snapshot : IDisposable
private class ComponentSnapshot : IDisposable
{
private readonly NativeArray<Entity> DenseArray = new NativeArray<Entity>();
private readonly NativeArray<Entity> SparseArray = new NativeArray<Entity>();
private readonly NativeArray ElementArray;
private readonly NativeArray<Entity> DenseArray;
private readonly NativeArray<int> SparseArray;
private nint ElementArray;
private int ElementArrayCapacity;
private bool IsDisposed;
public ComponentSnapshot(int elementSize)
public unsafe ComponentSnapshot(int elementSize)
{
ElementArray = new NativeArray(elementSize);
ElementArray = (nint) NativeMemory.Alloc((nuint) (16 * elementSize));
DenseArray = new NativeArray<Entity>(elementSize);
SparseArray = new NativeArray<Entity>(elementSize);
SparseArray = new NativeArray<int>(elementSize);
}
public void Take(ComponentStorage componentStorage)
public unsafe void Take(ComponentStorage componentStorage)
{
componentStorage.DenseArray.CopyTo(DenseArray);
componentStorage.SparseArray.CopyTo(SparseArray);
componentStorage.ElementArray.CopyAllTo(ElementArray);
if (componentStorage.ElementArrayCapacity > ElementArrayCapacity)
{
ElementArrayCapacity = componentStorage.ElementArrayCapacity;
NativeMemory.Realloc((void*) ElementArray, (nuint) (componentStorage.ElementSize * ElementArrayCapacity));
}
NativeMemory.Copy((void*) componentStorage.ElementArray, (void*) ElementArray, (nuint) (ElementArrayCapacity * componentStorage.ElementSize));
}
public void Restore(ComponentStorage componentStorage)
public unsafe void Restore(ComponentStorage componentStorage)
{
DenseArray.CopyTo(componentStorage.DenseArray);
SparseArray.CopyTo(componentStorage.SparseArray);
ElementArray.CopyAllTo(componentStorage.ElementArray);
NativeMemory.Copy((void*) ElementArray, (void*) componentStorage.ElementArray, (nuint) (ElementArrayCapacity * componentStorage.ElementSize));
}
protected virtual void Dispose(bool disposing)
protected unsafe virtual void Dispose(bool disposing)
{
if (!IsDisposed)
{
@ -241,9 +248,10 @@ public class Snapshot : IDisposable
{
DenseArray.Dispose();
SparseArray.Dispose();
ElementArray.Dispose();
}
NativeMemory.Free((void*) ElementArray);
IsDisposed = true;
}
}

1
src/TypeId.cs
View File

@ -36,6 +36,7 @@ public class ComponentTypeIdAssigner<T> : ComponentTypeIdAssigner
#if DEBUG
World.ComponentTypeToId[typeof(T)] = new TypeId(Id);
World.ComponentTypeIdToType.Add(typeof(T));
#endif
}
}

4
src/World.cs
View File

@ -148,12 +148,12 @@ public class World : IDisposable
public bool Has<T>(in Entity entity) where T : unmanaged
{
return EntityComponentIndex[entity].Contains(new TypeId(ComponentTypeIdAssigner<T>.Id));
return GetComponentStorage<T>().Has(entity);
}
internal bool Has(in Entity entity, in TypeId typeId)
{
return EntityComponentIndex[entity].Contains(typeId);
return ComponentIndex[(int) typeId.Value].Has(entity);
}
public bool Some<T>() where T : unmanaged