dacha 0.18.0-alpha.9 → 0.18.1

package/build/contrib/systems/index.js

@@ -4,6 +4,7 @@ export { GameStatsMeter } from './game-stats-meter';
 export { KeyboardInputSystem } from './keyboard-input-system';
 export { KeyboardControlSystem } from './keyboard-control-system';
 export { CharacterController } from './character-controller';
+export { Interpolator, InterpolatorAPI } from './interpolator';
 export { MouseControlSystem } from './mouse-control-system';
 export { MouseInputSystem } from './mouse-input-system';
 export { PhysicsSystem, PhysicsAPI } from './physics-system';

package/build/contrib/systems/interpolator/api.d.ts

@@ -0,0 +1,40 @@
+import type { Actor } from '../../../engine/actor';
+import type { Time } from '../../../engine/time';
+export interface RenderTransform {
+    x: number;
+    y: number;
+    rotation: number;
+}
+interface InterpolatorAPIOptions {
+    time: Time;
+}
+/**
+ * Public API for reading render-facing (visually smoothed) transforms.
+ *
+ * Retrieve it via `world.systemApi.get(InterpolatorAPI)`. Use it in
+ * systems and behaviors that position visuals against moving actors —
+ * e.g. a camera-follow script — instead of reading the authoritative
+ * Transform, which advances in fixed steps.
+ *
+ * Values are computed from the current `Time.alpha`, so this API is only
+ * meaningful during the update phase (not inside `fixedUpdate`).
+ *
+ * @category Systems
+ */
+export declare class InterpolatorAPI {
+    private time;
+    constructor(options: InterpolatorAPIOptions);
+    /**
+     * Returns the world-space transform the actor is rendered with this
+     * frame. Falls back to the Transform for actors (and
+     * ancestors) without an active Interpolation component.
+     */
+    getRenderTransform(actor: Actor): RenderTransform;
+    /**
+     * Requests an immediate visual jump to the actor's
+     * Transform. Call right after teleporting the actor.
+     */
+    snap(actor: Actor): void;
+    private composeRenderWorldMatrix;
+}
+export {};

package/build/contrib/systems/interpolator/api.js

@@ -0,0 +1,70 @@
+import { Matrix } from '../../../engine/math-lib';
+import { Interpolation } from '../../components/interpolation';
+import { Transform } from '../../components/transform';
+import { computeRenderValues } from './utils';
+/**
+ * Public API for reading render-facing (visually smoothed) transforms.
+ *
+ * Retrieve it via `world.systemApi.get(InterpolatorAPI)`. Use it in
+ * systems and behaviors that position visuals against moving actors —
+ * e.g. a camera-follow script — instead of reading the authoritative
+ * Transform, which advances in fixed steps.
+ *
+ * Values are computed from the current `Time.alpha`, so this API is only
+ * meaningful during the update phase (not inside `fixedUpdate`).
+ *
+ * @category Systems
+ */
+export class InterpolatorAPI {
+    time;
+    constructor(options) {
+        this.time = options.time;
+    }
+    /**
+     * Returns the world-space transform the actor is rendered with this
+     * frame. Falls back to the Transform for actors (and
+     * ancestors) without an active Interpolation component.
+     */
+    getRenderTransform(actor) {
+        const matrix = this.composeRenderWorldMatrix(actor);
+        return {
+            x: matrix.tx,
+            y: matrix.ty,
+            rotation: Math.atan2(matrix.b, matrix.a),
+        };
+    }
+    /**
+     * Requests an immediate visual jump to the actor's
+     * Transform. Call right after teleporting the actor.
+     */
+    snap(actor) {
+        const interpolation = actor.getComponent(Interpolation);
+        interpolation?.snap();
+    }
+    composeRenderWorldMatrix(actor) {
+        const transform = actor.getComponent(Transform);
+        const interpolation = actor.getComponent(Interpolation);
+        const useRender = interpolation !== undefined &&
+            !interpolation.disabled &&
+            interpolation.initialized;
+        if (useRender) {
+            computeRenderValues(actor, interpolation, this.time.alpha, this.time.fixedDeltaTime);
+        }
+        const x = useRender ? interpolation.renderX : transform.local.position.x;
+        const y = useRender ? interpolation.renderY : transform.local.position.y;
+        const rotation = useRender
+            ? interpolation.renderRotation
+            : transform.local.rotation;
+        const { scale } = transform.local;
+        const cos = Math.cos(rotation);
+        const sin = Math.sin(rotation);
+        const localMatrix = new Matrix(cos * scale.x, sin * scale.x, -sin * scale.y, cos * scale.y, x, y);
+        const parentTransform = transform.getParentComponent();
+        if (!parentTransform?.actor) {
+            return localMatrix;
+        }
+        const result = new Matrix(1, 0, 0, 1, 0, 0);
+        Matrix.multiply(result, this.composeRenderWorldMatrix(parentTransform.actor), localMatrix);
+        return result;
+    }
+}

package/build/contrib/systems/interpolator/index.d.ts

@@ -0,0 +1,3 @@
+export { Interpolator } from './system';
+export { InterpolatorAPI } from './api';
+export type { RenderTransform } from './api';

package/build/contrib/systems/interpolator/index.js

@@ -0,0 +1,2 @@
+export { Interpolator } from './system';
+export { InterpolatorAPI } from './api';

package/build/contrib/systems/interpolator/system.d.ts

@@ -0,0 +1,31 @@
+import { SceneSystem } from '../../../engine/system';
+import type { SceneSystemOptions } from '../../../engine/system';
+/**
+ * System that produces smooth render-facing transforms for actors moved
+ * during fixed updates.
+ *
+ * During `fixedUpdate` it snapshots the local Transform of every actor with
+ * an Interpolation component. During `update` it blends the last two
+ * snapshots using `Time.alpha` and writes the result into the component's
+ * `renderX`/`renderY`/`renderRotation`, which the renderer prefers over the
+ * Transform.
+ *
+ * Ordering: place this system AFTER every system that moves transforms in
+ * fixed updates (`PhysicsSystem`, `CharacterController`, behavior scripts
+ * that move actors in `fixedUpdate`) and BEFORE `Renderer` in the system
+ * configuration.
+ *
+ * @category Systems
+ */
+export declare class Interpolator extends SceneSystem {
+    private actorQuery;
+    private time;
+    private world;
+    private api;
+    constructor(options: SceneSystemOptions);
+    onSceneEnter(): void;
+    onSceneExit(): void;
+    onSceneDestroy(): void;
+    fixedUpdate(): void;
+    update(): void;
+}

package/build/contrib/systems/interpolator/system.js

@@ -0,0 +1,96 @@
+import { ActorQuery } from '../../../engine/actor';
+import { SceneSystem } from '../../../engine/system';
+import { Interpolation } from '../../components/interpolation';
+import { Transform } from '../../components/transform';
+import { InterpolatorAPI } from './api';
+import { snapToTransform, computeRenderValues } from './utils';
+/**
+ * System that produces smooth render-facing transforms for actors moved
+ * during fixed updates.
+ *
+ * During `fixedUpdate` it snapshots the local Transform of every actor with
+ * an Interpolation component. During `update` it blends the last two
+ * snapshots using `Time.alpha` and writes the result into the component's
+ * `renderX`/`renderY`/`renderRotation`, which the renderer prefers over the
+ * Transform.
+ *
+ * Ordering: place this system AFTER every system that moves transforms in
+ * fixed updates (`PhysicsSystem`, `CharacterController`, behavior scripts
+ * that move actors in `fixedUpdate`) and BEFORE `Renderer` in the system
+ * configuration.
+ *
+ * @category Systems
+ */
+export class Interpolator extends SceneSystem {
+    actorQuery;
+    time;
+    world;
+    api;
+    constructor(options) {
+        super();
+        this.time = options.time;
+        this.world = options.world;
+        this.actorQuery = new ActorQuery({
+            scene: options.scene,
+            filter: [Interpolation, Transform],
+        });
+        this.api = new InterpolatorAPI({ time: options.time });
+    }
+    onSceneEnter() {
+        this.world.systemApi.register(this.api);
+    }
+    onSceneExit() {
+        this.world.systemApi.unregister(InterpolatorAPI);
+    }
+    onSceneDestroy() {
+        this.actorQuery.destroy();
+    }
+    fixedUpdate() {
+        for (const actor of this.actorQuery.getActors()) {
+            const interpolation = actor.getComponent(Interpolation);
+            const { local } = actor.getComponent(Transform);
+            if (interpolation.disabled) {
+                interpolation._initialized = false;
+                continue;
+            }
+            if (!interpolation._initialized || interpolation._snapRequested) {
+                snapToTransform(interpolation, local);
+                continue;
+            }
+            interpolation._prevX = interpolation._currX;
+            interpolation._prevY = interpolation._currY;
+            interpolation._prevRotation = interpolation._currRotation;
+            interpolation._currX = local.position.x;
+            interpolation._currY = local.position.y;
+            interpolation._currRotation = local.rotation;
+            const threshold = interpolation.snapThreshold;
+            if (threshold > 0) {
+                const dx = interpolation._currX - interpolation._prevX;
+                const dy = interpolation._currY - interpolation._prevY;
+                if (dx * dx + dy * dy > threshold * threshold) {
+                    interpolation._prevX = interpolation._currX;
+                    interpolation._prevY = interpolation._currY;
+                    interpolation._prevRotation = interpolation._currRotation;
+                }
+            }
+        }
+    }
+    update() {
+        const { alpha, fixedDeltaTime } = this.time;
+        for (const actor of this.actorQuery.getActors()) {
+            const interpolation = actor.getComponent(Interpolation);
+            if (interpolation.disabled) {
+                continue;
+            }
+            if (interpolation._snapRequested) {
+                snapToTransform(interpolation, actor.getComponent(Transform).local);
+                continue;
+            }
+            if (!interpolation._initialized) {
+                continue;
+            }
+            computeRenderValues(actor, interpolation, alpha, fixedDeltaTime);
+        }
+    }
+}
+Interpolator.systemName = 'Interpolator';

package/build/contrib/systems/interpolator/tests/helpers.d.ts

@@ -0,0 +1,13 @@
+import { Actor } from '../../../../engine/actor';
+import { Scene } from '../../../../engine/scene';
+import { World } from '../../../../engine/world';
+import { Time } from '../../../../engine/time';
+import type { InterpolationConfig } from '../../../components/interpolation';
+import { Interpolator } from '../system';
+export declare const createScene: () => Scene;
+export declare const createInterpolator: (scene: Scene) => {
+    system: Interpolator;
+    world: World;
+    time: Time;
+};
+export declare const createInterpolatedActor: (id: string, x: number, y: number, config?: InterpolationConfig) => Actor;

package/build/contrib/systems/interpolator/tests/helpers.js

@@ -0,0 +1,45 @@
+import { Actor, ActorCreator, ActorSpawner } from '../../../../engine/actor';
+import { Scene } from '../../../../engine/scene';
+import { TemplateCollection } from '../../../../engine/template';
+import { World } from '../../../../engine/world';
+import { Time } from '../../../../engine/time';
+import { Interpolation } from '../../../components/interpolation';
+import { Transform } from '../../../components/transform';
+import { Interpolator } from '../system';
+export const createScene = () => {
+    const templateCollection = new TemplateCollection();
+    const actorCreator = new ActorCreator([], templateCollection);
+    return new Scene({
+        id: 'scene',
+        name: 'scene',
+        actors: [],
+        actorCreator,
+        templateCollection,
+    });
+};
+export const createInterpolator = (scene) => {
+    const world = new World({ id: 'world', name: 'world' });
+    const templateCollection = new TemplateCollection();
+    const actorCreator = new ActorCreator([], templateCollection);
+    const time = new Time();
+    time.fixedDeltaTime = 0.1;
+    world.appendChild(scene);
+    const system = new Interpolator({
+        scene,
+        world,
+        actorSpawner: new ActorSpawner(actorCreator),
+        globalOptions: {},
+        templateCollection,
+        time,
+    });
+    system.onSceneEnter?.();
+    return { system, world, time };
+};
+export const createInterpolatedActor = (id, x, y, config = {}) => {
+    const actor = new Actor({ id, name: id });
+    const transform = actor.getComponent(Transform);
+    transform.local.position.x = x;
+    transform.local.position.y = y;
+    actor.setComponent(new Interpolation(config));
+    return actor;
+};

package/build/contrib/systems/interpolator/utils.d.ts

@@ -0,0 +1,5 @@
+import type { Actor } from '../../../engine/actor';
+import type { Interpolation } from '../../components/interpolation';
+import type { LocalTransform } from '../../components/transform/local-transform';
+export declare const snapToTransform: (interpolation: Interpolation, local: LocalTransform) => void;
+export declare const computeRenderValues: (actor: Actor, interpolation: Interpolation, alpha: number, fixedDeltaTime: number) => void;

package/build/contrib/systems/interpolator/utils.js

@@ -0,0 +1,41 @@
+import { MathOps } from '../../../engine/math-lib';
+import { RigidBody } from '../../components/rigid-body';
+export const snapToTransform = (interpolation, local) => {
+    interpolation._prevX = local.position.x;
+    interpolation._prevY = local.position.y;
+    interpolation._prevRotation = local.rotation;
+    interpolation._currX = local.position.x;
+    interpolation._currY = local.position.y;
+    interpolation._currRotation = local.rotation;
+    interpolation.renderX = local.position.x;
+    interpolation.renderY = local.position.y;
+    interpolation.renderRotation = local.rotation;
+    interpolation._initialized = true;
+    interpolation._snapRequested = false;
+};
+export const computeRenderValues = (actor, interpolation, alpha, fixedDeltaTime) => {
+    if (interpolation.mode === 'extrapolate') {
+        const rigidBody = actor.getComponent(RigidBody);
+        if (rigidBody !== undefined && !rigidBody.disabled) {
+            const timeAhead = alpha * fixedDeltaTime;
+            interpolation.renderX =
+                interpolation._currX + rigidBody.linearVelocity.x * timeAhead;
+            interpolation.renderY =
+                interpolation._currY + rigidBody.linearVelocity.y * timeAhead;
+            interpolation.renderRotation = rigidBody.lockRotation
+                ? interpolation._currRotation
+                : interpolation._currRotation + rigidBody.angularVelocity * timeAhead;
+            return;
+        }
+    }
+    interpolation.renderX =
+        interpolation._prevX +
+            (interpolation._currX - interpolation._prevX) * alpha;
+    interpolation.renderY =
+        interpolation._prevY +
+            (interpolation._currY - interpolation._prevY) * alpha;
+    interpolation.renderRotation =
+        interpolation._prevRotation +
+            MathOps.getAngleDelta(interpolation._prevRotation, interpolation._currRotation) *
+                alpha;
+};

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

@@ -1,5 +1,5 @@
 import type { Vector2 } from '../../../engine/math-lib';
-import type { CastHit, OverlapHit, RaycastParams, OverlapParams, OverlapActorParams, ShapeCastParams, CastActorParams } from './types';
+import type { CastHit, OverlapHit, RaycastParams, OverlapParams, OverlapActorParams, ShapeCastParams, CastActorParams, CastHitCallback, OverlapHitCallback } from './types';
 export interface PhysicsAPIHandlers {
     raycast(params: RaycastParams): CastHit | null;
     raycastAll(params: RaycastParams): CastHit[];
@@ -9,6 +9,11 @@ export interface PhysicsAPIHandlers {
     shapeCastAll(params: ShapeCastParams): CastHit[];
     castActor(params: CastActorParams): CastHit | null;
     castActorAll(params: CastActorParams): CastHit[];
+    raycastEach(params: RaycastParams, callback: CastHitCallback): void;
+    shapeCastEach(params: ShapeCastParams, callback: CastHitCallback): void;
+    overlapEach(params: OverlapParams, callback: OverlapHitCallback): void;
+    castActorEach(params: CastActorParams, callback: CastHitCallback): void;
+    overlapActorEach(params: OverlapActorParams, callback: OverlapHitCallback): void;
     getGravity(): Vector2;
     setGravity(gravity: Vector2): void;
 }
@@ -55,6 +60,13 @@ export declare class PhysicsAPI {
      * @returns All hits sorted from nearest to farthest
      */
     raycastAll(params: RaycastParams): CastHit[];
+    /**
+     * Casts a ray and invokes `callback` for every hit.
+     *
+     * @param params - Raycast parameters
+     * @param callback - Invoked once per hit with a reused hit object
+     */
+    raycastEach(params: RaycastParams, callback: CastHitCallback): void;
     /**
      * Returns all collider intersections for the given query shape.
      *
@@ -62,6 +74,13 @@ export declare class PhysicsAPI {
      * @returns All overlap hits
      */
     overlapShape(params: OverlapParams): OverlapHit[];
+    /**
+     * Invokes `callback` for every collider intersecting the query shape.
+     *
+     * @param params - Overlap parameters
+     * @param callback - Invoked once per overlap with a reused hit object
+     */
+    overlapEach(params: OverlapParams, callback: OverlapHitCallback): void;
     /**
      * Returns all collider intersections for an actor's collider.
      *
@@ -69,6 +88,13 @@ export declare class PhysicsAPI {
      * @returns All overlap hits
      */
     overlapActor(params: OverlapActorParams): OverlapHit[];
+    /**
+     * Invokes `callback` for every collider intersecting an actor's collider.
+     *
+     * @param params - Actor overlap parameters
+     * @param callback - Invoked once per overlap with a reused hit object
+     */
+    overlapActorEach(params: OverlapActorParams, callback: OverlapHitCallback): void;
     /**
      * Casts a shape and returns the nearest hit, if any.
      *
@@ -83,6 +109,13 @@ export declare class PhysicsAPI {
      * @returns All hits sorted from nearest to farthest
      */
     shapeCastAll(params: ShapeCastParams): CastHit[];
+    /**
+     * Casts a shape and invokes `callback` for every hit.
+     *
+     * @param params - Shape cast parameters
+     * @param callback - Invoked once per hit with a reused hit object
+     */
+    shapeCastEach(params: ShapeCastParams, callback: CastHitCallback): void;
     /**
      * Casts an actor's collider and returns the nearest hit, if any.
      *
@@ -97,4 +130,15 @@ export declare class PhysicsAPI {
      * @returns All hits sorted from nearest to farthest
      */
     castActorAll(params: CastActorParams): CastHit[];
+    /**
+     * Casts an actor's collider and invokes `callback` for every hit.
+     *
+     * The `hit` passed to `callback` is a single object reused across
+     * invocations and is only valid for the duration of the call. Copy any
+     * fields you need to keep. Hits are delivered in arbitrary order.
+     *
+     * @param params - Actor cast parameters
+     * @param callback - Invoked once per hit with a reused hit object
+     */
+    castActorEach(params: CastActorParams, callback: CastHitCallback): void;
 }

package/build/contrib/systems/physics-system/api.js

@@ -51,6 +51,15 @@ export class PhysicsAPI {
     raycastAll(params) {
         return this.handlers.raycastAll(params);
     }
+    /**
+     * Casts a ray and invokes `callback` for every hit.
+     *
+     * @param params - Raycast parameters
+     * @param callback - Invoked once per hit with a reused hit object
+     */
+    raycastEach(params, callback) {
+        this.handlers.raycastEach(params, callback);
+    }
     /**
      * Returns all collider intersections for the given query shape.
      *
@@ -60,6 +69,15 @@ export class PhysicsAPI {
     overlapShape(params) {
         return this.handlers.overlapShape(params);
     }
+    /**
+     * Invokes `callback` for every collider intersecting the query shape.
+     *
+     * @param params - Overlap parameters
+     * @param callback - Invoked once per overlap with a reused hit object
+     */
+    overlapEach(params, callback) {
+        this.handlers.overlapEach(params, callback);
+    }
     /**
      * Returns all collider intersections for an actor's collider.
      *
@@ -69,6 +87,15 @@ export class PhysicsAPI {
     overlapActor(params) {
         return this.handlers.overlapActor(params);
     }
+    /**
+     * Invokes `callback` for every collider intersecting an actor's collider.
+     *
+     * @param params - Actor overlap parameters
+     * @param callback - Invoked once per overlap with a reused hit object
+     */
+    overlapActorEach(params, callback) {
+        this.handlers.overlapActorEach(params, callback);
+    }
     /**
      * Casts a shape and returns the nearest hit, if any.
      *
@@ -87,6 +114,15 @@ export class PhysicsAPI {
     shapeCastAll(params) {
         return this.handlers.shapeCastAll(params);
     }
+    /**
+     * Casts a shape and invokes `callback` for every hit.
+     *
+     * @param params - Shape cast parameters
+     * @param callback - Invoked once per hit with a reused hit object
+     */
+    shapeCastEach(params, callback) {
+        this.handlers.shapeCastEach(params, callback);
+    }
     /**
      * Casts an actor's collider and returns the nearest hit, if any.
      *
@@ -105,4 +141,17 @@ export class PhysicsAPI {
     castActorAll(params) {
         return this.handlers.castActorAll(params);
     }
+    /**
+     * Casts an actor's collider and invokes `callback` for every hit.
+     *
+     * The `hit` passed to `callback` is a single object reused across
+     * invocations and is only valid for the duration of the call. Copy any
+     * fields you need to keep. Hits are delivered in arbitrary order.
+     *
+     * @param params - Actor cast parameters
+     * @param callback - Invoked once per hit with a reused hit object
+     */
+    castActorEach(params, callback) {
+        this.handlers.castActorEach(params, callback);
+    }
 }

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

@@ -1,5 +1,5 @@
 export declare const DEFAULT_SOLVER_ITERATIONS = 8;
-export declare const DEFAULT_LINEAR_SLEEP_THRESHOLD = 2;
+export declare const DEFAULT_LINEAR_SLEEP_THRESHOLD = 1;
 export declare const DEFAULT_ANGULAR_SLEEP_THRESHOLD = 0.05;
 export declare const DEFAULT_SLEEP_TIME_THRESHOLD = 0.5;
 export declare const DEFAULT_MAX_BIAS_VELOCITY = 60;
@@ -9,3 +9,5 @@ export declare const BIAS_ANGULAR_SLEEP_MULTIPLIER = 2;
 export declare const RESTITUTION_VELOCITY_THRESHOLD = 1;
 export declare const PENETRATION_SLEEP_MARGIN = 0.25;
 export declare const SUPPORT_MIN_GRAVITY_DOT = 0.5;
+export declare const DEFAULT_GRAVITY_X = 0;
+export declare const DEFAULT_GRAVITY_Y = 980;

package/build/contrib/systems/physics-system/consts.js

@@ -1,5 +1,5 @@
 export const DEFAULT_SOLVER_ITERATIONS = 8;
-export const DEFAULT_LINEAR_SLEEP_THRESHOLD = 2;
+export const DEFAULT_LINEAR_SLEEP_THRESHOLD = 1;
 export const DEFAULT_ANGULAR_SLEEP_THRESHOLD = 0.05;
 export const DEFAULT_SLEEP_TIME_THRESHOLD = 0.5;
 export const DEFAULT_MAX_BIAS_VELOCITY = 60;
@@ -12,3 +12,6 @@ export const RESTITUTION_VELOCITY_THRESHOLD = 1;
 export const PENETRATION_SLEEP_MARGIN = 0.25;
 // 0.5 treats surfaces up to ~60° from horizontal as holding a body up.
 export const SUPPORT_MIN_GRAVITY_DOT = 0.5;
+// Default gravity in world units (px/s²).
+export const DEFAULT_GRAVITY_X = 0;
+export const DEFAULT_GRAVITY_Y = 980;

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

@@ -2,6 +2,7 @@ import { SceneSystem } from '../../../engine/system';
 import { Vector2 } from '../../../engine/math-lib';
 import { PhysicsSubsystem, CollisionDetectionSubsystem, CollisionBroadcastSubsystem, ConstraintSolver, } from './subsystems';
 import { PhysicsAPI } from './api';
+import { DEFAULT_GRAVITY_X, DEFAULT_GRAVITY_Y } from './consts';
 /**
  * Physics system that handles 2D physics simulation and collision detection
  *
@@ -21,7 +22,7 @@ export class PhysicsSystem extends SceneSystem {
     gravity;
     constructor(options) {
         super();
-        const { gravityX = 0, gravityY = 0, solverIterations, linearSleepThreshold, angularSleepThreshold, sleepTimeThreshold, maxAllowedPenetration, maxBiasVelocity, } = options;
+        const { gravityX = DEFAULT_GRAVITY_X, gravityY = DEFAULT_GRAVITY_Y, solverIterations, linearSleepThreshold, angularSleepThreshold, sleepTimeThreshold, maxAllowedPenetration, maxBiasVelocity, } = options;
         this.gravity = new Vector2(gravityX, gravityY);
         this.world = options.world;
         this.physicsSubsystem = new PhysicsSubsystem({
@@ -51,6 +52,11 @@ export class PhysicsSystem extends SceneSystem {
             shapeCastAll: (params) => this.collisionDetectionSubsystem.shapeCastAll(params),
             castActor: (params) => this.collisionDetectionSubsystem.castActor(params),
             castActorAll: (params) => this.collisionDetectionSubsystem.castActorAll(params),
+            raycastEach: (params, callback) => this.collisionDetectionSubsystem.raycastEach(params, callback),
+            shapeCastEach: (params, callback) => this.collisionDetectionSubsystem.shapeCastEach(params, callback),
+            overlapEach: (params, callback) => this.collisionDetectionSubsystem.overlapEach(params, callback),
+            castActorEach: (params, callback) => this.collisionDetectionSubsystem.castActorEach(params, callback),
+            overlapActorEach: (params, callback) => this.collisionDetectionSubsystem.overlapActorEach(params, callback),
             getGravity: () => this.gravity,
             setGravity: (gravity) => {
                 this.gravity = gravity;

package/build/contrib/systems/physics-system/subsystems/collision-detection/dynamic-aabb-tree/index.d.ts

@@ -4,7 +4,7 @@ export declare class DynamicAABBTree<T> {
     private root;
     private nodesById;
     private freeInternalNodes;
-    private queryStack;
+    private stackPool;
     private nextId;
     get size(): number;
     insert(aabb: AABB, value: T): DynamicAABBTreeEntryId;

package/build/contrib/systems/physics-system/subsystems/collision-detection/dynamic-aabb-tree/index.js

@@ -1,3 +1,4 @@
+import { Pool } from '../../../../../../engine/data-lib';
 const isLeaf = (node) => node.child1 === null;
 const createAABB = () => ({
     min: { x: 0, y: 0 },
@@ -26,7 +27,9 @@ export class DynamicAABBTree {
     root = null;
     nodesById = new Map();
     freeInternalNodes = [];
-    queryStack = [];
+    stackPool = new Pool(() => [], (stack) => {
+        stack.length = 0;
+    });
     nextId = 1;
     get size() {
         return this.nodesById.size;
@@ -52,22 +55,25 @@ export class DynamicAABBTree {
         if (!this.root) {
             return;
         }
-        const stack = this.queryStack;
-        stack.length = 0;
+        const stack = this.stackPool.acquire();
         stack.push(this.root);
-        while (stack.length > 0) {
-            const node = stack.pop();
-            if (!overlaps(node.aabb, aabb)) {
-                continue;
-            }
-            if (isLeaf(node)) {
-                if (visitor(node.value) === false) {
-                    stack.length = 0;
-                    return;
+        try {
+            while (stack.length > 0) {
+                const node = stack.pop();
+                if (!overlaps(node.aabb, aabb)) {
+                    continue;
                 }
-                continue;
+                if (isLeaf(node)) {
+                    if (visitor(node.value) === false) {
+                        return;
+                    }
+                    continue;
+                }
+                stack.push(node.child1, node.child2);
             }
-            stack.push(node.child1, node.child2);
+        }
+        finally {
+            this.stackPool.release(stack);
         }
     }
     queryAll(aabb, output = []) {
@@ -80,7 +86,7 @@ export class DynamicAABBTree {
         this.root = null;
         this.nodesById.clear();
         this.freeInternalNodes.length = 0;
-        this.queryStack.length = 0;
+        this.stackPool.clear();
     }
     createNode(aabb, value) {
         return {