Modified callback conventions so that the paradigm is more Unity implementing system calls required by Quake in whatever way works best, rather than Quake calling specific Unity functions.

Assets/Scripts/UniQuake.cs

@@ -78,7 +78,7 @@ public class UniQuake: MonoBehaviour
     }
 
     [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
-    private static extern void UniQuake_Echo(DebugLogCallback logCallback, [MarshalAs(UnmanagedType.LPStr)] string message);
+    private static extern void UniQuake_Echo(SysPrintCallback logCallback, [MarshalAs(UnmanagedType.LPStr)] string message);
     
     [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
     private static extern void UniQuake_Init(IntPtr callbacks, QuakeParms parms);
@@ -86,36 +86,37 @@ public class UniQuake: MonoBehaviour
     [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
     private static extern void UniQuake_Update(float deltaTime);
 
-    private delegate void DebugLogCallback([MarshalAs(UnmanagedType.LPStr)] string message);
+    private delegate void SysPrintCallback([MarshalAs(UnmanagedType.LPStr)] string message);
     
-    [AOT.MonoPInvokeCallback(typeof(DebugLogCallback))]
-    private static void Callback_DebugLog(string message)
+    [AOT.MonoPInvokeCallback(typeof(SysPrintCallback))]
+    private static void Callback_SysPrint(string message)
     {
         Debug.Log(message);
     }
     
-    private delegate void DebugLogErrorCallback([MarshalAs(UnmanagedType.LPStr)] string message);
+    private delegate void SysErrorCallback([MarshalAs(UnmanagedType.LPStr)] string message);
 
-    [AOT.MonoPInvokeCallback(typeof(DebugLogErrorCallback))]
-    private static void Callback_DebugLogError(string message)
+    [AOT.MonoPInvokeCallback(typeof(SysErrorCallback))]
+    private static void Callback_SysError(string message)
     {
         Debug.LogError(message);
+        Application.Quit(1);
     }
 
-    private delegate void ApplicationQuitCallback(int exitCode);
+    private delegate void SysQuitCallback();
     
-    [AOT.MonoPInvokeCallback(typeof(ApplicationQuitCallback))]
-    private static void Callback_ApplicationQuit(int exitCode)
+    [AOT.MonoPInvokeCallback(typeof(SysQuitCallback))]
+    private static void Callback_SysQuit()
     {
-        Debug.Log($"Quitting application with exit code: {exitCode}");
+        Debug.Log($"Quitting application normally");
         // TODO: kill execution of the DLL entirely (Sys_Quit expects immediate exit, which Application.Quit doesn't do)
-        Application.Quit(exitCode);
+        Application.Quit(0);
     }
 
-    private delegate double RealtimeSinceStartupCallback();
+    private delegate double SysFloatTimeCallback();
     
-    [AOT.MonoPInvokeCallback(typeof(RealtimeSinceStartupCallback))]
-    private static double Callback_RealtimeSinceStartup()
+    [AOT.MonoPInvokeCallback(typeof(SysFloatTimeCallback))]
+    private static double Callback_SysFloatTime()
     {
         return Time.timeAsDouble - startTime;
     }
@@ -130,10 +131,10 @@ public class UniQuake: MonoBehaviour
         {
             container = new UnityCallbacksContainer
             {
-                DebugLogPtr = CreateCallback<DebugLogCallback>(Callback_DebugLog),
-                DebugLogErrorPtr = CreateCallback<DebugLogErrorCallback>(Callback_DebugLogError),
-                ApplicationQuitPtr = CreateCallback<ApplicationQuitCallback>(Callback_ApplicationQuit),
-                RealtimeSinceStartupPtr = CreateCallback<RealtimeSinceStartupCallback>(Callback_RealtimeSinceStartup),
+                SysPrint = CreateCallback<SysPrintCallback>(Callback_SysPrint),
+                SysError = CreateCallback<SysErrorCallback>(Callback_SysError),
+                SysQuit = CreateCallback<SysQuitCallback>(Callback_SysQuit),
+                SysFloatTime = CreateCallback<SysFloatTimeCallback>(Callback_SysFloatTime),
             };
             
             containerHandle = GCHandle.Alloc(container, GCHandleType.Pinned);
@@ -163,10 +164,10 @@ public class UniQuake: MonoBehaviour
     [StructLayout(LayoutKind.Sequential, Pack = 0)]
     private class UnityCallbacksContainer
     {
-        public IntPtr DebugLogPtr;
-        public IntPtr DebugLogErrorPtr;
-        public IntPtr ApplicationQuitPtr;
-        public IntPtr RealtimeSinceStartupPtr;
+        public IntPtr SysPrint;
+        public IntPtr SysError;
+        public IntPtr SysQuit;
+        public IntPtr SysFloatTime;
     }
 
     [StructLayout(LayoutKind.Sequential, Pack = 0)]

engine/projects/uniquake/uniquake.c

@@ -7,14 +7,6 @@
 
 #include "../../code/quakedef.h"
 
-typedef struct unity_callbacks_s
-{
-	void(__stdcall *DebugLog)(const char *msg);
-	void(__stdcall *DebugLogError)(const char *msg);
-	void(__stdcall *ApplicationQuit)(int exitCode);
-	double(__stdcall *RealtimeSinceStartup)();
-} unity_callbacks_t;
-
 const unity_callbacks_t *unity_callbacks;
 
 void Sys_Error(char *error, ...)
@@ -26,8 +18,7 @@ void Sys_Error(char *error, ...)
 	vsprintf(text, error, argptr);
 	va_end(argptr);
 
-	unity_callbacks->DebugLogError(text);
-	unity_callbacks->ApplicationQuit(1);
+	unity_callbacks->SysError(text);
 }
 
 void Sys_Printf(char *fmt, ...)
@@ -39,18 +30,18 @@ void Sys_Printf(char *fmt, ...)
 	vsprintf(text, fmt, argptr);
 	va_end(argptr);
 
-	unity_callbacks->DebugLog(text);
+	unity_callbacks->SysPrint(text);
 }
 
 void Sys_Quit(void)
 {
 	Host_Shutdown();
-	unity_callbacks->ApplicationQuit(0);
+	unity_callbacks->SysQuit();
 }
 
 double Sys_FloatTime(void)
 {
-	return unity_callbacks->RealtimeSinceStartup();
+	return unity_callbacks->SysFloatTime();
 }
 
 UNIQUAKE_API void UniQuake_Echo(void(__stdcall *DebugLog)(const char *msg), const char *message)

engine/projects/uniquake/uniquake.h

@@ -4,3 +4,12 @@
 #define UNIQUAKE_API __declspec(dllimport)
 #endif
 
+typedef struct unity_callbacks_s
+{
+	void(__stdcall *SysPrint)(const char *msg);
+	void(__stdcall *SysError)(const char *msg);
+	void(__stdcall *SysQuit)();
+	double(__stdcall *SysFloatTime)();
+} unity_callbacks_t;
+
+extern const unity_callbacks_t *unity_callbacks;