Refactor entity-component system and related classes

Changed the `Component` class to an interface `IComponentData` to support a data-oriented design.
Changed the `Transform` class from a class to a struct, implementing `IComponentData` and updating properties.
Changed the `GameObject` class to use a dictionary for components and added properties for state management.
Changed the `PlayerLoopService` class to `GameLoopService` and updated methods to integrate with the new `SceneManager`.
Changed the `World` class to manage multiple worlds and enhance entity management with new querying methods.

Added the `Scene` class to manage root game objects and their lifecycle.
Added new utility classes like `ComponentMask`, `Box<T>`, and `TypeHandle<T>` for better component management.
Added the `ScriptComponent` class to allow for modular scriptable components attached to entities.
Added the `QueryEnumerable` class to facilitate flexible querying of entities with specific components.

Updated the `Test` class in `Program.cs` to demonstrate the new entity and component management system.
Updated project files to include new references and settings supporting the changes made in the codebase.

Ghost.Entities/Template/Helpers.ttinclude

@@ -2,8 +2,8 @@
 <#@ import namespace="System.Collections.Generic" #>
 <#+
 
-    public int Amount = 25;
-
+    public int Amount = 8;
+    public int ExtensionAmount = 3;
 
     public string Indent(StringBuilder sb, int spaces)
     {
@@ -11,17 +11,22 @@
         return sb.ToString().Replace("\n", "\n" + indent);
     }
 
-    string AppendGenerics(int amount)
+    string AppendGenerics(int amount, string template)
     {
         var sb = new StringBuilder();
         for (var i = 0; i < amount; i++)
         {
             if (i > 0) sb.Append(", ");
-            sb.Append($"T{i}");
+            sb.Append($"{template}{i}");
         }
         return sb.ToString();
     }
 
+    string AppendGenerics(int amount)
+    {
+        return AppendGenerics(amount, "T");
+    }
+
     public StringBuilder AppendGenericRefParameters(int amount)
     {
         var sb = new StringBuilder();
@@ -46,12 +51,12 @@
         return sb;
     }
 
-    public StringBuilder AppendGenericRestrictions(int amount, string template)
+    public StringBuilder AppendGenericRestrictions(int amount, string Ttemplate, string template)
     {
         var sb = new StringBuilder();
         for (var localIndex = 0; localIndex < amount; localIndex++)
         {
-            sb.Append($"where T{localIndex} : {template}");
+            sb.Append($"where {Ttemplate}{localIndex} : {template}");
             if (localIndex < amount - 1)
             {
                 sb.Append(' ');
@@ -60,12 +65,17 @@
         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($"TryGetPool<T{localIndex}>(out var pool{localIndex})");
+            sb.Append($"_componentStorage.TryGetPool<T{localIndex}>(out var pool{localIndex})");
             if (localIndex < amount - 1)
             {
                 sb.Append(" && ");

Ghost.Entities/Template/QueryEnumerable.tt

@@ -0,0 +1,147 @@
+<#@ template language="C#" #>
+<#@ output extension=".cs" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Linq" #>
+<#@ include file="Helpers.ttinclude" #>
+
+using Ghost.Entities.Query;
+using Ghost.Entities.Utilities;
+using Misaki.HighPerformance.Unsafe.Collections;
+
+namespace Ghost.Entities;
+
+<# for (int arity = 1; arity <= Amount; arity++) {
+var generics = AppendGenerics(arity);
+var restrictions = AppendGenericRestrictions(arity, "struct, 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 struct QueryEnumerable<<#= generics #>>
+    <#= restrictions #>
+{
+    private readonly World _world;
+
+<# for (int i = 0; i < arity; i++){ #>
+    private readonly ComponentPool<T<#= i #>> _pool<#= i #>;
+<# } #>
+    private readonly int _count;
+
+    private QueryFilter _filters;
+    internal readonly QueryFilter Filters => _filters;
+
+    internal QueryEnumerable(World world, <#= poolParams #>, int count)
+    {
+        _world = world;
+
+<# for (int i = 0; i < arity; i++) { #>
+        _pool<#= i #> = pool<#= i #>;
+<# } #>
+
+        _count = count;
+        
+        _filters = new();
+<# for (int i = 0; i < arity; i++) {#>
+        _filters._all.Add(TypeHandle<T<#= i #>>.Value);
+<# } #>
+    }
+
+    public Enumerator GetEnumerator() => new Enumerator(_world, <#= constructorParams #>, _count, _filters);
+
+    public ref struct Enumerator
+    {
+        private readonly World _world;
+        private readonly ReadOnlySpan<Entity> _entities;
+
+<# for (int i = 0; i < arity; i++){ #>
+        private readonly ComponentPool<T<#= i #>> _pool<#= i #>;
+<# } #>
+
+        private int _index;
+        private readonly int _count;
+
+        private BitSet _filterMask;
+        
+        public QueryItem<<#= generics #>> Current
+        {
+            get;
+            private set;
+        }
+
+        internal Enumerator(World world, <#= poolParams #>, int count, QueryFilter filters)
+        {
+            _world = world;
+            _entities = _world.EntityManager.Entities;
+
+<# for (int i = 0; i < arity; i++){ #>
+            _pool<#= i #> = pool<#= i #>;
+<# } #>
+
+            _count = count;
+            _index = -1;
+            filters.ComputeFilterBitMask(_world, ref _filterMask);
+
+            Current = default;
+        }
+
+        public bool MoveNext()
+        {
+            _index = _filterMask.NextSetBit(_index + 1);
+            if (_index < 0 || _index >= _world.EntityManager.EntityCount)
+            {
+                return false;
+            }
+
+            Current = new QueryItem<<#= generics #>>(_entities[_index], <#= constructorParams #>);
+            return true;
+        }
+    }
+<# for (int i = 1; i <= ExtensionAmount; i++) {
+var compGenerics = AppendGenerics(i, "TComponent");
+var compRestrictions = AppendGenericRestrictions(i, "TComponent", "struct, IComponentData");
+#>
+
+	public readonly QueryEnumerable<<#= generics #>> WithAll<<#= compGenerics #>>()
+		<#= compRestrictions #>
+	{
+<# for (int j = 0; j < i; j++) {#>
+        _filters._all.Add(TypeHandle<TComponent<#= j #>>.Value);
+<# } #>
+        return this;
+	}
+
+    public readonly QueryEnumerable<<#= generics #>> WithAny<<#= compGenerics #>>()
+		<#= compRestrictions #>
+	{
+<# for (int j = 0; j < i; j++) {#>
+        _filters._any.Add(TypeHandle<TComponent<#= j #>>.Value);
+<# } #>
+        return this;
+	}
+
+    public readonly QueryEnumerable<<#= generics #>> WithAbsent<<#= compGenerics #>>()
+		<#= compRestrictions #>
+	{
+<# for (int j = 0; j < i; j++) {#>
+        _filters._absent.Add(TypeHandle<TComponent<#= j #>>.Value);
+<# } #>
+        return this;
+	}
+
+    public readonly QueryEnumerable<<#= generics #>> WithDisabled<<#= compGenerics #>>()
+		<#= compRestrictions #>
+	{
+<# for (int j = 0; j < i; j++) {#>
+        _filters._disabled.Add(TypeHandle<TComponent<#= j #>>.Value);
+<# } #>
+        return this;
+	}
+<# } #>
+}
+
+<# } #>

Ghost.Entities/Template/QueryItem.cs

@@ -0,0 +1,282 @@
+
+
+using Ghost.Entities.Query;
+
+namespace Ghost.Entities;
+
+public readonly struct QueryItem<T0>
+    where T0 : struct, 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 Ref<T0> c0)
+    {
+        entity = _entity;
+        c0 = new (ref _pool0.GetRef(_entity));
+    }
+}
+
+public readonly struct QueryItem<T0, T1>
+    where T0 : struct, IComponentData where T1 : struct, 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 Ref<T0> c0, out Ref<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 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, 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 Ref<T0> c0, out Ref<T1> c1, out Ref<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 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, 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 Ref<T0> c0, out Ref<T1> c1, out Ref<T2> c2, out Ref<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 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, IComponentData where T4 : struct, 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 Ref<T0> c0, out Ref<T1> c1, out Ref<T2> c2, out Ref<T3> c3, out Ref<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 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, IComponentData where T4 : struct, IComponentData where T5 : struct, 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 Ref<T0> c0, out Ref<T1> c1, out Ref<T2> c2, out Ref<T3> c3, out Ref<T4> c4, out Ref<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 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, IComponentData where T4 : struct, IComponentData where T5 : struct, IComponentData where T6 : struct, 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 Ref<T0> c0, out Ref<T1> c1, out Ref<T2> c2, out Ref<T3> c3, out Ref<T4> c4, out Ref<T5> c5, out Ref<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 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, IComponentData where T4 : struct, IComponentData where T5 : struct, IComponentData where T6 : struct, IComponentData where T7 : struct, 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 Ref<T0> c0, out Ref<T1> c1, out Ref<T2> c2, out Ref<T3> c3, out Ref<T4> c4, out Ref<T5> c5, out Ref<T6> c6, out Ref<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.Entities/Template/QueryItem.tt

@@ -0,0 +1,63 @@
+<#@ 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.Query;
+
+namespace Ghost.Entities;
+
+<# for (int arity = 1; arity <= Amount; arity++)
+{
+var generics = AppendGenerics(arity);
+var restrictions = AppendGenericRestrictions(arity, "struct, 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 Ref<T0> {name}"
+                                            : $"out Ref<T{i}> {name}";
+                                    })
+                                    .Aggregate((a, b) => a + ", " + b);
+var deconstructAssigns = Enumerable.Range(0, arity)
+                                    .Select(i => {
+                                        var name = $"c{i}";
+                                        return $"{name} = new (ref _pool{i}.GetRef(_entity));";
+                                    })
+                                    .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;
+        <#= deconstructAssigns #>
+    }
+}
+
+<# } #>

Ghost.Entities/Template/QueryRefComponent.cs

@@ -3,52 +3,18 @@
 namespace Ghost.Entities;
 
 public delegate void QueryRefComponent<T0>(Entity entity, ref T0 t0Component)
-    where T0 : struct, IComponent;
+    where T0 : struct, IComponentData;
 public delegate void QueryRefComponent<T0, T1>(Entity entity, ref T0 t0Component,ref T1 t1Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent;
+    where T0 : struct, IComponentData where T1 : struct, IComponentData;
 public delegate void QueryRefComponent<T0, T1, T2>(Entity entity, ref T0 t0Component,ref T1 t1Component,ref T2 t2Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent;
+    where T0 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, 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 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent;
+    where T0 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, 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 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent;
+    where T0 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, IComponentData where T4 : struct, 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 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent;
+    where T0 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, IComponentData where T4 : struct, IComponentData where T5 : struct, 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 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent;
+    where T0 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, IComponentData where T4 : struct, IComponentData where T5 : struct, IComponentData where T6 : struct, 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 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8>(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,ref T8 t8Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(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,ref T8 t8Component,ref T9 t9Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component,ref T11 t11Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component,ref T11 t11Component,ref T12 t12Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component,ref T11 t11Component,ref T12 t12Component,ref T13 t13Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component,ref T11 t11Component,ref T12 t12Component,ref T13 t13Component,ref T14 t14Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component,ref T11 t11Component,ref T12 t12Component,ref T13 t13Component,ref T14 t14Component,ref T15 t15Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component,ref T11 t11Component,ref T12 t12Component,ref T13 t13Component,ref T14 t14Component,ref T15 t15Component,ref T16 t16Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component,ref T11 t11Component,ref T12 t12Component,ref T13 t13Component,ref T14 t14Component,ref T15 t15Component,ref T16 t16Component,ref T17 t17Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component,ref T11 t11Component,ref T12 t12Component,ref T13 t13Component,ref T14 t14Component,ref T15 t15Component,ref T16 t16Component,ref T17 t17Component,ref T18 t18Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent where T18 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component,ref T11 t11Component,ref T12 t12Component,ref T13 t13Component,ref T14 t14Component,ref T15 t15Component,ref T16 t16Component,ref T17 t17Component,ref T18 t18Component,ref T19 t19Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent where T18 : struct, IComponent where T19 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component,ref T11 t11Component,ref T12 t12Component,ref T13 t13Component,ref T14 t14Component,ref T15 t15Component,ref T16 t16Component,ref T17 t17Component,ref T18 t18Component,ref T19 t19Component,ref T20 t20Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent where T18 : struct, IComponent where T19 : struct, IComponent where T20 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component,ref T11 t11Component,ref T12 t12Component,ref T13 t13Component,ref T14 t14Component,ref T15 t15Component,ref T16 t16Component,ref T17 t17Component,ref T18 t18Component,ref T19 t19Component,ref T20 t20Component,ref T21 t21Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent where T18 : struct, IComponent where T19 : struct, IComponent where T20 : struct, IComponent where T21 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component,ref T11 t11Component,ref T12 t12Component,ref T13 t13Component,ref T14 t14Component,ref T15 t15Component,ref T16 t16Component,ref T17 t17Component,ref T18 t18Component,ref T19 t19Component,ref T20 t20Component,ref T21 t21Component,ref T22 t22Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent where T18 : struct, IComponent where T19 : struct, IComponent where T20 : struct, IComponent where T21 : struct, IComponent where T22 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component,ref T11 t11Component,ref T12 t12Component,ref T13 t13Component,ref T14 t14Component,ref T15 t15Component,ref T16 t16Component,ref T17 t17Component,ref T18 t18Component,ref T19 t19Component,ref T20 t20Component,ref T21 t21Component,ref T22 t22Component,ref T23 t23Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent where T18 : struct, IComponent where T19 : struct, IComponent where T20 : struct, IComponent where T21 : struct, IComponent where T22 : struct, IComponent where T23 : struct, IComponent;
-public delegate void QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>(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,ref T8 t8Component,ref T9 t9Component,ref T10 t10Component,ref T11 t11Component,ref T12 t12Component,ref T13 t13Component,ref T14 t14Component,ref T15 t15Component,ref T16 t16Component,ref T17 t17Component,ref T18 t18Component,ref T19 t19Component,ref T20 t20Component,ref T21 t21Component,ref T22 t22Component,ref T23 t23Component,ref T24 t24Component)
-    where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent where T18 : struct, IComponent where T19 : struct, IComponent where T20 : struct, IComponent where T21 : struct, IComponent where T22 : struct, IComponent where T23 : struct, IComponent where T24 : struct, IComponent;
+    where T0 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, IComponentData where T4 : struct, IComponentData where T5 : struct, IComponentData where T6 : struct, IComponentData where T7 : struct, IComponentData;

Ghost.Entities/Template/QueryRefComponent.tt

@@ -10,7 +10,7 @@ for (var index = 1; index <= Amount; index++)
 {
     var generics = AppendGenerics(index);
     var parameters = AppendGenericRefParameters(index);
-    var restrictions = AppendGenericRestrictions(index, "struct, IComponent");
+    var restrictions = AppendGenericRestrictions(index, "struct, IComponentData");
 #>
 public delegate void QueryRefComponent<<#= generics #>>(Entity entity, <#= parameters.ToString() #>)
     <#= restrictions.ToString() #>;

Ghost.Entities/Template/World.Query.cs

@@ -2,501 +2,102 @@
 
 namespace Ghost.Entities;
 
-public partial struct World
+public partial class World
 {
-    public readonly void Query<T0>(QueryRefComponent<T0> callback)
-        where T0 : struct, IComponent
+    public QueryEnumerable<T0> Query<T0>()
+        where T0 : struct, IComponentData
     {
-        if (!(TryGetPool<T0>(out var pool0)))
-        {
-            return;
-        }
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0)))
+            return default;
 
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            callback(entity, ref pool0.GetRef(entity));
-        }
+        return new QueryEnumerable<T0>(
+            this,
+            pool0,
+            pool0.Count);
     }
 
-    public readonly void Query<T0, T1>(QueryRefComponent<T0, T1> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent
+    public QueryEnumerable<T0, T1> Query<T0, T1>()
+        where T0 : struct, IComponentData where T1 : struct, IComponentData
     {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1)))
-        {
-            return;
-        }
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1)))
+            return default;
 
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity));
-        }
+        return new QueryEnumerable<T0, T1>(
+            this,
+            pool0, pool1,
+            pool0.Count);
     }
 
-    public readonly void Query<T0, T1, T2>(QueryRefComponent<T0, T1, T2> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent
+    public QueryEnumerable<T0, T1, T2> Query<T0, T1, T2>()
+        where T0 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData
     {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2)))
-        {
-            return;
-        }
+        if (!(_componentStorage.TryGetPool<T0>(out var pool0) && _componentStorage.TryGetPool<T1>(out var pool1) && _componentStorage.TryGetPool<T2>(out var pool2)))
+            return default;
 
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity));
-        }
+        return new QueryEnumerable<T0, T1, T2>(
+            this,
+            pool0, pool1, pool2,
+            pool0.Count);
     }
 
-    public readonly void Query<T0, T1, T2, T3>(QueryRefComponent<T0, T1, T2, T3> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent
+    public QueryEnumerable<T0, T1, T2, T3> Query<T0, T1, T2, T3>()
+        where T0 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, IComponentData
     {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3)))
-        {
-            return;
-        }
+        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;
 
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity));
-        }
+        return new QueryEnumerable<T0, T1, T2, T3>(
+            this,
+            pool0, pool1, pool2, pool3,
+            pool0.Count);
     }
 
-    public readonly void Query<T0, T1, T2, T3, T4>(QueryRefComponent<T0, T1, T2, T3, T4> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent
+    public QueryEnumerable<T0, T1, T2, T3, T4> Query<T0, T1, T2, T3, T4>()
+        where T0 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, IComponentData where T4 : struct, IComponentData
     {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4)))
-        {
-            return;
-        }
+        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;
 
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity));
-        }
+        return new QueryEnumerable<T0, T1, T2, T3, T4>(
+            this,
+            pool0, pool1, pool2, pool3, pool4,
+            pool0.Count);
     }
 
-    public readonly void Query<T0, T1, T2, T3, T4, T5>(QueryRefComponent<T0, T1, T2, T3, T4, T5> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent
+    public QueryEnumerable<T0, T1, T2, T3, T4, T5> Query<T0, T1, T2, T3, T4, T5>()
+        where T0 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, IComponentData where T4 : struct, IComponentData where T5 : struct, IComponentData
     {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5)))
-        {
-            return;
-        }
+        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;
 
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity));
-        }
+        return new QueryEnumerable<T0, T1, T2, T3, T4, T5>(
+            this,
+            pool0, pool1, pool2, pool3, pool4, pool5,
+            pool0.Count);
     }
 
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent
+    public QueryEnumerable<T0, T1, T2, T3, T4, T5, T6> Query<T0, T1, T2, T3, T4, T5, T6>()
+        where T0 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, IComponentData where T4 : struct, IComponentData where T5 : struct, IComponentData where T6 : struct, IComponentData
     {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6)))
-        {
-            return;
-        }
+        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;
 
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity));
-        }
+        return new QueryEnumerable<T0, T1, T2, T3, T4, T5, T6>(
+            this,
+            pool0, pool1, pool2, pool3, pool4, pool5, pool6,
+            pool0.Count);
     }
 
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent
+    public QueryEnumerable<T0, T1, T2, T3, T4, T5, T6, T7> Query<T0, T1, T2, T3, T4, T5, T6, T7>()
+        where T0 : struct, IComponentData where T1 : struct, IComponentData where T2 : struct, IComponentData where T3 : struct, IComponentData where T4 : struct, IComponentData where T5 : struct, IComponentData where T6 : struct, IComponentData where T7 : struct, IComponentData
     {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7)))
-        {
-            return;
-        }
+        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;
 
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10) && TryGetPool<T11>(out var pool11)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity) && pool11.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity), ref pool11.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10) && TryGetPool<T11>(out var pool11) && TryGetPool<T12>(out var pool12)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity) && pool11.Has(entity) && pool12.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity), ref pool11.GetRef(entity), ref pool12.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10) && TryGetPool<T11>(out var pool11) && TryGetPool<T12>(out var pool12) && TryGetPool<T13>(out var pool13)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity) && pool11.Has(entity) && pool12.Has(entity) && pool13.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity), ref pool11.GetRef(entity), ref pool12.GetRef(entity), ref pool13.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10) && TryGetPool<T11>(out var pool11) && TryGetPool<T12>(out var pool12) && TryGetPool<T13>(out var pool13) && TryGetPool<T14>(out var pool14)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity) && pool11.Has(entity) && pool12.Has(entity) && pool13.Has(entity) && pool14.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity), ref pool11.GetRef(entity), ref pool12.GetRef(entity), ref pool13.GetRef(entity), ref pool14.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10) && TryGetPool<T11>(out var pool11) && TryGetPool<T12>(out var pool12) && TryGetPool<T13>(out var pool13) && TryGetPool<T14>(out var pool14) && TryGetPool<T15>(out var pool15)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity) && pool11.Has(entity) && pool12.Has(entity) && pool13.Has(entity) && pool14.Has(entity) && pool15.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity), ref pool11.GetRef(entity), ref pool12.GetRef(entity), ref pool13.GetRef(entity), ref pool14.GetRef(entity), ref pool15.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10) && TryGetPool<T11>(out var pool11) && TryGetPool<T12>(out var pool12) && TryGetPool<T13>(out var pool13) && TryGetPool<T14>(out var pool14) && TryGetPool<T15>(out var pool15) && TryGetPool<T16>(out var pool16)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity) && pool11.Has(entity) && pool12.Has(entity) && pool13.Has(entity) && pool14.Has(entity) && pool15.Has(entity) && pool16.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity), ref pool11.GetRef(entity), ref pool12.GetRef(entity), ref pool13.GetRef(entity), ref pool14.GetRef(entity), ref pool15.GetRef(entity), ref pool16.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10) && TryGetPool<T11>(out var pool11) && TryGetPool<T12>(out var pool12) && TryGetPool<T13>(out var pool13) && TryGetPool<T14>(out var pool14) && TryGetPool<T15>(out var pool15) && TryGetPool<T16>(out var pool16) && TryGetPool<T17>(out var pool17)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity) && pool11.Has(entity) && pool12.Has(entity) && pool13.Has(entity) && pool14.Has(entity) && pool15.Has(entity) && pool16.Has(entity) && pool17.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity), ref pool11.GetRef(entity), ref pool12.GetRef(entity), ref pool13.GetRef(entity), ref pool14.GetRef(entity), ref pool15.GetRef(entity), ref pool16.GetRef(entity), ref pool17.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent where T18 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10) && TryGetPool<T11>(out var pool11) && TryGetPool<T12>(out var pool12) && TryGetPool<T13>(out var pool13) && TryGetPool<T14>(out var pool14) && TryGetPool<T15>(out var pool15) && TryGetPool<T16>(out var pool16) && TryGetPool<T17>(out var pool17) && TryGetPool<T18>(out var pool18)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity) && pool11.Has(entity) && pool12.Has(entity) && pool13.Has(entity) && pool14.Has(entity) && pool15.Has(entity) && pool16.Has(entity) && pool17.Has(entity) && pool18.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity), ref pool11.GetRef(entity), ref pool12.GetRef(entity), ref pool13.GetRef(entity), ref pool14.GetRef(entity), ref pool15.GetRef(entity), ref pool16.GetRef(entity), ref pool17.GetRef(entity), ref pool18.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent where T18 : struct, IComponent where T19 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10) && TryGetPool<T11>(out var pool11) && TryGetPool<T12>(out var pool12) && TryGetPool<T13>(out var pool13) && TryGetPool<T14>(out var pool14) && TryGetPool<T15>(out var pool15) && TryGetPool<T16>(out var pool16) && TryGetPool<T17>(out var pool17) && TryGetPool<T18>(out var pool18) && TryGetPool<T19>(out var pool19)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity) && pool11.Has(entity) && pool12.Has(entity) && pool13.Has(entity) && pool14.Has(entity) && pool15.Has(entity) && pool16.Has(entity) && pool17.Has(entity) && pool18.Has(entity) && pool19.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity), ref pool11.GetRef(entity), ref pool12.GetRef(entity), ref pool13.GetRef(entity), ref pool14.GetRef(entity), ref pool15.GetRef(entity), ref pool16.GetRef(entity), ref pool17.GetRef(entity), ref pool18.GetRef(entity), ref pool19.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent where T18 : struct, IComponent where T19 : struct, IComponent where T20 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10) && TryGetPool<T11>(out var pool11) && TryGetPool<T12>(out var pool12) && TryGetPool<T13>(out var pool13) && TryGetPool<T14>(out var pool14) && TryGetPool<T15>(out var pool15) && TryGetPool<T16>(out var pool16) && TryGetPool<T17>(out var pool17) && TryGetPool<T18>(out var pool18) && TryGetPool<T19>(out var pool19) && TryGetPool<T20>(out var pool20)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity) && pool11.Has(entity) && pool12.Has(entity) && pool13.Has(entity) && pool14.Has(entity) && pool15.Has(entity) && pool16.Has(entity) && pool17.Has(entity) && pool18.Has(entity) && pool19.Has(entity) && pool20.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity), ref pool11.GetRef(entity), ref pool12.GetRef(entity), ref pool13.GetRef(entity), ref pool14.GetRef(entity), ref pool15.GetRef(entity), ref pool16.GetRef(entity), ref pool17.GetRef(entity), ref pool18.GetRef(entity), ref pool19.GetRef(entity), ref pool20.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent where T18 : struct, IComponent where T19 : struct, IComponent where T20 : struct, IComponent where T21 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10) && TryGetPool<T11>(out var pool11) && TryGetPool<T12>(out var pool12) && TryGetPool<T13>(out var pool13) && TryGetPool<T14>(out var pool14) && TryGetPool<T15>(out var pool15) && TryGetPool<T16>(out var pool16) && TryGetPool<T17>(out var pool17) && TryGetPool<T18>(out var pool18) && TryGetPool<T19>(out var pool19) && TryGetPool<T20>(out var pool20) && TryGetPool<T21>(out var pool21)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity) && pool11.Has(entity) && pool12.Has(entity) && pool13.Has(entity) && pool14.Has(entity) && pool15.Has(entity) && pool16.Has(entity) && pool17.Has(entity) && pool18.Has(entity) && pool19.Has(entity) && pool20.Has(entity) && pool21.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity), ref pool11.GetRef(entity), ref pool12.GetRef(entity), ref pool13.GetRef(entity), ref pool14.GetRef(entity), ref pool15.GetRef(entity), ref pool16.GetRef(entity), ref pool17.GetRef(entity), ref pool18.GetRef(entity), ref pool19.GetRef(entity), ref pool20.GetRef(entity), ref pool21.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent where T18 : struct, IComponent where T19 : struct, IComponent where T20 : struct, IComponent where T21 : struct, IComponent where T22 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10) && TryGetPool<T11>(out var pool11) && TryGetPool<T12>(out var pool12) && TryGetPool<T13>(out var pool13) && TryGetPool<T14>(out var pool14) && TryGetPool<T15>(out var pool15) && TryGetPool<T16>(out var pool16) && TryGetPool<T17>(out var pool17) && TryGetPool<T18>(out var pool18) && TryGetPool<T19>(out var pool19) && TryGetPool<T20>(out var pool20) && TryGetPool<T21>(out var pool21) && TryGetPool<T22>(out var pool22)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity) && pool11.Has(entity) && pool12.Has(entity) && pool13.Has(entity) && pool14.Has(entity) && pool15.Has(entity) && pool16.Has(entity) && pool17.Has(entity) && pool18.Has(entity) && pool19.Has(entity) && pool20.Has(entity) && pool21.Has(entity) && pool22.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity), ref pool11.GetRef(entity), ref pool12.GetRef(entity), ref pool13.GetRef(entity), ref pool14.GetRef(entity), ref pool15.GetRef(entity), ref pool16.GetRef(entity), ref pool17.GetRef(entity), ref pool18.GetRef(entity), ref pool19.GetRef(entity), ref pool20.GetRef(entity), ref pool21.GetRef(entity), ref pool22.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent where T18 : struct, IComponent where T19 : struct, IComponent where T20 : struct, IComponent where T21 : struct, IComponent where T22 : struct, IComponent where T23 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10) && TryGetPool<T11>(out var pool11) && TryGetPool<T12>(out var pool12) && TryGetPool<T13>(out var pool13) && TryGetPool<T14>(out var pool14) && TryGetPool<T15>(out var pool15) && TryGetPool<T16>(out var pool16) && TryGetPool<T17>(out var pool17) && TryGetPool<T18>(out var pool18) && TryGetPool<T19>(out var pool19) && TryGetPool<T20>(out var pool20) && TryGetPool<T21>(out var pool21) && TryGetPool<T22>(out var pool22) && TryGetPool<T23>(out var pool23)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity) && pool11.Has(entity) && pool12.Has(entity) && pool13.Has(entity) && pool14.Has(entity) && pool15.Has(entity) && pool16.Has(entity) && pool17.Has(entity) && pool18.Has(entity) && pool19.Has(entity) && pool20.Has(entity) && pool21.Has(entity) && pool22.Has(entity) && pool23.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity), ref pool11.GetRef(entity), ref pool12.GetRef(entity), ref pool13.GetRef(entity), ref pool14.GetRef(entity), ref pool15.GetRef(entity), ref pool16.GetRef(entity), ref pool17.GetRef(entity), ref pool18.GetRef(entity), ref pool19.GetRef(entity), ref pool20.GetRef(entity), ref pool21.GetRef(entity), ref pool22.GetRef(entity), ref pool23.GetRef(entity));
-        }
-    }
-
-    public readonly void Query<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>(QueryRefComponent<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> callback)
-        where T0 : struct, IComponent where T1 : struct, IComponent where T2 : struct, IComponent where T3 : struct, IComponent where T4 : struct, IComponent where T5 : struct, IComponent where T6 : struct, IComponent where T7 : struct, IComponent where T8 : struct, IComponent where T9 : struct, IComponent where T10 : struct, IComponent where T11 : struct, IComponent where T12 : struct, IComponent where T13 : struct, IComponent where T14 : struct, IComponent where T15 : struct, IComponent where T16 : struct, IComponent where T17 : struct, IComponent where T18 : struct, IComponent where T19 : struct, IComponent where T20 : struct, IComponent where T21 : struct, IComponent where T22 : struct, IComponent where T23 : struct, IComponent where T24 : struct, IComponent
-    {
-        if (!(TryGetPool<T0>(out var pool0) && TryGetPool<T1>(out var pool1) && TryGetPool<T2>(out var pool2) && TryGetPool<T3>(out var pool3) && TryGetPool<T4>(out var pool4) && TryGetPool<T5>(out var pool5) && TryGetPool<T6>(out var pool6) && TryGetPool<T7>(out var pool7) && TryGetPool<T8>(out var pool8) && TryGetPool<T9>(out var pool9) && TryGetPool<T10>(out var pool10) && TryGetPool<T11>(out var pool11) && TryGetPool<T12>(out var pool12) && TryGetPool<T13>(out var pool13) && TryGetPool<T14>(out var pool14) && TryGetPool<T15>(out var pool15) && TryGetPool<T16>(out var pool16) && TryGetPool<T17>(out var pool17) && TryGetPool<T18>(out var pool18) && TryGetPool<T19>(out var pool19) && TryGetPool<T20>(out var pool20) && TryGetPool<T21>(out var pool21) && TryGetPool<T22>(out var pool22) && TryGetPool<T23>(out var pool23) && TryGetPool<T24>(out var pool24)))
-        {
-            return;
-        }
-
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-            if (!(pool1.Has(entity) && pool2.Has(entity) && pool3.Has(entity) && pool4.Has(entity) && pool5.Has(entity) && pool6.Has(entity) && pool7.Has(entity) && pool8.Has(entity) && pool9.Has(entity) && pool10.Has(entity) && pool11.Has(entity) && pool12.Has(entity) && pool13.Has(entity) && pool14.Has(entity) && pool15.Has(entity) && pool16.Has(entity) && pool17.Has(entity) && pool18.Has(entity) && pool19.Has(entity) && pool20.Has(entity) && pool21.Has(entity) && pool22.Has(entity) && pool23.Has(entity) && pool24.Has(entity)))
-            {
-                continue;
-            }
-
-            callback(entity, ref pool0.GetRef(entity), ref pool1.GetRef(entity), ref pool2.GetRef(entity), ref pool3.GetRef(entity), ref pool4.GetRef(entity), ref pool5.GetRef(entity), ref pool6.GetRef(entity), ref pool7.GetRef(entity), ref pool8.GetRef(entity), ref pool9.GetRef(entity), ref pool10.GetRef(entity), ref pool11.GetRef(entity), ref pool12.GetRef(entity), ref pool13.GetRef(entity), ref pool14.GetRef(entity), ref pool15.GetRef(entity), ref pool16.GetRef(entity), ref pool17.GetRef(entity), ref pool18.GetRef(entity), ref pool19.GetRef(entity), ref pool20.GetRef(entity), ref pool21.GetRef(entity), ref pool22.GetRef(entity), ref pool23.GetRef(entity), ref pool24.GetRef(entity));
-        }
+        return new QueryEnumerable<T0, T1, T2, T3, T4, T5, T6, T7>(
+            this,
+            pool0, pool1, pool2, pool3, pool4, pool5, pool6, pool7,
+            pool0.Count);
     }
 
 }

Ghost.Entities/Template/World.Query.tt

@@ -1,48 +1,34 @@
 <#@ 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;
 
-public partial struct World
+public partial class World
 {
-<#
-    for (var index = 1; index <= Amount; index++)
+<# for (var index = 1; index <= Amount; index++) {
+    var generics  = AppendGenerics(index);
+    var restrictions = AppendGenericRestrictions(index, "struct, 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 #>
     {
-        var generics = AppendGenerics(index);
-        var restrictions = AppendGenericRestrictions(index, "struct, IComponent");
-        var getPools = TryGetComponentPools(index);
-        var hasEntity = HasEntity(index);
-#>
-    public readonly void Query<<#= generics #>>(QueryRefComponent<<#= generics #>> callback)
-        <#= restrictions.ToString() #>
-    {
-        if (!(<#=getPools.ToString()#>))
-        {
-            return;
-        }
+        if (!(<#= tryGetPools #>))
+            return default;
 
-        for (var i = 0; i < pool0.Count; i++)
-        {
-			var entity = _entities[i];
-<#
-        if (index > 1)
-        {
-#>
-            if (!(<#=hasEntity.ToString()#>))
-            {
-                continue;
-            }
-
-<#
-        }
-#>
-            callback(entity, <#= GetComponentRef(index).ToString() #>);
-        }
+        return new QueryEnumerable<<#= generics #>>(
+            this,
+            <#= poolParams #>,
+            <#= countSource #>);
     }
 
-<#
-    }
-#>
+<# } #>
 }