@series-inc/rundot-syncplay 5.28.0-beta.2 → 5.28.0-beta.3

package/dist/physics3d-joints.d.ts

@@ -101,6 +101,11 @@ export type DeterministicPhysicsJoint3D = {
     readonly targetZ: number;
     readonly maxForce: number;
     readonly damping?: number;
+    readonly targetRotation?: Quat3D;
+    readonly maxTorque?: number;
+    readonly angularDamping?: number;
+    readonly breakDistance?: number;
+    readonly breakImpulse?: number;
 };
 /** Build solver joint objects from joint definitions, seeded from the joint cache. */
 export declare function createSolverJoints(joints: readonly DeterministicPhysicsJoint3D[], indexById: Map<string, number>, jointCache: readonly SolverJointCacheEntry[]): SolverJointSolve[];

package/dist/physics3d-joints.js

@@ -639,12 +639,33 @@ function grabJoint(joint, bodyIndex, warm) {
     let desiredVel = { x: 0, y: 0, z: 0 };
     const target = { x: joint.targetX, y: joint.targetY, z: joint.targetZ };
     const maxImpulse = joint.maxForce * 1;
+    const targetRotation = joint.targetRotation !== undefined ? normalizeQuat(joint.targetRotation) : undefined;
+    const maxTorque = joint.maxTorque ?? 0;
+    const angularDamping = joint.angularDamping ?? joint.damping ?? 1;
+    let desiredAngVel = { x: 0, y: 0, z: 0 };
+    let angMassMat;
+    let angMassDiag;
+    let broken = false;
+    let torqueImpulse = { x: 0, y: 0, z: 0 };
     return {
         bodyIndices: [bodyIndex],
         prepare(ctx) {
+            if (broken) {
+                return;
+            }
+            torqueImpulse = { x: 0, y: 0, z: 0 };
             const body = ctx.bodies[bodyIndex];
             r = jointLever(body, joint.anchor);
             const worldAnchor = addVec3(body.c, r);
+            if (joint.breakDistance !== undefined) {
+                const delta = subVec3(target, worldAnchor);
+                const d = solverSqrt(dotVec3(delta, delta));
+                if (d > joint.breakDistance) {
+                    broken = true;
+                    state.impulse = { x: 0, y: 0, z: 0 };
+                    return;
+                }
+            }
             const imB = ctx.invMass[bodyIndex];
             const linear = mat3FromDiag(imB);
             const skewR = skewMat3(r);
@@ -653,8 +674,36 @@ function grabJoint(joint, bodyIndex, warm) {
             const damping = joint.damping ?? 1;
             desiredVel = scaleVec3(subVec3(target, worldAnchor), damping / ctx.dt);
             ctx.applyToBody(bodyIndex, r, state.impulse);
+            if (targetRotation !== undefined) {
+                const errorRotation = quatMultiply(quatConjugate(targetRotation), body.q);
+                const sign = errorRotation.w < 0 ? -1 : 1;
+                const error = {
+                    x: 2 * sign * errorRotation.x,
+                    y: 2 * sign * errorRotation.y,
+                    z: 2 * sign * errorRotation.z,
+                };
+                desiredAngVel = scaleVec3(error, -angularDamping / ctx.dt);
+                const invI = ctx.invInertia[bodyIndex];
+                const fullInv = invertMat3(invI);
+                const isSingular = fullInv[0] === 0 && fullInv[4] === 0 && fullInv[8] === 0;
+                if (!isSingular) {
+                    angMassMat = fullInv;
+                    angMassDiag = undefined;
+                }
+                else {
+                    angMassMat = undefined;
+                    angMassDiag = {
+                        x: invI[0] > 1e-9 ? 1 / invI[0] : 0,
+                        y: invI[4] > 1e-9 ? 1 / invI[4] : 0,
+                        z: invI[8] > 1e-9 ? 1 / invI[8] : 0,
+                    };
+                }
+            }
         },
         iterate(ctx) {
+            if (broken) {
+                return;
+            }
             const body = ctx.bodies[bodyIndex];
             const currentVel = addVec3(body.v, crossVec3(body.w, r));
             const dImpulse = mulMat3Vec(kInv, subVec3(desiredVel, currentVel));
@@ -663,9 +712,36 @@ function grabJoint(joint, bodyIndex, warm) {
             const applied = subVec3(clamped, state.impulse);
             state.impulse = clamped;
             ctx.applyToBody(bodyIndex, r, applied);
+            if (targetRotation !== undefined && maxTorque > 0) {
+                const deltaW = subVec3(desiredAngVel, body.w);
+                const dTorque = angMassMat !== undefined
+                    ? mulMat3Vec(angMassMat, deltaW)
+                    : { x: deltaW.x * angMassDiag.x, y: deltaW.y * angMassDiag.y, z: deltaW.z * angMassDiag.z };
+                const targetTorque = addVec3(torqueImpulse, dTorque);
+                const clampedTorque = clampMagnitude(targetTorque, maxTorque * ctx.dt);
+                const appliedTorque = subVec3(clampedTorque, torqueImpulse);
+                torqueImpulse = clampedTorque;
+                ctx.applyAngularToBody(bodyIndex, appliedTorque);
+            }
+        },
+        postSubstep(_ctx) {
+            if (!broken) {
+                state.stepImpulse = addVec3(state.stepImpulse, state.impulse);
+            }
+            torqueImpulse = { x: 0, y: 0, z: 0 };
         },
         emitCache() {
-            return { jointId: joint.id, impulseX: state.impulse.x, impulseY: state.impulse.y, impulseZ: state.impulse.z, axialImpulse: 0, hingeAngle: 0 };
+            const reaction2 = dotVec3(state.stepImpulse, state.stepImpulse);
+            const isBroken = broken || (joint.breakImpulse !== undefined && reaction2 > joint.breakImpulse * joint.breakImpulse);
+            return {
+                jointId: joint.id,
+                impulseX: isBroken ? 0 : state.impulse.x,
+                impulseY: isBroken ? 0 : state.impulse.y,
+                impulseZ: isBroken ? 0 : state.impulse.z,
+                axialImpulse: 0,
+                hingeAngle: 0,
+                ...(isBroken ? { broken: true } : {}),
+            };
         },
     };
 }
@@ -687,6 +763,33 @@ function validateJoint(joint) {
         if (!Number.isFinite(joint.targetX) || !Number.isFinite(joint.targetY) || !Number.isFinite(joint.targetZ)) {
             throw new Error(`physics3d joint ${joint.id}: target must be finite`);
         }
+        if (joint.damping !== undefined && (!Number.isFinite(joint.damping) || joint.damping < 0)) {
+            throw new Error(`physics3d joint ${joint.id}: damping must be non-negative`);
+        }
+        if (joint.targetRotation !== undefined) {
+            const target = joint.targetRotation;
+            if (!Number.isFinite(target.x) || !Number.isFinite(target.y) || !Number.isFinite(target.z) || !Number.isFinite(target.w)
+                || target.x * target.x + target.y * target.y + target.z * target.z + target.w * target.w === 0) {
+                throw new Error(`physics3d joint ${joint.id}: targetRotation must be a finite non-zero quaternion`);
+            }
+            if (joint.maxTorque === undefined || !Number.isFinite(joint.maxTorque) || joint.maxTorque <= 0) {
+                throw new Error(`physics3d joint ${joint.id}: maxTorque must be a positive finite number`);
+            }
+        }
+        else if (joint.maxTorque !== undefined) {
+            if (!Number.isFinite(joint.maxTorque) || joint.maxTorque <= 0) {
+                throw new Error(`physics3d joint ${joint.id}: maxTorque must be a positive finite number`);
+            }
+        }
+        if (joint.angularDamping !== undefined && (!Number.isFinite(joint.angularDamping) || joint.angularDamping < 0)) {
+            throw new Error(`physics3d joint ${joint.id}: angularDamping must be non-negative`);
+        }
+        if (joint.breakDistance !== undefined && (!Number.isFinite(joint.breakDistance) || joint.breakDistance <= 0)) {
+            throw new Error(`physics3d joint ${joint.id}: breakDistance must be positive`);
+        }
+        if (joint.breakImpulse !== undefined && (!Number.isFinite(joint.breakImpulse) || joint.breakImpulse <= 0)) {
+            throw new Error(`physics3d joint ${joint.id}: breakImpulse must be positive`);
+        }
         return;
     }
     assertFiniteVec(joint.anchorA, 'anchorA', joint.id);

package/dist/physics3d-solver.d.ts

@@ -222,6 +222,8 @@ export interface SolverJointContext {
     apply(a: number, b: number, rA: Point3D, rB: Point3D, impulse: Point3D): void;
     /** Angular-only impulse (no linear component), e.g. hinge motor/limit rows. */
     applyAngular(a: number, b: number, angularImpulse: Point3D): void;
+    /** Apply an angular impulse to a single body (grab joint orientation drive). */
+    applyAngularToBody(index: number, angularImpulse: Point3D): void;
     /** Apply an impulse to a single body at anchor `r` (grab / world-target joints). */
     applyToBody(index: number, r: Point3D, impulse: Point3D): void;
     /** Split-impulse position correction on pseudo-velocities (no real momentum). */

package/dist/physics3d-solver.js

@@ -1685,6 +1685,13 @@ export function solveRigidStep(bodies, options) {
                 B.w = addVec3(B.w, mulMat3Vec(invInertia[b], angularImpulse));
             }
         },
+        applyAngularToBody: (index, angularImpulse) => {
+            const body = bodies[index];
+            if (!solid(body)) {
+                return;
+            }
+            body.w = addVec3(body.w, mulMat3Vec(invInertia[index], angularImpulse));
+        },
         applyToBody: (index, r, impulse) => {
             const body = bodies[index];
             if (!solid(body)) {

package/dist/runner.d.ts

@@ -85,7 +85,17 @@ export interface SyncplayRunnerOfflineOptions<Input> {
 }
 export interface SyncplayRunnerSnapshot<RenderState> {
     readonly status: SyncplayRunnerStatus;
+    /**
+     * Discrete tick render state. Note: to prevent 30Hz display judder on
+     * high-refresh displays, prefer interpolatedRenderState or runner.getRenderState().
+     */
     readonly renderState?: Readonly<RenderState>;
+    /**
+     * Smooth presentation state interpolated between previous and current
+     * render states at the current `renderAlpha`. If no interpolator is
+     * configured or interpolation throws, falls back to `renderState`.
+     */
+    readonly interpolatedRenderState?: Readonly<RenderState>;
     readonly renderAlpha: number;
     readonly localSlot: number;
     readonly rollbackCount: number;

package/dist/runner.js

@@ -68,9 +68,28 @@ export function createSyncplayRunner(config) {
         return localSession !== undefined ? localSession.currentFrame : 0;
     }
     function snapshot() {
+        let interpolatedRender;
+        if (currentRender !== undefined) {
+            if (previousRender !== undefined && config.presentation.interpolate !== undefined) {
+                try {
+                    interpolatedRender = config.presentation.interpolate(previousRender, currentRender, renderAlpha);
+                }
+                catch {
+                    interpolatedRender = currentRender;
+                }
+            }
+            else {
+                interpolatedRender = currentRender;
+            }
+        }
         return Object.freeze({
             status,
-            ...(currentRender === undefined ? {} : { renderState: currentRender }),
+            ...(currentRender === undefined
+                ? {}
+                : {
+                    renderState: currentRender,
+                    interpolatedRenderState: interpolatedRender,
+                }),
             renderAlpha,
             localSlot,
             rollbackCount: networkClient?.rollbacks ?? 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@series-inc/rundot-syncplay",
-  "version": "5.28.0-beta.2",
+  "version": "5.28.0-beta.3",
   "description": "Kinetix orchestration, rollback, replay, late-join, and deterministic networking for RUN.game",
   "repository": {
     "type": "git",