@thi.ng/wasm-api-webgl 0.1.0

package/generated/api.js

@@ -0,0 +1,546 @@
+import { Pointer, WasmStringPtr } from "@thi.ng/wasm-api";
+import { __array, __instanceArray, __slice32, __primslice32 } from "@thi.ng/wasm-api/memory";
+const $WebGLContextOpts = (mem) => ({
+  get align() {
+    return 1;
+  },
+  get size() {
+    return 9;
+  },
+  instanceArray(base, num) {
+    return __instanceArray(this, base, num);
+  },
+  instance: (base) => {
+    return {
+      get __base() {
+        return base;
+      },
+      get __bytes() {
+        return mem.u8.subarray(base, base + 9);
+      },
+      get alpha() {
+        return mem.u8[base];
+      },
+      get antialias() {
+        return mem.u8[base + 1];
+      },
+      get depth() {
+        return mem.u8[base + 2];
+      },
+      get desynchronized() {
+        return mem.u8[base + 3];
+      },
+      get failIfMajorPerformanceCaveat() {
+        return mem.u8[base + 4];
+      },
+      get powerPreference() {
+        return mem.u8[base + 5];
+      },
+      get premultipliedAlpha() {
+        return mem.u8[base + 6];
+      },
+      get preserveDrawingBuffer() {
+        return mem.u8[base + 7];
+      },
+      get stencil() {
+        return mem.u8[base + 8];
+      }
+    };
+  }
+});
+var WebGLPowerPreference = /* @__PURE__ */ ((WebGLPowerPreference2) => {
+  WebGLPowerPreference2[WebGLPowerPreference2["default"] = 0] = "default";
+  WebGLPowerPreference2[WebGLPowerPreference2["high_performance"] = 1] = "high_performance";
+  WebGLPowerPreference2[WebGLPowerPreference2["low_power"] = 2] = "low_power";
+  return WebGLPowerPreference2;
+})(WebGLPowerPreference || {});
+const $ShaderSpec = (mem) => ({
+  get align() {
+    return 4;
+  },
+  get size() {
+    return 32;
+  },
+  instanceArray(base, num) {
+    return __instanceArray(this, base, num);
+  },
+  instance: (base) => {
+    let $vs = null;
+    let $fs = null;
+    return {
+      get __base() {
+        return base;
+      },
+      get __bytes() {
+        return mem.u8.subarray(base, base + 32);
+      },
+      get vs() {
+        return $vs || ($vs = new WasmStringPtr(mem, base, true));
+      },
+      get fs() {
+        return $fs || ($fs = new WasmStringPtr(mem, base + 4, true));
+      },
+      get attribs() {
+        return __slice32(mem, $ShaderAttribSpec, base + 8);
+      },
+      get varying() {
+        return __slice32(mem, $ShaderVaryingSpec, base + 16);
+      },
+      get uniforms() {
+        return __slice32(mem, $ShaderUniformSpec, base + 24);
+      }
+    };
+  }
+});
+const $ShaderAttribSpec = (mem) => ({
+  get align() {
+    return 4;
+  },
+  get size() {
+    return 8;
+  },
+  instanceArray(base, num) {
+    return __instanceArray(this, base, num);
+  },
+  instance: (base) => {
+    let $name = null;
+    return {
+      get __base() {
+        return base;
+      },
+      get __bytes() {
+        return mem.u8.subarray(base, base + 8);
+      },
+      get name() {
+        return $name || ($name = new WasmStringPtr(mem, base, true));
+      },
+      get type() {
+        return mem.u8[base + 4];
+      }
+    };
+  }
+});
+const $ShaderVaryingSpec = (mem) => ({
+  get align() {
+    return 4;
+  },
+  get size() {
+    return 8;
+  },
+  instanceArray(base, num) {
+    return __instanceArray(this, base, num);
+  },
+  instance: (base) => {
+    let $name = null;
+    return {
+      get __base() {
+        return base;
+      },
+      get __bytes() {
+        return mem.u8.subarray(base, base + 8);
+      },
+      get name() {
+        return $name || ($name = new WasmStringPtr(mem, base, true));
+      },
+      get type() {
+        return mem.u8[base + 4];
+      }
+    };
+  }
+});
+const $ShaderUniformSpec = (mem) => ({
+  get align() {
+    return 16;
+  },
+  get size() {
+    return 32;
+  },
+  instanceArray(base, num) {
+    return __instanceArray(this, base, num);
+  },
+  instance: (base) => {
+    let $name = null;
+    return {
+      get __base() {
+        return base;
+      },
+      get __bytes() {
+        return mem.u8.subarray(base, base + 32);
+      },
+      get name() {
+        return $name || ($name = new WasmStringPtr(mem, base, true));
+      },
+      get type() {
+        return mem.u8[base + 4];
+      },
+      get default() {
+        return $UniformValue(mem).instance(base + 16);
+      }
+    };
+  }
+});
+const $ModelSpec = (mem) => ({
+  get align() {
+    return 4;
+  },
+  get size() {
+    return 48;
+  },
+  instanceArray(base, num) {
+    return __instanceArray(this, base, num);
+  },
+  instance: (base) => {
+    return {
+      get __base() {
+        return base;
+      },
+      get __bytes() {
+        return mem.u8.subarray(base, base + 48);
+      },
+      get attribs() {
+        return __slice32(mem, $ModelAttribSpec, base);
+      },
+      get instances() {
+        return __slice32(mem, $ModelAttribSpec, base + 8);
+      },
+      get uniforms() {
+        return __slice32(mem, $ModelUniform, base + 16);
+      },
+      get textures() {
+        return __primslice32(mem, mem.i32, base + 24, 2);
+      },
+      get shader() {
+        return mem.i32[base + 32 >>> 2];
+      },
+      get num() {
+        return mem.u32[base + 36 >>> 2];
+      },
+      get numInstances() {
+        return mem.u32[base + 40 >>> 2];
+      },
+      get mode() {
+        return mem.u8[base + 44];
+      }
+    };
+  }
+});
+const $ModelAttribSpec = (mem) => ({
+  get align() {
+    return 4;
+  },
+  get size() {
+    return 28;
+  },
+  instanceArray(base, num) {
+    return __instanceArray(this, base, num);
+  },
+  instance: (base) => {
+    let $name = null;
+    return {
+      get __base() {
+        return base;
+      },
+      get __bytes() {
+        return mem.u8.subarray(base, base + 28);
+      },
+      get name() {
+        return $name || ($name = new WasmStringPtr(mem, base, true));
+      },
+      get data() {
+        return $ModelAttribData(mem).instance(base + 4);
+      },
+      get type() {
+        return mem.u16[base + 12 >>> 1];
+      },
+      get offset() {
+        return mem.u32[base + 16 >>> 2];
+      },
+      get stride() {
+        return mem.u32[base + 20 >>> 2];
+      },
+      get size() {
+        return mem.u32[base + 24 >>> 2];
+      }
+    };
+  }
+});
+const $ModelAttribData = (mem) => ({
+  get align() {
+    return 4;
+  },
+  get size() {
+    return 8;
+  },
+  instanceArray(base, num) {
+    return __instanceArray(this, base, num);
+  },
+  instance: (base) => {
+    return {
+      get __base() {
+        return base;
+      },
+      get __bytes() {
+        return mem.u8.subarray(base, base + 8);
+      },
+      get u8() {
+        return __primslice32(mem, mem.i8, base, 0);
+      },
+      get i8() {
+        return __primslice32(mem, mem.u8, base, 0);
+      },
+      get i16() {
+        return __primslice32(mem, mem.i16, base, 1);
+      },
+      get u16() {
+        return __primslice32(mem, mem.u16, base, 1);
+      },
+      get u32() {
+        return __primslice32(mem, mem.i32, base, 2);
+      },
+      get i32() {
+        return __primslice32(mem, mem.u32, base, 2);
+      },
+      get f32() {
+        return __primslice32(mem, mem.f32, base, 2);
+      }
+    };
+  }
+});
+const $AttribUpdateSpec = (mem) => ({
+  get align() {
+    return 4;
+  },
+  get size() {
+    return 16;
+  },
+  instanceArray(base, num) {
+    return __instanceArray(this, base, num);
+  },
+  instance: (base) => {
+    return {
+      get __base() {
+        return base;
+      },
+      get __bytes() {
+        return mem.u8.subarray(base, base + 16);
+      },
+      get data() {
+        return $ModelAttribData(mem).instance(base);
+      },
+      get type() {
+        return mem.u16[base + 8 >>> 1];
+      },
+      get offset() {
+        return mem.u32[base + 12 >>> 2];
+      }
+    };
+  }
+});
+const $ModelUniform = (mem) => ({
+  get align() {
+    return 16;
+  },
+  get size() {
+    return 32;
+  },
+  instanceArray(base, num) {
+    return __instanceArray(this, base, num);
+  },
+  instance: (base) => {
+    let $name = null;
+    return {
+      get __base() {
+        return base;
+      },
+      get __bytes() {
+        return mem.u8.subarray(base, base + 32);
+      },
+      get name() {
+        return $name || ($name = new WasmStringPtr(mem, base, true));
+      },
+      get type() {
+        return mem.u8[base + 4];
+      },
+      get value() {
+        return $UniformValue(mem).instance(base + 16);
+      }
+    };
+  }
+});
+const $UniformValue = (mem) => ({
+  get align() {
+    return 16;
+  },
+  get size() {
+    return 16;
+  },
+  instanceArray(base, num) {
+    return __instanceArray(this, base, num);
+  },
+  instance: (base) => {
+    return {
+      get __base() {
+        return base;
+      },
+      get __bytes() {
+        return mem.u8.subarray(base, base + 16);
+      },
+      get float() {
+        return mem.f32[base >>> 2];
+      },
+      get vec2() {
+        const addr = base >>> 2;
+        return mem.f32.subarray(addr, addr + 2);
+      },
+      get vec3() {
+        const addr = base >>> 2;
+        return mem.f32.subarray(addr, addr + 3);
+      },
+      get vec4() {
+        const addr = base >>> 2;
+        return mem.f32.subarray(addr, addr + 4);
+      }
+    };
+  }
+});
+const $TextureSpec = (mem) => ({
+  get align() {
+    return 4;
+  },
+  get size() {
+    return 28;
+  },
+  instanceArray(base, num) {
+    return __instanceArray(this, base, num);
+  },
+  instance: (base) => {
+    return {
+      get __base() {
+        return base;
+      },
+      get __bytes() {
+        return mem.u8.subarray(base, base + 28);
+      },
+      get img() {
+        return $ImageData(mem).instance(base);
+      },
+      get width() {
+        return mem.u16[base + 8 >>> 1];
+      },
+      get height() {
+        return mem.u16[base + 10 >>> 1];
+      },
+      get depth() {
+        return mem.u16[base + 12 >>> 1];
+      },
+      get format() {
+        return mem.u16[base + 14 >>> 1];
+      },
+      get target() {
+        return mem.u16[base + 16 >>> 1];
+      },
+      get type() {
+        return mem.u16[base + 18 >>> 1];
+      },
+      get filter() {
+        return mem.u16[base + 20 >>> 1];
+      },
+      get wrap() {
+        return mem.u16[base + 22 >>> 1];
+      },
+      get imgType() {
+        return mem.u8[base + 24];
+      }
+    };
+  }
+});
+const $ImageData = (mem) => ({
+  get align() {
+    return 4;
+  },
+  get size() {
+    return 8;
+  },
+  instanceArray(base, num) {
+    return __instanceArray(this, base, num);
+  },
+  instance: (base) => {
+    return {
+      get __base() {
+        return base;
+      },
+      get __bytes() {
+        return mem.u8.subarray(base, base + 8);
+      },
+      get none() {
+        return mem.u32[base >>> 2];
+      },
+      get u8() {
+        return __primslice32(mem, mem.u8, base, 0);
+      },
+      get u16() {
+        return __primslice32(mem, mem.u16, base, 1);
+      },
+      get u32() {
+        return __primslice32(mem, mem.u32, base, 2);
+      },
+      get f32() {
+        return __primslice32(mem, mem.f32, base, 2);
+      }
+    };
+  }
+});
+var ImageType = /* @__PURE__ */ ((ImageType2) => {
+  ImageType2[ImageType2["none"] = 0] = "none";
+  ImageType2[ImageType2["u8"] = 1] = "u8";
+  ImageType2[ImageType2["u16"] = 2] = "u16";
+  ImageType2[ImageType2["u32"] = 3] = "u32";
+  ImageType2[ImageType2["f32"] = 4] = "f32";
+  return ImageType2;
+})(ImageType || {});
+var ShaderAttribType = /* @__PURE__ */ ((ShaderAttribType2) => {
+  ShaderAttribType2[ShaderAttribType2["float"] = 0] = "float";
+  ShaderAttribType2[ShaderAttribType2["int"] = 1] = "int";
+  ShaderAttribType2[ShaderAttribType2["uint"] = 2] = "uint";
+  ShaderAttribType2[ShaderAttribType2["vec2"] = 3] = "vec2";
+  ShaderAttribType2[ShaderAttribType2["vec3"] = 4] = "vec3";
+  ShaderAttribType2[ShaderAttribType2["vec4"] = 5] = "vec4";
+  ShaderAttribType2[ShaderAttribType2["mat22"] = 6] = "mat22";
+  ShaderAttribType2[ShaderAttribType2["mat33"] = 7] = "mat33";
+  ShaderAttribType2[ShaderAttribType2["mat44"] = 8] = "mat44";
+  return ShaderAttribType2;
+})(ShaderAttribType || {});
+var UniformType = /* @__PURE__ */ ((UniformType2) => {
+  UniformType2[UniformType2["float"] = 0] = "float";
+  UniformType2[UniformType2["int"] = 1] = "int";
+  UniformType2[UniformType2["uint"] = 2] = "uint";
+  UniformType2[UniformType2["vec2"] = 3] = "vec2";
+  UniformType2[UniformType2["vec3"] = 4] = "vec3";
+  UniformType2[UniformType2["vec4"] = 5] = "vec4";
+  UniformType2[UniformType2["mat22"] = 6] = "mat22";
+  UniformType2[UniformType2["mat33"] = 7] = "mat33";
+  UniformType2[UniformType2["mat44"] = 8] = "mat44";
+  UniformType2[UniformType2["sampler2D"] = 9] = "sampler2D";
+  UniformType2[UniformType2["sampler3D"] = 10] = "sampler3D";
+  UniformType2[UniformType2["samplerCube"] = 11] = "samplerCube";
+  return UniformType2;
+})(UniformType || {});
+export {
+  $AttribUpdateSpec,
+  $ImageData,
+  $ModelAttribData,
+  $ModelAttribSpec,
+  $ModelSpec,
+  $ModelUniform,
+  $ShaderAttribSpec,
+  $ShaderSpec,
+  $ShaderUniformSpec,
+  $ShaderVaryingSpec,
+  $TextureSpec,
+  $UniformValue,
+  $WebGLContextOpts,
+  ImageType,
+  ShaderAttribType,
+  UniformType,
+  WebGLPowerPreference
+};

package/gl.d.ts

@@ -0,0 +1,46 @@
+import type { IWasmAPI, MemoryViewType, WasmBridge, WasmModuleSpec, WasmType } from "@thi.ng/wasm-api";
+import { type WasmDom } from "@thi.ng/wasm-api-dom";
+import { ObjectIndex } from "@thi.ng/wasm-api/object-index";
+import type { ITexture, Shader, ModelSpec as WEBGL_ModelSpec } from "@thi.ng/webgl";
+import type { AttribUpdateSpec, WasmWebGLExports, WasmWebGLImports, WebGLContextOpts } from "./api.js";
+import { type ModelSpec, type ShaderSpec, type TextureSpec, type UniformValue } from "./generated/api.js";
+/**
+ * WASM module descriptor for use as dependency object in other module
+ * definitions or for direct use with
+ * [`WasmBridge`](https://docs.thi.ng/umbrella/wasm-api/classes/WasmBridge.html).
+ *
+ * @remarks
+ * Module defines the following dependencies:
+ * - [WasmDomModule](https://docs.thi.ng/umbrella/wasm-api-dom/variables/WasmDomModule.html)
+ *
+ * See
+ * [`WasmModuleSpec`](https://docs.thi.ng/umbrella/wasm-api/interfaces/WasmModuleSpec.html)
+ * for more details.
+ */
+export declare const WasmWebGLModule: WasmModuleSpec<WasmWebGLExports>;
+export declare class WasmWebGL implements IWasmAPI<WasmWebGLExports> {
+    parent: WasmBridge<WasmWebGLExports>;
+    dom: WasmDom;
+    contexts: ObjectIndex<WebGL2RenderingContext>;
+    models: ObjectIndex<WEBGL_ModelSpec>;
+    shaders: ObjectIndex<Shader>;
+    textures: ObjectIndex<ITexture>;
+    $ShaderSpec: WasmType<ShaderSpec>;
+    $ModelSpec: WasmType<ModelSpec>;
+    $TextureSpec: WasmType<TextureSpec>;
+    $UniformValue: WasmType<UniformValue>;
+    $AttribUpdateSpec: WasmType<AttribUpdateSpec>;
+    $WebGLContextOpts: WasmType<WebGLContextOpts>;
+    init(parent: WasmBridge<WasmWebGLExports>): Promise<boolean>;
+    getImports(): WasmWebGLImports;
+    /**
+     * Shared handler for setting a scalar uniform in a ModelSpec
+     *
+     * @param modelID
+     * @param name
+     * @param value
+     */
+    uniformScalar(modelID: number, name: number, value: number): void;
+    uniformVec(modelID: number, name: number, type: MemoryViewType, addr: number, size: number): void;
+}
+//# sourceMappingURL=gl.d.ts.map