@geastack/native-webgl-angle 0.1.12 → 0.1.14

package/native/angle_webgl_host.mm

@@ -1,5 +1,16 @@
 #include "webgl_readback.h"
 #if defined(_WIN32)
+// The EGL and OpenGL ES libraries the Windows host loads beside the executable.
+#ifndef GEA_WEBGL_EGL_LIBRARY
+#define GEA_WEBGL_EGL_LIBRARY "libEGL.dll"
+#endif
+#ifndef GEA_WEBGL_GLES_LIBRARY
+#define GEA_WEBGL_GLES_LIBRARY "libGLESv2.dll"
+#endif
+#endif
+// GEA_WEBGL_STATIC_GLES: EGL/GLES are statically linked into the program, so
+// nothing is loaded and entry points resolve through eglGetProcAddress.
+#if defined(_WIN32)
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
@@ -7,13 +18,14 @@
 // Legacy Win16 macros are not C++ identifiers and must not leak into the runtime.
 #undef near
 #undef far
-#else
+#elif defined(__APPLE__)
 #include "gea/apple/native_bridge.h"
 
 #import <AppKit/AppKit.h>
 #import <QuartzCore/QuartzCore.h>
 #import <dispatch/dispatch.h>
-
+#endif
+#if !defined(_WIN32) && !defined(GEA_WEBGL_STATIC_GLES)
 #include <dlfcn.h>
 #endif
 // Typed uniform arguments use the compiler runtime on both native platforms.
@@ -172,7 +184,7 @@ extern "C" bool gea_three_key_pressed(double code) {
   return gGeaKeyState[c];
 }
 
-#if defined(_WIN32)
+#if !defined(__APPLE__)
 // The Win32 window procedure owns input on Windows; it reports into the same
 // tables the AppKit host view fills on macOS (keys as macOS virtual key codes).
 extern "C" void gea_three_set_key_state(int code, bool down) {
@@ -189,7 +201,7 @@ extern "C" void gea_three_set_pointer_state(double x, double y, double width, do
 }
 #endif
 
-#if !defined(_WIN32)
+#if defined(__APPLE__)
 @interface GeaAngleWebGLHostView : NSView
 @end
 
@@ -410,6 +422,10 @@ using PFNGLTEXIMAGE2DPROC = void (*)(GLenum, GLint, GLint, GLsizei, GLsizei, GLi
 using PFNGLTEXPARAMETERFPROC = void (*)(GLenum, GLenum, GLfloat);
 using PFNGLTEXPARAMETERIPROC = void (*)(GLenum, GLenum, GLint);
 using PFNGLTEXSUBIMAGE2DPROC = void (*)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const void *);
+using PFNGLTEXIMAGE3DPROC = void (*)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const void *);
+using PFNGLTEXSUBIMAGE3DPROC = void (*)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const void *);
+using PFNGLTEXSTORAGE3DPROC = void (*)(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei);
+using PFNGLFRAMEBUFFERTEXTURELAYERPROC = void (*)(GLenum, GLenum, GLuint, GLint, GLint);
 using PFNGLTEXSTORAGE2DPROC = void (*)(GLenum, GLsizei, GLenum, GLsizei, GLsizei);
 using PFNGLUNIFORM1FPROC = void (*)(GLint, GLfloat);
 using PFNGLUNIFORM1FVPROC = void (*)(GLint, GLsizei, const GLfloat *);
@@ -447,6 +463,13 @@ using PFNGLCOPYTEXIMAGE2DPROC=void(*)(GLenum,GLint,GLenum,GLint,GLint,GLsizei,GL
 using PFNGLCOPYTEXSUBIMAGE2DPROC=void(*)(GLenum,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei);
 using PFNGLBLITFRAMEBUFFERPROC = void (*)(GLint,GLint,GLint,GLint,GLint,GLint,GLint,GLint,GLbitfield,GLenum);
 using PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC = void (*)(GLenum,GLsizei,GLenum,GLsizei,GLsizei);
+using GLuint64 = std::uint64_t;
+using GLsync = struct __GLsync *;
+using PFNGLMAPBUFFERRANGEPROC = void *(*)(GLenum, GLintptr, GLsizeiptr, GLbitfield);
+using PFNGLUNMAPBUFFERPROC = GLboolean (*)(GLenum);
+using PFNGLFENCESYNCPROC = GLsync (*)(GLenum, GLbitfield);
+using PFNGLCLIENTWAITSYNCPROC = GLenum (*)(GLsync, GLbitfield, GLuint64);
+using PFNGLDELETESYNCPROC = void (*)(GLsync);
 struct AngleWebGLState {
   PFNGLCOPYTEXIMAGE2DPROC glCopyTexImage2D=nullptr;
   PFNGLCOPYTEXSUBIMAGE2DPROC glCopyTexSubImage2D=nullptr;
@@ -533,6 +556,12 @@ struct AngleWebGLState {
   PFNGLPIXELSTOREIPROC glPixelStorei = nullptr;
   PFNGLPOLYGONOFFSETPROC glPolygonOffset = nullptr;
   PFNGLREADPIXELSPROC glReadPixels = nullptr;
+  // WebGL2 asynchronous readback: PIXEL_PACK_BUFFER reads, sync objects and read-mapping.
+  PFNGLMAPBUFFERRANGEPROC glMapBufferRange = nullptr;
+  PFNGLUNMAPBUFFERPROC glUnmapBuffer = nullptr;
+  PFNGLFENCESYNCPROC glFenceSync = nullptr;
+  PFNGLCLIENTWAITSYNCPROC glClientWaitSync = nullptr;
+  PFNGLDELETESYNCPROC glDeleteSync = nullptr;
   PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage = nullptr;
   PFNGLSCISSORPROC glScissor = nullptr;
   PFNGLSHADERSOURCEPROC glShaderSource = nullptr;
@@ -547,6 +576,12 @@ struct AngleWebGLState {
   PFNGLTEXPARAMETERIPROC glTexParameteri = nullptr;
   PFNGLTEXSUBIMAGE2DPROC glTexSubImage2D = nullptr;
   PFNGLTEXSTORAGE2DPROC glTexStorage2D = nullptr;
+  // Array/3D entry points are optional: a GLES without them still starts,
+  // and uploads to those targets report GL_INVALID_OPERATION in the log.
+  PFNGLTEXIMAGE3DPROC glTexImage3D = nullptr;
+  PFNGLTEXSUBIMAGE3DPROC glTexSubImage3D = nullptr;
+  PFNGLTEXSTORAGE3DPROC glTexStorage3D = nullptr;
+  PFNGLFRAMEBUFFERTEXTURELAYERPROC glFramebufferTextureLayer = nullptr;
   PFNGLUNIFORM1FPROC glUniform1f = nullptr;
   PFNGLUNIFORM1FVPROC glUniform1fv = nullptr;
   PFNGLUNIFORM1IPROC glUniform1i = nullptr;
@@ -579,7 +614,7 @@ struct AngleWebGLState {
   PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer = nullptr;
   PFNGLVIEWPORTPROC glViewport = nullptr;
 
-#if defined(_WIN32)
+#if !defined(__APPLE__)
   void *nativeWindow = nullptr;
 #else
   NSView *hostView = nil;
@@ -617,7 +652,7 @@ static bool nativeShadowColorAuditEnabled() {
 }
 
 static void smokeLog(const char *format, ...) {
-  char message[1024] = {};
+  char message[16384] = {};
   va_list args;
   va_start(args, format);
   std::vsnprintf(message, sizeof(message), format, args);
@@ -631,8 +666,13 @@ static void smokeLog(const char *format, ...) {
     std::fprintf(stderr, "%s\n", message);
     return;
   }
-#else
+#elif defined(__APPLE__)
   if (!path || path[0] == '\0') path = "/tmp/three-angle-metal-smoke.log";
+#else
+  if (!path || path[0] == '\0') {
+    std::fprintf(stderr, "%s\n", message);
+    return;
+  }
 #endif
   if (FILE *file = std::fopen(path, "a")) {
     std::fprintf(file, "%s\n", message);
@@ -653,7 +693,7 @@ extern "C" void gea_three_angle_smoke_log(std::string message) {
 // handler records the position in the host view's coordinate space with the
 // same top-left-origin flip the per-view path used. Returning the event
 // unmodified keeps normal dispatch (clicks, first responder) intact.
-#if !defined(_WIN32)
+#if defined(__APPLE__)
 static id gGeaPointerMonitor = nil;
 static void geaInstallPointerMonitor(void) {
   if (gGeaPointerMonitor) return;
@@ -696,9 +736,16 @@ static void *openFirst(const char *envName, const char *const *paths) {
 
 #endif
 
+#if defined(GEA_WEBGL_STATIC_GLES)
+extern "C" void *eglGetProcAddress(const char *name);
+#endif
 template <typename Fn>
 static Fn loadSymbol(void *library, const char *name) {
-#if defined(_WIN32)
+#if defined(GEA_WEBGL_STATIC_GLES)
+  (void)library;
+  if (std::strcmp(name, "eglGetProcAddress") == 0) return reinterpret_cast<Fn>(&eglGetProcAddress);
+  return reinterpret_cast<Fn>(eglGetProcAddress(name));
+#elif defined(_WIN32)
   return reinterpret_cast<Fn>(GetProcAddress(static_cast<HMODULE>(library), name));
 #else
   return reinterpret_cast<Fn>(dlsym(library, name));
@@ -797,7 +844,7 @@ static void logEglFailure(const char *step) {
   std::fprintf(stderr, "[three-angle-metal] %s failed, EGL error 0x%04x\n", step, lastEglError());
 }
 
-#if !defined(_WIN32)
+#if defined(__APPLE__)
 static CGFloat backingScaleForHostView(NSView *nativeView) {
   CGFloat scale = nativeView.window ? nativeView.window.backingScaleFactor : 0.0;
   if (scale <= 0.0 && nativeView.window.screen) scale = nativeView.window.screen.backingScaleFactor;
@@ -870,13 +917,13 @@ extern "C" void gea_three_webgl_update_size_uwp(double width, double height, dou
 }
 #endif
 
-#if defined(_WIN32)
+#if !defined(__APPLE__)
 // The UWP frame driver owns its EGL context exclusively until it returns to
 // CoreWindow event dispatch. Other hosts retain per-call binding semantics.
 static thread_local bool gUwpFrameContextCurrent = false;
 #endif
 static bool makeCurrent(const char *label) {
-#if defined(_WIN32)
+#if !defined(__APPLE__)
   if (gUwpFrameContextCurrent) return true;
 #endif
   if (!gWebGL.ready && gWebGL.context == EGL_NO_CONTEXT) return false;
@@ -907,7 +954,7 @@ static bool makeCurrent(const char *label) {
   return true;
 }
 
-#if defined(_WIN32)
+#if !defined(__APPLE__)
 extern "C" bool gea_three_webgl_begin_frame_uwp() {
   // Always rebind after the dispatcher, where arbitrary platform callbacks
   // may have used a different context. No such callbacks run within the frame.
@@ -921,7 +968,7 @@ extern "C" void gea_three_webgl_end_frame_uwp() {
 }
 #endif
 
-#if !defined(_WIN32)
+#if defined(__APPLE__)
 static bool rebuildWindowSurface(const char *label) {
   if (!gWebGL.eglCreateWindowSurface || !gWebGL.eglDestroySurface || !gWebGL.eglMakeCurrent ||
       !gWebGL.metalLayer || !gWebGL.config || gWebGL.context == EGL_NO_CONTEXT) {
@@ -1029,6 +1076,11 @@ static bool loadGlSymbols() {
   LOAD_GL(glPixelStorei, PFNGLPIXELSTOREIPROC)
   LOAD_GL(glPolygonOffset, PFNGLPOLYGONOFFSETPROC)
   LOAD_GL(glReadPixels, PFNGLREADPIXELSPROC)
+  LOAD_GL(glMapBufferRange, PFNGLMAPBUFFERRANGEPROC)
+  LOAD_GL(glUnmapBuffer, PFNGLUNMAPBUFFERPROC)
+  LOAD_GL(glFenceSync, PFNGLFENCESYNCPROC)
+  LOAD_GL(glClientWaitSync, PFNGLCLIENTWAITSYNCPROC)
+  LOAD_GL(glDeleteSync, PFNGLDELETESYNCPROC)
   LOAD_GL(glCopyTexImage2D,PFNGLCOPYTEXIMAGE2DPROC)
   LOAD_GL(glCopyTexSubImage2D,PFNGLCOPYTEXSUBIMAGE2DPROC)
   LOAD_GL(glBlitFramebuffer, PFNGLBLITFRAMEBUFFERPROC)
@@ -1047,6 +1099,10 @@ static bool loadGlSymbols() {
   LOAD_GL(glTexParameteri, PFNGLTEXPARAMETERIPROC)
   LOAD_GL(glTexSubImage2D, PFNGLTEXSUBIMAGE2DPROC)
   LOAD_GL(glTexStorage2D, PFNGLTEXSTORAGE2DPROC)
+  gWebGL.glTexImage3D = loadGl<PFNGLTEXIMAGE3DPROC>("glTexImage3D");
+  gWebGL.glTexSubImage3D = loadGl<PFNGLTEXSUBIMAGE3DPROC>("glTexSubImage3D");
+  gWebGL.glTexStorage3D = loadGl<PFNGLTEXSTORAGE3DPROC>("glTexStorage3D");
+  gWebGL.glFramebufferTextureLayer = loadGl<PFNGLFRAMEBUFFERTEXTURELAYERPROC>("glFramebufferTextureLayer");
   LOAD_GL(glUniform1f, PFNGLUNIFORM1FPROC)
   LOAD_GL(glUniform1fv, PFNGLUNIFORM1FVPROC)
   LOAD_GL(glUniform1i, PFNGLUNIFORM1IPROC)
@@ -1082,7 +1138,7 @@ static bool loadGlSymbols() {
   return true;
 }
 
-#if defined(_WIN32)
+#if !defined(__APPLE__)
 extern "C" bool gea_three_webgl_attach_uwp(
   void *nativeWindow,
 #else
@@ -1097,24 +1153,50 @@ extern "C" bool gea_three_webgl_attach(
   smokeLog("[three-angle-metal] WebGL host attach requested");
   if (gWebGL.ready) return true;
 
-#if defined(_WIN32)
-  // An override (e.g. threejs-rendozer's GeaRendozerGLES.dll) first, then the
-  // packaged ANGLE of a UWP app, then a plain desktop load next to the exe.
-  auto openWin32 = [](const wchar_t *overrideEnv, const wchar_t *name) -> HMODULE {
+#if defined(GEA_WEBGL_STATIC_GLES)
+  // Linked into the program: nothing to load; loadSymbol resolves through
+  // eglGetProcAddress. The handles only need to be non-null.
+  static int staticGles;
+  gWebGL.egl = &staticGles;
+  gWebGL.gles = &staticGles;
+#elif defined(_WIN32)
+  // An override path from the environment first, then the packaged library of
+  // a UWP app, then the file beside the executable. The file names default to
+  // ANGLE's; a build that stages another EGL/GLES implementation names its
+  // files through GEA_WEBGL_EGL_LIBRARY / GEA_WEBGL_GLES_LIBRARY (paths
+  // relative to the executable's directory; one DLL may implement both).
+  auto openWin32 = [](const wchar_t *overrideEnv, const char *name) -> HMODULE {
     wchar_t overridePath[MAX_PATH];
     const DWORD n = GetEnvironmentVariableW(overrideEnv, overridePath, MAX_PATH);
     if (n > 0 && n < MAX_PATH) {
       if (HMODULE m = LoadLibraryW(overridePath)) return m;
+      smokeLog("[native-webgl-angle] %ls names a library that does not load (error %lu)", overrideEnv, GetLastError());
     }
+    std::wstring file;
+    for (const char *c = name; *c; ++c) file.push_back(*c == '/' ? L'\\' : static_cast<wchar_t>(static_cast<unsigned char>(*c)));
 #if defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_APP
-    return LoadPackagedLibrary(name, 0);
+    return LoadPackagedLibrary(file.c_str(), 0);
 #else
-    return LoadLibraryW(name);
+    wchar_t module[MAX_PATH] = {};
+    const DWORD length = GetModuleFileNameW(nullptr, module, MAX_PATH);
+    std::wstring beside(module, length < MAX_PATH ? length : 0);
+    const size_t slash = beside.find_last_of(L"\\/");
+    if (slash != std::wstring::npos) {
+      beside.resize(slash + 1);
+      beside += file;
+      // Altered search path: the library's own dependencies resolve from its directory.
+      if (HMODULE m = LoadLibraryExW(beside.c_str(), nullptr, LOAD_WITH_ALTERED_SEARCH_PATH)) return m;
+    }
+    return LoadLibraryW(file.c_str());
 #endif
   };
-  gWebGL.egl = openWin32(L"GEA_ANGLE_EGL_DYLIB", L"libEGL.dll");
-  gWebGL.gles = openWin32(L"GEA_ANGLE_GLES_DYLIB", L"libGLESv2.dll");
-#else
+  gWebGL.egl = openWin32(L"GEA_ANGLE_EGL_DYLIB", GEA_WEBGL_EGL_LIBRARY);
+  gWebGL.gles = openWin32(L"GEA_ANGLE_GLES_DYLIB", GEA_WEBGL_GLES_LIBRARY);
+  if (!gWebGL.egl || !gWebGL.gles) {
+    smokeLog("[native-webgl-angle] EGL/GLES implementation not found: %s and %s beside the executable "
+             "(GEA_ANGLE_EGL_DYLIB / GEA_ANGLE_GLES_DYLIB override them)", GEA_WEBGL_EGL_LIBRARY, GEA_WEBGL_GLES_LIBRARY);
+  }
+#elif defined(__APPLE__)
   static const char *const eglPaths[] = {
     "/Applications/Visual Studio Code.app/Contents/Frameworks/Electron Framework.framework/Versions/A/Libraries/libEGL.dylib",
     "/Applications/Cursor.app/Contents/Frameworks/Electron Framework.framework/Versions/A/Libraries/libEGL.dylib",
@@ -1132,6 +1214,8 @@ extern "C" bool gea_three_webgl_attach(
 
   gWebGL.egl = openFirst("GEA_ANGLE_EGL_DYLIB", eglPaths);
   gWebGL.gles = openFirst("GEA_ANGLE_GLES_DYLIB", glesPaths);
+#else
+#error "load libEGL/libGLESv2 for this platform, or build with GEA_WEBGL_STATIC_GLES"
 #endif
   if (!gWebGL.egl || !gWebGL.gles) {
     smokeLog("[three-angle-metal] ANGLE libEGL/libGLESv2 were not found");
@@ -1209,7 +1293,7 @@ extern "C" bool gea_three_webgl_attach(
   }
   gWebGL.config = config;
 
-#if defined(_WIN32)
+#if !defined(__APPLE__)
   gWebGL.nativeWindow = nativeWindow;
   gea_three_webgl_update_size_uwp(width, height, devicePixelRatio);
   if (gWebGL.eglCreateWindowSurface) {
@@ -1275,7 +1359,7 @@ extern "C" bool gea_three_webgl_attach(
 
   gWebGL.ready = true;
   gWebGL.glViewport(0, 0, gWebGL.widthPx, gWebGL.heightPx);
-#if !defined(_WIN32)
+#if defined(__APPLE__)
   dispatch_async(dispatch_get_main_queue(), ^{
     if (gWebGL.ready && rebuildWindowSurface("eglCreateWindowSurface(deferred)")) {
       smokeLog("[three-angle-metal] WebGL EGL surface rebound at %dx%d", gWebGL.widthPx, gWebGL.heightPx);
@@ -1391,7 +1475,7 @@ extern "C" void gea_three_webgl_swap() {
   // TEMP-DIAG: GEA_THREE_VIEW_DUMP=1 — at frame 60, log the window's full
   // subview tree and a hit-test grid so overlay views that would swallow
   // mouse events are visible without Accessibility permission.
-#if !defined(_WIN32)
+#if defined(__APPLE__)
   if (std::getenv("GEA_THREE_VIEW_DUMP")) {
     static int viewDumpCount = 0;
     if (++viewDumpCount == 60) {
@@ -1424,6 +1508,16 @@ extern "C" void gea_three_webgl_swap() {
     }
   }
 #endif
+  // The debug dump and recording read the window into client memory. A PIXEL_PACK_BUFFER the app left
+  // bound (WebGL2 asynchronous readback) would make the pointer a buffer offset instead, so the read
+  // runs with it unbound and the binding is restored afterwards.
+  const auto readWindowRgba = [](int w, int h, unsigned char *rgba) {
+    GLint packBuffer = 0;
+    if (gWebGL.glGetIntegerv) gWebGL.glGetIntegerv(0x88ED /* PIXEL_PACK_BUFFER_BINDING */, &packBuffer);
+    if (packBuffer) gWebGL.glBindBuffer(0x88EB /* PIXEL_PACK_BUFFER */, 0);
+    gWebGL.glReadPixels(0, 0, w, h, GL_RGBA_VALUE, GL_UNSIGNED_BYTE, rgba);
+    if (packBuffer) gWebGL.glBindBuffer(0x88EB, static_cast<GLuint>(packBuffer));
+  };
   // Debug frame dump: GEA_WEBGL_DUMP_FRAME=<path-prefix> writes the full
   // framebuffer of frames 90/180/300 as PPM (P6) — visual ground truth for
   // native-vs-browser comparisons without needing a window screenshot.
@@ -1434,7 +1528,7 @@ extern "C" void gea_three_webgl_swap() {
       const int w = gWebGL.widthPx;
       const int h = gWebGL.heightPx;
       std::vector<unsigned char> rgba(static_cast<size_t>(w) * h * 4);
-      gWebGL.glReadPixels(0, 0, w, h, GL_RGBA_VALUE, GL_UNSIGNED_BYTE, rgba.data());
+      readWindowRgba(w, h, rgba.data());
       char path[512];
       std::snprintf(path, sizeof path, "%s-f%d.ppm", dumpPrefix, dumpCount);
       if (FILE *file = std::fopen(path, "wb")) {
@@ -1483,7 +1577,7 @@ extern "C" void gea_three_webgl_swap() {
       if (due > recordWritten && gWebGL.widthPx == recordW && gWebGL.heightPx == recordH) {
         std::vector<unsigned char> rgba(static_cast<size_t>(recordW) * recordH * 4);
         std::vector<unsigned char> rgb(static_cast<size_t>(recordW) * recordH * 3);
-        gWebGL.glReadPixels(0, 0, recordW, recordH, GL_RGBA_VALUE, GL_UNSIGNED_BYTE, rgba.data());
+        readWindowRgba(recordW, recordH, rgba.data());
         for (int y = 0; y < recordH; ++y) {
           const unsigned char *src = rgba.data() + static_cast<size_t>(recordH - 1 - y) * recordW * 4;
           unsigned char *dst = rgb.data() + static_cast<size_t>(y) * recordW * 3;
@@ -2498,6 +2592,36 @@ extern "C" void gea_three_webgl_tex_image_2d_bytes(double target, double level,
   gWebGL.glTexImage2D(asGLenum(target), asGLint(level), asGLint(internalFormat), asGLsizei(width), asGLsizei(height), 0, asGLenum(format), asGLenum(type), bytes);
 }
 
+static bool requireGl(const void *fn, const char *name) {
+  if (fn) return true;
+  smokeLog("[native-webgl] %s is not provided by this GLES; the call is dropped", name);
+  return false;
+}
+
+extern "C" void gea_three_webgl_tex_image_3d_bytes(double target, double level, double internalFormat, double width, double height, double depth, double format, double type, const void* bytes, double) {
+  GEA_WEBGL_VOID("texImage3DBytes");
+  if (!requireGl(reinterpret_cast<const void *>(gWebGL.glTexImage3D), "glTexImage3D")) return;
+  gWebGL.glTexImage3D(asGLenum(target), asGLint(level), asGLint(internalFormat), asGLsizei(width), asGLsizei(height), asGLsizei(depth), 0, asGLenum(format), asGLenum(type), bytes);
+}
+
+extern "C" void gea_three_webgl_tex_sub_image_3d_bytes(double target, double level, double xoffset, double yoffset, double zoffset, double width, double height, double depth, double format, double type, const void* bytes, double) {
+  GEA_WEBGL_VOID("texSubImage3DBytes");
+  if (!requireGl(reinterpret_cast<const void *>(gWebGL.glTexSubImage3D), "glTexSubImage3D")) return;
+  gWebGL.glTexSubImage3D(asGLenum(target), asGLint(level), asGLint(xoffset), asGLint(yoffset), asGLint(zoffset), asGLsizei(width), asGLsizei(height), asGLsizei(depth), asGLenum(format), asGLenum(type), bytes);
+}
+
+extern "C" void gea_three_webgl_tex_storage_3d(double target, double levels, double internalFormat, double width, double height, double depth) {
+  GEA_WEBGL_VOID("texStorage3D");
+  if (!requireGl(reinterpret_cast<const void *>(gWebGL.glTexStorage3D), "glTexStorage3D")) return;
+  gWebGL.glTexStorage3D(asGLenum(target), asGLsizei(std::max(1.0, levels)), asGLenum(internalFormat), asGLsizei(width), asGLsizei(height), asGLsizei(depth));
+}
+
+extern "C" void gea_three_webgl_framebuffer_texture_layer(double target, double attachment, double texture, double level, double layer) {
+  GEA_WEBGL_VOID("framebufferTextureLayer");
+  if (!requireGl(reinterpret_cast<const void *>(gWebGL.glFramebufferTextureLayer), "glFramebufferTextureLayer")) return;
+  gWebGL.glFramebufferTextureLayer(asGLenum(target), asGLenum(attachment), asGLuint(texture), asGLint(level), asGLint(layer));
+}
+
 extern "C" void gea_three_webgl_tex_sub_image_2d_bytes(double target, double level, double xoffset, double yoffset, double width, double height, double format, double type, const void* bytes, double) {
   GEA_WEBGL_VOID("texSubImage2DBytes");
   gWebGL.glTexSubImage2D(asGLenum(target), asGLint(level), asGLint(xoffset), asGLint(yoffset), asGLsizei(width), asGLsizei(height), asGLenum(format), asGLenum(type), bytes);
@@ -2805,6 +2929,106 @@ extern "C" void gea_three_webgl_read_pixels_bytes(double x, double y, double wid
   gWebGL.glReadPixels(asGLint(x),asGLint(y),asGLsizei(width),asGLsizei(height),asGLenum(format),asGLenum(type),bytes);
 }
 
+// WebGL2 asynchronous readback (three's readRenderTargetPixelsAsync): readPixels into the bound
+// PIXEL_PACK_BUFFER at a byte offset, a fence, polling, then getBufferSubData through a read mapping.
+extern "C" void gea_three_webgl_read_pixels_pack(double x, double y, double width, double height, double format, double type, double offset) {
+  GEA_WEBGL_VOID("readPixels");
+  GLint packBuffer = 0;
+  gWebGL.glGetIntegerv(0x88ED, &packBuffer);
+  if (!packBuffer || !std::isfinite(offset) || offset < 0 || std::floor(offset) != offset) { if (!hostReadbackError) hostReadbackError = 0x0502; return; }
+  gWebGL.glReadPixels(asGLint(x), asGLint(y), asGLsizei(width), asGLsizei(height), asGLenum(format), asGLenum(type),
+                      reinterpret_cast<void *>(static_cast<std::uintptr_t>(offset)));
+}
+static std::unordered_map<std::uint32_t, GLsync> gWebGLSyncs;
+static std::uint32_t gWebGLNextSync = 1;
+extern "C" double gea_three_webgl_fence_sync() {
+  GEA_WEBGL_DOUBLE("fenceSync");
+  GLsync sync = gWebGL.glFenceSync(0x9117 /* SYNC_GPU_COMMANDS_COMPLETE */, 0);
+  if (!sync) return 0.0;
+  const std::uint32_t id = gWebGLNextSync++;
+  gWebGLSyncs[id] = sync;
+  return static_cast<double>(id);
+}
+extern "C" double gea_three_webgl_client_wait_sync(double sync, double flags, double timeout) {
+  GEA_WEBGL_DOUBLE("clientWaitSync");
+  auto it = gWebGLSyncs.find(static_cast<std::uint32_t>(sync));
+  if (it == gWebGLSyncs.end()) return 0x911D; // WAIT_FAILED
+  return static_cast<double>(gWebGL.glClientWaitSync(it->second, static_cast<GLbitfield>(flags), static_cast<GLuint64>(std::max(0.0, timeout))));
+}
+extern "C" void gea_three_webgl_delete_sync(double sync) {
+  GEA_WEBGL_VOID("deleteSync");
+  auto it = gWebGLSyncs.find(static_cast<std::uint32_t>(sync));
+  if (it == gWebGLSyncs.end()) return;
+  gWebGL.glDeleteSync(it->second);
+  gWebGLSyncs.erase(it);
+}
+// GPU timers for the app's frame profiler, on GL_EXT_disjoint_timer_query.
+struct HostGpuTimers {
+  bool initialized = false, supported = false;
+  void (*gen)(GLsizei, GLuint *) = nullptr;
+  void (*remove)(GLsizei, const GLuint *) = nullptr;
+  void (*begin)(GLenum, GLuint) = nullptr;
+  void (*end)(GLenum) = nullptr;
+  void (*available)(GLuint, GLenum, GLuint *) = nullptr;
+  void (*result)(GLuint, GLenum, std::uint64_t *) = nullptr;
+  bool open = false;
+  bool ensure() {
+    if (initialized) return supported;
+    initialized = true;
+    const auto extensions = reinterpret_cast<const char *>(gWebGL.glGetString(0x1F03));
+    const std::string list = " " + std::string(extensions ? extensions : "") + " ";
+    if (list.find(" GL_EXT_disjoint_timer_query ") == std::string::npos) return false;
+    gen = loadGl<decltype(gen)>("glGenQueriesEXT");
+    remove = loadGl<decltype(remove)>("glDeleteQueriesEXT");
+    begin = loadGl<decltype(begin)>("glBeginQueryEXT");
+    end = loadGl<decltype(end)>("glEndQueryEXT");
+    available = loadGl<decltype(available)>("glGetQueryObjectuivEXT");
+    result = loadGl<decltype(result)>("glGetQueryObjectui64vEXT");
+    supported = gen && remove && begin && end && available && result;
+    return supported;
+  }
+};
+static HostGpuTimers gHostGpuTimers;
+extern "C" double gea_three_webgl_timer_begin() {
+  GEA_WEBGL_DOUBLE("timerBegin");
+  auto &t = gHostGpuTimers;
+  if (!t.ensure() || t.open) return 0.0;
+  GLuint query = 0;
+  t.gen(1, &query);
+  if (!query) return 0.0;
+  t.begin(0x88BF /* TIME_ELAPSED_EXT */, query);
+  t.open = true;
+  return static_cast<double>(query);
+}
+extern "C" void gea_three_webgl_timer_end() {
+  GEA_WEBGL_VOID("timerEnd");
+  auto &t = gHostGpuTimers;
+  if (!t.supported || !t.open) return;
+  t.end(0x88BF);
+  t.open = false;
+}
+extern "C" double gea_three_webgl_timer_result(double timer) {
+  GEA_WEBGL_DOUBLE("timerResult");
+  auto &t = gHostGpuTimers;
+  const GLuint query = static_cast<GLuint>(timer);
+  if (!t.supported || !query) return 0.0;
+  GLuint ready = 0;
+  t.available(query, 0x8867 /* QUERY_RESULT_AVAILABLE */, &ready);
+  if (!ready) return -1.0;
+  std::uint64_t ns = 0;
+  t.result(query, 0x8866 /* QUERY_RESULT */, &ns);
+  t.remove(1, &query);
+  return static_cast<double>(ns);
+}
+extern "C" void gea_three_webgl_get_buffer_sub_data_bytes(double target, double srcOffset, void *bytes, double byteLength) {
+  GEA_WEBGL_VOID("getBufferSubData");
+  if (!bytes || !(byteLength > 0) || !(srcOffset >= 0)) { if (!hostReadbackError) hostReadbackError = 0x0501; return; }
+  void *mapped = gWebGL.glMapBufferRange(asGLenum(target), static_cast<GLintptr>(srcOffset), static_cast<GLsizeiptr>(byteLength), 0x0001 /* MAP_READ_BIT */);
+  if (!mapped) { if (!hostReadbackError) hostReadbackError = 0x0502; return; }
+  std::memcpy(bytes, mapped, static_cast<std::size_t>(byteLength));
+  gWebGL.glUnmapBuffer(asGLenum(target));
+}
+
 extern "C" void gea_three_webgl_blit_framebuffer(double sx0,double sy0,double sx1,double sy1,double dx0,double dy0,double dx1,double dy1,double mask,double filter) {
   GEA_WEBGL_VOID("blitFramebuffer");
   gWebGL.glBlitFramebuffer(asGLint(sx0),asGLint(sy0),asGLint(sx1),asGLint(sy1),asGLint(dx0),asGLint(dy0),asGLint(dx1),asGLint(dy1),asGLenum(mask),asGLenum(filter));

package/native/audio_host.mm

@@ -21,6 +21,9 @@
 #if defined(_WIN32)
 #define _USE_MATH_DEFINES
 #include "audio_uwp.h"
+// Legacy Win16 macros are not C++ identifiers and must not leak into the runtime.
+#undef near
+#undef far
 #else
 #import <AVFoundation/AVFoundation.h>
 #import <Foundation/Foundation.h>
@@ -44,8 +47,30 @@
 
 #if defined(_WIN32)
 static std::wstring geaAudioAssetDirectory;
+static bool geaAudioAssetDirectorySet = false;
 extern "C" void gea_three_audio_set_directory_uwp(const wchar_t *path) {
   geaAudioAssetDirectory = path ? path : L"";
+  geaAudioAssetDirectorySet = true;
+}
+// Without a driver naming the directory: GEA_THREE_AUDIO_DIR, else the
+// Resources\Sounds folder beside the executable (where the desktop target
+// stages an app's sounds), matching the macOS host's bundle lookup.
+static const std::wstring &geaAudioDirectory() {
+  if (!geaAudioAssetDirectorySet) {
+    geaAudioAssetDirectorySet = true;
+    wchar_t value[MAX_PATH] = {};
+    const DWORD n = GetEnvironmentVariableW(L"GEA_THREE_AUDIO_DIR", value, MAX_PATH);
+    if (n > 0 && n < MAX_PATH) {
+      geaAudioAssetDirectory = value;
+    } else {
+      wchar_t module[MAX_PATH] = {};
+      const DWORD length = GetModuleFileNameW(nullptr, module, MAX_PATH);
+      std::wstring directory(module, length < MAX_PATH ? length : 0);
+      const size_t slash = directory.find_last_of(L"\\/");
+      if (slash != std::wstring::npos) geaAudioAssetDirectory = directory.substr(0, slash) + L"\\Resources\\Sounds";
+    }
+  }
+  return geaAudioAssetDirectory;
 }
 #endif
 
@@ -427,7 +452,7 @@ struct GeaAudioEngine {
   long loadBufferFile(const std::string &name) {
     if (name.empty() || name.find('/') != std::string::npos || name.find("..") != std::string::npos) return 0;
 #if defined(_WIN32)
-    if (name.find('\\') != std::string::npos || geaAudioAssetDirectory.empty()) return 0;
+    if (name.find('\\') != std::string::npos || geaAudioDirectory().empty()) return 0;
     const int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, name.data(), static_cast<int>(name.size()), nullptr, 0);
     if (length <= 0) return 0;
     std::wstring base(static_cast<size_t>(length), L'\0');