dacha 0.18.0-alpha.9 → 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,72 +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] ??
             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 &&
@@ -225,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) {
@@ -293,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();
@@ -312,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/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 {};

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

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

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

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