@series-inc/rundot-syncplay 5.23.0-beta.8 → 5.23.0

package/dist/cjs/physics3d-shared.js

@@ -0,0 +1,288 @@
+"use strict";
+/**
+ * Leaf numeric kernel + vector/quaternion/matrix helpers for the deterministic
+ * rigid-body solver. This module imports nothing package-local so `physics3d`,
+ * `physics3d-solver`, and `physics3d-joints` can all depend on it in one
+ * direction with no ESM cycle.
+ *
+ * Determinism regime: plain IEEE doubles restricted to `+ - * /` plus integer
+ * rounding/abs/min/max/trunc (no transcendental library calls — the static
+ * checker bans the square-root/power/trig family). Square roots go through
+ * `deterministicSqrt` (quantized, for persisted distances) or `solverSqrt`
+ * (unquantized Newton, for solver-internal math — state is quantized only at the
+ * frame edge, never mid-solve).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quantizeDistance = quantizeDistance;
+exports.quantizeAngle = quantizeAngle;
+exports.deterministicSqrt = deterministicSqrt;
+exports.solverSqrt = solverSqrt;
+exports.vec3 = vec3;
+exports.addVec3 = addVec3;
+exports.subVec3 = subVec3;
+exports.scaleVec3 = scaleVec3;
+exports.dotVec3 = dotVec3;
+exports.crossVec3 = crossVec3;
+exports.lengthVec3 = lengthVec3;
+exports.normalizeVec3 = normalizeVec3;
+exports.quatToMat3 = quatToMat3;
+exports.mulMat3Vec = mulMat3Vec;
+exports.mulMat3TransposeVec = mulMat3TransposeVec;
+exports.worldInvInertia = worldInvInertia;
+exports.integrateQuat = integrateQuat;
+exports.normalizeQuat = normalizeQuat;
+exports.quatConjugate = quatConjugate;
+exports.quatMultiply = quatMultiply;
+exports.quaternionFromQuarterTurns = quaternionFromQuarterTurns;
+exports.rotatePointByQuat = rotatePointByQuat;
+exports.rotatePointByQuatInverse = rotatePointByQuatInverse;
+exports.clampNumber = clampNumber;
+exports.skewMat3 = skewMat3;
+exports.mat3Multiply = mat3Multiply;
+exports.mat3Sub = mat3Sub;
+exports.mat3FromDiag = mat3FromDiag;
+exports.invertMat3 = invertMat3;
+function quantizeDistance(distance) {
+    // Pure integer rounding, not fixed-point string rounding — see physics2d
+    // quantizeDistance (cross-engine half-way divergence on checksummed state).
+    const quantized = Math.round(distance * 1e6) / 1e6;
+    return quantized === 0 ? 0 : quantized;
+}
+function quantizeAngle(value) {
+    const wrapped = value - Math.floor(value);
+    const quantizedAngle = Math.round(wrapped * 1e6) / 1e6;
+    return quantizedAngle === 0 ? 0 : quantizedAngle;
+}
+function deterministicSqrt(value) {
+    if (value <= 0) {
+        return 0;
+    }
+    let estimate = 1;
+    let magnitude = value;
+    while (magnitude >= 4) {
+        magnitude /= 4;
+        estimate *= 2;
+    }
+    if (magnitude > 1) {
+        estimate *= 2;
+    }
+    for (let iteration = 0; iteration < 8; iteration += 1) {
+        estimate = (estimate + value / estimate) / 2;
+    }
+    return quantizeDistance(estimate);
+}
+/**
+ * Unquantized Newton square root for solver-internal math. Bit-for-bit identical
+ * to the seed/iteration schedule the validated spike used; every operation is
+ * exactly specified IEEE-754 arithmetic, so all certified V8 peers agree. State
+ * that reaches the canonical world is quantized separately at the frame edge.
+ */
+function solverSqrt(value) {
+    if (value <= 0) {
+        return 0;
+    }
+    let estimate = 1;
+    let magnitude = value;
+    while (magnitude >= 4) {
+        magnitude /= 4;
+        estimate *= 2;
+    }
+    if (magnitude > 1) {
+        estimate *= 2;
+    }
+    for (let iteration = 0; iteration < 8; iteration += 1) {
+        estimate = (estimate + value / estimate) / 2;
+    }
+    return estimate;
+}
+function vec3(x, y, z) {
+    return { x, y, z };
+}
+function addVec3(a, b) {
+    return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+}
+function subVec3(a, b) {
+    return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+}
+function scaleVec3(a, s) {
+    return { x: a.x * s, y: a.y * s, z: a.z * s };
+}
+function dotVec3(a, b) {
+    return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function crossVec3(a, b) {
+    return {
+        x: a.y * b.z - a.z * b.y,
+        y: a.z * b.x - a.x * b.z,
+        z: a.x * b.y - a.y * b.x,
+    };
+}
+function lengthVec3(a) {
+    return solverSqrt(dotVec3(a, a));
+}
+function normalizeVec3(a) {
+    const length = lengthVec3(a);
+    return length === 0 ? { x: 0, y: 0, z: 0 } : scaleVec3(a, 1 / length);
+}
+function quatToMat3(q) {
+    const { x, y, z, w } = q;
+    return [
+        1 - 2 * (y * y + z * z), 2 * (x * y - w * z), 2 * (x * z + w * y),
+        2 * (x * y + w * z), 1 - 2 * (x * x + z * z), 2 * (y * z - w * x),
+        2 * (x * z - w * y), 2 * (y * z + w * x), 1 - 2 * (x * x + y * y),
+    ];
+}
+function mulMat3Vec(m, a) {
+    return {
+        x: m[0] * a.x + m[1] * a.y + m[2] * a.z,
+        y: m[3] * a.x + m[4] * a.y + m[5] * a.z,
+        z: m[6] * a.x + m[7] * a.y + m[8] * a.z,
+    };
+}
+function mulMat3TransposeVec(m, a) {
+    return {
+        x: m[0] * a.x + m[3] * a.y + m[6] * a.z,
+        y: m[1] * a.x + m[4] * a.y + m[7] * a.z,
+        z: m[2] * a.x + m[5] * a.y + m[8] * a.z,
+    };
+}
+/** World-space inverse inertia = R · diag(invI) · Rᵀ. */
+function worldInvInertia(rot, invI) {
+    const invIArr = [invI.x, invI.y, invI.z];
+    const out = new Array(9).fill(0);
+    for (let row = 0; row < 3; row += 1) {
+        for (let col = 0; col < 3; col += 1) {
+            out[row * 3 + col] =
+                rot[row * 3 + 0] * invIArr[0] * rot[col * 3 + 0] +
+                    rot[row * 3 + 1] * invIArr[1] * rot[col * 3 + 1] +
+                    rot[row * 3 + 2] * invIArr[2] * rot[col * 3 + 2];
+        }
+    }
+    return out;
+}
+/**
+ * Trig-free quaternion integration: q += ½·(ω⊗q)·dt, renormalized with
+ * `solverSqrt`. Returns a unit quaternion; degenerate inputs collapse to
+ * identity so no NaN reaches state.
+ */
+function integrateQuat(q, w, dt) {
+    const hx = w.x * 0.5 * dt;
+    const hy = w.y * 0.5 * dt;
+    const hz = w.z * 0.5 * dt;
+    const nx = q.x + (hx * q.w + hy * q.z - hz * q.y);
+    const ny = q.y + (hy * q.w + hz * q.x - hx * q.z);
+    const nz = q.z + (hz * q.w + hx * q.y - hy * q.x);
+    const nw = q.w + (-hx * q.x - hy * q.y - hz * q.z);
+    const length = solverSqrt(nx * nx + ny * ny + nz * nz + nw * nw);
+    if (length === 0) {
+        return { x: 0, y: 0, z: 0, w: 1 };
+    }
+    return { x: nx / length, y: ny / length, z: nz / length, w: nw / length };
+}
+function normalizeQuat(q) {
+    const length = solverSqrt(q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w);
+    if (length === 0) {
+        return { x: 0, y: 0, z: 0, w: 1 };
+    }
+    return { x: q.x / length, y: q.y / length, z: q.z / length, w: q.w / length };
+}
+function quatConjugate(q) {
+    return { x: -q.x, y: -q.y, z: -q.z, w: q.w };
+}
+function quatMultiply(a, b) {
+    return {
+        w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z,
+        x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
+        y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
+        z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
+    };
+}
+const QUARTER_ROOT_HALF = solverSqrt(0.5);
+function axisQuarterTurnQuat(axis, turns) {
+    const c = ((Math.trunc(turns) % 4) + 4) % 4;
+    // half-angle is turns·45°; sin/cos of {0,45,90,135}° are exactly {0/1, ±√½}.
+    const table = [
+        { s: 0, w: 1 },
+        { s: QUARTER_ROOT_HALF, w: QUARTER_ROOT_HALF },
+        { s: 1, w: 0 },
+        { s: QUARTER_ROOT_HALF, w: -QUARTER_ROOT_HALF },
+    ];
+    const entry = table[c];
+    return {
+        x: axis === 0 ? entry.s : 0,
+        y: axis === 1 ? entry.s : 0,
+        z: axis === 2 ? entry.s : 0,
+        w: entry.w,
+    };
+}
+/** Compose integer quarter-turn rotations about x, then y, then z into a quaternion. */
+function quaternionFromQuarterTurns(turns) {
+    const qx = axisQuarterTurnQuat(0, turns.x);
+    const qy = axisQuarterTurnQuat(1, turns.y);
+    const qz = axisQuarterTurnQuat(2, turns.z);
+    return quatMultiply(quatMultiply(qx, qy), qz);
+}
+/** Rotate a vector by a quaternion using only mul/add/cross (no transcendentals). */
+function rotatePointByQuat(q, p) {
+    const u = { x: q.x, y: q.y, z: q.z };
+    const t = scaleVec3(crossVec3(u, p), 2);
+    return addVec3(addVec3(p, scaleVec3(t, q.w)), crossVec3(u, t));
+}
+/** Rotate a vector by the inverse (conjugate) of a quaternion. */
+function rotatePointByQuatInverse(q, p) {
+    return rotatePointByQuat(quatConjugate(q), p);
+}
+function clampNumber(value, lo, hi) {
+    return value < lo ? lo : value > hi ? hi : value;
+}
+/** Skew-symmetric (cross-product) matrix of a vector. */
+function skewMat3(v) {
+    return [
+        0, -v.z, v.y,
+        v.z, 0, -v.x,
+        -v.y, v.x, 0,
+    ];
+}
+function mat3Multiply(a, b) {
+    const out = new Array(9).fill(0);
+    for (let row = 0; row < 3; row += 1) {
+        for (let col = 0; col < 3; col += 1) {
+            out[row * 3 + col] =
+                a[row * 3 + 0] * b[0 * 3 + col] +
+                    a[row * 3 + 1] * b[1 * 3 + col] +
+                    a[row * 3 + 2] * b[2 * 3 + col];
+        }
+    }
+    return out;
+}
+function mat3Sub(a, b) {
+    return a.map((value, index) => value - b[index]);
+}
+function mat3FromDiag(d) {
+    return [d.x, 0, 0, 0, d.y, 0, 0, 0, d.z];
+}
+/** Invert a 3x3 matrix; returns a zero matrix if singular (deterministic fallback). */
+function invertMat3(m) {
+    const a = m[0];
+    const b = m[1];
+    const c = m[2];
+    const d = m[3];
+    const e = m[4];
+    const f = m[5];
+    const g = m[6];
+    const h = m[7];
+    const i = m[8];
+    const co0 = e * i - f * h;
+    const co1 = f * g - d * i;
+    const co2 = d * h - e * g;
+    const det = a * co0 + b * co1 + c * co2;
+    if (det === 0) {
+        return [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    }
+    const inv = 1 / det;
+    return [
+        co0 * inv, (c * h - b * i) * inv, (b * f - c * e) * inv,
+        co1 * inv, (a * i - c * g) * inv, (c * d - a * f) * inv,
+        co2 * inv, (b * g - a * h) * inv, (a * e - b * d) * inv,
+    ];
+}