dacha 0.18.0-alpha.6 → 0.18.0-alpha.7

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

@@ -0,0 +1,28 @@
+import type { AABB } from '../types';
+export type DynamicAABBTreeEntryId = number;
+export declare class DynamicAABBTree<T> {
+    private root;
+    private nodesById;
+    private freeInternalNodes;
+    private queryStack;
+    private nextId;
+    get size(): number;
+    insert(aabb: AABB, value: T): DynamicAABBTreeEntryId;
+    update(id: DynamicAABBTreeEntryId, aabb: AABB): void;
+    remove(id: DynamicAABBTreeEntryId): void;
+    query(aabb: AABB, visitor: (value: T) => unknown): void;
+    queryAll(aabb: AABB, output?: T[]): T[];
+    clear(): void;
+    private createNode;
+    private getNode;
+    private insertLeaf;
+    private removeLeaf;
+    private createInternalNode;
+    private releaseInternalNode;
+    private findBestSibling;
+    private getDescentCost;
+    private fixAncestors;
+    private balance;
+    private rotateLeft;
+    private rotateRight;
+}

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

@@ -0,0 +1,299 @@
+const isLeaf = (node) => node.child1 === null;
+const createAABB = () => ({
+    min: { x: 0, y: 0 },
+    max: { x: 0, y: 0 },
+});
+const setCombinedAABB = (target, aabb1, aabb2) => {
+    target.min.x = Math.min(aabb1.min.x, aabb2.min.x);
+    target.min.y = Math.min(aabb1.min.y, aabb2.min.y);
+    target.max.x = Math.max(aabb1.max.x, aabb2.max.x);
+    target.max.y = Math.max(aabb1.max.y, aabb2.max.y);
+};
+const getPerimeter = (aabb) => 2 *
+    (Math.max(0, aabb.max.x - aabb.min.x) + Math.max(0, aabb.max.y - aabb.min.y));
+const getCombinedPerimeter = (aabb1, aabb2) => {
+    const minX = Math.min(aabb1.min.x, aabb2.min.x);
+    const minY = Math.min(aabb1.min.y, aabb2.min.y);
+    const maxX = Math.max(aabb1.max.x, aabb2.max.x);
+    const maxY = Math.max(aabb1.max.y, aabb2.max.y);
+    return 2 * (Math.max(0, maxX - minX) + Math.max(0, maxY - minY));
+};
+const overlaps = (aabb1, aabb2) => aabb1.max.x >= aabb2.min.x &&
+    aabb1.min.x <= aabb2.max.x &&
+    aabb1.max.y >= aabb2.min.y &&
+    aabb1.min.y <= aabb2.max.y;
+export class DynamicAABBTree {
+    root = null;
+    nodesById = new Map();
+    freeInternalNodes = [];
+    queryStack = [];
+    nextId = 1;
+    get size() {
+        return this.nodesById.size;
+    }
+    insert(aabb, value) {
+        const node = this.createNode(aabb, value);
+        this.nodesById.set(node.id, node);
+        this.insertLeaf(node);
+        return node.id;
+    }
+    update(id, aabb) {
+        const node = this.getNode(id);
+        this.removeLeaf(node);
+        node.aabb = aabb;
+        this.insertLeaf(node);
+    }
+    remove(id) {
+        const node = this.getNode(id);
+        this.removeLeaf(node);
+        this.nodesById.delete(id);
+    }
+    query(aabb, visitor) {
+        if (!this.root) {
+            return;
+        }
+        const stack = this.queryStack;
+        stack.length = 0;
+        stack.push(this.root);
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (!overlaps(node.aabb, aabb)) {
+                continue;
+            }
+            if (isLeaf(node)) {
+                if (visitor(node.value) === false) {
+                    stack.length = 0;
+                    return;
+                }
+                continue;
+            }
+            stack.push(node.child1, node.child2);
+        }
+    }
+    queryAll(aabb, output = []) {
+        this.query(aabb, (value) => {
+            output.push(value);
+        });
+        return output;
+    }
+    clear() {
+        this.root = null;
+        this.nodesById.clear();
+        this.freeInternalNodes.length = 0;
+        this.queryStack.length = 0;
+    }
+    createNode(aabb, value) {
+        return {
+            id: this.nextId++,
+            aabb,
+            value,
+            parent: null,
+            child1: null,
+            child2: null,
+            height: 0,
+        };
+    }
+    getNode(id) {
+        const node = this.nodesById.get(id);
+        if (!node) {
+            throw new Error(`DynamicAABBTree entry ${id} does not exist.`);
+        }
+        return node;
+    }
+    insertLeaf(leaf) {
+        if (!this.root) {
+            this.root = leaf;
+            leaf.parent = null;
+            return;
+        }
+        const sibling = this.findBestSibling(leaf.aabb);
+        const oldParent = sibling.parent;
+        const newParent = this.createInternalNode(leaf, sibling, oldParent);
+        sibling.parent = newParent;
+        leaf.parent = newParent;
+        if (oldParent) {
+            if (oldParent.child1 === sibling) {
+                oldParent.child1 = newParent;
+            }
+            else {
+                oldParent.child2 = newParent;
+            }
+        }
+        else {
+            this.root = newParent;
+        }
+        this.fixAncestors(leaf.parent);
+    }
+    removeLeaf(leaf) {
+        if (leaf === this.root) {
+            this.root = null;
+            leaf.parent = null;
+            return;
+        }
+        const parent = leaf.parent;
+        const grandParent = parent.parent;
+        const sibling = parent.child1 === leaf ? parent.child2 : parent.child1;
+        if (grandParent) {
+            if (grandParent.child1 === parent) {
+                grandParent.child1 = sibling;
+            }
+            else {
+                grandParent.child2 = sibling;
+            }
+            sibling.parent = grandParent;
+            this.fixAncestors(grandParent);
+        }
+        else {
+            this.root = sibling;
+            sibling.parent = null;
+        }
+        leaf.parent = null;
+        this.releaseInternalNode(parent);
+    }
+    createInternalNode(leaf, sibling, parent) {
+        const node = this.freeInternalNodes.pop() ?? {
+            id: 0,
+            aabb: createAABB(),
+            value: null,
+            parent: null,
+            child1: null,
+            child2: null,
+            height: 0,
+        };
+        setCombinedAABB(node.aabb, leaf.aabb, sibling.aabb);
+        node.value = null;
+        node.parent = parent;
+        node.child1 = sibling;
+        node.child2 = leaf;
+        node.height = sibling.height + 1;
+        return node;
+    }
+    releaseInternalNode(node) {
+        node.value = null;
+        node.parent = null;
+        node.child1 = null;
+        node.child2 = null;
+        node.height = 0;
+        this.freeInternalNodes.push(node);
+    }
+    findBestSibling(aabb) {
+        let node = this.root;
+        while (!isLeaf(node)) {
+            const child1 = node.child1;
+            const child2 = node.child2;
+            const perimeter = getPerimeter(node.aabb);
+            const combinedPerimeter = getCombinedPerimeter(node.aabb, aabb);
+            const inheritedCost = 2 * (combinedPerimeter - perimeter);
+            const cost = 2 * combinedPerimeter;
+            const cost1 = this.getDescentCost(child1, aabb, inheritedCost);
+            const cost2 = this.getDescentCost(child2, aabb, inheritedCost);
+            if (cost < cost1 && cost < cost2) {
+                break;
+            }
+            node = cost1 < cost2 ? child1 : child2;
+        }
+        return node;
+    }
+    getDescentCost(child, aabb, inheritedCost) {
+        const combinedPerimeter = getCombinedPerimeter(child.aabb, aabb);
+        if (isLeaf(child)) {
+            return combinedPerimeter + inheritedCost;
+        }
+        return combinedPerimeter - getPerimeter(child.aabb) + inheritedCost;
+    }
+    fixAncestors(node) {
+        while (node) {
+            node = this.balance(node);
+            const child1 = node.child1;
+            const child2 = node.child2;
+            node.height = 1 + Math.max(child1.height, child2.height);
+            setCombinedAABB(node.aabb, child1.aabb, child2.aabb);
+            node = node.parent;
+        }
+    }
+    balance(node) {
+        if (isLeaf(node) || node.height < 2) {
+            return node;
+        }
+        const child1 = node.child1;
+        const child2 = node.child2;
+        const balance = child2.height - child1.height;
+        if (balance > 1) {
+            return this.rotateLeft(node);
+        }
+        if (balance < -1) {
+            return this.rotateRight(node);
+        }
+        return node;
+    }
+    rotateLeft(node) {
+        const child1 = node.child1;
+        const child2 = node.child2;
+        const grandChild1 = child2.child1;
+        const grandChild2 = child2.child2;
+        child2.child1 = node;
+        child2.parent = node.parent;
+        node.parent = child2;
+        if (child2.parent) {
+            if (child2.parent.child1 === node) {
+                child2.parent.child1 = child2;
+            }
+            else {
+                child2.parent.child2 = child2;
+            }
+        }
+        else {
+            this.root = child2;
+        }
+        if (grandChild1.height > grandChild2.height) {
+            child2.child2 = grandChild1;
+            node.child2 = grandChild2;
+            grandChild2.parent = node;
+        }
+        else {
+            child2.child2 = grandChild2;
+            node.child2 = grandChild1;
+            grandChild1.parent = node;
+        }
+        setCombinedAABB(node.aabb, child1.aabb, node.child2.aabb);
+        setCombinedAABB(child2.aabb, node.aabb, child2.child2.aabb);
+        node.height = 1 + Math.max(child1.height, node.child2.height);
+        child2.height = 1 + Math.max(node.height, child2.child2.height);
+        return child2;
+    }
+    rotateRight(node) {
+        const child1 = node.child1;
+        const child2 = node.child2;
+        const grandChild1 = child1.child1;
+        const grandChild2 = child1.child2;
+        child1.child1 = node;
+        child1.parent = node.parent;
+        node.parent = child1;
+        if (child1.parent) {
+            if (child1.parent.child1 === node) {
+                child1.parent.child1 = child1;
+            }
+            else {
+                child1.parent.child2 = child1;
+            }
+        }
+        else {
+            this.root = child1;
+        }
+        if (grandChild1.height > grandChild2.height) {
+            child1.child2 = grandChild1;
+            node.child1 = grandChild2;
+            grandChild2.parent = node;
+        }
+        else {
+            child1.child2 = grandChild2;
+            node.child1 = grandChild1;
+            grandChild1.parent = node;
+        }
+        setCombinedAABB(node.aabb, node.child1.aabb, child2.aabb);
+        setCombinedAABB(child1.aabb, node.aabb, child1.child2.aabb);
+        node.height = 1 + Math.max(node.child1.height, child2.height);
+        child1.height = 1 + Math.max(node.height, child1.child2.height);
+        return child1;
+    }
+}

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

@@ -4,6 +4,7 @@ import type { Contact } from './types';
 export declare class CollisionDetectionSubsystem {
     private actorQuery;
     private axis;
+    private queryTree;
     private proxiesByActorId;
     private proxyPairs;
     private contacts;
@@ -33,7 +34,7 @@ export declare class CollisionDetectionSubsystem {
     private testAABB;
     private testCollisionLayers;
     private testState;
-    private sweepAndPruneQuery;
+    private collectQueryCandidates;
     private sweepAndPrune;
     private checkOnIntersection;
     private storeContact;

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

@@ -2,6 +2,7 @@ import { ActorQuery } from '../../../../../engine/actor';
 import { Transform, Collider, RigidBody } from '../../../../components';
 import { AddActor, RemoveActor } from '../../../../../engine/events';
 import { insertionSort } 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';
@@ -11,6 +12,7 @@ import { buildQueryProxy, buildActorQueryProxy, raycast, raycastAll, overlap, ge
 export class CollisionDetectionSubsystem {
     actorQuery;
     axis;
+    queryTree;
     proxiesByActorId;
     proxyPairs;
     contacts;
@@ -33,6 +35,7 @@ export class CollisionDetectionSubsystem {
                 dispersionCalculator: new DispersionCalculator('y'),
             },
         };
+        this.queryTree = new DynamicAABBTree();
         this.proxiesByActorId = new Map();
         this.proxyPairs = [];
         this.contacts = [];
@@ -47,20 +50,21 @@ export class CollisionDetectionSubsystem {
         this.actorQuery.removeEventListener(AddActor, this.handleActorAdd);
         this.actorQuery.removeEventListener(RemoveActor, this.handleActorRemove);
         this.actorQuery.destroy();
+        this.queryTree.clear();
     }
     raycast(params) {
         const queryProxy = buildQueryProxy('ray', params);
-        this.sweepAndPruneQuery(queryProxy);
+        this.collectQueryCandidates(queryProxy);
         return raycast(queryProxy, this.queryCandidates);
     }
     raycastAll(params) {
         const queryProxy = buildQueryProxy('ray', params);
-        this.sweepAndPruneQuery(queryProxy);
+        this.collectQueryCandidates(queryProxy);
         return raycastAll(queryProxy, this.queryCandidates);
     }
     overlapShape(params) {
         const queryProxy = buildQueryProxy(params.shape.type, params);
-        this.sweepAndPruneQuery(queryProxy);
+        this.collectQueryCandidates(queryProxy);
         return overlap(params.shape.type, queryProxy, this.queryCandidates);
     }
     overlapActor(params) {
@@ -69,19 +73,19 @@ export class CollisionDetectionSubsystem {
             return [];
         }
         const queryProxy = buildActorQueryProxy(queryType, params);
-        this.sweepAndPruneQuery(queryProxy);
+        this.collectQueryCandidates(queryProxy);
         return overlap(queryType, queryProxy, this.queryCandidates);
     }
     shapeCast(params) {
         const queryType = getShapeCastQueryType(params);
         const queryProxy = buildQueryProxy(queryType, params);
-        this.sweepAndPruneQuery(queryProxy);
+        this.collectQueryCandidates(queryProxy);
         return shapeCast(queryType, queryProxy, this.queryCandidates);
     }
     shapeCastAll(params) {
         const queryType = getShapeCastQueryType(params);
         const queryProxy = buildQueryProxy(queryType, params);
-        this.sweepAndPruneQuery(queryProxy);
+        this.collectQueryCandidates(queryProxy);
         return shapeCastAll(queryType, queryProxy, this.queryCandidates);
     }
     castActor(params) {
@@ -90,7 +94,7 @@ export class CollisionDetectionSubsystem {
             return null;
         }
         const queryProxy = buildActorQueryProxy(queryType, params);
-        this.sweepAndPruneQuery(queryProxy);
+        this.collectQueryCandidates(queryProxy);
         return shapeCast(queryType, queryProxy, this.queryCandidates);
     }
     castActorAll(params) {
@@ -99,7 +103,7 @@ export class CollisionDetectionSubsystem {
             return [];
         }
         const queryProxy = buildActorQueryProxy(queryType, params);
-        this.sweepAndPruneQuery(queryProxy);
+        this.collectQueryCandidates(queryProxy);
         return shapeCastAll(queryType, queryProxy, this.queryCandidates);
     }
     handleActorAdd = (event) => {
@@ -130,8 +134,10 @@ export class CollisionDetectionSubsystem {
             aabb,
             geometry,
             orientationData: getOrientationData(actor),
+            treeEntryId: 0,
             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);
@@ -149,6 +155,7 @@ export class CollisionDetectionSubsystem {
         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');
@@ -200,39 +207,15 @@ export class CollisionDetectionSubsystem {
         const collider2 = actor2?.getComponent(Collider);
         return !collider1?.disabled && !collider2?.disabled;
     }
-    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);
-            }
-        }
+    collectQueryCandidates(queryProxy) {
         let candidateIndex = 0;
-        candidates.forEach((proxy) => {
+        this.queryTree.query(queryProxy.aabb, (proxy) => {
             if (queryProxy.excludedActors?.has(proxy.actor)) {
                 return;
             }
             if (!this.testState(proxy, queryProxy)) {
                 return;
             }
-            if (!this.testAABB(proxy, queryProxy, secondAxis)) {
-                return;
-            }
             if (queryProxy.layer !== undefined &&
                 !this.testCollisionLayers(proxy, queryProxy)) {
                 return;
@@ -312,6 +295,7 @@ export class CollisionDetectionSubsystem {
         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);

package/build/contrib/systems/physics-system/subsystems/collision-detection/shape-cast-checkers/box-box/check-box-cast-and-box.d.ts

@@ -1,3 +1,9 @@
 import type { BoxCastGeometry, BoxGeometry } from '../../types';
 import type { ShapeCastCheckerFn } from '../types';
+/**
+ * Casts a moving box by expanding every target box corner by the moving box
+ * half-extents, building the convex hull, and raycasting the moving box center
+ * against that expanded target. The final contact point is shifted back from
+ * the center ray to the moving box support point.
+ */
 export declare const checkBoxCastAndBox: ShapeCastCheckerFn<BoxCastGeometry, BoxGeometry>;

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

@@ -1,6 +1,12 @@
 import { intersectionCheckers } from '../../intersection-checkers';
 import { buildInitialOverlapHit } from '../utils';
 import { checkBoxCastAndConvexPoints, correctContactPoint } from '../box-utils';
+/**
+ * Casts a moving box by expanding every target box corner by the moving box
+ * half-extents, building the convex hull, and raycasting the moving box center
+ * against that expanded target. The final contact point is shifted back from
+ * the center ray to the moving box support point.
+ */
 export const checkBoxCastAndBox = (boxCast, box) => {
     const overlapIntersection = intersectionCheckers.box.box(boxCast, box);
     if (overlapIntersection) {

package/build/contrib/systems/physics-system/subsystems/collision-detection/shape-cast-checkers/box-capsule/check-box-cast-and-capsule.d.ts

@@ -1,3 +1,9 @@
 import type { BoxCastGeometry, CapsuleGeometry } from '../../types';
 import type { ShapeCastCheckerFn } from '../types';
+/**
+ * Casts a moving box against a capsule by delegating to the box-capsule helper:
+ * the capsule segment is expanded by the box half-extents, the capsule caps are
+ * checked as circles, and the nearest hit is converted back to the moving box
+ * support point.
+ */
 export declare const checkBoxCastAndCapsule: ShapeCastCheckerFn<BoxCastGeometry, CapsuleGeometry>;

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

@@ -1,6 +1,13 @@
 import { intersectionCheckers } from '../../intersection-checkers';
 import { buildInitialOverlapHit } from '../utils';
-import { checkBoxCastAndCapsuleGeometry, correctContactPoint, } from '../box-utils';
+import { correctContactPoint } from '../box-utils';
+import { checkBoxCastAndCapsuleGeometry } from './utils';
+/**
+ * Casts a moving box against a capsule by delegating to the box-capsule helper:
+ * the capsule segment is expanded by the box half-extents, the capsule caps are
+ * checked as circles, and the nearest hit is converted back to the moving box
+ * support point.
+ */
 export const checkBoxCastAndCapsule = (boxCast, capsule) => {
     const overlapIntersection = intersectionCheckers.box.capsule(boxCast, capsule);
     if (overlapIntersection) {

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

@@ -0,0 +1,3 @@
+import type { BoxCastGeometry, CapsuleGeometry } from '../../types';
+import type { ShapeCastCheckerHit } from '../types';
+export declare const checkBoxCastAndCapsuleGeometry: (box: BoxCastGeometry, capsule: CapsuleGeometry) => ShapeCastCheckerHit | false;

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

@@ -0,0 +1,23 @@
+import { chooseNearestIntersection } from '../../intersection-checkers/common/cast';
+import { checkRayAndCapsuleIntersection } from '../../raycast-checkers/ray-capsule/check-ray-and-capsule-intersection';
+import { raycastCheckers } from '../../raycast-checkers';
+import { checkBoxCastAndCircleGeometry } from '../box-utils';
+import { ConvexHullWorkspace } from '../common/convex-hull-workspace';
+const convexHullWorkspace = new ConvexHullWorkspace(8);
+const buildBoxExpandedCapsuleGeometry = (halfExtents, capsule) => {
+    convexHullWorkspace.start();
+    convexHullWorkspace.addExpandedPoint(capsule.point1, halfExtents);
+    convexHullWorkspace.addExpandedPoint(capsule.point2, halfExtents);
+    return convexHullWorkspace.buildGeometry();
+};
+export const checkBoxCastAndCapsuleGeometry = (box, capsule) => {
+    const { halfExtents } = box;
+    const expandedCapsule = buildBoxExpandedCapsuleGeometry(halfExtents, capsule);
+    let nearest = raycastCheckers.ray.box(box, expandedCapsule);
+    nearest = chooseNearestIntersection(nearest, checkBoxCastAndCircleGeometry(box, capsule.point1, capsule.radius));
+    nearest = chooseNearestIntersection(nearest, checkBoxCastAndCircleGeometry(box, capsule.point2, capsule.radius));
+    for (const edge of expandedCapsule.edges) {
+        nearest = chooseNearestIntersection(nearest, checkRayAndCapsuleIntersection(box, edge, capsule.radius));
+    }
+    return nearest;
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/shape-cast-checkers/box-circle/check-box-cast-and-circle.d.ts

@@ -1,3 +1,9 @@
 import type { BoxCastGeometry, CircleGeometry } from '../../types';
 import type { ShapeCastCheckerFn } from '../types';
+/**
+ * Casts a moving box against a circle by treating the target as the union of
+ * two expanded axis-aligned rectangles and four corner circles. The nearest
+ * sub-hit is then shifted back from the center ray to the moving box support
+ * point.
+ */
 export declare const checkBoxCastAndCircle: ShapeCastCheckerFn<BoxCastGeometry, CircleGeometry>;

package/build/contrib/systems/physics-system/subsystems/collision-detection/shape-cast-checkers/box-circle/check-box-cast-and-circle.js

@@ -1,6 +1,12 @@
 import { intersectionCheckers } from '../../intersection-checkers';
 import { buildInitialOverlapHit } from '../utils';
 import { checkBoxCastAndCircleGeometry, correctContactPoint, } from '../box-utils';
+/**
+ * Casts a moving box against a circle by treating the target as the union of
+ * two expanded axis-aligned rectangles and four corner circles. The nearest
+ * sub-hit is then shifted back from the center ray to the moving box support
+ * point.
+ */
 export const checkBoxCastAndCircle = (boxCast, circle) => {
     const overlapIntersection = intersectionCheckers.box.circle(boxCast, circle);
     if (overlapIntersection) {

package/build/contrib/systems/physics-system/subsystems/collision-detection/shape-cast-checkers/box-segment/check-box-cast-and-segment.d.ts

@@ -1,3 +1,8 @@
 import type { BoxCastGeometry, SegmentGeometry } from '../../types';
 import type { ShapeCastCheckerFn } from '../types';
+/**
+ * Casts a moving box against a segment by expanding both segment endpoints by
+ * the moving box half-extents, building the convex hull, and raycasting the box
+ * center against that expanded segment shape.
+ */
 export declare const checkBoxCastAndSegment: ShapeCastCheckerFn<BoxCastGeometry, SegmentGeometry>;

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

@@ -1,15 +1,17 @@
 import { intersectionCheckers } from '../../intersection-checkers';
 import { buildInitialOverlapHit } from '../utils';
-import { checkBoxCastAndConvexPoints, correctContactPoint } from '../box-utils';
+import { checkBoxCastAndConvexPointPair, correctContactPoint, } from '../box-utils';
+/**
+ * Casts a moving box against a segment by expanding both segment endpoints by
+ * the moving box half-extents, building the convex hull, and raycasting the box
+ * center against that expanded segment shape.
+ */
 export const checkBoxCastAndSegment = (boxCast, segment) => {
     const overlapIntersection = intersectionCheckers.box.segment(boxCast, segment);
     if (overlapIntersection) {
         return buildInitialOverlapHit(overlapIntersection);
     }
-    const hit = checkBoxCastAndConvexPoints(boxCast, [
-        segment.point1,
-        segment.point2,
-    ]);
+    const hit = checkBoxCastAndConvexPointPair(boxCast, segment.point1, segment.point2);
     correctContactPoint(boxCast, hit);
     return hit;
 };

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

@@ -1,7 +1,7 @@
 import type { RaycastCheckerHit } from '../raycast-checkers/types';
-import type { BoxCastGeometry, CapsuleGeometry, Point } from '../types';
+import type { BoxCastGeometry, Point } from '../types';
 import type { ShapeCastCheckerHit } from './types';
 export declare const correctContactPoint: (box: BoxCastGeometry, hit: RaycastCheckerHit | false) => void;
 export declare const checkBoxCastAndConvexPoints: (box: BoxCastGeometry, points: Point[]) => ShapeCastCheckerHit | false;
+export declare const checkBoxCastAndConvexPointPair: (box: BoxCastGeometry, point1: Point, point2: Point) => ShapeCastCheckerHit | false;
 export declare const checkBoxCastAndCircleGeometry: (box: BoxCastGeometry, center: Point, radius: number) => ShapeCastCheckerHit | false;
-export declare const checkBoxCastAndCapsuleGeometry: (box: BoxCastGeometry, capsule: CapsuleGeometry) => ShapeCastCheckerHit | false;