Changed project name

Ghost.SparseEntities/Query/QueryBuilder.cs

@@ -0,0 +1,42 @@
+using Ghost.Core;
+
+namespace Ghost.SparseEntities.Query;
+
+public struct QueryBuilder
+{
+    private QueryFilter _filter;
+
+    public QueryBuilder()
+    {
+        _filter = new QueryFilter();
+    }
+
+    public QueryBuilder WithAll<T>()
+    {
+        _filter._all.Add(TypeHandle.Get<T>());
+        return this;
+    }
+
+    public QueryBuilder WithAny<T>()
+    {
+        _filter._any.Add(TypeHandle.Get<T>());
+        return this;
+    }
+
+    public QueryBuilder WithAbsent<T>()
+    {
+        _filter._absent.Add(TypeHandle.Get<T>());
+        return this;
+    }
+
+    public QueryBuilder WithDisabled<T>()
+    {
+        _filter._disabled.Add(TypeHandle.Get<T>());
+        return this;
+    }
+
+    public readonly QueryFilter Build()
+    {
+        return _filter;
+    }
+}

Ghost.SparseEntities/Query/QueryFilter.cs

@@ -0,0 +1,97 @@
+using Ghost.Core;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+
+namespace Ghost.SparseEntities.Query;
+
+public struct QueryFilter : IDisposable
+{
+    //private readonly Stack.Scope _scope;
+
+    internal UnsafeList<TypeHandle> _all;
+    internal UnsafeList<TypeHandle> _any;
+    internal UnsafeList<TypeHandle> _absent;
+    internal UnsafeList<TypeHandle> _disabled;
+
+    public QueryFilter()
+    {
+        //_scope = AllocationManager.CreateStackScope();
+
+        _all = new UnsafeList<TypeHandle>(4, Allocator.Stack);
+        _any = new UnsafeList<TypeHandle>(4, Allocator.Stack);
+        _absent = new UnsafeList<TypeHandle>(4, Allocator.Stack);
+        _disabled = new UnsafeList<TypeHandle>(4, Allocator.Stack);
+    }
+
+    public readonly UnsafeBitSet ComputeFilterBitMask(World world, Allocator allocator)
+    {
+        UnsafeBitSet allMask = default;
+        UnsafeBitSet anyMask = default;
+        UnsafeBitSet absentMask = default;
+
+        var result = new UnsafeBitSet(world.EntityManager.EntityCount, allocator);
+        result.ClearAll();
+
+        using (AllocationManager.CreateStackScope())
+        {
+            foreach (var typeHandle in _all)
+            {
+                var mask = world.ComponentStorage.GetOrCreateMask(typeHandle);
+
+                if (!allMask.IsCreated)
+                {
+                    allMask = new UnsafeBitSet(mask.Count, Allocator.Stack, AllocationOption.None);
+                    allMask.SetAll();
+                }
+
+                allMask.And(mask);
+            }
+
+            foreach (var typeHandle in _any)
+            {
+                var mask = world.ComponentStorage.GetOrCreateMask(typeHandle);
+
+                if (!anyMask.IsCreated)
+                {
+                    anyMask = new UnsafeBitSet(mask.Count, Allocator.Stack);
+                }
+
+                anyMask.And(mask);
+            }
+
+            foreach (var typeHandle in _absent)
+            {
+                var mask = world.ComponentStorage.GetOrCreateMask(typeHandle);
+
+                if (!absentMask.IsCreated)
+                {
+                    absentMask = new UnsafeBitSet(mask.Count, Allocator.Stack);
+                }
+
+                absentMask.Or(mask);
+            }
+
+            if (allMask.IsCreated)
+            {
+                result.And(allMask);
+            }
+
+            if (anyMask.IsCreated)
+            {
+                result.And(anyMask);
+            }
+
+            if (absentMask.IsCreated)
+            {
+                result.ANDC(absentMask);
+            }
+        }
+
+        return result;
+    }
+
+    public readonly void Dispose()
+    {
+        //_scope.Dispose();
+    }
+}

Ghost.SparseEntities/Query/QueryTypeParameter.cs

@@ -0,0 +1,73 @@
+using Ghost.SparseEntities.Components;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.SparseEntities.Query;
+
+public interface IQueryTypeParameter<T>
+    where T : IComponentData
+{
+}
+
+public ref struct CompRef<T> : IQueryTypeParameter<T>
+    where T : IComponentData
+{
+    internal ref T _value;
+
+    public ref T ValueRW
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => ref _value;
+    }
+
+    public readonly ref T ValueRO
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => ref _value;
+    }
+
+    public readonly bool IsValid
+    {
+        get;
+        init;
+    }
+
+    public CompRef(ref T value, bool isValid)
+    {
+        _value = ref value;
+        IsValid = isValid;
+    }
+
+    public CompRef(ref T value)
+        : this(ref value, true)
+    {
+    }
+}
+
+public readonly ref struct CompRO<T> : IQueryTypeParameter<T>
+    where T : IComponentData
+{
+    internal readonly ref T _value;
+
+    public readonly ref T ValueRO
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => ref _value;
+    }
+
+    public readonly bool IsValid
+    {
+        get;
+        init;
+    }
+
+    public CompRO(ref T value, bool isValid)
+    {
+        _value = ref value;
+        IsValid = isValid;
+    }
+
+    public CompRO(ref T value)
+        : this(ref value, true)
+    {
+    }
+}