webgl2 1.1.4 → 1.1.6

package/src/webgl2_context.js

@@ -35,14 +35,34 @@ export class WasmWebGL2RenderingContext {
   ARRAY_BUFFER = 0x8892;
   ELEMENT_ARRAY_BUFFER = 0x8893;
   STATIC_DRAW = 0x88E4;
-  FLOAT = 0x1406;
-  UNSIGNED_SHORT = 0x1403;
+  BYTE = 0x1400;
   UNSIGNED_BYTE = 0x1401;
+  SHORT = 0x1402;
+  UNSIGNED_SHORT = 0x1403;
+  INT = 0x1404;
+  UNSIGNED_INT = 0x1405;
+  FLOAT = 0x1406;
   RGBA = 0x1908;
   VIEWPORT = 0x0BA2;
   COLOR_CLEAR_VALUE = 0x0C22;
   BUFFER_SIZE = 0x8764;
+  MAX_VERTEX_ATTRIBS = 0x8869;
   NO_ERROR = 0;
+  INVALID_ENUM = 0x0500;
+  INVALID_VALUE = 0x0501;
+  INVALID_OPERATION = 0x0502;
+  OUT_OF_MEMORY = 0x0505;
+
+  CURRENT_VERTEX_ATTRIB = 0x8626;
+  VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622;
+  VERTEX_ATTRIB_ARRAY_SIZE = 0x8623;
+  VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624;
+  VERTEX_ATTRIB_ARRAY_TYPE = 0x8625;
+  VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A;
+  VERTEX_ATTRIB_ARRAY_POINTER = 0x8645;
+  VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F;
+  VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE;
+  VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD;
 
   RENDERBUFFER = 0x8D41;
   FRAMEBUFFER = 0x8D40;
@@ -51,6 +71,7 @@ export class WasmWebGL2RenderingContext {
   RGBA4 = 0x8056;
   RGB565 = 0x8D62;
   RGB5_A1 = 0x8057;
+  RGBA8 = 0x8058;
   STENCIL_INDEX8 = 0x8D48;
   COLOR_ATTACHMENT0 = 0x8CE0;
   DEPTH_ATTACHMENT = 0x8D00;
@@ -82,13 +103,68 @@ export class WasmWebGL2RenderingContext {
     this._destroyed = false;
     /** @type {import('./webgl2_resources.js').WasmWebGLProgram | null} */
     this._currentProgram = null;
+    this._debugMode = 0; // 0=None, 1=Shaders, 2=Rust, 3=All
+    this._drawingBufferWidth = 640;
+    this._drawingBufferHeight = 480;
+
+    WasmWebGL2RenderingContext._contexts.set(ctxHandle, this);
+  }
+
+  setDebugMode(mode) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_set_debug_mode !== 'function') {
+      console.warn('wasm_ctx_set_debug_mode not found');
+      return;
+    }
+
+    let modeVal = 0;
+    if (mode === true || mode === 'all') modeVal = 3;
+    else if (mode === 'shaders') modeVal = 1;
+    else if (mode === 'rust') modeVal = 2;
+    else modeVal = 0;
+
+    this._debugMode = modeVal;
+    const code = ex.wasm_ctx_set_debug_mode(this._ctxHandle, modeVal);
+    _checkErr(code, this._instance);
+  }
+
+  get drawingBufferWidth() {
+    return this._drawingBufferWidth;
+  }
+
+  get drawingBufferHeight() {
+    return this._drawingBufferHeight;
+  }
+
+  resize(width, height) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_resize !== 'function') {
+      throw new Error('wasm_ctx_resize not found');
+    }
+    const code = ex.wasm_ctx_resize(this._ctxHandle, width, height);
+    _checkErr(code, this._instance);
+    this._drawingBufferWidth = width;
+    this._drawingBufferHeight = height;
+  }
 
-    WasmWebGL2RenderingContext.activeContext = this;
+  // Set the viewport for rendering
+  viewport(x, y, width, height) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_viewport !== 'function') {
+      throw new Error('wasm_ctx_viewport not found');
+    }
+    const code = ex.wasm_ctx_viewport(this._ctxHandle, x | 0, y | 0, width >>> 0, height >>> 0);
+    _checkErr(code, this._instance);
   }
 
+  /** @type {Map<number, WasmWebGL2RenderingContext>} */
+  static _contexts = new Map();
+
   _executeShader(type, attrPtr, uniformPtr, varyingPtr, privatePtr, texturePtr) {
     if (!this._currentProgram) {
-      console.log("DEBUG: No current program");
       return;
     }
     const shaderInstance = type === this.VERTEX_SHADER ? this._currentProgram._vsInstance : this._currentProgram._fsInstance;
@@ -101,17 +177,18 @@ export class WasmWebGL2RenderingContext {
         console.error(`  attrPtr: ${attrPtr}, uniformPtr: ${uniformPtr}, varyingPtr: ${varyingPtr}, privatePtr: ${privatePtr}, texturePtr: ${texturePtr}`);
         throw e;
       }
+    } else {
+      // console.log(`DEBUG: Shader instance or main missing for type ${type}. Instance: ${!!shaderInstance}`);
     }
   }
 
   destroy() {
     if (this._destroyed) return;
+    WasmWebGL2RenderingContext._contexts.delete(this._ctxHandle);
     const ex = this._instance.exports;
-    if (ex && typeof ex.wasm_ctx_destroy_context === 'function') {
-      if (typeof ex.wasm_destroy_context === 'function') {
-        const code = ex.wasm_destroy_context(this._ctxHandle);
-        _checkErr(code, this._instance);
-      }
+    if (ex && typeof ex.wasm_destroy_context === 'function') {
+      const code = ex.wasm_destroy_context(this._ctxHandle);
+      _checkErr(code, this._instance);
     }
     this._destroyed = true;
   }
@@ -466,32 +543,127 @@ export class WasmWebGL2RenderingContext {
     const vsWasm = this.getProgramWasm(program, this.VERTEX_SHADER);
     const fsWasm = this.getProgramWasm(program, this.FRAGMENT_SHADER);
 
+    const createDebugEnv = (type, instanceRef) => {
+      if (this._debugMode !== 1 && this._debugMode !== 3) return {};
+
+      const stubCode = this.getProgramDebugStub(program, type);
+      if (!stubCode) return {};
+
+      // // Add sourceURL for debugging
+      // const debugName = `shader_stub_program_${program._handle}_${type === this.VERTEX_SHADER ? 'vs' : 'fs'}.js`;
+      // const codeWithUrl = stubCode + `\n//# sourceURL=${debugName}`;
+
+      let stubFuncs;
+      try {
+        // Eval the stub array
+        stubFuncs = (0, eval)(stubCode);
+      } catch (e) {
+        console.error("Failed to eval debug stub:", e);
+        return {};
+      }
+
+      return {
+        debug_step: (line, funcIdx, resultPtr) => {
+          const func = stubFuncs[line - 1];
+          if (func) {
+            const ctx = {
+              go: () => {
+                // Trampoline logic would go here
+                // For now we rely on WASM calling the function after debug_step returns
+              }
+            };
+            try {
+              func.call(ctx);
+            } catch (e) {
+              console.error("Error in debug stub:", e);
+            }
+          }
+        }
+      };
+    };
+
     if (vsWasm) {
       try {
         const vsModule = new WebAssembly.Module(vsWasm);
+        const instanceRef = { current: null };
+        const debugEnv = createDebugEnv(this.VERTEX_SHADER, instanceRef);
+
         program._vsInstance = new WebAssembly.Instance(vsModule, {
           env: {
-            memory: this._instance.exports.memory
+            memory: this._instance.exports.memory,
+            ...debugEnv
           }
         });
+        instanceRef.current = program._vsInstance;
       } catch (e) {
-        console.log(`DEBUG: VS Instance creation failed: ${e}`);
+        // console.log(`DEBUG: VS Instance creation failed: ${e}`);
       }
     }
     if (fsWasm) {
       try {
         const fsModule = new WebAssembly.Module(fsWasm);
+        const instanceRef = { current: null };
+        const debugEnv = createDebugEnv(this.FRAGMENT_SHADER, instanceRef);
+
         program._fsInstance = new WebAssembly.Instance(fsModule, {
           env: {
-            memory: this._instance.exports.memory
+            memory: this._instance.exports.memory,
+            ...debugEnv
           }
         });
+        instanceRef.current = program._fsInstance;
       } catch (e) {
-        console.log(`DEBUG: FS Instance creation failed: ${e}`);
+        // console.log(`DEBUG: FS Instance creation failed: ${e}`);
       }
     }
   }
 
+  getProgramDebugStub(program, shaderType) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_get_program_debug_stub !== 'function') {
+      return null;
+    }
+    const programHandle = program && typeof program === 'object' && typeof program._handle === 'number' ? program._handle : (program >>> 0);
+    const len = ex.wasm_ctx_get_program_debug_stub(this._ctxHandle, programHandle, shaderType, 0, 0);
+    if (len === 0) return null;
+
+    const ptr = ex.wasm_alloc(len);
+    if (ptr === 0) return null;
+
+    try {
+      const actualLen = ex.wasm_ctx_get_program_debug_stub(this._ctxHandle, programHandle, shaderType, ptr, len);
+      const mem = new Uint8Array(ex.memory.buffer);
+      const bytes = mem.subarray(ptr, ptr + actualLen);
+      return new TextDecoder().decode(bytes);
+    } finally {
+      ex.wasm_free(ptr);
+    }
+  }
+
+  getProgramDebugStub(program, shaderType) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_get_program_debug_stub !== 'function') {
+      return null;
+    }
+    const programHandle = program && typeof program === 'object' && typeof program._handle === 'number' ? program._handle : (program >>> 0);
+    const len = ex.wasm_ctx_get_program_debug_stub(this._ctxHandle, programHandle, shaderType, 0, 0);
+    if (len === 0) return null;
+
+    const ptr = ex.wasm_alloc(len);
+    if (ptr === 0) return null;
+
+    try {
+      const actualLen = ex.wasm_ctx_get_program_debug_stub(this._ctxHandle, programHandle, shaderType, ptr, len);
+      const mem = new Uint8Array(ex.memory.buffer);
+      const bytes = mem.subarray(ptr, ptr + actualLen);
+      return new TextDecoder().decode(bytes);
+    } finally {
+      ex.wasm_free(ptr);
+    }
+  }
+
   deleteProgram(program) {
     this._assertNotDestroyed();
     const ex = this._instance.exports;
@@ -526,7 +698,7 @@ export class WasmWebGL2RenderingContext {
     }
     const shaderHandle = shader && typeof shader === 'object' && typeof shader._handle === 'number' ? shader._handle : (shader >>> 0);
     const val = ex.wasm_ctx_get_shader_parameter(this._ctxHandle, shaderHandle, pname >>> 0);
-    
+
     // WebGL returns boolean for status parameters
     if (pname === 0x8B81 /* COMPILE_STATUS */ || pname === 0x8B80 /* DELETE_STATUS */) {
       return !!val;
@@ -557,7 +729,7 @@ export class WasmWebGL2RenderingContext {
       throw new Error('wasm_ctx_get_shader_info_log not found');
     }
     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');
@@ -699,6 +871,23 @@ export class WasmWebGL2RenderingContext {
     _checkErr(code, this._instance);
   }
 
+  vertexAttribIPointer(index, size, type, stride, offset) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_vertex_attrib_ipointer !== 'function') {
+      throw new Error('wasm_ctx_vertex_attrib_ipointer not found');
+    }
+    const code = ex.wasm_ctx_vertex_attrib_ipointer(
+      this._ctxHandle,
+      index >>> 0,
+      size >>> 0,
+      type >>> 0,
+      stride >>> 0,
+      offset >>> 0
+    );
+    _checkErr(code, this._instance);
+  }
+
   vertexAttrib1f(index, v0) {
     this._assertNotDestroyed();
     const ex = this._instance.exports;
@@ -706,6 +895,7 @@ export class WasmWebGL2RenderingContext {
       throw new Error('wasm_ctx_vertex_attrib1f not found');
     }
     const code = ex.wasm_ctx_vertex_attrib1f(this._ctxHandle, index >>> 0, +v0);
+    if (code === 5) return; // ERR_GL
     _checkErr(code, this._instance);
   }
   vertexAttrib2f(index, v0, v1) {
@@ -715,6 +905,7 @@ export class WasmWebGL2RenderingContext {
       throw new Error('wasm_ctx_vertex_attrib2f not found');
     }
     const code = ex.wasm_ctx_vertex_attrib2f(this._ctxHandle, index >>> 0, +v0, +v1);
+    if (code === 5) return; // ERR_GL
     _checkErr(code, this._instance);
   }
   vertexAttrib3f(index, v0, v1, v2) {
@@ -724,6 +915,7 @@ export class WasmWebGL2RenderingContext {
       throw new Error('wasm_ctx_vertex_attrib3f not found');
     }
     const code = ex.wasm_ctx_vertex_attrib3f(this._ctxHandle, index >>> 0, +v0, +v1, +v2);
+    if (code === 5) return; // ERR_GL
     _checkErr(code, this._instance);
   }
   vertexAttrib4f(index, v0, v1, v2, v3) {
@@ -733,9 +925,77 @@ export class WasmWebGL2RenderingContext {
       throw new Error('wasm_ctx_vertex_attrib4f not found');
     }
     const code = ex.wasm_ctx_vertex_attrib4f(this._ctxHandle, index >>> 0, +v0, +v1, +v2, +v3);
+    if (code === 5) return; // ERR_GL
+    _checkErr(code, this._instance);
+  }
+
+  vertexAttrib1fv(index, v) {
+    if (v && v.length >= 1) {
+      this.vertexAttrib1f(index, v[0]);
+    } else {
+      this._setError(0x0501);
+    }
+  }
+  vertexAttrib2fv(index, v) {
+    if (v && v.length >= 2) {
+      this.vertexAttrib2f(index, v[0], v[1]);
+    } else {
+      this._setError(0x0501);
+    }
+  }
+  vertexAttrib3fv(index, v) {
+    if (v && v.length >= 3) {
+      this.vertexAttrib3f(index, v[0], v[1], v[2]);
+    } else {
+      this._setError(0x0501);
+    }
+  }
+  vertexAttrib4fv(index, v) {
+    if (v && v.length >= 4) {
+      this.vertexAttrib4f(index, v[0], v[1], v[2], v[3]);
+    } else {
+      this._setError(0x0501);
+    }
+  }
+
+  vertexAttribI4i(index, v0, v1, v2, v3) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_vertex_attrib_i4i !== 'function') {
+      throw new Error('wasm_ctx_vertex_attrib_i4i not found');
+    }
+    const code = ex.wasm_ctx_vertex_attrib_i4i(this._ctxHandle, index >>> 0, v0 | 0, v1 | 0, v2 | 0, v3 | 0);
+    if (code === 5) return; // ERR_GL
     _checkErr(code, this._instance);
   }
 
+  vertexAttribI4ui(index, v0, v1, v2, v3) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_vertex_attrib_i4ui !== 'function') {
+      throw new Error('wasm_ctx_vertex_attrib_i4ui not found');
+    }
+    const code = ex.wasm_ctx_vertex_attrib_i4ui(this._ctxHandle, index >>> 0, v0 >>> 0, v1 >>> 0, v2 >>> 0, v3 >>> 0);
+    if (code === 5) return; // ERR_GL
+    _checkErr(code, this._instance);
+  }
+
+  vertexAttribI4iv(index, v) {
+    if (v && v.length >= 4) {
+      this.vertexAttribI4i(index, v[0], v[1], v[2], v[3]);
+    } else {
+      this._setError(0x0501);
+    }
+  }
+
+  vertexAttribI4uiv(index, v) {
+    if (v && v.length >= 4) {
+      this.vertexAttribI4ui(index, v[0], v[1], v[2], v[3]);
+    } else {
+      this._setError(0x0501);
+    }
+  }
+
   vertexAttribDivisor(index, divisor) {
     this._assertNotDestroyed();
     const ex = this._instance.exports;
@@ -779,9 +1039,10 @@ export class WasmWebGL2RenderingContext {
     }
     const handle = buffer && typeof buffer === 'object' && typeof buffer._handle === 'number' ? buffer._handle : (buffer >>> 0);
     const code = ex.wasm_ctx_delete_buffer(this._ctxHandle, handle);
-    _checkErr(code, this._instance);    if (buffer && typeof buffer === 'object') {
+    _checkErr(code, this._instance); if (buffer && typeof buffer === 'object') {
       try { buffer._handle = 0; buffer._deleted = true; } catch (e) { /* ignore */ }
-    }  }
+    }
+  }
 
   bufferData(target, data, usage) {
     this._assertNotDestroyed();
@@ -1087,7 +1348,7 @@ export class WasmWebGL2RenderingContext {
       throw new Error('wasm_ctx_uniform_matrix_4fv not found');
     }
     const locHandle = loc === null ? -1 : (typeof loc === 'number' ? loc : (loc._handle >>> 0));
-    
+
     let bytes;
     if (value instanceof Float32Array) {
       bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
@@ -1111,6 +1372,64 @@ export class WasmWebGL2RenderingContext {
   getActiveUniform(program, index) { this._assertNotDestroyed(); throw new Error('not implemented'); }
   getActiveAttrib(program, index) { this._assertNotDestroyed(); throw new Error('not implemented'); }
 
+  getVertexAttrib(index, pname) {
+    this._assertNotDestroyed();
+    const ex = this._instance.exports;
+    if (!ex || typeof ex.wasm_ctx_get_vertex_attrib !== 'function') {
+      throw new Error('wasm_ctx_get_vertex_attrib not found');
+    }
+
+    // Allocate memory for result.
+    // Most params return 1 int (4 bytes).
+    // CURRENT_VERTEX_ATTRIB returns 4 values (16 bytes) + type (4 bytes) = 20 bytes.
+    const len = 20;
+    const ptr = ex.wasm_alloc(len);
+    if (ptr === 0) throw new Error('Failed to allocate memory for getVertexAttrib');
+
+    try {
+      const code = ex.wasm_ctx_get_vertex_attrib(this._ctxHandle, index >>> 0, pname >>> 0, ptr, len);
+      if (code === 5) { // ERR_GL
+        return undefined;
+      }
+      _checkErr(code, this._instance);
+
+      const mem = new Int32Array(ex.memory.buffer, ptr, 5);
+      const memU = new Uint32Array(ex.memory.buffer, ptr, 5);
+      const memF = new Float32Array(ex.memory.buffer, ptr, 5);
+
+      if (pname === 0x8626 /* CURRENT_VERTEX_ATTRIB */) {
+        // Check type at index 4
+        const type = memU[4];
+        if (type === 0x1404 /* INT */) {
+          return new Int32Array([mem[0], mem[1], mem[2], mem[3]]);
+        } else if (type === 0x1405 /* UNSIGNED_INT */) {
+          return new Uint32Array([memU[0], memU[1], memU[2], memU[3]]);
+        } else {
+          // Default to float
+          return new Float32Array([memF[0], memF[1], memF[2], memF[3]]);
+        }
+      }
+
+      // Other params
+      if (pname === 0x8622 /* ENABLED */ ||
+        pname === 0x886A /* NORMALIZED */ ||
+        pname === 0x88FD /* INTEGER */) {
+        return mem[0] !== 0;
+      }
+
+      if (pname === 0x889F /* BUFFER_BINDING */) {
+        const handle = memU[0];
+        if (handle === 0) return null;
+        return new WasmWebGLBuffer(this, handle);
+      }
+
+      return mem[0];
+    } finally {
+      ex.wasm_free(ptr, len);
+    }
+  }
+
+
   getParameter(pname) {
     this._assertNotDestroyed();
     const ex = this._instance.exports;
@@ -1142,6 +1461,10 @@ export class WasmWebGL2RenderingContext {
       }
     }
 
+    if (pname === 0x8869 /* MAX_VERTEX_ATTRIBS */) {
+      return 16;
+    }
+
     throw new Error(`getParameter for ${pname} not implemented`);
   }
   getError() {
@@ -1152,6 +1475,14 @@ export class WasmWebGL2RenderingContext {
     }
     return ex.wasm_ctx_get_error(this._ctxHandle);
   }
+
+  _setError(error) {
+    const ex = this._instance.exports;
+    if (ex && typeof ex.wasm_ctx_set_gl_error === 'function') {
+      ex.wasm_ctx_set_gl_error(this._ctxHandle, error);
+    }
+  }
+
   finish() { this._assertNotDestroyed(); throw new Error('not implemented'); }
   flush() { this._assertNotDestroyed(); throw new Error('not implemented'); }
 
@@ -1252,25 +1583,6 @@ export class WasmWebGL2RenderingContext {
     }
     this._verbosity = level;
   }
-
-  /**
-   * Get LCOV coverage report.
-   * @returns {string}
-   */
-  getLcovReport() {
-    // Coverage is global to the WASM module, so we can retrieve it even if context is destroyed.
-    // 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 '';
-  }
 }
 
 /**