webgl2 1.3.0 → 1.3.2

package/coverage.md

@@ -4,50 +4,52 @@
 
 | File | Lines Covered | Lines Missed | Total Lines | Coverage |
 |---|---|---|---|---:|
-| src/coverage.rs | 12 | 5 | 17 | 70.59% 🟡 |
-| src/decompiler/ast.rs | 3 | 2 | 5 | 60.00% 🟡 |
-| src/decompiler/emitter.rs | 6 | 0 | 6 | 100.00% 🟢 |
-| src/decompiler/lifter.rs | 10 | 1 | 11 | 90.91% 🟢 |
-| src/decompiler/module.rs | 1 | 0 | 1 | 100.00% 🟢 |
-| src/decompiler/parser.rs | 15 | 5 | 20 | 75.00% 🟡 |
-| src/decompiler/simplifier.rs | 35 | 6 | 41 | 85.37% 🟢 |
-| src/error.rs | 34 | 7 | 41 | 82.93% 🟢 |
-| src/lib.rs | 183 | 310 | 493 | 37.12% 🟠 |
-| src/naga_wasm_backend/backend.rs | 161 | 29 | 190 | 84.74% 🟢 |
-| src/naga_wasm_backend/call_lowering.rs | 10 | 5 | 15 | 66.67% 🟡 |
-| src/naga_wasm_backend/control_flow.rs | 37 | 30 | 67 | 55.22% 🟡 |
+| src/coverage.rs | 11 | 5 | 16 | 68.75% 🟡 |
+| src/decompiler/ast.rs | 3 | 5 | 8 | 37.50% 🟠 |
+| src/decompiler/emitter.rs | 30 | 3 | 33 | 90.91% 🟢 |
+| src/decompiler/lifter.rs | 6 | 2 | 8 | 75.00% 🟡 |
+| src/decompiler/parser.rs | 2 | 1 | 3 | 66.67% 🟡 |
+| src/decompiler/simplifier.rs | 35 | 2 | 37 | 94.59% 🟢 |
+| src/error.rs | 32 | 5 | 37 | 86.49% 🟢 |
+| src/lib.rs | 144 | 305 | 449 | 32.07% 🟠 |
+| src/naga_wasm_backend/backend.rs | 154 | 28 | 182 | 84.62% 🟢 |
+| src/naga_wasm_backend/call_lowering.rs | 9 | 3 | 12 | 75.00% 🟡 |
+| src/naga_wasm_backend/control_flow.rs | 38 | 29 | 67 | 56.72% 🟡 |
 | src/naga_wasm_backend/debug/stub.rs | 11 | 15 | 26 | 42.31% 🟠 |
-| src/naga_wasm_backend/expressions.rs | 255 | 152 | 407 | 62.65% 🟡 |
-| src/naga_wasm_backend/function_abi.rs | 14 | 5 | 19 | 73.68% 🟡 |
-| src/naga_wasm_backend/functions/prep.rs | 8 | 0 | 8 | 100.00% 🟢 |
-| src/naga_wasm_backend/functions/registry.rs | 1 | 0 | 1 | 100.00% 🟢 |
-| src/naga_wasm_backend/memory_layout.rs | 12 | 0 | 12 | 100.00% 🟢 |
-| src/naga_wasm_backend/mod.rs | 9 | 1 | 10 | 90.00% 🟢 |
-| src/naga_wasm_backend/output_layout.rs | 7 | 2 | 9 | 77.78% 🟡 |
-| src/naga_wasm_backend/types.rs | 14 | 6 | 20 | 70.00% 🟡 |
+| src/naga_wasm_backend/expressions.rs | 255 | 149 | 404 | 63.12% 🟡 |
+| src/naga_wasm_backend/function_abi.rs | 19 | 5 | 24 | 79.17% 🟡 |
+| src/naga_wasm_backend/functions/prep.rs | 5 | 0 | 5 | 100.00% 🟢 |
+| src/naga_wasm_backend/functions/registry.rs | 6 | 0 | 6 | 100.00% 🟢 |
+| src/naga_wasm_backend/memory_layout.rs | 15 | 1 | 16 | 93.75% 🟢 |
+| src/naga_wasm_backend/mod.rs | 7 | 0 | 7 | 100.00% 🟢 |
+| src/naga_wasm_backend/output_layout.rs | 5 | 0 | 5 | 100.00% 🟢 |
+| src/naga_wasm_backend/types.rs | 22 | 5 | 27 | 81.48% 🟢 |
+| src/wasm_gl_emu/device.rs | 3 | 2 | 5 | 60.00% 🟡 |
 | src/wasm_gl_emu/framebuffer.rs | 1 | 0 | 1 | 100.00% 🟢 |
-| src/wasm_gl_emu/rasterizer.rs | 38 | 26 | 64 | 59.38% 🟡 |
-| src/wasm_gl_emu/transfer.rs | 1 | 0 | 1 | 100.00% 🟢 |
-| src/webgl2_context/blend.rs | 6 | 0 | 6 | 100.00% 🟢 |
-| src/webgl2_context/buffers.rs | 15 | 1 | 16 | 93.75% 🟢 |
-| src/webgl2_context/drawing.rs | 31 | 1 | 32 | 96.88% 🟢 |
-| src/webgl2_context/registry.rs | 13 | 1 | 14 | 92.86% 🟢 |
-| src/webgl2_context/shaders.rs | 147 | 21 | 168 | 87.50% 🟢 |
-| src/webgl2_context/state.rs | 15 | 16 | 31 | 48.39% 🟠 |
-| src/webgl2_context/textures.rs | 52 | 0 | 52 | 100.00% 🟢 |
-| src/webgl2_context/types.rs | 24 | 9 | 33 | 72.73% 🟡 |
-| src/webgpu/adapter.rs | 13 | 6 | 19 | 68.42% 🟡 |
-| src/webgpu/backend.rs | 72 | 9 | 81 | 88.89% 🟢 |
-| src/webgpu/buffer.rs | 0 | 3 | 3 | 0.00% 🟡 |
-| src/webgpu/command.rs | 23 | 4 | 27 | 85.19% 🟢 |
-| src/webgpu/pipeline.rs | 1 | 0 | 1 | 100.00% 🟢 |
-| **Total** | **1290** | **678** | **1968** | **65.55% 🟡** |
+| src/wasm_gl_emu/rasterizer.rs | 17 | 41 | 58 | 29.31% 🟠 |
+| src/wasm_gl_emu/transfer.rs | 0 | 2 | 2 | 0.00% 🟡 |
+| src/webgl2_context/buffers.rs | 14 | 0 | 14 | 100.00% 🟢 |
+| src/webgl2_context/drawing.rs | 30 | 0 | 30 | 100.00% 🟢 |
+| src/webgl2_context/ephemeral.rs | 3 | 0 | 3 | 100.00% 🟢 |
+| src/webgl2_context/registry.rs | 10 | 0 | 10 | 100.00% 🟢 |
+| src/webgl2_context/shaders.rs | 141 | 27 | 168 | 83.93% 🟢 |
+| src/webgl2_context/state.rs | 2 | 0 | 2 | 100.00% 🟢 |
+| src/webgl2_context/textures.rs | 59 | 0 | 59 | 100.00% 🟢 |
+| src/webgl2_context/types.rs | 46 | 17 | 63 | 73.02% 🟡 |
+| src/webgpu/adapter.rs | 5 | 0 | 5 | 100.00% 🟢 |
+| src/webgpu/backend.rs | 61 | 21 | 82 | 74.39% 🟡 |
+| src/webgpu/bind_group.rs | 3 | 0 | 3 | 100.00% 🟢 |
+| src/webgpu/buffer.rs | 1 | 2 | 3 | 33.33% 🟡 |
+| src/webgpu/command.rs | 7 | 5 | 12 | 58.33% 🟡 |
+| src/webgpu/shader.rs | 1 | 0 | 1 | 100.00% 🟢 |
+| src/webgpu/texture.rs | 8 | 4 | 12 | 66.67% 🟡 |
+| **Total** | **1221** | **684** | **1905** | **64.09% 🟡** |
 
 ## Top Missed Files
 
 | File | Lines Missed | Illustrative Line | Coverage |
 |---|---|---|---:|
-| src/lib.rs | 310/493 | [1996] `}` | 37.12% 🟠 |
-| src/naga_wasm_backend/expressions.rs | 152/407 | [1845] `translate_expression_component(*arg, j, ctx)?;` | 62.65% 🟡 |
-| src/naga_wasm_backend/control_flow.rs | 30/67 | [488] `if let Some(ret) = &called_func.result {` | 55.22% 🟡 |
-| src/naga_wasm_backend/backend.rs | 29/190 | [469] `func.instruction(&Instruction::F32Div);` | 84.74% 🟢 |
+| src/lib.rs | 305/449 | [1994] `depth_write_enabled: u32,` | 32.07% 🟠 |
+| src/naga_wasm_backend/expressions.rs | 149/404 | [910] `if let Some(handle) = found_global {` | 63.12% 🟡 |
+| src/wasm_gl_emu/rasterizer.rs | 41/58 | [370] `match eq {` | 29.31% 🟠 |
+| src/naga_wasm_backend/control_flow.rs | 29/67 | [489] `let types = super::types::naga_to_wasm_types(` | 56.72% 🟡 |

package/index.js

@@ -366,16 +366,23 @@ async function initWASM({ debug } = {}) {
  */
 function _readErrorMessage(instance) {
   const ex = instance.exports;
-  if (!ex || typeof ex.wasm_last_error_ptr !== 'function' || typeof ex.wasm_last_error_len !== 'function') {
+  if (!ex || typeof ex.wasm_last_error !== 'function') {
+    if (typeof ex.wasm_last_error_ptr === 'function') {
+      const ptr = ex.wasm_last_error_ptr();
+      const len = ex.wasm_last_error_len();
+      if (ptr === 0 || len === 0) return '';
+      const mem = new Uint8Array(ex.memory.buffer);
+      const bytes = mem.subarray(ptr, ptr + len);
+      return new TextDecoder('utf-8').decode(bytes);
+    }
     return '(no error message available)';
   }
-  const ptr = ex.wasm_last_error_ptr();
-  const len = ex.wasm_last_error_len();
-  if (ptr === 0 || len === 0) {
-    return '';
-  }
+  const ptr = ex.wasm_last_error();
+  if (ptr === 0) return '';
+  const dv = new DataView(ex.memory.buffer);
+  const len = dv.getUint32(ptr - 16, true);
   const mem = new Uint8Array(ex.memory.buffer);
-  const bytes = mem.subarray(ptr, ptr + len);
+  const bytes = mem.slice(ptr, ptr + len);
   return new TextDecoder('utf-8').decode(bytes);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webgl2",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "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

@@ -709,48 +709,31 @@ export class WasmWebGL2RenderingContext {
       throw new Error('wasm_ctx_read_pixels not found');
     }
 
-    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_ === 0x1405 || type_ === 0x1404) { // GL_UNSIGNED_INT or GL_INT
-      if (format === 0x8D9E) bpp = 16;      // GL_RGBA_INTEGER
-      else if (format === 0x8228) bpp = 8;  // GL_RG_INTEGER
-      else if (format === 0x8D94) bpp = 4;  // GL_RED_INTEGER
-    } 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_ctx_read_pixels(
+      this._ctxHandle,
+      x | 0,
+      y | 0,
+      width >>> 0,
+      height >>> 0,
+      format >>> 0,
+      type_ >>> 0
+    );
+
+    if (ptr === 0) {
+      const msg = readErrorMessage(this._instance);
+      throw new Error(`readPixels failed: ${msg}`);
     }
 
-    const ptr = ex.wasm_alloc(len);
-    if (ptr === 0) throw new Error('Failed to allocate memory for readPixels output');
+    const dv = new DataView(ex.memory.buffer);
+    const len = dv.getUint32(ptr - 16, true);
 
-    try {
-      const code = ex.wasm_ctx_read_pixels(
-        this._ctxHandle,
-        x | 0,
-        y | 0,
-        width >>> 0,
-        height >>> 0,
-        format >>> 0,
-        type_ >>> 0,
-        ptr >>> 0,
-        len >>> 0
-      );
-      _checkErr(code, this._instance);
-
-      const mem = new Uint8Array(ex.memory.buffer);
-      const src = mem.subarray(ptr, ptr + len);
-      const out_bytes = new Uint8Array(out.buffer, out.byteOffset, len);
-      out_bytes.set(src);
-    } finally {
-      ex.wasm_free(ptr);
+    if (!out || out.byteLength < len) {
+      throw new Error(`output buffer too small (need ${len} bytes, have ${out ? out.byteLength : 0})`);
     }
+
+    const src = new Uint8Array(ex.memory.buffer, ptr, len);
+    const out_bytes = new Uint8Array(out.buffer, out.byteOffset, len);
+    out_bytes.set(src);
   }
 
   // --- Stubs for unimplemented WebGL2 methods (forwarding API surface) ---
@@ -856,43 +839,18 @@ export class WasmWebGL2RenderingContext {
     }
     const programHandle = program && typeof program === 'object' && typeof program._handle === 'number' ? program._handle : (program >>> 0);
 
-    // Allocate buffers: size(4) + type(4) + name(256)
-    const sizePtr = ex.wasm_alloc(4);
-    const typePtr = ex.wasm_alloc(4);
-    const nameMaxLen = 256;
-    const namePtr = ex.wasm_alloc(nameMaxLen);
-
-    try {
-      const nameLen = ex.wasm_ctx_get_active_uniform(
-        this._ctxHandle,
-        programHandle,
-        index >>> 0,
-        sizePtr,
-        typePtr,
-        namePtr,
-        nameMaxLen
-      );
-
-      if (nameLen === 0) {
-        return null;
-      }
-
-      const mem32SizeIdx = sizePtr >>> 2;
-      const mem32TypeIdx = typePtr >>> 2;
-
-      const size = new Int32Array(ex.memory.buffer)[mem32SizeIdx];
-      const type_ = new Uint32Array(ex.memory.buffer)[mem32TypeIdx];
-
-      const nameBytes = new Uint8Array(ex.memory.buffer, namePtr, nameLen);
-      const name = new TextDecoder().decode(nameBytes);
+    const ptr = ex.wasm_ctx_get_active_uniform(this._ctxHandle, programHandle, index >>> 0);
+    if (ptr === 0) return null;
 
-      return { name, size, type: type_ };
+    const dv = new DataView(ex.memory.buffer);
+    const totalLen = dv.getUint32(ptr - 16, true);
+    const size = dv.getInt32(ptr, true);
+    const type_ = dv.getUint32(ptr + 4, true);
+    const nameLen = totalLen - 8;
+    const nameBytes = new Uint8Array(ex.memory.buffer, ptr + 8, nameLen);
+    const name = new TextDecoder('utf-8').decode(nameBytes);
 
-    } finally {
-      ex.wasm_free(sizePtr);
-      ex.wasm_free(typePtr);
-      ex.wasm_free(namePtr);
-    }
+    return { name, size, type: type_ };
   }
 
   getActiveAttrib(program, index) {
@@ -903,43 +861,18 @@ export class WasmWebGL2RenderingContext {
     }
     const programHandle = program && typeof program === 'object' && typeof program._handle === 'number' ? program._handle : (program >>> 0);
 
-    // Allocate buffers: size(4) + type(4) + name(256)
-    const sizePtr = ex.wasm_alloc(4);
-    const typePtr = ex.wasm_alloc(4);
-    const nameMaxLen = 256;
-    const namePtr = ex.wasm_alloc(nameMaxLen);
-
-    try {
-      const nameLen = ex.wasm_ctx_get_active_attrib(
-        this._ctxHandle,
-        programHandle,
-        index >>> 0,
-        sizePtr,
-        typePtr,
-        namePtr,
-        nameMaxLen
-      );
-
-      if (nameLen === 0) {
-        return null;
-      }
-
-      const mem32SizeIdx = sizePtr >>> 2;
-      const mem32TypeIdx = typePtr >>> 2;
-
-      const size = new Int32Array(ex.memory.buffer)[mem32SizeIdx];
-      const type_ = new Uint32Array(ex.memory.buffer)[mem32TypeIdx];
-
-      const nameBytes = new Uint8Array(ex.memory.buffer, namePtr, nameLen);
-      const name = new TextDecoder().decode(nameBytes);
+    const ptr = ex.wasm_ctx_get_active_attrib(this._ctxHandle, programHandle, index >>> 0);
+    if (ptr === 0) return null;
 
-      return { name, size, type: type_ };
+    const dv = new DataView(ex.memory.buffer);
+    const totalLen = dv.getUint32(ptr - 16, true);
+    const size = dv.getInt32(ptr, true);
+    const type_ = dv.getUint32(ptr + 4, true);
+    const nameLen = totalLen - 8;
+    const nameBytes = new Uint8Array(ex.memory.buffer, ptr + 8, nameLen);
+    const name = new TextDecoder('utf-8').decode(nameBytes);
 
-    } finally {
-      ex.wasm_free(sizePtr);
-      ex.wasm_free(typePtr);
-      ex.wasm_free(namePtr);
-    }
+    return { name, size, type: type_ };
   }
 
   linkProgram(program) {
@@ -1216,18 +1149,14 @@ export class WasmWebGL2RenderingContext {
     }
     const shaderHandle = shader && typeof shader === 'object' && typeof shader._handle === 'number' ? shader._handle : (shader >>> 0);
 
-    const maxLen = 1024;
-    const ptr = ex.wasm_alloc(maxLen);
-    if (ptr === 0) throw new Error('Failed to allocate memory for getShaderInfoLog');
+    const ptr = ex.wasm_ctx_get_shader_info_log(this._ctxHandle, shaderHandle);
+    if (ptr === 0) return "";
 
-    try {
-      const len = ex.wasm_ctx_get_shader_info_log(this._ctxHandle, shaderHandle, ptr, maxLen);
-      const mem = new Uint8Array(ex.memory.buffer);
-      const bytes = mem.subarray(ptr, ptr + len);
-      return new TextDecoder().decode(bytes);
-    } finally {
-      ex.wasm_free(ptr);
-    }
+    const dv = new DataView(ex.memory.buffer);
+    const len = dv.getUint32(ptr - 16, true);
+    const mem = new Uint8Array(ex.memory.buffer);
+    const bytes = mem.slice(ptr, ptr + len);
+    return new TextDecoder().decode(bytes);
   }
 
   getProgramInfoLog(program) {
@@ -1238,18 +1167,14 @@ export class WasmWebGL2RenderingContext {
     }
     const programHandle = program && typeof program === 'object' && typeof program._handle === 'number' ? program._handle : (program >>> 0);
 
-    const maxLen = 1024;
-    const ptr = ex.wasm_alloc(maxLen);
-    if (ptr === 0) throw new Error('Failed to allocate memory for getProgramInfoLog');
+    const ptr = ex.wasm_ctx_get_program_info_log(this._ctxHandle, programHandle);
+    if (ptr === 0) return "";
 
-    try {
-      const len = ex.wasm_ctx_get_program_info_log(this._ctxHandle, programHandle, ptr, maxLen);
-      const mem = new Uint8Array(ex.memory.buffer);
-      const bytes = mem.subarray(ptr, ptr + len);
-      return new TextDecoder().decode(bytes);
-    } finally {
-      ex.wasm_free(ptr);
-    }
+    const dv = new DataView(ex.memory.buffer);
+    const len = dv.getUint32(ptr - 16, true);
+    const mem = new Uint8Array(ex.memory.buffer);
+    const bytes = mem.slice(ptr, ptr + len);
+    return new TextDecoder().decode(bytes);
   }
 
   getProgramWasm(program, shaderType) {
@@ -1918,45 +1843,18 @@ export class WasmWebGL2RenderingContext {
     }
     const programHandle = program && typeof program === "object" && typeof program._handle === "number" ? program._handle : (program >>> 0);
 
-    const sizePtr = ex.wasm_alloc(4);
-    const typePtr = ex.wasm_alloc(4);
-    const nameCapacity = 256;
-    const namePtr = ex.wasm_alloc(nameCapacity);
-
-    if (sizePtr === 0 || typePtr === 0 || namePtr === 0) {
-      if (sizePtr) ex.wasm_free(sizePtr);
-      if (typePtr) ex.wasm_free(typePtr);
-      if (namePtr) ex.wasm_free(namePtr);
-      throw new Error("Failed to allocate memory for getTransformFeedbackVarying");
-    }
-
-    try {
-      const code = ex.wasm_ctx_get_transform_feedback_varying(
-        this._ctxHandle,
-        programHandle,
-        index >>> 0,
-        sizePtr,
-        typePtr,
-        namePtr,
-        nameCapacity
-      );
-      _checkErr(code, this._instance);
-
-      const mem = new DataView(ex.memory.buffer);
-      const size = mem.getInt32(sizePtr, true);
-      const type = mem.getUint32(typePtr, true);
+    const ptr = ex.wasm_ctx_get_transform_feedback_varying(this._ctxHandle, programHandle, index >>> 0);
+    if (ptr === 0) return null;
 
-      const nameBytes = new Uint8Array(ex.memory.buffer, namePtr, nameCapacity);
-      let nameLen = 0;
-      while (nameLen < nameCapacity && nameBytes[nameLen] !== 0) nameLen++;
-      const name = new TextDecoder().decode(nameBytes.subarray(0, nameLen));
+    const dv = new DataView(ex.memory.buffer);
+    const totalLen = dv.getUint32(ptr - 16, true);
+    const size = dv.getInt32(ptr, true);
+    const type = dv.getUint32(ptr + 4, true);
+    const nameLen = totalLen - 8;
+    const nameBytes = new Uint8Array(ex.memory.buffer, ptr + 8, nameLen);
+    const name = new TextDecoder('utf-8').decode(nameBytes);
 
-      return { name, size, type };
-    } finally {
-      ex.wasm_free(sizePtr);
-      ex.wasm_free(typePtr);
-      ex.wasm_free(namePtr);
-    }
+    return { name, size, type };
   }
 
   createQuery() { this._assertNotDestroyed(); throw new Error('not implemented'); }
@@ -2317,148 +2215,78 @@ export class WasmWebGL2RenderingContext {
   getParameter(pname) {
     this._assertNotDestroyed();
     const ex = this._instance.exports;
-    if (!ex || typeof ex.wasm_ctx_get_parameter_v !== 'function') {
-      throw new Error('wasm_ctx_get_parameter_v not found');
+    if (!ex || typeof ex.wasm_ctx_get_parameter !== 'function') {
+      throw new Error('wasm_ctx_get_parameter not found');
     }
 
-    if (pname === 0x0BA2 /* VIEWPORT */) {
-      const ptr = ex.wasm_alloc(16);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 16);
-        _checkErr(code, this._instance);
-        const mem = new Int32Array(ex.memory.buffer, ptr, 4);
-        return new Int32Array(mem);
-      } finally {
-        ex.wasm_free(ptr, 16);
-      }
+    const ptr = ex.wasm_ctx_get_parameter(this._ctxHandle, pname);
+    if (ptr === 0) {
+      return null;
     }
 
-    if (pname === 0x0C22 /* COLOR_CLEAR_VALUE */) {
-      const ptr = ex.wasm_alloc(16);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 16);
-        _checkErr(code, this._instance);
-        const mem = new Float32Array(ex.memory.buffer, ptr, 4);
-        return new Float32Array(mem);
-      } finally {
-        ex.wasm_free(ptr, 16);
+    const dv = new DataView(ex.memory.buffer);
+
+    switch (pname) {
+      case this.VENDOR:
+      case this.RENDERER:
+      case this.VERSION:
+      case this.SHADING_LANGUAGE_VERSION: {
+        const len = dv.getUint32(ptr - 16, true);
+        const bytes = new Uint8Array(ex.memory.buffer, ptr, len);
+        return new TextDecoder().decode(bytes);
       }
-    }
 
-    if (pname === 0x0C23 /* COLOR_WRITEMASK */) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
+      case this.VIEWPORT:
+        return new Int32Array(ex.memory.buffer.slice(ptr, ptr + 16));
+
+      case this.COLOR_CLEAR_VALUE:
+        return new Float32Array(ex.memory.buffer.slice(ptr, ptr + 16));
+
+      case this.COLOR_WRITEMASK: {
         const mem = new Uint8Array(ex.memory.buffer, ptr, 4);
         return [mem[0] !== 0, mem[1] !== 0, mem[2] !== 0, mem[3] !== 0];
-      } finally {
-        ex.wasm_free(ptr, 4);
       }
-    }
 
-    if (pname === 0x8CA6 /* DRAW_FRAMEBUFFER_BINDING */ || pname === 0x8CAA /* READ_FRAMEBUFFER_BINDING */) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        const handle = new Int32Array(ex.memory.buffer, ptr, 1)[0];
+      case this.DRAW_FRAMEBUFFER_BINDING:
+      case this.READ_FRAMEBUFFER_BINDING: {
+        const handle = dv.getInt32(ptr, true);
         if (handle === 0) return null;
         return this._fbHandles.get(handle) || null;
-      } finally {
-        ex.wasm_free(ptr, 4);
       }
-    }
 
-    if (pname === 0x8CA7 /* RENDERBUFFER_BINDING */) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        const handle = new Int32Array(ex.memory.buffer, ptr, 1)[0];
+      case this.RENDERBUFFER_BINDING: {
+        const handle = dv.getInt32(ptr, true);
         if (handle === 0) return null;
         return this._rbHandles.get(handle) || null;
-      } finally {
-        ex.wasm_free(ptr, 4);
-      }
-    }
-
-    if (pname === 0x8824 /* MAX_DRAW_BUFFERS */ || pname === 0x8CDF /* MAX_COLOR_ATTACHMENTS */) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        return new Int32Array(ex.memory.buffer, ptr, 1)[0];
-      } finally {
-        ex.wasm_free(ptr, 4);
       }
-    }
 
-    if (pname >= 0x8825 /* DRAW_BUFFER0 */ && pname <= 0x882C /* DRAW_BUFFER7 */) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        return new Int32Array(ex.memory.buffer, ptr, 1)[0];
-      } finally {
-        ex.wasm_free(ptr, 4);
-      }
-    }
-
-    if (pname === 0x0B72 /* DEPTH_WRITEMASK */) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        const mem = new Uint8Array(ex.memory.buffer, ptr, 1);
-        return mem[0] !== 0;
-      } finally {
-        ex.wasm_free(ptr, 4);
-      }
-    }
-
-    if (pname === 0x0B98 /* STENCIL_WRITEMASK */ || pname === 0x8CA5 /* STENCIL_BACK_WRITEMASK */) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        const mem = new Int32Array(ex.memory.buffer, ptr, 1);
-        return mem[0];
-      } finally {
-        ex.wasm_free(ptr, 4);
-      }
-    }
-
-    const singleIntParams = [
-      0x0B74, // DEPTH_FUNC
-      0x0B92, // STENCIL_FUNC
-      0x0B93, // STENCIL_VALUE_MASK
-      0x0B97, // STENCIL_REF
-      0x8800, // STENCIL_BACK_FUNC
-      0x8CA4, // STENCIL_BACK_VALUE_MASK
-      0x8CA3, // STENCIL_BACK_REF
-      0x0B94, // STENCIL_FAIL
-      0x0B95, // STENCIL_PASS_DEPTH_FAIL
-      0x0B96, // STENCIL_PASS_DEPTH_PASS
-      0x8801, // STENCIL_BACK_FAIL
-      0x8802, // STENCIL_BACK_PASS_DEPTH_FAIL
-      0x8803, // STENCIL_BACK_PASS_DEPTH_PASS
-    ];
-
-    if (singleIntParams.includes(pname)) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        const mem = new Int32Array(ex.memory.buffer, ptr, 1);
-        return mem[0];
-      } finally {
-        ex.wasm_free(ptr, 4);
-      }
-    }
-
-    if (pname === 0x8869 /* MAX_VERTEX_ATTRIBS */) {
-      return 16;
+      case this.MAX_DRAW_BUFFERS:
+      case this.MAX_COLOR_ATTACHMENTS:
+      case this.MAX_VERTEX_ATTRIBS:
+      case this.STENCIL_WRITEMASK:
+      case this.STENCIL_BACK_WRITEMASK:
+      case this.DEPTH_FUNC:
+      case this.STENCIL_FUNC:
+      case this.STENCIL_VALUE_MASK:
+      case this.STENCIL_REF:
+      case this.STENCIL_BACK_FUNC:
+      case this.STENCIL_BACK_VALUE_MASK:
+      case this.STENCIL_BACK_REF:
+      case this.STENCIL_FAIL:
+      case this.STENCIL_PASS_DEPTH_FAIL:
+      case this.STENCIL_PASS_DEPTH_PASS:
+      case this.STENCIL_BACK_FAIL:
+      case this.STENCIL_BACK_PASS_DEPTH_FAIL:
+      case this.STENCIL_BACK_PASS_DEPTH_PASS:
+        return dv.getInt32(ptr, true);
+
+      case this.DEPTH_WRITEMASK:
+        return dv.getUint8(ptr) !== 0;
+
+      default:
+        if (pname >= this.DRAW_BUFFER0 && pname <= this.DRAW_BUFFER7) {
+          return dv.getInt32(ptr, true);
+        }
     }
 
     throw new Error(`getParameter for ${pname} not implemented`);
@@ -2740,16 +2568,24 @@ export class WasmWebGL2RenderingContext {
  */
 export function readErrorMessage(instance) {
   const ex = instance.exports;
-  if (!ex || typeof ex.wasm_last_error_ptr !== 'function' || typeof ex.wasm_last_error_len !== 'function') {
+  if (!ex || typeof ex.wasm_last_error !== 'function') {
+    // Fallback to old ptr/len if exists, otherwise return unknown
+    if (typeof ex.wasm_last_error_ptr === 'function') {
+      const ptr = ex.wasm_last_error_ptr();
+      const len = ex.wasm_last_error_len();
+      if (ptr === 0 || len === 0) return '';
+      const mem = new Uint8Array(ex.memory.buffer);
+      const bytes = mem.subarray(ptr, ptr + len);
+      return new TextDecoder('utf-8').decode(bytes);
+    }
     return '(no error message available)';
   }
-  const ptr = ex.wasm_last_error_ptr();
-  const len = ex.wasm_last_error_len();
-  if (ptr === 0 || len === 0) {
-    return '';
-  }
+  const ptr = ex.wasm_last_error();
+  if (ptr === 0) return '';
+  const dv = new DataView(ex.memory.buffer);
+  const len = dv.getUint32(ptr - 16, true);
   const mem = new Uint8Array(ex.memory.buffer);
-  const bytes = mem.subarray(ptr, ptr + len);
+  const bytes = mem.slice(ptr, ptr + len);
   return new TextDecoder('utf-8').decode(bytes);
 }
 
@@ -2897,24 +2733,18 @@ export function getShaderGlsl(ctxHandle, programHandle, shaderType) {
     mem.set(wasmBytes, wasmBytesPtr);
 
     // Call the decompiler
-    const resultLen = ex.wasm_decompile_to_glsl(wasmBytesPtr, wasmBytesLen);
+    const glslPtr = ex.wasm_decompile_to_glsl(wasmBytesPtr, wasmBytesLen);
 
-    if (resultLen === 0) {
+    if (glslPtr === 0) {
       return null;
     }
 
-    // Get the decompiled GLSL
-    const glslPtr = ex.wasm_get_decompiled_glsl_ptr();
-    const glslLen = ex.wasm_get_decompiled_glsl_len();
-
-    if (glslPtr === 0 || glslLen === 0) {
-      return null;
-    }
+    const dv = new DataView(ex.memory.buffer);
+    const glslLen = dv.getUint32(glslPtr - 16, true);
 
     // Read the GLSL string
-    const glslBytes = new Uint8Array(ex.memory.buffer).subarray(glslPtr, glslPtr + glslLen);
-    const decoder = new TextDecoder('utf-8');
-    return decoder.decode(glslBytes);
+    const glslBytes = new Uint8Array(ex.memory.buffer).slice(glslPtr, glslPtr + glslLen);
+    return new TextDecoder('utf-8').decode(glslBytes);
   } finally {
     // Free the allocated memory
     ex.wasm_free(wasmBytesPtr);
@@ -2953,24 +2783,18 @@ export function decompileWasmToGlsl(gl, wasmBytes) {
     mem.set(wasmBytes, wasmBytesPtr);
 
     // Call the decompiler
-    const resultLen = ex.wasm_decompile_to_glsl(wasmBytesPtr, wasmBytesLen);
+    const glslPtr = ex.wasm_decompile_to_glsl(wasmBytesPtr, wasmBytesLen);
 
-    if (resultLen === 0) {
+    if (glslPtr === 0) {
       return null;
     }
 
-    // Get the decompiled GLSL
-    const glslPtr = ex.wasm_get_decompiled_glsl_ptr();
-    const glslLen = ex.wasm_get_decompiled_glsl_len();
-
-    if (glslPtr === 0 || glslLen === 0) {
-      return null;
-    }
+    const dv = new DataView(ex.memory.buffer);
+    const glslLen = dv.getUint32(glslPtr - 16, true);
 
     // Read the GLSL string
-    const glslBytes = new Uint8Array(ex.memory.buffer).subarray(glslPtr, glslPtr + glslLen);
-    const decoder = new TextDecoder('utf-8');
-    return decoder.decode(glslBytes);
+    const glslBytes = new Uint8Array(ex.memory.buffer).slice(glslPtr, glslPtr + glslLen);
+    return new TextDecoder('utf-8').decode(glslBytes);
   } finally {
     // Free the allocated memory
     ex.wasm_free(wasmBytesPtr);