dacha 0.18.0-alpha.9 → 0.18.0

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 {

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

@@ -1,16 +1,17 @@
 import type { SceneSystemOptions } from '../../../../../engine/system';
-import type { RaycastParams, CastHit, OverlapHit, OverlapParams, OverlapActorParams, ShapeCastParams, CastActorParams } from '../../types';
+import type { RaycastParams, CastHit, OverlapHit, OverlapParams, OverlapActorParams, ShapeCastParams, CastActorParams, CastHitCallback, OverlapHitCallback } from '../../types';
 import type { Contact } from './types';
 export declare class CollisionDetectionSubsystem {
     private actorQuery;
-    private axis;
     private queryTree;
     private proxiesByActorId;
     private proxyPairs;
     private contacts;
     private actorIdsToDelete;
     private collisionMatrix;
-    private queryCandidates;
+    private candidateBufferPool;
+    private castHitPool;
+    private overlapHitPool;
     constructor(options: SceneSystemOptions);
     destroy(): void;
     raycast(params: RaycastParams): CastHit | null;
@@ -21,21 +22,20 @@ export declare class CollisionDetectionSubsystem {
     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;
     private handleActorAdd;
     private handleActorRemove;
     private checkOnReorientation;
     private addProxy;
     private updateProxy;
-    private addToSortedList;
-    private updateSortedList;
-    private clearSortedList;
-    private getAxes;
-    private areStaticBodies;
-    private testAABB;
     private testCollisionLayers;
-    private testState;
+    private withCandidates;
     private collectQueryCandidates;
-    private sweepAndPrune;
+    private collectPairs;
     private checkOnIntersection;
     private storeContact;
     private clearDeletedProxies;