Support basic low level plugin interface

Author: mcpiroman

src/DllManipulator.cs

@@ -53,7 +53,7 @@ public static void LoadAll()
                     {
                         foreach (var nativeFunction in dll.functions)
                         {
-                            LoadTargetFunction(nativeFunction);
+                            LoadTargetFunction(nativeFunction, false);
                         }
                     }
                 }
@@ -76,6 +76,8 @@ public static void UnloadAll()
                 {
                     if (dll.handle != IntPtr.Zero)
                     {
+                        LowLevelPluginManager.OnBeforeDllUnload(dll);
+
                         bool success = SysUnloadDll(dll.handle);
                         dll.handle = IntPtr.Zero;
 
@@ -198,7 +200,7 @@ private static DynamicMethod GetNativeFunctionMockMethod(MethodInfo nativeMethod
                     _dlls.Add(dllName, dll);
                 }
 
-                var nativeFunction = new NativeFunction(new NativeFunctionIdentity(nativeFunctionSymbol, dllName), dll);
+                var nativeFunction = new NativeFunction(nativeFunctionSymbol, dll);
                 dll.functions.Add(nativeFunction);
                 var nativeFunctionIndex = _nativeFunctionsCount;
                 AddNativeFunction(nativeFunction);
@@ -255,6 +257,7 @@ private static void GenerateNativeFunctionMockBody(ILGenerator il, ParameterInfo
                     throw new InvalidOperationException("Thread safety with Lazy mode is not supported");
 
                 il.Emit(OpCodes.Dup);
+                il.Emit(OpCodes.Ldc_I4_0); //ignoreLoadErrors -> false
                 il.Emit(OpCodes.Call, Method_LoadTargetFunction.Value);
             }
 
@@ -430,21 +433,27 @@ private static CustomAttributeBuilder CreateMarshalingAttributeBuilderFromAttrib
         /// To achieve thread safety calls to this method must be synchronized.
         /// Note: This method is being called by dynamically generated code. Be careful when changing its signature.
         /// </summary>
-        private static void LoadTargetFunction(NativeFunction nativeFunction)
+        internal static void LoadTargetFunction(NativeFunction nativeFunction, bool ignoreLoadError)
         {
             var dll = nativeFunction.containingDll;
             if (dll.handle == IntPtr.Zero)
             {
                 dll.handle = SysLoadDll(dll.path);
                 if (dll.handle == IntPtr.Zero)
                 {
-                    dll.loadingError = true;
-                    Prop_EditorApplication_isPaused.Value?.SetValue(null, true);
-                    throw new NativeDllException($"Could not load DLL \"{dll.name}\" at path \"{dll.path}\".");
+                    if (!ignoreLoadError)
+                    {
+                        dll.loadingError = true;
+                        Prop_EditorApplication_isPaused.Value?.SetValue(null, true);
+                        throw new NativeDllException($"Could not load DLL \"{dll.name}\" at path \"{dll.path}\".");
+                    }
+
+                    return;
                 }
                 else
                 {
                     dll.loadingError = false;
+                    LowLevelPluginManager.OnDllLoaded(dll);
                 }
             }
 
@@ -453,9 +462,14 @@ private static void LoadTargetFunction(NativeFunction nativeFunction)
                 IntPtr funcPtr = SysGetDllProcAddress(dll.handle, nativeFunction.identity.symbol);
                 if (funcPtr == IntPtr.Zero)
                 {
-                    dll.symbolError = true;
-                    Prop_EditorApplication_isPaused.Value?.SetValue(null, true);
-                    throw new NativeDllException($"Could not get address of symbol \"{nativeFunction.identity.symbol}\" in DLL \"{dll.name}\" at path \"{dll.path}\".");
+                    if (!ignoreLoadError)
+                    {
+                        dll.symbolError = true;
+                        Prop_EditorApplication_isPaused.Value?.SetValue(null, true);
+                        throw new NativeDllException($"Could not get address of symbol \"{nativeFunction.identity.symbol}\" in DLL \"{dll.name}\" at path \"{dll.path}\".");
+                    }
+
+                    return;
                 }
                 else
                 {

src/DllManipulatorScript.cs

@@ -75,6 +75,8 @@ private void OnEnable()
                 }
             }
 
+            LowLevelPluginManager.Initialize();
+
             if (DllManipulator.Options.loadingMode == DllLoadingMode.Preload)
                 DllManipulator.LoadAll();
 

src/LowLevelPluginManager.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.IO;
+using UnityEngine;
+
+namespace UnityNativeTool.Internal
+{
+    [DisableMocking]
+    class LowLevelPluginManager
+    {
+        private static IntPtr _unityInterfacePtr = IntPtr.Zero;
+        public static void Initialize()
+        {
+            try
+            {
+                _unityInterfacePtr = GetUnityInterfacesPtr();
+                if (_unityInterfacePtr == IntPtr.Zero)
+                    throw new Exception($"{nameof(GetUnityInterfacesPtr)} returned null");
+            }
+            catch(DllNotFoundException ex)
+            {
+                Debug.Log(ex);
+            }
+
+            Debug.Log("Initialize()");
+        }
+
+        public static void OnDllLoaded(NativeDll dll)
+        {
+            Debug.Log("OnDllLoaded() " + _unityInterfacePtr);
+
+            if (_unityInterfacePtr == IntPtr.Zero)
+                return;
+
+            var unityPluginLoadFunc = new NativeFunction("UnityPluginLoad", dll) {
+                delegateType = typeof(UnityPluginLoadDel)
+            };
+
+            DllManipulator.LoadTargetFunction(unityPluginLoadFunc, true);
+            if (unityPluginLoadFunc.@delegate != null)
+            {
+                ((UnityPluginLoadDel)unityPluginLoadFunc.@delegate)(_unityInterfacePtr);
+                Debug.Log("Called UnityPluginLoad");
+            }
+        }
+
+        public static void OnBeforeDllUnload(NativeDll dll)
+        {
+            var unityPluginUnloadFunc = new NativeFunction("UnityPluginUnload", dll) {
+                delegateType = typeof(UnityPluginUnloadDel)
+            };
+
+            DllManipulator.LoadTargetFunction(unityPluginUnloadFunc, true);
+            if (unityPluginUnloadFunc.@delegate != null)
+            { 
+                Debug.Log("Called UnityPluginUnload");
+            }
+        }
+
+        delegate void UnityPluginLoadDel(IntPtr unityInterfaces);
+        delegate void UnityPluginUnloadDel();
+        
+        [DllImport("StubLluiPlugin")]
+        private static extern IntPtr GetUnityInterfacesPtr();
+    }
+}

src/NativeFunction.cs

@@ -38,9 +38,9 @@ internal class NativeFunction
         public Type delegateType = null;
         public int index = -1;
 
-        public NativeFunction(NativeFunctionIdentity identity, NativeDll containingDll)
+        public NativeFunction(string symbol, NativeDll containingDll)
         {
-            this.identity = identity;
+            this.identity = new NativeFunctionIdentity(symbol, containingDll.name);
             this.containingDll = containingDll;
         }
     }

stubLluiPlugin/main.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include "IUnityInterface.h"
+
+static IUnityInterfaces* s_IUnityInterfaces = NULL;
+
+UNITY_INTERFACE_EXPORT IUnityInterfaces* UNITY_INTERFACE_API GetUnityInterfacesPtr()
+{
+	return s_IUnityInterfaces;
+}
+
+UNITY_INTERFACE_EXPORT void UNITY_INTERFACE_API UnityPluginLoad(IUnityInterfaces* unityInterfaces)
+{
+	s_IUnityInterfaces = unityInterfaces;
+}