dacha 0.18.0-alpha.8 → 0.18.0

package/build/contrib/systems/physics-system/subsystems/constraint-solver/impulse-utils.js

@@ -0,0 +1,77 @@
+export const getContactRestitution = (rigidBody1, rigidBody2) => {
+    return Math.max(rigidBody1.restitution, rigidBody2.restitution);
+};
+export const getContactFriction = (rigidBody1, rigidBody2) => {
+    return Math.sqrt(rigidBody1.friction * rigidBody2.friction);
+};
+/**
+ * Returns the effective mass at a contact point along a unit direction.
+ * It represents how strongly the two bodies resist an impulse applied at
+ * that point in that direction.
+ */
+export const getEffectiveMass = (invMassA, invInertiaA, anchorAX, anchorAY, invMassB, invInertiaB, anchorBX, anchorBY, directionX, directionY) => {
+    const crossA = anchorAX * directionY - anchorAY * directionX;
+    const crossB = anchorBX * directionY - anchorBY * directionX;
+    return (invMassA +
+        invMassB +
+        crossA * crossA * invInertiaA +
+        crossB * crossB * invInertiaB);
+};
+/**
+ * Relative velocity of body B against body A at a contact point, projected onto
+ * a direction, using the supplied velocity fields (live, previous, or bias).
+ */
+const getRelativeVelocityAtPoint = (linearVelocityA, angularVelocityA, linearVelocityB, angularVelocityB, point, directionX, directionY) => {
+    const velocityAX = linearVelocityA.x - angularVelocityA * point.anchorAY;
+    const velocityAY = linearVelocityA.y + angularVelocityA * point.anchorAX;
+    const velocityBX = linearVelocityB.x - angularVelocityB * point.anchorBY;
+    const velocityBY = linearVelocityB.y + angularVelocityB * point.anchorBX;
+    return ((velocityBX - velocityAX) * directionX +
+        (velocityBY - velocityAY) * directionY);
+};
+export const getNormalVelocity = (state, point) => getRelativeVelocityAtPoint(state.bodyA.linearVelocity, state.bodyA.angularVelocity, state.bodyB.linearVelocity, state.bodyB.angularVelocity, point, state.normalX, state.normalY);
+export const getTangentVelocity = (state, point) => getRelativeVelocityAtPoint(state.bodyA.linearVelocity, state.bodyA.angularVelocity, state.bodyB.linearVelocity, state.bodyB.angularVelocity, point, state.tangentX, state.tangentY);
+export const getPrevNormalVelocity = (state, point) => getRelativeVelocityAtPoint(state.bodyA._prevLinearVelocity, state.bodyA._prevAngularVelocity, state.bodyB._prevLinearVelocity, state.bodyB._prevAngularVelocity, point, state.normalX, state.normalY);
+export const getBiasNormalVelocity = (state, point) => getRelativeVelocityAtPoint(state.bodyA._biasLinearVelocity, state.bodyA._biasAngularVelocity, state.bodyB._biasLinearVelocity, state.bodyB._biasAngularVelocity, point, state.normalX, state.normalY);
+export const applyImpulse = (state, point, impulseX, impulseY) => {
+    const { bodyA, bodyB } = state;
+    if (state.invMassA > 0) {
+        bodyA.linearVelocity.x -= impulseX * state.invMassA;
+        bodyA.linearVelocity.y -= impulseY * state.invMassA;
+    }
+    if (state.invInertiaA > 0) {
+        bodyA.angularVelocity -=
+            (point.anchorAX * impulseY - point.anchorAY * impulseX) *
+                state.invInertiaA;
+    }
+    if (state.invMassB > 0) {
+        bodyB.linearVelocity.x += impulseX * state.invMassB;
+        bodyB.linearVelocity.y += impulseY * state.invMassB;
+    }
+    if (state.invInertiaB > 0) {
+        bodyB.angularVelocity +=
+            (point.anchorBX * impulseY - point.anchorBY * impulseX) *
+                state.invInertiaB;
+    }
+};
+export const applyBiasImpulse = (state, point, impulseX, impulseY) => {
+    const { bodyA, bodyB } = state;
+    if (state.invMassA > 0) {
+        bodyA._biasLinearVelocity.x -= impulseX * state.invMassA;
+        bodyA._biasLinearVelocity.y -= impulseY * state.invMassA;
+    }
+    if (state.invInertiaA > 0) {
+        bodyA._biasAngularVelocity -=
+            (point.anchorAX * impulseY - point.anchorAY * impulseX) *
+                state.invInertiaA;
+    }
+    if (state.invMassB > 0) {
+        bodyB._biasLinearVelocity.x += impulseX * state.invMassB;
+        bodyB._biasLinearVelocity.y += impulseY * state.invMassB;
+    }
+    if (state.invInertiaB > 0) {
+        bodyB._biasAngularVelocity +=
+            (point.anchorBX * impulseY - point.anchorBY * impulseX) *
+                state.invInertiaB;
+    }
+};

package/build/contrib/systems/physics-system/subsystems/constraint-solver/index.d.ts

@@ -1,13 +1,62 @@
+import type { Time } from '../../../../../engine/time';
+import { type Vector2 } from '../../../../../engine/math-lib';
 import type { Contact } from '../collision-detection/types';
+interface ConstraintSolverOptions {
+    time: Time;
+    getGravity: () => Vector2;
+    solverIterations?: number;
+    maxAllowedPenetration?: number;
+    maxBiasVelocity?: number;
+    linearSleepThreshold?: number;
+}
 export declare class ConstraintSolver {
-    private validContacts;
     private oneWayValidator;
-    constructor();
+    private contactStateManager;
+    private sleepSupportTracker;
+    private time;
+    private getGravity;
+    private restitutionThreshold;
+    private solverIterations;
+    private maxAllowedPenetration;
+    private maxBiasVelocity;
+    private linearSleepThreshold;
+    private penetrationSleepThreshold;
+    private flippedNormal;
+    private blockImpulse0;
+    private blockImpulse1;
+    constructor(options: ConstraintSolverOptions);
     private validateCollision;
     private validateOneWayContact;
-    private getInverseMass;
+    private validateSleepContact;
+    private getPoint;
+    private prepareContact;
+    private prepareBlockSolver;
+    private prepareDecisions;
+    private applyWarmStartImpulse;
     private applyNormalImpulse;
+    private applyPointNormalImpulse;
+    private applyBlockNormalImpulse;
+    /**
+     * Solves the normal impulses for both contact points of a two-point
+     * manifold together, instead of one at a time.
+     *
+     * A contact point can only push, never pull (its impulse
+     * must stay >= 0), and a point that's already pulling apart on its own
+     * shouldn't be pushed at all. Which point(s) actually need pushing this
+     * step isn't known upfront, so this tries the possibilities from most to
+     * least likely and uses the first one that comes out consistent:
+     *  1. Both points push — solve the 2x2 system directly; only valid if both
+     *     resulting impulses are non-negative.
+     *  2. Only point0 pushes, point1 is left alone — only valid if point1
+     *     isn't still closing in without help (that would mean it needed a
+     *     push too, contradicting the assumption).
+     *  3. Only point1 pushes, point0 is left alone — mirror of case 2.
+     *  4. Neither pushes — only valid if both points are already separating
+     *     on their own.
+     */
+    private solveBlockNormalImpulse;
     private applyFrictionImpulse;
-    private applyPositionCorrection;
+    private applyBiasImpulse;
     update(contacts: Contact[]): void;
 }
+export {};

package/build/contrib/systems/physics-system/subsystems/constraint-solver/index.js

@@ -1,16 +1,57 @@
+import { MathOps, } from '../../../../../engine/math-lib';
 import { RigidBody } from '../../../../components/rigid-body';
 import { Transform } from '../../../../components/transform';
-import { OneWayValidator } from '../../../../utils/one-way-validator';
-const SOLVER_ITERATIONS = 8;
-const POSITION_CORRECTION_PERCENT = 0.8;
-const PENETRATION_SLOP = 0.01;
-const DEFAULT_CONTACT_FRICTION = 0.6;
+import { DEFAULT_SOLVER_ITERATIONS, DEFAULT_CONTACT_MAX_ALLOWED_PENETRATION, CONTACT_BIAS, DEFAULT_MAX_BIAS_VELOCITY, RESTITUTION_VELOCITY_THRESHOLD, DEFAULT_LINEAR_SLEEP_THRESHOLD, PENETRATION_SLEEP_MARGIN, } from '../../consts';
+import { ContactStateManager, } from './contact-state-manager';
+import { OneWayValidator } from './one-way-validator';
+import { getContactFriction, getContactRestitution, getEffectiveMass, getNormalVelocity, getTangentVelocity, getPrevNormalVelocity, getBiasNormalVelocity, applyImpulse, applyBiasImpulse, } from './impulse-utils';
+import { shouldWakeSleepingContact } from './contact-utils';
+import { SleepSupportTracker } from './sleep-support-tracker';
+const BLOCK_SOLVER_MIN_DETERMINANT = 1e-8;
+const BLOCK_SOLVER_TOLERANCE = 1e-8;
+/**
+ * A resting body gains g * dt of downward velocity from gravity before the
+ * solver runs. The restitution threshold must be higher than this velocity,
+ * otherwise resting contacts may be treated as impacts and keep bouncing.
+ *
+ * This factor keeps the threshold safely above one frame of gravity while
+ * never allowing it to fall below the base threshold.
+ */
+const RESTITUTION_GRAVITY_THRESHOLD_FACTOR = 2;
 export class ConstraintSolver {
-    validContacts;
     oneWayValidator;
-    constructor() {
-        this.validContacts = [];
+    contactStateManager;
+    sleepSupportTracker;
+    time;
+    getGravity;
+    restitutionThreshold;
+    solverIterations;
+    maxAllowedPenetration;
+    maxBiasVelocity;
+    linearSleepThreshold;
+    penetrationSleepThreshold;
+    flippedNormal;
+    blockImpulse0;
+    blockImpulse1;
+    constructor(options) {
         this.oneWayValidator = new OneWayValidator();
+        this.contactStateManager = new ContactStateManager();
+        this.sleepSupportTracker = new SleepSupportTracker(options.getGravity);
+        this.time = options.time;
+        this.getGravity = options.getGravity;
+        this.restitutionThreshold = RESTITUTION_VELOCITY_THRESHOLD;
+        this.solverIterations =
+            options.solverIterations ?? DEFAULT_SOLVER_ITERATIONS;
+        this.maxAllowedPenetration =
+            options.maxAllowedPenetration ?? DEFAULT_CONTACT_MAX_ALLOWED_PENETRATION;
+        this.maxBiasVelocity = options.maxBiasVelocity ?? DEFAULT_MAX_BIAS_VELOCITY;
+        this.linearSleepThreshold =
+            options.linearSleepThreshold ?? DEFAULT_LINEAR_SLEEP_THRESHOLD;
+        this.penetrationSleepThreshold =
+            this.maxAllowedPenetration + PENETRATION_SLEEP_MARGIN;
+        this.flippedNormal = { x: 0, y: 0 };
+        this.blockImpulse0 = 0;
+        this.blockImpulse1 = 0;
     }
     validateCollision(actor1, actor2) {
         const rigidBody1 = actor1.getComponent(RigidBody);
@@ -30,124 +71,292 @@ export class ConstraintSolver {
         const rigidBody1 = contact.actor1.getComponent(RigidBody);
         const rigidBody2 = contact.actor2.getComponent(RigidBody);
         if (rigidBody1.oneWay &&
-            !this.oneWayValidator.validate(contact.actor1, contact.actor2, contact.normal)) {
+            rigidBody2.type === 'dynamic' &&
+            !this.oneWayValidator.shouldBlock(contact.actor1, contact.actor2, contact.normal)) {
             return false;
         }
-        if (!rigidBody2.oneWay) {
+        if (!rigidBody2.oneWay || rigidBody1.type !== 'dynamic') {
             return true;
         }
-        return this.oneWayValidator.validate(contact.actor2, contact.actor1, {
-            x: -contact.normal.x,
-            y: -contact.normal.y,
-        });
+        this.flippedNormal.x = -contact.normal.x;
+        this.flippedNormal.y = -contact.normal.y;
+        return this.oneWayValidator.shouldBlock(contact.actor2, contact.actor1, this.flippedNormal);
     }
-    getInverseMass(rigidBody) {
-        if (rigidBody.type === 'static' || rigidBody.type === 'kinematic') {
-            return 0;
+    validateSleepContact(contact) {
+        const rigidBody1 = contact.actor1.getComponent(RigidBody);
+        const rigidBody2 = contact.actor2.getComponent(RigidBody);
+        const isDeepContact = contact.penetration > this.penetrationSleepThreshold;
+        const isFastContact = shouldWakeSleepingContact(contact, this.linearSleepThreshold);
+        if (!isDeepContact && !isFastContact) {
+            this.sleepSupportTracker.trackContact(contact);
         }
-        return rigidBody.inverseMass;
+        if (rigidBody1.sleeping && rigidBody2.sleeping) {
+            return false;
+        }
+        if ((rigidBody1.sleeping || rigidBody2.sleeping) &&
+            (isDeepContact || isFastContact)) {
+            rigidBody1.wakeUp();
+            rigidBody2.wakeUp();
+        }
+        return true;
     }
-    applyNormalImpulse(contact) {
-        const { actor1, actor2, normal } = contact;
-        const rigidBody1 = actor1.getComponent(RigidBody);
-        const rigidBody2 = actor2.getComponent(RigidBody);
-        const inverseMass1 = this.getInverseMass(rigidBody1);
-        const inverseMass2 = this.getInverseMass(rigidBody2);
-        const inverseMassSum = inverseMass1 + inverseMass2;
-        if (inverseMassSum === 0) {
-            return 0;
-        }
-        const relativeVelocityX = rigidBody2.linearVelocity.x - rigidBody1.linearVelocity.x;
-        const relativeVelocityY = rigidBody2.linearVelocity.y - rigidBody1.linearVelocity.y;
-        const velocityAlongNormal = relativeVelocityX * normal.x + relativeVelocityY * normal.y;
-        if (velocityAlongNormal >= 0) {
-            return 0;
-        }
-        const impulseMagnitude = -velocityAlongNormal / inverseMassSum;
-        const impulseX = normal.x * impulseMagnitude;
-        const impulseY = normal.y * impulseMagnitude;
-        if (inverseMass1 > 0) {
-            rigidBody1.linearVelocity.x -= impulseX * inverseMass1;
-            rigidBody1.linearVelocity.y -= impulseY * inverseMass1;
-        }
-        if (inverseMass2 > 0) {
-            rigidBody2.linearVelocity.x += impulseX * inverseMass2;
-            rigidBody2.linearVelocity.y += impulseY * inverseMass2;
-        }
-        return impulseMagnitude;
-    }
-    applyFrictionImpulse(contact, normalImpulseMagnitude) {
-        if (normalImpulseMagnitude <= 0) {
+    getPoint(state, index) {
+        return index === 0 ? state.point0 : state.point1;
+    }
+    prepareContact(state) {
+        const { normal } = state.contact;
+        const bodyA = state.actor1.getComponent(RigidBody);
+        const bodyB = state.actor2.getComponent(RigidBody);
+        const transformA = state.actor1.getComponent(Transform);
+        const transformB = state.actor2.getComponent(Transform);
+        const invMassA = bodyA.inverseMass;
+        const invMassB = bodyB.inverseMass;
+        const invInertiaA = bodyA.inverseInertia;
+        const invInertiaB = bodyB.inverseInertia;
+        state.bodyA = bodyA;
+        state.bodyB = bodyB;
+        state.invMassA = invMassA;
+        state.invInertiaA = invInertiaA;
+        state.invMassB = invMassB;
+        state.invInertiaB = invInertiaB;
+        state.normalX = normal.x;
+        state.normalY = normal.y;
+        state.tangentX = -normal.y;
+        state.tangentY = normal.x;
+        state.friction = getContactFriction(bodyA, bodyB);
+        state.restitution = getContactRestitution(bodyA, bodyB);
+        state.active = invMassA + invMassB + invInertiaA + invInertiaB > 0;
+        if (!state.active) {
             return;
         }
-        const { normal } = contact;
-        const rigidBody1 = contact.actor1.getComponent(RigidBody);
-        const rigidBody2 = contact.actor2.getComponent(RigidBody);
-        const inverseMass1 = this.getInverseMass(rigidBody1);
-        const inverseMass2 = this.getInverseMass(rigidBody2);
-        const inverseMassSum = inverseMass1 + inverseMass2;
-        if (inverseMassSum === 0) {
+        const posAX = transformA.world.position.x;
+        const posAY = transformA.world.position.y;
+        const posBX = transformB.world.position.x;
+        const posBY = transformB.world.position.y;
+        let minPrevNormalVelocity = Infinity;
+        for (let index = 0; index < state.pointCount; index += 1) {
+            const point = this.getPoint(state, index);
+            point.anchorAX = point.positionX - posAX;
+            point.anchorAY = point.positionY - posAY;
+            point.anchorBX = point.positionX - posBX;
+            point.anchorBY = point.positionY - posBY;
+            point.normalMass = getEffectiveMass(invMassA, invInertiaA, point.anchorAX, point.anchorAY, invMassB, invInertiaB, point.anchorBX, point.anchorBY, state.normalX, state.normalY);
+            point.tangentMass = getEffectiveMass(invMassA, invInertiaA, point.anchorAX, point.anchorAY, invMassB, invInertiaB, point.anchorBX, point.anchorBY, state.tangentX, state.tangentY);
+            const prevNormalVelocity = getPrevNormalVelocity(state, point);
+            if (prevNormalVelocity < minPrevNormalVelocity) {
+                minPrevNormalVelocity = prevNormalVelocity;
+            }
+            if (state.restitution > 0 &&
+                -prevNormalVelocity > this.restitutionThreshold) {
+                point.velocityBias = -state.restitution * prevNormalVelocity;
+            }
+            else {
+                point.velocityBias = 0;
+            }
+        }
+        this.prepareBlockSolver(state);
+        this.prepareDecisions(state, minPrevNormalVelocity);
+    }
+    prepareBlockSolver(state) {
+        if (state.pointCount !== 2 ||
+            state.point0.normalMass === 0 ||
+            state.point1.normalMass === 0) {
+            state.blockSolvable = false;
             return;
         }
-        const relativeVelocityX = rigidBody2.linearVelocity.x - rigidBody1.linearVelocity.x;
-        const relativeVelocityY = rigidBody2.linearVelocity.y - rigidBody1.linearVelocity.y;
-        const velocityAlongNormal = relativeVelocityX * normal.x + relativeVelocityY * normal.y;
-        const tangentX = relativeVelocityX - normal.x * velocityAlongNormal;
-        const tangentY = relativeVelocityY - normal.y * velocityAlongNormal;
-        const tangentMagnitude = Math.sqrt(tangentX ** 2 + tangentY ** 2);
-        if (tangentMagnitude === 0) {
+        const { point0, point1 } = state;
+        const crossA0 = point0.anchorAX * state.normalY - point0.anchorAY * state.normalX;
+        const crossB0 = point0.anchorBX * state.normalY - point0.anchorBY * state.normalX;
+        const crossA1 = point1.anchorAX * state.normalY - point1.anchorAY * state.normalX;
+        const crossB1 = point1.anchorBX * state.normalY - point1.anchorBY * state.normalX;
+        state.k01 =
+            state.invMassA +
+                state.invMassB +
+                crossA0 * crossA1 * state.invInertiaA +
+                crossB0 * crossB1 * state.invInertiaB;
+        state.determinant =
+            point0.normalMass * point1.normalMass - state.k01 * state.k01;
+        state.blockSolvable =
+            Math.abs(state.determinant) >= BLOCK_SOLVER_MIN_DETERMINANT;
+    }
+    prepareDecisions(state, minPrevNormalVelocity) {
+        const hasRestitution = state.restitution > 0;
+        const isBouncing = hasRestitution && -minPrevNormalVelocity > this.restitutionThreshold;
+        const eitherSleeping = state.bodyA.sleeping || state.bodyB.sleeping;
+        state.warmStartAllowed =
+            (!hasRestitution || !isBouncing) && !eitherSleeping;
+        state.skipBias =
+            isBouncing && (state.invMassA === 0 || state.invMassB === 0);
+    }
+    applyWarmStartImpulse(state) {
+        if (!state.warmStartAllowed) {
+            this.contactStateManager.clearWarmStartImpulses(state);
             return;
         }
-        const normalizedTangentX = tangentX / tangentMagnitude;
-        const normalizedTangentY = tangentY / tangentMagnitude;
-        const velocityAlongTangent = relativeVelocityX * normalizedTangentX +
-            relativeVelocityY * normalizedTangentY;
-        const unclampedImpulseMagnitude = -velocityAlongTangent / inverseMassSum;
-        const maxFrictionImpulseMagnitude = DEFAULT_CONTACT_FRICTION * normalImpulseMagnitude;
-        const impulseMagnitude = Math.max(-maxFrictionImpulseMagnitude, Math.min(unclampedImpulseMagnitude, maxFrictionImpulseMagnitude));
-        const impulseX = normalizedTangentX * impulseMagnitude;
-        const impulseY = normalizedTangentY * impulseMagnitude;
-        if (inverseMass1 > 0) {
-            rigidBody1.linearVelocity.x -= impulseX * inverseMass1;
-            rigidBody1.linearVelocity.y -= impulseY * inverseMass1;
-        }
-        if (inverseMass2 > 0) {
-            rigidBody2.linearVelocity.x += impulseX * inverseMass2;
-            rigidBody2.linearVelocity.y += impulseY * inverseMass2;
-        }
-    }
-    applyPositionCorrection(contact) {
-        const { actor1, actor2, normal, penetration } = contact;
-        const rigidBody1 = actor1.getComponent(RigidBody);
-        const rigidBody2 = actor2.getComponent(RigidBody);
-        const inverseMass1 = this.getInverseMass(rigidBody1);
-        const inverseMass2 = this.getInverseMass(rigidBody2);
-        const inverseMassSum = inverseMass1 + inverseMass2;
-        if (inverseMassSum === 0) {
+        for (let index = 0; index < state.pointCount; index += 1) {
+            const point = this.getPoint(state, index);
+            if (point.normalImpulse === 0 && point.tangentImpulse === 0) {
+                continue;
+            }
+            applyImpulse(state, point, state.normalX * point.normalImpulse +
+                state.tangentX * point.tangentImpulse, state.normalY * point.normalImpulse +
+                state.tangentY * point.tangentImpulse);
+        }
+    }
+    applyNormalImpulse(state) {
+        if (state.blockSolvable) {
+            this.applyBlockNormalImpulse(state);
             return;
         }
-        const correctionMagnitude = (Math.max(penetration - PENETRATION_SLOP, 0) *
-            POSITION_CORRECTION_PERCENT) /
-            inverseMassSum;
-        if (correctionMagnitude === 0) {
+        for (let index = 0; index < state.pointCount; index += 1) {
+            this.applyPointNormalImpulse(state, index);
+        }
+    }
+    applyPointNormalImpulse(state, index) {
+        const point = this.getPoint(state, index);
+        if (point.normalMass === 0) {
             return;
         }
-        const correctionX = normal.x * correctionMagnitude;
-        const correctionY = normal.y * correctionMagnitude;
-        const transform1 = actor1.getComponent(Transform);
-        const transform2 = actor2.getComponent(Transform);
-        if (inverseMass1 > 0) {
-            transform1.world.position.x -= correctionX * inverseMass1;
-            transform1.world.position.y -= correctionY * inverseMass1;
+        const velocityAlongNormal = getNormalVelocity(state, point);
+        const oldImpulse = point.normalImpulse;
+        const newImpulse = Math.max(oldImpulse +
+            (point.velocityBias - velocityAlongNormal) / point.normalMass, 0);
+        point.normalImpulse = newImpulse;
+        const impulse = newImpulse - oldImpulse;
+        if (impulse === 0) {
+            return;
         }
-        if (inverseMass2 > 0) {
-            transform2.world.position.x += correctionX * inverseMass2;
-            transform2.world.position.y += correctionY * inverseMass2;
+        applyImpulse(state, point, state.normalX * impulse, state.normalY * impulse);
+    }
+    applyBlockNormalImpulse(state) {
+        const { point0, point1 } = state;
+        const mass00 = point0.normalMass;
+        const mass11 = point1.normalMass;
+        const mass01 = state.k01;
+        const velocity0 = getNormalVelocity(state, point0) - point0.velocityBias;
+        const velocity1 = getNormalVelocity(state, point1) - point1.velocityBias;
+        const oldImpulse0 = point0.normalImpulse;
+        const oldImpulse1 = point1.normalImpulse;
+        const target0 = mass00 * oldImpulse0 + mass01 * oldImpulse1 - velocity0;
+        const target1 = mass01 * oldImpulse0 + mass11 * oldImpulse1 - velocity1;
+        if (!this.solveBlockNormalImpulse(mass00, mass01, mass11, target0, target1, velocity0, velocity1, oldImpulse0, oldImpulse1, state.determinant)) {
+            this.applyPointNormalImpulse(state, 0);
+            this.applyPointNormalImpulse(state, 1);
+            return;
+        }
+        const impulseDelta0 = this.blockImpulse0 - oldImpulse0;
+        const impulseDelta1 = this.blockImpulse1 - oldImpulse1;
+        point0.normalImpulse = this.blockImpulse0;
+        point1.normalImpulse = this.blockImpulse1;
+        if (impulseDelta0 !== 0) {
+            applyImpulse(state, point0, state.normalX * impulseDelta0, state.normalY * impulseDelta0);
+        }
+        if (impulseDelta1 !== 0) {
+            applyImpulse(state, point1, state.normalX * impulseDelta1, state.normalY * impulseDelta1);
+        }
+    }
+    /**
+     * Solves the normal impulses for both contact points of a two-point
+     * manifold together, instead of one at a time.
+     *
+     * A contact point can only push, never pull (its impulse
+     * must stay >= 0), and a point that's already pulling apart on its own
+     * shouldn't be pushed at all. Which point(s) actually need pushing this
+     * step isn't known upfront, so this tries the possibilities from most to
+     * least likely and uses the first one that comes out consistent:
+     *  1. Both points push — solve the 2x2 system directly; only valid if both
+     *     resulting impulses are non-negative.
+     *  2. Only point0 pushes, point1 is left alone — only valid if point1
+     *     isn't still closing in without help (that would mean it needed a
+     *     push too, contradicting the assumption).
+     *  3. Only point1 pushes, point0 is left alone — mirror of case 2.
+     *  4. Neither pushes — only valid if both points are already separating
+     *     on their own.
+     */
+    solveBlockNormalImpulse(mass00, mass01, mass11, target0, target1, velocity0, velocity1, oldImpulse0, oldImpulse1, determinant) {
+        const bothImpulse0 = (mass11 * target0 - mass01 * target1) / determinant;
+        const bothImpulse1 = (mass00 * target1 - mass01 * target0) / determinant;
+        if (bothImpulse0 >= 0 && bothImpulse1 >= 0) {
+            this.blockImpulse0 = bothImpulse0;
+            this.blockImpulse1 = bothImpulse1;
+            return true;
+        }
+        const point0Impulse = target0 / mass00;
+        const point0InactiveVelocity = velocity1 + mass01 * (point0Impulse - oldImpulse0) - mass11 * oldImpulse1;
+        if (point0Impulse >= 0 &&
+            point0InactiveVelocity >= -BLOCK_SOLVER_TOLERANCE) {
+            this.blockImpulse0 = point0Impulse;
+            this.blockImpulse1 = 0;
+            return true;
+        }
+        const point1Impulse = target1 / mass11;
+        const point1InactiveVelocity = velocity0 - mass00 * oldImpulse0 + mass01 * (point1Impulse - oldImpulse1);
+        if (point1Impulse >= 0 &&
+            point1InactiveVelocity >= -BLOCK_SOLVER_TOLERANCE) {
+            this.blockImpulse0 = 0;
+            this.blockImpulse1 = point1Impulse;
+            return true;
+        }
+        const inactiveVelocity0 = velocity0 - mass00 * oldImpulse0 - mass01 * oldImpulse1;
+        const inactiveVelocity1 = velocity1 - mass01 * oldImpulse0 - mass11 * oldImpulse1;
+        if (inactiveVelocity0 >= -BLOCK_SOLVER_TOLERANCE &&
+            inactiveVelocity1 >= -BLOCK_SOLVER_TOLERANCE) {
+            this.blockImpulse0 = 0;
+            this.blockImpulse1 = 0;
+            return true;
+        }
+        return false;
+    }
+    applyFrictionImpulse(state) {
+        for (let index = 0; index < state.pointCount; index += 1) {
+            const point = this.getPoint(state, index);
+            if (point.tangentMass === 0) {
+                continue;
+            }
+            const maxFrictionImpulse = state.friction * point.normalImpulse;
+            const velocityAlongTangent = getTangentVelocity(state, point);
+            const oldImpulse = point.tangentImpulse;
+            const newImpulse = MathOps.clamp(oldImpulse - velocityAlongTangent / point.tangentMass, -maxFrictionImpulse, maxFrictionImpulse);
+            point.tangentImpulse = newImpulse;
+            const impulse = newImpulse - oldImpulse;
+            if (impulse === 0) {
+                continue;
+            }
+            applyImpulse(state, point, state.tangentX * impulse, state.tangentY * impulse);
+        }
+    }
+    applyBiasImpulse(state, deltaTime) {
+        const targetBiasVelocity = Math.min((Math.max(state.contact.penetration - this.maxAllowedPenetration, 0) *
+            CONTACT_BIAS) /
+            deltaTime, this.maxBiasVelocity);
+        if (targetBiasVelocity === 0) {
+            return;
+        }
+        for (let index = 0; index < state.pointCount; index += 1) {
+            const point = this.getPoint(state, index);
+            if (point.normalMass === 0) {
+                continue;
+            }
+            const biasVelocityAlongNormal = getBiasNormalVelocity(state, point);
+            const oldImpulse = point.biasImpulse;
+            const newImpulse = Math.max(oldImpulse +
+                (targetBiasVelocity - biasVelocityAlongNormal) / point.normalMass, 0);
+            point.biasImpulse = newImpulse;
+            const impulse = newImpulse - oldImpulse;
+            if (impulse === 0) {
+                continue;
+            }
+            applyBiasImpulse(state, point, state.normalX * impulse, state.normalY * impulse);
         }
     }
     update(contacts) {
-        this.oneWayValidator.update();
-        let validContactsCount = 0;
+        this.oneWayValidator.updateVersion();
+        this.contactStateManager.updateVersion();
+        this.sleepSupportTracker.beginFrame();
+        const deltaTime = this.time.fixedDeltaTime;
+        this.restitutionThreshold = Math.max(RESTITUTION_VELOCITY_THRESHOLD, RESTITUTION_GRAVITY_THRESHOLD_FACTOR *
+            this.getGravity().magnitude *
+            deltaTime);
         contacts.forEach((contact) => {
             if (!this.validateCollision(contact.actor1, contact.actor2)) {
                 return;
@@ -155,19 +364,28 @@ export class ConstraintSolver {
             if (!this.validateOneWayContact(contact)) {
                 return;
             }
-            this.validContacts[validContactsCount] = contact;
-            validContactsCount += 1;
+            if (!this.validateSleepContact(contact)) {
+                return;
+            }
+            const state = this.contactStateManager.acquire(contact);
+            this.prepareContact(state);
+            this.applyWarmStartImpulse(state);
         });
-        this.validContacts.length = validContactsCount;
-        for (let iteration = 0; iteration < SOLVER_ITERATIONS; iteration += 1) {
-            this.validContacts.forEach((contact) => {
-                const normalImpulseMagnitude = this.applyNormalImpulse(contact);
-                this.applyFrictionImpulse(contact, normalImpulseMagnitude);
+        this.sleepSupportTracker.wakeUnsupportedBodies();
+        this.contactStateManager.pruneStaleStates();
+        for (let iteration = 0; iteration < this.solverIterations; iteration += 1) {
+            this.contactStateManager.forEach((state) => {
+                if (!state.active) {
+                    return;
+                }
+                this.applyNormalImpulse(state);
+                this.applyFrictionImpulse(state);
+                if (!state.skipBias) {
+                    this.applyBiasImpulse(state, deltaTime);
+                }
             });
         }
-        this.validContacts.forEach((contact) => {
-            this.applyPositionCorrection(contact);
-        });
-        this.oneWayValidator.lateUpdate();
+        this.oneWayValidator.clearOneWayContacts();
+        this.sleepSupportTracker.endFrame();
     }
 }

package/build/contrib/systems/physics-system/subsystems/constraint-solver/one-way-validator.d.ts

@@ -0,0 +1,11 @@
+import type { Actor } from '../../../../../engine/actor';
+import { type Point } from '../../../../../engine/math-lib';
+export declare class OneWayValidator {
+    private ignoredOneWayContacts;
+    private version;
+    constructor();
+    private trackOneWayContact;
+    shouldBlock(oneWayActor: Actor, otherActor: Actor, normal: Point): boolean;
+    updateVersion(): void;
+    clearOneWayContacts(): void;
+}