@woosh/meep-engine 3.55.0 → 3.57.0

package/src/shade/renderer/shader/type/serde/read_gpu_typed_buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read_gpu_typed_buffer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/type/serde/read_gpu_typed_buffer.js"],"names":[],"mappings":"AAwGA;;;;GAIG;AACH,6CAHW,YAAY,yBAqDtB;AAwBD;;;;;;GAMG;AACH,8DALW,WAAW,eACX,MAAM,UACN,MAAM,GACJ,EAAE,CAsBd;6BAlN4B,4CAA4C"}
+{"version":3,"file":"read_gpu_typed_buffer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/type/serde/read_gpu_typed_buffer.js"],"names":[],"mappings":"AAoLA;;;;GAIG;AACH,6CAHW,YAAY,yBAmGtB;AA0BD;;;;;;GAMG;AACH,8DALW,WAAW,eACX,MAAM,UACN,MAAM,GACJ,EAAE,CAsBd;6BA9U4B,4CAA4C"}

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

@@ -1,211 +1,335 @@
-import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
-import { platform_compute_endianness } from "../../../../../core/binary/platform_compute_endianness.js";
-import { round_up } from "../../../../../core/math/round_up.js";
-import {
-    atomic_i32,
-    atomic_u32,
-    bool,
-    f32,
-    i32,
-    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";
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {WebGPUArray} type
- */
-function read_array_value(buffer, type) {
-    let count = type.count;
-
-    const result = [];
-
-    const element_type = type.type;
-    // WGSL array stride is the element's `aligned_size`. For
-    // arrays-of-primitives this equals `size`; for arrays-of-struct
-    // it diverges when the struct needs trailing padding to satisfy
-    // its alignment requirement. Walking by `read_wgsl_type_value`'s
-    // implicit advance — which only spans the struct's `size` —
-    // would slide every subsequent element back into the previous
-    // element's stride-padding region. See `write_array_value` for
-    // the matching write-side fix.
-    const element_stride = element_type.aligned_size;
-    const array_start = buffer.position;
-
-    if (type.runtime_sized) {
-        // figure out how big the array should be
-        const remaining_bytes = buffer.capacity - buffer.position;
-        count = Math.floor(remaining_bytes / element_stride);
-    }
-
-    for (let i = 0; i < count; i++) {
-        buffer.position = array_start + i * element_stride;
-        result[i] = read_wgsl_type_value(buffer, element_type);
-    }
-
-    // Park the cursor past the array's stride-sized footprint so any
-    // following field in an enclosing struct lands cleanly.
-    buffer.position = array_start + count * element_stride;
-
-    return result;
-}
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {number} count
- * @returns {Float32Array}
- */
-function read_multiple_f32(buffer, count) {
-
-    const r = new Float32Array(count);
-    buffer.readFloat32Array(r, 0, count);
-    return r;
-}
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {number} count
- * @returns {Int32Array}
- */
-function read_multiple_i32(buffer, count) {
-
-    // signed storage, or every negative component reads back as its u32 bit pattern
-    const r = new Int32Array(count);
-    buffer.readInt32Array(r, 0, count);
-    return r;
-}
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {number} count
- * @returns {Uint32Array}
- */
-function read_multiple_u32(buffer, count) {
-
-    const r = new Uint32Array(count);
-    buffer.readUint32Array(r, 0, count);
-    return r;
-}
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {WebGPUType} type
- */
-export function read_wgsl_type_value(buffer, type) {
-    buffer.position = round_up(buffer.position, type.align)
-
-    if (type instanceof WebGPUArray) {
-        return read_array_value(buffer, type);
-    }
-
-    if (type instanceof WebGPUStruct) {
-        return read_struct_value(buffer, type);
-    }
-
-
-    switch (type) {
-        case bool:
-            return buffer.readUint32() !== 0;
-
-        case u32:
-        case atomic_u32:
-            return buffer.readUint32();
-        case i32:
-        case atomic_i32:
-            return buffer.readInt32();
-        case f32:
-            return buffer.readFloat32();
-
-        case vec2u:
-            return read_multiple_u32(buffer, 2);
-        case vec3u:
-            return read_multiple_u32(buffer, 3);
-        case vec4u:
-            return read_multiple_u32(buffer, 4);
-
-        case vec2i:
-            return read_multiple_i32(buffer, 2);
-        case vec3i:
-            return read_multiple_i32(buffer, 3);
-        case vec4i:
-            return read_multiple_i32(buffer, 4);
-
-        case vec2f:
-            return read_multiple_f32(buffer, 2);
-        case vec3f:
-            return read_multiple_f32(buffer, 3);
-        case vec4f:
-            return read_multiple_f32(buffer, 4);
-        case mat4x4f:
-            return read_multiple_f32(buffer, 16);
-        default:
-            throw new Error(`Unsupported type ${type}`);
-    }
-}
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {WebGPUStruct} struct
- */
-function read_struct_value(buffer, struct) {
-    const fields = struct.fields;
-    const record_address = buffer.position;
-
-    const element = {};
-
-    for (let j = 0; j < fields.length; j++) {
-        const field = fields[j];
-
-        buffer.position = record_address + field.offset;
-
-        element[field.name] = read_wgsl_type_value(buffer, field.type);
-    }
-
-    return element;
-}
-
-/**
- * @param {WebGPUType} type
- * @param {ArrayBuffer} data
- * @param {number} byteOffset
- * @param {number} count number of structs to read
- * @returns {[]}
- */
-export function read_gpu_typed_buffer(type, data, byteOffset = 0, count = (data.byteLength - byteOffset) / type.aligned_size) {
-    // TODO we can do primitive types much faster, let's implement a separate path for those
-
-
-    const result = [];
-
-    const buffer = BinaryBuffer.fromArrayBuffer(data);
-    buffer.endianness = platform_compute_endianness();
-
-    buffer.position = byteOffset;
-
-    for (let i = 0; i < count; i++) {
-
-        const element = read_wgsl_type_value(buffer, type);
-
-        result.push(element);
-
-    }
-
-    return result;
-}
+import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
+import { platform_compute_endianness } from "../../../../../core/binary/platform_compute_endianness.js";
+import { round_up } from "../../../../../core/math/round_up.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";
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {WebGPUArray} type
+ */
+function read_array_value(buffer, type) {
+    let count = type.count;
+
+    const result = [];
+
+    const element_type = type.type;
+    // WGSL array stride is the element's `aligned_size`. For
+    // arrays-of-primitives this equals `size`; for arrays-of-struct
+    // it diverges when the struct needs trailing padding to satisfy
+    // its alignment requirement. Walking by `read_wgsl_type_value`'s
+    // implicit advance — which only spans the struct's `size` —
+    // would slide every subsequent element back into the previous
+    // element's stride-padding region. See `write_array_value` for
+    // the matching write-side fix.
+    const element_stride = element_type.aligned_size;
+    const array_start = buffer.position;
+
+    if (type.runtime_sized) {
+        // figure out how big the array should be
+        const remaining_bytes = buffer.capacity - buffer.position;
+        count = Math.floor(remaining_bytes / element_stride);
+    }
+
+    for (let i = 0; i < count; i++) {
+        buffer.position = array_start + i * element_stride;
+        result[i] = read_wgsl_type_value(buffer, element_type);
+    }
+
+    // Park the cursor past the array's stride-sized footprint so any
+    // following field in an enclosing struct lands cleanly.
+    buffer.position = array_start + count * element_stride;
+
+    return result;
+}
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number} count
+ * @returns {Float32Array}
+ */
+function read_multiple_f32(buffer, count) {
+
+    const r = new Float32Array(count);
+    buffer.readFloat32Array(r, 0, count);
+    return r;
+}
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number} count
+ * @returns {Float16Array}
+ */
+function read_multiple_f16(buffer, count) {
+
+    const r = new Float16Array(count);
+    buffer.readFloat16Array(r, 0, count);
+    return r;
+}
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number} count
+ * @returns {Int32Array}
+ */
+function read_multiple_i32(buffer, count) {
+
+    // signed storage, or every negative component reads back as its u32 bit pattern
+    const r = new Int32Array(count);
+    buffer.readInt32Array(r, 0, count);
+    return r;
+}
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number} count
+ * @returns {Uint32Array}
+ */
+function read_multiple_u32(buffer, count) {
+
+    const r = new Uint32Array(count);
+    buffer.readUint32Array(r, 0, count);
+    return r;
+}
+
+/**
+ * Read a `matCx3<f32>` from WGSL host-shareable memory (each 3-float column padded to 16 bytes)
+ * into a flat `Float32Array(columns * 3)`.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number} columns
+ * @returns {Float32Array}
+ */
+function read_mat_cx3_f32(buffer, columns) {
+    const r = new Float32Array(columns * 3);
+    const start = buffer.position;
+
+    for (let c = 0; c < columns; c++) {
+        buffer.position = start + c * 16;
+        buffer.readFloat32Array(r, c * 3, 3);
+    }
+
+    buffer.position = start + columns * 16;
+    return r;
+}
+
+/**
+ * Read a `matCx3<f16>` from WGSL host-shareable memory (each 3-half column padded to 8 bytes)
+ * into a flat `Float16Array(columns * 3)`.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number} columns
+ * @returns {Float16Array}
+ */
+function read_mat_cx3_f16(buffer, columns) {
+    const r = new Float16Array(columns * 3);
+    const start = buffer.position;
+
+    for (let c = 0; c < columns; c++) {
+        buffer.position = start + c * 8;
+        buffer.readFloat16Array(r, c * 3, 3);
+    }
+
+    buffer.position = start + columns * 8;
+    return r;
+}
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {WebGPUType} type
+ */
+export function read_wgsl_type_value(buffer, type) {
+    buffer.position = round_up(buffer.position, type.align)
+
+    if (type instanceof WebGPUArray) {
+        return read_array_value(buffer, type);
+    }
+
+    if (type instanceof WebGPUStruct) {
+        return read_struct_value(buffer, type);
+    }
+
+
+    switch (type) {
+        case bool:
+            return buffer.readUint32() !== 0;
+
+        case u32:
+        case atomic_u32:
+            return buffer.readUint32();
+        case i32:
+        case atomic_i32:
+            return buffer.readInt32();
+        case f32:
+            return buffer.readFloat32();
+        case f16:
+            return buffer.readFloat16();
+
+        case vec2u:
+            return read_multiple_u32(buffer, 2);
+        case vec3u:
+            return read_multiple_u32(buffer, 3);
+        case vec4u:
+            return read_multiple_u32(buffer, 4);
+
+        case vec2i:
+            return read_multiple_i32(buffer, 2);
+        case vec3i:
+            return read_multiple_i32(buffer, 3);
+        case vec4i:
+            return read_multiple_i32(buffer, 4);
+
+        case vec2f:
+            return read_multiple_f32(buffer, 2);
+        case vec3f:
+            return read_multiple_f32(buffer, 3);
+        case vec4f:
+            return read_multiple_f32(buffer, 4);
+
+        case vec2h:
+            return read_multiple_f16(buffer, 2);
+        case vec3h:
+            return read_multiple_f16(buffer, 3);
+        case vec4h:
+            return read_multiple_f16(buffer, 4);
+
+        case mat2x2f:
+            return read_multiple_f32(buffer, 4);
+        case mat3x2f:
+            return read_multiple_f32(buffer, 6);
+        case mat4x2f:
+        case mat2x4f:
+            return read_multiple_f32(buffer, 8);
+        case mat3x4f:
+            return read_multiple_f32(buffer, 12);
+        case mat4x4f:
+            return read_multiple_f32(buffer, 16);
+
+        case mat2x3f:
+            return read_mat_cx3_f32(buffer, 2);
+        case mat3x3f:
+            return read_mat_cx3_f32(buffer, 3);
+        case mat4x3f:
+            return read_mat_cx3_f32(buffer, 4);
+
+        case mat2x2h:
+            return read_multiple_f16(buffer, 4);
+        case mat3x2h:
+            return read_multiple_f16(buffer, 6);
+        case mat4x2h:
+        case mat2x4h:
+            return read_multiple_f16(buffer, 8);
+        case mat3x4h:
+            return read_multiple_f16(buffer, 12);
+        case mat4x4h:
+            return read_multiple_f16(buffer, 16);
+
+        case mat2x3h:
+            return read_mat_cx3_f16(buffer, 2);
+        case mat3x3h:
+            return read_mat_cx3_f16(buffer, 3);
+        case mat4x3h:
+            return read_mat_cx3_f16(buffer, 4);
+
+        default:
+            throw new Error(`Unsupported type ${type}`);
+    }
+}
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {WebGPUStruct} struct
+ */
+function read_struct_value(buffer, struct) {
+    const fields = struct.fields;
+    const record_address = buffer.position;
+
+    const element = {};
+
+    for (let j = 0; j < fields.length; j++) {
+        const field = fields[j];
+
+        buffer.position = record_address + field.offset;
+
+        element[field.name] = read_wgsl_type_value(buffer, field.type);
+    }
+
+    buffer.position = record_address + struct.size;
+
+    return element;
+}
+
+/**
+ * @param {WebGPUType} type
+ * @param {ArrayBuffer} data
+ * @param {number} byteOffset
+ * @param {number} count number of structs to read
+ * @returns {[]}
+ */
+export function read_gpu_typed_buffer(type, data, byteOffset = 0, count = (data.byteLength - byteOffset) / type.aligned_size) {
+    // TODO we can do primitive types much faster, let's implement a separate path for those
+
+
+    const result = [];
+
+    const buffer = BinaryBuffer.fromArrayBuffer(data);
+    buffer.endianness = platform_compute_endianness();
+
+    buffer.position = byteOffset;
+
+    for (let i = 0; i < count; i++) {
+
+        const element = read_wgsl_type_value(buffer, type);
+
+        result.push(element);
+
+    }
+
+    return result;
+}

package/src/shade/renderer/shader/type/serde/write_gpu_typed_buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"write_gpu_typed_buffer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/type/serde/write_gpu_typed_buffer.js"],"names":[],"mappings":"AA0GA;;;;;;GAMG;AACH,0DAJW,YAAY,qBAEV,IAAI,CA+DhB;AAMD;;;;;;GAMG;AACH,2EAHW,WAAW,eACX,MAAM,QAkChB;6BA1N4B,4CAA4C"}
+{"version":3,"file":"write_gpu_typed_buffer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/type/serde/write_gpu_typed_buffer.js"],"names":[],"mappings":"AA8KA;;;;;;GAMG;AACH,0DAJW,YAAY,qBAEV,IAAI,CAwGhB;AAMD;;;;;;GAMG;AACH,2EAHW,WAAW,eACX,MAAM,QAkChB;6BAvU4B,4CAA4C"}