webgl2 1.1.18 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webgl2",
-  "version": "1.1.18",
+  "version": "1.2.1",
   "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,10 +25,12 @@ 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;
   STENCIL_TEST = 0x0B90;
+  SCISSOR_TEST = 0x0C11;
   STENCIL_BUFFER_BIT = 0x00000400;
   COMPILE_STATUS = 0x8B81;
   LINK_STATUS = 0x8B82;
@@ -36,6 +38,12 @@ export class WasmWebGL2RenderingContext {
   VALIDATE_STATUS = 0x8B83;
   ARRAY_BUFFER = 0x8892;
   ELEMENT_ARRAY_BUFFER = 0x8893;
+  COPY_READ_BUFFER = 0x8F36;
+  COPY_WRITE_BUFFER = 0x8F37;
+  PIXEL_PACK_BUFFER = 0x88EB;
+  PIXEL_UNPACK_BUFFER = 0x88EC;
+  UNIFORM_BUFFER = 0x8A11;
+  TRANSFORM_FEEDBACK_BUFFER = 0x8C8E;
   STATIC_DRAW = 0x88E4;
   BYTE = 0x1400;
   UNSIGNED_BYTE = 0x1401;
@@ -44,7 +52,6 @@ export class WasmWebGL2RenderingContext {
   INT = 0x1404;
   UNSIGNED_INT = 0x1405;
   FLOAT = 0x1406;
-  RGBA = 0x1908;
   FLOAT_VEC2 = 0x8B50;
   FLOAT_VEC3 = 0x8B51;
   FLOAT_VEC4 = 0x8B52;
@@ -59,6 +66,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;
@@ -107,6 +115,8 @@ export class WasmWebGL2RenderingContext {
 
   RENDERBUFFER = 0x8D41;
   FRAMEBUFFER = 0x8D40;
+  READ_FRAMEBUFFER = 0x8CA8;
+  DRAW_FRAMEBUFFER = 0x8CA9;
   DEPTH_COMPONENT16 = 0x81A5;
   DEPTH_STENCIL = 0x84F9;
   RGBA4 = 0x8056;
@@ -141,10 +151,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 +230,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 +319,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 +360,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 +560,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 +580,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 +593,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 +800,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 +812,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 +842,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 +867,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 +901,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 +991,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 +1001,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 +1199,7 @@ export class WasmWebGL2RenderingContext {
       stride >>> 0,
       offset >>> 0
     );
+    if (code === 5) return; // ERR_GL
     _checkErr(code, this._instance);
   }
 
@@ -1104,6 +1217,7 @@ export class WasmWebGL2RenderingContext {
       stride >>> 0,
       offset >>> 0
     );
+    if (code === 5) return; // ERR_GL
     _checkErr(code, this._instance);
   }
 
@@ -1282,6 +1396,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');
 
@@ -1321,7 +1441,22 @@ export class WasmWebGL2RenderingContext {
       ex.wasm_free(ptr);
     }
   }
-  copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size) { this._assertNotDestroyed(); throw new Error('not implemented'); }
+  copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_copy_buffer_sub_data !== 'function') {
+      throw new Error('wasm_ctx_copy_buffer_sub_data not found');
+    }
+    const code = ex.wasm_ctx_copy_buffer_sub_data(
+      this._ctxHandle,
+      readTarget >>> 0,
+      writeTarget >>> 0,
+      readOffset >>> 0,
+      writeOffset >>> 0,
+      size >>> 0
+    );
+    _checkErr(code, this._instance);
+  }
   getBufferParameter(target, pname) {
     this._assertNotDestroyed();
     const ex = this._instance.exports;
@@ -1508,10 +1643,65 @@ 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'); }
+  blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_blit_framebuffer !== 'function') {
+      throw new Error('wasm_ctx_blit_framebuffer not found');
+    }
+    const code = ex.wasm_ctx_blit_framebuffer(
+      this._ctxHandle,
+      srcX0 | 0, srcY0 | 0, srcX1 | 0, srcY1 | 0,
+      dstX0 | 0, dstY0 | 0, dstX1 | 0, dstY1 | 0,
+      mask >>> 0, filter >>> 0
+    );
+    _checkErr(code, this._instance);
+  }
   readBuffer(src) { this._assertNotDestroyed(); throw new Error('not implemented'); }
 
   pixelStorei(pname, param) { this._assertNotDestroyed(); throw new Error('not implemented'); }