dacha 0.18.0-alpha.8 → 0.18.0

package/build/contrib/systems/physics-system/subsystems/collision-detection/query-utils.js

@@ -1,3 +1,4 @@
+import { Vector2 } from '../../../../../engine/math-lib';
 import { Collider, Transform } from '../../../../components';
 import { geometryBuilders } from './geometry-builders';
 import { aabbBuilders } from './aabb-builders';
@@ -10,7 +11,7 @@ export function buildQueryProxy(type, params) {
         aabb: aabbBuilders[type](geometry),
         geometry,
         layer: params.layer,
-        excludedActors: params.excludeActors
+        excludedActors: params.excludeActors?.length
             ? new Set(params.excludeActors)
             : undefined,
         actorFilter: params.actorFilter,
@@ -62,130 +63,145 @@ export const getActorCastQueryType = (params) => {
             return null;
     }
 };
+export const makeCastHit = () => ({
+    actor: undefined,
+    point: { x: 0, y: 0 },
+    normal: new Vector2(0, 0),
+    distance: 0,
+});
+const cloneCastHit = (hit) => ({
+    actor: hit.actor,
+    point: hit.point,
+    normal: hit.normal,
+    distance: hit.distance,
+});
+export const makeOverlapHit = () => ({
+    actor: undefined,
+    normal: new Vector2(0, 0),
+    penetration: 0,
+    contactPoints: [],
+});
+const cloneOverlapHit = (hit) => ({
+    actor: hit.actor,
+    normal: hit.normal,
+    penetration: hit.penetration,
+    contactPoints: hit.contactPoints,
+});
 export const overlap = (type, queryProxy, proxies) => {
+    const scratch = makeOverlapHit();
     const hits = [];
-    for (const proxy of proxies) {
-        const collider = proxy.actor.getComponent(Collider);
-        const checker = intersectionCheckers[type]?.[collider.shape.type];
-        if (!checker) {
-            continue;
-        }
-        const intersection = checker(queryProxy.geometry, proxy.geometry);
-        if (!intersection) {
-            continue;
-        }
-        const hit = {
-            actor: proxy.actor,
-            normal: intersection.normal.clone().multiplyNumber(-1),
-            penetration: intersection.penetration,
-            contactPoints: intersection.contactPoints,
-        };
-        if (queryProxy.hitFilter && !queryProxy.hitFilter(hit)) {
-            continue;
-        }
-        hits.push(hit);
-    }
+    overlapEach(type, queryProxy, proxies, scratch, (hit) => {
+        hits.push(cloneOverlapHit(hit));
+    });
     return hits;
 };
 export const raycast = (queryProxy, proxies) => {
+    const scratch = makeCastHit();
     let nearestDistance = Infinity;
     let nearestHit = null;
-    for (const proxy of proxies) {
-        const collider = proxy.actor.getComponent(Collider);
-        const hit = raycastCheckers.ray[collider.shape.type](queryProxy.geometry, proxy.geometry);
-        if (!hit) {
-            continue;
-        }
-        const castHit = {
-            actor: proxy.actor,
-            point: hit.point,
-            normal: hit.normal,
-            distance: hit.distance,
-        };
-        if (queryProxy.hitFilter && !queryProxy.hitFilter(castHit)) {
-            continue;
-        }
+    raycastEach(queryProxy, proxies, scratch, (hit) => {
         if (hit.distance < nearestDistance) {
-            nearestHit = castHit;
             nearestDistance = hit.distance;
+            nearestHit = nearestHit ?? makeCastHit();
+            nearestHit.actor = hit.actor;
+            nearestHit.point = hit.point;
+            nearestHit.normal = hit.normal;
+            nearestHit.distance = hit.distance;
         }
-    }
+    });
     return nearestHit;
 };
 export const raycastAll = (queryProxy, proxies) => {
+    const scratch = makeCastHit();
     const hits = [];
+    raycastEach(queryProxy, proxies, scratch, (hit) => {
+        hits.push(cloneCastHit(hit));
+    });
+    hits.sort((arg1, arg2) => arg1.distance - arg2.distance);
+    return hits;
+};
+export const shapeCast = (type, queryProxy, proxies) => {
+    const scratch = makeCastHit();
+    let nearestDistance = Infinity;
+    let nearestHit = null;
+    shapeCastEach(type, queryProxy, proxies, scratch, (hit) => {
+        if (hit.distance < nearestDistance) {
+            nearestDistance = hit.distance;
+            nearestHit = nearestHit ?? makeCastHit();
+            nearestHit.actor = hit.actor;
+            nearestHit.point = hit.point;
+            nearestHit.normal = hit.normal;
+            nearestHit.distance = hit.distance;
+        }
+    });
+    return nearestHit;
+};
+export const shapeCastAll = (type, queryProxy, proxies) => {
+    const scratch = makeCastHit();
+    const hits = [];
+    shapeCastEach(type, queryProxy, proxies, scratch, (hit) => {
+        hits.push(cloneCastHit(hit));
+    });
+    hits.sort((arg1, arg2) => arg1.distance - arg2.distance);
+    return hits;
+};
+export const raycastEach = (queryProxy, proxies, hit, callback) => {
     for (const proxy of proxies) {
         const collider = proxy.actor.getComponent(Collider);
-        const hit = raycastCheckers.ray[collider.shape.type](queryProxy.geometry, proxy.geometry);
-        if (!hit) {
+        const result = raycastCheckers.ray[collider.shape.type](queryProxy.geometry, proxy.geometry);
+        if (!result) {
             continue;
         }
-        const castHit = {
-            actor: proxy.actor,
-            point: hit.point,
-            normal: hit.normal,
-            distance: hit.distance,
-        };
-        if (queryProxy.hitFilter && !queryProxy.hitFilter(castHit)) {
+        hit.actor = proxy.actor;
+        hit.point = result.point;
+        hit.normal = result.normal;
+        hit.distance = result.distance;
+        if (queryProxy.hitFilter && !queryProxy.hitFilter(hit)) {
             continue;
         }
-        hits.push(castHit);
+        callback(hit);
     }
-    hits.sort((arg1, arg2) => arg1.distance - arg2.distance);
-    return hits;
 };
-export const shapeCast = (type, queryProxy, proxies) => {
-    let nearestDistance = Infinity;
-    let nearestHit = null;
+export const shapeCastEach = (type, queryProxy, proxies, hit, callback) => {
     for (const proxy of proxies) {
         const collider = proxy.actor.getComponent(Collider);
         const checker = shapeCastCheckers[type]?.[collider.shape.type];
         if (!checker) {
             continue;
         }
-        const castHit = checker(queryProxy.geometry, proxy.geometry);
-        if (!castHit) {
+        const result = checker(queryProxy.geometry, proxy.geometry);
+        if (!result) {
             continue;
         }
-        const hit = {
-            actor: proxy.actor,
-            point: castHit.point,
-            normal: castHit.normal,
-            distance: castHit.distance,
-        };
+        hit.actor = proxy.actor;
+        hit.point = result.point;
+        hit.normal = result.normal;
+        hit.distance = result.distance;
         if (queryProxy.hitFilter && !queryProxy.hitFilter(hit)) {
             continue;
         }
-        if (castHit.distance < nearestDistance) {
-            nearestHit = hit;
-            nearestDistance = castHit.distance;
-        }
+        callback(hit);
     }
-    return nearestHit;
 };
-export const shapeCastAll = (type, queryProxy, proxies) => {
-    const hits = [];
+export const overlapEach = (type, queryProxy, proxies, hit, callback) => {
     for (const proxy of proxies) {
         const collider = proxy.actor.getComponent(Collider);
-        const checker = shapeCastCheckers[type]?.[collider.shape.type];
+        const checker = intersectionCheckers[type]?.[collider.shape.type];
         if (!checker) {
             continue;
         }
-        const castHit = checker(queryProxy.geometry, proxy.geometry);
-        if (!castHit) {
+        const intersection = checker(queryProxy.geometry, proxy.geometry);
+        if (!intersection) {
             continue;
         }
-        const hit = {
-            actor: proxy.actor,
-            point: castHit.point,
-            normal: castHit.normal,
-            distance: castHit.distance,
-        };
+        intersection.normal.multiplyNumber(-1);
+        hit.actor = proxy.actor;
+        hit.normal = intersection.normal;
+        hit.penetration = intersection.penetration;
+        hit.contactPoints = intersection.contactPoints;
         if (queryProxy.hitFilter && !queryProxy.hitFilter(hit)) {
             continue;
         }
-        hits.push(hit);
+        callback(hit);
     }
-    hits.sort((arg1, arg2) => arg1.distance - arg2.distance);
-    return hits;
 };

package/build/contrib/systems/physics-system/subsystems/collision-detection/shape-cast-checkers/tests/helpers.js

@@ -2,6 +2,7 @@ import { Vector2 } from '../../../../../../../engine/math-lib';
 import { buildBoxCastGeometry } from '../../geometry-builders/build-box-cast-geometry';
 import { buildCapsuleCastGeometry } from '../../geometry-builders/build-capsule-cast-geometry';
 import { buildCircleCastGeometry } from '../../geometry-builders/build-circle-cast-geometry';
+import { expectHit } from '../../tests/assertions';
 export const createCircleCastGeometry = (centerX, centerY, radius, directionX, directionY, maxDistance) => buildCircleCastGeometry({
     shape: {
         type: 'circle',
@@ -30,10 +31,4 @@ export const createBoxCastGeometry = (centerX, centerY, sizeX, sizeY, directionX
     direction: new Vector2(directionX, directionY),
     maxDistance,
 });
-export const expectShapeCastHit = (hit) => {
-    expect(hit).not.toBe(false);
-    if (hit === false) {
-        throw new Error('Expected shape-cast hit, received false');
-    }
-    return hit;
-};
+export const expectShapeCastHit = (hit) => expectHit(hit, 'shape-cast hit');

package/build/contrib/systems/physics-system/subsystems/collision-detection/tests/assertions.d.ts

@@ -0,0 +1 @@
+export declare const expectHit: <T>(hit: false | T, label: string) => T;

package/build/contrib/systems/physics-system/subsystems/collision-detection/tests/assertions.js

@@ -0,0 +1,7 @@
+export const expectHit = (hit, label) => {
+    expect(hit).not.toBe(false);
+    if (hit === false) {
+        throw new Error(`Expected ${label}, received false`);
+    }
+    return hit;
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/types.d.ts

@@ -2,7 +2,6 @@ import type { Vector2, Point } from '../../../../../engine/math-lib';
 import type { Actor } from '../../../../../engine/actor';
 import type { CastHit, OverlapHit } from '../../types';
 import type { DynamicAABBTreeEntryId } from './dynamic-aabb-tree';
-import type { DispersionCalculator } from './dispersion-calculator';
 export type { Point };
 export interface AABB {
     min: Point;
@@ -83,7 +82,6 @@ export interface ActorProxy {
     aabb: AABB;
     geometry: Geometry;
     orientationData: OrientationData;
-    edges: Record<Axis, [SortedItem, SortedItem]>;
     treeEntryId: DynamicAABBTreeEntryId;
     layer: string;
 }
@@ -96,19 +94,6 @@ export interface QueryProxy {
     hitFilter?: (hit: OverlapHit | CastHit) => boolean;
 }
 export type Proxy = ActorProxy | QueryProxy;
-export interface SortedItem {
-    proxy: ActorProxy;
-    value: number;
-}
-export interface AxisEntry {
-    sortedList: SortedItem[];
-    dispersionCalculator: DispersionCalculator;
-}
-export type Axis = 'x' | 'y';
-export interface Axes {
-    x: AxisEntry;
-    y: AxisEntry;
-}
 export type ProxyPair = [ActorProxy, ActorProxy];
 export interface Contact {
     actor1: Actor;

package/build/contrib/systems/physics-system/subsystems/collision-detection/utils.d.ts

@@ -1,5 +1,8 @@
+import type { ActorProxy } from './types';
 export declare const isZero: (value: number) => boolean;
 export declare const isDefinitelyPositive: (value: number) => boolean;
 export declare const isDefinitelyNegative: (value: number) => boolean;
 export declare const isGreaterThan: (left: number, right: number) => boolean;
 export declare const isLessThan: (left: number, right: number) => boolean;
+export declare const isStatic: (proxy: ActorProxy) => boolean;
+export declare const isDisabled: (proxy: ActorProxy) => boolean;

package/build/contrib/systems/physics-system/subsystems/collision-detection/utils.js

@@ -1,6 +1,15 @@
+import { RigidBody, Collider } from '../../../../components';
 import { INTERSECTION_EPSILON } from './constants';
 export const isZero = (value) => Math.abs(value) <= INTERSECTION_EPSILON;
 export const isDefinitelyPositive = (value) => value > INTERSECTION_EPSILON;
 export const isDefinitelyNegative = (value) => value < -INTERSECTION_EPSILON;
 export const isGreaterThan = (left, right) => isDefinitelyPositive(left - right);
 export const isLessThan = (left, right) => isDefinitelyNegative(left - right);
+export const isStatic = (proxy) => {
+    const rigidBody = proxy.actor.getComponent(RigidBody);
+    return rigidBody?.type === 'static';
+};
+export const isDisabled = (proxy) => {
+    const collider = proxy.actor.getComponent(Collider);
+    return collider?.disabled === true;
+};

package/build/contrib/systems/physics-system/subsystems/constraint-solver/contact-state-manager.d.ts

@@ -0,0 +1,63 @@
+import type { Actor } from '../../../../../engine/actor';
+import { RigidBody } from '../../../../components/rigid-body';
+import type { Contact } from '../collision-detection/types';
+export interface ContactPoint {
+    positionX: number;
+    positionY: number;
+    normalImpulse: number;
+    tangentImpulse: number;
+    biasImpulse: number;
+    anchorAX: number;
+    anchorAY: number;
+    anchorBX: number;
+    anchorBY: number;
+    normalMass: number;
+    tangentMass: number;
+    velocityBias: number;
+}
+export interface ContactState {
+    contact: Contact;
+    actor1: Actor;
+    actor2: Actor;
+    bodyA: RigidBody;
+    bodyB: RigidBody;
+    invMassA: number;
+    invInertiaA: number;
+    invMassB: number;
+    invInertiaB: number;
+    normalX: number;
+    normalY: number;
+    tangentX: number;
+    tangentY: number;
+    friction: number;
+    restitution: number;
+    k01: number;
+    determinant: number;
+    blockSolvable: boolean;
+    active: boolean;
+    warmStartAllowed: boolean;
+    skipBias: boolean;
+    point0: ContactPoint;
+    point1: ContactPoint;
+    pointCount: number;
+    version: number;
+}
+export declare class ContactStateManager {
+    private stateMap;
+    private states;
+    private version;
+    constructor();
+    updateVersion(): void;
+    acquire(contact: Contact): ContactState;
+    pruneStaleStates(): void;
+    forEach(callback: (state: ContactState) => void): void;
+    clearWarmStartImpulses(state: ContactState): void;
+    private clearFrameImpulses;
+    private get;
+    private set;
+    private delete;
+    private createState;
+    private canPreserveImpulses;
+    private isPointClose;
+    private updateContactIdentity;
+}

package/build/contrib/systems/physics-system/subsystems/constraint-solver/contact-state-manager.js

@@ -0,0 +1,170 @@
+import { RigidBody } from '../../../../components/rigid-body';
+const CONTACT_NORMAL_MIN_DOT = 0.98;
+const CONTACT_POINT_MAX_DISTANCE = 0.2;
+const CONTACT_POINT_MAX_DISTANCE_SQUARED = CONTACT_POINT_MAX_DISTANCE * CONTACT_POINT_MAX_DISTANCE;
+const createContactPoint = () => ({
+    positionX: 0,
+    positionY: 0,
+    normalImpulse: 0,
+    tangentImpulse: 0,
+    biasImpulse: 0,
+    anchorAX: 0,
+    anchorAY: 0,
+    anchorBX: 0,
+    anchorBY: 0,
+    normalMass: 0,
+    tangentMass: 0,
+    velocityBias: 0,
+});
+export class ContactStateManager {
+    stateMap;
+    states;
+    version;
+    constructor() {
+        this.stateMap = new Map();
+        this.states = [];
+        this.version = 0;
+    }
+    updateVersion() {
+        this.version += 1;
+    }
+    acquire(contact) {
+        let state = this.get(contact.actor1, contact.actor2);
+        if (!state) {
+            state = this.createState(contact);
+            this.set(contact.actor1, contact.actor2, state);
+            this.set(contact.actor2, contact.actor1, state);
+            this.states.push(state);
+        }
+        else {
+            state.contact = contact;
+            state.actor1 = contact.actor1;
+            state.actor2 = contact.actor2;
+        }
+        if (!this.canPreserveImpulses(state, contact)) {
+            this.clearWarmStartImpulses(state);
+        }
+        this.clearFrameImpulses(state);
+        this.updateContactIdentity(state, contact);
+        state.version = this.version;
+        return state;
+    }
+    pruneStaleStates() {
+        let stateIndex = 0;
+        for (const state of this.states) {
+            if (state.version === this.version ||
+                (state.bodyA.sleeping && state.bodyB.sleeping)) {
+                this.states[stateIndex] = state;
+                stateIndex += 1;
+                continue;
+            }
+            this.delete(state.actor1, state.actor2);
+            this.delete(state.actor2, state.actor1);
+        }
+        this.states.length = stateIndex;
+    }
+    forEach(callback) {
+        this.states.forEach(callback);
+    }
+    clearWarmStartImpulses(state) {
+        state.point0.normalImpulse = 0;
+        state.point0.tangentImpulse = 0;
+        state.point1.normalImpulse = 0;
+        state.point1.tangentImpulse = 0;
+    }
+    clearFrameImpulses(state) {
+        state.point0.biasImpulse = 0;
+        state.point1.biasImpulse = 0;
+    }
+    get(actor1, actor2) {
+        return this.stateMap.get(actor1)?.get(actor2);
+    }
+    set(actor1, actor2, state) {
+        let actorStates = this.stateMap.get(actor1);
+        if (!actorStates) {
+            actorStates = new Map();
+            this.stateMap.set(actor1, actorStates);
+        }
+        actorStates.set(actor2, state);
+    }
+    delete(actor1, actor2) {
+        const actorStates = this.stateMap.get(actor1);
+        if (!actorStates) {
+            return;
+        }
+        actorStates.delete(actor2);
+        if (actorStates.size === 0) {
+            this.stateMap.delete(actor1);
+        }
+    }
+    createState(contact) {
+        const rigidBody1 = contact.actor1.getComponent(RigidBody);
+        const rigidBody2 = contact.actor2.getComponent(RigidBody);
+        return {
+            contact,
+            actor1: contact.actor1,
+            actor2: contact.actor2,
+            bodyA: rigidBody1,
+            bodyB: rigidBody2,
+            invMassA: 0,
+            invInertiaA: 0,
+            invMassB: 0,
+            invInertiaB: 0,
+            normalX: contact.normal.x,
+            normalY: contact.normal.y,
+            tangentX: -contact.normal.y,
+            tangentY: contact.normal.x,
+            friction: 0,
+            restitution: 0,
+            k01: 0,
+            determinant: 0,
+            blockSolvable: false,
+            active: false,
+            warmStartAllowed: false,
+            skipBias: false,
+            point0: createContactPoint(),
+            point1: createContactPoint(),
+            pointCount: 0,
+            version: this.version,
+        };
+    }
+    canPreserveImpulses(state, contact) {
+        const contactPoints = contact.contactPoints;
+        if (state.pointCount !== contactPoints.length) {
+            return false;
+        }
+        if (state.normalX * contact.normal.x + state.normalY * contact.normal.y <
+            CONTACT_NORMAL_MIN_DOT) {
+            return false;
+        }
+        if (contactPoints[0] &&
+            !this.isPointClose(state.point0.positionX, state.point0.positionY, contactPoints[0].x, contactPoints[0].y)) {
+            return false;
+        }
+        if (contactPoints[1] &&
+            !this.isPointClose(state.point1.positionX, state.point1.positionY, contactPoints[1].x, contactPoints[1].y)) {
+            return false;
+        }
+        return true;
+    }
+    isPointClose(point1X, point1Y, point2X, point2Y) {
+        const distanceX = point1X - point2X;
+        const distanceY = point1Y - point2Y;
+        return (distanceX * distanceX + distanceY * distanceY <=
+            CONTACT_POINT_MAX_DISTANCE_SQUARED);
+    }
+    updateContactIdentity(state, contact) {
+        const contactPoints = contact.contactPoints;
+        state.normalX = contact.normal.x;
+        state.normalY = contact.normal.y;
+        state.pointCount = contactPoints.length;
+        if (contactPoints[0]) {
+            state.point0.positionX = contactPoints[0].x;
+            state.point0.positionY = contactPoints[0].y;
+        }
+        if (contactPoints[1]) {
+            state.point1.positionX = contactPoints[1].x;
+            state.point1.positionY = contactPoints[1].y;
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { Actor } from '../../../../../engine/actor';
+import { type Vector2 } from '../../../../../engine/math-lib';
+import type { Contact } from '../collision-detection/types';
+export declare const shouldWakeSleepingContact: (contact: Contact, contactSpeedThreshold: number) => boolean;
+export declare const isSleepSupportContact: (contact: Contact, actor: Actor, gravity: Vector2) => boolean;

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

@@ -0,0 +1,41 @@
+import { VectorOps } from '../../../../../engine/math-lib';
+import { RigidBody } from '../../../../components/rigid-body';
+import { Transform } from '../../../../components/transform';
+import { SUPPORT_MIN_GRAVITY_DOT } from '../../consts';
+const getMinNormalVelocity = (contact) => {
+    const rigidBody1 = contact.actor1.getComponent(RigidBody);
+    const rigidBody2 = contact.actor2.getComponent(RigidBody);
+    const transform1 = contact.actor1.getComponent(Transform);
+    const transform2 = contact.actor2.getComponent(Transform);
+    const { normal } = contact;
+    let minVelocity = null;
+    for (const point of contact.contactPoints) {
+        const anchor1X = point.x - transform1.world.position.x;
+        const anchor1Y = point.y - transform1.world.position.y;
+        const anchor2X = point.x - transform2.world.position.x;
+        const anchor2Y = point.y - transform2.world.position.y;
+        const velocity1X = rigidBody1.linearVelocity.x - rigidBody1.angularVelocity * anchor1Y;
+        const velocity1Y = rigidBody1.linearVelocity.y + rigidBody1.angularVelocity * anchor1X;
+        const velocity2X = rigidBody2.linearVelocity.x - rigidBody2.angularVelocity * anchor2Y;
+        const velocity2Y = rigidBody2.linearVelocity.y + rigidBody2.angularVelocity * anchor2X;
+        const velocity = (velocity2X - velocity1X) * normal.x +
+            (velocity2Y - velocity1Y) * normal.y;
+        if (minVelocity === null || velocity < minVelocity) {
+            minVelocity = velocity;
+        }
+    }
+    return minVelocity;
+};
+export const shouldWakeSleepingContact = (contact, contactSpeedThreshold) => {
+    const minNormalVelocity = getMinNormalVelocity(contact);
+    return (minNormalVelocity !== null && -minNormalVelocity > contactSpeedThreshold);
+};
+export const isSleepSupportContact = (contact, actor, gravity) => {
+    const gravityMagnitude = gravity.magnitude;
+    if (gravityMagnitude === 0) {
+        return false;
+    }
+    const normalGravityDot = VectorOps.dotProduct(contact.normal, gravity);
+    const supportDot = contact.actor1 === actor ? normalGravityDot : -normalGravityDot;
+    return supportDot / gravityMagnitude > SUPPORT_MIN_GRAVITY_DOT;
+};

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

@@ -0,0 +1,16 @@
+import type { RigidBody } from '../../../../components/rigid-body';
+import type { ContactPoint, ContactState } from './contact-state-manager';
+export declare const getContactRestitution: (rigidBody1: RigidBody, rigidBody2: RigidBody) => number;
+export declare const getContactFriction: (rigidBody1: RigidBody, rigidBody2: RigidBody) => number;
+/**
+ * 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 declare const getEffectiveMass: (invMassA: number, invInertiaA: number, anchorAX: number, anchorAY: number, invMassB: number, invInertiaB: number, anchorBX: number, anchorBY: number, directionX: number, directionY: number) => number;
+export declare const getNormalVelocity: (state: ContactState, point: ContactPoint) => number;
+export declare const getTangentVelocity: (state: ContactState, point: ContactPoint) => number;
+export declare const getPrevNormalVelocity: (state: ContactState, point: ContactPoint) => number;
+export declare const getBiasNormalVelocity: (state: ContactState, point: ContactPoint) => number;
+export declare const applyImpulse: (state: ContactState, point: ContactPoint, impulseX: number, impulseY: number) => void;
+export declare const applyBiasImpulse: (state: ContactState, point: ContactPoint, impulseX: number, impulseY: number) => void;