src/gaemstone.ECS/Component.cs

@@ -1,18 +1,17 @@
 using System;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using static flecs_hub.flecs;
 
 namespace gaemstone.ECS;
 
-public static unsafe class ComponentExtensions
+public static class ComponentExtensions
 {
-	public static EntityRef InitComponent(this EntityRef entity, Type type)
+	public unsafe static EntityRef InitComponent(this EntityRef entity, Type type)
 		=> (EntityRef)typeof(ComponentExtensions)
 			.GetMethod(nameof(InitComponent), new[] { typeof(EntityRef) })!
 			.MakeGenericMethod(type).Invoke(null, new[]{ entity })!;
 
-	public static EntityRef InitComponent<T>(this EntityRef entity)
+	public unsafe static EntityRef InitComponent<T>(this EntityRef entity)
 	{
 		if (typeof(T).IsPrimitive) throw new ArgumentException(
 			"Must not be primitive");
@@ -20,91 +19,12 @@ public static unsafe class ComponentExtensions
 			"Struct component must satisfy the unmanaged constraint. " +
 			"Consider making it a class if you need to store references.");
 
-		var size = typeof(T).IsValueType ? Unsafe.SizeOf<T>() : sizeof(ReferenceHandle);
+		var size = Unsafe.SizeOf<T>();
-		var typeInfo = new ecs_type_info_t { size = size, alignment = size };
+		var typeInfo = new ecs_type_info_t
-		var componentDesc = new ecs_component_desc_t { entity = entity, type = typeInfo };
+			{ size = size, alignment = size };
+		var componentDesc = new ecs_component_desc_t
+			{ entity = entity, type = typeInfo };
 		ecs_component_init(entity.World, &componentDesc);
-
-		if (!typeof(T).IsValueType) {
-			// Set up component hooks for proper freeing of GCHandles.
-			// Without them, managed classes would never be garbage collected.
-			var typeHooks = new ecs_type_hooks_t {
-				ctor = new() { Data = new() { Pointer = &ReferenceHandle.Construct } },
-				dtor = new() { Data = new() { Pointer = &ReferenceHandle.Destruct } },
-				move = new() { Data = new() { Pointer = &ReferenceHandle.Move } },
-				copy = new() { Data = new() { Pointer = &ReferenceHandle.Copy } },
-			};
-			ecs_set_hooks_id(entity.World, entity, &typeHooks);
-		}
-
 		return entity.CreateLookup(typeof(T));
 	}
 }
-
-public unsafe readonly struct ReferenceHandle
-	: IDisposable
-{
-	public static int NumActiveHandles { get; private set; }
-
-
-	private readonly nint _value;
-
-	public object? Target =>
-		(_value != default)
-			? ((GCHandle)_value).Target
-			: null;
-
-	private ReferenceHandle(nint value)
-		=> _value = value;
-
-	public static ReferenceHandle Alloc(object? target)
-	{
-		if (target == null) return default;
-		NumActiveHandles++;
-		return new((nint)GCHandle.Alloc(target));
-	}
-
-	public ReferenceHandle Clone()
-		=> Alloc(Target);
-
-	public void Dispose()
-	{
-		if (_value == default) return;
-		NumActiveHandles--;
-		((GCHandle)_value).Free();
-	}
-
-
-	[UnmanagedCallersOnly]
-	internal static void Construct(void* ptr, int count, ecs_type_info_t* _)
-		=> new Span<ReferenceHandle>(ptr, count).Clear();
-
-	[UnmanagedCallersOnly]
-	internal static void Destruct(void* ptr, int count, ecs_type_info_t* _)
-	{
-		var span = new Span<ReferenceHandle>(ptr, count);
-		foreach (var handle in span) handle.Dispose();
-		span.Clear();
-	}
-
-	[UnmanagedCallersOnly]
-	internal static void Move(void* dstPtr, void* srcPtr, int count, ecs_type_info_t* _)
-	{
-		var dst = new Span<ReferenceHandle>(dstPtr, count);
-		var src = new Span<ReferenceHandle>(srcPtr, count);
-		foreach (var handle in dst) handle.Dispose();
-		src.CopyTo(dst);
-		src.Clear();
-	}
-
-	[UnmanagedCallersOnly]
-	internal static void Copy(void* dstPtr, void* srcPtr, int count, ecs_type_info_t* _)
-	{
-		var dst = new Span<ReferenceHandle>(dstPtr, count);
-		var src = new Span<ReferenceHandle>(srcPtr, count);
-		for (var i = 0; i < count; i++) {
-			dst[i].Dispose();
-			dst[i] = src[i].Clone();
-		}
-	}
-}

src/gaemstone.ECS/EntityRef.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using gaemstone.Utility;
 using static flecs_hub.flecs;
 
@@ -87,23 +88,22 @@ public unsafe class EntityRef
 		where T : class
 	{
 		var ptr = ecs_get_id(World, this, id);
-		return (T?)Unsafe.Read<ReferenceHandle>(ptr).Target;
+		return (ptr != null) ? (T)((GCHandle)Unsafe.Read<nint>(ptr)).Target! : null;
 	}
 
 	public override T GetOrThrow<T>(Id id)
 	{
 		var ptr = ecs_get_id(World, this, id);
 		if (ptr == null) throw new Exception($"Component {typeof(T)} not found on {this}");
-		if (typeof(T).IsValueType) return Unsafe.Read<T>(ptr);
+		return typeof(T).IsValueType ? Unsafe.Read<T>(ptr)
-		else return (T)Unsafe.Read<ReferenceHandle>(ptr).Target!;
+			: (T)((GCHandle)Unsafe.Read<nint>(ptr)).Target!;
 	}
 
 	public override ref T GetRefOrNull<T>(Id id)
 	{
 		var @ref = ecs_ref_init_id(World, this, id);
 		var ptr  = ecs_ref_get_id(World, &@ref, id);
-		return ref (ptr != null) ? ref Unsafe.AsRef<T>(ptr)
+		return ref (ptr != null) ? ref Unsafe.AsRef<T>(ptr) : ref Unsafe.NullRef<T>();
-		                         : ref Unsafe.NullRef<T>();
 	}
 
 	public override ref T GetRefOrThrow<T>(Id id)
@@ -135,12 +135,11 @@ public unsafe class EntityRef
 
 	public override EntityRef Set<T>(Id id, T obj) where T : class
 	{
-		if (obj == null) throw new ArgumentNullException(nameof(obj));
+		var handle = (nint)GCHandle.Alloc(obj);
-		var size = (ulong)sizeof(ReferenceHandle);
+		// FIXME: Previous handle needs to be freed.
-		// Dispose this handle afterwards, since Flecs clones it.
+		if (ecs_set_id(World, this, id, (ulong)sizeof(nint), &handle).Data == 0)
-		using var handle = ReferenceHandle.Alloc(obj);
-		if (ecs_set_id(World, this, id, size, &handle).Data == 0)
 			throw new InvalidOperationException();
+		// FIXME: Handle needs to be freed when component is removed!
 		return this;
 	}
 

src/gaemstone.ECS/Iterator.cs

@@ -40,7 +40,6 @@ public unsafe class Iterator
 				ecs_iter_fini(ptr);
 	}
 
-
 	public EntityRef GetVar(Variable var)
 	{
 		fixed (ecs_iter_t* ptr = &Value)
@@ -54,7 +53,6 @@ public unsafe class Iterator
 		return this;
 	}
 
-
 	public bool Next()
 	{
 		fixed (ecs_iter_t* ptr = &Value) {
@@ -70,23 +68,8 @@ public unsafe class Iterator
 		}
 	}
 
-
+	public EntityRef Entity(int index)
-	public bool FieldIsSet(int index)
+		=> new(World, new(Value.entities[index]));
-	{
-		fixed (ecs_iter_t* ptr = &Value)
-			return ecs_field_is_set(ptr, index);
-	}
-
-	public bool FieldIs(int index, Id id)
-	{
-		fixed (ecs_iter_t* ptr = &Value)
-			return ecs_field_id(ptr, index) == id.Value;
-	}
-
-	// TODO: Potentially misleading, doesn't check the field's backing data type.
-	//       The id might be "(Identifier, Name)", but its data type "Identifier".
-	public bool FieldIs<T>(int index)
-		=> FieldIs(index, World.LookupByType<T>());
 
 	public IdRef FieldId(int index)
 	{
@@ -94,10 +77,6 @@ public unsafe class Iterator
 			return new(World, new(ecs_field_id(ptr, index)));
 	}
 
-
-	public EntityRef Entity(int index)
-		=> new(World, new(Value.entities[index]));
-
 	public Span<T> Field<T>(int index)
 		where T : unmanaged
 	{
@@ -109,15 +88,27 @@ public unsafe class Iterator
 		}
 	}
 
-	public SpanToRef<T> Field<T>(int index, T _ = null!) where T : class
+	public Span<T> FieldOrEmpty<T>(int index)
-		=> new(Field<ReferenceHandle>(index));
+		where T : unmanaged => FieldIsSet(index) ? Field<T>(index) : default;
 
-	public Span<T> FieldOrEmpty<T>(int index) where T : unmanaged
+	public SpanToRef<T> FieldRef<T>(int index)
-		=> FieldIsSet(index) ? Field<T>(index) : Span<T>.Empty;
+		where T : class => new(Field<nint>(index));
 
-	public SpanToRef<T> FieldOrEmpty<T>(int index, T _ = null!) where T : class
+	public bool FieldIsSet(int index)
-		=> FieldIsSet(index) ? Field(index, _) : SpanToRef<T>.Empty;
+	{
+		fixed (ecs_iter_t* ptr = &Value)
+			return ecs_field_is_set(ptr, index);
+	}
 
+	// TODO: Potentially misleading, doesn't check the field's backing data type.
+	//       The id might be "(Identifier, Name)", but its data type "Identifier".
+	public bool FieldIs<T>(int index)
+		=> FieldIs(index, World.LookupByType<T>());
+	public bool FieldIs(int index, Id id)
+	{
+		fixed (ecs_iter_t* ptr = &Value)
+			return ecs_field_id(ptr, index) == id.Value;
+	}
 
 	public override string ToString()
 	{
@@ -137,16 +128,6 @@ public unsafe class Iterator
 		public Variable(int index, string name)
 			{ Index = index; Name = name; }
 	}
-
-	public readonly ref struct SpanToRef<T>
-		where T : class
-	{
-		public static SpanToRef<T> Empty => default;
-		private readonly Span<ReferenceHandle> _span;
-		public int Length => _span.Length;
-		public T? this[int index] => (T?)_span[index].Target;
-		internal SpanToRef(Span<ReferenceHandle> span) => _span = span;
-	}
 }
 
 public enum IteratorType

src/gaemstone.Utility/SpanToRef.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace gaemstone.Utility;
+
+public readonly ref struct SpanToRef<T>
+	where T : class
+{
+	private readonly Span<nint> _span;
+
+	public int Length => _span.Length;
+	public T? this[int index] => (_span[index] != 0)
+		? (T)((GCHandle)_span[index]).Target! : null;
+
+	internal SpanToRef(Span<nint> span) => _span = span;
+
+	public void Clear() => _span.Clear();
+	public void CopyTo(SpanToRef<T> dest) => _span.CopyTo(dest._span);
+}