@woosh/meep-engine 3.55.0 → 3.57.0

package/src/shade/renderer/shader/type/serde/write_gpu_typed_buffer.js

@@ -1,221 +1,329 @@
-import { assert } from "../../../../../core/assert.js";
-import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
-import { platform_compute_endianness } from "../../../../../core/binary/platform_compute_endianness.js";
-import {
-    atomic_i32,
-    atomic_u32,
-    bool,
-    f32,
-    i32,
-    mat2x3f,
-    mat3x2f,
-    mat3x3f,
-    mat4x4f,
-    u32,
-    vec2f,
-    vec2i,
-    vec2u,
-    vec3f,
-    vec3i,
-    vec3u,
-    vec4f,
-    vec4i,
-    vec4u
-} from "../WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../WebGPUArray.js";
-import { WebGPUStruct } from "../WebGPUStruct.js";
-
-/**
- * @template T
- * @param {T[]} value
- * @param {BinaryBuffer} buffer
- * @param {WebGPUArray} type
- */
-function write_array_value(
-    value,
-    buffer,
-    type
-) {
-    assert.notOk(type.runtime_sized, 'array does not have a static count, it is runtime sized. Runtime sized arrays are not supported');
-
-    const count = type.count;
-
-    // WGSL array stride is the element type's `aligned_size` — i.e.
-    // `round_up(size, align)`. For arrays of primitives where alignment
-    // matches size (vec4f, mat4x4f, etc.), aligned_size == size and the
-    // distinction is invisible. For arrays of structs, the gap is real:
-    // a struct of {mat4x4f, u32} packs to size 68 (mat at offset 0,
-    // u32 at offset 64) but its aligned_size is 80 (round_up(68, 16)
-    // for mat4x4f's 16-byte alignment requirement). Without this seek,
-    // each subsequent element would land 12 bytes too early, every
-    // shader read at WGSL's stride-aligned offset would land in the
-    // previous element's tail-padding region, and the values would be
-    // garbage from element 1 onward — element 0 lands at offset 0
-    // either way, so the bug is silent on single-element arrays.
-    //
-    // The matching read path (`read_array_value`) has the same gap and
-    // needs the same fix; if only one of the two is patched, CPU
-    // round-trips would look fine while the GPU side reads garbage.
-    const element_stride = type.type.aligned_size;
-    const array_start = buffer.position;
-
-    for (let i = 0; i < count; i++) {
-        buffer.position = array_start + i * element_stride;
-        write_wgsl_type_value(value[i], buffer, type.type);
-    }
-
-    // Park the cursor at the end of the array's stride-sized footprint
-    // so the next field in any enclosing struct lands at its declared
-    // offset (struct field writes seek to `record_address + field.offset`
-    // anyway, but a correct trailing position keeps stand-alone array
-    // writes — and the unit tests that verify them — sound).
-    buffer.position = array_start + count * element_stride;
-}
-
-/**
- *
- * @param {*} value
- * @param {BinaryBuffer} buffer
- * @param {WebGPUStruct} struct
- */
-function write_struct_value(value, buffer, struct) {
-    assert.isObject(value, 'value');
-
-    const fields = struct.fields;
-    const record_address = buffer.position;
-
-    const field_count = fields.length;
-
-    for (let j = 0; j < field_count; j++) {
-        const field = fields[j];
-
-        buffer.position = record_address + field.offset;
-
-        const field_value = value[field.name];
-
-        if (field_value === undefined) {
-            // skip missing fields
-            continue;
-        }
-
-        write_wgsl_type_value(field_value, buffer, field.type);
-    }
-
-    // TODO we can check for extra fields that are named in the value but are not part of the struct
-}
-
-/**
- * Note: this function does not perform any initial alignment.
- * @param {*} value
- * @param {BinaryBuffer} buffer
- * @param {WebGPUType} type
- * @returns {void}
- */
-export function write_wgsl_type_value(value, buffer, type) {
-    assert.defined(value, 'value');
-    assert.defined(buffer, 'buffer');
-    assert.defined(type, 'type');
-
-    if (type instanceof WebGPUArray) {
-        return write_array_value(value, buffer, type);
-    }
-
-    if (type instanceof WebGPUStruct) {
-        return write_struct_value(value, buffer, type);
-    }
-
-    switch (type) {
-        case bool:
-            assert.isBoolean(value, 'value');
-            return buffer.writeUint32(value ? 1 : 0);
-
-        case u32:
-        case atomic_u32:
-            assert.isNonNegativeInteger(value, 'value');
-            return buffer.writeUint32(value);
-        case i32:
-        case atomic_i32:
-            assert.isInteger(value, 'value');
-            return buffer.writeInt32(value);
-        case f32:
-            assert.isNumber(value, 'value');
-            return buffer.writeFloat32(value);
-
-        case vec2i:
-            return buffer.writeInt32Array(value, 0, 2);
-        case vec3i:
-            return buffer.writeInt32Array(value, 0, 3);
-        case vec4i:
-            return buffer.writeInt32Array(value, 0, 4);
-
-        case vec2u:
-            return buffer.writeUint32Array(value, 0, 2);
-        case vec3u:
-            return buffer.writeUint32Array(value, 0, 3);
-        case vec4u:
-            return buffer.writeUint32Array(value, 0, 4);
-
-        case vec2f:
-            return buffer.writeFloat32Array(value, 0, 2);
-        case vec3f:
-            return buffer.writeFloat32Array(value, 0, 3);
-        case vec4f:
-            return buffer.writeFloat32Array(value, 0, 4);
-
-        case mat4x4f:
-            return buffer.writeFloat32Array(value, 0, 16);
-        case mat3x3f:
-            return buffer.writeFloat32Array(value, 0, 9);
-        case mat3x2f:
-        case mat2x3f:
-            return buffer.writeFloat32Array(value, 0, 6);
-        default:
-            throw new Error(`Unsupported type ${type}`);
-    }
-}
-
-const scratch_buffer = new BinaryBuffer();
-// platform endianness is needed for marshaling data to the GPU
-scratch_buffer.endianness = platform_compute_endianness();
-
-/**
- *
- * @param {*} value
- * @param {WebGPUType} type
- * @param {ArrayBuffer} data
- * @param {number} [byteOffset]
- */
-export function write_gpu_typed_buffer(
-    value,
-    type,
-    data,
-    byteOffset = 0
-) {
-
-    assert.defined(value, 'value');
-
-    assert.defined(type, 'type');
-    assert.equal(type.isWebGPUType, true, 'type.isWebGPUType !== true');
-
-    assert.defined(data, 'data');
-    assert.isInstanceOf(data, ArrayBuffer, 'data');
-
-    assert.isNonNegativeInteger(byteOffset, 'byteOffset');
-    assert.greaterThanOrEqual(data.byteLength - byteOffset, type.size, "Data buffer is too small");
-
-    if (scratch_buffer.data !== data || scratch_buffer.capacity !== data.byteLength) {
-        // Bound afresh only for a buffer it is not bound to already: binding makes a DataView and a
-        // Uint8Array, and a command context's uniforms arrive one after another into the same
-        // upload block. The length is compared as well, so a buffer the scratch grew away from, or
-        // one detached since, is bound anew rather than written through stale views.
-        scratch_buffer.fromArrayBuffer(data);
-    }
-
-    scratch_buffer.position = byteOffset;
-
-    assert.equal(scratch_buffer.data, data, 'scratch_buffer.buffer !== data'); // sanity check
-
-    write_wgsl_type_value(value, scratch_buffer, type);
-
-}
-
+import { assert } from "../../../../../core/assert.js";
+import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
+import { platform_compute_endianness } from "../../../../../core/binary/platform_compute_endianness.js";
+import {
+    atomic_i32,
+    atomic_u32,
+    bool,
+    f16,
+    f32,
+    i32,
+    mat2x2f,
+    mat2x2h,
+    mat2x3f,
+    mat2x3h,
+    mat2x4f,
+    mat2x4h,
+    mat3x2f,
+    mat3x2h,
+    mat3x3f,
+    mat3x3h,
+    mat3x4f,
+    mat3x4h,
+    mat4x2f,
+    mat4x2h,
+    mat4x3f,
+    mat4x3h,
+    mat4x4f,
+    mat4x4h,
+    u32,
+    vec2f,
+    vec2h,
+    vec2i,
+    vec2u,
+    vec3f,
+    vec3h,
+    vec3i,
+    vec3u,
+    vec4f,
+    vec4h,
+    vec4i,
+    vec4u
+} from "../WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../WebGPUArray.js";
+import { WebGPUStruct } from "../WebGPUStruct.js";
+
+/**
+ * @template T
+ * @param {T[]} value
+ * @param {BinaryBuffer} buffer
+ * @param {WebGPUArray} type
+ */
+function write_array_value(
+    value,
+    buffer,
+    type
+) {
+    assert.notOk(type.runtime_sized, 'array does not have a static count, it is runtime sized. Runtime sized arrays are not supported');
+
+    const count = type.count;
+
+    // WGSL array stride is the element type's `aligned_size` — i.e.
+    // `round_up(size, align)`. For arrays of primitives where alignment
+    // matches size (vec4f, mat4x4f, etc.), aligned_size == size and the
+    // distinction is invisible. For arrays of structs, the gap is real:
+    // a struct of {mat4x4f, u32} packs to size 68 (mat at offset 0,
+    // u32 at offset 64) but its aligned_size is 80 (round_up(68, 16)
+    // for mat4x4f's 16-byte alignment requirement). Without this seek,
+    // each subsequent element would land 12 bytes too early, every
+    // shader read at WGSL's stride-aligned offset would land in the
+    // previous element's tail-padding region, and the values would be
+    // garbage from element 1 onward — element 0 lands at offset 0
+    // either way, so the bug is silent on single-element arrays.
+    //
+    // The matching read path (`read_array_value`) has the same gap and
+    // needs the same fix; if only one of the two is patched, CPU
+    // round-trips would look fine while the GPU side reads garbage.
+    const element_stride = type.type.aligned_size;
+    const array_start = buffer.position;
+
+    for (let i = 0; i < count; i++) {
+        buffer.position = array_start + i * element_stride;
+        write_wgsl_type_value(value[i], buffer, type.type);
+    }
+
+    // Park the cursor at the end of the array's stride-sized footprint
+    // so the next field in any enclosing struct lands at its declared
+    // offset (struct field writes seek to `record_address + field.offset`
+    // anyway, but a correct trailing position keeps stand-alone array
+    // writes — and the unit tests that verify them — sound).
+    buffer.position = array_start + count * element_stride;
+}
+
+/**
+ *
+ * @param {*} value
+ * @param {BinaryBuffer} buffer
+ * @param {WebGPUStruct} struct
+ */
+function write_struct_value(value, buffer, struct) {
+    assert.isObject(value, 'value');
+
+    const fields = struct.fields;
+    const record_address = buffer.position;
+
+    const field_count = fields.length;
+
+    for (let j = 0; j < field_count; j++) {
+        const field = fields[j];
+
+        buffer.position = record_address + field.offset;
+
+        const field_value = value[field.name];
+
+        if (field_value === undefined) {
+            // skip missing fields
+            continue;
+        }
+
+        write_wgsl_type_value(field_value, buffer, field.type);
+    }
+
+    buffer.position = record_address + struct.size;
+
+    // TODO we can check for extra fields that are named in the value but are not part of the struct
+}
+
+/**
+ * In WGSL host-shareable memory, `matCx3<f32>` is laid out as `array<vec3<f32>, C>` where each
+ * 3-component column is aligned to 16 bytes (12 bytes of payload + 4 bytes of column padding),
+ * while on the CPU a `matCx3` value is a flat `C * 3` array of column-major components.
+ *
+ * @param {Float32Array|number[]|ArrayLike<number>} value
+ * @param {BinaryBuffer} buffer
+ * @param {number} columns
+ */
+function write_mat_cx3_f32(value, buffer, columns) {
+    assert.isArrayLike(value, 'value');
+    assert.greaterThanOrEqual(value.length, columns * 3, 'source underflow');
+
+    const start = buffer.position;
+    buffer.ensureCapacity(start + columns * 16);
+
+    for (let c = 0; c < columns; c++) {
+        buffer.position = start + c * 16;
+        buffer.writeFloat32Array(value, c * 3, 3);
+    }
+
+    buffer.position = start + columns * 16;
+}
+
+/**
+ * In WGSL host-shareable memory, `matCx3<f16>` is laid out as `array<vec3<f16>, C>` where each
+ * 3-component column is aligned to 8 bytes (6 bytes of payload + 2 bytes of column padding),
+ * while on the CPU a `matCx3h` value is a flat `C * 3` array of column-major components.
+ *
+ * @param {Float16Array|Float32Array|number[]|ArrayLike<number>} value
+ * @param {BinaryBuffer} buffer
+ * @param {number} columns
+ */
+function write_mat_cx3_f16(value, buffer, columns) {
+    assert.isArrayLike(value, 'value');
+    assert.greaterThanOrEqual(value.length, columns * 3, 'source underflow');
+
+    const start = buffer.position;
+    buffer.ensureCapacity(start + columns * 8);
+
+    for (let c = 0; c < columns; c++) {
+        buffer.position = start + c * 8;
+        buffer.writeFloat16Array(value, c * 3, 3);
+    }
+
+    buffer.position = start + columns * 8;
+}
+
+/**
+ * Note: this function does not perform any initial alignment.
+ * @param {*} value
+ * @param {BinaryBuffer} buffer
+ * @param {WebGPUType} type
+ * @returns {void}
+ */
+export function write_wgsl_type_value(value, buffer, type) {
+    assert.defined(value, 'value');
+    assert.defined(buffer, 'buffer');
+    assert.defined(type, 'type');
+
+    if (type instanceof WebGPUArray) {
+        return write_array_value(value, buffer, type);
+    }
+
+    if (type instanceof WebGPUStruct) {
+        return write_struct_value(value, buffer, type);
+    }
+
+    switch (type) {
+        case bool:
+            assert.isBoolean(value, 'value');
+            return buffer.writeUint32(value ? 1 : 0);
+
+        case u32:
+        case atomic_u32:
+            assert.isNonNegativeInteger(value, 'value');
+            return buffer.writeUint32(value);
+        case i32:
+        case atomic_i32:
+            assert.isInteger(value, 'value');
+            return buffer.writeInt32(value);
+        case f32:
+            assert.isNumber(value, 'value');
+            return buffer.writeFloat32(value);
+        case f16:
+            assert.isNumber(value, 'value');
+            return buffer.writeFloat16(value);
+
+        case vec2i:
+            return buffer.writeInt32Array(value, 0, 2);
+        case vec3i:
+            return buffer.writeInt32Array(value, 0, 3);
+        case vec4i:
+            return buffer.writeInt32Array(value, 0, 4);
+
+        case vec2u:
+            return buffer.writeUint32Array(value, 0, 2);
+        case vec3u:
+            return buffer.writeUint32Array(value, 0, 3);
+        case vec4u:
+            return buffer.writeUint32Array(value, 0, 4);
+
+        case vec2f:
+            return buffer.writeFloat32Array(value, 0, 2);
+        case vec3f:
+            return buffer.writeFloat32Array(value, 0, 3);
+        case vec4f:
+            return buffer.writeFloat32Array(value, 0, 4);
+
+        case vec2h:
+            return buffer.writeFloat16Array(value, 0, 2);
+        case vec3h:
+            return buffer.writeFloat16Array(value, 0, 3);
+        case vec4h:
+            return buffer.writeFloat16Array(value, 0, 4);
+
+        case mat2x2f:
+            return buffer.writeFloat32Array(value, 0, 4);
+        case mat3x2f:
+            return buffer.writeFloat32Array(value, 0, 6);
+        case mat4x2f:
+        case mat2x4f:
+            return buffer.writeFloat32Array(value, 0, 8);
+        case mat3x4f:
+            return buffer.writeFloat32Array(value, 0, 12);
+        case mat4x4f:
+            return buffer.writeFloat32Array(value, 0, 16);
+
+        case mat2x3f:
+            return write_mat_cx3_f32(value, buffer, 2);
+        case mat3x3f:
+            return write_mat_cx3_f32(value, buffer, 3);
+        case mat4x3f:
+            return write_mat_cx3_f32(value, buffer, 4);
+
+        case mat2x2h:
+            return buffer.writeFloat16Array(value, 0, 4);
+        case mat3x2h:
+            return buffer.writeFloat16Array(value, 0, 6);
+        case mat4x2h:
+        case mat2x4h:
+            return buffer.writeFloat16Array(value, 0, 8);
+        case mat3x4h:
+            return buffer.writeFloat16Array(value, 0, 12);
+        case mat4x4h:
+            return buffer.writeFloat16Array(value, 0, 16);
+
+        case mat2x3h:
+            return write_mat_cx3_f16(value, buffer, 2);
+        case mat3x3h:
+            return write_mat_cx3_f16(value, buffer, 3);
+        case mat4x3h:
+            return write_mat_cx3_f16(value, buffer, 4);
+
+        default:
+            throw new Error(`Unsupported type ${type}`);
+    }
+}
+
+const scratch_buffer = new BinaryBuffer();
+// platform endianness is needed for marshaling data to the GPU
+scratch_buffer.endianness = platform_compute_endianness();
+
+/**
+ *
+ * @param {*} value
+ * @param {WebGPUType} type
+ * @param {ArrayBuffer} data
+ * @param {number} [byteOffset]
+ */
+export function write_gpu_typed_buffer(
+    value,
+    type,
+    data,
+    byteOffset = 0
+) {
+
+    assert.defined(value, 'value');
+
+    assert.defined(type, 'type');
+    assert.equal(type.isWebGPUType, true, 'type.isWebGPUType !== true');
+
+    assert.defined(data, 'data');
+    assert.isInstanceOf(data, ArrayBuffer, 'data');
+
+    assert.isNonNegativeInteger(byteOffset, 'byteOffset');
+    assert.greaterThanOrEqual(data.byteLength - byteOffset, type.size, "Data buffer is too small");
+
+    if (scratch_buffer.data !== data || scratch_buffer.capacity !== data.byteLength) {
+        // Bound afresh only for a buffer it is not bound to already: binding makes a DataView and a
+        // Uint8Array, and a command context's uniforms arrive one after another into the same
+        // upload block. The length is compared as well, so a buffer the scratch grew away from, or
+        // one detached since, is bound anew rather than written through stale views.
+        scratch_buffer.fromArrayBuffer(data);
+    }
+
+    scratch_buffer.position = byteOffset;
+
+    assert.equal(scratch_buffer.data, data, 'scratch_buffer.buffer !== data'); // sanity check
+
+    write_wgsl_type_value(value, scratch_buffer, type);
+
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Whether `t` is, or transitively contains, a half-precision (`f16`) primitive type.
+ *
+ * Any WGSL struct declaration or resource variable whose type contains `f16` requires the
+ * `enable f16;` directive ({@link WebGPUExtensionType.ShaderF16}).
+ *
+ * @param {WebGPUType} t
+ * @returns {boolean}
+ */
+export function type_has_f16(t: WebGPUType): boolean;
+export type WebGPUType = import("./WebGPUType.js").WebGPUType;
+//# sourceMappingURL=type_has_f16.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"type_has_f16.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/type_has_f16.js"],"names":[],"mappings":"AAoCA;;;;;;;;GAQG;AACH,gCAHW,UAAU,GACR,OAAO,CAsBnB;yBAhDY,OAAO,iBAAiB,EAAE,UAAU"}

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

@@ -0,0 +1,66 @@
+import {
+    f16,
+    mat2x2h,
+    mat2x3h,
+    mat2x4h,
+    mat3x2h,
+    mat3x3h,
+    mat3x4h,
+    mat4x2h,
+    mat4x3h,
+    mat4x4h,
+    vec2h,
+    vec3h,
+    vec4h
+} from "./WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+
+/**
+ * @typedef {import("./WebGPUType.js").WebGPUType} WebGPUType
+ */
+
+const F16_PRIMITIVE_TYPES = new Set([
+    f16,
+    vec2h,
+    vec3h,
+    vec4h,
+    mat2x2h,
+    mat3x2h,
+    mat4x2h,
+    mat2x3h,
+    mat3x3h,
+    mat4x3h,
+    mat2x4h,
+    mat3x4h,
+    mat4x4h,
+]);
+
+/**
+ * Whether `t` is, or transitively contains, a half-precision (`f16`) primitive type.
+ *
+ * Any WGSL struct declaration or resource variable whose type contains `f16` requires the
+ * `enable f16;` directive ({@link WebGPUExtensionType.ShaderF16}).
+ *
+ * @param {WebGPUType} t
+ * @returns {boolean}
+ */
+export function type_has_f16(t) {
+    if (t.isPrimitive || t.isAtomic) {
+        return F16_PRIMITIVE_TYPES.has(t);
+    }
+
+    if (t.isArray) {
+        return type_has_f16(t.type);
+    }
+
+    if (t.isStruct) {
+        for (const f of t.fields) {
+            if (type_has_f16(f.type)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    throw new Error(`Unsupported type '${t}'`);
+}