dacha 0.17.2 → 0.18.0-alpha.1

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-circle-geometry.js

@@ -1,13 +1,38 @@
-export const buildCircleGeometry = (collider, transform) => {
-    const { world: { position, scale }, } = transform;
-    const { centerX, centerY, radius } = collider;
+export function buildCircleGeometry(colliderOrOverlap, transform) {
+    let centerX;
+    let centerY;
+    let radius;
+    let positionX;
+    let positionY;
+    let scaleX;
+    let scaleY;
+    if (transform !== undefined) {
+        const collider = colliderOrOverlap;
+        centerX = collider.centerX;
+        centerY = collider.centerY;
+        radius = collider.radius;
+        positionX = transform.world.position.x;
+        positionY = transform.world.position.y;
+        scaleX = transform.world.scale.x;
+        scaleY = transform.world.scale.y;
+    }
+    else {
+        const overlap = colliderOrOverlap;
+        centerX = 0;
+        centerY = 0;
+        radius = overlap.radius;
+        positionX = overlap.center.x;
+        positionY = overlap.center.y;
+        scaleX = 1;
+        scaleY = 1;
+    }
     const center = {
-        x: centerX + position.x,
-        y: centerY + position.y,
+        x: centerX + positionX,
+        y: centerY + positionY,
     };
-    const scaledRadius = radius * Math.max(scale.x, scale.y);
+    const scaledRadius = radius * Math.max(scaleX, scaleY);
     return {
         center,
         radius: scaledRadius,
     };
-};
+}

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-point-geometry.d.ts

@@ -0,0 +1,3 @@
+import type { PointGeometry } from '../types';
+import type { OverlapPointParams } from '../../../types';
+export declare function buildPointGeometry(overlap: OverlapPointParams): PointGeometry;

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-point-geometry.js

@@ -0,0 +1,5 @@
+export function buildPointGeometry(overlap) {
+    return {
+        center: overlap.point,
+    };
+}

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-ray-geometry.d.ts

@@ -0,0 +1,3 @@
+import type { RayGeometry } from '../types';
+import type { RaycastParams } from '../../../types';
+export declare function buildRayGeometry(overlap: RaycastParams): RayGeometry;

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-ray-geometry.js

@@ -0,0 +1,7 @@
+export function buildRayGeometry(overlap) {
+    return {
+        origin: overlap.origin,
+        direction: overlap.direction.normalize(),
+        maxDistance: overlap.maxDistance,
+    };
+}

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-segment-geometry.d.ts

@@ -0,0 +1,3 @@
+import type { Collider, Transform } from '../../../../../components';
+import type { SegmentGeometry } from '../types';
+export declare function buildSegmentGeometry(collider: Collider, transform: Transform): SegmentGeometry;

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-segment-geometry.js

@@ -0,0 +1,33 @@
+import { VectorOps } from '../../../../../../engine/math-lib';
+export function buildSegmentGeometry(collider, transform) {
+    const centerX = collider.centerX + transform.world.position.x;
+    const centerY = collider.centerY + transform.world.position.y;
+    const point1X = collider.point1?.x ?? 0;
+    const point1Y = collider.point1?.y ?? 0;
+    const point2X = collider.point2?.x ?? 0;
+    const point2Y = collider.point2?.y ?? 0;
+    const rotation = transform.world.rotation;
+    const scaleX = transform.world.scale.x;
+    const scaleY = transform.world.scale.y;
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    const buildPoint = (x, y) => {
+        const scaledX = x * scaleX;
+        const scaledY = y * scaleY;
+        return {
+            x: scaledX * cos - scaledY * sin + centerX,
+            y: scaledX * sin + scaledY * cos + centerY,
+        };
+    };
+    const point1 = buildPoint(point1X, point1Y);
+    const point2 = buildPoint(point2X, point2Y);
+    return {
+        center: {
+            x: (point1.x + point2.x) / 2,
+            y: (point1.y + point2.y) / 2,
+        },
+        point1,
+        point2,
+        normal: VectorOps.getNormal(point1.x, point2.x, point1.y, point2.y),
+    };
+}

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

@@ -1,4 +1,15 @@
 import type { Collider, Transform } from '../../../../../components';
 import type { Geometry } from '../types';
+import { buildBoxGeometry } from './build-box-geometry';
+import { buildCircleGeometry } from './build-circle-geometry';
+import { buildPointGeometry } from './build-point-geometry';
+import { buildRayGeometry } from './build-ray-geometry';
+import { buildSegmentGeometry } from './build-segment-geometry';
 export type BuildGeometryFn = (collider: Collider, transform: Transform) => Geometry;
-export declare const geometryBuilders: Record<string, BuildGeometryFn>;
+export declare const geometryBuilders: {
+    box: typeof buildBoxGeometry;
+    circle: typeof buildCircleGeometry;
+    segment: typeof buildSegmentGeometry;
+    point: typeof buildPointGeometry;
+    ray: typeof buildRayGeometry;
+};

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

@@ -1,6 +1,12 @@
 import { buildBoxGeometry } from './build-box-geometry';
 import { buildCircleGeometry } from './build-circle-geometry';
+import { buildPointGeometry } from './build-point-geometry';
+import { buildRayGeometry } from './build-ray-geometry';
+import { buildSegmentGeometry } from './build-segment-geometry';
 export const geometryBuilders = {
     box: buildBoxGeometry,
     circle: buildCircleGeometry,
+    segment: buildSegmentGeometry,
+    point: buildPointGeometry,
+    ray: buildRayGeometry,
 };

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

@@ -1,28 +1,40 @@
 import type { SceneSystemOptions } from '../../../../../engine/system';
+import type { Actor } from '../../../../../engine/actor';
+import type { RaycastParams, RaycastHit, OverlapPointParams, OverlapCircleParams, OverlapBoxParams } from '../../types';
+import type { Contact } from './types';
 export declare class CollisionDetectionSubsystem {
     private actorQuery;
-    private scene;
     private axis;
-    private entriesMap;
-    private collisionPairs;
-    private entriesToDelete;
+    private proxiesByActorId;
+    private proxyPairs;
+    private contacts;
+    private actorIdsToDelete;
+    private collisionMatrix;
+    private queryCandidates;
     constructor(options: SceneSystemOptions);
     destroy(): void;
+    raycast(params: RaycastParams): RaycastHit | null;
+    raycastAll(params: RaycastParams): RaycastHit[];
+    overlapPoint(params: OverlapPointParams): Actor[];
+    overlapCircle(params: OverlapCircleParams): Actor[];
+    overlapBox(params: OverlapBoxParams): Actor[];
     private handleActorAdd;
     private handleActorRemove;
     private checkOnReorientation;
     private getOrientationData;
-    private addCollisionEntry;
-    private updateCollisionEntry;
+    private addProxy;
+    private updateProxy;
     private addToSortedList;
     private updateSortedList;
     private clearSortedList;
     private getAxes;
     private areStaticBodies;
     private testAABB;
+    private testCollisionLayers;
+    private sweepAndPruneQuery;
     private sweepAndPrune;
     private checkOnIntersection;
-    private sendCollisionEvent;
-    private clearDeletedEntries;
-    update(): void;
+    private storeContact;
+    private clearDeletedProxies;
+    update(): Contact[];
 }

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

@@ -1,26 +1,28 @@
 import { ActorQuery } from '../../../../../engine/actor';
 import { Transform, Collider, RigidBody } from '../../../../components';
 import { AddActor, RemoveActor } from '../../../../../engine/events';
-import { Collision } from '../../../../events';
 import { insertionSort } from '../../../../../engine/data-lib';
 import { geometryBuilders } from './geometry-builders';
 import { aabbBuilders } from './aabb-builders';
 import { intersectionCheckers } from './intersection-checkers';
 import { DispersionCalculator } from './dispersion-calculator';
 import { checkTransform, checkCollider } from './reorientation-checkers';
+import { buildQueryProxy, raycast, raycastAll, overlap } from './query-utils';
 export class CollisionDetectionSubsystem {
     actorQuery;
-    scene;
     axis;
-    entriesMap;
-    collisionPairs;
-    entriesToDelete;
+    proxiesByActorId;
+    proxyPairs;
+    contacts;
+    actorIdsToDelete;
+    collisionMatrix;
+    queryCandidates;
     constructor(options) {
+        const settings = options.globalOptions.physics;
         this.actorQuery = new ActorQuery({
             scene: options.scene,
             filter: [Collider, Transform],
         });
-        this.scene = options.scene;
         this.axis = {
             x: {
                 sortedList: [],
@@ -31,34 +33,61 @@ export class CollisionDetectionSubsystem {
                 dispersionCalculator: new DispersionCalculator('y'),
             },
         };
-        this.entriesMap = new Map();
-        this.collisionPairs = [];
-        this.entriesToDelete = new Set();
-        this.actorQuery
-            .getActors()
-            .forEach((actor) => this.addCollisionEntry(actor));
+        this.proxiesByActorId = new Map();
+        this.proxyPairs = [];
+        this.contacts = [];
+        this.actorIdsToDelete = new Set();
+        this.collisionMatrix = settings?.collisionMatrix ?? {};
+        this.queryCandidates = [];
+        this.actorQuery.getActors().forEach((actor) => this.addProxy(actor));
         this.actorQuery.addEventListener(AddActor, this.handleActorAdd);
         this.actorQuery.addEventListener(RemoveActor, this.handleActorRemove);
     }
     destroy() {
         this.actorQuery.removeEventListener(AddActor, this.handleActorAdd);
         this.actorQuery.removeEventListener(RemoveActor, this.handleActorRemove);
+        this.actorQuery.destroy();
+    }
+    raycast(params) {
+        const queryProxy = buildQueryProxy('ray', params);
+        this.sweepAndPruneQuery(queryProxy);
+        return raycast(queryProxy, this.queryCandidates);
+    }
+    raycastAll(params) {
+        const queryProxy = buildQueryProxy('ray', params);
+        this.sweepAndPruneQuery(queryProxy);
+        return raycastAll(queryProxy, this.queryCandidates);
+    }
+    overlapPoint(params) {
+        const queryProxy = buildQueryProxy('point', params);
+        this.sweepAndPruneQuery(queryProxy);
+        return overlap('point', queryProxy, this.queryCandidates);
+    }
+    overlapCircle(params) {
+        const queryProxy = buildQueryProxy('circle', params);
+        this.sweepAndPruneQuery(queryProxy);
+        return overlap('circle', queryProxy, this.queryCandidates);
+    }
+    overlapBox(params) {
+        const queryProxy = buildQueryProxy('box', params);
+        this.sweepAndPruneQuery(queryProxy);
+        return overlap('box', queryProxy, this.queryCandidates);
     }
     handleActorAdd = (event) => {
-        this.addCollisionEntry(event.actor);
+        this.addProxy(event.actor);
     };
     handleActorRemove = (event) => {
-        this.entriesToDelete.add(event.actor.id);
+        this.actorIdsToDelete.add(event.actor.id);
     };
     checkOnReorientation(actor) {
-        const entry = this.entriesMap.get(actor.id);
-        if (!entry) {
+        const proxy = this.proxiesByActorId.get(actor.id);
+        if (!proxy) {
             return true;
         }
         const transform = actor.getComponent(Transform);
         const collider = actor.getComponent(Collider);
-        const transformOld = entry.orientationData.transform;
-        const colliderOld = entry.orientationData.collider;
+        const transformOld = proxy.orientationData.transform;
+        const colliderOld = proxy.orientationData.collider;
         return (checkTransform(transform, transformOld) ||
             checkCollider(collider, colliderOld));
     }
@@ -75,160 +104,216 @@ export class CollisionDetectionSubsystem {
             },
             collider: {
                 type: collider.type,
+                layer: collider.layer,
                 centerX: collider.centerX,
                 centerY: collider.centerY,
                 sizeX: collider.sizeX,
                 sizeY: collider.sizeY,
                 radius: collider.radius,
+                point1: collider.point1 ? { ...collider.point1 } : undefined,
+                point2: collider.point2 ? { ...collider.point2 } : undefined,
             },
         };
     }
-    addCollisionEntry(actor) {
+    addProxy(actor) {
         const transform = actor.getComponent(Transform);
         const collider = actor.getComponent(Collider);
         const geometry = geometryBuilders[collider.type](collider, transform);
         const aabb = aabbBuilders[collider.type](geometry);
-        const entry = {
+        const proxy = {
             actor,
             aabb,
             geometry,
             orientationData: this.getOrientationData(actor),
+            layer: collider.layer,
         };
         this.axis.x.dispersionCalculator.addToSample(aabb);
-        this.addToSortedList(entry, 'x');
+        this.addToSortedList(proxy, 'x');
         this.axis.y.dispersionCalculator.addToSample(aabb);
-        this.addToSortedList(entry, 'y');
-        this.entriesMap.set(actor.id, entry);
+        this.addToSortedList(proxy, 'y');
+        this.proxiesByActorId.set(actor.id, proxy);
     }
-    updateCollisionEntry(actor) {
+    updateProxy(actor) {
         const transform = actor.getComponent(Transform);
         const collider = actor.getComponent(Collider);
         const geometry = geometryBuilders[collider.type](collider, transform);
         const aabb = aabbBuilders[collider.type](geometry);
-        const entry = this.entriesMap.get(actor.id);
-        const prevAABB = entry.aabb;
-        entry.aabb = aabb;
-        entry.geometry = geometry;
-        entry.orientationData = this.getOrientationData(actor);
+        const proxy = this.proxiesByActorId.get(actor.id);
+        const prevAABB = proxy.aabb;
+        proxy.aabb = aabb;
+        proxy.geometry = geometry;
+        proxy.orientationData = this.getOrientationData(actor);
+        proxy.layer = collider.layer;
         this.axis.x.dispersionCalculator.removeFromSample(prevAABB);
         this.axis.x.dispersionCalculator.addToSample(aabb);
-        this.updateSortedList(entry, 'x');
+        this.updateSortedList(proxy, 'x');
         this.axis.y.dispersionCalculator.removeFromSample(prevAABB);
         this.axis.y.dispersionCalculator.addToSample(aabb);
-        this.updateSortedList(entry, 'y');
+        this.updateSortedList(proxy, 'y');
     }
-    addToSortedList(entry, axis) {
-        const min = { value: entry.aabb.min[axis], entry };
-        const max = { value: entry.aabb.max[axis], entry };
+    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);
-        entry.edges ??= {};
-        entry.edges[axis] = [min, max];
+        proxy.edges ??= {};
+        proxy.edges[axis] = [min, max];
     }
-    updateSortedList(entry, axis) {
-        const [min, max] = entry.edges[axis];
-        min.value = entry.aabb.min[axis];
-        min.entry = entry;
-        max.value = entry.aabb.max[axis];
-        max.entry = entry;
+    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.entriesToDelete.has(item.entry.actor.id));
+        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(entry1, entry2) {
-        const { actor: actor1 } = entry1;
-        const { actor: actor2 } = entry2;
+    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(entry1, entry2, axis) {
-        const aabb1 = entry1.aabb;
-        const aabb2 = entry2.aabb;
+    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;
+    }
+    sweepAndPruneQuery(queryProxy) {
+        const [mainAxis, secondAxis] = this.getAxes();
+        const sortedList = this.axis[mainAxis].sortedList;
+        const candidates = new Set();
+        for (const item of sortedList) {
+            const { proxy, value } = item;
+            if (value < queryProxy.aabb.min[mainAxis]) {
+                if (candidates.has(proxy)) {
+                    candidates.delete(proxy);
+                }
+                else {
+                    candidates.add(proxy);
+                }
+                continue;
+            }
+            if (value > queryProxy.aabb.max[mainAxis]) {
+                break;
+            }
+            if (!candidates.has(proxy)) {
+                candidates.add(proxy);
+            }
+        }
+        let candidateIndex = 0;
+        candidates.forEach((proxy) => {
+            if (!this.testAABB(proxy, queryProxy, secondAxis)) {
+                return;
+            }
+            if (queryProxy.layer !== undefined &&
+                !this.testCollisionLayers(proxy, queryProxy)) {
+                return;
+            }
+            this.queryCandidates[candidateIndex] = proxy;
+            candidateIndex += 1;
+        });
+        this.queryCandidates.length = candidateIndex;
+    }
     sweepAndPrune() {
         const [mainAxis, secondAxis] = this.getAxes();
         const { sortedList } = this.axis[mainAxis];
         insertionSort(sortedList, (arg1, arg2) => arg1.value - arg2.value);
-        const activeEntries = new Set();
-        let collisionIndex = 0;
+        const activeProxies = new Set();
+        let proxyPairIndex = 0;
         for (const item of sortedList) {
-            const { entry } = item;
-            if (!activeEntries.has(entry)) {
-                activeEntries.forEach((activeEntry) => {
-                    if (!this.testAABB(entry, activeEntry, secondAxis)) {
+            const { proxy } = item;
+            if (!activeProxies.has(proxy)) {
+                activeProxies.forEach((activeProxy) => {
+                    if (!this.testAABB(proxy, activeProxy, secondAxis)) {
+                        return;
+                    }
+                    if (this.areStaticBodies(proxy, activeProxy)) {
                         return;
                     }
-                    if (this.areStaticBodies(entry, activeEntry)) {
+                    if (!this.testCollisionLayers(proxy, activeProxy)) {
                         return;
                     }
-                    this.collisionPairs[collisionIndex] = [entry, activeEntry];
-                    collisionIndex += 1;
+                    this.proxyPairs[proxyPairIndex] = [proxy, activeProxy];
+                    proxyPairIndex += 1;
                 });
-                activeEntries.add(entry);
+                activeProxies.add(proxy);
             }
             else {
-                activeEntries.delete(entry);
+                activeProxies.delete(proxy);
             }
         }
-        if (this.collisionPairs.length > collisionIndex) {
-            this.collisionPairs.length = collisionIndex;
+        if (this.proxyPairs.length > proxyPairIndex) {
+            this.proxyPairs.length = proxyPairIndex;
         }
     }
-    checkOnIntersection(pair) {
-        const [arg1, arg2] = pair;
-        const type1 = arg1.actor.getComponent(Collider).type;
-        const type2 = arg2.actor.getComponent(Collider).type;
-        return intersectionCheckers[type1][type2](arg1, arg2);
+    checkOnIntersection(proxyPair) {
+        const [proxy1, proxy2] = proxyPair;
+        const type1 = proxy1.actor.getComponent(Collider).type;
+        const type2 = proxy2.actor.getComponent(Collider).type;
+        const intersectionChecker = intersectionCheckers[type1]?.[type2];
+        if (!intersectionChecker) {
+            return false;
+        }
+        return intersectionChecker(proxy1, proxy2);
     }
-    sendCollisionEvent(actor1, actor2, intersection) {
-        const { mtv1, mtv2 } = intersection;
-        this.scene.dispatchEventImmediately(Collision, {
+    storeContact(contactIndex, actor1, actor2, intersection) {
+        this.contacts[contactIndex] ??= {
             actor1,
             actor2,
-            mtv1,
-            mtv2,
-        });
-        this.scene.dispatchEventImmediately(Collision, {
-            actor1: actor2,
-            actor2: actor1,
-            mtv1: mtv2,
-            mtv2: mtv1,
-        });
+            normal: intersection.normal,
+            penetration: intersection.penetration,
+            contactPoints: intersection.contactPoints,
+        };
+        this.contacts[contactIndex].actor1 = actor1;
+        this.contacts[contactIndex].actor2 = actor2;
+        this.contacts[contactIndex].normal = intersection.normal;
+        this.contacts[contactIndex].penetration = intersection.penetration;
+        this.contacts[contactIndex].contactPoints = intersection.contactPoints;
     }
-    clearDeletedEntries() {
-        if (this.entriesToDelete.size === 0) {
+    clearDeletedProxies() {
+        if (this.actorIdsToDelete.size === 0) {
             return;
         }
         this.clearSortedList('x');
         this.clearSortedList('y');
-        this.entriesToDelete.forEach((id) => {
-            const entry = this.entriesMap.get(id);
-            this.axis.x.dispersionCalculator.removeFromSample(entry.aabb);
-            this.axis.y.dispersionCalculator.removeFromSample(entry.aabb);
-            this.entriesMap.delete(id);
+        this.actorIdsToDelete.forEach((id) => {
+            const proxy = this.proxiesByActorId.get(id);
+            this.axis.x.dispersionCalculator.removeFromSample(proxy.aabb);
+            this.axis.y.dispersionCalculator.removeFromSample(proxy.aabb);
+            this.proxiesByActorId.delete(id);
         });
-        this.entriesToDelete.clear();
+        this.actorIdsToDelete.clear();
     }
     update() {
-        this.clearDeletedEntries();
+        this.clearDeletedProxies();
         this.actorQuery.getActors().forEach((actor) => {
             if (!this.checkOnReorientation(actor)) {
                 return;
             }
-            this.updateCollisionEntry(actor);
+            this.updateProxy(actor);
         });
         this.sweepAndPrune();
-        this.collisionPairs.forEach((pair) => {
-            const intersection = this.checkOnIntersection(pair);
+        let contactIndex = 0;
+        this.proxyPairs.forEach((proxyPair) => {
+            const intersection = this.checkOnIntersection(proxyPair);
             if (intersection) {
-                this.sendCollisionEvent(pair[0].actor, pair[1].actor, intersection);
+                this.storeContact(contactIndex, proxyPair[0].actor, proxyPair[1].actor, intersection);
+                contactIndex += 1;
             }
         });
+        if (this.contacts.length > contactIndex) {
+            this.contacts.length = contactIndex;
+        }
+        return this.contacts;
     }
 }

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

@@ -0,0 +1,10 @@
+import type { Proxy, Intersection } from '../../types';
+/**
+ * Checks box colliders for intersection.
+ *
+ * The SAT (separating axis theorem) is used to find the collision normal
+ * and penetration depth. Once the best axis is known, the incident edge is
+ * clipped against the reference edge to produce up to two stable contact
+ * points for impulse-based collision resolution.
+ */
+export declare const checkBoxesIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;

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

@@ -0,0 +1,36 @@
+import { orientNormal } from '../utils';
+import { findMinBoxesOverlap, buildContactPoints } from './utils';
+/**
+ * Checks box colliders for intersection.
+ *
+ * The SAT (separating axis theorem) is used to find the collision normal
+ * and penetration depth. Once the best axis is known, the incident edge is
+ * clipped against the reference edge to produce up to two stable contact
+ * points for impulse-based collision resolution.
+ */
+export const checkBoxesIntersection = (arg1, arg2) => {
+    const geometry1 = arg1.geometry;
+    const geometry2 = arg2.geometry;
+    const overlap1 = findMinBoxesOverlap(geometry1, geometry2);
+    if (overlap1 === false) {
+        return false;
+    }
+    const overlap2 = findMinBoxesOverlap(geometry2, geometry1);
+    if (overlap2 === false) {
+        return false;
+    }
+    const isArg1Reference = overlap1.overlap <= overlap2.overlap;
+    const referenceGeometry = isArg1Reference ? geometry1 : geometry2;
+    const incidentGeometry = isArg1Reference ? geometry2 : geometry1;
+    const referenceOverlap = isArg1Reference ? overlap1 : overlap2;
+    const normal = orientNormal(referenceOverlap.axis.clone(), geometry1.center, geometry2.center);
+    const referenceNormal = normal.clone();
+    if (!isArg1Reference) {
+        referenceNormal.multiplyNumber(-1);
+    }
+    return {
+        normal,
+        penetration: referenceOverlap.overlap,
+        contactPoints: buildContactPoints(referenceGeometry, referenceNormal, incidentGeometry),
+    };
+};

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

@@ -0,0 +1,17 @@
+import { Vector2 } from '../../../../../../../engine/math-lib';
+import type { BoxGeometry, Point } from '../../types';
+export declare const CONTACT_EPSILON = 0.0001;
+export declare const MAX_CONTACT_POINTS = 2;
+export interface AxisOverlap {
+    axis: Vector2;
+    overlap: number;
+}
+export declare const findMinBoxesOverlap: (geometry1: BoxGeometry, geometry2: BoxGeometry) => AxisOverlap | false;
+/**
+ * Builds up to two box-vs-box contact points by clipping the incident edge
+ * against the side planes of the reference edge.
+ *
+ * The returned points lie on the reference face plane, which makes them
+ * suitable to use as world-space contact points in a simple impulse solver.
+ */
+export declare const buildContactPoints: (referencePolygon: BoxGeometry, referenceNormal: Vector2, incidentPolygon: BoxGeometry) => Point[];