dacha 0.18.0-alpha.4 → 0.18.0-alpha.6

package/build/contrib/systems/character-controller/index.js

@@ -0,0 +1,262 @@
+import { ActorQuery } from '../../../engine/actor';
+import { SceneSystem } from '../../../engine/system';
+import { Vector2, VectorOps } from '../../../engine/math-lib';
+import { Collider, CharacterBody, RigidBody, Transform, } from '../../components';
+import { PhysicsAPI } from '../physics-system';
+import { OneWayValidator } from '../../utils/one-way-validator';
+import { CharacterHit } from '../../events';
+import { clipAgainstNormal } from './utils';
+const DISTANCE_EPSILON = 0.000001;
+const SNAP_EPSILON = 0.000001;
+/**
+ * Kinematic character controller system with sweep/slide collision movement.
+ *
+ * The system expects actors to have `CharacterBody`, `Transform`,
+ * `Collider`, and a kinematic `RigidBody`. Put this system before
+ * `PhysicsSystem` in system configuration so `movePosition()` targets are
+ * consumed by physics in the same fixed step.
+ *
+ * @category Systems
+ */
+export class CharacterController extends SceneSystem {
+    actorQuery;
+    world;
+    oneWayValidator;
+    constructor(options) {
+        super();
+        this.world = options.world;
+        this.actorQuery = new ActorQuery({
+            scene: options.scene,
+            filter: [CharacterBody, Transform, Collider, RigidBody],
+        });
+        this.oneWayValidator = new OneWayValidator();
+    }
+    onSceneDestroy() {
+        this.actorQuery.destroy();
+    }
+    isBlockingHit(actor, hit) {
+        const rigidBody = hit.actor.getComponent(RigidBody);
+        if (!rigidBody || rigidBody.disabled) {
+            return false;
+        }
+        if (!rigidBody?.oneWay || !rigidBody.oneWayNormal) {
+            return true;
+        }
+        return this.oneWayValidator.validate(hit.actor, actor, hit.normal);
+    }
+    isWalkable(actor, normal) {
+        const character = actor.getComponent(CharacterBody);
+        return (VectorOps.dotProduct(normal, character.upDirection) >=
+            Math.cos(character.maxSlopeAngle));
+    }
+    isRecoverableOverlap(actor, hit) {
+        const rigidBody = hit.actor.getComponent(RigidBody);
+        if (!rigidBody || rigidBody.disabled || rigidBody.type === 'dynamic') {
+            return false;
+        }
+        if (!rigidBody.oneWay || !rigidBody.oneWayNormal) {
+            return true;
+        }
+        return this.oneWayValidator.validate(hit.actor, actor, hit.normal);
+    }
+    resetGroundState(character) {
+        if (character.onGround) {
+            character.groundActor = null;
+            character.groundNormal = character.upDirection.clone();
+            character.onGround = false;
+        }
+    }
+    resetState(character) {
+        this.resetGroundState(character);
+        character.onWall = false;
+        character.onCeiling = false;
+    }
+    cast(actor, position, displacement, hitFilter) {
+        if (displacement.squaredMagnitude <= DISTANCE_EPSILON) {
+            return null;
+        }
+        const physicsApi = this.world.systemApi.get(PhysicsAPI);
+        const character = actor.getComponent(CharacterBody);
+        const transform = actor.getComponent(Transform);
+        const distance = displacement.magnitude;
+        return physicsApi.castActor({
+            actor,
+            offset: {
+                x: position.x - transform.world.position.x,
+                y: position.y - transform.world.position.y,
+            },
+            direction: displacement,
+            maxDistance: distance + character.skinWidth,
+            hitFilter,
+        });
+    }
+    castMotion(actor, position, displacement) {
+        return this.cast(actor, position, displacement, (hit) => {
+            if (hit.distance <= DISTANCE_EPSILON &&
+                VectorOps.dotProduct(displacement, hit.normal) > DISTANCE_EPSILON) {
+                return false;
+            }
+            return this.isBlockingHit(actor, hit);
+        });
+    }
+    castGround(actor, position, displacement) {
+        return this.cast(actor, position, displacement, (hit) => this.isBlockingHit(actor, hit) && this.isWalkable(actor, hit.normal));
+    }
+    recoverOverlaps(actor, position) {
+        const character = actor.getComponent(CharacterBody);
+        if (!character._needsRecovery) {
+            return;
+        }
+        const transform = actor.getComponent(Transform);
+        const physicsApi = this.world.systemApi.get(PhysicsAPI);
+        for (let i = 0; i < character.maxRecoveries; i += 1) {
+            const hits = physicsApi.overlapActor({
+                actor,
+                offset: {
+                    x: position.x - transform.world.position.x,
+                    y: position.y - transform.world.position.y,
+                },
+            });
+            let recovered = false;
+            for (const hit of hits) {
+                if (!this.isRecoverableOverlap(actor, hit)) {
+                    continue;
+                }
+                const correction = hit.penetration + character.skinWidth;
+                if (correction <= DISTANCE_EPSILON) {
+                    continue;
+                }
+                position.x += hit.normal.x * correction;
+                position.y += hit.normal.y * correction;
+                recovered = true;
+            }
+            if (!recovered) {
+                character._needsRecovery = false;
+                break;
+            }
+        }
+    }
+    handleHit(actor, hit) {
+        const character = actor.getComponent(CharacterBody);
+        let kind;
+        if (character.motionMode === 'surface') {
+            const upDot = VectorOps.dotProduct(hit.normal, character.upDirection);
+            const threshold = Math.cos(character.maxSlopeAngle);
+            if (upDot >= threshold) {
+                kind = 'ground';
+                character.onGround = true;
+                character.groundNormal = hit.normal;
+                character.groundActor = hit.actor;
+            }
+            else if (upDot <= -threshold) {
+                kind = 'ceiling';
+                character.onCeiling = true;
+            }
+            else {
+                kind = 'wall';
+                character.onWall = true;
+            }
+        }
+        else {
+            kind = 'wall';
+            character.onWall = true;
+        }
+        actor.dispatchEvent(CharacterHit, {
+            actor: hit.actor,
+            point: hit.point,
+            normal: hit.normal,
+            distance: hit.distance,
+            kind,
+        });
+    }
+    move(actor, position, displacement) {
+        if (displacement.squaredMagnitude <= DISTANCE_EPSILON) {
+            return;
+        }
+        const character = actor.getComponent(CharacterBody);
+        for (let i = 0; i < character.maxSlides; i += 1) {
+            if (displacement.squaredMagnitude <= DISTANCE_EPSILON) {
+                break;
+            }
+            const distance = displacement.magnitude;
+            const hit = this.castMotion(actor, position, displacement);
+            if (!hit) {
+                position.add(displacement);
+                break;
+            }
+            const safeDistance = Math.max(hit.distance - character.skinWidth, 0);
+            const direction = displacement.clone().normalize();
+            position.x += direction.x * safeDistance;
+            position.y += direction.y * safeDistance;
+            this.handleHit(actor, hit);
+            clipAgainstNormal(character.velocity, hit.normal);
+            const remainingDistance = Math.max(distance - safeDistance, 0);
+            displacement.x = direction.x * remainingDistance;
+            displacement.y = direction.y * remainingDistance;
+            clipAgainstNormal(displacement, hit.normal);
+        }
+    }
+    updateGroundState(actor, target, skipSnapping) {
+        const character = actor.getComponent(CharacterBody);
+        if (skipSnapping) {
+            this.resetGroundState(character);
+            return;
+        }
+        const probeDistance = Math.max(character.groundSnapDistance, character.skinWidth);
+        const probeDirection = character.upDirection
+            .clone()
+            .multiplyNumber(-probeDistance);
+        const hit = this.castGround(actor, target, probeDirection);
+        if (!hit) {
+            this.resetGroundState(character);
+            return;
+        }
+        character.onGround = true;
+        character.groundNormal = hit.normal;
+        character.groundActor = hit.actor;
+        const snapDistance = Math.max(hit.distance - character.skinWidth, 0);
+        const snapDirection = character.upDirection
+            .clone()
+            .multiplyNumber(-snapDistance);
+        target.x += snapDirection.x;
+        target.y += snapDirection.y;
+    }
+    fixedUpdate(options) {
+        if (!this.world.systemApi.has(PhysicsAPI)) {
+            return;
+        }
+        const deltaTimeInSeconds = options.deltaTime / 1000;
+        this.oneWayValidator.update();
+        this.actorQuery.getActors().forEach((actor) => {
+            const transform = actor.getComponent(Transform);
+            const character = actor.getComponent(CharacterBody);
+            const rigidBody = actor.getComponent(RigidBody);
+            const collider = actor.getComponent(Collider);
+            this.resetState(character);
+            if (character.disabled ||
+                rigidBody.disabled ||
+                collider.disabled ||
+                rigidBody.type !== 'kinematic') {
+                character._displacement.multiplyNumber(0);
+                return;
+            }
+            const position = new Vector2(transform.world.position.x, transform.world.position.y);
+            this.recoverOverlaps(actor, position);
+            const displacement = character.velocity
+                .clone()
+                .multiplyNumber(deltaTimeInSeconds)
+                .add(character._displacement);
+            const movingUp = VectorOps.dotProduct(displacement, character.upDirection) >
+                SNAP_EPSILON;
+            this.move(actor, position, displacement);
+            this.updateGroundState(actor, position, movingUp || character.motionMode === 'free');
+            if (Math.abs(position.x - transform.world.position.x) > DISTANCE_EPSILON ||
+                Math.abs(position.y - transform.world.position.y) > DISTANCE_EPSILON) {
+                rigidBody.movePosition(position);
+            }
+            character._displacement.multiplyNumber(0);
+        });
+        this.oneWayValidator.lateUpdate();
+    }
+}
+CharacterController.systemName = 'CharacterController';

package/build/contrib/systems/character-controller/utils.d.ts

@@ -0,0 +1,2 @@
+import { type Point } from '../../../engine/math-lib';
+export declare const clipAgainstNormal: (vector: Point, normal: Point) => void;

package/build/contrib/systems/character-controller/utils.js

@@ -0,0 +1,9 @@
+import { VectorOps } from '../../../engine/math-lib';
+export const clipAgainstNormal = (vector, normal) => {
+    const dot = VectorOps.dotProduct(vector, normal);
+    if (dot >= 0) {
+        return;
+    }
+    vector.x -= normal.x * dot;
+    vector.y -= normal.y * dot;
+};

package/build/contrib/systems/index.d.ts

@@ -3,6 +3,7 @@ export { CameraSystem, CameraAPI } from './camera-system';
 export { GameStatsMeter } from './game-stats-meter';
 export { KeyboardInputSystem } from './keyboard-input-system';
 export { KeyboardControlSystem } from './keyboard-control-system';
+export { CharacterController } from './character-controller';
 export { MouseControlSystem } from './mouse-control-system';
 export { MouseInputSystem } from './mouse-input-system';
 export { PhysicsSystem, PhysicsAPI } from './physics-system';
@@ -10,5 +11,5 @@ export { BehaviorSystem, Behavior } from './behavior-system';
 export type { BehaviorOptions } from './behavior-system';
 export { UIBridge } from './ui-bridge';
 export type { UIOptions, UIInitFn, UIDestroyFn, LoadUIFn } from './ui-bridge';
-export { AudioSystem } from './audio-system';
+export { AudioSystem, AudioAPI } from './audio-system';
 export { Renderer, RendererAPI, FilterEffect, Shader } from './renderer';

package/build/contrib/systems/index.js

@@ -3,10 +3,11 @@ export { CameraSystem, CameraAPI } from './camera-system';
 export { GameStatsMeter } from './game-stats-meter';
 export { KeyboardInputSystem } from './keyboard-input-system';
 export { KeyboardControlSystem } from './keyboard-control-system';
+export { CharacterController } from './character-controller';
 export { MouseControlSystem } from './mouse-control-system';
 export { MouseInputSystem } from './mouse-input-system';
 export { PhysicsSystem, PhysicsAPI } from './physics-system';
 export { BehaviorSystem, Behavior } from './behavior-system';
 export { UIBridge } from './ui-bridge';
-export { AudioSystem } from './audio-system';
+export { AudioSystem, AudioAPI } from './audio-system';
 export { Renderer, RendererAPI, FilterEffect, Shader } from './renderer';

package/build/contrib/systems/physics-system/api.d.ts

@@ -1,6 +1,17 @@
-import type { Actor } from '../../../engine/actor';
-import type { CollisionDetectionSubsystem } from './subsystems';
-import type { CastHit, RaycastParams, OverlapParams, ShapeCastParams } from './types';
+import type { Vector2 } from '../../../engine/math-lib';
+import type { CastHit, OverlapHit, RaycastParams, OverlapParams, OverlapActorParams, ShapeCastParams, CastActorParams } from './types';
+export interface PhysicsAPIHandlers {
+    raycast(params: RaycastParams): CastHit | null;
+    raycastAll(params: RaycastParams): CastHit[];
+    overlapShape(params: OverlapParams): OverlapHit[];
+    overlapActor(params: OverlapActorParams): OverlapHit[];
+    shapeCast(params: ShapeCastParams): CastHit | null;
+    shapeCastAll(params: ShapeCastParams): CastHit[];
+    castActor(params: CastActorParams): CastHit | null;
+    castActorAll(params: CastActorParams): CastHit[];
+    getGravity(): Vector2;
+    setGravity(gravity: Vector2): void;
+}
 /**
  * API that provides methods for performing physics queries such as raycasting and overlap tests.
  *
@@ -12,8 +23,18 @@ import type { CastHit, RaycastParams, OverlapParams, ShapeCastParams } from './t
  * @category Systems
  */
 export declare class PhysicsAPI {
-    private collisionDetectionSubsystem;
-    constructor(collisionDetectionSubsystem: CollisionDetectionSubsystem);
+    private handlers;
+    constructor(handlers: PhysicsAPIHandlers);
+    /**
+     * Current gravity vector.
+     */
+    get gravity(): Vector2;
+    /**
+     * Sets the gravity vector.
+     *
+     * @param gravity - New gravity vector
+     */
+    set gravity(gravity: Vector2);
     /**
      * Casts a ray and returns the nearest hit, if any.
      *
@@ -35,12 +56,19 @@ export declare class PhysicsAPI {
      */
     raycastAll(params: RaycastParams): CastHit[];
     /**
-     * Returns all actors whose colliders overlap the given query shape.
+     * Returns all collider intersections for the given query shape.
      *
      * @param params - Overlap parameters
-     * @returns Actors whose colliders overlap the shape
+     * @returns All overlap hits
      */
-    overlapShape(params: OverlapParams): Actor[];
+    overlapShape(params: OverlapParams): OverlapHit[];
+    /**
+     * Returns all collider intersections for an actor's collider.
+     *
+     * @param params - Actor overlap parameters
+     * @returns All overlap hits
+     */
+    overlapActor(params: OverlapActorParams): OverlapHit[];
     /**
      * Casts a shape and returns the nearest hit, if any.
      *
@@ -55,4 +83,18 @@ export declare class PhysicsAPI {
      * @returns All hits sorted from nearest to farthest
      */
     shapeCastAll(params: ShapeCastParams): CastHit[];
+    /**
+     * Casts an actor's collider and returns the nearest hit, if any.
+     *
+     * @param params - Actor cast parameters
+     * @returns The nearest hit or `null` when nothing is hit
+     */
+    castActor(params: CastActorParams): CastHit | null;
+    /**
+     * Casts an actor's collider and returns all hits sorted by distance.
+     *
+     * @param params - Actor cast parameters
+     * @returns All hits sorted from nearest to farthest
+     */
+    castActorAll(params: CastActorParams): CastHit[];
 }

package/build/contrib/systems/physics-system/api.js

@@ -9,9 +9,23 @@
  * @category Systems
  */
 export class PhysicsAPI {
-    collisionDetectionSubsystem;
-    constructor(collisionDetectionSubsystem) {
-        this.collisionDetectionSubsystem = collisionDetectionSubsystem;
+    handlers;
+    constructor(handlers) {
+        this.handlers = handlers;
+    }
+    /**
+     * Current gravity vector.
+     */
+    get gravity() {
+        return this.handlers.getGravity();
+    }
+    /**
+     * Sets the gravity vector.
+     *
+     * @param gravity - New gravity vector
+     */
+    set gravity(gravity) {
+        this.handlers.setGravity(gravity);
     }
     /**
      * Casts a ray and returns the nearest hit, if any.
@@ -23,7 +37,7 @@ export class PhysicsAPI {
      * @returns The nearest hit or `null` when nothing is hit
      */
     raycast(params) {
-        return this.collisionDetectionSubsystem.raycast(params);
+        return this.handlers.raycast(params);
     }
     /**
      * Casts a ray and returns all hits sorted by distance.
@@ -35,16 +49,25 @@ export class PhysicsAPI {
      * @returns All hits sorted from nearest to farthest
      */
     raycastAll(params) {
-        return this.collisionDetectionSubsystem.raycastAll(params);
+        return this.handlers.raycastAll(params);
     }
     /**
-     * Returns all actors whose colliders overlap the given query shape.
+     * Returns all collider intersections for the given query shape.
      *
      * @param params - Overlap parameters
-     * @returns Actors whose colliders overlap the shape
+     * @returns All overlap hits
      */
     overlapShape(params) {
-        return this.collisionDetectionSubsystem.overlapShape(params);
+        return this.handlers.overlapShape(params);
+    }
+    /**
+     * Returns all collider intersections for an actor's collider.
+     *
+     * @param params - Actor overlap parameters
+     * @returns All overlap hits
+     */
+    overlapActor(params) {
+        return this.handlers.overlapActor(params);
     }
     /**
      * Casts a shape and returns the nearest hit, if any.
@@ -53,7 +76,7 @@ export class PhysicsAPI {
      * @returns The nearest hit or `null` when nothing is hit
      */
     shapeCast(params) {
-        return this.collisionDetectionSubsystem.shapeCast(params);
+        return this.handlers.shapeCast(params);
     }
     /**
      * Casts a shape and returns all hits sorted by distance.
@@ -62,6 +85,24 @@ export class PhysicsAPI {
      * @returns All hits sorted from nearest to farthest
      */
     shapeCastAll(params) {
-        return this.collisionDetectionSubsystem.shapeCastAll(params);
+        return this.handlers.shapeCastAll(params);
+    }
+    /**
+     * Casts an actor's collider and returns the nearest hit, if any.
+     *
+     * @param params - Actor cast parameters
+     * @returns The nearest hit or `null` when nothing is hit
+     */
+    castActor(params) {
+        return this.handlers.castActor(params);
+    }
+    /**
+     * Casts an actor's collider and returns all hits sorted by distance.
+     *
+     * @param params - Actor cast parameters
+     * @returns All hits sorted from nearest to farthest
+     */
+    castActorAll(params) {
+        return this.handlers.castActorAll(params);
     }
 }

package/build/contrib/systems/physics-system/physics-system.d.ts

@@ -16,6 +16,7 @@ export declare class PhysicsSystem extends SceneSystem {
     private collisionBroadcastSubsystem;
     private constraintSolver;
     private physicsApi;
+    private gravity;
     constructor(options: SceneSystemOptions);
     onSceneEnter(): void;
     onSceneExit(): void;

package/build/contrib/systems/physics-system/physics-system.js

@@ -1,4 +1,5 @@
 import { SceneSystem } from '../../../engine/system';
+import { Vector2 } from '../../../engine/math-lib';
 import { PhysicsSubsystem, CollisionDetectionSubsystem, CollisionBroadcastSubsystem, ConstraintSolver, } from './subsystems';
 import { PhysicsAPI } from './api';
 /**
@@ -17,14 +18,33 @@ export class PhysicsSystem extends SceneSystem {
     collisionBroadcastSubsystem;
     constraintSolver;
     physicsApi;
+    gravity;
     constructor(options) {
         super();
+        const { gravityX = 0, gravityY = 0 } = options;
+        this.gravity = new Vector2(gravityX, gravityY);
         this.world = options.world;
-        this.physicsSubsystem = new PhysicsSubsystem(options);
+        this.physicsSubsystem = new PhysicsSubsystem({
+            scene: options.scene,
+            getGravity: () => this.gravity,
+        });
         this.collisionDetectionSubsystem = new CollisionDetectionSubsystem(options);
         this.collisionBroadcastSubsystem = new CollisionBroadcastSubsystem();
         this.constraintSolver = new ConstraintSolver();
-        this.physicsApi = new PhysicsAPI(this.collisionDetectionSubsystem);
+        this.physicsApi = new PhysicsAPI({
+            raycast: (params) => this.collisionDetectionSubsystem.raycast(params),
+            raycastAll: (params) => this.collisionDetectionSubsystem.raycastAll(params),
+            overlapShape: (params) => this.collisionDetectionSubsystem.overlapShape(params),
+            overlapActor: (params) => this.collisionDetectionSubsystem.overlapActor(params),
+            shapeCast: (params) => this.collisionDetectionSubsystem.shapeCast(params),
+            shapeCastAll: (params) => this.collisionDetectionSubsystem.shapeCastAll(params),
+            castActor: (params) => this.collisionDetectionSubsystem.castActor(params),
+            castActorAll: (params) => this.collisionDetectionSubsystem.castActorAll(params),
+            getGravity: () => this.gravity,
+            setGravity: (gravity) => {
+                this.gravity = gravity;
+            },
+        });
     }
     onSceneEnter() {
         this.world.systemApi.register(this.physicsApi);
@@ -33,7 +53,6 @@ export class PhysicsSystem extends SceneSystem {
         this.world.systemApi.unregister(PhysicsAPI);
     }
     onSceneDestroy() {
-        this.world.systemApi.unregister(PhysicsAPI);
         this.physicsSubsystem.destroy();
         this.collisionDetectionSubsystem.destroy();
     }

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

@@ -1,3 +1,5 @@
+import type { Collider, Transform } from '../../../../../components';
 import type { BoxCastGeometry } from '../types';
-import type { BoxCastParams } from '../../../types';
-export declare function buildBoxCastGeometry(shapeCast: BoxCastParams): BoxCastGeometry;
+import type { BoxCastParams, CastActorParams } from '../../../types';
+export declare function buildBoxCastGeometry(castParams: BoxCastParams): BoxCastGeometry;
+export declare function buildBoxCastGeometry(collider: Collider, transform: Transform, castParams: CastActorParams): BoxCastGeometry;

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

@@ -1,6 +1,9 @@
 import { buildBoxGeometry } from './build-box-geometry';
-export function buildBoxCastGeometry(shapeCast) {
-    const box = buildBoxGeometry(shapeCast);
+export function buildBoxCastGeometry(castParamsOrCollider, transform, castParams) {
+    const params = castParams ?? castParamsOrCollider;
+    const box = transform !== undefined
+        ? buildBoxGeometry(castParamsOrCollider, transform, castParams)
+        : buildBoxGeometry(castParamsOrCollider);
     let minX = Infinity;
     let maxX = -Infinity;
     let minY = Infinity;
@@ -14,8 +17,8 @@ export function buildBoxCastGeometry(shapeCast) {
     return {
         ...box,
         origin: box.center,
-        direction: shapeCast.direction.normalize(),
-        maxDistance: shapeCast.maxDistance,
+        direction: params.direction.clone().normalize(),
+        maxDistance: params.maxDistance,
         halfExtents: {
             x: (maxX - minX) / 2,
             y: (maxY - minY) / 2,

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

@@ -1,5 +1,5 @@
 import type { Collider, Transform } from '../../../../../components';
-import type { BoxGeometry } from '../types';
-import type { OverlapBoxParams } from '../../../types';
-export declare function buildBoxGeometry(overlap: OverlapBoxParams): BoxGeometry;
-export declare function buildBoxGeometry(collider: Collider, transform: Transform): BoxGeometry;
+import type { ActorGeometryParams, BoxGeometry } from '../types';
+import type { OverlapBoxParams, BoxCastParams } from '../../../types';
+export declare function buildBoxGeometry(queryParams: OverlapBoxParams | BoxCastParams): BoxGeometry;
+export declare function buildBoxGeometry(collider: Collider, transform: Transform, params?: ActorGeometryParams): BoxGeometry;

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

@@ -1,7 +1,7 @@
 import { VectorOps } from '../../../../../../engine/math-lib';
-export function buildBoxGeometry(colliderOrOverlap, transform) {
-    let centerX;
-    let centerY;
+export function buildBoxGeometry(colliderOrQueryParams, transform, params) {
+    let offsetX;
+    let offsetY;
     let sizeX;
     let sizeY;
     let positionX;
@@ -10,29 +10,29 @@ export function buildBoxGeometry(colliderOrOverlap, transform) {
     let scaleX;
     let scaleY;
     if (transform !== undefined) {
-        const collider = colliderOrOverlap;
+        const collider = colliderOrQueryParams;
         if (collider.shape.type !== 'box') {
             throw new Error(`Expected box collider, got ${collider.shape.type}.`);
         }
-        centerX = collider.offset.x;
-        centerY = collider.offset.y;
+        offsetX = collider.offset.x;
+        offsetY = collider.offset.y;
         sizeX = collider.shape.size.x;
         sizeY = collider.shape.size.y;
-        positionX = transform.world.position.x;
-        positionY = transform.world.position.y;
+        positionX = transform.world.position.x + (params?.offset?.x ?? 0);
+        positionY = transform.world.position.y + (params?.offset?.y ?? 0);
         rotation = transform.world.rotation;
         scaleX = transform.world.scale.x;
         scaleY = transform.world.scale.y;
     }
     else {
-        const overlap = colliderOrOverlap.shape;
-        centerX = 0;
-        centerY = 0;
-        sizeX = overlap.size.x;
-        sizeY = overlap.size.y;
-        positionX = overlap.center.x;
-        positionY = overlap.center.y;
-        rotation = overlap.rotation ?? 0;
+        const queryShape = colliderOrQueryParams.shape;
+        offsetX = 0;
+        offsetY = 0;
+        sizeX = queryShape.size.x;
+        sizeY = queryShape.size.y;
+        positionX = queryShape.center.x;
+        positionY = queryShape.center.y;
+        rotation = queryShape.rotation ?? 0;
         scaleX = 1;
         scaleY = 1;
     }
@@ -42,12 +42,12 @@ export function buildBoxGeometry(colliderOrOverlap, transform) {
     const y2 = sizeY / 2;
     const cos = Math.cos(rotation);
     const sin = Math.sin(rotation);
-    centerX += positionX;
-    centerY += positionY;
-    const center = {
-        x: centerX,
-        y: centerY,
-    };
+    const center = VectorOps.rotatePoint({
+        x: offsetX * scaleX,
+        y: offsetY * scaleY,
+    }, rotation);
+    center.x += positionX;
+    center.y += positionY;
     const points = [
         { x: x1, y: y1 },
         { x: x1, y: y2 },

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

@@ -1,3 +1,5 @@
+import type { Collider, Transform } from '../../../../../components';
 import type { CapsuleCastGeometry } from '../types';
-import type { CapsuleCastParams } from '../../../types';
-export declare function buildCapsuleCastGeometry(shapeCast: CapsuleCastParams): CapsuleCastGeometry;
+import type { CapsuleCastParams, CastActorParams } from '../../../types';
+export declare function buildCapsuleCastGeometry(castParams: CapsuleCastParams): CapsuleCastGeometry;
+export declare function buildCapsuleCastGeometry(collider: Collider, transform: Transform, castParams: CastActorParams): CapsuleCastGeometry;