@woosh/meep-engine 3.64.0 → 3.65.0

package/src/engine/physics/fluid/obstacle/chunk_fluid_obstacle_record.js

@@ -1,5 +1,6 @@
 import { chunk_quat_rotate_v3 } from "../../../../shade/renderer/shader/chunk/geometry/quaternion/chunk_v3_apply_quat.js";
 import { chunk_rigid_velocity_at_point } from "../../../../shade/renderer/shader/chunk/physics/kinematics/chunk_rigid_velocity_at_point.js";
+import { chunk_shape_record_line_span } from "../../../../shade/renderer/shader/chunk/sdf/chunk_shape_record_line_span.js";
 import { chunk_shape_record_signed_distance } from "../../../../shade/renderer/shader/chunk/sdf/chunk_shape_record_signed_distance.js";
 import { CodeChunk } from "../../../../shade/renderer/shader/compiler/CodeChunk.js";
 import { FLUID_OBSTACLE_RECORD_STRUCT } from "./FLUID_OBSTACLE_RECORD_STRUCT.js";
@@ -10,7 +11,11 @@ import { FLUID_OBSTACLE_RECORD_STRUCT } from "./FLUID_OBSTACLE_RECORD_STRUCT.js"
  * - `fluid_obstacle_record_signed_distance(record, global, x) -> f32`: signed distance to its
  *   surface, negative inside; the point is solid when it is at most `record.inflation`;
  * - `fluid_obstacle_record_wall_velocity(record, global, x) -> vec3<f32>`: the wall's velocity there,
- *   `rigid_velocity_at_point(v, ω, t, x)` with `t` the node's translation.
+ *   `rigid_velocity_at_point(v, ω, t, x)` with `t` the node's translation;
+ * - `fluid_obstacle_record_line_span(record, global, origin, direction) -> vec2<f32>`: the part of the
+ *   world line `origin + t · direction` (`direction` unit) inside its surface, as the `t` it enters at
+ *   and the `t` it leaves at, the first greater than the second for a line that misses
+ *   (`shape_record_line_span`). The inflation is not part of it.
  *
  * The node poses the record rigidly: its translation, and its matrix's rotation with each column
  * normalised, scale ignored, as the physics narrowphase and the CPU fluid pose a collider; then the
@@ -47,6 +52,26 @@ fn fluid_obstacle_record_signed_distance(
     return shape_record_signed_distance(record.shape_kind, record.shape_parameters, local);
 }
 
+fn fluid_obstacle_record_line_span(
+    record: ${FLUID_OBSTACLE_RECORD_STRUCT.wgsl_ref}, global: mat4x4<f32>, origin: vec3<f32>, direction: vec3<f32>
+) -> vec2<f32> {
+    // the node's rotation: its columns normalised, so its scale is ignored
+    let r0 = global[0].xyz * (1.0 / length(global[0].xyz));
+    let r1 = global[1].xyz * (1.0 / length(global[1].xyz));
+    let r2 = global[2].xyz * (1.0 / length(global[2].xyz));
+
+    let offset = origin - global[3].xyz;
+
+    // the record's own pose within the collider, inverted
+    let q = record.pose_rotation;
+    let inverse = vec4<f32>(-q.xyz, q.w);
+
+    let local_origin = quat_rotate_v3(inverse, vec3<f32>(dot(r0, offset), dot(r1, offset), dot(r2, offset)) - record.pose_translation);
+    let local_direction = quat_rotate_v3(inverse, vec3<f32>(dot(r0, direction), dot(r1, direction), dot(r2, direction)));
+
+    return shape_record_line_span(record.shape_kind, record.shape_parameters, local_origin, local_direction);
+}
+
 fn fluid_obstacle_record_wall_velocity(
     record: ${FLUID_OBSTACLE_RECORD_STRUCT.wgsl_ref}, global: mat4x4<f32>, x: vec3<f32>
 ) -> vec3<f32> {
@@ -57,5 +82,6 @@ fn fluid_obstacle_record_wall_velocity(
         chunk_quat_rotate_v3,
         chunk_rigid_velocity_at_point,
         chunk_shape_record_signed_distance,
+        chunk_shape_record_line_span,
     ]
 );

package/src/format/image/exr/ExrCompression.d.ts

@@ -0,0 +1,22 @@
+/**
+ * How the pixel data of an OpenEXR file is compressed, by the value its `compression` attribute holds.
+ *
+ * {@link exr_read } and {@link exr_write } handle {@link None }, {@link ZIPS } and {@link ZIP }. The other
+ * methods are listed so that a refusal can name the one a file uses.
+ */
+export type ExrCompression = number;
+export namespace ExrCompression {
+    let None: number;
+    let RLE: number;
+    let ZIPS: number;
+    let ZIP: number;
+    let PIZ: number;
+    let PXR24: number;
+    let B44: number;
+    let B44A: number;
+    let DWAA: number;
+    let DWAB: number;
+    let HTJ2K256: number;
+    let HTJ2K32: number;
+}
+//# sourceMappingURL=ExrCompression.d.ts.map

package/src/format/image/exr/ExrCompression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExrCompression.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/ExrCompression.js"],"names":[],"mappings":";;;;;;6BAQU,MAAM"}

package/src/format/image/exr/ExrCompression.js

@@ -0,0 +1,27 @@
+/**
+ * How the pixel data of an OpenEXR file is compressed, by the value its `compression` attribute holds.
+ *
+ * {@link exr_read} and {@link exr_write} handle {@link None}, {@link ZIPS} and {@link ZIP}. The other
+ * methods are listed so that a refusal can name the one a file uses.
+ *
+ * @see https://openexr.com/en/latest/OpenEXRFileLayout.html#compression-methods
+ * @readonly
+ * @enum {number}
+ */
+export const ExrCompression = {
+    /** the chunk bytes are the pixel bytes, one scanline per chunk */
+    None: 0,
+    RLE: 1,
+    /** zlib, one scanline per chunk */
+    ZIPS: 2,
+    /** zlib, sixteen scanlines per chunk */
+    ZIP: 3,
+    PIZ: 4,
+    PXR24: 5,
+    B44: 6,
+    B44A: 7,
+    DWAA: 8,
+    DWAB: 9,
+    HTJ2K256: 10,
+    HTJ2K32: 11,
+};

package/src/format/image/exr/ExrImage.d.ts

@@ -0,0 +1,32 @@
+/**
+ * One channel of an {@link ExrImage }.
+ *
+ * The array's class is the channel's pixel type: `Float16Array` is HALF, `Float32Array` is FLOAT and
+ * `Uint32Array` is UINT, the three types OpenEXR has. It holds one sample per pixel, row by row, top row
+ * first.
+ */
+type ExrChannel = {
+    name: string;
+    /**
+     * `width * height` samples
+     */
+    data: Float16Array | Float32Array | Uint32Array;
+};
+/**
+ * The pixels of a scanline OpenEXR image, one plane per channel — what {@link exr_read } returns and
+ * {@link exr_write } takes.
+ *
+ * `width` and `height` are those of the file's data window. Where that window sits, and the display window
+ * around it, are not part of the record: {@link exr_read } drops them and {@link exr_write } puts both windows
+ * at the origin, exactly covering the pixels.
+ *
+ * {@link exr_read } returns channels in the order OpenEXR keeps them, sorted by the bytes of their names
+ * (see {@link exr_compare_names }), which is the order a file's pixel data holds them in whatever order its
+ * channel list names them. {@link exr_write } takes them in any order.
+ */
+type ExrImage = {
+    width: number;
+    height: number;
+    channels: ExrChannel[];
+};
+//# sourceMappingURL=ExrImage.d.ts.map

package/src/format/image/exr/ExrImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExrImage.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/ExrImage.js"],"names":[],"mappings":";;;;;;;;UAQc,MAAM;;;;UACN,eAAa,YAAY,GAAC,WAAW;;;;;;;;;;;;;;;WAgBrC,MAAM;YACN,MAAM;cACN,UAAU,EAAE"}

package/src/format/image/exr/ExrImage.js

@@ -0,0 +1,32 @@
+/**
+ * One channel of an {@link ExrImage}.
+ *
+ * The array's class is the channel's pixel type: `Float16Array` is HALF, `Float32Array` is FLOAT and
+ * `Uint32Array` is UINT, the three types OpenEXR has. It holds one sample per pixel, row by row, top row
+ * first.
+ *
+ * @typedef {object} ExrChannel
+ * @property {string} name
+ * @property {Float16Array|Float32Array|Uint32Array} data `width * height` samples
+ */
+
+/**
+ * The pixels of a scanline OpenEXR image, one plane per channel — what {@link exr_read} returns and
+ * {@link exr_write} takes.
+ *
+ * `width` and `height` are those of the file's data window. Where that window sits, and the display window
+ * around it, are not part of the record: {@link exr_read} drops them and {@link exr_write} puts both windows
+ * at the origin, exactly covering the pixels.
+ *
+ * {@link exr_read} returns channels in the order OpenEXR keeps them, sorted by the bytes of their names
+ * (see {@link exr_compare_names}), which is the order a file's pixel data holds them in whatever order its
+ * channel list names them. {@link exr_write} takes them in any order.
+ *
+ * @typedef {object} ExrImage
+ * @property {number} width
+ * @property {number} height
+ * @property {ExrChannel[]} channels
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */

package/src/format/image/exr/ExrPixelType.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The type of a channel's samples, by the value an OpenEXR channel list stores.
+ *
+ * In an {@link ExrImage } the type is the class of the channel's array: `Uint32Array`, `Float16Array` or
+ * `Float32Array`.
+ */
+export type ExrPixelType = number;
+export namespace ExrPixelType {
+    let UINT: number;
+    let HALF: number;
+    let FLOAT: number;
+}
+//# sourceMappingURL=ExrPixelType.d.ts.map

package/src/format/image/exr/ExrPixelType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExrPixelType.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/ExrPixelType.js"],"names":[],"mappings":";;;;;;2BAQU,MAAM"}

package/src/format/image/exr/ExrPixelType.js

@@ -0,0 +1,18 @@
+/**
+ * The type of a channel's samples, by the value an OpenEXR channel list stores.
+ *
+ * In an {@link ExrImage} the type is the class of the channel's array: `Uint32Array`, `Float16Array` or
+ * `Float32Array`.
+ *
+ * @see https://openexr.com/en/latest/OpenEXRFileLayout.html#channel-list
+ * @readonly
+ * @enum {number}
+ */
+export const ExrPixelType = {
+    /** 32-bit unsigned integer */
+    UINT: 0,
+    /** IEEE 754 binary16 */
+    HALF: 1,
+    /** IEEE 754 binary32 */
+    FLOAT: 2,
+};

package/src/format/image/exr/exr_compare_names.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Order two names the way OpenEXR orders channels: byte by byte, as `strcmp` compares them.
+ *
+ * A file's pixel data holds its channels in this order whatever order its channel list is in, so this is
+ * the order {@link exr_read} lays samples out in and {@link exr_write} writes them in. On UTF-8 bytes it is
+ * code point order, which JavaScript's own string comparison is not past U+FFFF.
+ *
+ * @param {Uint8Array} a a name's bytes, without its terminator
+ * @param {Uint8Array} b
+ * @returns {number} negative when `a` comes first, positive when `b` does, 0 for the same name
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function exr_compare_names(a: Uint8Array, b: Uint8Array): number;
+//# sourceMappingURL=exr_compare_names.d.ts.map

package/src/format/image/exr/exr_compare_names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exr_compare_names.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/exr_compare_names.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,qCAPW,UAAU,KACV,UAAU,GACR,MAAM,CAelB"}

package/src/format/image/exr/exr_compare_names.js

@@ -0,0 +1,25 @@
+/**
+ * Order two names the way OpenEXR orders channels: byte by byte, as `strcmp` compares them.
+ *
+ * A file's pixel data holds its channels in this order whatever order its channel list is in, so this is
+ * the order {@link exr_read} lays samples out in and {@link exr_write} writes them in. On UTF-8 bytes it is
+ * code point order, which JavaScript's own string comparison is not past U+FFFF.
+ *
+ * @param {Uint8Array} a a name's bytes, without its terminator
+ * @param {Uint8Array} b
+ * @returns {number} negative when `a` comes first, positive when `b` does, 0 for the same name
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function exr_compare_names(a, b) {
+    const length = Math.min(a.length, b.length);
+
+    for (let i = 0; i < length; i++) {
+        if (a[i] !== b[i]) {
+            return a[i] - b[i];
+        }
+    }
+
+    return a.length - b.length;
+}

package/src/format/image/exr/exr_constants.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Numbers fixed by the OpenEXR file layout that both {@link exr_read} and {@link exr_write} need.
+ *
+ * @see https://openexr.com/en/latest/OpenEXRFileLayout.html
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * The first four bytes of every OpenEXR file, read as a little-endian integer.
+ * @type {number}
+ */
+export const EXR_MAGIC: number;
+/**
+ * The file format version, which is the low byte of the version field.
+ * @type {number}
+ */
+export const EXR_VERSION: number;
+/**
+ * Version field flag: the file holds a single tiled part.
+ * @type {number}
+ */
+export const EXR_FLAG_TILED: number;
+/**
+ * Version field flag: attribute names, attribute type names and channel names may be up to
+ * {@link EXR_LONG_NAME_BYTES} long rather than {@link EXR_SHORT_NAME_BYTES}.
+ * @type {number}
+ */
+export const EXR_FLAG_LONG_NAMES: number;
+/**
+ * Version field flag: the file holds deep data.
+ * @type {number}
+ */
+export const EXR_FLAG_NON_IMAGE: number;
+/**
+ * Version field flag: the file holds more than one part.
+ * @type {number}
+ */
+export const EXR_FLAG_MULTI_PART: number;
+/**
+ * Longest name, in bytes and without its terminator, a file without {@link EXR_FLAG_LONG_NAMES} may carry.
+ * @type {number}
+ */
+export const EXR_SHORT_NAME_BYTES: number;
+/**
+ * Longest name, in bytes and without its terminator, any file may carry.
+ * @type {number}
+ */
+export const EXR_LONG_NAME_BYTES: number;
+//# sourceMappingURL=exr_constants.d.ts.map

package/src/format/image/exr/exr_constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exr_constants.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/exr_constants.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;GAGG;AACH,wBAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,0BAFU,MAAM,CAEa;AAE7B;;;GAGG;AACH,6BAFU,MAAM,CAEoB;AAEpC;;;;GAIG;AACH,kCAFU,MAAM,CAEyB;AAEzC;;;GAGG;AACH,iCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH,kCAFU,MAAM,CAE0B;AAE1C;;;GAGG;AACH,mCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,kCAFU,MAAM,CAEuB"}

package/src/format/image/exr/exr_constants.js

@@ -0,0 +1,56 @@
+/**
+ * Numbers fixed by the OpenEXR file layout that both {@link exr_read} and {@link exr_write} need.
+ *
+ * @see https://openexr.com/en/latest/OpenEXRFileLayout.html
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * The first four bytes of every OpenEXR file, read as a little-endian integer.
+ * @type {number}
+ */
+export const EXR_MAGIC = 20000630;
+
+/**
+ * The file format version, which is the low byte of the version field.
+ * @type {number}
+ */
+export const EXR_VERSION = 2;
+
+/**
+ * Version field flag: the file holds a single tiled part.
+ * @type {number}
+ */
+export const EXR_FLAG_TILED = 0x200;
+
+/**
+ * Version field flag: attribute names, attribute type names and channel names may be up to
+ * {@link EXR_LONG_NAME_BYTES} long rather than {@link EXR_SHORT_NAME_BYTES}.
+ * @type {number}
+ */
+export const EXR_FLAG_LONG_NAMES = 0x400;
+
+/**
+ * Version field flag: the file holds deep data.
+ * @type {number}
+ */
+export const EXR_FLAG_NON_IMAGE = 0x800;
+
+/**
+ * Version field flag: the file holds more than one part.
+ * @type {number}
+ */
+export const EXR_FLAG_MULTI_PART = 0x1000;
+
+/**
+ * Longest name, in bytes and without its terminator, a file without {@link EXR_FLAG_LONG_NAMES} may carry.
+ * @type {number}
+ */
+export const EXR_SHORT_NAME_BYTES = 31;
+
+/**
+ * Longest name, in bytes and without its terminator, any file may carry.
+ * @type {number}
+ */
+export const EXR_LONG_NAME_BYTES = 255;

package/src/format/image/exr/exr_read.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Read a scanline OpenEXR file.
+ *
+ * **What it reads**: a single-part scanline image with full-resolution channels, compressed with
+ * {@link ExrCompression.None}, {@link ExrCompression.ZIPS} or {@link ExrCompression.ZIP}, in any of
+ * OpenEXR's three pixel types, mixed freely between channels. Samples come back as they are stored — a
+ * HALF channel is a `Float16Array` holding the file's exact bits — so reading converts nothing. Chunks are
+ * found through the offset table, so the file's line order does not matter.
+ *
+ * Of the header, only what decoding depends on is read: the channel list, the compression method and the
+ * data window. OpenEXR requires five more attributes — display window, line order, pixel aspect ratio,
+ * screen window centre and width — and its own reader fills in a default for any a file leaves out;
+ * nothing here would use them, so they are skipped like every other attribute.
+ *
+ * **What it refuses**, by name: tiled, multi-part and deep files; every other compression method;
+ * subsampled channels; a header without the channel list, compression or data window, or with one of
+ * them of the wrong type; and a file whose chunks do not add up — an offset outside the file, a chunk
+ * holding other scanlines than its place in the table says, a chunk whose stored or inflated size
+ * disagrees with the scanlines it holds. Every chunk is checked before anything is allocated for the
+ * pixels — against its place, its scanline, and what deflate could inflate its stored bytes to — so a file
+ * cannot claim more pixel data than its own chunks could hold.
+ *
+ * @param {ArrayBuffer} bytes the whole file; keep unchanged until the promise settles
+ * @returns {Promise<ExrImage>}
+ * @throws {Error} naming what is unsupported or malformed
+ *
+ * @see https://openexr.com/en/latest/OpenEXRFileLayout.html
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function exr_read(bytes: ArrayBuffer): Promise<ExrImage>;
+//# sourceMappingURL=exr_read.d.ts.map

package/src/format/image/exr/exr_read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exr_read.d.ts","sourceRoot":"","sources":["../../../../../src/format/image/exr/exr_read.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,gCARW,WAAW,GACT,QAAQ,QAAQ,CAAC,CAqL7B"}