@woosh/meep-engine 3.56.0 → 3.57.0

package/src/shade/renderer/shader/type/WebGPUArray.d.ts

@@ -22,9 +22,12 @@ export class WebGPUArray extends WebGPUType {
 }
 export namespace WebGPUArray {
     let f32: WebGPUArray;
+    let f16: WebGPUArray;
     let u32: WebGPUArray;
     let vec4u: Readonly<WebGPUArray>;
     let vec4f: Readonly<WebGPUArray>;
+    let vec2h: Readonly<WebGPUArray>;
+    let vec4h: Readonly<WebGPUArray>;
 }
 import { WebGPUType } from "./WebGPUType.js";
 //# sourceMappingURL=WebGPUArray.d.ts.map

package/src/shade/renderer/shader/type/WebGPUArray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebGPUArray.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/WebGPUArray.js"],"names":[],"mappings":"AAOA;IAkEI;;;;;OAKG;IACH,kBAJW,UAAU,UACV,MAAM,GACJ,WAAW,CAgBvB;IArFD,cAAU;IAEV;;;OAGG;IACH,MAFU,UAAU,GAAC,IAAI,CAEb;IAoCZ,4BAUC;IA8EL;;;OAGG;IACH,SAFU,OAAO,CAEY;;CAN5B;;aAUS,WAAW;aAMX,WAAW;eAMX,SAAS,WAAW,CAAC;eAMrB,SAAS,WAAW,CAAC;;2BA/JJ,iBAAiB"}
+{"version":3,"file":"WebGPUArray.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/WebGPUArray.js"],"names":[],"mappings":"AAOA;IAkEI;;;;;OAKG;IACH,kBAJW,UAAU,UACV,MAAM,GACJ,WAAW,CAgBvB;IArFD,cAAU;IAEV;;;OAGG;IACH,MAFU,UAAU,GAAC,IAAI,CAEb;IAoCZ,4BAUC;IA8EL;;;OAGG;IACH,SAFU,OAAO,CAEY;;CAN5B;;aAUS,WAAW;aAMX,WAAW;aAMX,WAAW;eAMX,SAAS,WAAW,CAAC;eAMrB,SAAS,WAAW,CAAC;eAMrB,SAAS,WAAW,CAAC;eAMrB,SAAS,WAAW,CAAC;;2BAjLJ,iBAAiB"}

package/src/shade/renderer/shader/type/WebGPUArray.js

@@ -1,167 +1,185 @@
-import { assert } from "../../../../core/assert.js";
-import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
-import { round_up } from "../../../../core/math/round_up.js";
-import { CodeChunk } from "../compiler/CodeChunk.js";
-import { f32, u32, vec4f, vec4u } from "./WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUType } from "./WebGPUType.js";
-
-export class WebGPUArray extends WebGPUType {
-    count = -1
-
-    /**
-     * Element type
-     * @type {WebGPUType|null}
-     */
-    type = null;
-
-    get align() {
-        return this.type.align;
-    }
-
-    /**
-     * Bytes this array occupies.
-     *
-     * A RUNTIME-SIZED one counts as a single element, which is WGSL rule for a type whose last
-     * member is unbounded and is the minimum binding size a caller sizing a binding wants.
-     *
-     * This was count * stride with no guard, and count is -1 for a runtime-sized array — the same
-     * -1 runtime_sized tests for — so it answered MINUS one stride. WebGPUStruct then does
-     * cursor = field.offset + field.size, which REWOUND past a trailing unbounded member: a struct
-     * of a u32 header and an array of f32 reported size 0, which is the worst possible wrong
-     * answer downstream. read_gpu_typed_buffer computes its default count as
-     * byteLength / aligned_size, which is Infinity; GPUTypedBuffer.from would ask for a zero-byte
-     * buffer; write_gpu_typed_buffer byteLength - offset >= type.size guard is vacuous. Every
-     * guard against runtime-sized types in this layer is an assert, stripped by the consumer, so
-     * in a shipped build the wrong number propagated rather than an error.
-     *
-     * @returns {number}
-     */
-    get size() {
-        const base_type = this.type;
-
-        const stride = round_up(base_type.size, base_type.align);
-
-        if (this.runtime_sized) {
-            return stride;
-        }
-
-        return this.count * stride;
-    }
-
-    equals(other) {
-        if (this === other) {
-            return true;
-        }
-
-        if (!(other instanceof WebGPUArray)) {
-            return false;
-        }
-
-        return this.type.equals(other.type) && this.count === other.count;
-    }
-
-    hash() {
-        return hash_mix2(
-            this.type.hash(),
-            this.count
-        );
-    }
-
-    get runtime_sized() {
-        return this.count < 0;
-    }
-
-    /**
-     *
-     * @param {WebGPUType} type
-     * @param {number} [count] -1 means "runtime sized", no static size
-     * @returns {WebGPUArray}
-     */
-    static from(type, count = -1) {
-        assert.isInteger(count, 'count');
-
-        assert.defined(type, 'type');
-        assert.notNull(type, 'type');
-        assert.isObject(type, 'type');
-        assert.equal(type.isWebGPUType, true, 'type.isWebGPUType !== true');
-
-        const r = new WebGPUArray();
-
-        r.type = type;
-        r.count = count;
-
-        return r;
-    }
-
-    get requires_declaration() {
-        return this.type.requires_declaration;
-    }
-
-    /**
-     * @type {CodeChunk}
-     */
-    #declaration_chunk
-
-    get declaration_chunk() {
-        if (this.#declaration_chunk === undefined) {
-
-            if (this.type.requires_declaration) {
-                this.#declaration_chunk = this.type.declaration_chunk;
-            } else {
-                this.#declaration_chunk = CodeChunk.empty;
-            }
-        }
-
-        return this.#declaration_chunk;
-    }
-
-    get wgsl_ref() {
-        const type = this.type;
-
-        if (this.runtime_sized) {
-            return `array< ${type.wgsl_ref} >`
-        } else {
-            return `array< ${type.wgsl_ref}, ${this.count} >`;
-        }
-    }
-
-    get wgsl_declaration() {
-        const td = this.type.wgsl_ref;
-
-        if (this.runtime_sized) {
-            return `array< ${td} >`
-        } else {
-            return `array< ${td}, ${this.count} >`;
-        }
-    }
-}
-
-/**
- *
- * @type {boolean}
- */
-WebGPUArray.prototype.isArray = true;
-
-/**
- * @readonly
- * @type {WebGPUArray}
- */
-WebGPUArray.f32 = Object.freeze(WebGPUArray.from(f32));
-
-/**
- * @readonly
- * @type {WebGPUArray}
- */
-WebGPUArray.u32 = Object.freeze(WebGPUArray.from(u32));
-
-/**
- * @readonly
- * @type {Readonly<WebGPUArray>}
- */
-WebGPUArray.vec4u = Object.freeze(WebGPUArray.from(vec4u));
-
-/**
- * @readonly
- * @type {Readonly<WebGPUArray>}
- */
-WebGPUArray.vec4f = Object.freeze(WebGPUArray.from(vec4f));
+import { assert } from "../../../../core/assert.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
+import { round_up } from "../../../../core/math/round_up.js";
+import { CodeChunk } from "../compiler/CodeChunk.js";
+import { f16, f32, u32, vec2h, vec4f, vec4h, vec4u } from "./WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUType } from "./WebGPUType.js";
+
+export class WebGPUArray extends WebGPUType {
+    count = -1
+
+    /**
+     * Element type
+     * @type {WebGPUType|null}
+     */
+    type = null;
+
+    get align() {
+        return this.type.align;
+    }
+
+    /**
+     * Bytes this array occupies.
+     *
+     * A RUNTIME-SIZED one counts as a single element, which is WGSL rule for a type whose last
+     * member is unbounded and is the minimum binding size a caller sizing a binding wants.
+     *
+     * This was count * stride with no guard, and count is -1 for a runtime-sized array — the same
+     * -1 runtime_sized tests for — so it answered MINUS one stride. WebGPUStruct then does
+     * cursor = field.offset + field.size, which REWOUND past a trailing unbounded member: a struct
+     * of a u32 header and an array of f32 reported size 0, which is the worst possible wrong
+     * answer downstream. read_gpu_typed_buffer computes its default count as
+     * byteLength / aligned_size, which is Infinity; GPUTypedBuffer.from would ask for a zero-byte
+     * buffer; write_gpu_typed_buffer byteLength - offset >= type.size guard is vacuous. Every
+     * guard against runtime-sized types in this layer is an assert, stripped by the consumer, so
+     * in a shipped build the wrong number propagated rather than an error.
+     *
+     * @returns {number}
+     */
+    get size() {
+        const base_type = this.type;
+
+        const stride = round_up(base_type.size, base_type.align);
+
+        if (this.runtime_sized) {
+            return stride;
+        }
+
+        return this.count * stride;
+    }
+
+    equals(other) {
+        if (this === other) {
+            return true;
+        }
+
+        if (!(other instanceof WebGPUArray)) {
+            return false;
+        }
+
+        return this.type.equals(other.type) && this.count === other.count;
+    }
+
+    hash() {
+        return hash_mix2(
+            this.type.hash(),
+            this.count
+        );
+    }
+
+    get runtime_sized() {
+        return this.count < 0;
+    }
+
+    /**
+     *
+     * @param {WebGPUType} type
+     * @param {number} [count] -1 means "runtime sized", no static size
+     * @returns {WebGPUArray}
+     */
+    static from(type, count = -1) {
+        assert.isInteger(count, 'count');
+
+        assert.defined(type, 'type');
+        assert.notNull(type, 'type');
+        assert.isObject(type, 'type');
+        assert.equal(type.isWebGPUType, true, 'type.isWebGPUType !== true');
+
+        const r = new WebGPUArray();
+
+        r.type = type;
+        r.count = count;
+
+        return r;
+    }
+
+    get requires_declaration() {
+        return this.type.requires_declaration;
+    }
+
+    /**
+     * @type {CodeChunk}
+     */
+    #declaration_chunk
+
+    get declaration_chunk() {
+        if (this.#declaration_chunk === undefined) {
+
+            if (this.type.requires_declaration) {
+                this.#declaration_chunk = this.type.declaration_chunk;
+            } else {
+                this.#declaration_chunk = CodeChunk.empty;
+            }
+        }
+
+        return this.#declaration_chunk;
+    }
+
+    get wgsl_ref() {
+        const type = this.type;
+
+        if (this.runtime_sized) {
+            return `array< ${type.wgsl_ref} >`
+        } else {
+            return `array< ${type.wgsl_ref}, ${this.count} >`;
+        }
+    }
+
+    get wgsl_declaration() {
+        const td = this.type.wgsl_ref;
+
+        if (this.runtime_sized) {
+            return `array< ${td} >`
+        } else {
+            return `array< ${td}, ${this.count} >`;
+        }
+    }
+}
+
+/**
+ *
+ * @type {boolean}
+ */
+WebGPUArray.prototype.isArray = true;
+
+/**
+ * @readonly
+ * @type {WebGPUArray}
+ */
+WebGPUArray.f32 = Object.freeze(WebGPUArray.from(f32));
+
+/**
+ * @readonly
+ * @type {WebGPUArray}
+ */
+WebGPUArray.f16 = Object.freeze(WebGPUArray.from(f16));
+
+/**
+ * @readonly
+ * @type {WebGPUArray}
+ */
+WebGPUArray.u32 = Object.freeze(WebGPUArray.from(u32));
+
+/**
+ * @readonly
+ * @type {Readonly<WebGPUArray>}
+ */
+WebGPUArray.vec4u = Object.freeze(WebGPUArray.from(vec4u));
+
+/**
+ * @readonly
+ * @type {Readonly<WebGPUArray>}
+ */
+WebGPUArray.vec4f = Object.freeze(WebGPUArray.from(vec4f));
+
+/**
+ * @readonly
+ * @type {Readonly<WebGPUArray>}
+ */
+WebGPUArray.vec2h = Object.freeze(WebGPUArray.from(vec2h));
+
+/**
+ * @readonly
+ * @type {Readonly<WebGPUArray>}
+ */
+WebGPUArray.vec4h = Object.freeze(WebGPUArray.from(vec4h));

package/src/shade/renderer/shader/type/WebGPUStruct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebGPUStruct.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/WebGPUStruct.js"],"names":[],"mappings":"AA2BA;;;;GAIG;AACH;IAmNI;;;;;;;;;;;;;;OAcG;IACH,8BAHW,MAAM,GACL,YAAY,CAiCvB;IAED;;;;OAIG;IACH,6BAHc,eAAe,KACjB,YAAY,CAiBvB;IA5QD;;;OAGG;IACH,uBAEC;IAVD,kBAEC;IAUD;;;OAGG;IACH,iBAFU,eAAe,EAAE,CAEf;IAmBZ;;;;OAIG;IACH,YAHW,YAAY,GACV,IAAI,CAwBhB;IAED;;;OAGG;IACH,SAFY,YAAY,CAUvB;IAED;;;;;;;;OAQG;IACH,kBAJa,MAAM,CA+BlB;IAED;;;;;;OAMG;IACH,QAFa,IAAI,CAoChB;IAED,4BAYC;IAuGD;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,GACL,eAAe,CAa1B;IA8GL;;;OAGG;IACH,mBAFU,OAAO,CAEc;;CAN9B;2BAvb0B,iBAAiB;gCAEZ,sBAAsB"}
+{"version":3,"file":"WebGPUStruct.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/WebGPUStruct.js"],"names":[],"mappings":"AA6BA;;;;GAIG;AACH;IAmNI;;;;;;;;;;;;;;OAcG;IACH,8BAHW,MAAM,GACL,YAAY,CAiCvB;IAED;;;;OAIG;IACH,6BAHc,eAAe,KACjB,YAAY,CAiBvB;IA5QD;;;OAGG;IACH,uBAEC;IAVD,kBAEC;IAUD;;;OAGG;IACH,iBAFU,eAAe,EAAE,CAEf;IAmBZ;;;;OAIG;IACH,YAHW,YAAY,GACV,IAAI,CAwBhB;IAED;;;OAGG;IACH,SAFY,YAAY,CAUvB;IAED;;;;;;;;OAQG;IACH,kBAJa,MAAM,CA+BlB;IAED;;;;;;OAMG;IACH,QAFa,IAAI,CAoChB;IAED,4BAYC;IAuGD;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,GACL,eAAe,CAa1B;IAkHL;;;OAGG;IACH,mBAFU,OAAO,CAEc;;CAN9B;2BA3b0B,iBAAiB;gCAEZ,sBAAsB"}