@driftengine/physics 3.61.0

package/dist/bodies.js

@@ -0,0 +1,298 @@
+import { combineMassProperties, createMassProperties, shapeMassProperties } from './mass.js';
+/**
+ * Rigid body state, structure-of-arrays, indexed by a dense body index.
+ *
+ * **`Float32Array` for state and doubles for every intermediate.** A store rounds through
+ * `Math.fround`, which ECMAScript specifies exactly, while the arithmetic between stores stays in
+ * doubles — so the solver computes at higher precision than it keeps and halves its memory
+ * bandwidth. Both halves of that are deliberate, and JavaScript has no SIMD to spend the bandwidth
+ * on instead.
+ *
+ * **Indices are dense and removal swaps the last body in**, so a caller holding an index must be
+ * told when one moves. `remove` returns the index that moved, or −1, and every structure keyed by
+ * body index has to act on it.
+ */
+export const BODY_STATIC = 0;
+export const BODY_KINEMATIC = 1;
+export const BODY_DYNAMIC = 2;
+/** Set on a body whose island is asleep. Woken bodies clear it together. */
+export const BODY_SLEEPING = 1;
+/**
+ * A sensor reports overlap and resolves none of it.
+ *
+ * Narrowphase still runs — an overlap that is never computed cannot be reported — and the solver is
+ * what skips it. **What this costs** is a sensor being as dear as a solid body in the broadphase and
+ * narrowphase, which is where most of the cost is anyway.
+ */
+export const BODY_SENSOR = 2;
+const SCRATCH_MASS = createMassProperties();
+export class BodySet {
+    count = 0;
+    posX;
+    posY;
+    posZ;
+    rotX;
+    rotY;
+    rotZ;
+    rotW;
+    velX;
+    velY;
+    velZ;
+    angX;
+    angY;
+    angZ;
+    invMass;
+    /** Body-frame inverse inertia, six symmetric terms per body: xx, yy, zz, xy, xz, yz. */
+    invInertia;
+    /** Centre of mass in body frame, which a shape built off-centre has. */
+    comX;
+    comY;
+    comZ;
+    friction;
+    restitution;
+    type;
+    flags;
+    sleepTicks;
+    layer;
+    mask;
+    shape = [];
+    /** The parts of a compound body, or undefined where it has a single `shape`. */
+    shapes = [];
+    capacity;
+    constructor(capacity = 64) {
+        this.capacity = Math.max(1, capacity | 0);
+        const f = (n = 1) => new Float32Array(this.capacity * n);
+        this.posX = f();
+        this.posY = f();
+        this.posZ = f();
+        this.rotX = f();
+        this.rotY = f();
+        this.rotZ = f();
+        this.rotW = f();
+        this.velX = f();
+        this.velY = f();
+        this.velZ = f();
+        this.angX = f();
+        this.angY = f();
+        this.angZ = f();
+        this.invMass = f();
+        this.invInertia = f(6);
+        this.comX = f();
+        this.comY = f();
+        this.comZ = f();
+        this.friction = f();
+        this.restitution = f();
+        this.type = new Uint8Array(this.capacity);
+        this.flags = new Uint8Array(this.capacity);
+        this.sleepTicks = new Uint16Array(this.capacity);
+        this.layer = new Uint32Array(this.capacity);
+        this.mask = new Uint32Array(this.capacity);
+    }
+    add(desc) {
+        if (this.count === this.capacity)
+            this.grow();
+        const i = this.count++;
+        this.posX[i] = desc.x ?? 0;
+        this.posY[i] = desc.y ?? 0;
+        this.posZ[i] = desc.z ?? 0;
+        this.rotX[i] = desc.qx ?? 0;
+        this.rotY[i] = desc.qy ?? 0;
+        this.rotZ[i] = desc.qz ?? 0;
+        this.rotW[i] = desc.qw ?? 1;
+        this.velX[i] = 0;
+        this.velY[i] = 0;
+        this.velZ[i] = 0;
+        this.angX[i] = 0;
+        this.angY[i] = 0;
+        this.angZ[i] = 0;
+        this.type[i] = desc.type;
+        this.flags[i] = desc.sensor ? BODY_SENSOR : 0;
+        this.sleepTicks[i] = 0;
+        this.friction[i] = desc.friction ?? 0.5;
+        this.restitution[i] = desc.restitution ?? 0;
+        this.layer[i] = desc.layer ?? 1;
+        this.mask[i] = desc.mask ?? 0xffffffff;
+        this.shape[i] = desc.shape;
+        this.shapes[i] = desc.shapes;
+        /*
+         * A static or kinematic body has zero inverse mass and zero inverse inertia, which is what
+         * makes it immovable *arithmetically* rather than by a branch in the solver. Every constraint
+         * then treats it uniformly and the hot loop has one fewer test in it.
+         */
+        if (desc.type === BODY_DYNAMIC) {
+            const density = desc.density ?? 1000;
+            const m = desc.shapes
+                ? combineMassProperties(desc.shapes, density, SCRATCH_MASS)
+                : shapeMassProperties(desc.shape, density, SCRATCH_MASS);
+            const mass = m.volume * density;
+            this.invMass[i] = mass > 0 ? 1 / mass : 0;
+            this.comX[i] = m.comX;
+            this.comY[i] = m.comY;
+            this.comZ[i] = m.comZ;
+            invertSymmetric(m.ixx, m.iyy, m.izz, m.ixy, m.ixz, m.iyz, this.invInertia, i * 6);
+        }
+        else {
+            this.invMass[i] = 0;
+            this.comX[i] = 0;
+            this.comY[i] = 0;
+            this.comZ[i] = 0;
+            for (let k = 0; k < 6; k++)
+                this.invInertia[i * 6 + k] = 0;
+        }
+        return i;
+    }
+    /** Swap-remove. Returns the index that moved into `index`, or −1 if it was the last. */
+    remove(index) {
+        const last = --this.count;
+        if (index === last) {
+            this.shape[index] = undefined;
+            this.shapes[index] = undefined;
+            return -1;
+        }
+        const copy = (a, stride = 1) => {
+            for (let k = 0; k < stride; k++)
+                a[index * stride + k] = a[last * stride + k] ?? 0;
+        };
+        for (const a of [
+            this.posX,
+            this.posY,
+            this.posZ,
+            this.rotX,
+            this.rotY,
+            this.rotZ,
+            this.rotW,
+            this.velX,
+            this.velY,
+            this.velZ,
+            this.angX,
+            this.angY,
+            this.angZ,
+            this.invMass,
+            this.comX,
+            this.comY,
+            this.comZ,
+            this.friction,
+            this.restitution,
+        ])
+            copy(a);
+        copy(this.invInertia, 6);
+        copy(this.type);
+        copy(this.flags);
+        copy(this.sleepTicks);
+        copy(this.layer);
+        copy(this.mask);
+        this.shape[index] = this.shape[last];
+        this.shape[last] = undefined;
+        this.shapes[index] = this.shapes[last];
+        this.shapes[last] = undefined;
+        return last;
+    }
+    /**
+     * Fill `out` with the world-frame inverse inertia, six symmetric terms.
+     *
+     * `R · I⁻¹ · Rᵀ`, a congruence, rather than a diagonalisation. Storing three principal moments
+     * would need an eigen decomposition, and Jacobi is iterative — a fixed sweep count would be
+     * deterministic but is one more thing to get exactly right for no gain. **What this gives up** is
+     * six floats per body instead of three and a congruence per substep. **What would make it wrong**
+     * is a measurement showing that congruence dominates the tick.
+     */
+    worldInverseInertia(index, out, at = 0) {
+        const x = this.rotX[index] ?? 0;
+        const y = this.rotY[index] ?? 0;
+        const z = this.rotZ[index] ?? 0;
+        const w = this.rotW[index] ?? 1;
+        // Rotation matrix, row-major.
+        const r00 = 1 - 2 * (y * y + z * z);
+        const r01 = 2 * (x * y - z * w);
+        const r02 = 2 * (x * z + y * w);
+        const r10 = 2 * (x * y + z * w);
+        const r11 = 1 - 2 * (x * x + z * z);
+        const r12 = 2 * (y * z - x * w);
+        const r20 = 2 * (x * z - y * w);
+        const r21 = 2 * (y * z + x * w);
+        const r22 = 1 - 2 * (x * x + y * y);
+        const b = index * 6;
+        const mxx = this.invInertia[b] ?? 0;
+        const myy = this.invInertia[b + 1] ?? 0;
+        const mzz = this.invInertia[b + 2] ?? 0;
+        const mxy = this.invInertia[b + 3] ?? 0;
+        const mxz = this.invInertia[b + 4] ?? 0;
+        const myz = this.invInertia[b + 5] ?? 0;
+        // T = R · M, then out = T · Rᵀ, keeping only the six symmetric terms.
+        const t00 = r00 * mxx + r01 * mxy + r02 * mxz;
+        const t01 = r00 * mxy + r01 * myy + r02 * myz;
+        const t02 = r00 * mxz + r01 * myz + r02 * mzz;
+        const t10 = r10 * mxx + r11 * mxy + r12 * mxz;
+        const t11 = r10 * mxy + r11 * myy + r12 * myz;
+        const t12 = r10 * mxz + r11 * myz + r12 * mzz;
+        const t20 = r20 * mxx + r21 * mxy + r22 * mxz;
+        const t21 = r20 * mxy + r21 * myy + r22 * myz;
+        const t22 = r20 * mxz + r21 * myz + r22 * mzz;
+        out[at] = t00 * r00 + t01 * r01 + t02 * r02;
+        out[at + 1] = t10 * r10 + t11 * r11 + t12 * r12;
+        out[at + 2] = t20 * r20 + t21 * r21 + t22 * r22;
+        out[at + 3] = t00 * r10 + t01 * r11 + t02 * r12;
+        out[at + 4] = t00 * r20 + t01 * r21 + t02 * r22;
+        out[at + 5] = t10 * r20 + t11 * r21 + t12 * r22;
+    }
+    grow() {
+        const next = this.capacity * 2;
+        const wider = (a, stride = 1) => {
+            const out = new a.constructor(next * stride);
+            out.set(a);
+            return out;
+        };
+        this.posX = wider(this.posX);
+        this.posY = wider(this.posY);
+        this.posZ = wider(this.posZ);
+        this.rotX = wider(this.rotX);
+        this.rotY = wider(this.rotY);
+        this.rotZ = wider(this.rotZ);
+        this.rotW = wider(this.rotW);
+        this.velX = wider(this.velX);
+        this.velY = wider(this.velY);
+        this.velZ = wider(this.velZ);
+        this.angX = wider(this.angX);
+        this.angY = wider(this.angY);
+        this.angZ = wider(this.angZ);
+        this.invMass = wider(this.invMass);
+        this.invInertia = wider(this.invInertia, 6);
+        this.comX = wider(this.comX);
+        this.comY = wider(this.comY);
+        this.comZ = wider(this.comZ);
+        this.friction = wider(this.friction);
+        this.restitution = wider(this.restitution);
+        this.type = wider(this.type);
+        this.flags = wider(this.flags);
+        this.sleepTicks = wider(this.sleepTicks);
+        this.layer = wider(this.layer);
+        this.mask = wider(this.mask);
+        this.capacity = next;
+    }
+}
+/**
+ * Invert a symmetric 3×3 in closed form, writing six terms.
+ *
+ * A singular tensor — a shape with no volume — inverts to zero rather than to infinity, which makes
+ * it behave as a point mass instead of producing NaN in every constraint that touches it. An
+ * unwritten uniform is zero and zero is a real value, which is the failure this engine has recorded
+ * twice; here zero is the *correct* value and the comment is what says so.
+ */
+function invertSymmetric(xx, yy, zz, xy, xz, yz, out, at) {
+    const c00 = yy * zz - yz * yz;
+    const c01 = xz * yz - xy * zz;
+    const c02 = xy * yz - xz * yy;
+    const det = xx * c00 + xy * c01 + xz * c02;
+    if (det === 0) {
+        for (let k = 0; k < 6; k++)
+            out[at + k] = 0;
+        return;
+    }
+    const inv = 1 / det;
+    out[at] = c00 * inv;
+    out[at + 1] = (xx * zz - xz * xz) * inv;
+    out[at + 2] = (xx * yy - xy * xy) * inv;
+    out[at + 3] = c01 * inv;
+    out[at + 4] = c02 * inv;
+    out[at + 5] = (xy * xz - xx * yz) * inv;
+}

package/dist/buoyancy.d.ts

@@ -0,0 +1,46 @@
+/**
+ * What water does to a body that falls in.
+ *
+ * **Two things, and both are about momentum rather than about floating.** A kinematic body has no
+ * mass to displace, so there is no buoyant force to compute — what a consumer actually wants is
+ * that falling in *costs* something, and that the drop settles instead of accelerating into the
+ * seabed.
+ *
+ * **Drag on every axis, not only the vertical one.** Killing horizontal momentum is the whole
+ * reason falling in is a setback rather than a shortcut: a body that kept its speed underwater
+ * would be taking a faster line.
+ *
+ * Zero game nouns, which is why it is here. What stays with a consumer is where the water is.
+ */
+export interface BuoyancyOptions {
+    /**
+     * The surface height. Default −Infinity, which is a world with no water in it.
+     *
+     * A consumer that has not asked reaches none of this and pays for none of it.
+     */
+    level?: number;
+    /** How much of a body's speed a second of water takes, as a fraction. */
+    drag?: number;
+    /** The fastest a submerged body sinks, metres a second. Negative is downward. */
+    sinkSpeed?: number;
+}
+export interface Buoyancy {
+    readonly level: number;
+    readonly drag: number;
+    readonly sinkSpeed: number;
+}
+/** Anything with a velocity. Declared structurally so nothing is imported in either direction. */
+export interface BuoyantState {
+    velX: number;
+    velY: number;
+    velZ: number;
+}
+export declare function createBuoyancy(options?: BuoyancyOptions): Buoyancy;
+/**
+ * Apply it, and report whether the body is submerged.
+ *
+ * @param y Where the body is. Under `level` is submerged.
+ * @returns Whether it was, so a consumer can count the time or drown somebody — which is a game's
+ *   decision and not this function's.
+ */
+export declare function applyBuoyancy(water: Buoyancy, y: number, state: BuoyantState, dt: number): boolean;

package/dist/buoyancy.js

@@ -0,0 +1,45 @@
+/**
+ * What water does to a body that falls in.
+ *
+ * **Two things, and both are about momentum rather than about floating.** A kinematic body has no
+ * mass to displace, so there is no buoyant force to compute — what a consumer actually wants is
+ * that falling in *costs* something, and that the drop settles instead of accelerating into the
+ * seabed.
+ *
+ * **Drag on every axis, not only the vertical one.** Killing horizontal momentum is the whole
+ * reason falling in is a setback rather than a shortcut: a body that kept its speed underwater
+ * would be taking a faster line.
+ *
+ * Zero game nouns, which is why it is here. What stays with a consumer is where the water is.
+ */
+export function createBuoyancy(options = {}) {
+    return {
+        level: options.level ?? -Infinity,
+        drag: options.drag ?? 0,
+        sinkSpeed: options.sinkSpeed ?? 0,
+    };
+}
+/**
+ * Apply it, and report whether the body is submerged.
+ *
+ * @param y Where the body is. Under `level` is submerged.
+ * @returns Whether it was, so a consumer can count the time or drown somebody — which is a game's
+ *   decision and not this function's.
+ */
+export function applyBuoyancy(water, y, state, dt) {
+    if (y >= water.level)
+        return false;
+    /*
+     * Clamped at zero: `1 − drag·dt` goes negative past `dt = 1/drag`, and a negative factor does
+     * not slow a body, it throws it backwards. The worst a long step can do is stop it dead.
+     */
+    const kept = Math.max(0, 1 - water.drag * dt);
+    state.velX *= kept;
+    state.velY *= kept;
+    state.velZ *= kept;
+    /* A floor on the fall rather than a speed it is driven to: a body drifting down slower than
+       terminal is left alone, and one falling faster is settled to it. */
+    if (state.velY < water.sinkSpeed)
+        state.velY = water.sinkSpeed;
+    return true;
+}

package/dist/cloth.d.ts

@@ -0,0 +1,226 @@
+import type { PhysicsWorld } from './world.ts';
+/**
+ * Cloth, as position-based dynamics with compliance.
+ *
+ * **A separate solver from the rigid bodies, deliberately, and it is §5's decision in a different
+ * place.** Thousands of rotationless particles are the wrong data layout for a rigid constraint
+ * graph: every particle would carry an orientation it never uses and an inertia tensor that is
+ * always zero. Two solvers with two jobs, not two implementations of one decision.
+ *
+ * **Compliance rather than a stiffness constant**, for the same reason §7 states contact stiffness
+ * as a frequency: `α = compliance / h²` makes a constraint's stiffness independent of the step
+ * length, so the iteration count is a quality dial rather than a behaviour change. A raw
+ * position-based solver's stiffness is a function of how many times you iterated, which means
+ * tuning it is tuning the solver rather than the cloth.
+ *
+ * **Two-way coupled since 2026-08-27, by an impulse exchange rather than by a merged island.** The
+ * refusal this replaces was right about the price and wrong about the only way to pay it. Putting
+ * particles into the rigid solver's constraint graph *would* merge islands — a character in a cloak
+ * becomes one island with everything the cloak brushes, and merged islands are what §8a's
+ * parallelism is made of. So that is still refused. What ships instead is the exchange the two
+ * solvers can make **without either learning about the other's structure**: the collision pass
+ * already moves a particle out of a body, and a particle moved by `d` in a tick of `h` has had its
+ * momentum changed by `m·d/h`; the body receives the opposite of that at the contact point, through
+ * the same `applyImpulse` any consumer would call.
+ *
+ * **What that costs, said plainly.** The exchange is *explicit* — the body responds on the next
+ * tick rather than in the same solve — so it is a spring with a one-tick delay in it, and a very
+ * heavy sheet landing on a very light body can oscillate. `coupling` is a scale from 0 to 1 and
+ * **0 is the default**, so no existing consumer's world moves by a millimetre until it asks. *What
+ * would reverse the remaining refusal:* a consumer who needs the sheet and the body to converge
+ * together in one solve, at which point the price is the island structure and it is a track rather
+ * than a field.
+ */
+export interface ClothOptions {
+    /** Metres of stretch per newton. Zero is inextensible; larger is stretchier. */
+    stretchCompliance?: number;
+    /** The same, for the constraints that resist folding. */
+    bendCompliance?: number;
+    /** Solver passes per tick. A quality dial: compliance keeps stiffness meaningful across it. */
+    iterations?: number;
+    /**
+     * How close two unconnected particles may come before they push each other apart, in metres.
+     *
+     * **0 is off and is the default**, because self-collision is the half of cloth whose *tuning*
+     * decides whether it ships: a sheet that resists itself at a distance larger than its own
+     * spacing cannot lie flat, and one that resists at a distance far smaller than a fold's
+     * thickness passes through itself anyway. A consumer sets this from the sheet they built, and
+     * the honest starting point is **a little under the grid spacing** — `makeClothGrid` at 5 cm
+     * wants about 3 to 4 cm.
+     *
+     * **Particles joined by a constraint are exempt**, and that is not an optimisation. A stretch
+     * link's rest length is the spacing, so a self-collision distance anywhere near it would have
+     * every neighbour pair fighting its own link at every step — the sheet would inflate rather than
+     * drape, which is the failure that reads as a solver bug. `ClothBody` builds the adjacency once
+     * at construction for exactly this.
+     */
+    selfDistance?: number;
+    /** Per-second velocity retained, as a fraction. */
+    damping?: number;
+    /** How far a particle is held off a surface it meets. */
+    thickness?: number;
+    /**
+     * How much of the momentum a pushed particle gave up is handed back to the body, 0 to 1.
+     *
+     * **0 by default, which is one-way coupling and is what every consumer had before this existed.**
+     * 1 is the whole exchange; anything between is a sheet that pushes less than its mass says it
+     * should, which is the dial a consumer reaches for when the delay in the exchange makes a light
+     * body jitter.
+     */
+    coupling?: number;
+    /**
+     * What one particle weighs, in kilograms. Only the coupling reads it.
+     *
+     * **Separate from `invMass`, and the separation is deliberate.** That array is a *relative
+     * weight* in the position solve — every free particle is 1 and a pinned one is 0 — and the
+     * compliance is tuned against it, so redefining it as an inverse mass in kilograms would move
+     * every sheet any consumer has ever tuned. The coupling needs kilograms and nothing else does,
+     * so it takes them here.
+     *
+     * The default is fifty grams: a square metre of ordinary cloth is two to three hundred grams,
+     * and `makeClothGrid` at a five-centimetre spacing puts four hundred particles in that square
+     * metre. A consumer building a tarpaulin or a chainmail cape sets it.
+     */
+    particleMass?: number;
+    gravityX?: number;
+    gravityY?: number;
+    gravityZ?: number;
+}
+export declare class ClothBody {
+    /** xyz-packed particle positions. */
+    readonly position: Float32Array;
+    /** xyz-packed velocities. */
+    readonly velocity: Float32Array;
+    /** Inverse mass per particle. Zero pins it. */
+    readonly invMass: Float32Array;
+    readonly count: number;
+    /** Two particle indices per constraint. */
+    private readonly link;
+    private readonly rest;
+    /** Compliance per constraint, so stretch and bend can differ. */
+    private readonly compliance;
+    private readonly previous;
+    private readonly lambda;
+    private readonly linkCount;
+    readonly iterations: number;
+    readonly damping: number;
+    readonly thickness: number;
+    /** See `ClothOptions.coupling`. 0 is one-way, which is the default. */
+    readonly coupling: number;
+    /** See `ClothOptions.particleMass`. Kilograms, read only by the coupling. */
+    readonly particleMass: number;
+    /** See `ClothOptions.selfDistance`. 0 is off, which is the default. */
+    readonly selfDistance: number;
+    /**
+     * Who is linked to whom, as CSR: `neighbourStart[i]` to `neighbourStart[i + 1]` indexes
+     * `neighbour`.
+     *
+     * **Built once, because the link set never changes** and the self-collision pass asks "are these
+     * two linked" once per candidate pair per tick. A `Set` of packed pairs would answer the same
+     * question with a hash probe and an allocation at construction the size of the link list; a
+     * sorted adjacency answers it with a scan over the eight or so neighbours a grid particle has,
+     * which is shorter than the probe.
+     *
+     * Empty when `selfDistance` is 0, so a sheet that does not collide with itself pays neither the
+     * memory nor the build.
+     */
+    private readonly neighbourStart;
+    private readonly neighbour;
+    /**
+     * The spatial hash the self-collision pass rebuilds each tick: a cell list over the particles.
+     *
+     * **A hash rather than a grid, because a sheet has no bounds worth allocating for.** A curtain
+     * hanging in a room occupies a sliver of it, and a dense grid over the room's extent would be
+     * mostly empty cells rebuilt every tick. The table is sized once from the particle count and
+     * reused; `cellHead` and `cellNext` are the standard two arrays, so a rebuild is one pass that
+     * writes and allocates nothing.
+     */
+    private readonly cellHead;
+    private readonly cellNext;
+    gravityX: number;
+    gravityY: number;
+    gravityZ: number;
+    constructor(positions: Float32Array, links: Int32Array, bendLinks: Int32Array, options?: ClothOptions);
+    /** Pin a particle where it is, or release it. */
+    pin(index: number, pinned?: boolean): void;
+    /**
+     * Advance one fixed tick.
+     *
+     * Integrate, project every constraint `iterations` times, then derive velocity from how far each
+     * particle actually moved — which is what makes it position-based: a constraint that moves a
+     * particle also, by construction, changes its velocity, so nothing has to reconcile the two.
+     */
+    step(world: PhysicsWorld | null, dt: number): void;
+    /**
+     * One distance constraint, with its compliance.
+     *
+     * `α = compliance / h²` is what makes the stiffness independent of the step and of the iteration
+     * count. At zero compliance this reduces exactly to an ordinary position-based projection, which
+     * is why an inextensible sheet costs nothing extra.
+     */
+    private project;
+    /**
+     * Keep the sheet out of itself: a spatial hash over the particles, and a symmetric push apart.
+     *
+     * **The hash is rebuilt every tick and that is the cheap half.** One pass over the particles
+     * writing two integers each, against a structure that tried to be incremental and would have to
+     * know which particles moved — which in a cloth solver is all of them.
+     *
+     * The cell size is the self-collision distance, so a particle's neighbours are in its own cell
+     * and the twenty-six around it. **The 3x3x3 scan is what makes the answer complete**: a pair at
+     * the distance exactly cannot be in cells more than one apart, and a scan of the own cell alone
+     * would miss every pair straddling a boundary — which is most of them, since a folded sheet lies
+     * along one.
+     *
+     * **Each pair is resolved once, by index order.** Visiting both halves would apply the
+     * correction twice and turn a resting fold into a buzzing one; the `other > i` test is what
+     * makes the pass a sweep over pairs rather than over particles.
+     *
+     * A projection rather than a constraint with compliance, unlike the distance links: a contact is
+     * an inequality — it does nothing until it is violated — and XPBD's accumulated multiplier is
+     * for a constraint that holds all tick. *What that gives up* is that the stiffness of a fold is
+     * the iteration count's again, for this one term. *What would make it wrong* is a consumer
+     * wanting a fold to have a measurable resistance, at which point it needs its own multiplier
+     * array and a sign clamp on it.
+     */
+    private collideSelf;
+    /** Whether a link joins these two. A scan over the eight or so a grid particle has. */
+    private linked;
+    /** Push two particles apart to exactly `radius`, split by their inverse masses. */
+    private separate;
+    /**
+     * Push every particle out of anything it has entered, and hand the body back what it took.
+     *
+     * **The impulse is derived from the correction rather than measured**, which is what makes the
+     * exchange cost one multiply: the constraint solve has already decided where the particle would
+     * be, the push says where it must be instead, and the difference over the tick is the velocity
+     * the collision removed from it. `m·Δ/h` is that momentum, and the body gets its negative at the
+     * point of contact — a push straight down on a plank's end tips the plank, because
+     * `applyImpulse` takes the point.
+     *
+     * A static body is skipped for the impulse rather than for the push: scenery does not move, and
+     * `applyImpulse` would return without doing anything anyway.
+     */
+    private collideParticles;
+}
+/**
+ * A rectangular sheet: positions, its stretch links, and the bend links across them.
+ *
+ * Bend links skip a particle rather than joining diagonals, because a diagonal resists *shear* and a
+ * skip resists *bowing*, and a sheet that cannot shear drapes like cardboard.
+ *
+ * **A skip-one distance constraint resists curvature and not orientation**, which is worth knowing
+ * before tuning it: three collinear particles satisfy it at any angle, so a flat sheet and a sheet
+ * hanging straight down are equally happy. Measured — a cantilever pinned along one edge settles at
+ * exactly vertical whether the bend compliance is 1e-8 or 1e6. What it *does* buy is 12.5
+ * millimetres less bow on a strip pinned at both ends with slack.
+ *
+ * **What would make it wrong** is a consumer wanting a cloak to stand out from a shoulder, and the
+ * answer then is a dihedral-angle constraint over the two triangles either side of an edge, which
+ * knows a rest angle and therefore knows the difference between flat and folded.
+ */
+export declare function makeClothGrid(columns: number, rows: number, spacing: number): {
+    positions: Float32Array;
+    links: Int32Array;
+    bendLinks: Int32Array;
+};