macOS Apple Silicon arm64 + Vulkan/MoltenVK backend (WIP)

Brings PsyCross up on Apple Silicon and adds an opt-in Vulkan/MoltenVK
rendering backend alongside the existing OpenGL one. Selected at build
time via the parent project's premake option `--renderer=vulkan`.

Visible state with the Vulkan backend enabled:
- Driver 2 main menu (logo, items, sepia tint, red highlight) renders
  pixel-equivalent to the OpenGL backend.
- HUD (Damage / Felony bars, timer, mini-map) renders with the right
  palette.
- 3D world geometry is visible (skyline, skybox, player car segments).
  Wet-street reflection still wins over the road overlay until blend
  modes are re-enabled (gated for now — see below).
- Texture sampling for 4-bit / 8-bit / 16-bit paletted PSX textures
  with CLUT lookup; UVs floor()ed to integer texels to avoid sub-texel
  palette-index noise; RGB-1555 decode.
- D32_SFLOAT depth attachment with depth test (LESS_OR_EQUAL); the
  GL-style projection matrices are remapped from [-1, 1] to Vulkan's
  [0, 1] z range in the vertex shader.

Build / toolchain:
- src/render/PsyX_render_vk.cpp — new Vulkan backend behind RENDERER_VK.
  Vulkan instance + surface + device + swapchain + render pass +
  command buffers, single graphics pipeline layout matching GrVertex
  (PGXP variant), push-constant projection (2D ortho + 3D perspective),
  shaderc-runtime GLSL→SPIR-V compile, GR_BeginScene/EndScene/Clear/
  DrawTriangles/UpdateVertexBuffer plus stubs for the rest of the GR_*
  surface.
- include/PsyX/PsyX_render.h — recognises RENDERER_VK alongside the
  existing RENDERER_OGL/RENDERER_OGLES paths.
- 5 PSX BlendMode pipeline variants (BM_NONE / BM_AVERAGE / BM_ADD /
  BM_SUBTRACT / BM_ADD_QUATER_SOURCE) pre-baked; GR_SetBlendMode picks
  the active one. Currently forced to BM_NONE because BM_AVERAGE was
  being applied to every semi-trans face and turning the entire HUD
  translucent — re-enable will need the texture's STP bit plumbed
  through to the fragment first.

LP64 / arm64 portability fixes:
- include/psx/types.h: u_long → uint32_t on LP64 (preserves PSX 32-bit
  semantics) with a macOS guard that pre-empts <sys/types.h> typedefs.
- include/psx/libgpu.h: P_LEN = 3 for arm64 (same as x86_64) and a
  64-bit-correct pointer pack.
- src/psx/LIBCD.C, LIBETC.C, LIBGPU.C, LIBSPU.C: macOS portability —
  malloc.h guards, intptr_t casts for ptr→int conversions, missing
  libetc include.
- src/PsyX_main.cpp: drop the intrThread, run vsync_callback on the
  main thread instead. Fixes an arm64 race where the interrupt thread
  could fire vsync_callback in the middle of OT building, dropping
  primitives non-deterministically.
- src/render/PsyX_render.cpp: disable async PBO/blit on macOS — the
  GL-on-Metal compatibility layer doesn't honour the same timing the
  GL backend assumes.

Author: ebellumat

include/PsyX/PsyX_render.h

@@ -5,8 +5,13 @@
 
 /*
  * Platform specific emulator setup
+ *
+ * RENDERER_VK can be defined externally (via build system) to opt into
+ * the Vulkan/MoltenVK backend instead of the default OpenGL one.
  */
-#if (defined(_WIN32) || defined(__APPLE__) || defined(__linux__)) && !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__RPI__)
+#if defined(RENDERER_VK)
+    /* Vulkan backend selected — keep RENDERER_OGL/OGLES undefined */
+#elif (defined(_WIN32) || defined(__APPLE__) || defined(__linux__)) && !defined(__ANDROID__) && !defined(__EMSCRIPTEN__) && !defined(__RPI__)
 #   define RENDERER_OGL
 #   define USE_GLAD
 #elif defined(__RPI__)
@@ -26,6 +31,14 @@
 #   define USE_OPENGL 0
 #endif
 
+#if defined(RENDERER_VK)
+#   define USE_VULKAN 1
+#else
+#   ifndef USE_VULKAN
+#   define USE_VULKAN 0
+#   endif
+#endif
+
 #if OGLES_VERSION == 2
 #   define ES2_SHADERS
 #elif OGLES_VERSION == 3
@@ -35,22 +48,15 @@
  /*
   * OpenGL
   */
-
 #if defined (RENDERER_OGL)
 
 #   define GL_GLEXT_PROTOTYPES
-
-#if defined(USE_GLAD)
 #   include "common/glad.h"
-#endif
 
 #elif defined (RENDERER_OGLES)
 
 #   define GL_GLEXT_PROTOTYPES
 
-#if defined(USE_GLAD)
-#   include "common/glad.h"
-#else
 #   ifdef __EMSCRIPTEN__
 #      include <GL/gl.h>
 #   else
@@ -61,7 +67,6 @@
 #          include <GLES3/gl3.h>
 #      endif
 #   endif
-#endif
 
 #   include <EGL/egl.h>
 
@@ -72,6 +77,9 @@
 #   define TEXTURE_FORMAT GL_UNSIGNED_SHORT_1_5_5_5_REV
 #elif defined(RENDERER_OGLES)
 #   define TEXTURE_FORMAT GL_UNSIGNED_SHORT_5_5_5_1
+#elif defined(RENDERER_VK)
+/* Vulkan equivalent: VK_FORMAT_A1R5G5B5_UNORM_PACK16. Symbolic constant
+ * resolved in the Vulkan backend; nothing to define here for the public header. */
 #endif
 
 #include "psx/types.h"
@@ -105,6 +113,8 @@
 #elif defined(RENDERER_OGLES)
 #	define VRAM_FORMAT            GL_LUMINANCE_ALPHA
 #	define VRAM_INTERNAL_FORMAT   GL_LUMINANCE_ALPHA
+#elif defined(RENDERER_VK)
+/* Vulkan: VRAM is emulated as a R32G32_SFLOAT image (analogous to GL_RG32F) */
 #endif
 
 #define VRAM_WIDTH		(1024)
@@ -163,8 +173,13 @@ typedef enum
 #if defined(RENDERER_OGLES) || defined(RENDERER_OGL)
 typedef uint TextureID;
 typedef uint ShaderID;
+#elif defined(RENDERER_VK)
+/* Vulkan: opaque uint32_t handles into internal Vulkan resource tables.
+ * Backend manages VkImage/VkImageView/VkSampler/VkPipeline creation. */
+typedef uint TextureID;
+typedef uint ShaderID;
 #else
-#error
+#error "No renderer backend selected"
 #endif
 
 #if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)

include/psx/inline_c.h

@@ -104,10 +104,10 @@ extern int doCOP2(int op);
 		MTC2(*(uint*)((char*)(r2)), 22); \
 		MTC2(*(uint*)((char*)(r2)), 6); }
 
-// mtc2 12, lwc2 1
+// mtc2 0, lwc2 1
 #define gte_ldlv0( r0 ) \
-	{	MTC2((*(ushort*)((char*)(r0)+4) << 16) | *(ushort*)((char*)(r0)), 12);\
-		MTC2(*(ushort*)((char*)(r0)+8), 1); }
+	{	MTC2((*(ushort*)((char*)(r0)+4) << 16) | *(ushort*)((char*)(r0)));\
+		MTC2(*(ushort*)((char*)(r0)+8) << 16); }
 
 // mtc2 8
 #define gte_lddp( r0 )	\

include/psx/libgpu.h

@@ -329,14 +329,14 @@ typedef struct _RECT16 {
 
 #if USE_EXTENDED_PRIM_POINTERS
 
-#if defined(_M_X64) || defined(__amd64__)
+#if defined(_M_X64) || defined(__amd64__) || defined(__aarch64__) || defined(__arm64__) || defined(_M_ARM64)
 
 #define DECLARE_P_ADDR \
 		uintptr_t addr; \
 		uint len : 16; \
 		uint pgxp_index : 16;
 
-#define P_LEN		3		// 3 longs
+#define P_LEN		3		// 3 longs (addr is 8 bytes on 64-bit + 4 bytes len/pgxp_index)
 
 #else
 
@@ -347,7 +347,7 @@ typedef struct _RECT16 {
 
 #define P_LEN		2		// 2 longs
 
-#endif // _M_X64 || __amd64__
+#endif // 64-bit detection
 
 #define DECLARE_P_ADDR_PTAG DECLARE_P_ADDR
 

include/psx/libgte.h

@@ -48,7 +48,7 @@ SVECTOR *ApplyMatrixSV(MATRIX *m, SVECTOR *v0, SVECTOR *v1);
 VECTOR *ApplyMatrixLV(MATRIX *m, VECTOR *v0, VECTOR *v1);
 extern void RotTrans(SVECTOR* v0, VECTOR* v1, long* flag);
 extern void RotTransSV(SVECTOR* v0, SVECTOR* v1, long* flag);
-extern int RotTransPers(SVECTOR* v0, int* sxy, long* p, long* flag);
+extern int RotTransPers(SVECTOR* v0, long* sxy, long* p, long* flag);
 extern int RotTransPers3(SVECTOR* v0, SVECTOR* v1, SVECTOR* v2, long* sxy0, long* sxy1, long* sxy2, long* p, long* flag);
 extern int RotTransPers4(SVECTOR* v0, SVECTOR* v1, SVECTOR* v2, SVECTOR* v3, long* sxy0, long* sxy1, long* sxy2, long* sxy3, long* p, long* flag);
 extern void NormalColor(SVECTOR* v0, CVECTOR* v1);

include/psx/types.h

@@ -4,6 +4,26 @@
 #include <stdint.h>
 #include <stddef.h>
 
+/*
+ * Pre-empt macOS/BSD <sys/types.h> from declaring u_long as `unsigned long`
+ * (which is 64-bit on LP64). PSX code expects u_long to be 32-bit, so we
+ * mark the system's guard and define u_long ourselves below.
+ */
+#if defined(__APPLE__) && (defined(__LP64__) || defined(_LP64))
+#  ifndef _U_LONG
+#    define _U_LONG
+#  endif
+#  ifndef _U_INT
+#    define _U_INT
+#  endif
+#  ifndef _U_CHAR
+#    define _U_CHAR
+#  endif
+#  ifndef _U_SHORT
+#    define _U_SHORT
+#  endif
+#endif
+
 #if !defined(__APPLE__)
 /* major part of a device */
 #define	major(x)	((int)(((unsigned)(x)>>8)&0377))
@@ -30,8 +50,18 @@ typedef	unsigned int	u_int;
 #endif
 #ifndef _ULONG_T
 #define _ULONG_T
+/*
+ * The original PSX SDK treats `u_long` as a 32-bit type. On LP64 platforms
+ * (macOS arm64/x64, Linux x64) `unsigned long` is 64-bit, which breaks the
+ * PSX-style packing/casting throughout the codebase. Map it to uint32_t on
+ * those targets to preserve binary layout and call-site compatibility.
+ */
+#if defined(__LP64__) || defined(_LP64)
+typedef	uint32_t	u_long;
+#else
 typedef	unsigned long	u_long;
 #endif
+#endif
 #ifndef _SYSIII_USHORT
 #define _SYSIII_USHORT
 typedef	unsigned short	ushort;		/* sys III compat */
@@ -43,10 +73,16 @@ typedef	unsigned int	uint;		/* sys V compat */
 #endif
 #ifndef _SYSV_ULONG
 #define _SYSV_ULONG
+#if defined(__LP64__) || defined(_LP64)
+typedef	uint32_t	ulong;		/* sys V compat */
+#else
 typedef	unsigned long	ulong;		/* sys V compat */
 #endif
+#endif
 #endif /* ! __psx__ */
 
+#ifndef NBBY
 #define	NBBY	8
+#endif
 
 #endif

src/PsyX_main.cpp

@@ -146,71 +146,66 @@ int PsyX_Sys_SetVMode(int mode)
 	return old;
 }
 
+// Drives the vsync_callback + vblank counter from the calling thread.
+// Originally this was done from a separate `intrThreadMain` thread, but
+// firing PSX-VBlank callbacks asynchronously while the main thread was in
+// the middle of building the OT / running game logic raced badly on
+// arm64 (LP64 + weaker memory ordering than x86), producing intermittently
+// missing geometry. Doing it inline here keeps everything single-threaded.
+static void PsyX_PollVBlankFromMainThread(void)
+{
+	const double timestep = g_vmode == MODE_NTSC ? FIXED_TIME_STEP_NTSC : FIXED_TIME_STEP_PAL;
+
+	// Catch up: fire one callback per missed timestep
+	while (1)
+	{
+		const double vblDelta = Util_GetHPCTime(&g_vblTimer, 0);
+		if (vblDelta < timestep)
+			break;
+
+		if (vsync_callback)
+			vsync_callback();
+
+		g_psxSysCounters[PsxCounter_VBLANK]++;
+		Util_GetHPCTime(&g_vblTimer, 1);
+	}
+}
+
 int PsyX_Sys_GetVBlankCount()
 {
+	PsyX_PollVBlankFromMainThread();
+
 	if (g_skipSwapInterval)
 	{
 		// extra speedup.
 		// does not affect `vsync_callback` count
 		g_psxSysCounters[PsxCounter_VBLANK] += 1;
 		g_frameSkip++;
 	}
-	
+
 	return g_psxSysCounters[PsxCounter_VBLANK];
 }
 
+// Kept as a no-op stub so any external callers / port code still link.
+// The real logic now lives in PsyX_PollVBlankFromMainThread() and runs
+// on the main thread via PsyX_Sys_GetVBlankCount().
 int intrThreadMain(void* data)
 {
-	Util_InitHPCTimer(&g_vblTimer);
-
-	while (!g_stopIntrThread)
-	{
-		// step counters
-		{
-			const double timestep = g_vmode == MODE_NTSC ? FIXED_TIME_STEP_NTSC : FIXED_TIME_STEP_PAL;
-			const double vblDelta = Util_GetHPCTime(&g_vblTimer, 0);
-
-			if (vblDelta > timestep)
-			{
-				SDL_LockMutex(g_intrMutex);
-				
-				if (vsync_callback)
-					vsync_callback();
-				
-				SDL_UnlockMutex(g_intrMutex);
-				
-				// do vblank events
-				g_psxSysCounters[PsxCounter_VBLANK]++;
-			
-				Util_GetHPCTime(&g_vblTimer, 1);
-			}
-			
-		}
-	}
-
+	(void)data;
 	return 0;
 }
 
 static int PsyX_Sys_InitialiseCore()
 {
-#ifdef __EMSCRIPTEN__
+	// Initialise the timer on whichever thread will be polling vblank
+	// (always the main thread now).
 	Util_InitHPCTimer(&g_vblTimer);
-#else
 
-	g_intrThread = SDL_CreateThread(intrThreadMain, "psyX_intr", NULL);
-
-	if (NULL == g_intrThread)
-	{
-		eprinterr("SDL_CreateThread failed: %s\n", SDL_GetError());
-		return 0;
-	}
-	
-	g_intrMutex = SDL_CreateMutex();
-	if (NULL == g_intrMutex)
-	{
-		eprinterr("SDL_CreateMutex failed: %s\n", SDL_GetError());
-		return 0;
-	}
+#ifndef __EMSCRIPTEN__
+	// We no longer spawn `psyX_intr`. The mutex is left null because no
+	// other thread takes it; any legacy locking sites are guarded.
+	g_intrThread = NULL;
+	g_intrMutex = NULL;
 #endif
 	return 1;
 }