@geastack/native-webgl-angle 0.1.11 → 0.1.13

package/native/angle_webgl_host.mm

@@ -1,15 +1,22 @@
+#include "webgl_readback.h"
+// 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
 #include <windows.h>
-#else
+// Legacy Win16 macros are not C++ identifiers and must not leak into the runtime.
+#undef near
+#undef far
+#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.
@@ -168,7 +175,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) {
@@ -185,7 +192,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
 
@@ -406,6 +413,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 *);
@@ -439,7 +450,22 @@ using PFNGLVERTEXATTRIBDIVISORPROC = void (*)(GLuint, GLuint);
 using PFNGLVERTEXATTRIBPOINTERPROC = void (*)(GLuint, GLint, GLenum, GLboolean, GLsizei, const void *);
 using PFNGLVIEWPORTPROC = void (*)(GLint, GLint, GLsizei, GLsizei);
 
+using PFNGLCOPYTEXIMAGE2DPROC=void(*)(GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLsizei,GLint);
+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;
+  PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer = nullptr;
+  PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glRenderbufferStorageMultisample = nullptr;
   void *egl = nullptr;
   void *gles = nullptr;
   EGLDisplay display = EGL_NO_DISPLAY;
@@ -521,6 +547,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;
@@ -535,6 +567,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;
@@ -567,7 +605,7 @@ struct AngleWebGLState {
   PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer = nullptr;
   PFNGLVIEWPORTPROC glViewport = nullptr;
 
-#if defined(_WIN32)
+#if !defined(__APPLE__)
   void *nativeWindow = nullptr;
 #else
   NSView *hostView = nil;
@@ -580,6 +618,7 @@ struct AngleWebGLState {
 };
 
 static AngleWebGLState gWebGL;
+static GLenum hostReadbackError = 0;
 static std::chrono::steady_clock::time_point gProfileSizeSync;
 static bool gProfileSizeSyncPending = false;
 static bool nativeFrameProfileEnabled() {
@@ -604,7 +643,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);
@@ -618,8 +657,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);
@@ -640,7 +684,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;
@@ -683,9 +727,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));
@@ -784,7 +835,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;
@@ -857,13 +908,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;
@@ -894,7 +945,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.
@@ -908,7 +959,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) {
@@ -1016,6 +1067,15 @@ 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)
+  LOAD_GL(glRenderbufferStorageMultisample, PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)
   LOAD_GL(glRenderbufferStorage, PFNGLRENDERBUFFERSTORAGEPROC)
   LOAD_GL(glScissor, PFNGLSCISSORPROC)
   LOAD_GL(glShaderSource, PFNGLSHADERSOURCEPROC)
@@ -1030,6 +1090,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)
@@ -1065,7 +1129,7 @@ static bool loadGlSymbols() {
   return true;
 }
 
-#if defined(_WIN32)
+#if !defined(__APPLE__)
 extern "C" bool gea_three_webgl_attach_uwp(
   void *nativeWindow,
 #else
@@ -1080,7 +1144,13 @@ extern "C" bool gea_three_webgl_attach(
   smokeLog("[three-angle-metal] WebGL host attach requested");
   if (gWebGL.ready) return true;
 
-#if defined(_WIN32)
+#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 (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 {
@@ -1097,7 +1167,7 @@ extern "C" bool gea_three_webgl_attach(
   };
   gWebGL.egl = openWin32(L"GEA_ANGLE_EGL_DYLIB", L"libEGL.dll");
   gWebGL.gles = openWin32(L"GEA_ANGLE_GLES_DYLIB", L"libGLESv2.dll");
-#else
+#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",
@@ -1115,6 +1185,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");
@@ -1192,7 +1264,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) {
@@ -1258,7 +1330,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);
@@ -1374,7 +1446,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) {
@@ -1407,6 +1479,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.
@@ -1417,7 +1499,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")) {
@@ -1466,7 +1548,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;
@@ -2259,7 +2341,7 @@ extern "C" void gea_three_webgl_draw_arrays_instanced(double mode, double first,
   geaTrapCheck("gea_three_webgl_draw_arrays_instanced"); GEA_WEBGL_VOID("drawArraysInstanced");
   gWebGL.glDrawArraysInstanced(asGLenum(mode), asGLint(first), asGLsizei(count), asGLsizei(instanceCount)); }
 extern "C" double gea_three_webgl_get_error() {
-  geaTrapCheck("gea_three_webgl_get_error"); GEA_WEBGL_DOUBLE("getError"); return gWebGL.glGetError(); }
+  geaTrapCheck("gea_three_webgl_get_error"); GEA_WEBGL_DOUBLE("getError"); if (hostReadbackError) { const GLenum e = hostReadbackError; hostReadbackError = 0; return e; } return gWebGL.glGetError(); }
 
 extern "C" double gea_three_webgl_call(
   double opValue,
@@ -2481,6 +2563,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);
@@ -2771,3 +2883,135 @@ extern "C" double gea_three_webgl_call_f32(
   }
   return 0.0;
 }
+
+extern "C" void gea_three_webgl_read_pixels_bytes(double x, double y, double width, double height,
+    double format, double type, void* bytes, double byteLength, double elementType) {
+  GEA_WEBGL_VOID("readPixels");
+  GLint alignment = 4, rowLength = 0, skipRows = 0, skipPixels = 0, packBuffer = 0;
+  gWebGL.glGetIntegerv(0x0D05, &alignment);
+  gWebGL.glGetIntegerv(0x0D02, &rowLength);
+  gWebGL.glGetIntegerv(0x0D03, &skipRows);
+  gWebGL.glGetIntegerv(0x0D04, &skipPixels);
+  gWebGL.glGetIntegerv(0x88ED, &packBuffer);
+  GLenum error = gea_webgl::validateReadPixels(width,height,format,type,byteLength,elementType,alignment,rowLength,skipRows,skipPixels);
+  if (packBuffer || (!bytes && width > 0 && height > 0)) error = 0x0502;
+  if (!std::isfinite(x) || !std::isfinite(y) || x < INT32_MIN || x > INT32_MAX || y < INT32_MIN || y > INT32_MAX) error = 0x0501;
+  if (error) { if (!hostReadbackError) hostReadbackError = error; return; }
+  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));
+}
+extern "C" void gea_three_webgl_renderbuffer_storage_multisample(double target,double samples,double format,double width,double height) {
+  GEA_WEBGL_VOID("renderbufferStorageMultisample");
+  gWebGL.glRenderbufferStorageMultisample(asGLenum(target),asGLsizei(samples),asGLenum(format),asGLsizei(width),asGLsizei(height));
+}
+
+extern "C" void gea_three_webgl_copy_tex_image_2d(double target,double level,double format,double x,double y,double w,double h,double border){
+ GEA_WEBGL_VOID("copyTexImage2D");gWebGL.glCopyTexImage2D(asGLenum(target),asGLint(level),asGLenum(format),asGLint(x),asGLint(y),asGLsizei(w),asGLsizei(h),asGLint(border));
+}
+extern "C" void gea_three_webgl_copy_tex_sub_image_2d(double target,double level,double xo,double yo,double x,double y,double w,double h){
+ GEA_WEBGL_VOID("copyTexSubImage2D");gWebGL.glCopyTexSubImage2D(asGLenum(target),asGLint(level),asGLint(xo),asGLint(yo),asGLint(x),asGLint(y),asGLsizei(w),asGLsizei(h));
+}

package/native/webgl_readback.h

@@ -0,0 +1,29 @@
+#pragma once
+#include <cmath>
+#include <cstdint>
+#include <limits>
+
+namespace gea_webgl {
+// Calculate the complete destination window, including WebGL2 pack layout.
+// Return a GL error before the driver can touch an undersized typed array.
+inline unsigned validateReadPixels(double width, double height, double format, double type,
+    double bytes, double elementType, int alignment, int rowLength, int skipRows, int skipPixels) {
+  if (!std::isfinite(width) || !std::isfinite(height) || width < 0 || height < 0 ||
+      width > INT32_MAX || height > INT32_MAX || std::floor(width) != width || std::floor(height) != height) return 0x0501;
+  if (format != 0x1908 || (type != 0x1401 && type != 0x1406 && type != 0x140B)) return 0x0502;
+  if (elementType != type && !(type == 0x140B && elementType == 0x1403)) return 0x0502;
+  if (bytes < 0 || !std::isfinite(bytes)) return 0x0501;
+  if (width == 0 || height == 0) return 0;
+  if (alignment != 1 && alignment != 2 && alignment != 4 && alignment != 8) return 0x0502;
+  if (rowLength < 0 || skipRows < 0 || skipPixels < 0) return 0x0502;
+  const uint64_t pixel = type == 0x1406 ? 16 : type == 0x140B ? 8 : 4;
+  const uint64_t row = rowLength ? rowLength : static_cast<uint64_t>(width);
+  if (row < static_cast<uint64_t>(width) + skipPixels) return 0x0502;
+  const uint64_t pitch = (row*pixel + alignment-1)/alignment*alignment;
+  const uint64_t rows = static_cast<uint64_t>(height)-1+skipRows;
+  if (rows && pitch > UINT64_MAX/rows) return 0x0502;
+  const uint64_t tail = (static_cast<uint64_t>(skipPixels)+static_cast<uint64_t>(width))*pixel;
+  if (rows*pitch > UINT64_MAX-tail) return 0x0502;
+  return static_cast<long double>(rows*pitch+tail) <= bytes ? 0 : 0x0502;
+}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geastack/native-webgl-angle",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Typed native WebGL compatibility layer backed by ANGLE/Metal",
   "license": "Apache-2.0",
   "repository": {
@@ -20,6 +20,7 @@
     "./nativeThreeUtils": "./src/nativeThreeUtils.ts",
     "./nativeWebXRManager": "./src/nativeWebXRManager.ts",
     "./troika-three-text": "./src/troika-three-text.ts",
+    "./inflate": "./src/inflate.ts",
     "./geatsc-plugin": "./geatsc-plugin.mjs",
     "./native/*": "./native/*",
     "./package.json": "./package.json",
@@ -38,7 +39,8 @@
     "geatsc-plugin-instancing.mjs",
     "geatsc-plugin-batched-probe.mjs",
     "test/batched-render-scene.ts",
-    "test/auto-instanced-render-scene.ts"
+    "test/auto-instanced-render-scene.ts",
+    "geatsc-plugin-readback.mjs"
   ],
   "publishConfig": {
     "access": "public",
@@ -53,16 +55,16 @@
     "test:package": "node --experimental-vm-modules test/package.test.mjs"
   },
   "dependencies": {
-    "@geastack/apple": "^0.2.14"
+    "@geastack/apple": "^0.2.15"
   },
   "peerDependencies": {
     "three": "^0.185.0",
-    "@geastack/compiler": "^1.0.22"
+    "@geastack/compiler": "^1.0.29"
   },
   "devDependencies": {
-    "@geastack/compiler": "^1.0.22",
-    "@geastack/core": "^0.1.37",
-    "@geastack/engine": "^0.1.13",
+    "@geastack/compiler": "^1.0.29",
+    "@geastack/core": "^0.1.40",
+    "@geastack/engine": "^0.1.16",
     "@types/three": "^0.185.0",
     "three": "^0.185.0",
     "troika-three-text": "^0.52.4",