dacha 0.18.0-alpha.8 → 0.18.0

package/build/contrib/{utils → systems/physics-system/subsystems/constraint-solver}/one-way-validator.js

@@ -1,26 +1,11 @@
-import { RigidBody, Transform } from '../components';
-import { VectorOps } from '../../engine/math-lib';
+import { RigidBody, Transform } from '../../../../components';
+import { VectorOps } from '../../../../../engine/math-lib';
 export class OneWayValidator {
     ignoredOneWayContacts;
-    oneWayContactUpdateIndex;
+    version;
     constructor() {
         this.ignoredOneWayContacts = new Map();
-        this.oneWayContactUpdateIndex = 0;
-    }
-    clearOneWayContacts() {
-        this.ignoredOneWayContacts.forEach((ignoredContacts, oneWayActor) => {
-            ignoredContacts.forEach((lastSeenUpdate, otherActor) => {
-                if (lastSeenUpdate !== this.oneWayContactUpdateIndex) {
-                    ignoredContacts.delete(otherActor);
-                }
-            });
-            if (ignoredContacts.size === 0) {
-                this.ignoredOneWayContacts.delete(oneWayActor);
-            }
-        });
-        if (this.ignoredOneWayContacts.size === 0) {
-            this.oneWayContactUpdateIndex = 0;
-        }
+        this.version = 0;
     }
     trackOneWayContact(oneWayActor, otherActor) {
         let ignoredContacts = this.ignoredOneWayContacts.get(oneWayActor);
@@ -28,9 +13,9 @@ export class OneWayValidator {
             ignoredContacts = new Map();
             this.ignoredOneWayContacts.set(oneWayActor, ignoredContacts);
         }
-        ignoredContacts.set(otherActor, this.oneWayContactUpdateIndex);
+        ignoredContacts.set(otherActor, this.version);
     }
-    validate(oneWayActor, otherActor, normal) {
+    shouldBlock(oneWayActor, otherActor, normal) {
         if (this.ignoredOneWayContacts.get(oneWayActor)?.has(otherActor)) {
             this.trackOneWayContact(oneWayActor, otherActor);
             return false;
@@ -44,10 +29,22 @@ export class OneWayValidator {
         this.trackOneWayContact(oneWayActor, otherActor);
         return false;
     }
-    update() {
-        this.oneWayContactUpdateIndex += 1;
+    updateVersion() {
+        this.version += 1;
     }
-    lateUpdate() {
-        this.clearOneWayContacts();
+    clearOneWayContacts() {
+        this.ignoredOneWayContacts.forEach((ignoredContacts, oneWayActor) => {
+            ignoredContacts.forEach((lastSeenUpdate, otherActor) => {
+                if (lastSeenUpdate !== this.version) {
+                    ignoredContacts.delete(otherActor);
+                }
+            });
+            if (ignoredContacts.size === 0) {
+                this.ignoredOneWayContacts.delete(oneWayActor);
+            }
+        });
+        if (this.ignoredOneWayContacts.size === 0) {
+            this.version = 0;
+        }
     }
 }

package/build/contrib/systems/physics-system/subsystems/constraint-solver/sleep-support-tracker.d.ts

@@ -0,0 +1,13 @@
+import type { Vector2 } from '../../../../../engine/math-lib';
+import type { Contact } from '../collision-detection/types';
+export declare class SleepSupportTracker {
+    private currentSupportedActors;
+    private previousSupportedActors;
+    private getGravity;
+    constructor(getGravity: () => Vector2);
+    beginFrame(): void;
+    trackContact(contact: Contact): void;
+    wakeUnsupportedBodies(): void;
+    endFrame(): void;
+    private trackActor;
+}

package/build/contrib/systems/physics-system/subsystems/constraint-solver/sleep-support-tracker.js

@@ -0,0 +1,42 @@
+import { RigidBody } from '../../../../components/rigid-body';
+import { isSleepSupportContact } from './contact-utils';
+export class SleepSupportTracker {
+    currentSupportedActors;
+    previousSupportedActors;
+    getGravity;
+    constructor(getGravity) {
+        this.currentSupportedActors = new Set();
+        this.previousSupportedActors = new Set();
+        this.getGravity = getGravity;
+    }
+    beginFrame() {
+        this.currentSupportedActors.clear();
+    }
+    trackContact(contact) {
+        this.trackActor(contact.actor1, contact);
+        this.trackActor(contact.actor2, contact);
+    }
+    wakeUnsupportedBodies() {
+        this.previousSupportedActors.forEach((actor) => {
+            if (this.currentSupportedActors.has(actor)) {
+                return;
+            }
+            const rigidBody = actor.getComponent(RigidBody);
+            rigidBody?.wakeUp();
+        });
+    }
+    endFrame() {
+        const previousSupportedActors = this.previousSupportedActors;
+        this.previousSupportedActors = this.currentSupportedActors;
+        this.currentSupportedActors = previousSupportedActors;
+    }
+    trackActor(actor, contact) {
+        const gravity = this.getGravity();
+        const rigidBody = actor.getComponent(RigidBody);
+        if (rigidBody.type !== 'dynamic' ||
+            !isSleepSupportContact(contact, actor, gravity)) {
+            return;
+        }
+        this.currentSupportedActors.add(actor);
+    }
+}

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

@@ -0,0 +1,4 @@
+import { Actor } from '../../../../../../engine/actor';
+import { type RigidBodyConfig, type RigidBodyType } from '../../../../../components/rigid-body';
+export declare const createActor: (id: string, type: RigidBodyType, config?: Partial<RigidBodyConfig>) => Actor;
+export declare const createActorWithInertia: (id: string, type: RigidBodyType, config?: Partial<RigidBodyConfig>) => Actor;

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

@@ -0,0 +1,20 @@
+import { Actor } from '../../../../../../engine/actor';
+import { RigidBody, } from '../../../../../components/rigid-body';
+export const createActor = (id, type, config = {}) => {
+    const actor = new Actor({ id, name: id });
+    actor.setComponent(new RigidBody({
+        type,
+        mass: 1,
+        gravityScale: 0,
+        linearDamping: 0,
+        disabled: false,
+        oneWay: false,
+        ...config,
+    }));
+    return actor;
+};
+export const createActorWithInertia = (id, type, config = {}) => {
+    const actor = createActor(id, type, config);
+    actor.getComponent(RigidBody).inertia = 1;
+    return actor;
+};

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

@@ -1,19 +1,30 @@
-import type { UpdateOptions } from '../../../../../engine/system';
 import type { Scene } from '../../../../../engine/scene';
+import type { Time } from '../../../../../engine/time';
 import type { Vector2 } from '../../../../../engine/math-lib';
 export interface PhysicsSubsystemOptions {
     scene: Scene;
+    time: Time;
     getGravity: () => Vector2;
+    linearSleepThreshold?: number;
+    angularSleepThreshold?: number;
+    sleepTimeThreshold?: number;
 }
 export declare class PhysicsSubsystem {
     private actorQuery;
+    private time;
     private getGravity;
+    private linearSleepThreshold;
+    private angularSleepThreshold;
+    private biasAngularSleepThreshold;
+    private sleepTimeThreshold;
     private kinematicMovedActors;
     constructor(options: PhysicsSubsystemOptions);
     destroy(): void;
     private applyLinearDamping;
-    private integrateVelocities;
-    private integratePositions;
-    update(options: UpdateOptions): void;
+    private applyAngularDamping;
+    integrateVelocities(): void;
+    integrateKinematicPositions(): void;
+    integrateDynamicPositions(): void;
+    updateSleepTimers(): void;
     lateUpdate(): void;
 }

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

@@ -1,45 +1,61 @@
 import { ActorQuery } from '../../../../../engine/actor';
 import { RigidBody } from '../../../../components/rigid-body';
 import { Transform } from '../../../../components/transform';
+import { Collider } from '../../../../components/collider';
+import { DEFAULT_LINEAR_SLEEP_THRESHOLD, DEFAULT_ANGULAR_SLEEP_THRESHOLD, DEFAULT_SLEEP_TIME_THRESHOLD, BIAS_ANGULAR_SLEEP_MULTIPLIER, } from '../../consts';
+import { calculateInertia } from './mass-properties';
 export class PhysicsSubsystem {
     actorQuery;
+    time;
     getGravity;
+    linearSleepThreshold;
+    angularSleepThreshold;
+    biasAngularSleepThreshold;
+    sleepTimeThreshold;
     kinematicMovedActors;
     constructor(options) {
-        const { scene, getGravity } = options;
+        const { scene, time, getGravity } = options;
         this.actorQuery = new ActorQuery({ scene, filter: [RigidBody, Transform] });
+        this.time = time;
         this.getGravity = getGravity;
+        this.linearSleepThreshold =
+            options.linearSleepThreshold ?? DEFAULT_LINEAR_SLEEP_THRESHOLD;
+        this.angularSleepThreshold =
+            options.angularSleepThreshold ?? DEFAULT_ANGULAR_SLEEP_THRESHOLD;
+        this.biasAngularSleepThreshold =
+            this.angularSleepThreshold * BIAS_ANGULAR_SLEEP_MULTIPLIER;
+        this.sleepTimeThreshold =
+            options.sleepTimeThreshold ?? DEFAULT_SLEEP_TIME_THRESHOLD;
         this.kinematicMovedActors = new Set();
     }
     destroy() {
         this.actorQuery.destroy();
     }
     applyLinearDamping(rigidBody, deltaTime) {
-        const { mass, linearDamping, linearVelocity } = rigidBody;
+        const { linearDamping, linearVelocity } = rigidBody;
         if (!linearDamping || (!linearVelocity.x && !linearVelocity.y)) {
             return;
         }
-        const velocitySignX = Math.sign(linearVelocity.x);
-        const velocitySignY = Math.sign(linearVelocity.y);
-        const gravity = this.getGravity();
-        const reactionForceValue = mass * gravity.magnitude;
-        const dragForceValue = -1 * linearDamping * reactionForceValue;
-        const forceToVelocityMultiplier = deltaTime / mass;
-        const slowdownValue = dragForceValue * forceToVelocityMultiplier;
-        const normalizationMultiplier = 1 / linearVelocity.magnitude;
-        const slowdownMultiplier = slowdownValue * normalizationMultiplier;
-        linearVelocity.x += linearVelocity.x * slowdownMultiplier;
-        linearVelocity.y += linearVelocity.y * slowdownMultiplier;
-        if (Math.sign(linearVelocity.x) !== velocitySignX &&
-            Math.sign(linearVelocity.y) !== velocitySignY) {
-            linearVelocity.multiplyNumber(0);
+        linearVelocity.multiplyNumber(Math.max(0, 1 - linearDamping * deltaTime));
+    }
+    applyAngularDamping(rigidBody, deltaTime) {
+        const { angularDamping, angularVelocity } = rigidBody;
+        if (!angularDamping || !angularVelocity) {
+            return;
         }
+        rigidBody.angularVelocity *= Math.max(0, 1 - angularDamping * deltaTime);
     }
-    integrateVelocities(deltaTimeInSeconds) {
+    integrateVelocities() {
+        const deltaTime = this.time.fixedDeltaTime;
         this.actorQuery.getActors().forEach((actor) => {
             const rigidBody = actor.getComponent(RigidBody);
+            const collider = actor.getComponent(Collider);
             const transform = actor.getComponent(Transform);
-            const { mass, inverseMass } = rigidBody;
+            rigidBody._biasLinearVelocity.multiplyNumber(0);
+            rigidBody._biasAngularVelocity = 0;
+            rigidBody._prevLinearVelocity.x = rigidBody.linearVelocity.x;
+            rigidBody._prevLinearVelocity.y = rigidBody.linearVelocity.y;
+            rigidBody._prevAngularVelocity = rigidBody.angularVelocity;
             if (rigidBody.disabled) {
                 rigidBody._movementTarget = null;
                 rigidBody.clearForces();
@@ -54,70 +70,132 @@ export class PhysicsSubsystem {
                     return;
                 }
                 rigidBody.linearVelocity.x =
-                    (_movementTarget.x - transform.world.position.x) / deltaTimeInSeconds;
+                    (_movementTarget.x - transform.world.position.x) / deltaTime;
                 rigidBody.linearVelocity.y =
-                    (_movementTarget.y - transform.world.position.y) / deltaTimeInSeconds;
+                    (_movementTarget.y - transform.world.position.y) / deltaTime;
                 this.kinematicMovedActors.add(actor);
                 return;
             }
-            if (mass <= 0) {
+            if (rigidBody.mass <= 0) {
                 rigidBody.clearForces();
                 return;
             }
-            const { force, impulse } = rigidBody;
-            const velocity = rigidBody.linearVelocity;
-            if (rigidBody.sleeping) {
-                if (force.x || force.y || impulse.x || impulse.y) {
-                    rigidBody.wakeUp();
-                }
-                else {
-                    return;
-                }
+            rigidBody.inertia = calculateInertia(rigidBody.mass, collider, transform);
+            rigidBody._pointForces.forEach(({ force, position }) => {
+                rigidBody._centralForce.add(force);
+                rigidBody._torque +=
+                    (position.x - transform.world.position.x) * force.y -
+                        (position.y - transform.world.position.y) * force.x;
+            });
+            rigidBody._pointImpulses.forEach(({ impulse, position }) => {
+                rigidBody._centralImpulse.add(impulse);
+                rigidBody._angularImpulse +=
+                    (position.x - transform.world.position.x) * impulse.y -
+                        (position.y - transform.world.position.y) * impulse.x;
+            });
+            const { _centralForce, _centralImpulse, linearVelocity, mass, inverseMass, inverseInertia, gravityScale, lockRotation, sleeping, } = rigidBody;
+            if (sleeping) {
+                return;
             }
-            if (rigidBody.gravityScale) {
+            if (gravityScale) {
                 const gravity = this.getGravity();
-                force.x += mass * gravity.x * rigidBody.gravityScale;
-                force.y += mass * gravity.y * rigidBody.gravityScale;
+                _centralForce.x += mass * gravity.x * gravityScale;
+                _centralForce.y += mass * gravity.y * gravityScale;
+            }
+            if (_centralForce.x || _centralForce.y) {
+                _centralForce.multiplyNumber(deltaTime * inverseMass);
+                linearVelocity.add(_centralForce);
             }
-            if (force.x || force.y) {
-                force.multiplyNumber(deltaTimeInSeconds * inverseMass);
-                velocity.add(force);
+            if (_centralImpulse.x || _centralImpulse.y) {
+                _centralImpulse.multiplyNumber(inverseMass);
+                linearVelocity.add(_centralImpulse);
             }
-            if (impulse.x || impulse.y) {
-                impulse.multiplyNumber(inverseMass);
-                velocity.add(impulse);
+            if (lockRotation) {
+                rigidBody.angularVelocity = 0;
             }
-            this.applyLinearDamping(rigidBody, deltaTimeInSeconds);
+            else {
+                if (rigidBody._torque && inverseInertia > 0) {
+                    rigidBody.angularVelocity +=
+                        rigidBody._torque * inverseInertia * deltaTime;
+                }
+                if (rigidBody._angularImpulse && inverseInertia > 0) {
+                    rigidBody.angularVelocity +=
+                        rigidBody._angularImpulse * inverseInertia;
+                }
+                this.applyAngularDamping(rigidBody, deltaTime);
+            }
+            this.applyLinearDamping(rigidBody, deltaTime);
             rigidBody.clearForces();
         });
     }
-    integratePositions(deltaTimeInSeconds) {
+    integrateKinematicPositions() {
+        const deltaTime = this.time.fixedDeltaTime;
         this.actorQuery.getActors().forEach((actor) => {
             const rigidBody = actor.getComponent(RigidBody);
             const transform = actor.getComponent(Transform);
-            if (rigidBody.disabled || rigidBody.type === 'static') {
+            if (rigidBody.disabled ||
+                rigidBody.type !== 'kinematic' ||
+                (!rigidBody.linearVelocity.x && !rigidBody.linearVelocity.y)) {
                 return;
             }
-            if (rigidBody.type === 'kinematic') {
-                transform.world.position.x +=
-                    rigidBody.linearVelocity.x * deltaTimeInSeconds;
-                transform.world.position.y +=
-                    rigidBody.linearVelocity.y * deltaTimeInSeconds;
+            transform.world.position.x += rigidBody.linearVelocity.x * deltaTime;
+            transform.world.position.y += rigidBody.linearVelocity.y * deltaTime;
+        });
+    }
+    integrateDynamicPositions() {
+        const deltaTime = this.time.fixedDeltaTime;
+        this.actorQuery.getActors().forEach((actor) => {
+            const rigidBody = actor.getComponent(RigidBody);
+            const transform = actor.getComponent(Transform);
+            if (rigidBody.disabled || rigidBody.type !== 'dynamic') {
                 return;
             }
             if (rigidBody.mass <= 0 || rigidBody.sleeping) {
                 return;
             }
             transform.world.position.x +=
-                rigidBody.linearVelocity.x * deltaTimeInSeconds;
+                (rigidBody.linearVelocity.x + rigidBody._biasLinearVelocity.x) *
+                    deltaTime;
             transform.world.position.y +=
-                rigidBody.linearVelocity.y * deltaTimeInSeconds;
+                (rigidBody.linearVelocity.y + rigidBody._biasLinearVelocity.y) *
+                    deltaTime;
+            if (!rigidBody.lockRotation) {
+                transform.world.rotation +=
+                    (rigidBody.angularVelocity + rigidBody._biasAngularVelocity) *
+                        deltaTime;
+            }
         });
     }
-    update(options) {
-        const deltaTimeInSeconds = options.deltaTime / 1000;
-        this.integrateVelocities(deltaTimeInSeconds);
-        this.integratePositions(deltaTimeInSeconds);
+    updateSleepTimers() {
+        const deltaTime = this.time.fixedDeltaTime;
+        this.actorQuery.getActors().forEach((actor) => {
+            const rigidBody = actor.getComponent(RigidBody);
+            if (rigidBody.disabled ||
+                rigidBody.type !== 'dynamic' ||
+                rigidBody.mass <= 0 ||
+                !rigidBody.autoSleep) {
+                rigidBody._sleepTime = 0;
+                return;
+            }
+            if (rigidBody.sleeping) {
+                return;
+            }
+            const realMotionIsSmall = rigidBody.linearVelocity.squaredMagnitude <=
+                this.linearSleepThreshold * this.linearSleepThreshold &&
+                Math.abs(rigidBody.angularVelocity) <= this.angularSleepThreshold;
+            const biasMotionIsSmall = rigidBody._biasLinearVelocity.squaredMagnitude <=
+                this.linearSleepThreshold * this.linearSleepThreshold &&
+                Math.abs(rigidBody._biasAngularVelocity) <=
+                    this.biasAngularSleepThreshold;
+            if (!realMotionIsSmall || !biasMotionIsSmall) {
+                rigidBody._sleepTime = 0;
+                return;
+            }
+            rigidBody._sleepTime += deltaTime;
+            if (rigidBody._sleepTime >= this.sleepTimeThreshold) {
+                rigidBody.sleep();
+            }
+        });
     }
     lateUpdate() {
         this.kinematicMovedActors.forEach((actor) => {

package/build/contrib/systems/physics-system/subsystems/physics/mass-properties.d.ts

@@ -0,0 +1,2 @@
+import type { Collider, Transform } from '../../../../components';
+export declare const calculateInertia: (mass: number, collider: Collider | undefined, transform: Transform) => number;

package/build/contrib/systems/physics-system/subsystems/physics/mass-properties.js

@@ -0,0 +1,55 @@
+const getOffsetInertia = (mass, offsetX, offsetY) => {
+    return mass * (offsetX * offsetX + offsetY * offsetY);
+};
+export const calculateInertia = (mass, collider, transform) => {
+    if (mass <= 0 || !collider || collider.disabled) {
+        return 0;
+    }
+    const scaleX = Math.abs(transform.world.scale.x);
+    const scaleY = Math.abs(transform.world.scale.y);
+    const offsetX = collider.offset.x * scaleX;
+    const offsetY = collider.offset.y * scaleY;
+    let inertia = 0;
+    switch (collider.shape.type) {
+        case 'circle': {
+            const radius = collider.shape.radius * Math.max(scaleX, scaleY);
+            if (radius <= 0) {
+                return 0;
+            }
+            inertia = 0.5 * mass * radius * radius;
+            break;
+        }
+        case 'box': {
+            const width = collider.shape.size.x * scaleX;
+            const height = collider.shape.size.y * scaleY;
+            if (width <= 0 || height <= 0) {
+                return 0;
+            }
+            inertia = (mass * (width * width + height * height)) / 12;
+            break;
+        }
+        case 'capsule': {
+            const radius = collider.shape.radius * Math.max(scaleX, scaleY);
+            const width = radius * 2;
+            const height = collider.shape.height * scaleY + width;
+            if (radius <= 0 || height <= 0) {
+                return 0;
+            }
+            inertia = (mass * (width * width + height * height)) / 12;
+            break;
+        }
+        case 'segment': {
+            const point1 = collider.shape.point1;
+            const point2 = collider.shape.point2;
+            const dx = (point2.x - point1.x) * scaleX;
+            const dy = (point2.y - point1.y) * scaleY;
+            const length = Math.sqrt(dx * dx + dy * dy);
+            if (length <= 0) {
+                return 0;
+            }
+            inertia = (mass * length * length) / 12;
+            break;
+        }
+    }
+    return inertia + getOffsetInertia(mass, offsetX, offsetY);
+};

package/build/contrib/systems/physics-system/tests/helpers.d.ts

@@ -1,13 +1,16 @@
 import { Actor } from '../../../../engine/actor';
 import { Scene } from '../../../../engine/scene';
 import { World } from '../../../../engine/world';
+import { Time } from '../../../../engine/time';
 import { Collider } from '../../../components';
 import { PhysicsSystem } from '../index';
-import type { PhysicsSettings } from '../types';
+import type { PhysicsSettings, PhysicsSystemOptions } from '../types';
+export declare const createTime: (fixedDeltaTime?: number) => Time;
 export declare const createScene: () => Scene;
-export declare const createPhysicsSystem: (scene: Scene, settings?: PhysicsSettings, gravityY?: number, gravityX?: number) => {
+export declare const createPhysicsSystem: (scene: Scene, settings?: PhysicsSettings, gravityY?: number, gravityX?: number, solverOptions?: Partial<Pick<PhysicsSystemOptions, 'solverIterations' | 'linearSleepThreshold' | 'angularSleepThreshold' | 'sleepTimeThreshold' | 'maxAllowedPenetration' | 'maxBiasVelocity'>>) => {
     physicsSystem: PhysicsSystem;
     world: World;
+    time: Time;
 };
 export declare const createBoxActor: (id: string, type: 'dynamic' | 'static' | 'kinematic', positionX: number, positionY: number, colliderConfig?: {
     layer: string;

package/build/contrib/systems/physics-system/tests/helpers.js

@@ -2,9 +2,15 @@ import { ActorCreator, ActorSpawner, Actor } from '../../../../engine/actor';
 import { Scene } from '../../../../engine/scene';
 import { TemplateCollection } from '../../../../engine/template';
 import { World } from '../../../../engine/world';
+import { Time } from '../../../../engine/time';
 import { Collider, RigidBody } from '../../../components';
 import { Transform } from '../../../components/transform';
 import { PhysicsSystem } from '../index';
+export const createTime = (fixedDeltaTime = 0.1) => {
+    const time = new Time();
+    time.fixedDeltaTime = fixedDeltaTime;
+    return time;
+};
 export const createScene = () => {
     const templateCollection = new TemplateCollection();
     const actorCreator = new ActorCreator([], templateCollection);
@@ -16,10 +22,11 @@ export const createScene = () => {
         templateCollection,
     });
 };
-export const createPhysicsSystem = (scene, settings, gravityY = 0, gravityX = 0) => {
+export const createPhysicsSystem = (scene, settings, gravityY = 0, gravityX = 0, solverOptions = {}) => {
     const world = new World({ id: 'world', name: 'world' });
     const templateCollection = new TemplateCollection();
     const actorCreator = new ActorCreator([], templateCollection);
+    const time = createTime();
     world.appendChild(scene);
     const physicsSystem = new PhysicsSystem({
         scene,
@@ -29,9 +36,11 @@ export const createPhysicsSystem = (scene, settings, gravityY = 0, gravityX = 0)
         actorSpawner: new ActorSpawner(actorCreator),
         globalOptions: settings ? { physics: settings } : {},
         templateCollection,
+        time,
+        ...solverOptions,
     });
     physicsSystem.onSceneEnter?.();
-    return { physicsSystem, world };
+    return { physicsSystem, world, time };
 };
 export const createBoxActor = (id, type, positionX, positionY, colliderConfig = { layer: 'default', oneWay: false }) => {
     const actor = new Actor({ id, name: id });

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

@@ -2,8 +2,14 @@ import type { SceneSystemOptions } from '../../../engine/system';
 import type { Actor } from '../../../engine/actor';
 import type { Vector2, Point } from '../../../engine/math-lib';
 export interface PhysicsSystemOptions extends SceneSystemOptions {
-    gravityX: number;
-    gravityY: number;
+    gravityX?: number;
+    gravityY?: number;
+    solverIterations?: number;
+    linearSleepThreshold?: number;
+    angularSleepThreshold?: number;
+    sleepTimeThreshold?: number;
+    maxAllowedPenetration?: number;
+    maxBiasVelocity?: number;
 }
 export interface CollisionLayer {
     id: string;
@@ -18,6 +24,14 @@ export interface PhysicsQueryFilter<T> {
     layer?: string;
     excludeActors?: Actor[];
     actorFilter?: (actor: Actor) => boolean;
+    /**
+     * Called once per candidate hit to decide whether to keep it.
+     *
+     * The `hit` object passed to this callback may be reused and is only valid
+     * for the duration of the call.
+     * Inspect it and return a boolean; do not retain the reference or store it
+     * in an external collection.
+     */
     hitFilter?: (hit: T) => boolean;
 }
 export interface CommonCastParams extends PhysicsQueryFilter<CastHit> {
@@ -39,6 +53,8 @@ export interface OverlapHit {
     penetration: number;
     contactPoints: Point[];
 }
+export type CastHitCallback = (hit: CastHit) => void;
+export type OverlapHitCallback = (hit: OverlapHit) => void;
 export interface PointQueryShape {
     type: 'point';
     point: Point;

package/build/contrib/systems/renderer/actor-render-tree.js

@@ -1,6 +1,7 @@
 import { Container } from 'pixi.js';
 import { Actor } from '../../../engine/actor';
 import { Transform } from '../../components/transform';
+import { Interpolation } from '../../components/interpolation';
 import { Sprite } from '../../components/sprite';
 import { Shape } from '../../components/shape';
 import { PixiView } from '../../components/pixi-view';
@@ -146,17 +147,25 @@ export class ActorRenderTree {
         this.actorParentMap.set(actor, actor.parent);
     }
     updatePosition(container, actor) {
-        const { local: { position, rotation, scale }, } = actor.getComponent(Transform);
+        const { local } = actor.getComponent(Transform);
+        const interpolation = actor.getComponent(Interpolation);
+        const useRender = interpolation !== undefined &&
+            !interpolation.disabled &&
+            interpolation.initialized;
+        const positionX = useRender ? interpolation.renderX : local.position.x;
+        const positionY = useRender ? interpolation.renderY : local.position.y;
+        const rotation = useRender ? interpolation.renderRotation : local.rotation;
+        const { scale } = local;
         const meta = container.__dacha.meta;
         if (rotation !== meta.rotation) {
             container.rotation = rotation;
             meta.rotation = rotation;
         }
-        if (!floatEquals(position.x, meta.positionX) ||
-            !floatEquals(position.y, meta.positionY)) {
-            container.position.set(position.x, position.y);
-            meta.positionX = position.x;
-            meta.positionY = position.y;
+        if (!floatEquals(positionX, meta.positionX) ||
+            !floatEquals(positionY, meta.positionY)) {
+            container.position.set(positionX, positionY);
+            meta.positionX = positionX;
+            meta.positionY = positionY;
         }
         if (scale.x !== meta.scaleX || scale.y !== meta.scaleY) {
             container.scale.set(scale.x, scale.y);

package/build/contrib/systems/renderer/filters/index.d.ts

@@ -1,5 +1,5 @@
 import { type Application } from 'pixi.js';
-import type { Time } from '../types';
+import type { Time } from '../../../../engine/time';
 import type { FilterEffectConstructor, FilterEffectConfig } from './filter-effect';
 export interface FiltersSystemOptions {
     application: Application;

package/build/contrib/systems/renderer/filters/index.js

@@ -58,7 +58,7 @@ export class FilterSystem {
             }
         });
         this.filtersMap.forEach((filter, config) => {
-            this.effects[config.name]?.update?.(filter, config.options, this.time.elapsed);
+            this.effects[config.name]?.update?.(filter, config.options, this.time.elapsedTime);
         });
     }
 }