@geastack/native-webgl-angle 0.1.12 → 0.1.14

package/native/win32_webgl_surface.cpp

@@ -0,0 +1,230 @@
+// SPDX-License-Identifier: Apache-2.0
+// The WebGL surface of a Windows desktop build: a child window filling the
+// main window's content area, which the native WebGL host renders into, and
+// the input the host reports to the program.
+//
+// It plugs into the Windows target as a host extension (gea_win32_host.h):
+// the target attaches it before the program's top level runs -- the program
+// creates its WebGL context while it initializes -- and brackets the
+// initialization and every frame with begin/end, which is when the host's
+// EGL context is current. Keys reach the host as macOS virtual key codes, the
+// code space the program's key polling uses on every platform; pointer
+// positions are in CSS pixels of the surface.
+#include "gea_win32_host.h"
+
+#include <windowsx.h>
+
+#include <algorithm>
+#include <cstdio>
+#include <cstdlib>
+
+extern "C" bool gea_three_webgl_attach_uwp(void *nativeWindow, double width, double height, double devicePixelRatio);
+extern "C" void gea_three_webgl_update_size_uwp(double width, double height, double devicePixelRatio);
+extern "C" bool gea_three_webgl_begin_frame_uwp();
+extern "C" void gea_three_webgl_end_frame_uwp();
+extern "C" void gea_three_set_key_state(int code, bool down);
+extern "C" void gea_three_set_pointer_state(double x, double y, double width, double height, bool down);
+
+namespace {
+
+HWND gSurface = nullptr;
+HWND gMainWindow = nullptr;
+double gScale = 1.0;
+bool gPointerDown = false;
+// The program polls key state once per frame, so a tap whose key-down and
+// key-up both arrive between two frames would never be seen. A release waits
+// here until a frame has run with the key down.
+bool gReleasePending[256] = {};
+
+// macOS virtual key codes (Carbon kVK_*), for the keys a game typically polls.
+int macKeyCode(WPARAM vk)
+{
+	switch (vk) {
+	case VK_LEFT: return 123;
+	case VK_RIGHT: return 124;
+	case VK_DOWN: return 125;
+	case VK_UP: return 126;
+	case VK_SPACE: return 49;
+	case VK_RETURN: return 36;
+	case VK_ESCAPE: return 53;
+	case VK_TAB: return 48;
+	case VK_BACK: return 51;
+	case VK_DELETE: return 117;
+	case VK_HOME: return 115;
+	case VK_END: return 119;
+	case VK_PRIOR: return 116;
+	case VK_NEXT: return 121;
+	case VK_SHIFT: case VK_LSHIFT: return 56;
+	case VK_RSHIFT: return 60;
+	case VK_CONTROL: case VK_LCONTROL: return 59;
+	case VK_RCONTROL: return 62;
+	case VK_MENU: case VK_LMENU: return 58;
+	case VK_RMENU: return 61;
+	case VK_OEM_MINUS: return 27;
+	case VK_OEM_PLUS: return 24;
+	case VK_OEM_COMMA: return 43;
+	case VK_OEM_PERIOD: return 47;
+	case VK_OEM_1: return 41;   // ;
+	case VK_OEM_2: return 44;   // /
+	case VK_OEM_3: return 50;   // `
+	case VK_OEM_4: return 33;   // [
+	case VK_OEM_5: return 42;   // backslash
+	case VK_OEM_6: return 30;   // ]
+	case VK_OEM_7: return 39;   // '
+	default: break;
+	}
+	static const int letters[26] = {0, 11, 8, 2, 14, 3, 5, 4, 34, 38, 40, 37, 46, 45, 31, 35, 12, 15, 1, 17, 32, 9, 13, 7, 16, 6};
+	if (vk >= 'A' && vk <= 'Z') return letters[vk - 'A'];
+	static const int digits[10] = {29, 18, 19, 20, 21, 23, 22, 26, 28, 25};
+	if (vk >= '0' && vk <= '9') return digits[vk - '0'];
+	static const int functions[12] = {122, 120, 99, 118, 96, 97, 98, 100, 101, 109, 103, 111};
+	if (vk >= VK_F1 && vk <= VK_F12) return functions[vk - VK_F1];
+	return -1;
+}
+
+void releaseAllKeys()
+{
+	for (int code = 0; code < 256; ++code) {
+		gReleasePending[code] = false;
+		gea_three_set_key_state(code, false);
+	}
+}
+
+void reportPointer(LPARAM lParam)
+{
+	RECT client{};
+	GetClientRect(gSurface, &client);
+	gea_three_set_pointer_state(GET_X_LPARAM(lParam) / gScale, GET_Y_LPARAM(lParam) / gScale, std::max<LONG>(1, client.right) / gScale,
+	                            std::max<LONG>(1, client.bottom) / gScale, gPointerDown);
+}
+
+LRESULT CALLBACK surfaceProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	switch (message) {
+	case WM_KEYDOWN:
+	case WM_SYSKEYDOWN:
+		if (message == WM_SYSKEYDOWN && wParam == VK_F4) break;  // Alt+F4 closes the window
+		if (const int code = macKeyCode(wParam); code >= 0) {
+			gReleasePending[code] = false;
+			gea_three_set_key_state(code, true);
+		}
+		return 0;  // no menu activation on Alt or F10
+	case WM_KEYUP:
+	case WM_SYSKEYUP:
+		if (const int code = macKeyCode(wParam); code >= 0) gReleasePending[code] = true;
+		return 0;
+	case WM_SYSCHAR:
+		return 0;  // no beep for Alt+key
+	case WM_KILLFOCUS:
+		gPointerDown = false;
+		ReleaseCapture();
+		releaseAllKeys();
+		return 0;
+	case WM_LBUTTONDOWN:
+		SetFocus(hwnd);
+		gPointerDown = true;
+		SetCapture(hwnd);
+		reportPointer(lParam);
+		return 0;
+	case WM_LBUTTONUP:
+		gPointerDown = false;
+		ReleaseCapture();
+		reportPointer(lParam);
+		return 0;
+	case WM_MOUSEMOVE:
+		reportPointer(lParam);
+		return 0;
+	case WM_ERASEBKGND:
+		return 1;  // the swap chain owns every pixel
+	case WM_PAINT:
+		ValidateRect(hwnd, nullptr);
+		return 0;
+	default:
+		break;
+	}
+	return DefWindowProcW(hwnd, message, wParam, lParam);
+}
+
+int attach(HWND window, RECT area, double scale)
+{
+	gMainWindow = window;
+	gScale = scale > 0 ? scale : 1.0;
+	HINSTANCE instance = GetModuleHandleW(nullptr);
+	WNDCLASSEXW cls{};
+	cls.cbSize = sizeof(cls);
+	cls.style = CS_OWNDC | CS_DBLCLKS;
+	cls.lpfnWndProc = surfaceProc;
+	cls.hInstance = instance;
+	cls.hCursor = LoadCursorW(nullptr, IDC_ARROW);
+	cls.lpszClassName = L"GeaWebGLSurface";
+	RegisterClassExW(&cls);
+	// The main window must not paint over its swap-chain child.
+	SetWindowLongPtrW(window, GWL_STYLE, GetWindowLongPtrW(window, GWL_STYLE) | WS_CLIPCHILDREN);
+	const int width = std::max<int>(1, area.right - area.left);
+	const int height = std::max<int>(1, area.bottom - area.top);
+	gSurface = CreateWindowExW(0, cls.lpszClassName, L"", WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS, area.left, area.top, width, height, window, nullptr,
+	                           instance, nullptr);
+	if (!gSurface) {
+		std::fprintf(stderr, "[native-webgl-angle] could not create the surface window (error %lu)\n", GetLastError());
+		return 0;
+	}
+	SetWindowPos(gSurface, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+	// Present with vsync unless the environment says otherwise.
+	if (!std::getenv("GEA_ANGLE_SWAP_INTERVAL")) _putenv_s("GEA_ANGLE_SWAP_INTERVAL", "1");
+	if (!gea_three_webgl_attach_uwp(gSurface, width, height, gScale)) {
+		std::fprintf(stderr, "[native-webgl-angle] the WebGL surface could not start: no usable EGL/OpenGL ES implementation\n");
+		return 0;
+	}
+	// eglSwapBuffers paces the loop: it waits for the refresh with vsync on and
+	// renders unthrottled with it off (GEA_ANGLE_SWAP_INTERVAL=0).
+	gea_win32_set_frame_pacing(GEA_WIN32_FRAME_PACING_PRESENT);
+	SetFocus(gSurface);
+	return 1;
+}
+
+void layout(RECT area, double scale)
+{
+	if (!gSurface) return;
+	gScale = scale > 0 ? scale : 1.0;
+	const int width = std::max<int>(1, area.right - area.left);
+	const int height = std::max<int>(1, area.bottom - area.top);
+	SetWindowPos(gSurface, nullptr, area.left, area.top, width, height, SWP_NOZORDER | SWP_NOACTIVATE);
+	gea_three_webgl_update_size_uwp(width, height, gScale);
+}
+
+int beginFrame() { return gea_three_webgl_begin_frame_uwp() ? 1 : 0; }
+
+void endFrame()
+{
+	gea_three_webgl_end_frame_uwp();
+	for (int code = 0; code < 256; ++code) {
+		if (!gReleasePending[code]) continue;
+		gReleasePending[code] = false;
+		gea_three_set_key_state(code, false);
+	}
+}
+
+int windowMessage(HWND, UINT message, WPARAM, LPARAM, LRESULT *result)
+{
+	// Activating the main window gives it the keyboard focus; the surface is
+	// where keys are read.
+	if (message == WM_SETFOCUS && gSurface) {
+		SetFocus(gSurface);
+		*result = 0;
+		return 1;
+	}
+	return 0;
+}
+
+void detach()
+{
+	if (gSurface) DestroyWindow(gSurface);
+	gSurface = nullptr;
+}
+
+const gea_win32_host_extension kSurfaceExtension = {
+	GEA_WIN32_HOST_EXTENSION_VERSION, "The WebGL surface", attach, layout, beginFrame, endFrame, windowMessage, detach,
+};
+const bool kRegistered = (gea_win32_register_host_extension(&kSurfaceExtension), true);
+
+}  // namespace

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geastack/native-webgl-angle",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Typed native WebGL compatibility layer backed by ANGLE/Metal",
   "license": "Apache-2.0",
   "repository": {
@@ -28,7 +28,8 @@
     "./text/native-text-types": "./src/text/native-text-types.ts",
     "./geatsc-plugin-batched-probe": "./geatsc-plugin-batched-probe.mjs",
     "./test/batched-render-scene": "./test/batched-render-scene.ts",
-    "./test/auto-instanced-render-scene": "./test/auto-instanced-render-scene.ts"
+    "./test/auto-instanced-render-scene": "./test/auto-instanced-render-scene.ts",
+    "./gea-native.json": "./gea-native.json"
   },
   "files": [
     "src",
@@ -40,7 +41,8 @@
     "geatsc-plugin-batched-probe.mjs",
     "test/batched-render-scene.ts",
     "test/auto-instanced-render-scene.ts",
-    "geatsc-plugin-readback.mjs"
+    "geatsc-plugin-readback.mjs",
+    "gea-native.json"
   ],
   "publishConfig": {
     "access": "public",
@@ -51,7 +53,7 @@
     "test:host-effects": "node test/native-host-effects-contract.test.mjs",
     "test:allocation-contracts": "node test/render-sort-contract.test.mjs && node test/upload-array-contract.test.mjs && node test/draw-dispatch-contract.test.mjs && node test/native-upload-transport.test.mjs && node test/fixed-uniform-contract.test.mjs && node test/uniform-binding-contract.test.mjs && node test/buffer-streaming-contract.test.mjs",
     "check": "tsc -p tsconfig.json --noEmit",
-    "test": "node test/native-blending-contract.test.mjs && node test/native-transform-contract.test.mjs && node test/troika-three-text.test.mjs && node test/typed-void-contract.test.mjs && node test/instancing-transport-contract.test.mjs && node test/automatic-instancing-contract.test.mjs && node test/jsdoc-fold-contract.test.mjs",
+    "test": "node test/native-blending-contract.test.mjs && node test/native-transform-contract.test.mjs && node test/troika-three-text.test.mjs && node test/typed-void-contract.test.mjs && node test/instancing-transport-contract.test.mjs && node test/automatic-instancing-contract.test.mjs && node test/jsdoc-fold-contract.test.mjs && node test/gea-native-declaration.test.mjs",
     "test:package": "node --experimental-vm-modules test/package.test.mjs"
   },
   "dependencies": {

package/src/inflate.ts

@@ -18,7 +18,7 @@ const codeLengthOrder = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4,
 // native build narrows a function's integer locals to machine integers, but a
 // class's number fields stay doubles, and on a core without a double FPU (the
 // ESP32-S31) every bit read through a field was several soft-float calls --
-// inflating skytail's kit at boot took over 80 seconds.
+// inflating a game's asset kit at boot took over 80 seconds.
 
 /** Decoder state: read position, bit buffer, bits held, bytes written. */
 const position = 0

package/src/nativeWebGL.ts

@@ -1,4 +1,6 @@
+/** @gea-host-inert Reads scalar arguments, writes GL state only; never calls back into script. */
 declare function threeWebGLCopyTexImage2D(target:number,level:number,internalFormat:number,x:number,y:number,width:number,height:number,border:number):void;
+/** @gea-host-inert Reads scalar arguments, writes GL state only; never calls back into script. */
 declare function threeWebGLCopyTexSubImage2D(target:number,level:number,xoffset:number,yoffset:number,x:number,y:number,width:number,height:number):void;
 /// <reference path="./gea-native-types.d.ts" />
 
@@ -93,6 +95,7 @@ type NativeHandleKind =
   | 'program'
   | 'renderbuffer'
   | 'shader'
+  | 'sync'
   | 'texture'
   | 'uniform'
   | 'vertexArray'
@@ -200,11 +203,26 @@ function typedArrayKind(value: BufferSourceLike): number {
   return 1
 }
 
+/** @gea-host-inert Reads scalar arguments, writes GL state only; never calls back into script. */
 declare function threeWebGLBlitFramebuffer(sx0:number, sy0:number, sx1:number, sy1:number, dx0:number, dy0:number, dx1:number, dy1:number, mask:number, filter:number): void
+/** @gea-host-inert Reads scalar arguments, writes GL state only; never calls back into script. */
 declare function threeWebGLRenderbufferStorageMultisample(target:number, samples:number, format:number, width:number, height:number): void
 type ReadPixelsDestination = Uint8Array | Uint16Array | Float32Array | Uint32Array | Int32Array | Int16Array | Int8Array
 // Mutates the destination view; deliberately not marked host-inert.
+/** @gea-host-typed-array-element-writes Stores pixels into the destination typed array's elements only; no other property of any object, no callbacks. */
 declare function threeWebGLReadPixels(x: number, y: number, width: number, height: number, format: number, type: number, destination: ReadPixelsDestination, offset: number): void
+// WebGL2 asynchronous readback: into the bound PIXEL_PACK_BUFFER, fenced, then read through getBufferSubData.
+/** @gea-host-inert Reads scalar arguments, writes GL state only; never calls back into script. */
+declare function threeWebGLReadPixelsPack(x: number, y: number, width: number, height: number, format: number, type: number, offset: number): void
+/** @gea-host-inert Creates a GL sync object; never calls back into script. */
+declare function threeWebGLFenceSync(): number
+/** @gea-host-inert Reads scalar arguments, waits on GL state only; never calls back into script. */
+declare function threeWebGLClientWaitSync(sync: number, flags: number, timeout: number): number
+/** @gea-host-inert Reads scalar arguments, writes GL state only; never calls back into script. */
+declare function threeWebGLDeleteSync(sync: number): void
+// Mutates the destination view; deliberately not marked host-inert.
+/** @gea-host-typed-array-element-writes Stores buffer bytes into the destination typed array's elements only; no other property of any object, no callbacks. */
+declare function threeWebGLGetBufferSubData(target: number, srcByteOffset: number, destination: ReadPixelsDestination, dstOffset: number, length: number): void
 
 function zeroF32Array(length: number): f32[] {
   const out: f32[] = []
@@ -254,6 +272,14 @@ declare function threeWebGLTexImage2D(target: number, level: number, internalFor
 declare function threeWebGLTexSubImage2D(target: number, level: number, xoffset: number, yoffset: number, width: number, height: number, format: number, type: number, values: BufferSourceLike): void
 /** @gea-host-inert Reads its arguments, writes GL state only; never calls back into script. */
 declare function threeWebGLTexStorage2D(target: number, levels: number, internalFormat: number, width: number, height: number): void
+/** @gea-host-inert Reads its arguments, writes GL state only; never calls back into script. */
+declare function threeWebGLTexImage3D(target: number, level: number, internalFormat: number, width: number, height: number, depth: number, format: number, type: number, values: BufferSourceLike): void
+/** @gea-host-inert Reads its arguments, writes GL state only; never calls back into script. */
+declare function threeWebGLTexSubImage3D(target: number, level: number, xoffset: number, yoffset: number, zoffset: number, width: number, height: number, depth: number, format: number, type: number, values: BufferSourceLike): void
+/** @gea-host-inert Reads its arguments, writes GL state only; never calls back into script. */
+declare function threeWebGLTexStorage3D(target: number, levels: number, internalFormat: number, width: number, height: number, depth: number): void
+/** @gea-host-inert Reads its arguments, writes GL state only; never calls back into script. */
+declare function threeWebGLFramebufferTextureLayer(target: number, attachment: number, texture: number, level: number, layer: number): void
 
 // Shader source keyed by the stable native GL handle. A NativeShader instance
 // can be value-copied when it round-trips through a function-return / gcv
@@ -663,6 +689,10 @@ export class NativeWebGL2RenderingContext {
   readonly TIMEOUT_EXPIRED = 0x911B
   readonly CONDITION_SATISFIED = 0x911C
   readonly WAIT_FAILED = 0x911D
+  readonly SYNC_GPU_COMMANDS_COMPLETE = 0x9117
+  readonly PIXEL_PACK_BUFFER = 0x88EB
+  readonly PIXEL_PACK_BUFFER_BINDING = 0x88ED
+  readonly STREAM_READ = 0x88E1
   readonly COLOR = 0x1800
   readonly DEPTH_COMPONENT = 0x1902
   readonly ALPHA = 0x1906
@@ -935,11 +965,14 @@ export class NativeWebGL2RenderingContext {
     if (name === this.MAX_RENDERBUFFER_SIZE || name === this.MAX_3D_TEXTURE_SIZE) return 16384
     if (name === this.MAX_ARRAY_TEXTURE_LAYERS) return 2048
     if (name === this.MAX_VERTEX_ATTRIBS) return 16
-    if (name === this.MAX_TEXTURE_IMAGE_UNITS || name === this.MAX_VERTEX_TEXTURE_IMAGE_UNITS) return 16
+    // threejs-rendozer binds up to 32 textures per program (both stages); three checks a program's total against this.
+    if (name === this.MAX_TEXTURE_IMAGE_UNITS || name === this.MAX_VERTEX_TEXTURE_IMAGE_UNITS) return 32
     if (name === this.MAX_COMBINED_TEXTURE_IMAGE_UNITS) return 32
     if (name === this.MAX_VERTEX_UNIFORM_VECTORS || name === this.MAX_FRAGMENT_UNIFORM_VECTORS) return 1024
     if (name === this.MAX_VARYING_VECTORS) return 32
-    if (name === this.MAX_SAMPLES || name === this.SAMPLES) return 4
+    // threejs-rendozer reports 8 when every multisampled renderbuffer format supports it (and steps down per format).
+    if (name === this.MAX_SAMPLES) return 8
+    if (name === this.SAMPLES) return 4
     if (name === this.MAX_UNIFORM_BUFFER_BINDINGS) return 24
     if (name === this.DEPTH_BITS) return 24
     if (name === this.STENCIL_BITS) return 8
@@ -1106,10 +1139,10 @@ export class NativeWebGL2RenderingContext {
   texImage2D(target: number, level: number, internalFormat: number, widthOrFormat: number, heightOrType: number, borderOrSource?: number | NativeTextureImage | null, format?: number, type?: number, pixels?: BufferSourceLike | null): void {
     if (typeof borderOrSource === 'number' && typeof format === 'number' && typeof type === 'number') {
       threeWebGLTexImage2D(target, level, internalFormat, widthOrFormat, heightOrType, format, type, pixels ?? new Uint8Array(0))
-    } else if (borderOrSource && typeof borderOrSource !== 'number') {
+    } else if (borderOrSource !== null && borderOrSource !== undefined && typeof borderOrSource !== 'number') {
       threeWebGLTexImage2D(target, level, internalFormat, borderOrSource.width, borderOrSource.height, widthOrFormat, heightOrType, borderOrSource.data)
     } else {
-      throw new Error('Native texImage2D requires dimensions and typed pixels, or a decoded NativeTextureImage')
+      throw new Error(`Native texImage2D requires dimensions and typed pixels, or a decoded NativeTextureImage (target ${target}, level ${level}, internal format ${internalFormat}, source ${borderOrSource === null ? 'null' : typeof borderOrSource})`)
     }
   }
   texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, width: number, height: number, format: number, type: number, pixels: BufferSourceLike): void {
@@ -1125,9 +1158,15 @@ export class NativeWebGL2RenderingContext {
   // Three uploads 3D and array textures only from typed `image.data` /
   // `mipmap.data` (or `null` to allocate), the same carrier the 2D uploads
   // take; no TexImageSource ever reaches these entry points.
-  texImage3D(_target: number, _level: number, _internalFormat: number, _width: number, _height: number, _depth: number, _border: number, _format: number, _type: number, _source: BufferSourceLike | null): void {}
-  texSubImage3D(_target: number, _level: number, _xoffset: number, _yoffset: number, _zoffset: number, _width: number, _height: number, _depth: number, _format: number, _type: number, _source: BufferSourceLike): void {}
-  texStorage3D(_target: number, _levels: number, _internalFormat: number, _width: number, _height: number, _depth: number): void {}
+  texImage3D(target: number, level: number, internalFormat: number, width: number, height: number, depth: number, _border: number, format: number, type: number, source: BufferSourceLike | null): void {
+    threeWebGLTexImage3D(target, level, internalFormat, width, height, depth, format, type, source ?? new Uint8Array(0))
+  }
+  texSubImage3D(target: number, level: number, xoffset: number, yoffset: number, zoffset: number, width: number, height: number, depth: number, format: number, type: number, source: BufferSourceLike): void {
+    threeWebGLTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, source)
+  }
+  texStorage3D(target: number, levels: number, internalFormat: number, width: number, height: number, depth: number): void {
+    threeWebGLTexStorage3D(target, levels, internalFormat, width, height, depth)
+  }
 
   createVertexArray(): NativeHandle { return createHandle('vertexArray', nativeWebGLCreateVertexArray()) }
   bindVertexArray(vertexArray: NativeHandle | null): void { nativeWebGLBindVertexArray(nullableNativeHandle(vertexArray)) }
@@ -1150,7 +1189,9 @@ export class NativeWebGL2RenderingContext {
   framebufferRenderbuffer(target: number, attachment: number, renderbuffertarget: number, renderbuffer: NativeHandle | null): void {
     nativeWebGLFramebufferRenderbuffer(target, attachment, renderbuffertarget, nullableNativeHandle(renderbuffer))
   }
-  framebufferTextureLayer(_target: number, _attachment: number, _texture: NativeHandle | null, _level: number, _layer: number): void {}
+  framebufferTextureLayer(target: number, attachment: number, texture: NativeHandle | null, level: number, layer: number): void {
+    threeWebGLFramebufferTextureLayer(target, attachment, nullableNativeHandle(texture), level, layer)
+  }
   drawBuffers(buffers: number[]): void { nativeWebGLDrawBuffers(buffers[0] ?? this.COLOR_ATTACHMENT0) }
 
   clearColor(r: number, g: number, b: number, a: number): void { nativeWebGLClearColor(r, g, b, a) }
@@ -1193,7 +1234,13 @@ export class NativeWebGL2RenderingContext {
   invalidateFramebuffer(_target: number, _attachments: BufferSourceLike): void {}
   blitFramebuffer(sx0:number, sy0:number, sx1:number, sy1:number, dx0:number, dy0:number, dx1:number, dy1:number, mask:number, filter:number): void { threeWebGLBlitFramebuffer(sx0,sy0,sx1,sy1,dx0,dy0,dx1,dy1,mask,filter) }
   readBuffer(_src: number): void {}
-  readPixels(x: number, y: number, width: number, height: number, format: number, type: number, destination: ReadPixelsDestination, offset = 0): void {
+  // WebGL2 also reads into the bound PIXEL_PACK_BUFFER at a byte offset (three's
+  // readRenderTargetPixelsAsync): the GPU copy is recorded without waiting for the GPU.
+  readPixels(x: number, y: number, width: number, height: number, format: number, type: number, destination: ReadPixelsDestination | number, offset = 0): void {
+    if (typeof destination === 'number') {
+      threeWebGLReadPixelsPack(x, y, width, height, format, type, destination)
+      return
+    }
     threeWebGLReadPixels(x, y, width, height, format, type, destination, offset)
   }
   copyTexImage2D(target: number, level: number, internalFormat: number, x: number, y: number, width: number, height: number, border: number): void {threeWebGLCopyTexImage2D(target,level,internalFormat,x,y,width,height,border);}
@@ -1202,7 +1249,9 @@ export class NativeWebGL2RenderingContext {
   clearBufferiv(_buffer: number, _drawbuffer: number, _values: BufferSourceLike): void {}
   clearBufferuiv(_buffer: number, _drawbuffer: number, _values: BufferSourceLike): void {}
   getBufferParameter(_target: number, _pname: number): number { return 0 }
-  getBufferSubData(_target: number, _srcByteOffset: number, _destination: unknown): void {}
+  getBufferSubData(target: number, srcByteOffset: number, destination: ReadPixelsDestination, dstOffset = 0, length = 0): void {
+    threeWebGLGetBufferSubData(target, srcByteOffset, destination, dstOffset, length)
+  }
   getFramebufferAttachmentParameter(_target: number, _attachment: number, _pname: number): number { return 0 }
   getRenderbufferParameter(_target: number, _pname: number): number { return 0 }
   getTexParameter(_target: number, _pname: number): number { return 0 }
@@ -1213,9 +1262,14 @@ export class NativeWebGL2RenderingContext {
   uniformBlockBinding(_program: NativeProgram | null, _uniformBlockIndex: number, _uniformBlockBinding: number): void {}
   bindBufferBase(_target: number, _index: number, _buffer: NativeHandle | null): void {}
   bindBufferRange(_target: number, _index: number, _buffer: NativeHandle | null, _offset: number, _size: number): void {}
-  fenceSync(_condition: number, _flags: number): null { return null }
-  clientWaitSync(_sync: NativeHandle | null, _flags: number, _timeout: number): number { return 0 }
-  deleteSync(_sync: NativeHandle | null): void {}
+  fenceSync(_condition: number, _flags: number): NativeHandle | null {
+    const sync = threeWebGLFenceSync()
+    return sync ? createHandle('sync', sync) : null
+  }
+  clientWaitSync(sync: NativeHandle | null, flags: number, timeout: number): number {
+    return sync ? threeWebGLClientWaitSync(nativeHandle(sync), flags, timeout) : this.WAIT_FAILED
+  }
+  deleteSync(sync: NativeHandle | null): void { if (sync) threeWebGLDeleteSync(nativeHandle(sync)) }
   isBuffer(_buffer: NativeHandle | null): boolean { return true }
   isFramebuffer(_framebuffer: NativeHandle | null): boolean { return true }
   isProgram(_program: NativeProgram | null): boolean { return true }

package/src/nativeWebGLHost.ts

@@ -35,6 +35,25 @@ export function nativeWebGLSwap(): void {
   threeWebGLSwap()
 }
 
+// GPU time-elapsed timers (GL_EXT_disjoint_timer_query): begin returns a timer id (0 when
+// unsupported), end closes the open timer, and result is the elapsed nanoseconds, or -1 while the
+// GPU has not finished it. A timer is released once its result has been read.
+export function nativeWebGLTimerBegin(): number {
+  return threeWebGLTimerBegin()
+}
+export function nativeWebGLTimerEnd(): void {
+  threeWebGLTimerEnd()
+}
+export function nativeWebGLTimerResult(timer: number): number {
+  return threeWebGLTimerResult(timer)
+}
+/** @gea-host-inert Native state only; retains no script references and invokes no script. */
+declare function threeWebGLTimerBegin(): number
+/** @gea-host-inert Native state only; retains no script references and invokes no script. */
+declare function threeWebGLTimerEnd(): void
+/** @gea-host-inert Native state only; retains no script references and invokes no script. */
+declare function threeWebGLTimerResult(timer: number): number
+
 export function logNativeWebGL(message: string): void {
   threeAngleSmokeLog(message)
 }