@woosh/meep-engine 3.22.0 → 3.23.0

package/src/engine/physics/cloth/collider/cloth_collider_pack.js

@@ -0,0 +1,173 @@
+import { BoxShape3D } from "../../../../core/geom/3d/shape/BoxShape3D.js";
+import { CapsuleShape3D } from "../../../../core/geom/3d/shape/CapsuleShape3D.js";
+import { CylinderShape3D } from "../../../../core/geom/3d/shape/CylinderShape3D.js";
+import { PlaneShape3D } from "../../../../core/geom/3d/shape/PlaneShape3D.js";
+import { SphereShape3D } from "../../../../core/geom/3d/shape/SphereShape3D.js";
+import { ClothColliderKind } from "./ClothColliderKind.js";
+import {
+    CCR_FEATURE,
+    CCR_KIND,
+    CCR_PARAM_0,
+    CCR_PARAM_1,
+    CCR_PARAM_2,
+    CCR_PARAM_3
+} from "./ClothColliderRecord.js";
+
+/**
+ * # `AbstractShape3D` → a packed record's geometry
+ *
+ * The one place a cloth collider is a shape object rather than a row of floats.
+ * It runs when a `ClothCollider` is linked or its shape changes, never per step
+ * and never per particle.
+ *
+ * `instanceof` rather than the prototype markers the physics narrowphase uses,
+ * because this needs to distinguish *five* kinds rather than short-circuit one,
+ * and because a marker per kind would be five new fields on `core` shapes for
+ * one consumer's benefit. The ordering matters in one place and is commented
+ * where it does.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Write a shape's kind, parameters and feature size into a record.
+ *
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record record index, not a slot offset
+ * @param {AbstractShape3D} shape in its canonical local frame
+ * @param {number} stride
+ * @returns {boolean} `false` if the shape is not one cloth can collide against,
+ *   in which case nothing was written
+ */
+export function cloth_collider_pack(table, record, shape, stride) {
+    const r = record * stride;
+
+    if (shape instanceof SphereShape3D) {
+        // Covers UnitSphereShape3D, which is a SphereShape3D of radius 1.
+        const radius = shape.radius;
+
+        table[r + CCR_KIND] = ClothColliderKind.Sphere;
+        table[r + CCR_PARAM_0] = radius;
+        table[r + CCR_PARAM_1] = 0;
+        table[r + CCR_PARAM_2] = 0;
+        table[r + CCR_PARAM_3] = 0;
+        table[r + CCR_FEATURE] = radius;
+
+        return true;
+    }
+
+    if (shape instanceof CapsuleShape3D) {
+        const radius = shape.radius;
+
+        table[r + CCR_KIND] = ClothColliderKind.Capsule;
+        table[r + CCR_PARAM_0] = radius;
+        table[r + CCR_PARAM_1] = shape.height;
+        table[r + CCR_PARAM_2] = 0;
+        table[r + CCR_PARAM_3] = 0;
+
+        // A capsule's tightest curvature is its cap, which is its own radius.
+        table[r + CCR_FEATURE] = radius;
+
+        return true;
+    }
+
+    if (shape instanceof BoxShape3D) {
+        // Covers UnitCubeShape3D, which is a BoxShape3D pinned to 0.5.
+        const h = shape.half_extents;
+
+        table[r + CCR_KIND] = ClothColliderKind.Box;
+        table[r + CCR_PARAM_0] = h.x;
+        table[r + CCR_PARAM_1] = h.y;
+        table[r + CCR_PARAM_2] = h.z;
+        table[r + CCR_PARAM_3] = 0;
+
+        // A box has no curvature; its edges are creases, and the distance over
+        // which "the nearest face's normal" describes the surface is how far
+        // the nearest face extends — its smallest half-extent, conservatively.
+        table[r + CCR_FEATURE] = Math.min(h.x, Math.min(h.y, h.z));
+
+        return true;
+    }
+
+    if (shape instanceof CylinderShape3D) {
+        const radius = shape.radius;
+
+        table[r + CCR_KIND] = ClothColliderKind.Cylinder;
+        table[r + CCR_PARAM_0] = radius;
+        table[r + CCR_PARAM_1] = shape.height;
+        table[r + CCR_PARAM_2] = 0;
+        table[r + CCR_PARAM_3] = 0;
+        table[r + CCR_FEATURE] = Math.min(radius, shape.height * 0.5);
+
+        return true;
+    }
+
+    if (shape instanceof PlaneShape3D) {
+        table[r + CCR_KIND] = ClothColliderKind.Plane;
+        table[r + CCR_PARAM_0] = shape.normal_x;
+        table[r + CCR_PARAM_1] = shape.normal_y;
+        table[r + CCR_PARAM_2] = shape.normal_z;
+        table[r + CCR_PARAM_3] = shape.offset;
+
+        // A plane is flat everywhere, so its normal describes it at any
+        // distance and it never narrows a trust region.
+        table[r + CCR_FEATURE] = Infinity;
+
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * The AABB of a packed shape in its own local frame, ignoring pose.
+ *
+ * Written here rather than taken from `AbstractShape3D#compute_bounding_box`
+ * because a plane's box is `±Infinity` on its unbounded axes and the caller
+ * transforms this one — `0 · Infinity` is `NaN`, so an unbounded local box
+ * cannot go through a pose. {@link cloth_collider_local_bounds} therefore
+ * refuses a plane and the index bounds one directly from its world normal.
+ *
+ * @param {Float64Array|number[]} out `[x0, y0, z0, x1, y1, z1]`
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record
+ * @param {number} stride
+ * @returns {boolean} `false` for an unbounded kind, in which case `out` is untouched
+ */
+export function cloth_collider_local_bounds(out, table, record, stride) {
+    const r = record * stride;
+
+    const kind = table[r + CCR_KIND];
+
+    let hx;
+    let hy;
+    let hz;
+
+    if (kind === ClothColliderKind.Sphere) {
+        hx = hy = hz = table[r + CCR_PARAM_0];
+    } else if (kind === ClothColliderKind.Capsule) {
+        const radius = table[r + CCR_PARAM_0];
+
+        hx = hz = radius;
+        hy = radius + table[r + CCR_PARAM_1] * 0.5;
+    } else if (kind === ClothColliderKind.Box) {
+        hx = table[r + CCR_PARAM_0];
+        hy = table[r + CCR_PARAM_1];
+        hz = table[r + CCR_PARAM_2];
+    } else if (kind === ClothColliderKind.Cylinder) {
+        hx = hz = table[r + CCR_PARAM_0];
+        hy = table[r + CCR_PARAM_1] * 0.5;
+    } else {
+        return false;
+    }
+
+    out[0] = -hx;
+    out[1] = -hy;
+    out[2] = -hz;
+    out[3] = hx;
+    out[4] = hy;
+    out[5] = hz;
+
+    return true;
+}

package/src/engine/physics/cloth/collider/cloth_collider_sdf.d.ts

@@ -0,0 +1,94 @@
+/**
+ * # Evaluating a packed collider
+ *
+ * Two functions, and between them they are the whole of §8.2. One writes a
+ * collider's pose interpolated to a substep; the other evaluates its signed
+ * distance and gradient at a point, in the frame the table is expressed in.
+ *
+ * The evaluation is: bring the point into the collider's local frame with the
+ * inverse of the interpolated pose, evaluate the closed-form field there, and
+ * rotate the gradient back. That is three steps and no matrix — a rigid pose
+ * inverts by conjugating its quaternion and subtracting its translation, which
+ * costs less than storing an inverse and is exact rather than cached.
+ *
+ * The fields themselves live in `core/geom/3d/shape/sdf/` as free functions
+ * over scalars, so this dispatch and {@link SphereShape3D} and the rest are
+ * calling one implementation (§14.1). Before M2 those shapes fell back to
+ * `compute_signed_distance_gradient_by_sampling` — four field evaluations and a
+ * normalise, for shapes whose gradients are two lines of algebra.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Write every collider's pose interpolated to fraction `t` of the step into its
+ * own record. `t = 0` is the previous step's pose and `t = 1` is this one's.
+ *
+ * **This is the whole of "swept collision", and it is swept in translation and
+ * rotation but not in the *contact set*.** Which particles are in contact is
+ * decided once per step; where those colliders are is decided once per substep.
+ * The limit §7 P3 states — a collider spinning fast enough that a point on its
+ * surface travels more than its own radius within one substep can still be
+ * missed — is a limit on the second of those, and more substeps is the answer
+ * to it.
+ *
+ * The rotation is an `nlerp` rather than a `slerp`: it is not constant angular
+ * velocity, and over the fraction of a fixed step it is indistinguishable from
+ * one — the two differ by under a thousandth of a degree at the half-radian per
+ * step `CLOTH_ANCHOR_ROTATION_LIMIT` already treats as a spin.
+ *
+ * @param {Float32Array|Float64Array} table
+ * @param {number} count records in `table`
+ * @param {number} t `[0, 1]`
+ * @returns {void}
+ */
+export function cloth_collider_pose_at(table: Float32Array | Float64Array, count: number, t: number): void;
+/**
+ * Signed distance from a point to one packed collider's surface, with the unit
+ * outward gradient written into `gradient` at `gradient_offset`.
+ *
+ * The point and the gradient are both in the frame `table` is expressed in.
+ *
+ * @param {Float32Array|Float64Array|number[]} gradient
+ * @param {number} gradient_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record record index, not a slot offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number} the signed distance
+ */
+export function cloth_collider_signed_distance(gradient: Float32Array | Float64Array | number[], gradient_offset: number, table: Float32Array | Float64Array, record: number, x: number, y: number, z: number): number;
+/**
+ * Bring a point expressed in a collider's own local frame out into the frame
+ * the table is expressed in, using the interpolated pose. This is the inverse
+ * of the localisation above, and it is what carries a friction anchor with a
+ * moving collider (§8.3): the anchor is stored where the collider will always
+ * agree it is, and read back wherever the collider has moved to.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record
+ * @param {number} x local
+ * @param {number} y local
+ * @param {number} z local
+ * @returns {void}
+ */
+export function cloth_collider_from_local(out: Float32Array | Float64Array | number[], out_offset: number, table: Float32Array | Float64Array, record: number, x: number, y: number, z: number): void;
+/**
+ * Bring a point out of the table's frame into a collider's own local frame,
+ * using the interpolated pose. The anchoring half of
+ * {@link cloth_collider_from_local}.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {void}
+ */
+export function cloth_collider_to_local(out: Float32Array | Float64Array | number[], out_offset: number, table: Float32Array | Float64Array, record: number, x: number, y: number, z: number): void;
+//# sourceMappingURL=cloth_collider_sdf.d.ts.map

package/src/engine/physics/cloth/collider/cloth_collider_sdf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_collider_sdf.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/cloth_collider_sdf.js"],"names":[],"mappings":"AAsCA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8CALW,YAAY,GAAC,YAAY,SACzB,MAAM,KACN,MAAM,GACJ,IAAI,CAiDhB;AAED;;;;;;;;;;;;;;GAcG;AACH,yDATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,mBAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CA4DlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,+CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAchB;AAED;;;;;;;;;;;;;GAaG;AACH,6CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAahB"}

package/src/engine/physics/cloth/collider/cloth_collider_sdf.js

@@ -0,0 +1,275 @@
+import { sdf3_box_gradient } from "../../../../core/geom/3d/shape/sdf/sdf3_box.js";
+import { sdf3_capsule_gradient } from "../../../../core/geom/3d/shape/sdf/sdf3_capsule.js";
+import { sdf3_cylinder_gradient } from "../../../../core/geom/3d/shape/sdf/sdf3_cylinder.js";
+import { sdf3_plane_gradient } from "../../../../core/geom/3d/shape/sdf/sdf3_plane.js";
+import { sdf3_sphere_gradient } from "../../../../core/geom/3d/shape/sdf/sdf3_sphere.js";
+import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+import { v3_quaternion_apply_inverse } from "../../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
+import {
+    CCR_INTERP_QW,
+    CCR_INTERP_QX,
+    CCR_INTERP_QY,
+    CCR_INTERP_QZ,
+    CCR_INTERP_TX,
+    CCR_INTERP_TY,
+    CCR_INTERP_TZ,
+    CCR_KIND,
+    CCR_PARAM_0,
+    CCR_PARAM_1,
+    CCR_PARAM_2,
+    CCR_PARAM_3,
+    CCR_PREV_QW,
+    CCR_PREV_QX,
+    CCR_PREV_QY,
+    CCR_PREV_QZ,
+    CCR_PREV_TX,
+    CCR_PREV_TY,
+    CCR_PREV_TZ,
+    CCR_QW,
+    CCR_QX,
+    CCR_QY,
+    CCR_QZ,
+    CCR_STRIDE,
+    CCR_TX,
+    CCR_TY,
+    CCR_TZ
+} from "./ClothColliderRecord.js";
+import { ClothColliderKind } from "./ClothColliderKind.js";
+
+/**
+ * # Evaluating a packed collider
+ *
+ * Two functions, and between them they are the whole of §8.2. One writes a
+ * collider's pose interpolated to a substep; the other evaluates its signed
+ * distance and gradient at a point, in the frame the table is expressed in.
+ *
+ * The evaluation is: bring the point into the collider's local frame with the
+ * inverse of the interpolated pose, evaluate the closed-form field there, and
+ * rotate the gradient back. That is three steps and no matrix — a rigid pose
+ * inverts by conjugating its quaternion and subtracting its translation, which
+ * costs less than storing an inverse and is exact rather than cached.
+ *
+ * The fields themselves live in `core/geom/3d/shape/sdf/` as free functions
+ * over scalars, so this dispatch and {@link SphereShape3D} and the rest are
+ * calling one implementation (§14.1). Before M2 those shapes fell back to
+ * `compute_signed_distance_gradient_by_sampling` — four field evaluations and a
+ * normalise, for shapes whose gradients are two lines of algebra.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Write every collider's pose interpolated to fraction `t` of the step into its
+ * own record. `t = 0` is the previous step's pose and `t = 1` is this one's.
+ *
+ * **This is the whole of "swept collision", and it is swept in translation and
+ * rotation but not in the *contact set*.** Which particles are in contact is
+ * decided once per step; where those colliders are is decided once per substep.
+ * The limit §7 P3 states — a collider spinning fast enough that a point on its
+ * surface travels more than its own radius within one substep can still be
+ * missed — is a limit on the second of those, and more substeps is the answer
+ * to it.
+ *
+ * The rotation is an `nlerp` rather than a `slerp`: it is not constant angular
+ * velocity, and over the fraction of a fixed step it is indistinguishable from
+ * one — the two differ by under a thousandth of a degree at the half-radian per
+ * step `CLOTH_ANCHOR_ROTATION_LIMIT` already treats as a spin.
+ *
+ * @param {Float32Array|Float64Array} table
+ * @param {number} count records in `table`
+ * @param {number} t `[0, 1]`
+ * @returns {void}
+ */
+export function cloth_collider_pose_at(table, count, t) {
+    const s = 1 - t;
+
+    for (let i = 0; i < count; i++) {
+        const r = i * CCR_STRIDE;
+
+        table[r + CCR_INTERP_TX] = s * table[r + CCR_PREV_TX] + t * table[r + CCR_TX];
+        table[r + CCR_INTERP_TY] = s * table[r + CCR_PREV_TY] + t * table[r + CCR_TY];
+        table[r + CCR_INTERP_TZ] = s * table[r + CCR_PREV_TZ] + t * table[r + CCR_TZ];
+
+        const ax = table[r + CCR_PREV_QX];
+        const ay = table[r + CCR_PREV_QY];
+        const az = table[r + CCR_PREV_QZ];
+        const aw = table[r + CCR_PREV_QW];
+
+        let bx = table[r + CCR_QX];
+        let by = table[r + CCR_QY];
+        let bz = table[r + CCR_QZ];
+        let bw = table[r + CCR_QW];
+
+        // `q` and `−q` are one rotation, so the pair has to be brought onto the
+        // same hemisphere or the interpolation takes the long way round — which
+        // for a collider is a bone that spins through the character.
+        if (ax * bx + ay * by + az * bz + aw * bw < 0) {
+            bx = -bx;
+            by = -by;
+            bz = -bz;
+            bw = -bw;
+        }
+
+        const qx = s * ax + t * bx;
+        const qy = s * ay + t * by;
+        const qz = s * az + t * bz;
+        const qw = s * aw + t * bw;
+
+        const length = Math.sqrt(qx * qx + qy * qy + qz * qz + qw * qw);
+
+        // Two opposed quaternions cancel exactly, which the hemisphere fix
+        // above makes impossible; the guard is for a record whose poses were
+        // never written rather than for a rotation.
+        const inverse = length > 0 ? 1 / length : 0;
+
+        table[r + CCR_INTERP_QX] = qx * inverse;
+        table[r + CCR_INTERP_QY] = qy * inverse;
+        table[r + CCR_INTERP_QZ] = qz * inverse;
+        table[r + CCR_INTERP_QW] = length > 0 ? qw * inverse : 1;
+    }
+}
+
+/**
+ * Signed distance from a point to one packed collider's surface, with the unit
+ * outward gradient written into `gradient` at `gradient_offset`.
+ *
+ * The point and the gradient are both in the frame `table` is expressed in.
+ *
+ * @param {Float32Array|Float64Array|number[]} gradient
+ * @param {number} gradient_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record record index, not a slot offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number} the signed distance
+ */
+export function cloth_collider_signed_distance(gradient, gradient_offset, table, record, x, y, z) {
+    const r = record * CCR_STRIDE;
+
+    const qx = table[r + CCR_INTERP_QX];
+    const qy = table[r + CCR_INTERP_QY];
+    const qz = table[r + CCR_INTERP_QZ];
+    const qw = table[r + CCR_INTERP_QW];
+
+    v3_quaternion_apply_inverse(
+        LOCAL_POINT, 0,
+        x - table[r + CCR_INTERP_TX],
+        y - table[r + CCR_INTERP_TY],
+        z - table[r + CCR_INTERP_TZ],
+        qx, qy, qz, qw
+    );
+
+    const lx = LOCAL_POINT[0];
+    const ly = LOCAL_POINT[1];
+    const lz = LOCAL_POINT[2];
+
+    const kind = table[r + CCR_KIND];
+
+    let distance;
+
+    if (kind === ClothColliderKind.Sphere) {
+        distance = sdf3_sphere_gradient(LOCAL_GRADIENT, 0, lx, ly, lz, table[r + CCR_PARAM_0]);
+    } else if (kind === ClothColliderKind.Capsule) {
+        distance = sdf3_capsule_gradient(
+            LOCAL_GRADIENT, 0, lx, ly, lz,
+            table[r + CCR_PARAM_0], table[r + CCR_PARAM_1]
+        );
+    } else if (kind === ClothColliderKind.Box) {
+        distance = sdf3_box_gradient(
+            LOCAL_GRADIENT, 0, lx, ly, lz,
+            table[r + CCR_PARAM_0], table[r + CCR_PARAM_1], table[r + CCR_PARAM_2]
+        );
+    } else if (kind === ClothColliderKind.Cylinder) {
+        distance = sdf3_cylinder_gradient(
+            LOCAL_GRADIENT, 0, lx, ly, lz,
+            table[r + CCR_PARAM_0], table[r + CCR_PARAM_1]
+        );
+    } else {
+        distance = sdf3_plane_gradient(
+            LOCAL_GRADIENT, 0, lx, ly, lz,
+            table[r + CCR_PARAM_0], table[r + CCR_PARAM_1], table[r + CCR_PARAM_2],
+            table[r + CCR_PARAM_3]
+        );
+    }
+
+    // The gradient is a direction, so it takes the rotation and not the
+    // translation.
+    v3_quaternion_apply(
+        gradient, gradient_offset,
+        LOCAL_GRADIENT[0], LOCAL_GRADIENT[1], LOCAL_GRADIENT[2],
+        qx, qy, qz, qw
+    );
+
+    return distance;
+}
+
+/**
+ * Bring a point expressed in a collider's own local frame out into the frame
+ * the table is expressed in, using the interpolated pose. This is the inverse
+ * of the localisation above, and it is what carries a friction anchor with a
+ * moving collider (§8.3): the anchor is stored where the collider will always
+ * agree it is, and read back wherever the collider has moved to.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record
+ * @param {number} x local
+ * @param {number} y local
+ * @param {number} z local
+ * @returns {void}
+ */
+export function cloth_collider_from_local(out, out_offset, table, record, x, y, z) {
+    const r = record * CCR_STRIDE;
+
+    v3_quaternion_apply(
+        out, out_offset, x, y, z,
+        table[r + CCR_INTERP_QX], table[r + CCR_INTERP_QY],
+        table[r + CCR_INTERP_QZ], table[r + CCR_INTERP_QW]
+    );
+
+    out[out_offset] += table[r + CCR_INTERP_TX];
+    out[out_offset + 1] += table[r + CCR_INTERP_TY];
+    out[out_offset + 2] += table[r + CCR_INTERP_TZ];
+}
+
+/**
+ * Bring a point out of the table's frame into a collider's own local frame,
+ * using the interpolated pose. The anchoring half of
+ * {@link cloth_collider_from_local}.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {void}
+ */
+export function cloth_collider_to_local(out, out_offset, table, record, x, y, z) {
+    const r = record * CCR_STRIDE;
+
+    v3_quaternion_apply_inverse(
+        out, out_offset,
+        x - table[r + CCR_INTERP_TX],
+        y - table[r + CCR_INTERP_TY],
+        z - table[r + CCR_INTERP_TZ],
+        table[r + CCR_INTERP_QX], table[r + CCR_INTERP_QY],
+        table[r + CCR_INTERP_QZ], table[r + CCR_INTERP_QW]
+    );
+}
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const LOCAL_GRADIENT = new Float64Array(3);
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const LOCAL_POINT = new Float64Array(3);

package/src/engine/physics/cloth/ecs/ClothCollider.d.ts

@@ -0,0 +1,126 @@
+/**
+ * # The marker that opts a collider into cloth
+ *
+ * Put this beside an existing `(Collider, Transform64)` and cloth collides
+ * against it. That is the whole of the component's job, and it is the third
+ * instance of a pattern the engine already has twice: `AcousticBody` opts a
+ * collider into the acoustic simulation and carries an `AcousticMaterial`,
+ * `FluidObstacle` opts a collider into the fluid simulation and carries an
+ * inflation radius. This should read as a sibling of those two rather than as a
+ * new invention.
+ *
+ * Everything not here is read from components the entity already has: geometry
+ * and friction from `Collider`, pose from `Transform64`.
+ *
+ * ## No `RigidBody` required
+ *
+ * A deliberate divergence from `FluidObstacle`, which requires one because it
+ * needs a wall velocity. Cloth's colliders are overwhelmingly character bones —
+ * ordinary entities in a `TransformAttachment` hierarchy — and making each of
+ * them a physics body to be seen by cloth would tax the common case. Collider
+ * velocity is derived from the pose delta between fixed steps, which the index
+ * caches anyway for swept collision (§8.2). A world prop that *does* carry a
+ * `RigidBody` adds a `ClothCollider` the same way and lands in the same index;
+ * the two cases are not distinguished.
+ *
+ * ## Layer and mask, which §3.5 did not have
+ *
+ * §3.5 gives this component three fields and says layer filtering comes "from
+ * the `Cloth` side". It cannot: `Cloth#mask` is a mask *of collider layers*,
+ * and with no `RigidBody` required there is nowhere else for a collider's layer
+ * to live. So the pair is here, with `RigidBody`'s own semantics — a cloth and
+ * a collider interact when each is in the other's mask — which is what
+ * `Cloth.js` already says it means by "`RigidBody` semantics".
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ClothCollider {
+    /**
+     * @param {object} [spec]
+     * @param {number} [spec.inflation]
+     * @param {number} [spec.friction_scale]
+     * @param {number} [spec.layer]
+     * @param {number} [spec.mask]
+     * @param {number} [spec.flags]
+     * @returns {ClothCollider}
+     */
+    static from(spec?: {
+        inflation?: number;
+        friction_scale?: number;
+        layer?: number;
+        mask?: number;
+        flags?: number;
+    }): ClothCollider;
+    /**
+     * Extra thickness in metres, on top of `ClothDynamics#thickness`.
+     *
+     * The contact row holds cloth at `thickness + inflation` from the surface,
+     * so this is how a garment is kept off a body it would otherwise graze —
+     * the same idea as `FluidObstacle#inflation`, and useful for the same
+     * reason: a collider that approximates a limb loosely wants the cloth held
+     * a little further out than the approximation.
+     * @type {number}
+     */
+    inflation: number;
+    /**
+     * Multiplies the entity's `Collider#friction` before it is combined with
+     * the cloth's own. `0` makes the surface frictionless to cloth without
+     * making it frictionless to rigid bodies, which is the case this exists
+     * for: a character's collision capsules are tuned for footing, and a cape
+     * that grips them the same way reads as glued.
+     * @type {number}
+     */
+    friction_scale: number;
+    /**
+     * Collision layer this collider belongs to, `RigidBody` semantics.
+     * @type {number}
+     */
+    layer: number;
+    /**
+     * Which `Cloth` layers this collider acts on.
+     * @type {number}
+     */
+    mask: number;
+    /**
+     * @see ClothColliderFlags
+     * @type {number}
+     */
+    flags: number;
+    /**
+     * @param {number|ClothColliderFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag: number | ClothColliderFlags): boolean;
+    /**
+     * @param {ClothCollider} other
+     * @returns {boolean}
+     */
+    equals(other: ClothCollider): boolean;
+    /**
+     * @returns {number}
+     */
+    hash(): number;
+    toJSON(): {
+        inflation: number;
+        friction_scale: number;
+        layer: number;
+        mask: number;
+        flags: number;
+    };
+    /**
+     * @param {object} json
+     */
+    fromJSON({ inflation, friction_scale, layer, mask, flags }: object): void;
+    toString(): string;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isClothCollider: boolean;
+}
+export namespace ClothCollider {
+    let typeName: string;
+}
+import { ClothColliderFlags } from "./ClothColliderFlags.js";
+//# sourceMappingURL=ClothCollider.d.ts.map

package/src/engine/physics/cloth/ecs/ClothCollider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClothCollider.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothCollider.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IA0CI;;;;;;;;OAQG;IACH;QAPyB,SAAS,GAAvB,MAAM;QACQ,cAAc,GAA5B,MAAM;QACQ,KAAK,GAAnB,MAAM;QACQ,IAAI,GAAlB,MAAM;QACQ,KAAK,GAAnB,MAAM;QACJ,aAAa,CA0BzB;IAzED;;;;;;;;;OASG;IACH,WAFU,MAAM,CAEF;IAEd;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,OAFU,MAAM,CAEgB;IAqChC;;;OAGG;IACH,cAHW,MAAM,GAAC,kBAAkB,GACvB,OAAO,CAInB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAgBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAUlB;IAED;;;;;;MAQC;IAED;;OAEG;IACH,4DAFW,MAAM,QAchB;IAED,mBAEC;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;CANtC;;;;mCA3LkC,yBAAyB"}