Changed project name

Ghost.SparseEntities/Template/ForEach.cs

@@ -0,0 +1,12 @@
+
+
+namespace Ghost.SparseEntities;
+
+public delegate void ForEach<T0>(ref T0 t0Component);
+public delegate void ForEach<T0, T1>(ref T0 t0Component,ref T1 t1Component);
+public delegate void ForEach<T0, T1, T2>(ref T0 t0Component,ref T1 t1Component,ref T2 t2Component);
+public delegate void ForEach<T0, T1, T2, T3>(ref T0 t0Component,ref T1 t1Component,ref T2 t2Component,ref T3 t3Component);
+public delegate void ForEach<T0, T1, T2, T3, T4>(ref T0 t0Component,ref T1 t1Component,ref T2 t2Component,ref T3 t3Component,ref T4 t4Component);
+public delegate void ForEach<T0, T1, T2, T3, T4, T5>(ref T0 t0Component,ref T1 t1Component,ref T2 t2Component,ref T3 t3Component,ref T4 t4Component,ref T5 t5Component);
+public delegate void ForEach<T0, T1, T2, T3, T4, T5, T6>(ref T0 t0Component,ref T1 t1Component,ref T2 t2Component,ref T3 t3Component,ref T4 t4Component,ref T5 t5Component,ref T6 t6Component);
+public delegate void ForEach<T0, T1, T2, T3, T4, T5, T6, T7>(ref T0 t0Component,ref T1 t1Component,ref T2 t2Component,ref T3 t3Component,ref T4 t4Component,ref T5 t5Component,ref T6 t6Component,ref T7 t7Component);

Ghost.SparseEntities/Template/ForEach.tt

@@ -0,0 +1,16 @@
+<#@ template language="C#" #>
+<#@ output extension=".cs" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ include file="Helpers.ttinclude" #>
+
+namespace Ghost.Entities;
+
+<# for (var i = 1; i <= Amount; i++)
+{
+    var generics = AppendGenerics(i);
+    var compGenerics = AppendGenericRefParameters(i);
+#>
+public delegate void ForEach<<#= generics #>>(<#= compGenerics #>);
+<# } #>

Ghost.SparseEntities/Template/Helpers.ttinclude

@@ -0,0 +1,128 @@
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#+
+
+    public int Amount = 8;
+    public int ExtensionAmount = 3;
+
+    public string Indent(StringBuilder sb, int spaces)
+    {
+        var indent = new string(' ', spaces);
+        return sb.ToString().Replace("\n", "\n" + indent);
+    }
+
+    string AppendGenerics(int amount, string template)
+    {
+        var sb = new StringBuilder();
+        for (var i = 0; i < amount; i++)
+        {
+            if (i > 0) sb.Append(", ");
+            sb.Append($"{template}{i}");
+        }
+        return sb.ToString();
+    }
+
+    string AppendGenerics(int amount)
+    {
+        return AppendGenerics(amount, "T");
+    }
+
+    public StringBuilder AppendGenericRefParameters(int amount)
+    {
+        var sb = new StringBuilder();
+        for (var localIndex = 0; localIndex < amount; localIndex++)
+        {
+            sb.Append($"ref T{localIndex} t{localIndex}Component,");
+        }
+
+        sb.Length--;
+        return sb;
+    }
+
+    public StringBuilder AppendRefParameters(int amount)
+    {
+        var sb = new StringBuilder();
+        for (var localIndex = 0; localIndex < amount; localIndex++)
+        {
+            sb.Append($"ref component{localIndex},");
+        }
+
+        sb.Length--;
+        return sb;
+    }
+
+    public StringBuilder AppendGenericRestrictions(int amount, string Ttemplate, string template)
+    {
+        var sb = new StringBuilder();
+        for (var localIndex = 0; localIndex < amount; localIndex++)
+        {
+            sb.Append($"where {Ttemplate}{localIndex} : {template}");
+            if (localIndex < amount - 1)
+            {
+                sb.Append(' ');
+            }
+        }
+        return sb;
+    }
+
+    public StringBuilder AppendGenericRestrictions(int amount, string template)
+    {
+        return AppendGenericRestrictions(amount, "T", template);
+    }
+
+    public StringBuilder TryGetComponentPools(int amount)
+    {
+        var sb = new StringBuilder();
+        for (var localIndex = 0; localIndex < amount; localIndex++)
+        {
+            sb.Append($"_componentStorage.TryGetPool<T{localIndex}>(out var pool{localIndex})");
+            if (localIndex < amount - 1)
+            {
+                sb.Append(" && ");
+            }
+        }
+        return sb;
+    }
+
+    public StringBuilder HasEntity(int amount)
+    {
+        var sb = new StringBuilder();
+        for (var localIndex = 1; localIndex < amount; localIndex++)
+        {
+            sb.Append($"pool{localIndex}.Has(entity)");
+            if (localIndex < amount - 1)
+            {
+                sb.Append(" && ");
+            }
+        }
+        return sb;
+    }
+
+    public StringBuilder GetComponent(int amount)
+    {
+        var sb = new StringBuilder();
+        for (var localIndex = 0; localIndex < amount; localIndex++)
+        {
+            sb.Append($"pool{localIndex}.GetRef(entity)");
+            if (localIndex < amount - 1)
+            {
+                sb.Append(", ");
+            }
+        }
+        return sb;
+    }
+
+        public StringBuilder GetComponentRef(int amount)
+    {
+        var sb = new StringBuilder();
+        for (var localIndex = 0; localIndex < amount; localIndex++)
+        {
+            sb.Append($"ref pool{localIndex}.GetRef(entity)");
+            if (localIndex < amount - 1)
+            {
+                sb.Append(", ");
+            }
+        }
+        return sb;
+    }
+#>

Ghost.SparseEntities/Template/QueryEnumerable.tt

@@ -0,0 +1,175 @@
+<#@ template language="C#" #>
+<#@ output extension=".cs" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Linq" #>
+<#@ include file="Helpers.ttinclude" #>
+
+using Ghost.Core;
+using Ghost.Entities.Components;
+using Ghost.Entities.Query;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+
+namespace Ghost.Entities;
+
+<# for (int arity = 1; arity <= Amount; arity++) {
+var generics = AppendGenerics(arity);
+var restrictions = AppendGenericRestrictions(arity, "unmanaged, IComponentData");
+var poolParams = Enumerable.Range(0, arity)
+                            .Select(i => $"ComponentPool<T{i}> pool{i}")
+                            .Aggregate((a, b) => a + ", " + b);
+var constructorParams = Enumerable.Range(0, arity)
+                                    .Select(i => $"_pool{i}")
+                                    .Aggregate((a, b) => a + ", " + b);
+    
+#>
+public unsafe ref struct QueryEnumerable<<#= generics #>>
+    <#= restrictions #>
+{
+    private QueryFilter _filter;
+
+    private readonly World _world;
+
+<# for (int i = 0; i < arity; i++){ #>
+    private readonly ComponentPool<T<#= i #>> _pool<#= i #>;
+<# } #>
+    private readonly int _count;
+
+    internal QueryEnumerable(World world, <#= poolParams #>, int count)
+    {
+        _filter = new();
+<# for (int i = 0; i < arity; i++) {#>
+        _filter._all.Add(TypeHandle.Get<T<#= i #>>());
+<# } #>
+
+        _world = world;
+
+<# for (int i = 0; i < arity; i++) { #>
+        _pool<#= i #> = pool<#= i #>;
+<# } #>
+
+        _count = count;
+    }
+
+    internal QueryEnumerable(World world, <#= poolParams #>, int count, ref readonly QueryFilter filter)
+    {
+        _filter = filter;
+
+        _world = world;
+
+<# for (int i = 0; i < arity; i++) { #>
+        _pool<#= i #> = pool<#= i #>;
+<# } #>
+
+        _count = count;
+    }
+
+#pragma warning disable CS9084 // Struct member returns 'this' or other instance members by reference
+    public Enumerator GetEnumerator() => new(_world, <#= constructorParams #>, _count, ref _filter);
+#pragma warning restore CS9084 // Struct member returns 'this' or other instance members by reference
+
+    public ref struct Enumerator
+    {
+        private ref QueryFilter _filter;
+        private UnsafeBitSet _filterMask;
+        
+        private readonly ReadOnlySpan<Entity> _entities;
+        private readonly Stack.Scope _stackScope;
+
+<# for (int i = 0; i < arity; i++){ #>
+        private readonly ComponentPool<T<#= i #>> _pool<#= i #>;
+<# } #>
+
+        private int _index;
+        private int _count;
+
+        public QueryItem<<#= generics #>> Current
+        {
+            get;
+            private set;
+        }
+
+        internal Enumerator(World world, <#= poolParams #>, int count, ref QueryFilter filter)
+        {
+            _stackScope = AllocationManager.CreateStackScope();
+
+            _filter = ref filter;
+            _filterMask = _filter.ComputeFilterBitMask(world, Allocator.Stack);
+
+            _entities = world.EntityManager.Entities;
+
+<# for (int i = 0; i < arity; i++){ #>
+            _pool<#= i #> = pool<#= i #>;
+<# } #>
+
+            _count = count;
+            _index = -1;
+
+            Current = default;
+        }
+
+        public bool MoveNext()
+        {
+            _index = _filterMask.NextSetBit(_index + 1);
+            if (_index < 0 || _count <= 0)
+            {
+                return false;
+            }
+
+            _count--;
+            Current = new QueryItem<<#= generics #>>(_entities[_index], <#= constructorParams #>);
+
+            return true;
+        }
+
+        public readonly void Dispose()
+        {
+            _stackScope.Dispose();
+            _filter.Dispose();
+        }
+    }
+<# for (int i = 1; i <= ExtensionAmount; i++) {
+var compGenerics = AppendGenerics(i, "TComponent");
+var compRestrictions = AppendGenericRestrictions(i, "TComponent", "unmanaged, IComponentData");
+#>
+
+	public QueryEnumerable<<#= generics #>> WithAll<<#= compGenerics #>>()
+		<#= compRestrictions #>
+	{
+<# for (int j = 0; j < i; j++) {#>
+        _filter._all.Add(TypeHandle.Get<TComponent<#= j #>>());
+<# } #>
+        return this;
+	}
+
+    public QueryEnumerable<<#= generics #>> WithAny<<#= compGenerics #>>()
+		<#= compRestrictions #>
+	{
+<# for (int j = 0; j < i; j++) {#>
+        _filter._any.Add(TypeHandle.Get<TComponent<#= j #>>());
+<# } #>
+        return this;
+	}
+
+    public QueryEnumerable<<#= generics #>> WithAbsent<<#= compGenerics #>>()
+		<#= compRestrictions #>
+	{
+<# for (int j = 0; j < i; j++) {#>
+        _filter._absent.Add(TypeHandle.Get<TComponent<#= j #>>());
+<# } #>
+        return this;
+	}
+
+    public QueryEnumerable<<#= generics #>> WithDisabled<<#= compGenerics #>>()
+		<#= compRestrictions #>
+	{
+<# for (int j = 0; j < i; j++) {#>
+        _filter._disabled.Add(TypeHandle.Get<TComponent<#= j #>>());
+<# } #>
+        return this;
+	}
+<# } #>
+}
+
+<# } #>

Ghost.SparseEntities/Template/QueryItem.cs

@@ -0,0 +1,319 @@
+
+
+using Ghost.SparseEntities.Components;
+using Ghost.SparseEntities.Query;
+
+namespace Ghost.SparseEntities;
+
+public readonly struct QueryItem<T0>
+    where T0 : unmanaged, IComponentData
+{
+    private readonly Entity _entity;
+    private readonly ComponentPool<T0> _pool0;
+
+    internal QueryItem(Entity entity, ComponentPool<T0> pool0)
+    {
+        _entity = entity;
+        _pool0 = pool0;
+    }
+
+    public Entity Entity => _entity;
+
+    public ref T0 Component0 => ref _pool0.GetRef(_entity);
+
+    // Deconstruct into tuple-like values
+    public void Deconstruct(out Entity entity, out CompRef<T0> c0)
+    {
+        entity = _entity;
+
+        c0 = new (ref _pool0.GetRef(_entity));
+    }
+}
+
+public readonly struct QueryItem<T0, T1>
+    where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData
+{
+    private readonly Entity _entity;
+    private readonly ComponentPool<T0> _pool0;
+    private readonly ComponentPool<T1> _pool1;
+
+    internal QueryItem(Entity entity, ComponentPool<T0> pool0, ComponentPool<T1> pool1)
+    {
+        _entity = entity;
+        _pool0 = pool0;
+        _pool1 = pool1;
+    }
+
+    public Entity Entity => _entity;
+
+    public ref T0 Component0 => ref _pool0.GetRef(_entity);
+    public ref T1 Component1 => ref _pool1.GetRef(_entity);
+
+    // Deconstruct into tuple-like values
+    public void Deconstruct(out Entity entity, out CompRef<T0> c0, out CompRef<T1> c1)
+    {
+        entity = _entity;
+
+        c0 = new (ref _pool0.GetRef(_entity));
+        c1 = new (ref _pool1.GetRef(_entity));
+    }
+}
+
+public readonly struct QueryItem<T0, T1, T2>
+    where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData
+{
+    private readonly Entity _entity;
+    private readonly ComponentPool<T0> _pool0;
+    private readonly ComponentPool<T1> _pool1;
+    private readonly ComponentPool<T2> _pool2;
+
+    internal QueryItem(Entity entity, ComponentPool<T0> pool0, ComponentPool<T1> pool1, ComponentPool<T2> pool2)
+    {
+        _entity = entity;
+        _pool0 = pool0;
+        _pool1 = pool1;
+        _pool2 = pool2;
+    }
+
+    public Entity Entity => _entity;
+
+    public ref T0 Component0 => ref _pool0.GetRef(_entity);
+    public ref T1 Component1 => ref _pool1.GetRef(_entity);
+    public ref T2 Component2 => ref _pool2.GetRef(_entity);
+
+    // Deconstruct into tuple-like values
+    public void Deconstruct(out Entity entity, out CompRef<T0> c0, out CompRef<T1> c1, out CompRef<T2> c2)
+    {
+        entity = _entity;
+
+        c0 = new (ref _pool0.GetRef(_entity));
+        c1 = new (ref _pool1.GetRef(_entity));
+        c2 = new (ref _pool2.GetRef(_entity));
+    }
+}
+
+public readonly struct QueryItem<T0, T1, T2, T3>
+    where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData
+{
+    private readonly Entity _entity;
+    private readonly ComponentPool<T0> _pool0;
+    private readonly ComponentPool<T1> _pool1;
+    private readonly ComponentPool<T2> _pool2;
+    private readonly ComponentPool<T3> _pool3;
+
+    internal QueryItem(Entity entity, ComponentPool<T0> pool0, ComponentPool<T1> pool1, ComponentPool<T2> pool2, ComponentPool<T3> pool3)
+    {
+        _entity = entity;
+        _pool0 = pool0;
+        _pool1 = pool1;
+        _pool2 = pool2;
+        _pool3 = pool3;
+    }
+
+    public Entity Entity => _entity;
+
+    public ref T0 Component0 => ref _pool0.GetRef(_entity);
+    public ref T1 Component1 => ref _pool1.GetRef(_entity);
+    public ref T2 Component2 => ref _pool2.GetRef(_entity);
+    public ref T3 Component3 => ref _pool3.GetRef(_entity);
+
+    // Deconstruct into tuple-like values
+    public void Deconstruct(out Entity entity, out CompRef<T0> c0, out CompRef<T1> c1, out CompRef<T2> c2, out CompRef<T3> c3)
+    {
+        entity = _entity;
+
+        c0 = new (ref _pool0.GetRef(_entity));
+        c1 = new (ref _pool1.GetRef(_entity));
+        c2 = new (ref _pool2.GetRef(_entity));
+        c3 = new (ref _pool3.GetRef(_entity));
+    }
+}
+
+public readonly struct QueryItem<T0, T1, T2, T3, T4>
+    where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData
+{
+    private readonly Entity _entity;
+    private readonly ComponentPool<T0> _pool0;
+    private readonly ComponentPool<T1> _pool1;
+    private readonly ComponentPool<T2> _pool2;
+    private readonly ComponentPool<T3> _pool3;
+    private readonly ComponentPool<T4> _pool4;
+
+    internal QueryItem(Entity entity, ComponentPool<T0> pool0, ComponentPool<T1> pool1, ComponentPool<T2> pool2, ComponentPool<T3> pool3, ComponentPool<T4> pool4)
+    {
+        _entity = entity;
+        _pool0 = pool0;
+        _pool1 = pool1;
+        _pool2 = pool2;
+        _pool3 = pool3;
+        _pool4 = pool4;
+    }
+
+    public Entity Entity => _entity;
+
+    public ref T0 Component0 => ref _pool0.GetRef(_entity);
+    public ref T1 Component1 => ref _pool1.GetRef(_entity);
+    public ref T2 Component2 => ref _pool2.GetRef(_entity);
+    public ref T3 Component3 => ref _pool3.GetRef(_entity);
+    public ref T4 Component4 => ref _pool4.GetRef(_entity);
+
+    // Deconstruct into tuple-like values
+    public void Deconstruct(out Entity entity, out CompRef<T0> c0, out CompRef<T1> c1, out CompRef<T2> c2, out CompRef<T3> c3, out CompRef<T4> c4)
+    {
+        entity = _entity;
+
+        c0 = new (ref _pool0.GetRef(_entity));
+        c1 = new (ref _pool1.GetRef(_entity));
+        c2 = new (ref _pool2.GetRef(_entity));
+        c3 = new (ref _pool3.GetRef(_entity));
+        c4 = new (ref _pool4.GetRef(_entity));
+    }
+}
+
+public readonly struct QueryItem<T0, T1, T2, T3, T4, T5>
+    where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData where T5 : unmanaged, IComponentData
+{
+    private readonly Entity _entity;
+    private readonly ComponentPool<T0> _pool0;
+    private readonly ComponentPool<T1> _pool1;
+    private readonly ComponentPool<T2> _pool2;
+    private readonly ComponentPool<T3> _pool3;
+    private readonly ComponentPool<T4> _pool4;
+    private readonly ComponentPool<T5> _pool5;
+
+    internal QueryItem(Entity entity, ComponentPool<T0> pool0, ComponentPool<T1> pool1, ComponentPool<T2> pool2, ComponentPool<T3> pool3, ComponentPool<T4> pool4, ComponentPool<T5> pool5)
+    {
+        _entity = entity;
+        _pool0 = pool0;
+        _pool1 = pool1;
+        _pool2 = pool2;
+        _pool3 = pool3;
+        _pool4 = pool4;
+        _pool5 = pool5;
+    }
+
+    public Entity Entity => _entity;
+
+    public ref T0 Component0 => ref _pool0.GetRef(_entity);
+    public ref T1 Component1 => ref _pool1.GetRef(_entity);
+    public ref T2 Component2 => ref _pool2.GetRef(_entity);
+    public ref T3 Component3 => ref _pool3.GetRef(_entity);
+    public ref T4 Component4 => ref _pool4.GetRef(_entity);
+    public ref T5 Component5 => ref _pool5.GetRef(_entity);
+
+    // Deconstruct into tuple-like values
+    public void Deconstruct(out Entity entity, out CompRef<T0> c0, out CompRef<T1> c1, out CompRef<T2> c2, out CompRef<T3> c3, out CompRef<T4> c4, out CompRef<T5> c5)
+    {
+        entity = _entity;
+
+        c0 = new (ref _pool0.GetRef(_entity));
+        c1 = new (ref _pool1.GetRef(_entity));
+        c2 = new (ref _pool2.GetRef(_entity));
+        c3 = new (ref _pool3.GetRef(_entity));
+        c4 = new (ref _pool4.GetRef(_entity));
+        c5 = new (ref _pool5.GetRef(_entity));
+    }
+}
+
+public readonly struct QueryItem<T0, T1, T2, T3, T4, T5, T6>
+    where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData where T5 : unmanaged, IComponentData where T6 : unmanaged, IComponentData
+{
+    private readonly Entity _entity;
+    private readonly ComponentPool<T0> _pool0;
+    private readonly ComponentPool<T1> _pool1;
+    private readonly ComponentPool<T2> _pool2;
+    private readonly ComponentPool<T3> _pool3;
+    private readonly ComponentPool<T4> _pool4;
+    private readonly ComponentPool<T5> _pool5;
+    private readonly ComponentPool<T6> _pool6;
+
+    internal QueryItem(Entity entity, ComponentPool<T0> pool0, ComponentPool<T1> pool1, ComponentPool<T2> pool2, ComponentPool<T3> pool3, ComponentPool<T4> pool4, ComponentPool<T5> pool5, ComponentPool<T6> pool6)
+    {
+        _entity = entity;
+        _pool0 = pool0;
+        _pool1 = pool1;
+        _pool2 = pool2;
+        _pool3 = pool3;
+        _pool4 = pool4;
+        _pool5 = pool5;
+        _pool6 = pool6;
+    }
+
+    public Entity Entity => _entity;
+
+    public ref T0 Component0 => ref _pool0.GetRef(_entity);
+    public ref T1 Component1 => ref _pool1.GetRef(_entity);
+    public ref T2 Component2 => ref _pool2.GetRef(_entity);
+    public ref T3 Component3 => ref _pool3.GetRef(_entity);
+    public ref T4 Component4 => ref _pool4.GetRef(_entity);
+    public ref T5 Component5 => ref _pool5.GetRef(_entity);
+    public ref T6 Component6 => ref _pool6.GetRef(_entity);
+
+    // Deconstruct into tuple-like values
+    public void Deconstruct(out Entity entity, out CompRef<T0> c0, out CompRef<T1> c1, out CompRef<T2> c2, out CompRef<T3> c3, out CompRef<T4> c4, out CompRef<T5> c5, out CompRef<T6> c6)
+    {
+        entity = _entity;
+
+        c0 = new (ref _pool0.GetRef(_entity));
+        c1 = new (ref _pool1.GetRef(_entity));
+        c2 = new (ref _pool2.GetRef(_entity));
+        c3 = new (ref _pool3.GetRef(_entity));
+        c4 = new (ref _pool4.GetRef(_entity));
+        c5 = new (ref _pool5.GetRef(_entity));
+        c6 = new (ref _pool6.GetRef(_entity));
+    }
+}
+
+public readonly struct QueryItem<T0, T1, T2, T3, T4, T5, T6, T7>
+    where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData where T5 : unmanaged, IComponentData where T6 : unmanaged, IComponentData where T7 : unmanaged, IComponentData
+{
+    private readonly Entity _entity;
+    private readonly ComponentPool<T0> _pool0;
+    private readonly ComponentPool<T1> _pool1;
+    private readonly ComponentPool<T2> _pool2;
+    private readonly ComponentPool<T3> _pool3;
+    private readonly ComponentPool<T4> _pool4;
+    private readonly ComponentPool<T5> _pool5;
+    private readonly ComponentPool<T6> _pool6;
+    private readonly ComponentPool<T7> _pool7;
+
+    internal QueryItem(Entity entity, ComponentPool<T0> pool0, ComponentPool<T1> pool1, ComponentPool<T2> pool2, ComponentPool<T3> pool3, ComponentPool<T4> pool4, ComponentPool<T5> pool5, ComponentPool<T6> pool6, ComponentPool<T7> pool7)
+    {
+        _entity = entity;
+        _pool0 = pool0;
+        _pool1 = pool1;
+        _pool2 = pool2;
+        _pool3 = pool3;
+        _pool4 = pool4;
+        _pool5 = pool5;
+        _pool6 = pool6;
+        _pool7 = pool7;
+    }
+
+    public Entity Entity => _entity;
+
+    public ref T0 Component0 => ref _pool0.GetRef(_entity);
+    public ref T1 Component1 => ref _pool1.GetRef(_entity);
+    public ref T2 Component2 => ref _pool2.GetRef(_entity);
+    public ref T3 Component3 => ref _pool3.GetRef(_entity);
+    public ref T4 Component4 => ref _pool4.GetRef(_entity);
+    public ref T5 Component5 => ref _pool5.GetRef(_entity);
+    public ref T6 Component6 => ref _pool6.GetRef(_entity);
+    public ref T7 Component7 => ref _pool7.GetRef(_entity);
+
+    // Deconstruct into tuple-like values
+    public void Deconstruct(out Entity entity, out CompRef<T0> c0, out CompRef<T1> c1, out CompRef<T2> c2, out CompRef<T3> c3, out CompRef<T4> c4, out CompRef<T5> c5, out CompRef<T6> c6, out CompRef<T7> c7)
+    {
+        entity = _entity;
+
+        c0 = new (ref _pool0.GetRef(_entity));
+        c1 = new (ref _pool1.GetRef(_entity));
+        c2 = new (ref _pool2.GetRef(_entity));
+        c3 = new (ref _pool3.GetRef(_entity));
+        c4 = new (ref _pool4.GetRef(_entity));
+        c5 = new (ref _pool5.GetRef(_entity));
+        c6 = new (ref _pool6.GetRef(_entity));
+        c7 = new (ref _pool7.GetRef(_entity));
+    }
+}
+

Ghost.SparseEntities/Template/QueryItem.tt

@@ -0,0 +1,61 @@
+<#@ template language="C#" debug="false" hostspecific="true" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ include file="Helpers.ttinclude" #>
+<#@ output extension=".cs" #>
+
+using Ghost.Entities.Components;
+using Ghost.Entities.Query;
+
+namespace Ghost.Entities;
+
+<# for (int arity = 1; arity <= Amount; arity++)
+{
+var generics = AppendGenerics(arity);
+var restrictions = AppendGenericRestrictions(arity, "unmanaged, IComponentData");
+var constructorParams = Enumerable.Range(0, arity)
+                                    .Select(i => $"ComponentPool<T{i}> pool{i}")
+                                    .Aggregate((a, b) => a + ", " + b);
+var deconstructParams = Enumerable.Range(0, arity)
+                                    .Select(i => {
+                                        var name = $"c{i}";
+                                        return arity == 1
+                                            ? $"out CompRef<T0> {name}"
+                                            : $"out CompRef<T{i}> {name}";
+                                    })
+                                    .Aggregate((a, b) => a + ", " + b);
+#>
+public readonly struct QueryItem<<#= generics #>>
+    <#= restrictions #>
+{
+    private readonly Entity _entity;
+<# for (int i = 0; i < arity; i++){ #>
+    private readonly ComponentPool<T<#= i #>> _pool<#= i #>;
+<# } #>
+
+    internal QueryItem(Entity entity, <#= constructorParams #>)
+    {
+        _entity = entity;
+<# for (int i = 0; i < arity; i++){ #>
+        _pool<#= i #> = pool<#= i #>;
+<# } #>
+    }
+
+    public Entity Entity => _entity;
+
+<# for (int i = 0; i < arity; i++){ #>
+    public ref T<#= i #> Component<#= i #> => ref _pool<#= i #>.GetRef(_entity);
+<# } #>
+
+    // Deconstruct into tuple-like values
+    public void Deconstruct(out Entity entity, <#= deconstructParams #>)
+    {
+        entity = _entity;
+
+<# for (int i = 0; i < arity; i++){ #>
+        c<#= i #> = new (ref _pool<#= i #>.GetRef(_entity));
+<# } #>
+    }
+}
+
+<# } #>

Ghost.SparseEntities/Template/QueryRefComponent.cs

@@ -0,0 +1,22 @@
+
+
+using Ghost.SparseEntities.Components;
+
+namespace Ghost.SparseEntities;
+
+public delegate void QueryRefComponent<T0>(Entity entity, ref T0 t0Component)
+    where T0 : unmanaged, IComponentData;
+public delegate void QueryRefComponent<T0, T1>(Entity entity, ref T0 t0Component,ref T1 t1Component)
+    where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData;
+public delegate void QueryRefComponent<T0, T1, T2>(Entity entity, ref T0 t0Component,ref T1 t1Component,ref T2 t2Component)
+    where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData;
+public delegate void QueryRefComponent<T0, T1, T2, T3>(Entity entity, ref T0 t0Component,ref T1 t1Component,ref T2 t2Component,ref T3 t3Component)
+    where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData;
+public delegate void QueryRefComponent<T0, T1, T2, T3, T4>(Entity entity, ref T0 t0Component,ref T1 t1Component,ref T2 t2Component,ref T3 t3Component,ref T4 t4Component)
+    where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData;
+public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5>(Entity entity, ref T0 t0Component,ref T1 t1Component,ref T2 t2Component,ref T3 t3Component,ref T4 t4Component,ref T5 t5Component)
+    where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData where T5 : unmanaged, IComponentData;
+public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6>(Entity entity, ref T0 t0Component,ref T1 t1Component,ref T2 t2Component,ref T3 t3Component,ref T4 t4Component,ref T5 t5Component,ref T6 t6Component)
+    where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData where T5 : unmanaged, IComponentData where T6 : unmanaged, IComponentData;
+public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7>(Entity entity, ref T0 t0Component,ref T1 t1Component,ref T2 t2Component,ref T3 t3Component,ref T4 t4Component,ref T5 t5Component,ref T6 t6Component,ref T7 t7Component)
+    where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData where T5 : unmanaged, IComponentData where T6 : unmanaged, IComponentData where T7 : unmanaged, IComponentData;

Ghost.SparseEntities/Template/QueryRefComponent.tt

@@ -0,0 +1,21 @@
+<#@ template language="C#" #>
+<#@ output extension=".cs" #>
+<#@ import namespace="System.Text" #>
+<#@ include file="Helpers.ttinclude" #>
+
+using Ghost.Entities.Components;
+
+namespace Ghost.Entities;
+
+<#
+for (var index = 1; index <= Amount; index++)
+{
+    var generics = AppendGenerics(index);
+    var parameters = AppendGenericRefParameters(index);
+    var restrictions = AppendGenericRestrictions(index, "unmanaged, IComponentData");
+#>
+public delegate void QueryRefComponent<<#= generics #>>(Entity entity, <#= parameters.ToString() #>)
+    <#= restrictions.ToString() #>;
+<#
+}
+#>

Ghost.SparseEntities/Template/World.Query.cs

@@ -0,0 +1,242 @@
+
+
+using Ghost.SparseEntities.Components;
+using Ghost.SparseEntities.Query;
+
+namespace Ghost.SparseEntities;
+
+public partial class World
+{
+    public QueryEnumerable<T0> Query<T0>()
+        where T0 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0>(
+            this,
+            pool0,
+            pool0.Count);
+    }
+
+    public QueryEnumerable<T0> QueryFilter<T0>(ref readonly QueryFilter filter) 
+        where T0 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0>(
+            this,
+            pool0,
+            pool0.Count,
+            in filter);
+    }
+
+    public QueryEnumerable<T0, T1> Query<T0, T1>()
+        where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0, T1>(
+            this,
+            pool0, pool1,
+            pool0.Count);
+    }
+
+    public QueryEnumerable<T0, T1> QueryFilter<T0, T1>(ref readonly QueryFilter filter) 
+        where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0, T1>(
+            this,
+            pool0, pool1,
+            pool0.Count,
+            in filter);
+    }
+
+    public QueryEnumerable<T0, T1, T2> Query<T0, T1, T2>()
+        where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1) && _componentStorage.TryGetPool<T2>(out var pool2)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0, T1, T2>(
+            this,
+            pool0, pool1, pool2,
+            pool0.Count);
+    }
+
+    public QueryEnumerable<T0, T1, T2> QueryFilter<T0, T1, T2>(ref readonly QueryFilter filter) 
+        where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1) && _componentStorage.TryGetPool<T2>(out var pool2)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0, T1, T2>(
+            this,
+            pool0, pool1, pool2,
+            pool0.Count,
+            in filter);
+    }
+
+    public QueryEnumerable<T0, T1, T2, T3> Query<T0, T1, T2, T3>()
+        where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1) && _componentStorage.TryGetPool<T2>(out var pool2) && _componentStorage.TryGetPool<T3>(out var pool3)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0, T1, T2, T3>(
+            this,
+            pool0, pool1, pool2, pool3,
+            pool0.Count);
+    }
+
+    public QueryEnumerable<T0, T1, T2, T3> QueryFilter<T0, T1, T2, T3>(ref readonly QueryFilter filter) 
+        where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1) && _componentStorage.TryGetPool<T2>(out var pool2) && _componentStorage.TryGetPool<T3>(out var pool3)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0, T1, T2, T3>(
+            this,
+            pool0, pool1, pool2, pool3,
+            pool0.Count,
+            in filter);
+    }
+
+    public QueryEnumerable<T0, T1, T2, T3, T4> Query<T0, T1, T2, T3, T4>()
+        where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1) && _componentStorage.TryGetPool<T2>(out var pool2) && _componentStorage.TryGetPool<T3>(out var pool3) && _componentStorage.TryGetPool<T4>(out var pool4)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0, T1, T2, T3, T4>(
+            this,
+            pool0, pool1, pool2, pool3, pool4,
+            pool0.Count);
+    }
+
+    public QueryEnumerable<T0, T1, T2, T3, T4> QueryFilter<T0, T1, T2, T3, T4>(ref readonly QueryFilter filter) 
+        where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1) && _componentStorage.TryGetPool<T2>(out var pool2) && _componentStorage.TryGetPool<T3>(out var pool3) && _componentStorage.TryGetPool<T4>(out var pool4)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0, T1, T2, T3, T4>(
+            this,
+            pool0, pool1, pool2, pool3, pool4,
+            pool0.Count,
+            in filter);
+    }
+
+    public QueryEnumerable<T0, T1, T2, T3, T4, T5> Query<T0, T1, T2, T3, T4, T5>()
+        where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData where T5 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1) && _componentStorage.TryGetPool<T2>(out var pool2) && _componentStorage.TryGetPool<T3>(out var pool3) && _componentStorage.TryGetPool<T4>(out var pool4) && _componentStorage.TryGetPool<T5>(out var pool5)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0, T1, T2, T3, T4, T5>(
+            this,
+            pool0, pool1, pool2, pool3, pool4, pool5,
+            pool0.Count);
+    }
+
+    public QueryEnumerable<T0, T1, T2, T3, T4, T5> QueryFilter<T0, T1, T2, T3, T4, T5>(ref readonly QueryFilter filter) 
+        where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData where T5 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1) && _componentStorage.TryGetPool<T2>(out var pool2) && _componentStorage.TryGetPool<T3>(out var pool3) && _componentStorage.TryGetPool<T4>(out var pool4) && _componentStorage.TryGetPool<T5>(out var pool5)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0, T1, T2, T3, T4, T5>(
+            this,
+            pool0, pool1, pool2, pool3, pool4, pool5,
+            pool0.Count,
+            in filter);
+    }
+
+    public QueryEnumerable<T0, T1, T2, T3, T4, T5, T6> Query<T0, T1, T2, T3, T4, T5, T6>()
+        where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData where T5 : unmanaged, IComponentData where T6 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1) && _componentStorage.TryGetPool<T2>(out var pool2) && _componentStorage.TryGetPool<T3>(out var pool3) && _componentStorage.TryGetPool<T4>(out var pool4) && _componentStorage.TryGetPool<T5>(out var pool5) && _componentStorage.TryGetPool<T6>(out var pool6)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0, T1, T2, T3, T4, T5, T6>(
+            this,
+            pool0, pool1, pool2, pool3, pool4, pool5, pool6,
+            pool0.Count);
+    }
+
+    public QueryEnumerable<T0, T1, T2, T3, T4, T5, T6> QueryFilter<T0, T1, T2, T3, T4, T5, T6>(ref readonly QueryFilter filter) 
+        where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData where T5 : unmanaged, IComponentData where T6 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1) && _componentStorage.TryGetPool<T2>(out var pool2) && _componentStorage.TryGetPool<T3>(out var pool3) && _componentStorage.TryGetPool<T4>(out var pool4) && _componentStorage.TryGetPool<T5>(out var pool5) && _componentStorage.TryGetPool<T6>(out var pool6)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0, T1, T2, T3, T4, T5, T6>(
+            this,
+            pool0, pool1, pool2, pool3, pool4, pool5, pool6,
+            pool0.Count,
+            in filter);
+    }
+
+    public QueryEnumerable<T0, T1, T2, T3, T4, T5, T6, T7> Query<T0, T1, T2, T3, T4, T5, T6, T7>()
+        where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData where T5 : unmanaged, IComponentData where T6 : unmanaged, IComponentData where T7 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1) && _componentStorage.TryGetPool<T2>(out var pool2) && _componentStorage.TryGetPool<T3>(out var pool3) && _componentStorage.TryGetPool<T4>(out var pool4) && _componentStorage.TryGetPool<T5>(out var pool5) && _componentStorage.TryGetPool<T6>(out var pool6) && _componentStorage.TryGetPool<T7>(out var pool7)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0, T1, T2, T3, T4, T5, T6, T7>(
+            this,
+            pool0, pool1, pool2, pool3, pool4, pool5, pool6, pool7,
+            pool0.Count);
+    }
+
+    public QueryEnumerable<T0, T1, T2, T3, T4, T5, T6, T7> QueryFilter<T0, T1, T2, T3, T4, T5, T6, T7>(ref readonly QueryFilter filter) 
+        where T0 : unmanaged, IComponentData where T1 : unmanaged, IComponentData where T2 : unmanaged, IComponentData where T3 : unmanaged, IComponentData where T4 : unmanaged, IComponentData where T5 : unmanaged, IComponentData where T6 : unmanaged, IComponentData where T7 : unmanaged, IComponentData
+    {
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1) && _componentStorage.TryGetPool<T2>(out var pool2) && _componentStorage.TryGetPool<T3>(out var pool3) && _componentStorage.TryGetPool<T4>(out var pool4) && _componentStorage.TryGetPool<T5>(out var pool5) && _componentStorage.TryGetPool<T6>(out var pool6) && _componentStorage.TryGetPool<T7>(out var pool7)))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<T0, T1, T2, T3, T4, T5, T6, T7>(
+            this,
+            pool0, pool1, pool2, pool3, pool4, pool5, pool6, pool7,
+            pool0.Count,
+            in filter);
+    }
+
+}

Ghost.SparseEntities/Template/World.Query.tt

@@ -0,0 +1,54 @@
+<#@ template language="C#" #>
+<#@ output extension=".cs" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ include file="Helpers.ttinclude" #>
+
+using Ghost.Entities.Components;
+using Ghost.Entities.Query;
+
+namespace Ghost.Entities;
+
+public partial class World
+{
+<# for (var index = 1; index <= Amount; index++) {
+    var generics  = AppendGenerics(index);
+    var restrictions = AppendGenericRestrictions(index, "unmanaged, IComponentData");
+    var tryGetPools = TryGetComponentPools(index);
+    var poolParams = Enumerable.Range(0, index)
+                                      .Select(i => $"pool{i}")
+                                      .Aggregate((a,b)=> a + ", " + b);
+    var countSource = "pool0.Count";
+#>
+    public QueryEnumerable<<#= generics #>> Query<<#= generics #>>()
+        <#= restrictions #>
+    {
+        if (!(<#= tryGetPools #>))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<<#= generics #>>(
+            this,
+            <#= poolParams #>,
+            <#= countSource #>);
+    }
+
+    public QueryEnumerable<<#= generics #>> QueryFilter<<#= generics #>>(ref readonly QueryFilter filter) 
+        <#= restrictions #>
+    {
+        if (!(<#= tryGetPools #>))
+        {
+            return default;
+        }
+
+        return new QueryEnumerable<<#= generics #>>(
+            this,
+            <#= poolParams #>,
+            <#= countSource #>,
+            in filter);
+    }
+
+<# } #>
+}