@woosh/meep-engine 2.147.0 → 2.148.0

package/src/engine/physics/integration/integrate_velocity.js

@@ -1,160 +1,201 @@
-import { BodyKind } from "../ecs/BodyKind.js";
-import { world_inverse_inertia_apply } from "../inertia/world_inverse_inertia.js";
-
-const scratch_angular = new Float64Array(3);
-
-/**
- * Semi-implicit Euler velocity integration for a single rigid body.
- *
- * For Dynamic bodies:
- *  - gravity (scaled by `gravityScale`) and the accumulated force are converted
- *    to a velocity delta via `1/mass`,
- *  - accumulated torque is converted to angular acceleration via the
- *    world-frame inverse inertia (R · diag(I_local) · R^T applied to τ),
- *  - linear and angular damping are applied as a stable implicit decay
- *    `v *= 1 / (1 + d·dt)` (Box2D / Bullet recipe — never goes negative, no
- *    `exp()` call on the hot path),
- *  - the force / torque accumulators are zeroed afterwards.
- *
- * Kinematic and Static bodies are skipped — their velocity is the
- * user / animation system's responsibility.
- *
- * @param {RigidBody} rb
- * @param {Transform} transform  used to rotate body-frame inertia into world
- * @param {number} gx world gravity x
- * @param {number} gy world gravity y
- * @param {number} gz world gravity z
- * @param {number} dt step size in seconds
- */
-export function integrate_velocity(rb, transform, gx, gy, gz, dt) {
-    const af = rb.accumulatedForce;
-    const at = rb.accumulatedTorque;
-
-    if (rb.kind !== BodyKind.Dynamic) {
-        // Direct indexing — no observer listens to body-internal accumulators.
-        af[0] = 0; af[1] = 0; af[2] = 0;
-        at[0] = 0; at[1] = 0; at[2] = 0;
-        return;
-    }
-
-    const inv_m = rb.mass > 0 ? 1 / rb.mass : 0;
-    const gs = rb.gravityScale;
-
-    // Linear velocity update: v += (F * invM + g * gravityScale) * dt
-    const lv = rb.linearVelocity;
-    let lvx = lv[0] + (af[0] * inv_m + gx * gs) * dt;
-    let lvy = lv[1] + (af[1] * inv_m + gy * gs) * dt;
-    let lvz = lv[2] + (af[2] * inv_m + gz * gs) * dt;
-
-    if (rb.linearDamping > 0) {
-        const k = 1 / (1 + rb.linearDamping * dt);
-        lvx *= k;
-        lvy *= k;
-        lvz *= k;
-    }
-    lv[0] = lvx; lv[1] = lvy; lv[2] = lvz;
-
-    // Angular velocity update: ω += I_world⁻¹ · τ · dt
-    const av = rb.angularVelocity;
-    let avx = av[0];
-    let avy = av[1];
-    let avz = av[2];
-    if (at[0] !== 0 || at[1] !== 0 || at[2] !== 0) {
-        world_inverse_inertia_apply(scratch_angular, 0, rb.inverseInertiaLocal, transform.rotation, at[0], at[1], at[2]);
-        avx += scratch_angular[0] * dt;
-        avy += scratch_angular[1] * dt;
-        avz += scratch_angular[2] * dt;
-    }
-
-    if (rb.angularDamping > 0) {
-        const k = 1 / (1 + rb.angularDamping * dt);
-        avx *= k;
-        avy *= k;
-        avz *= k;
-    }
-    av[0] = avx; av[1] = avy; av[2] = avz;
-
-    af[0] = 0; af[1] = 0; af[2] = 0;
-    at[0] = 0; at[1] = 0; at[2] = 0;
-}
-
-/**
- * Apply the accumulated force / torque to velocity over a step `dt`, then
- * zero the accumulators. Gravity and damping are NOT applied here.
- *
- * The "once per outer step" half of the TGS integrator: a user force is a
- * per-frame budget that must land in full exactly once, independent of
- * substep count. Gravity is the continuous field re-applied every substep
- * by {@link integrate_velocity_gravity}.
- *
- * @param {RigidBody} rb
- * @param {Transform} transform  used to rotate body-frame inertia into world
- * @param {number} dt full outer-step size in seconds
- */
-export function integrate_velocity_forces(rb, transform, dt) {
-    const af = rb.accumulatedForce;
-    const at = rb.accumulatedTorque;
-
-    if (rb.kind !== BodyKind.Dynamic) {
-        af[0] = 0; af[1] = 0; af[2] = 0;
-        at[0] = 0; at[1] = 0; at[2] = 0;
-        return;
-    }
-
-    const inv_m = rb.mass > 0 ? 1 / rb.mass : 0;
-
-    const lv = rb.linearVelocity;
-    lv[0] += af[0] * inv_m * dt;
-    lv[1] += af[1] * inv_m * dt;
-    lv[2] += af[2] * inv_m * dt;
-
-    if (at[0] !== 0 || at[1] !== 0 || at[2] !== 0) {
-        world_inverse_inertia_apply(scratch_angular, 0, rb.inverseInertiaLocal, transform.rotation, at[0], at[1], at[2]);
-        const av = rb.angularVelocity;
-        av[0] += scratch_angular[0] * dt;
-        av[1] += scratch_angular[1] * dt;
-        av[2] += scratch_angular[2] * dt;
-    }
-
-    af[0] = 0; af[1] = 0; af[2] = 0;
-    at[0] = 0; at[1] = 0; at[2] = 0;
-}
-
-/**
- * Apply gravity and velocity damping over a (sub)step `dt`. Does NOT touch
- * the force / torque accumulators (consumed once by
- * {@link integrate_velocity_forces}).
- *
- * The "every substep" half of the TGS integrator. Per substep the body sees
- * only `g·h` of gravity, which the per-substep contact warm-start + solve
- * cancels exactly — keeping a resting stack at zero velocity. Damping is the
- * stable implicit decay `v *= 1/(1 + d·dt)` applied at the substep `dt`.
- *
- * @param {RigidBody} rb
- * @param {Transform} transform  (unused; signature symmetry with the family)
- * @param {number} gx @param {number} gy @param {number} gz world gravity
- * @param {number} dt sub-step size in seconds
- */
-export function integrate_velocity_gravity(rb, transform, gx, gy, gz, dt) {
-    if (rb.kind !== BodyKind.Dynamic) {
-        return;
-    }
-
-    const gs = rb.gravityScale;
-    const lv = rb.linearVelocity;
-    let lvx = lv[0] + gx * gs * dt;
-    let lvy = lv[1] + gy * gs * dt;
-    let lvz = lv[2] + gz * gs * dt;
-
-    if (rb.linearDamping > 0) {
-        const k = 1 / (1 + rb.linearDamping * dt);
-        lvx *= k; lvy *= k; lvz *= k;
-    }
-    lv[0] = lvx; lv[1] = lvy; lv[2] = lvz;
-
-    if (rb.angularDamping > 0) {
-        const av = rb.angularVelocity;
-        const k = 1 / (1 + rb.angularDamping * dt);
-        av[0] *= k; av[1] *= k; av[2] *= k;
-    }
-}
+import { SBS_AV_X, SBS_AV_Y, SBS_AV_Z, SBS_LV_X, SBS_LV_Y, SBS_LV_Z, } from "../body/SolverBodyState.js";
+import { BodyKind } from "../ecs/BodyKind.js";
+import { world_inverse_inertia_apply } from "../inertia/world_inverse_inertia.js";
+
+const scratch_angular = new Float64Array(3);
+
+/**
+ * Semi-implicit Euler velocity integration for a single rigid body.
+ *
+ * For Dynamic bodies:
+ *  - gravity (scaled by `gravityScale`) and the accumulated force are converted
+ *    to a velocity delta via `1/mass`,
+ *  - accumulated torque is converted to angular acceleration via the
+ *    world-frame inverse inertia (R · diag(I_local) · R^T applied to τ),
+ *  - linear and angular damping are applied as a stable implicit decay
+ *    `v *= 1 / (1 + d·dt)` (Box2D / Bullet recipe — never goes negative, no
+ *    `exp()` call on the hot path),
+ *  - the force / torque accumulators are zeroed afterwards.
+ *
+ * Kinematic and Static bodies are skipped — their velocity is the
+ * user / animation system's responsibility.
+ *
+ * @param {RigidBody} rb
+ * @param {Transform} transform  used to rotate body-frame inertia into world
+ * @param {number} gx world gravity x
+ * @param {number} gy world gravity y
+ * @param {number} gz world gravity z
+ * @param {number} dt step size in seconds
+ */
+export function integrate_velocity(rb, transform, gx, gy, gz, dt) {
+    const af = rb.accumulatedForce;
+    const at = rb.accumulatedTorque;
+
+    if (rb.kind !== BodyKind.Dynamic) {
+        // Direct indexing — no observer listens to body-internal accumulators.
+        af[0] = 0; af[1] = 0; af[2] = 0;
+        at[0] = 0; at[1] = 0; at[2] = 0;
+        return;
+    }
+
+    const inv_m = rb.mass > 0 ? 1 / rb.mass : 0;
+    const gs = rb.gravityScale;
+
+    // Linear velocity update: v += (F * invM + g * gravityScale) * dt
+    const lv = rb.linearVelocity;
+    let lvx = lv[0] + (af[0] * inv_m + gx * gs) * dt;
+    let lvy = lv[1] + (af[1] * inv_m + gy * gs) * dt;
+    let lvz = lv[2] + (af[2] * inv_m + gz * gs) * dt;
+
+    if (rb.linearDamping > 0) {
+        const k = 1 / (1 + rb.linearDamping * dt);
+        lvx *= k;
+        lvy *= k;
+        lvz *= k;
+    }
+    lv[0] = lvx; lv[1] = lvy; lv[2] = lvz;
+
+    // Angular velocity update: ω += I_world⁻¹ · τ · dt
+    const av = rb.angularVelocity;
+    let avx = av[0];
+    let avy = av[1];
+    let avz = av[2];
+    if (at[0] !== 0 || at[1] !== 0 || at[2] !== 0) {
+        world_inverse_inertia_apply(scratch_angular, 0, rb.inverseInertiaLocal, transform.rotation, at[0], at[1], at[2]);
+        avx += scratch_angular[0] * dt;
+        avy += scratch_angular[1] * dt;
+        avz += scratch_angular[2] * dt;
+    }
+
+    if (rb.angularDamping > 0) {
+        const k = 1 / (1 + rb.angularDamping * dt);
+        avx *= k;
+        avy *= k;
+        avz *= k;
+    }
+    av[0] = avx; av[1] = avy; av[2] = avz;
+
+    af[0] = 0; af[1] = 0; af[2] = 0;
+    at[0] = 0; at[1] = 0; at[2] = 0;
+}
+
+/**
+ * Apply the accumulated force / torque to velocity over a step `dt`, then
+ * zero the accumulators. Gravity and damping are NOT applied here.
+ *
+ * The "once per outer step" half of the TGS integrator: a user force is a
+ * per-frame budget that must land in full exactly once, independent of
+ * substep count. Gravity is the continuous field re-applied every substep
+ * by {@link integrate_velocity_gravity}.
+ *
+ * @param {RigidBody} rb
+ * @param {Transform} transform  used to rotate body-frame inertia into world
+ * @param {number} dt full outer-step size in seconds
+ */
+export function integrate_velocity_forces(rb, transform, dt) {
+    const af = rb.accumulatedForce;
+    const at = rb.accumulatedTorque;
+
+    if (rb.kind !== BodyKind.Dynamic) {
+
+        af[0] = 0;
+        af[1] = 0;
+        af[2] = 0;
+
+        at[0] = 0;
+        at[1] = 0;
+        at[2] = 0;
+
+        return;
+    }
+
+    const inv_m = rb.mass > 0 ? 1 / rb.mass : 0;
+
+    const lv = rb.linearVelocity;
+    lv[0] += af[0] * inv_m * dt;
+    lv[1] += af[1] * inv_m * dt;
+    lv[2] += af[2] * inv_m * dt;
+
+    if (at[0] !== 0 || at[1] !== 0 || at[2] !== 0) {
+
+        world_inverse_inertia_apply(
+            scratch_angular, 0,
+            rb.inverseInertiaLocal, transform.rotation,
+            at[0],
+            at[1],
+            at[2]
+        );
+
+        const av = rb.angularVelocity;
+
+        av[0] += scratch_angular[0] * dt;
+        av[1] += scratch_angular[1] * dt;
+        av[2] += scratch_angular[2] * dt;
+    }
+
+    af[0] = 0;
+    af[1] = 0;
+    af[2] = 0;
+
+    at[0] = 0;
+    at[1] = 0;
+    at[2] = 0;
+}
+
+/**
+ * Apply gravity and velocity damping over a (sub)step `dt`. Does NOT touch
+ * the force / torque accumulators (consumed once by
+ * {@link integrate_velocity_forces}).
+ *
+ * The "every substep" half of the TGS integrator. Per substep the body sees
+ * only `g·h` of gravity, which the per-substep contact warm-start + solve
+ * cancels exactly — keeping a resting stack at zero velocity. Damping is the
+ * stable implicit decay `v *= 1/(1 + d·dt)` applied at the substep `dt`.
+ *
+ * Velocity (and the damping it applies) lives in the data-oriented
+ * {@link SolverBodyState} for the duration of the substep loop; this reads and
+ * writes that span by `base`. The body's configuration (kind / gravityScale /
+ * damping coefficients) is still read from the `RigidBody` — cheap, once per
+ * body per substep, and unchanged across the step.
+ *
+ * @param {Float64Array} ss solver-body-state data array
+ * @param {number} base `body_index * SBS_STRIDE`
+ * @param {RigidBody} rb
+ * @param {number} gx
+ * @param {number} gy
+ * @param {number} gz world gravity
+ * @param {number} dt sub-step size in seconds
+ */
+export function integrate_velocity_gravity(ss, base, rb, gx, gy, gz, dt) {
+    if (rb.kind !== BodyKind.Dynamic) {
+        return;
+    }
+
+    const gs = rb.gravityScale;
+
+    let lvx = ss[base + SBS_LV_X] + gx * gs * dt;
+    let lvy = ss[base + SBS_LV_Y] + gy * gs * dt;
+    let lvz = ss[base + SBS_LV_Z] + gz * gs * dt;
+
+    if (rb.linearDamping > 0) {
+        const k = 1 / (1 + rb.linearDamping * dt);
+
+        lvx *= k;
+        lvy *= k;
+        lvz *= k;
+    }
+
+    ss[base + SBS_LV_X] = lvx;
+    ss[base + SBS_LV_Y] = lvy;
+    ss[base + SBS_LV_Z] = lvz;
+
+    if (rb.angularDamping > 0) {
+
+        const k = 1 / (1 + rb.angularDamping * dt);
+
+        ss[base + SBS_AV_X] *= k;
+        ss[base + SBS_AV_Y] *= k;
+        ss[base + SBS_AV_Z] *= k;
+
+    }
+}

package/src/engine/physics/narrowphase/box_box_manifold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"box_box_manifold.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/box_box_manifold.js"],"names":[],"mappings":"AAqJA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCAvBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CA8anB;AA3hBD;;;GAGG;AACH,iCAFU,MAAM,CAEoD"}
+{"version":3,"file":"box_box_manifold.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/box_box_manifold.js"],"names":[],"mappings":"AAgHA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCAvBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CAghBnB;AArlBD;;;GAGG;AACH,iCAFU,MAAM,CAEoD"}