webgl2 1.0.22 → 1.1.0

package/README.md

@@ -25,7 +25,9 @@ npm run build
 npm test
 ```
 
-[🧊Demo](https://webgl2/was.hm)
+[🧊Demo WebGL/WASHM](https://webgl2.was.hm)
+
+![🧊Demo WebGL/WASHM -rotating cube around 35-40FPS](./webgl2-demo2.gif)
 
 ## ✨ Key Features
 

package/index.js

@@ -40,11 +40,13 @@ const isNode =
  * 3. Creates a Rust-owned context via wasm_create_context()
  * 4. Returns a WasmWebGL2RenderingContext JS wrapper
  *
- * @param {Object} opts - options (unused for now)
+ * @param {{
+ *  debug?: boolean,
+ * }} [opts] - options
  * @returns {Promise<WasmWebGL2RenderingContext>}
  * @throws {Error} if WASM loading or instantiation fails
  */
-async function webGL2(opts = {}) {
+async function webGL2({ debug } = {}) {
   // Load WASM binary
   const { ex, instance } = await (
     wasmInitPromise ||
@@ -52,7 +54,7 @@ async function webGL2(opts = {}) {
       // ensure success is cached but not failure
       let succeeded = false;
       try {
-        const wasm = await initWASM();
+        const wasm = await initWASM({ debug });
         succeeded = true;
         return wasm;
       } finally {
@@ -61,6 +63,16 @@ async function webGL2(opts = {}) {
       }
     })());
 
+  // Initialize coverage if available
+  if (ex.wasm_init_coverage && ex.COV_MAP_PTR) {
+    const mapPtr = ex.COV_MAP_PTR.value;
+    // Read num_entries from the start of the map data
+    // mapPtr is aligned to 16 bytes, so we can use Uint32Array
+    const mem = new Uint32Array(ex.memory.buffer);
+    const numEntries = mem[mapPtr >>> 2];
+    ex.wasm_init_coverage(numEntries);
+  }
+
   // Create a context in WASM
   const ctxHandle = ex.wasm_create_context();
   if (ctxHandle === 0) {
@@ -82,14 +94,15 @@ async function webGL2(opts = {}) {
  */
 var wasmInitPromise;
 
-async function initWASM() {
+async function initWASM({ debug } = {}) {
+  const wasmFile = debug ? 'webgl2.debug.wasm' : 'webgl2.wasm';
   let wasmBuffer;
   if (isNode) {
     // Use dynamic imports so this module can be loaded in the browser too.
     const path = await import('path');
     const fs = await import('fs');
     const { fileURLToPath } = await import('url');
-    const wasmPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'webgl2.wasm');
+    const wasmPath = path.join(path.dirname(fileURLToPath(import.meta.url)), wasmFile);
     if (!fs.existsSync(wasmPath)) {
       throw new Error(`WASM not found at ${wasmPath}. Run: npm run build:wasm`);
     }
@@ -97,9 +110,9 @@ async function initWASM() {
     wasmBuffer = fs.readFileSync(wasmPath);
   } else {
     // Browser: fetch the wasm relative to this module
-    const resp = await fetch(new URL('./webgl2.wasm', import.meta.url));
+    const resp = await fetch(new URL('./' + wasmFile, import.meta.url));
     if (!resp.ok) {
-      throw new Error(`Failed to fetch webgl2.wasm: ${resp.status}`);
+      throw new Error(`Failed to fetch ${wasmFile}: ${resp.status}`);
     }
     wasmBuffer = await resp.arrayBuffer();
   }
@@ -133,7 +146,7 @@ async function initWASM() {
   if (!(ex.memory instanceof WebAssembly.Memory)) {
     throw new Error('WASM module missing memory export');
   }
-  return wasmInitPromise = { ex, instance };
+  return wasmInitPromise = { ex, instance, module: wasmModule };
 }
 
 /**

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "webgl2",
-  "version": "1.0.22",
+  "version": "1.1.0",
   "description": "WebGL2 tools to derisk large GPU projects on the web beyond toys and demos.",
   "type": "module",
   "main": "index.js",
   "scripts": {
     "start": "node ./index.js",
-    "build": "cargo build --target wasm32-unknown-unknown --release && node -e \"fs.copyFileSync('target/wasm32-unknown-unknown/release/webgl2.wasm', 'webgl2.wasm')\"",
+    "build-release": "cargo build --target wasm32-unknown-unknown --release && node -e \"fs.copyFileSync('target/wasm32-unknown-unknown/release/webgl2.wasm', 'webgl2.wasm')\"",
+    "build-debug-wasm-only": "cargo build --target wasm32-unknown-unknown --features coverage --profile coverage && node -e \"fs.copyFileSync('target/wasm32-unknown-unknown/coverage/webgl2.wasm', 'webgl2.debug.wasm')\"",
+    "build-debug-distill": "cargo run --bin distill_wasm --features cli -- webgl2.debug.wasm --output webgl2.debug.wasm",
+    "build-debug": "npm run build-debug-wasm-only && npm run build-debug-distill",
+    "build": "npm run build-release && npm run build-debug",
     "prepublishOnly": "npm run build",
     "test": "node --test test/*.test.js",
     "test:smoke": "npm run build && node ./test/smoke.js"
@@ -18,7 +22,7 @@
   "keywords": [],
   "author": "",
   "license": "MIT",
-  "homepage": "https://webgl2/was.hm"
+  "homepage": "https://webgl2.was.hm"
   ,
   "files": [
     "index.js",

package/src/webgl2_context.js

@@ -44,6 +44,21 @@ export class WasmWebGL2RenderingContext {
   BUFFER_SIZE = 0x8764;
   NO_ERROR = 0;
 
+  TEXTURE_2D = 0x0DE1;
+  TEXTURE_WRAP_S = 0x2802;
+  TEXTURE_WRAP_T = 0x2803;
+  TEXTURE_MAG_FILTER = 0x2800;
+  TEXTURE_MIN_FILTER = 0x2801;
+  NEAREST = 0x2600;
+  LINEAR = 0x2601;
+  NEAREST_MIPMAP_NEAREST = 0x2700;
+  LINEAR_MIPMAP_NEAREST = 0x2701;
+  NEAREST_MIPMAP_LINEAR = 0x2702;
+  LINEAR_MIPMAP_LINEAR = 0x2703;
+  REPEAT = 0x2901;
+  CLAMP_TO_EDGE = 0x812F;
+  MIRRORED_REPEAT = 0x8370;
+
   /**
    * @param {WebAssembly.Instance} instance
    * @param {u32} ctxHandle
@@ -716,7 +731,32 @@ export class WasmWebGL2RenderingContext {
     }
   }
 
-  bufferSubData(target, offset, data) { this._assertNotDestroyed(); throw new Error('not implemented'); }
+  bufferSubData(target, offset, data) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_buffer_sub_data !== 'function') {
+      throw new Error('wasm_ctx_buffer_sub_data not found');
+    }
+
+    let bytes;
+    if (data instanceof Uint8Array) bytes = data;
+    else if (ArrayBuffer.isView(data)) bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    else if (data instanceof ArrayBuffer) bytes = new Uint8Array(data);
+    else bytes = new Uint8Array(data); // Fallback for arrays
+
+    const len = bytes.length;
+    const ptr = ex.wasm_alloc(len);
+    if (ptr === 0) throw new Error('Failed to allocate memory for bufferSubData');
+
+    try {
+      const mem = new Uint8Array(ex.memory.buffer);
+      mem.set(bytes, ptr);
+      const code = ex.wasm_ctx_buffer_sub_data(this._ctxHandle, target >>> 0, offset >>> 0, ptr, len);
+      _checkErr(code, this._instance);
+    } finally {
+      ex.wasm_free(ptr);
+    }
+  }
   copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size) { this._assertNotDestroyed(); throw new Error('not implemented'); }
   getBufferParameter(target, pname) {
     this._assertNotDestroyed();
@@ -757,10 +797,52 @@ export class WasmWebGL2RenderingContext {
   drawRangeElements(mode, start, end, count, type, offset) { this._assertNotDestroyed(); throw new Error('not implemented'); }
   drawBuffers(buffers) { this._assertNotDestroyed(); throw new Error('not implemented'); }
 
-  createVertexArray() { this._assertNotDestroyed(); throw new Error('not implemented'); }
-  bindVertexArray(vao) { this._assertNotDestroyed(); throw new Error('not implemented'); }
-  deleteVertexArray(vao) { this._assertNotDestroyed(); throw new Error('not implemented'); }
-  isVertexArray(vao) { this._assertNotDestroyed(); throw new Error('not implemented'); }
+  createVertexArray() {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_create_vertex_array !== 'function') {
+      throw new Error('wasm_ctx_create_vertex_array not found');
+    }
+    const handle = ex.wasm_ctx_create_vertex_array(this._ctxHandle);
+    if (handle === 0) return null;
+    return { _handle: handle, _type: 'WebGLVertexArrayObject' };
+  }
+
+  bindVertexArray(vao) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_bind_vertex_array !== 'function') {
+      throw new Error('wasm_ctx_bind_vertex_array not found');
+    }
+    const handle = vao && typeof vao === 'object' && typeof vao._handle === 'number' ? vao._handle : (vao ? (vao >>> 0) : 0);
+    const code = ex.wasm_ctx_bind_vertex_array(this._ctxHandle, handle);
+    _checkErr(code, this._instance);
+  }
+
+  deleteVertexArray(vao) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_delete_vertex_array !== 'function') {
+      throw new Error('wasm_ctx_delete_vertex_array not found');
+    }
+    const handle = vao && typeof vao === 'object' && typeof vao._handle === 'number' ? vao._handle : (vao >>> 0);
+    const code = ex.wasm_ctx_delete_vertex_array(this._ctxHandle, handle);
+    _checkErr(code, this._instance);
+    if (vao && typeof vao === 'object') {
+      try { vao._handle = 0; vao._deleted = true; } catch (e) { /* ignore */ }
+    }
+  }
+
+  isVertexArray(vao) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_is_vertex_array !== 'function') {
+      throw new Error('wasm_ctx_is_vertex_array not found');
+    }
+    const handle = vao && typeof vao === 'object' && typeof vao._handle === 'number' ? vao._handle : (vao >>> 0);
+    const res = ex.wasm_ctx_is_vertex_array(this._ctxHandle, handle);
+    return res !== 0;
+  }
 
   createTransformFeedback() { this._assertNotDestroyed(); throw new Error('not implemented'); }
   bindTransformFeedback(target, tf) { this._assertNotDestroyed(); throw new Error('not implemented'); }
@@ -798,7 +880,15 @@ export class WasmWebGL2RenderingContext {
     const code = ex.wasm_ctx_active_texture(this._ctxHandle, texture >>> 0);
     _checkErr(code, this._instance);
   }
-  texParameteri(target, pname, param) { this._assertNotDestroyed(); throw new Error('not implemented'); }
+  texParameteri(target, pname, param) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_tex_parameter_i !== 'function') {
+      throw new Error('wasm_ctx_tex_parameter_i not found');
+    }
+    const code = ex.wasm_ctx_tex_parameter_i(this._ctxHandle, target >>> 0, pname >>> 0, param | 0);
+    _checkErr(code, this._instance);
+  }
   generateMipmap(target) { this._assertNotDestroyed(); throw new Error('not implemented'); }
   copyTexImage2D(target, level, internalformat, x, y, width, height, border) { this._assertNotDestroyed(); throw new Error('not implemented'); }
   copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height) { this._assertNotDestroyed(); throw new Error('not implemented'); }
@@ -1067,6 +1157,24 @@ export class WasmWebGL2RenderingContext {
     }
     this._verbosity = level;
   }
+
+  /**
+   * Get LCOV coverage report.
+   * @returns {string}
+   */
+  getLcovReport() {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (ex && typeof ex.wasm_get_lcov_report_ptr === 'function' && typeof ex.wasm_get_lcov_report_len === 'function') {
+      const ptr = ex.wasm_get_lcov_report_ptr();
+      const len = ex.wasm_get_lcov_report_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 '';
+  }
 }
 
 /**