@woosh/meep-engine 3.22.0 → 3.23.0

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

@@ -0,0 +1,176 @@
+/**
+ * # The index of live cloth colliders
+ *
+ * A flat `Float64Array` of packed records in **world** coordinates, plus a
+ * parallel `Int32Array` of layer, mask and entity. §8.1's shape, and the same
+ * shape `AcousticOccluderIndex` + `OccluderBody` take in the sound simulation —
+ * a compact, pose-cached, broadphase-able view of a set of colliders that is
+ * deliberately **not** the physics BVH, because `ColliderObserverSystem` skips
+ * colliders with no owning body and a character's bone colliders have none.
+ *
+ * ## Why a linear scan and not a BVH
+ *
+ * `AcousticOccluderIndex` puts a BVH over its bodies and this does not, for two
+ * reasons that are both about what the query is.
+ *
+ * The query here is one AABB overlap per cloth per step against a set that is a
+ * character's bones — twenty or so, and never the whole world, because a
+ * `ClothCollider` is an opt-in marker rather than every collider in the scene.
+ * A tree over twenty leaves that all move every frame costs more to keep than
+ * to skip.
+ *
+ * And a {@link PlaneShape3D} has an **unbounded** AABB, which a BVH cannot hold
+ * — every refit would grow the root to infinity and every query would visit
+ * everything. A linear scan holds an infinity without complaint, because
+ * `min ≤ other_max` is still an answer when one side is `Infinity`. If a scene
+ * ever wants thousands of cloth colliders, the shape of the fix is a BVH over
+ * the bounded ones with the planes kept in a short list beside it.
+ *
+ * ## The previous pose is the index's, not the caller's
+ *
+ * Swept collision (§8.2) needs where each collider *was* as well as where it
+ * is. {@link advance} rolls the current pose into the previous one, and it is
+ * called once per fixed step by {@link ClothColliderSystem} before any pose is
+ * written. A collider that has just been added has both poses equal, so its
+ * first step sweeps nothing — which is right: it did not move, it appeared.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ClothColliderIndex {
+    /**
+     * Packed records, `CCR_STRIDE` doubles each. `Float64` rather than the
+     * `Float32` the per-cloth table uses, because these are world coordinates
+     * and a world coordinate can be kilometres from the origin, where `Float32`
+     * has given up the millimetre a contact is measured in.
+     * @type {Float64Array}
+     */
+    table: Float64Array;
+    /**
+     * Layer, mask and entity per record. Integers, and not folded into
+     * {@link table}, because a mask of `0xFFFFFFFF` needs 32 bits of mantissa
+     * and rounding it would silently merge the highest layers.
+     * @type {Int32Array}
+     */
+    meta: Int32Array;
+    /**
+     * Live records. Slots below this may still be retired — see
+     * {@link #free_slots}.
+     * @type {number}
+     */
+    count: number;
+    /**
+     * Add a collider. The shape is packed once, here; the pose is written by
+     * {@link setPose} and must be before the first query.
+     *
+     * @param {AbstractShape3D} shape in its canonical local frame
+     * @param {number} friction combined Coulomb coefficient
+     * @param {number} inflation metres
+     * @param {number} layer
+     * @param {number} mask
+     * @param {number} entity for diagnostics — the index never resolves it
+     * @returns {number} a handle, or `-1` if the shape is not one cloth collides against
+     */
+    add(shape: AbstractShape3D, friction: number, inflation: number, layer: number, mask: number, entity: number): number;
+    /**
+     * Retire a handle. Its slot is reused by the next {@link add}, and any
+     * cloth holding warm-started contacts against it drops them on its next
+     * step because the handle it remembers no longer names the same collider.
+     *
+     * @param {number} handle
+     * @returns {void}
+     */
+    remove(handle: number): void;
+    /**
+     * Whether a handle names a live collider.
+     * @param {number} handle
+     * @returns {boolean}
+     */
+    isLive(handle: number): boolean;
+    /**
+     * Roll every live record's current pose into its previous one. Called once
+     * per fixed step, before any pose for this step is written.
+     * @returns {void}
+     */
+    advance(): void;
+    /**
+     * Place a collider and refresh its swept world bounds.
+     *
+     * PRECONDITION, inherited from `OccluderBody`: the pose is rigid. A
+     * `Transform64`'s scale is ignored here exactly as the physics narrowphase
+     * ignores it, so a distance in the shape's local frame is a distance in
+     * world space.
+     *
+     * @param {number} handle
+     * @param {number} tx
+     * @param {number} ty
+     * @param {number} tz
+     * @param {number} qx
+     * @param {number} qy
+     * @param {number} qz
+     * @param {number} qw
+     * @returns {void}
+     */
+    setPose(handle: number, tx: number, ty: number, tz: number, qx: number, qy: number, qz: number, qw: number): void;
+    /**
+     * Also set the previous pose, so the collider reads as having been placed
+     * rather than having moved. Used when a collider is first linked and when
+     * something has teleported it — a swept collision against a jump is a
+     * collider smeared across a kilometre.
+     *
+     * @param {number} handle
+     * @param {number} tx
+     * @param {number} ty
+     * @param {number} tz
+     * @param {number} qx
+     * @param {number} qy
+     * @param {number} qz
+     * @param {number} qw
+     * @returns {void}
+     */
+    placePose(handle: number, tx: number, ty: number, tz: number, qx: number, qy: number, qz: number, qw: number): void;
+    /**
+     * Surface friction and inflation, after the fact. Both are read from
+     * components that an author can change while the scene runs.
+     *
+     * @param {number} handle
+     * @param {number} friction
+     * @param {number} inflation
+     * @returns {void}
+     */
+    setSurface(handle: number, friction: number, inflation: number): void;
+    /**
+     * @param {number} handle
+     * @param {number} layer
+     * @param {number} mask
+     * @returns {void}
+     */
+    setFilter(handle: number, layer: number, mask: number): void;
+    /**
+     * @param {number} handle
+     * @returns {number} the entity the collider was registered for
+     */
+    entityOf(handle: number): number;
+    /**
+     * Every live collider whose swept bounds overlap the box and whose
+     * layer/mask agree with the caller's, written into `out` as handles.
+     *
+     * The filter is `RigidBody`'s and is symmetric: each side has to be in the
+     * other's mask, so a cloth that ignores a collider and a collider that
+     * ignores a cloth are the same statement made from two directions.
+     *
+     * @param {number[]} out grown as needed; only `[0, returned)` is valid
+     * @param {number} min_x
+     * @param {number} min_y
+     * @param {number} min_z
+     * @param {number} max_x
+     * @param {number} max_y
+     * @param {number} max_z
+     * @param {number} layer the querier's layer
+     * @param {number} mask the querier's mask
+     * @returns {number} how many handles were written
+     */
+    query(out: number[], min_x: number, min_y: number, min_z: number, max_x: number, max_y: number, max_z: number, layer: number, mask: number): number;
+    #private;
+}
+//# sourceMappingURL=ClothColliderIndex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ClothColliderIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/ClothColliderIndex.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;IAEI;;;;;;OAMG;IACH,OAFU,YAAY,CAEM;IAE5B;;;;;OAKG;IACH,MAFU,UAAU,CAEK;IAEzB;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAoBV;;;;;;;;;;;OAWG;IACH,sCAPW,MAAM,aACN,MAAM,SACN,MAAM,QACN,MAAM,UACN,MAAM,GACJ,MAAM,CAuClB;IAED;;;;;;;OAOG;IACH,eAHW,MAAM,GACJ,IAAI,CAqBhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,WAFa,IAAI,CAqBhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAmBhB;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAiBhB;IAED;;;;;;;;OAQG;IACH,mBALW,MAAM,YACN,MAAM,aACN,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;OAKG;IACH,kBALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,IAAI,CAOhB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAXW,MAAM,EAAE,SACR,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CAyClB;;CAsCJ"}

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

@@ -0,0 +1,435 @@
+import { assert } from "../../../../core/assert.js";
+import {
+    CCR_AABB_MAX_X,
+    CCR_AABB_MAX_Y,
+    CCR_AABB_MAX_Z,
+    CCR_AABB_MIN_X,
+    CCR_AABB_MIN_Y,
+    CCR_AABB_MIN_Z,
+    CCR_FRICTION,
+    CCR_INFLATION,
+    CCR_META_ENTITY,
+    CCR_META_LAYER,
+    CCR_META_MASK,
+    CCR_META_STRIDE,
+    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 { cloth_collider_refit_bounds } from "./cloth_collider_bounds.js";
+import { cloth_collider_pack } from "./cloth_collider_pack.js";
+
+/**
+ * # The index of live cloth colliders
+ *
+ * A flat `Float64Array` of packed records in **world** coordinates, plus a
+ * parallel `Int32Array` of layer, mask and entity. §8.1's shape, and the same
+ * shape `AcousticOccluderIndex` + `OccluderBody` take in the sound simulation —
+ * a compact, pose-cached, broadphase-able view of a set of colliders that is
+ * deliberately **not** the physics BVH, because `ColliderObserverSystem` skips
+ * colliders with no owning body and a character's bone colliders have none.
+ *
+ * ## Why a linear scan and not a BVH
+ *
+ * `AcousticOccluderIndex` puts a BVH over its bodies and this does not, for two
+ * reasons that are both about what the query is.
+ *
+ * The query here is one AABB overlap per cloth per step against a set that is a
+ * character's bones — twenty or so, and never the whole world, because a
+ * `ClothCollider` is an opt-in marker rather than every collider in the scene.
+ * A tree over twenty leaves that all move every frame costs more to keep than
+ * to skip.
+ *
+ * And a {@link PlaneShape3D} has an **unbounded** AABB, which a BVH cannot hold
+ * — every refit would grow the root to infinity and every query would visit
+ * everything. A linear scan holds an infinity without complaint, because
+ * `min ≤ other_max` is still an answer when one side is `Infinity`. If a scene
+ * ever wants thousands of cloth colliders, the shape of the fix is a BVH over
+ * the bounded ones with the planes kept in a short list beside it.
+ *
+ * ## The previous pose is the index's, not the caller's
+ *
+ * Swept collision (§8.2) needs where each collider *was* as well as where it
+ * is. {@link advance} rolls the current pose into the previous one, and it is
+ * called once per fixed step by {@link ClothColliderSystem} before any pose is
+ * written. A collider that has just been added has both poses equal, so its
+ * first step sweeps nothing — which is right: it did not move, it appeared.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ClothColliderIndex {
+
+    /**
+     * Packed records, `CCR_STRIDE` doubles each. `Float64` rather than the
+     * `Float32` the per-cloth table uses, because these are world coordinates
+     * and a world coordinate can be kilometres from the origin, where `Float32`
+     * has given up the millimetre a contact is measured in.
+     * @type {Float64Array}
+     */
+    table = new Float64Array(0);
+
+    /**
+     * Layer, mask and entity per record. Integers, and not folded into
+     * {@link table}, because a mask of `0xFFFFFFFF` needs 32 bits of mantissa
+     * and rounding it would silently merge the highest layers.
+     * @type {Int32Array}
+     */
+    meta = new Int32Array(0);
+
+    /**
+     * Live records. Slots below this may still be retired — see
+     * {@link #free_slots}.
+     * @type {number}
+     */
+    count = 0;
+
+    /**
+     * Retired slots, reused before the table grows. A handle is a slot index,
+     * so reuse is what keeps handles dense; it also means a handle can name a
+     * *different* collider after a removal, which is why a cloth's warm-started
+     * contacts are keyed on the handle and dropped when the collider behind it
+     * changes (`cloth_contact_find.js`).
+     * @type {number[]}
+     * @private
+     */
+    #free_slots = [];
+
+    /**
+     * `true` for a live slot.
+     * @type {Uint8Array}
+     * @private
+     */
+    #live = new Uint8Array(0);
+
+    /**
+     * Add a collider. The shape is packed once, here; the pose is written by
+     * {@link setPose} and must be before the first query.
+     *
+     * @param {AbstractShape3D} shape in its canonical local frame
+     * @param {number} friction combined Coulomb coefficient
+     * @param {number} inflation metres
+     * @param {number} layer
+     * @param {number} mask
+     * @param {number} entity for diagnostics — the index never resolves it
+     * @returns {number} a handle, or `-1` if the shape is not one cloth collides against
+     */
+    add(shape, friction, inflation, layer, mask, entity) {
+        const handle = this.#free_slots.length > 0 ? this.#free_slots.pop() : this.count;
+
+        if (handle >= this.#capacity()) {
+            this.#grow(handle + 1);
+        }
+
+        if (!cloth_collider_pack(this.table, handle, shape, CCR_STRIDE)) {
+            this.#free_slots.push(handle);
+
+            return -1;
+        }
+
+        if (handle >= this.count) {
+            this.count = handle + 1;
+        }
+
+        const r = handle * CCR_STRIDE;
+
+        this.table[r + CCR_FRICTION] = friction;
+        this.table[r + CCR_INFLATION] = inflation;
+
+        const m = handle * CCR_META_STRIDE;
+
+        this.meta[m + CCR_META_LAYER] = layer;
+        this.meta[m + CCR_META_MASK] = mask;
+        this.meta[m + CCR_META_ENTITY] = entity;
+
+        this.#live[handle] = 1;
+
+        // No pose yet, and a record with an uninitialised rotation is a
+        // quaternion of all zeros — which normalises to nothing and poses
+        // everything at the origin. Identity until told otherwise.
+        this.table[r + CCR_QW] = 1;
+        this.table[r + CCR_PREV_QW] = 1;
+
+        return handle;
+    }
+
+    /**
+     * Retire a handle. Its slot is reused by the next {@link add}, and any
+     * cloth holding warm-started contacts against it drops them on its next
+     * step because the handle it remembers no longer names the same collider.
+     *
+     * @param {number} handle
+     * @returns {void}
+     */
+    remove(handle) {
+        if (handle < 0 || handle >= this.count || this.#live[handle] === 0) {
+            return;
+        }
+
+        this.#live[handle] = 0;
+        this.#free_slots.push(handle);
+
+        // A retired record must not be found by a query. Its bounds are emptied
+        // rather than its slot compacted, because compacting would move every
+        // handle above it and handles are what contacts are keyed on.
+        const r = handle * CCR_STRIDE;
+
+        this.table[r + CCR_AABB_MIN_X] = Infinity;
+        this.table[r + CCR_AABB_MIN_Y] = Infinity;
+        this.table[r + CCR_AABB_MIN_Z] = Infinity;
+        this.table[r + CCR_AABB_MAX_X] = -Infinity;
+        this.table[r + CCR_AABB_MAX_Y] = -Infinity;
+        this.table[r + CCR_AABB_MAX_Z] = -Infinity;
+    }
+
+    /**
+     * Whether a handle names a live collider.
+     * @param {number} handle
+     * @returns {boolean}
+     */
+    isLive(handle) {
+        return handle >= 0 && handle < this.count && this.#live[handle] === 1;
+    }
+
+    /**
+     * Roll every live record's current pose into its previous one. Called once
+     * per fixed step, before any pose for this step is written.
+     * @returns {void}
+     */
+    advance() {
+        const table = this.table;
+
+        for (let handle = 0; handle < this.count; handle++) {
+            if (this.#live[handle] === 0) {
+                continue;
+            }
+
+            const r = handle * CCR_STRIDE;
+
+            table[r + CCR_PREV_TX] = table[r + CCR_TX];
+            table[r + CCR_PREV_TY] = table[r + CCR_TY];
+            table[r + CCR_PREV_TZ] = table[r + CCR_TZ];
+
+            table[r + CCR_PREV_QX] = table[r + CCR_QX];
+            table[r + CCR_PREV_QY] = table[r + CCR_QY];
+            table[r + CCR_PREV_QZ] = table[r + CCR_QZ];
+            table[r + CCR_PREV_QW] = table[r + CCR_QW];
+        }
+    }
+
+    /**
+     * Place a collider and refresh its swept world bounds.
+     *
+     * PRECONDITION, inherited from `OccluderBody`: the pose is rigid. A
+     * `Transform64`'s scale is ignored here exactly as the physics narrowphase
+     * ignores it, so a distance in the shape's local frame is a distance in
+     * world space.
+     *
+     * @param {number} handle
+     * @param {number} tx
+     * @param {number} ty
+     * @param {number} tz
+     * @param {number} qx
+     * @param {number} qy
+     * @param {number} qz
+     * @param {number} qw
+     * @returns {void}
+     */
+    setPose(handle, tx, ty, tz, qx, qy, qz, qw) {
+        assert.ok(this.isLive(handle), `cloth collider handle ${handle} is not live`);
+
+        const table = this.table;
+
+        const r = handle * CCR_STRIDE;
+
+        table[r + CCR_TX] = tx;
+        table[r + CCR_TY] = ty;
+        table[r + CCR_TZ] = tz;
+
+        table[r + CCR_QX] = qx;
+        table[r + CCR_QY] = qy;
+        table[r + CCR_QZ] = qz;
+        table[r + CCR_QW] = qw;
+
+        cloth_collider_refit_bounds(this.table, handle, CCR_STRIDE);
+    }
+
+    /**
+     * Also set the previous pose, so the collider reads as having been placed
+     * rather than having moved. Used when a collider is first linked and when
+     * something has teleported it — a swept collision against a jump is a
+     * collider smeared across a kilometre.
+     *
+     * @param {number} handle
+     * @param {number} tx
+     * @param {number} ty
+     * @param {number} tz
+     * @param {number} qx
+     * @param {number} qy
+     * @param {number} qz
+     * @param {number} qw
+     * @returns {void}
+     */
+    placePose(handle, tx, ty, tz, qx, qy, qz, qw) {
+        assert.ok(this.isLive(handle), `cloth collider handle ${handle} is not live`);
+
+        const r = handle * CCR_STRIDE;
+
+        this.table[r + CCR_PREV_TX] = tx;
+        this.table[r + CCR_PREV_TY] = ty;
+        this.table[r + CCR_PREV_TZ] = tz;
+
+        this.table[r + CCR_PREV_QX] = qx;
+        this.table[r + CCR_PREV_QY] = qy;
+        this.table[r + CCR_PREV_QZ] = qz;
+        this.table[r + CCR_PREV_QW] = qw;
+
+        this.setPose(handle, tx, ty, tz, qx, qy, qz, qw);
+    }
+
+    /**
+     * Surface friction and inflation, after the fact. Both are read from
+     * components that an author can change while the scene runs.
+     *
+     * @param {number} handle
+     * @param {number} friction
+     * @param {number} inflation
+     * @returns {void}
+     */
+    setSurface(handle, friction, inflation) {
+        const r = handle * CCR_STRIDE;
+
+        this.table[r + CCR_FRICTION] = friction;
+        this.table[r + CCR_INFLATION] = inflation;
+    }
+
+    /**
+     * @param {number} handle
+     * @param {number} layer
+     * @param {number} mask
+     * @returns {void}
+     */
+    setFilter(handle, layer, mask) {
+        const m = handle * CCR_META_STRIDE;
+
+        this.meta[m + CCR_META_LAYER] = layer;
+        this.meta[m + CCR_META_MASK] = mask;
+    }
+
+    /**
+     * @param {number} handle
+     * @returns {number} the entity the collider was registered for
+     */
+    entityOf(handle) {
+        return this.meta[handle * CCR_META_STRIDE + CCR_META_ENTITY];
+    }
+
+    /**
+     * Every live collider whose swept bounds overlap the box and whose
+     * layer/mask agree with the caller's, written into `out` as handles.
+     *
+     * The filter is `RigidBody`'s and is symmetric: each side has to be in the
+     * other's mask, so a cloth that ignores a collider and a collider that
+     * ignores a cloth are the same statement made from two directions.
+     *
+     * @param {number[]} out grown as needed; only `[0, returned)` is valid
+     * @param {number} min_x
+     * @param {number} min_y
+     * @param {number} min_z
+     * @param {number} max_x
+     * @param {number} max_y
+     * @param {number} max_z
+     * @param {number} layer the querier's layer
+     * @param {number} mask the querier's mask
+     * @returns {number} how many handles were written
+     */
+    query(out, min_x, min_y, min_z, max_x, max_y, max_z, layer, mask) {
+        const table = this.table;
+        const meta = this.meta;
+
+        let found = 0;
+
+        for (let handle = 0; handle < this.count; handle++) {
+            if (this.#live[handle] === 0) {
+                continue;
+            }
+
+            const m = handle * CCR_META_STRIDE;
+
+            if ((mask & meta[m + CCR_META_LAYER]) === 0) {
+                continue;
+            }
+
+            if ((meta[m + CCR_META_MASK] & layer) === 0) {
+                continue;
+            }
+
+            const r = handle * CCR_STRIDE;
+
+            if (table[r + CCR_AABB_MIN_X] > max_x || table[r + CCR_AABB_MAX_X] < min_x) {
+                continue;
+            }
+
+            if (table[r + CCR_AABB_MIN_Y] > max_y || table[r + CCR_AABB_MAX_Y] < min_y) {
+                continue;
+            }
+
+            if (table[r + CCR_AABB_MIN_Z] > max_z || table[r + CCR_AABB_MAX_Z] < min_z) {
+                continue;
+            }
+
+            out[found++] = handle;
+        }
+
+        return found;
+    }
+
+    /**
+     * @returns {number}
+     * @private
+     */
+    #capacity() {
+        return this.#live.length;
+    }
+
+    /**
+     * @param {number} required
+     * @private
+     */
+    #grow(required) {
+        let capacity = this.#capacity();
+
+        if (capacity === 0) {
+            capacity = 8;
+        }
+
+        while (capacity < required) {
+            capacity *= 2;
+        }
+
+        const table = new Float64Array(capacity * CCR_STRIDE);
+        const meta = new Int32Array(capacity * CCR_META_STRIDE);
+        const live = new Uint8Array(capacity);
+
+        table.set(this.table);
+        meta.set(this.meta);
+        live.set(this.#live);
+
+        this.table = table;
+        this.meta = meta;
+        this.#live = live;
+    }
+
+}

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

@@ -0,0 +1,12 @@
+/**
+ * *
+ */
+export type ClothColliderKind = number;
+export namespace ClothColliderKind {
+    let Sphere: number;
+    let Capsule: number;
+    let Box: number;
+    let Cylinder: number;
+    let Plane: number;
+}
+//# sourceMappingURL=ClothColliderKind.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ClothColliderKind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/ClothColliderKind.js"],"names":[],"mappings":";;;gCAeU,MAAM"}

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

@@ -0,0 +1,38 @@
+/**
+ * The shapes cloth collides against.
+ *
+ * §8.2: analytic primitives only, which is universal in shipping cloth systems
+ * — MagicaCloth2 offers sphere, capsule and plane; Chaos Cloth adds tapered
+ * capsules and convex hulls — and is what makes the inner loop a handful of
+ * arithmetic instead of a BVH descent. A `Collider` carrying a mesh or a
+ * heightmap is skipped with one warning naming the entity, and the documented
+ * answer is to add primitive `ClothCollider` children, which is what an author
+ * would do for a character anyway.
+ *
+ * The values are indices into a dispatch, so they are contiguous from zero and
+ * their order is the order `cloth_collider_sdf.js` branches in.
+ *
+ * @readonly
+ * @enum {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export const ClothColliderKind = {
+    /** Radius in `CCR_PARAM_0`. */
+    Sphere: 0,
+
+    /** Radius in `CCR_PARAM_0`, segment length in `CCR_PARAM_1`, about local Y. */
+    Capsule: 1,
+
+    /** Half-extents in `CCR_PARAM_0..2`. */
+    Box: 2,
+
+    /** Radius in `CCR_PARAM_0`, height in `CCR_PARAM_1`, about local Y. */
+    Cylinder: 3,
+
+    /** Outward unit normal in `CCR_PARAM_0..2`, offset in `CCR_PARAM_3`. */
+    Plane: 4
+};
+
+Object.freeze(ClothColliderKind);