dacha 0.18.0-alpha.9 → 0.18.1

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;

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 {};