dacha 0.18.0-alpha.8 → 0.18.0

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

@@ -1,47 +1,42 @@
 import { ActorQuery } from '../../../../../engine/actor';
-import { Transform, Collider, RigidBody } from '../../../../components';
+import { Transform, Collider } from '../../../../components';
 import { AddActor, RemoveActor } from '../../../../../engine/events';
-import { insertionSort } from '../../../../../engine/data-lib';
+import { Pool } from '../../../../../engine/data-lib';
 import { DynamicAABBTree } from './dynamic-aabb-tree';
 import { geometryBuilders } from './geometry-builders';
 import { aabbBuilders } from './aabb-builders';
 import { intersectionCheckers } from './intersection-checkers';
-import { DispersionCalculator } from './dispersion-calculator';
 import { checkTransform, checkCollider, getOrientationData, } from './reorientation-checkers';
-import { buildQueryProxy, buildActorQueryProxy, raycast, raycastAll, overlap, getOverlapQueryType, shapeCast, shapeCastAll, getShapeCastQueryType, getActorCastQueryType, } from './query-utils';
+import { buildQueryProxy, buildActorQueryProxy, raycast, raycastAll, raycastEach, overlap, overlapEach, getOverlapQueryType, shapeCast, shapeCastAll, shapeCastEach, getShapeCastQueryType, getActorCastQueryType, makeCastHit, makeOverlapHit, } from './query-utils';
+import { isStatic, isDisabled } from './utils';
 export class CollisionDetectionSubsystem {
     actorQuery;
-    axis;
     queryTree;
     proxiesByActorId;
     proxyPairs;
     contacts;
     actorIdsToDelete;
     collisionMatrix;
-    queryCandidates;
+    candidateBufferPool;
+    castHitPool;
+    overlapHitPool;
     constructor(options) {
         const settings = options.globalOptions.physics;
         this.actorQuery = new ActorQuery({
             scene: options.scene,
             filter: [Collider, Transform],
         });
-        this.axis = {
-            x: {
-                sortedList: [],
-                dispersionCalculator: new DispersionCalculator('x'),
-            },
-            y: {
-                sortedList: [],
-                dispersionCalculator: new DispersionCalculator('y'),
-            },
-        };
         this.queryTree = new DynamicAABBTree();
         this.proxiesByActorId = new Map();
         this.proxyPairs = [];
         this.contacts = [];
         this.actorIdsToDelete = new Set();
         this.collisionMatrix = settings?.collisionMatrix ?? {};
-        this.queryCandidates = [];
+        this.candidateBufferPool = new Pool(() => [], (buffer) => {
+            buffer.length = 0;
+        });
+        this.castHitPool = new Pool(makeCastHit);
+        this.overlapHitPool = new Pool(makeOverlapHit);
         this.actorQuery.getActors().forEach((actor) => this.addProxy(actor));
         this.actorQuery.addEventListener(AddActor, this.handleActorAdd);
         this.actorQuery.addEventListener(RemoveActor, this.handleActorRemove);
@@ -54,18 +49,15 @@ export class CollisionDetectionSubsystem {
     }
     raycast(params) {
         const queryProxy = buildQueryProxy('ray', params);
-        this.collectQueryCandidates(queryProxy);
-        return raycast(queryProxy, this.queryCandidates);
+        return this.withCandidates(queryProxy, (candidates) => raycast(queryProxy, candidates));
     }
     raycastAll(params) {
         const queryProxy = buildQueryProxy('ray', params);
-        this.collectQueryCandidates(queryProxy);
-        return raycastAll(queryProxy, this.queryCandidates);
+        return this.withCandidates(queryProxy, (candidates) => raycastAll(queryProxy, candidates));
     }
     overlapShape(params) {
         const queryProxy = buildQueryProxy(params.shape.type, params);
-        this.collectQueryCandidates(queryProxy);
-        return overlap(params.shape.type, queryProxy, this.queryCandidates);
+        return this.withCandidates(queryProxy, (candidates) => overlap(params.shape.type, queryProxy, candidates));
     }
     overlapActor(params) {
         const queryType = getOverlapQueryType(params);
@@ -73,20 +65,17 @@ export class CollisionDetectionSubsystem {
             return [];
         }
         const queryProxy = buildActorQueryProxy(queryType, params);
-        this.collectQueryCandidates(queryProxy);
-        return overlap(queryType, queryProxy, this.queryCandidates);
+        return this.withCandidates(queryProxy, (candidates) => overlap(queryType, queryProxy, candidates));
     }
     shapeCast(params) {
         const queryType = getShapeCastQueryType(params);
         const queryProxy = buildQueryProxy(queryType, params);
-        this.collectQueryCandidates(queryProxy);
-        return shapeCast(queryType, queryProxy, this.queryCandidates);
+        return this.withCandidates(queryProxy, (candidates) => shapeCast(queryType, queryProxy, candidates));
     }
     shapeCastAll(params) {
         const queryType = getShapeCastQueryType(params);
         const queryProxy = buildQueryProxy(queryType, params);
-        this.collectQueryCandidates(queryProxy);
-        return shapeCastAll(queryType, queryProxy, this.queryCandidates);
+        return this.withCandidates(queryProxy, (candidates) => shapeCastAll(queryType, queryProxy, candidates));
     }
     castActor(params) {
         const queryType = getActorCastQueryType(params);
@@ -94,8 +83,7 @@ export class CollisionDetectionSubsystem {
             return null;
         }
         const queryProxy = buildActorQueryProxy(queryType, params);
-        this.collectQueryCandidates(queryProxy);
-        return shapeCast(queryType, queryProxy, this.queryCandidates);
+        return this.withCandidates(queryProxy, (candidates) => shapeCast(queryType, queryProxy, candidates));
     }
     castActorAll(params) {
         const queryType = getActorCastQueryType(params);
@@ -103,8 +91,76 @@ export class CollisionDetectionSubsystem {
             return [];
         }
         const queryProxy = buildActorQueryProxy(queryType, params);
-        this.collectQueryCandidates(queryProxy);
-        return shapeCastAll(queryType, queryProxy, this.queryCandidates);
+        return this.withCandidates(queryProxy, (candidates) => shapeCastAll(queryType, queryProxy, candidates));
+    }
+    raycastEach(params, callback) {
+        const queryProxy = buildQueryProxy('ray', params);
+        this.withCandidates(queryProxy, (candidates) => {
+            const hit = this.castHitPool.acquire();
+            try {
+                raycastEach(queryProxy, candidates, hit, callback);
+            }
+            finally {
+                this.castHitPool.release(hit);
+            }
+        });
+    }
+    shapeCastEach(params, callback) {
+        const queryType = getShapeCastQueryType(params);
+        const queryProxy = buildQueryProxy(queryType, params);
+        this.withCandidates(queryProxy, (candidates) => {
+            const hit = this.castHitPool.acquire();
+            try {
+                shapeCastEach(queryType, queryProxy, candidates, hit, callback);
+            }
+            finally {
+                this.castHitPool.release(hit);
+            }
+        });
+    }
+    overlapEach(params, callback) {
+        const queryProxy = buildQueryProxy(params.shape.type, params);
+        this.withCandidates(queryProxy, (candidates) => {
+            const hit = this.overlapHitPool.acquire();
+            try {
+                overlapEach(params.shape.type, queryProxy, candidates, hit, callback);
+            }
+            finally {
+                this.overlapHitPool.release(hit);
+            }
+        });
+    }
+    castActorEach(params, callback) {
+        const queryType = getActorCastQueryType(params);
+        if (!queryType) {
+            return;
+        }
+        const queryProxy = buildActorQueryProxy(queryType, params);
+        this.withCandidates(queryProxy, (candidates) => {
+            const hit = this.castHitPool.acquire();
+            try {
+                shapeCastEach(queryType, queryProxy, candidates, hit, callback);
+            }
+            finally {
+                this.castHitPool.release(hit);
+            }
+        });
+    }
+    overlapActorEach(params, callback) {
+        const queryType = getOverlapQueryType(params);
+        if (!queryType) {
+            return;
+        }
+        const queryProxy = buildActorQueryProxy(queryType, params);
+        this.withCandidates(queryProxy, (candidates) => {
+            const hit = this.overlapHitPool.acquire();
+            try {
+                overlapEach(queryType, queryProxy, candidates, hit, callback);
+            }
+            finally {
+                this.overlapHitPool.release(hit);
+            }
+        });
     }
     handleActorAdd = (event) => {
         this.addProxy(event.actor);
@@ -138,10 +194,6 @@ export class CollisionDetectionSubsystem {
             layer: collider.layer,
         };
         proxy.treeEntryId = this.queryTree.insert(aabb, proxy);
-        this.axis.x.dispersionCalculator.addToSample(aabb);
-        this.addToSortedList(proxy, 'x');
-        this.axis.y.dispersionCalculator.addToSample(aabb);
-        this.addToSortedList(proxy, 'y');
         this.proxiesByActorId.set(actor.id, proxy);
     }
     updateProxy(actor) {
@@ -150,70 +202,34 @@ export class CollisionDetectionSubsystem {
         const geometry = geometryBuilders[collider.shape.type](collider, transform);
         const aabb = aabbBuilders[collider.shape.type](geometry);
         const proxy = this.proxiesByActorId.get(actor.id);
-        const prevAABB = proxy.aabb;
         proxy.aabb = aabb;
         proxy.geometry = geometry;
         proxy.orientationData = getOrientationData(actor);
         proxy.layer = collider.layer;
         this.queryTree.update(proxy.treeEntryId, aabb);
-        this.axis.x.dispersionCalculator.removeFromSample(prevAABB);
-        this.axis.x.dispersionCalculator.addToSample(aabb);
-        this.updateSortedList(proxy, 'x');
-        this.axis.y.dispersionCalculator.removeFromSample(prevAABB);
-        this.axis.y.dispersionCalculator.addToSample(aabb);
-        this.updateSortedList(proxy, 'y');
-    }
-    addToSortedList(proxy, axis) {
-        const min = { value: proxy.aabb.min[axis], proxy };
-        const max = { value: proxy.aabb.max[axis], proxy };
-        this.axis[axis].sortedList.push(min, max);
-        proxy.edges ??= {};
-        proxy.edges[axis] = [min, max];
-    }
-    updateSortedList(proxy, axis) {
-        const [min, max] = proxy.edges[axis];
-        min.value = proxy.aabb.min[axis];
-        min.proxy = proxy;
-        max.value = proxy.aabb.max[axis];
-        max.proxy = proxy;
-    }
-    clearSortedList(axis) {
-        this.axis[axis].sortedList = this.axis[axis].sortedList.filter((item) => !this.actorIdsToDelete.has(item.proxy.actor.id));
-    }
-    getAxes() {
-        const xDispersion = this.axis.x.dispersionCalculator.getDispersion();
-        const yDispersion = this.axis.y.dispersionCalculator.getDispersion();
-        return xDispersion >= yDispersion ? ['x', 'y'] : ['y', 'x'];
-    }
-    areStaticBodies(proxy1, proxy2) {
-        const { actor: actor1 } = proxy1;
-        const { actor: actor2 } = proxy2;
-        const rigidBody1 = actor1.getComponent(RigidBody);
-        const rigidBody2 = actor2.getComponent(RigidBody);
-        return rigidBody1?.type === 'static' && rigidBody2?.type === 'static';
-    }
-    testAABB(proxy1, proxy2, axis) {
-        const aabb1 = proxy1.aabb;
-        const aabb2 = proxy2.aabb;
-        return (aabb1.max[axis] >= aabb2.min[axis] && aabb1.min[axis] <= aabb2.max[axis]);
     }
     testCollisionLayers(proxy1, proxy2) {
-        return this.collisionMatrix[proxy1.layer]?.[proxy2.layer] ?? true;
+        return (this.collisionMatrix[proxy1.layer]?.[proxy2.layer] ??
+            this.collisionMatrix[proxy2.layer]?.[proxy1.layer] ??
+            true);
     }
-    testState(proxy1, proxy2) {
-        const actor1 = 'actor' in proxy1 ? proxy1.actor : undefined;
-        const actor2 = 'actor' in proxy2 ? proxy2.actor : undefined;
-        const collider1 = actor1?.getComponent(Collider);
-        const collider2 = actor2?.getComponent(Collider);
-        return !collider1?.disabled && !collider2?.disabled;
+    withCandidates(queryProxy, run) {
+        const candidates = this.candidateBufferPool.acquire();
+        try {
+            this.collectQueryCandidates(queryProxy, candidates);
+            return run(candidates);
+        }
+        finally {
+            this.candidateBufferPool.release(candidates);
+        }
     }
-    collectQueryCandidates(queryProxy) {
+    collectQueryCandidates(queryProxy, out) {
         let candidateIndex = 0;
         this.queryTree.query(queryProxy.aabb, (proxy) => {
             if (queryProxy.excludedActors?.has(proxy.actor)) {
                 return;
             }
-            if (!this.testState(proxy, queryProxy)) {
+            if (isDisabled(proxy)) {
                 return;
             }
             if (queryProxy.layer !== undefined &&
@@ -223,44 +239,40 @@ export class CollisionDetectionSubsystem {
             if (queryProxy.actorFilter && !queryProxy.actorFilter(proxy.actor)) {
                 return;
             }
-            this.queryCandidates[candidateIndex] = proxy;
+            out[candidateIndex] = proxy;
             candidateIndex += 1;
         });
-        this.queryCandidates.length = candidateIndex;
+        out.length = candidateIndex;
     }
-    sweepAndPrune() {
-        const [mainAxis, secondAxis] = this.getAxes();
-        const { sortedList } = this.axis[mainAxis];
-        insertionSort(sortedList, (arg1, arg2) => arg1.value - arg2.value);
-        const activeProxies = new Set();
-        let proxyPairIndex = 0;
-        for (const item of sortedList) {
-            const { proxy } = item;
-            if (!activeProxies.has(proxy)) {
-                activeProxies.forEach((activeProxy) => {
-                    if (!this.testState(proxy, activeProxy)) {
-                        return;
-                    }
-                    if (!this.testAABB(proxy, activeProxy, secondAxis)) {
-                        return;
-                    }
-                    if (this.areStaticBodies(proxy, activeProxy)) {
-                        return;
-                    }
-                    if (!this.testCollisionLayers(proxy, activeProxy)) {
-                        return;
-                    }
-                    this.proxyPairs[proxyPairIndex] = [proxy, activeProxy];
-                    proxyPairIndex += 1;
-                });
-                activeProxies.add(proxy);
+    collectPairs() {
+        let pairIndex = 0;
+        this.proxiesByActorId.forEach((proxy) => {
+            if (isStatic(proxy)) {
+                return;
             }
-            else {
-                activeProxies.delete(proxy);
+            if (isDisabled(proxy)) {
+                return;
             }
-        }
-        if (this.proxyPairs.length > proxyPairIndex) {
-            this.proxyPairs.length = proxyPairIndex;
+            this.queryTree.query(proxy.aabb, (other) => {
+                if (other === proxy) {
+                    return;
+                }
+                // Deduplicate dynamic-dynamic pairs
+                if (!isStatic(other) && proxy.treeEntryId >= other.treeEntryId) {
+                    return;
+                }
+                if (isDisabled(other)) {
+                    return;
+                }
+                if (!this.testCollisionLayers(proxy, other)) {
+                    return;
+                }
+                this.proxyPairs[pairIndex] = [proxy, other];
+                pairIndex += 1;
+            });
+        });
+        if (this.proxyPairs.length > pairIndex) {
+            this.proxyPairs.length = pairIndex;
         }
     }
     checkOnIntersection(proxyPair) {
@@ -291,13 +303,9 @@ export class CollisionDetectionSubsystem {
         if (this.actorIdsToDelete.size === 0) {
             return;
         }
-        this.clearSortedList('x');
-        this.clearSortedList('y');
         this.actorIdsToDelete.forEach((id) => {
             const proxy = this.proxiesByActorId.get(id);
             this.queryTree.remove(proxy.treeEntryId);
-            this.axis.x.dispersionCalculator.removeFromSample(proxy.aabb);
-            this.axis.y.dispersionCalculator.removeFromSample(proxy.aabb);
             this.proxiesByActorId.delete(id);
         });
         this.actorIdsToDelete.clear();
@@ -310,7 +318,7 @@ export class CollisionDetectionSubsystem {
             }
             this.updateProxy(actor);
         });
-        this.sweepAndPrune();
+        this.collectPairs();
         let contactIndex = 0;
         this.proxyPairs.forEach((proxyPair) => {
             const intersection = this.checkOnIntersection(proxyPair);

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-box/check-boxes-intersection.js

@@ -1,5 +1,6 @@
 import { orientNormal } from '../common/normals';
-import { findMinBoxesOverlap, buildContactPoints } from './utils';
+import { sortPoints } from '../common/points';
+import { findMinBoxesOverlap, buildContactPoints, OVERLAP_TIE_EPSILON, } from './utils';
 /**
  * Checks box colliders for intersection.
  *
@@ -17,7 +18,7 @@ export const checkBoxesIntersection = (geometry1, geometry2) => {
     if (overlap2 === false) {
         return false;
     }
-    const isArg1Reference = overlap1.overlap <= overlap2.overlap;
+    const isArg1Reference = overlap1.overlap <= overlap2.overlap + OVERLAP_TIE_EPSILON;
     const referenceGeometry = isArg1Reference ? geometry1 : geometry2;
     const incidentGeometry = isArg1Reference ? geometry2 : geometry1;
     const referenceOverlap = isArg1Reference ? overlap1 : overlap2;
@@ -26,9 +27,10 @@ export const checkBoxesIntersection = (geometry1, geometry2) => {
     if (!isArg1Reference) {
         referenceNormal.multiplyNumber(-1);
     }
+    const contactPoints = buildContactPoints(referenceGeometry, referenceNormal, incidentGeometry);
     return {
         normal,
         penetration: referenceOverlap.overlap,
-        contactPoints: buildContactPoints(referenceGeometry, referenceNormal, incidentGeometry),
+        contactPoints: sortPoints(contactPoints, normal),
     };
 };

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

@@ -1,6 +1,7 @@
 import { Vector2 } from '../../../../../../../engine/math-lib';
 import type { BoxGeometry, Point } from '../../types';
 export declare const CONTACT_EPSILON = 0.0001;
+export declare const OVERLAP_TIE_EPSILON = 0.0001;
 export declare const MAX_CONTACT_POINTS = 2;
 export interface AxisOverlap {
     axis: Vector2;

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

@@ -1,6 +1,7 @@
 import { Vector2, VectorOps } from '../../../../../../../engine/math-lib';
 import { getProjectionOverlap, projectPolygon } from '../common/projections';
 export const CONTACT_EPSILON = 1e-4;
+export const OVERLAP_TIE_EPSILON = 1e-4;
 export const MAX_CONTACT_POINTS = 2;
 /**
  * Runs the SAT pass for one box's face normals against another box.
@@ -22,7 +23,7 @@ export const findMinBoxesOverlap = (geometry1, geometry2) => {
         if (overlap === false) {
             return false;
         }
-        if (overlap < minOverlap) {
+        if (overlap < minOverlap - OVERLAP_TIE_EPSILON) {
             minOverlap = overlap;
             bestAxis = axis;
         }

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-capsule/check-box-and-capsule-intersection.js

@@ -1,4 +1,5 @@
 import { orientNormal } from '../common/normals';
+import { sortPoints } from '../common/points';
 import { buildBoxCapsuleIntersection } from './utils';
 /**
  * Checks a box against a capsule.
@@ -23,8 +24,10 @@ export const checkBoxAndCapsuleIntersection = (box, capsule) => {
     if (!intersection) {
         return false;
     }
+    const normal = orientNormal(intersection.normal, box.center, capsule.center);
     return {
         ...intersection,
-        normal: orientNormal(intersection.normal, box.center, capsule.center),
+        normal,
+        contactPoints: sortPoints(intersection.contactPoints, normal),
     };
 };

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-segment/check-box-and-segment-intersection.js

@@ -1,5 +1,6 @@
 import { buildBoxSegmentContactPoints, findMinBoxSegmentOverlap, } from './utils';
 import { orientNormal } from '../common/normals';
+import { sortPoints } from '../common/points';
 /**
  * Checks a box against a segment.
  *
@@ -17,9 +18,10 @@ export const checkBoxAndSegmentIntersection = (box, segment) => {
     if (contactPoints.length === 0) {
         return false;
     }
+    const normal = orientNormal(overlap.axis.clone(), box.center, segment.center);
     return {
-        normal: orientNormal(overlap.axis.clone(), box.center, segment.center),
+        normal,
         penetration: overlap.overlap,
-        contactPoints,
+        contactPoints: sortPoints(contactPoints, normal),
     };
 };

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/common/points.d.ts

@@ -1,4 +1,6 @@
+import type { Vector2 } from '../../../../../../../engine/math-lib';
 import type { Point } from '../../types';
 export declare const arePointsEqual: (point1: Point, point2: Point) => boolean;
 export declare const lerpPoint: (point1: Point, point2: Point, value: number) => Point;
 export declare const getDistanceSquared: (point1: Point, point2: Point) => number;
+export declare const sortPoints: (points: Point[], normal: Vector2) => Point[];

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/common/points.js

@@ -5,3 +5,19 @@ export const lerpPoint = (point1, point2, value) => ({
     y: point1.y + (point2.y - point1.y) * value,
 });
 export const getDistanceSquared = (point1, point2) => (point1.x - point2.x) ** 2 + (point1.y - point2.y) ** 2;
+export const sortPoints = (points, normal) => {
+    if (points.length !== 2) {
+        return points;
+    }
+    const tangentX = -normal.y;
+    const tangentY = normal.x;
+    const projection1 = points[0].x * tangentX + points[0].y * tangentY;
+    const projection2 = points[1].x * tangentX + points[1].y * tangentY;
+    if (projection1 <= projection2) {
+        return points;
+    }
+    const point = points[0];
+    points[0] = points[1];
+    points[1] = point;
+    return points;
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/index.js

@@ -1,3 +1,4 @@
+import { sortPoints } from './common/points';
 import { checkBoxAndCapsuleIntersection } from './box-capsule/check-box-and-capsule-intersection';
 import { checkBoxAndCircleIntersection } from './box-circle/check-box-and-circle-intersection';
 import { checkBoxAndSegmentIntersection } from './box-segment/check-box-and-segment-intersection';
@@ -18,6 +19,7 @@ const swapArgs = (checker) => {
             return false;
         }
         intersection.normal.multiplyNumber(-1);
+        sortPoints(intersection.contactPoints, intersection.normal);
         return intersection;
     };
 };

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

@@ -5,6 +5,7 @@ import { buildCircleGeometry } from '../../geometry-builders/build-circle-geomet
 import { buildPointGeometry } from '../../geometry-builders/build-point-geometry';
 import { buildRayGeometry } from '../../geometry-builders/build-ray-geometry';
 import { buildSegmentGeometry } from '../../geometry-builders/build-segment-geometry';
+import { expectHit } from '../../tests/assertions';
 export const createBoxGeometry = (centerX, centerY, sizeX, sizeY) => {
     return createRotatedBoxGeometry(centerX, centerY, sizeX, sizeY, 0);
 };
@@ -71,20 +72,8 @@ export const expectToBeClose = (point, x, y, digits = 6) => {
     expect(point.x).toBeCloseTo(x, digits);
     expect(point.y).toBeCloseTo(y, digits);
 };
-export const expectIntersection = (intersection) => {
-    expect(intersection).not.toBe(false);
-    if (intersection === false) {
-        throw new Error('Expected intersection, received false');
-    }
-    return intersection;
-};
-export const expectCastHit = (hit) => {
-    expect(hit).not.toBe(false);
-    if (hit === false) {
-        throw new Error('Expected cast hit, received false');
-    }
-    return hit;
-};
+export const expectIntersection = (intersection) => expectHit(intersection, 'intersection');
+export const expectCastHit = (hit) => expectHit(hit, 'cast hit');
 export const sortPoints = (points) => [...points].sort((point1, point2) => {
     if (point1.x !== point2.x) {
         return point1.x - point2.x;

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

@@ -10,9 +10,14 @@ export declare function buildActorQueryProxy(type: OverlapQueryType, params: Ove
 export declare const getOverlapQueryType: (params: OverlapActorParams) => OverlapQueryType | null;
 export declare const getShapeCastQueryType: (params: ShapeCastParams) => ShapeCastQueryType;
 export declare const getActorCastQueryType: (params: CastActorParams) => ShapeCastQueryType | null;
+export declare const makeCastHit: () => CastHit;
+export declare const makeOverlapHit: () => OverlapHit;
 export declare const overlap: (type: OverlapQueryType, queryProxy: QueryProxy, proxies: Iterable<ActorProxy>) => OverlapHit[];
 export declare const raycast: (queryProxy: QueryProxy, proxies: Iterable<ActorProxy>) => CastHit | null;
 export declare const raycastAll: (queryProxy: QueryProxy, proxies: Iterable<ActorProxy>) => CastHit[];
 export declare const shapeCast: (type: ShapeCastQueryType, queryProxy: QueryProxy, proxies: Iterable<ActorProxy>) => CastHit | null;
 export declare const shapeCastAll: (type: ShapeCastQueryType, queryProxy: QueryProxy, proxies: Iterable<ActorProxy>) => CastHit[];
+export declare const raycastEach: (queryProxy: QueryProxy, proxies: Iterable<ActorProxy>, hit: CastHit, callback: (hit: CastHit) => void) => void;
+export declare const shapeCastEach: (type: ShapeCastQueryType, queryProxy: QueryProxy, proxies: Iterable<ActorProxy>, hit: CastHit, callback: (hit: CastHit) => void) => void;
+export declare const overlapEach: (type: OverlapQueryType, queryProxy: QueryProxy, proxies: Iterable<ActorProxy>, hit: OverlapHit, callback: (hit: OverlapHit) => void) => void;
 export {};