feat: Add PredefinedTypeAttribute & CppTypeSystem

src/Generation/PredefinedTypeAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Hosihikari.NativeInterop.Generation;
+
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct)]
+public class PredefinedTypeAttribute : Attribute
+{
+}

src/Unmanaged/CppTypeSystem.cs

@@ -0,0 +1,54 @@
+using Hosihikari.NativeInterop.Unmanaged.Attributes;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace Hosihikari.NativeInterop.Unmanaged;
+
+public static class CppTypeSystem
+{
+    public static unsafe void* GetVTable(void* ptr) => (void*)Unsafe.Read<long>(ptr);
+
+    public static unsafe TVtable* GetVTable<TVtable>(void* ptr)
+        where TVtable : unmanaged, ICppVtable
+        => (TVtable*)GetVTable(ptr);
+
+    public static unsafe TVtable* GetVTable<T, TVtable>(nint ptr, bool cheekAttribute = true)
+        where T : class, ICppInstance<T>
+        where TVtable : unmanaged, ICppVtable
+    {
+        if (cheekAttribute && typeof(T).GetCustomAttribute<VirtualCppClassAttribute>() is not null)
+            return GetVTable<TVtable>((void*)ptr);
+
+        throw new InvalidOperationException("\'VirtualCppClassAttribute\' instance is null.");
+    }
+
+    public static unsafe ValuePointer<TVtable> GetVTable<T, TVtable>(Pointer<T> ptr, bool cheekAttribute = true)
+        where T : class, ICppInstance<T>
+        where TVtable : unmanaged, ICppVtable
+        => GetVTable<T, TVtable>(ptr, cheekAttribute);
+
+    public static unsafe ref TVtable GetVTable<T, TVtable>(T obj, bool cheekAttribute = true)
+        where T : class, ICppInstance<T>
+        where TVtable : unmanaged, ICppVtable
+        => ref *GetVTable<T, TVtable>(obj.Pointer, cheekAttribute);
+}
+
+public static class CppTypeSystemUtils
+{
+    public static T As<T>(this ICppInstanceNonGeneric @this, bool releaseSrc = false)
+        where T : class, IDisposable, ICppInstance<T>
+    {
+        if (releaseSrc)
+        {
+            T temp = T.ConstructInstance(@this.Pointer, @this.IsOwner, @this.IsTempStackValue);
+            @this.Pointer = 0;
+            @this.IsOwner = false;
+            @this.IsTempStackValue = false;
+
+            @this.Dispose();
+
+            return temp;
+        }
+        return T.ConstructInstance(@this.Pointer, false, true);
+    }
+}

src/Unmanaged/ICppInstance.cs

@@ -47,23 +47,3 @@ public interface ICppInstance<TSelf> : ICppInstanceNonGeneric
     /// <param name="ins"></param>
     public static unsafe abstract implicit operator void*(TSelf ins);
 }
-
-public static class Utils
-{
-    public static T As<T>(this ICppInstanceNonGeneric @this, bool releaseSrc = false)
-        where T : class, IDisposable, ICppInstance<T>
-    {
-        if (releaseSrc)
-        {
-            T temp = T.ConstructInstance(@this.Pointer, @this.IsOwner, @this.IsTempStackValue);
-            @this.Pointer = 0;
-            @this.IsOwner = false;
-            @this.IsTempStackValue = false;
-
-            @this.Dispose();
-
-            return temp;
-        }
-        return T.ConstructInstance(@this.Pointer, false, true);
-    }
-}

src/Unmanaged/ValuePointer.cs

@@ -8,9 +8,18 @@ namespace Hosihikari.NativeInterop.Unmanaged;
 
     public readonly ref T Target => ref Unsafe.AsRef<T>(_ptr.ToPointer());
 
+    public readonly T* Pointer => (T*)_ptr;
+
+
     private ValuePointer(nint ptr) => _ptr = ptr;
 
+    public ValuePointer(T* ptr) => _ptr = (nint)ptr;
+
     public static explicit operator ValuePointer<T>(nint ptr) => new(ptr);
 
     public static implicit operator nint(ValuePointer<T> ptr) => ptr._ptr;
+
+    public static implicit operator ValuePointer<T>(T* ptr) => new(ptr);
+
+    public static implicit operator T*(ValuePointer<T> ptr) => ptr.Pointer;
 }