webgl2 1.1.18 → 1.2.0

package/coverage.md

@@ -9,42 +9,43 @@
 | src/decompiler/lifter.rs | 17 | 21 | 38 | 44.74% 🟠 |
 | src/decompiler/mod.rs | 8 | 6 | 14 | 57.14% 🟡 |
 | src/decompiler/module.rs | 1 | 1 | 2 | 50.00% 🟡 |
-| src/decompiler/parser.rs | 16 | 2 | 18 | 88.89% 🟢 |
-| src/decompiler/simplifier.rs | 56 | 18 | 74 | 75.68% 🟡 |
+| src/decompiler/parser.rs | 17 | 2 | 19 | 89.47% 🟢 |
+| src/decompiler/simplifier.rs | 53 | 19 | 72 | 73.61% 🟡 |
 | src/error.rs | 7 | 15 | 22 | 31.82% 🟠 |
-| src/lib.rs | 308 | 196 | 504 | 61.11% 🟡 |
-| src/naga_wasm_backend/backend.rs | 54 | 1 | 55 | 98.18% 🟢 |
-| src/naga_wasm_backend/call_lowering.rs | 17 | 0 | 17 | 100.00% 🟢 |
-| src/naga_wasm_backend/control_flow.rs | 29 | 15 | 44 | 65.91% 🟡 |
-| src/naga_wasm_backend/debug/stub.rs | 21 | 0 | 21 | 100.00% 🟢 |
-| src/naga_wasm_backend/expressions.rs | 55 | 16 | 71 | 77.46% 🟡 |
-| src/naga_wasm_backend/function_abi.rs | 23 | 0 | 23 | 100.00% 🟢 |
+| src/lib.rs | 315 | 210 | 525 | 60.00% 🟡 |
+| src/naga_wasm_backend/backend.rs | 62 | 2 | 64 | 96.88% 🟢 |
+| src/naga_wasm_backend/call_lowering.rs | 18 | 0 | 18 | 100.00% 🟢 |
+| src/naga_wasm_backend/control_flow.rs | 54 | 16 | 70 | 77.14% 🟡 |
+| src/naga_wasm_backend/debug/stub.rs | 20 | 0 | 20 | 100.00% 🟢 |
+| src/naga_wasm_backend/expressions.rs | 65 | 105 | 170 | 38.24% 🟠 |
+| src/naga_wasm_backend/function_abi.rs | 22 | 0 | 22 | 100.00% 🟢 |
 | src/naga_wasm_backend/functions/prep.rs | 4 | 0 | 4 | 100.00% 🟢 |
-| src/naga_wasm_backend/functions/registry.rs | 4 | 0 | 4 | 100.00% 🟢 |
+| src/naga_wasm_backend/functions/registry.rs | 4 | 1 | 5 | 80.00% 🟢 |
+| src/naga_wasm_backend/memory_layout.rs | 9 | 0 | 9 | 100.00% 🟢 |
 | src/naga_wasm_backend/output_layout.rs | 2 | 2 | 4 | 50.00% 🟡 |
 | src/naga_wasm_backend/types.rs | 11 | 0 | 11 | 100.00% 🟢 |
-| src/wasm_gl_emu/framebuffer.rs | 2 | 0 | 2 | 100.00% 🟢 |
-| src/wasm_gl_emu/rasterizer.rs | 36 | 13 | 49 | 73.47% 🟡 |
+| src/wasm_gl_emu/framebuffer.rs | 1 | 0 | 1 | 100.00% 🟢 |
+| src/wasm_gl_emu/rasterizer.rs | 26 | 18 | 44 | 59.09% 🟡 |
 | src/webgl2_context/blend.rs | 2 | 1 | 3 | 66.67% 🟡 |
 | src/webgl2_context/buffers.rs | 18 | 1 | 19 | 94.74% 🟢 |
-| src/webgl2_context/drawing.rs | 32 | 6 | 38 | 84.21% 🟢 |
+| src/webgl2_context/drawing.rs | 26 | 3 | 29 | 89.66% 🟢 |
 | src/webgl2_context/framebuffers.rs | 10 | 0 | 10 | 100.00% 🟢 |
-| src/webgl2_context/registry.rs | 6 | 0 | 6 | 100.00% 🟢 |
-| src/webgl2_context/renderbuffers.rs | 12 | 0 | 12 | 100.00% 🟢 |
-| src/webgl2_context/shaders.rs | 109 | 14 | 123 | 88.62% 🟢 |
-| src/webgl2_context/state.rs | 21 | 1 | 22 | 95.45% 🟢 |
-| src/webgl2_context/textures.rs | 23 | 9 | 32 | 71.88% 🟡 |
-| src/webgl2_context/types.rs | 10 | 1 | 11 | 90.91% 🟢 |
-| src/webgl2_context/vaos.rs | 36 | 0 | 36 | 100.00% 🟢 |
+| src/webgl2_context/registry.rs | 7 | 0 | 7 | 100.00% 🟢 |
+| src/webgl2_context/renderbuffers.rs | 11 | 0 | 11 | 100.00% 🟢 |
+| src/webgl2_context/shaders.rs | 113 | 12 | 125 | 90.40% 🟢 |
+| src/webgl2_context/state.rs | 23 | 1 | 24 | 95.83% 🟢 |
+| src/webgl2_context/textures.rs | 28 | 17 | 45 | 62.22% 🟡 |
+| src/webgl2_context/types.rs | 15 | 1 | 16 | 93.75% 🟢 |
+| src/webgl2_context/vaos.rs | 35 | 0 | 35 | 100.00% 🟢 |
 | src/webgpu/adapter.rs | 3 | 0 | 3 | 100.00% 🟢 |
-| src/webgpu/backend.rs | 25 | 25 | 50 | 50.00% 🟡 |
-| **Total** | **995** | **373** | **1368** | **72.73% 🟡** |
+| src/webgpu/backend.rs | 25 | 27 | 52 | 48.08% 🟠 |
+| **Total** | **1049** | **490** | **1539** | **68.16% 🟡** |
 
 ## Top Missed Files
 
 | File | Lines Missed | Illustrative Line | Coverage |
 |---|---|---|---:|
-| src/lib.rs | 196/504 | [1040] `// ---- GLSL Decompiler Support (docs/11.b-decompile-theo...` | 61.11% 🟡 |
-| src/webgpu/backend.rs | 25/50 | [943] `}` | 50.00% 🟡 |
+| src/lib.rs | 210/525 | [1040] `/// Get active attribute info.` | 60.00% 🟡 |
+| src/naga_wasm_backend/expressions.rs | 105/170 | [1504] `for j in 0..count {` | 38.24% 🟠 |
+| src/webgpu/backend.rs | 27/52 | [965] `}` | 48.08% 🟠 |
 | src/decompiler/lifter.rs | 21/38 | [455] `fn unary_op(&mut self, op: UnaryOp) {` | 44.74% 🟠 |
-| src/decompiler/simplifier.rs | 18/74 | [115] `let get_const = |id: &Id| egraph[*id].data.constant;` | 75.68% 🟡 |

package/daebug.md

@@ -1,14 +1,13 @@
-# 👾 Daebug remote debugging REPL: SERVER SHUT DOWN 23:15:36
-> This debugging session has concluded.
+# 👾 Daebug remote debugging REPL started 22:13:58
+> Interactive debugging REPL sessions for live browser contexts
 
-The REPL server has been shut down. Total uptime was from 23:13:45 to 23:15:36.
+This file tracks all active debugging sessions. Each entry represents a connected page or web worker where you can execute JavaScript code and see results in real-time.
 
 
-To begin a new debugging session:
+## Active Sessions
 
-```
-npm start
-```
+* [18-quartz-2214-06-webworker](daebug/18-quartz-2214-06-webworker.md) (worker://18-quartz-2214-06-webworker) at 22:14:06: live
+* [18-quartz-2214-06](daebug/18-quartz-2214-06.md) (http://localhost:8907/) at 22:14:06: live
 
 
 ## How to Use

package/index.js

@@ -221,10 +221,10 @@ async function initWASM({ debug } = {}) {
         const bytes = mem.subarray(ptr, ptr + len);
         console.log(new TextDecoder('utf-8').decode(bytes));
       },
-      wasm_execute_shader: (ctx, type, attrPtr, uniformPtr, varyingPtr, privatePtr, texturePtr) => {
+      wasm_execute_shader: (ctx, type, tableIdx, attrPtr, uniformPtr, varyingPtr, privatePtr, texturePtr) => {
         const gl = WasmWebGL2RenderingContext._contexts.get(ctx);
         if (gl) {
-          gl._executeShader(type, attrPtr, uniformPtr, varyingPtr, privatePtr, texturePtr);
+          gl._executeShader(type, tableIdx, attrPtr, uniformPtr, varyingPtr, privatePtr, texturePtr);
         } else {
           // console.log(`DEBUG: wasm_execute_shader: ctx ${ctx} not found in _contexts`);
         }
@@ -243,6 +243,20 @@ async function initWASM({ debug } = {}) {
       now: () => {
         return performance.now();
       }
+    },
+    math: {
+      sin: Math.sin,
+      cos: Math.cos,
+      tan: Math.tan,
+      asin: Math.asin,
+      acos: Math.acos,
+      atan: Math.atan,
+      atan2: Math.atan2,
+      exp: Math.exp,
+      exp2: (x) => Math.pow(2, x),
+      log: Math.log,
+      log2: Math.log2,
+      pow: Math.pow
     }
   };
   instance = await WebAssembly.instantiate(wasmModule, importObject);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webgl2",
-  "version": "1.1.18",
+  "version": "1.2.0",
   "description": "WebGL2 tools to derisk large GPU projects on the web beyond toys and demos.",
   "type": "module",
   "main": "index.js",

package/src/webgl2_context.js

@@ -25,6 +25,7 @@ export class WasmWebGL2RenderingContext {
   FRAGMENT_SHADER = 0x8B30;
   VERTEX_SHADER = 0x8B31;
   TRIANGLES = 0x0004;
+  TRIANGLE_STRIP = 0x0005;
   COLOR_BUFFER_BIT = 0x00004000;
   DEPTH_BUFFER_BIT = 0x00000100;
   DEPTH_TEST = 0x0B71;
@@ -44,7 +45,6 @@ export class WasmWebGL2RenderingContext {
   INT = 0x1404;
   UNSIGNED_INT = 0x1405;
   FLOAT = 0x1406;
-  RGBA = 0x1908;
   FLOAT_VEC2 = 0x8B50;
   FLOAT_VEC3 = 0x8B51;
   FLOAT_VEC4 = 0x8B52;
@@ -59,6 +59,7 @@ export class WasmWebGL2RenderingContext {
   FLOAT_MAT3 = 0x8B5B;
   FLOAT_MAT4 = 0x8B5C;
   SAMPLER_2D = 0x8B5E;
+  SAMPLER_3D = 0x8B5F;
   SAMPLER_CUBE = 0x8B60;
   ACTIVE_UNIFORMS = 0x8B86;
   ACTIVE_ATTRIBUTES = 0x8B89;
@@ -141,10 +142,18 @@ export class WasmWebGL2RenderingContext {
   FRONT_AND_BACK = 0x0408;
 
   TEXTURE_2D = 0x0DE1;
+  TEXTURE_3D = 0x806F;
+  TEXTURE_2D_ARRAY = 0x8C1A;
   TEXTURE_WRAP_S = 0x2802;
   TEXTURE_WRAP_T = 0x2803;
+  TEXTURE_WRAP_R = 0x8072;
   TEXTURE_MAG_FILTER = 0x2800;
   TEXTURE_MIN_FILTER = 0x2801;
+  RGBA = 0x1908;
+  RED = 0x1903;
+  RG = 0x8227;
+  UNSIGNED_BYTE = 0x1401;
+  FLOAT = 0x1406;
   NEAREST = 0x2600;
   LINEAR = 0x2601;
   NEAREST_MIPMAP_NEAREST = 0x2700;
@@ -212,14 +221,23 @@ export class WasmWebGL2RenderingContext {
   /** @type {Map<number, WasmWebGL2RenderingContext>} */
   static _contexts = new Map();
 
-  _executeShader(type, attrPtr, uniformPtr, varyingPtr, privatePtr, texturePtr) {
+  _executeShader(type, tableIdx, attrPtr, uniformPtr, varyingPtr, privatePtr, texturePtr) {
     if (!this._currentProgram) {
       return;
     }
+
+    if (tableIdx > 0 && this._sharedTable) {
+      const func = this._sharedTable.get(tableIdx);
+      if (func) {
+        func(this._ctxHandle, type, tableIdx, attrPtr, uniformPtr, varyingPtr, privatePtr, texturePtr);
+        return;
+      }
+    }
+
     const shaderInstance = type === this.VERTEX_SHADER ? this._currentProgram._vsInstance : this._currentProgram._fsInstance;
     if (shaderInstance && shaderInstance.exports.main) {
       // @ts-ignore
-      shaderInstance.exports.main(type, attrPtr, uniformPtr, varyingPtr, privatePtr, texturePtr);
+      shaderInstance.exports.main(this._ctxHandle, type, tableIdx, attrPtr, uniformPtr, varyingPtr, privatePtr, texturePtr);
     }
   }
 
@@ -292,8 +310,13 @@ export class WasmWebGL2RenderingContext {
     }
 
     let data = pixels;
-    if (!data) data = new Uint8Array(width * height * 4);
-    else if (!(data instanceof Uint8Array)) data = new Uint8Array(data);
+    if (!data) {
+      data = new Uint8Array(width * height * 4);
+    } else if (ArrayBuffer.isView(data)) {
+      data = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    } else if (data instanceof ArrayBuffer) {
+      data = new Uint8Array(data);
+    }
 
     const len = data.length;
     const ptr = ex.wasm_alloc(len);
@@ -328,6 +351,56 @@ export class WasmWebGL2RenderingContext {
     }
   }
 
+  texImage3D(target, level, internalFormat, width, height, depth, border, format, type_, pixels) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_tex_image_3d !== 'function') {
+      throw new Error('wasm_ctx_tex_image_3d not found');
+    }
+
+    let data = pixels;
+    if (!data) {
+      data = new Uint8Array(width * height * depth * 4);
+    } else if (ArrayBuffer.isView(data)) {
+      data = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    } else if (data instanceof ArrayBuffer) {
+      data = new Uint8Array(data);
+    }
+
+    const len = data.length;
+    const ptr = ex.wasm_alloc(len);
+    if (ptr === 0) throw new Error('Failed to allocate memory for pixel data');
+
+    try {
+      const mem = new Uint8Array(ex.memory.buffer);
+      mem.set(data, ptr);
+
+      const code = ex.wasm_ctx_tex_image_3d(
+        this._ctxHandle,
+        target >>> 0,
+        level >>> 0,
+        internalFormat >>> 0,
+        width >>> 0,
+        height >>> 0,
+        depth >>> 0,
+        border >>> 0,
+        format >>> 0,
+        type_ >>> 0,
+        ptr >>> 0,
+        len >>> 0
+      );
+      _checkErr(code, this._instance);
+
+      // Mirror texture data in JS for fast texel fetches by shader imports
+      this._textureData = this._textureData || new Map();
+      const handle = this._boundTexture || 0;
+      const copy = new Uint8Array(mem.slice(ptr, ptr + len));
+      this._textureData.set(handle, { width: width >>> 0, height: height >>> 0, depth: depth >>> 0, data: copy });
+    } finally {
+      ex.wasm_free(ptr);
+    }
+  }
+
   copyTexImage2D(target, level, internalFormat, x, y, width, height, border) {
     this._assertNotDestroyed();
     const ex = this._instance.exports;
@@ -478,9 +551,18 @@ export class WasmWebGL2RenderingContext {
       throw new Error('wasm_ctx_read_pixels not found');
     }
 
-    const len = width * height * 4;
-    if (!out || out.length < len) {
-      throw new Error(`output buffer too small (need ${len}, have ${out ? out.length : 0})`);
+    let bpp = 4;
+    if (type_ === 0x1406) { // GL_FLOAT
+      if (format === 0x1908) bpp = 16;      // GL_RGBA
+      else if (format === 0x8227) bpp = 8;  // GL_RG
+      else if (format === 0x1903) bpp = 4;  // GL_RED
+    } else if (type_ === 0x1401) { // GL_UNSIGNED_BYTE
+      if (format === 0x1908) bpp = 4;
+    }
+
+    const len = width * height * bpp;
+    if (!out || out.byteLength < len) {
+      throw new Error(`output buffer too small (need ${len} bytes, have ${out ? out.byteLength : 0})`);
     }
 
     const ptr = ex.wasm_alloc(len);
@@ -489,8 +571,8 @@ export class WasmWebGL2RenderingContext {
     try {
       const code = ex.wasm_ctx_read_pixels(
         this._ctxHandle,
-        x >>> 0,
-        y >>> 0,
+        x | 0,
+        y | 0,
         width >>> 0,
         height >>> 0,
         format >>> 0,
@@ -502,7 +584,8 @@ export class WasmWebGL2RenderingContext {
 
       const mem = new Uint8Array(ex.memory.buffer);
       const src = mem.subarray(ptr, ptr + len);
-      out.set(src);
+      const out_bytes = new Uint8Array(out.buffer, out.byteOffset, len);
+      out_bytes.set(src);
     } finally {
       ex.wasm_free(ptr);
     }
@@ -708,9 +791,6 @@ export class WasmWebGL2RenderingContext {
     _checkErr(code, this._instance);
 
     // After linking, we need to instantiate the WASM modules on the host.
-    // According to the WebGL 2.0 Spec (https://registry.khronos.org/webgl/specs/latest/2.0/#3.7.6),
-    // linkProgram sets the LINK_STATUS parameter. If linking fails, no executable is generated.
-    // We must check LINK_STATUS before attempting to instantiate the WASM, as getProgramWasm will return null.
     if (program && typeof program === 'object') {
       const linkStatus = this.getProgramParameter(program, this.LINK_STATUS);
       if (linkStatus) {
@@ -723,6 +803,10 @@ export class WasmWebGL2RenderingContext {
     const vsWasm = this.getProgramWasm(program, this.VERTEX_SHADER);
     const fsWasm = this.getProgramWasm(program, this.FRAGMENT_SHADER);
 
+    if (!vsWasm || !fsWasm) {
+      return;
+    }
+
     // Allocate table slots for both shaders
     const vsIdx = this._tableAllocator ? this._tableAllocator.allocate() : null;
     const fsIdx = this._tableAllocator ? this._tableAllocator.allocate() : null;
@@ -749,7 +833,6 @@ export class WasmWebGL2RenderingContext {
       return {
         debug_step: (line, funcIdx, resultPtr) => {
           if (line === 999999) {
-            console.log(`DEBUG LOG: val=${funcIdx} (0x${(funcIdx >>> 0).toString(16)})`);
             return;
           }
           const func = stubFuncs[line - 1];
@@ -775,13 +858,26 @@ export class WasmWebGL2RenderingContext {
     const vsInstanceRef = { current: null };
     const vsDebugEnv = createDebugEnv(this.VERTEX_SHADER, vsInstanceRef);
 
+    const env = {
+      memory: this._instance.exports.memory,
+      __indirect_function_table: this._sharedTable,
+      ...vsDebugEnv
+    };
 
-    program._vsInstance = new WebAssembly.Instance(vsModule, {
-      env: {
-        memory: this._instance.exports.memory,
-        __indirect_function_table: this._sharedTable,
-        ...vsDebugEnv
+    // Add math builtins from renderer (skipping host)
+    const mathFuncs = [
+      'gl_sin', 'gl_cos', 'gl_tan', 'gl_asin', 'gl_acos', 'gl_atan', 'gl_atan2',
+      'gl_exp', 'gl_exp2', 'gl_log', 'gl_log2', 'gl_pow',
+      'gl_sinh', 'gl_cosh', 'gl_tanh', 'gl_asinh', 'gl_acosh', 'gl_atanh'
+    ];
+    for (const name of mathFuncs) {
+      if (this._instance.exports[name]) {
+        env[name] = this._instance.exports[name];
       }
+    }
+
+    program._vsInstance = new WebAssembly.Instance(vsModule, {
+      env
     });
     vsInstanceRef.current = program._vsInstance;
 
@@ -796,13 +892,20 @@ export class WasmWebGL2RenderingContext {
     const fsInstanceRef = { current: null };
     const fsDebugEnv = createDebugEnv(this.FRAGMENT_SHADER, fsInstanceRef);
 
+    const fsEnv = {
+      memory: this._instance.exports.memory,
+      __indirect_function_table: this._sharedTable,
+      ...fsDebugEnv
+    };
 
-    program._fsInstance = new WebAssembly.Instance(fsModule, {
-      env: {
-        memory: this._instance.exports.memory,
-        __indirect_function_table: this._sharedTable,
-        ...fsDebugEnv
+    for (const name of mathFuncs) {
+      if (this._instance.exports[name]) {
+        fsEnv[name] = this._instance.exports[name];
       }
+    }
+
+    program._fsInstance = new WebAssembly.Instance(fsModule, {
+      env: fsEnv
     });
     fsInstanceRef.current = program._fsInstance;
 
@@ -879,7 +982,7 @@ export class WasmWebGL2RenderingContext {
       throw new Error('wasm_ctx_delete_program not found');
     }
     const programHandle = program && typeof program === 'object' && typeof program._handle === 'number' ? program._handle : (program >>> 0);
-    
+
     // Free table indices
     if (program && typeof program === 'object') {
       if (program._vsTableIndex !== undefined && this._tableAllocator) {
@@ -889,7 +992,7 @@ export class WasmWebGL2RenderingContext {
         this._tableAllocator.free(program._fsTableIndex);
       }
     }
-    
+
     const code = ex.wasm_ctx_delete_program(this._ctxHandle, programHandle);
     _checkErr(code, this._instance);
     if (program && typeof program === 'object') {
@@ -1087,6 +1190,7 @@ export class WasmWebGL2RenderingContext {
       stride >>> 0,
       offset >>> 0
     );
+    if (code === 5) return; // ERR_GL
     _checkErr(code, this._instance);
   }
 
@@ -1104,6 +1208,7 @@ export class WasmWebGL2RenderingContext {
       stride >>> 0,
       offset >>> 0
     );
+    if (code === 5) return; // ERR_GL
     _checkErr(code, this._instance);
   }
 
@@ -1282,6 +1387,12 @@ export class WasmWebGL2RenderingContext {
     }
 
     const len = bytes.length;
+    if (len === 0) {
+      const code = ex.wasm_ctx_buffer_data(this._ctxHandle, target >>> 0, 0, 0, usage >>> 0);
+      _checkErr(code, this._instance);
+      return;
+    }
+
     const ptr = ex.wasm_alloc(len);
     if (ptr === 0) throw new Error('Failed to allocate memory for bufferData');
 
@@ -1508,7 +1619,49 @@ export class WasmWebGL2RenderingContext {
     _checkErr(code, this._instance);
   }
   copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height) { this._assertNotDestroyed(); throw new Error('not implemented'); }
-  texImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels) { this._assertNotDestroyed(); throw new Error('not implemented'); }
+  texSubImage2D(target, level, xoffset, yoffset, width, height, format, type_, pixels) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_tex_sub_image_2d !== 'function') {
+      throw new Error('wasm_ctx_tex_sub_image_2d not found');
+    }
+
+    let data = pixels;
+    if (!data) return; // No-op if no data provided
+    if (!(data instanceof Uint8Array)) {
+      if (ArrayBuffer.isView(data)) {
+        data = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+      } else {
+        data = new Uint8Array(data);
+      }
+    }
+
+    const len = data.length;
+    const ptr = ex.wasm_alloc(len);
+    if (ptr === 0) throw new Error('Failed to allocate memory for sub-pixel data');
+
+    try {
+      const mem = new Uint8Array(ex.memory.buffer);
+      mem.set(data, ptr);
+
+      const code = ex.wasm_ctx_tex_sub_image_2d(
+        this._ctxHandle,
+        target >>> 0,
+        level >>> 0,
+        xoffset | 0,
+        yoffset | 0,
+        width >>> 0,
+        height >>> 0,
+        format >>> 0,
+        type_ >>> 0,
+        ptr >>> 0,
+        len >>> 0
+      );
+      _checkErr(code, this._instance);
+    } finally {
+      ex.wasm_free(ptr);
+    }
+  }
 
   checkFramebufferStatus(target) { this._assertNotDestroyed(); throw new Error('not implemented'); }
   blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter) { this._assertNotDestroyed(); throw new Error('not implemented'); }