feat(NativeAPI): restore backward compatibility, add option to add/remove MonoBehaviour nodes to generated classes, fix spelling mistakes

Author: K0lb3

TypeTreeGeneratorAPI/NativeAPI.cs

@@ -1,11 +1,30 @@
-using System.Reflection;
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;
 using TypeTreeGeneratorAPI.TypeTreeGenerator;
 
 namespace TypeTreeGeneratorAPI
 {
     public static class NativeAPI
     {
+        private static bool addMonoBehaviourRootNodes = true;
+
+        [UnmanagedCallersOnly(EntryPoint = "TypeTreeGenerator_setAddMonoBehaviourRootNodes")]
+        public static int TypeTreeGenerator_Config_setAddMonoBehaviourRootNodes(byte value)
+        {
+            switch (value)
+            {
+                case 0:
+                    addMonoBehaviourRootNodes = false;
+                    break;
+                case 1:
+                    addMonoBehaviourRootNodes = true;
+                    break;
+                default:
+                    Console.WriteLine($"Expected True(1)/False(0), but got {value} for TypeTreeGenerator_setAddMonoBehaviourRootNodes");
+                    return -1;
+            }
+            return 0;
+        }
+
         [UnmanagedCallersOnly(EntryPoint = "TypeTreeGenerator_init")]
         public static IntPtr TypeTreeGenerator_init(IntPtr unityVersionPtr, IntPtr generatorName)
         {
@@ -130,14 +149,36 @@ public static IntPtr TypeTreeGenerator_getLoadedDLLNames(IntPtr typeTreeGenerato
             var json = string.Join(",", names.Select(name => $"\"{name}\""));
             return Marshal.StringToCoTaskMemUTF8($"[{json}]");
         }
-        
+
         public enum GenerateTreeNodesResult
         {
             Ok = 0,
             Error = -1,
             NotFound = -2,
         }
 
+        private static List<TypeTreeNode>? GenerateTypeTreeNodes(TypeTreeGeneratorHandle handle, string assemblyName, string fullName)
+        {
+            var typeTreeNodes = handle.Instance.GenerateTreeNodes(assemblyName, fullName);
+            if (addMonoBehaviourRootNodes && typeTreeNodes != null && fullName != "UnityEngine.MonoBehaviour")
+            {
+                var monoBehaviourRootNodes = handle.Instance.GetMonoBehaviourRootNodes();
+                if (typeTreeNodes.Count == 0)
+                {
+                    return monoBehaviourRootNodes;
+                }
+                if (typeTreeNodes[0].m_Level == 0)
+                {
+                    // move head to MonoBehaviour head
+                    monoBehaviourRootNodes[0] = typeTreeNodes[0];
+                    typeTreeNodes = typeTreeNodes.Slice(0, typeTreeNodes.Count - 1);
+                }
+                return monoBehaviourRootNodes.Concat(typeTreeNodes).ToList();
+            }
+            return typeTreeNodes;
+        }
+
+
         [UnmanagedCallersOnly(EntryPoint = "TypeTreeGenerator_generateTreeNodesJson")]
         public static GenerateTreeNodesResult TypeTreeGenerator_generateTreeNodesJson(IntPtr typeTreeGeneratorPtr, IntPtr assemblyNamePtr, IntPtr fullNamePtr, IntPtr jsonAddr)
         {
@@ -151,8 +192,7 @@ public static GenerateTreeNodesResult TypeTreeGenerator_generateTreeNodesJson(In
             try
             {
                 var handle = (TypeTreeGeneratorHandle)GCHandle.FromIntPtr(typeTreeGeneratorPtr).Target!;
-
-                var typeTreeNodes = handle.Instance.GenerateTreeNodes(assemblyName, fullName);
+                var typeTreeNodes = GenerateTypeTreeNodes(handle, assemblyName, fullName);
                 if (typeTreeNodes == null)
                 {
                     Marshal.WriteIntPtr(jsonAddr, IntPtr.Zero);
@@ -182,7 +222,7 @@ public static GenerateTreeNodesResult TypeTreeGenerator_generateTreeNodesRaw(Int
             try
             {
                 var handle = (TypeTreeGeneratorHandle)GCHandle.FromIntPtr(typeTreeGeneratorPtr).Target!;
-                var typeTreeNodes = handle.Instance.GenerateTreeNodes(assemblyName, fullName);
+                var typeTreeNodes = GenerateTypeTreeNodes(handle, assemblyName, fullName);
                 if (typeTreeNodes == null)
                 {
                     Marshal.WriteIntPtr(arrAddrPtr, IntPtr.Zero);
@@ -218,8 +258,7 @@ public static int TypeTreeGenerator_freeTreeNodesRaw(IntPtr arrAddr, int arrLeng
             return 0;
         }
 
-        [UnmanagedCallersOnly(EntryPoint = "TypeTreeGenerator_getMonoBehaviorDefinitions")]
-        public static int TypeTreeGenerator_getMonoBehaviorDefinitions(IntPtr typeTreeGeneratorPtr, IntPtr arrAddrPtr, IntPtr arrLengthPtr)
+        public static int _TypeTreeGenerator_getMonoBehaviourDefinitions(IntPtr typeTreeGeneratorPtr, IntPtr arrAddrPtr, IntPtr arrLengthPtr)
         {
             if (typeTreeGeneratorPtr == IntPtr.Zero)
             {
@@ -248,14 +287,12 @@ public static int TypeTreeGenerator_getMonoBehaviorDefinitions(IntPtr typeTreeGe
             }
             catch (Exception ex)
             {
-                Console.WriteLine($"Error geting mono behaviour definitions:\n{ex.Message}");
+                Console.WriteLine($"Error getting MonoBehaviour definitions:\n{ex.Message}");
                 return -1;
             }
         }
 
-
-        [UnmanagedCallersOnly(EntryPoint = "TypeTreeGenerator_freeMonoBehaviorDefinitions")]
-        public static int TypeTreeGenerator_freeMonoBehaviorDefinitions(IntPtr arrAddr, int arrLength)
+        public static int _TypeTreeGenerator_freeMonoBehaviourDefinitions(IntPtr arrAddr, int arrLength)
         {
             if (arrAddr == IntPtr.Zero)
             {
@@ -272,6 +309,34 @@ public static int TypeTreeGenerator_freeMonoBehaviorDefinitions(IntPtr arrAddr,
             return 0;
         }
 
+        // alias for backward compatibility
+        // alias for backward compatibility
+        [UnmanagedCallersOnly(EntryPoint = "TypeTreeGenerator_getMonoBehaviourDefinitions")]
+        public static int TypeTreeGenerator_getMonoBehaviourDefinitions(IntPtr typeTreeGeneratorPtr, IntPtr arrAddrPtr, IntPtr arrLengthPtr)
+        {
+            return _TypeTreeGenerator_getMonoBehaviourDefinitions(typeTreeGeneratorPtr, arrAddrPtr, arrLengthPtr);
+        }
+
+        [UnmanagedCallersOnly(EntryPoint = "TypeTreeGenerator_freeMonoBehaviourDefinitions")]
+        public static int TypeTreeGenerator_freeMonoBehaviourDefinitions(IntPtr arrAddr, int arrLength)
+        {
+            return _TypeTreeGenerator_freeMonoBehaviourDefinitions(arrAddr, arrLength);
+        }
+
+        [UnmanagedCallersOnly(EntryPoint = "TypeTreeGenerator_getMonoBehaviorDefinitions")]
+        public static int TypeTreeGenerator_getMonoBehaviorDefinitions(IntPtr typeTreeGeneratorPtr, IntPtr arrAddrPtr, IntPtr arrLengthPtr)
+        {
+            return _TypeTreeGenerator_getMonoBehaviourDefinitions(typeTreeGeneratorPtr, arrAddrPtr, arrLengthPtr);
+        }
+
+        [UnmanagedCallersOnly(EntryPoint = "TypeTreeGenerator_freeMonoBehaviorDefinitions")]
+        public static int TypeTreeGenerator_freeMonoBehaviorDefinitions(IntPtr arrAddr, int arrLength)
+        {
+            return _TypeTreeGenerator_freeMonoBehaviourDefinitions(arrAddr, arrLength);
+        }
+
+
+
         [UnmanagedCallersOnly(EntryPoint = "FreeCoTaskMem")]
         public static void FreeCoTaskMem(IntPtr ptr)
         {

bindings/python/TypeTreeGeneratorAPI/TypeTreeGenerator.py

@@ -83,12 +83,12 @@ def init_dll(asm_path: Optional[str] = None):
         ctypes.POINTER(TypeTreeNodeNative),
         ctypes.c_int,
     ]
-    dll.TypeTreeGenerator_getMonoBehaviorDefinitions.argtypes = [
+    dll.TypeTreeGenerator_getMonoBehaviourDefinitions.argtypes = [
         ctypes.c_void_p,
         ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
         ctypes.POINTER(ctypes.c_int),
     ]
-    dll.TypeTreeGenerator_freeMonoBehaviorDefinitions.argtypes = [
+    dll.TypeTreeGenerator_freeMonoBehaviourDefinitions.argtypes = [
         ctypes.POINTER(ctypes.c_char_p),
         ctypes.c_int,
     ]
@@ -97,8 +97,11 @@ def init_dll(asm_path: Optional[str] = None):
 
     dll.TypeTreeGenerator_del.argtypes = [ctypes.c_void_p]
     dll.FreeCoTaskMem.argtypes = [ctypes.c_void_p]
-    DLL = dll  # type: ignore
 
+    dll.TypeTreeGenerator_setAddMonoBehaviourRootNodes.argtypes = [ctypes.c_void_p, ctypes.c_ubyte]
+    dll.TypeTreeGenerator_setAddMonoBehaviourRootNodes.restype = ctypes.c_int
+
+    DLL = dll  # type: ignore
 
 class TypeTreeGenerator:
     ptr = ctypes.c_void_p
@@ -163,19 +166,23 @@ def get_nodes(self, assembly: str, fullname: str) -> List[TypeTreeNode]:
         DLL.TypeTreeGenerator_freeTreeNodesRaw(nodes_ptr, nodes_count)
         return nodes
 
-    def get_monobehavior_definitions(self) -> List[Tuple[str, str]]:
+    def get_monobehaviour_definitions(self) -> List[Tuple[str, str]]:
         names_ptr = ctypes.POINTER(ctypes.c_char_p)()
         names_cnt = ctypes.c_int()
-        assert not DLL.TypeTreeGenerator_getMonoBehaviorDefinitions(
+        assert not DLL.TypeTreeGenerator_getMonoBehaviourDefinitions(
             self.ptr,
             ctypes.byref(names_ptr),
             ctypes.byref(names_cnt),
         ), "failed to get module exports"
-        ptr_array = ctypes.cast(names_ptr, ctypes.POINTER(ctypes.c_char_p * names_cnt.value))
+        ptr_array = ctypes.cast(names_ptr, ctypes.POINTER(ctypes.c_char_p * (names_cnt.value*2)))
         names = [name.decode("utf-8") for name in ptr_array.contents]
         DLL.TypeTreeGenerator_freeMonoBehaviorDefinitions(names_ptr, names_cnt)
         return [(module, fullname) for module, fullname in zip(names[::2], names[1::2])]
 
+    def get_monobehavior_definitions(self) -> List[Tuple[str, str]]:
+        # alias for backward compatibility
+        return self.get_monobehaviour_definitions()
+
     def get_loaded_dll_names(self) -> List[str]:
         names_ptr = DLL.TypeTreeGenerator_getLoadedDLLNames(self.ptr)
         if not names_ptr:
@@ -188,5 +195,11 @@ def get_loaded_dll_names(self) -> List[str]:
         DLL.FreeCoTaskMem(names_ptr)
         return names
 
+    def set_add_mono_behaviour_root_nodes(self, enable: bool):
+        if hasattr(DLL, "TypeTreeGenerator_setAddMonoBehaviourRootNodes"):
+            DLL.TypeTreeGenerator_setAddMonoBehaviourRootNodes(self.ptr, int(enable))
+        else:
+            raise Exception("setAddMonoBehaviourRootNodes is not supported in this version of TypeTreeGeneratorAPI")
+
 
 __all__ = ["TypeTreeGenerator", "TypeTreeNode", "TypeTreeNodeNative", "TypeTreeBackend"]