@woosh/meep-engine 2.138.20 → 2.140.0

package/src/engine/physics/ecs/PhysicsSystem.d.ts

@@ -0,0 +1,628 @@
+/**
+ * Rigid-body physics system.
+ *
+ * v1 scope: pool + active list + two BVHs (static / dynamic), Transform sync
+ * contract, and the user-facing API surface (gravity, force / impulse, layer
+ * filtering, wake / sleep, contact filter). The per-step simulation pipeline
+ * (broadphase pair generation, narrowphase, solver, islands, sleep test,
+ * contact-event emission) is built on top of this skeleton in subsequent
+ * iterations.
+ *
+ * Dependency tuple is `(RigidBody, Collider, Transform)` — every body has
+ * exactly one collider on the same entity. Compound bodies via child collider
+ * entities are an extension point handled by a follow-up sub-observer.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class PhysicsSystem extends System<any, any, any, any, any> {
+    constructor();
+    dependencies: (typeof Transform | typeof RigidBody)[];
+    components_used: (ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof Transform>)[];
+    /**
+     * @type {BodyStorage}
+     */
+    storage: BodyStorage;
+    /**
+     * @type {BVH}
+     */
+    staticBvh: BVH;
+    /**
+     * @type {BVH}
+     */
+    dynamicBvh: BVH;
+    /**
+     * Persistent contact-manifold cache. One slot per active pair.
+     * @type {ManifoldStore}
+     */
+    manifolds: ManifoldStore;
+    /**
+     * Per-frame list of broadphase-overlapping pairs (canonical
+     * `(min, max)`). Cleared at the top of each step.
+     * @type {PairList}
+     */
+    pairs: PairList;
+    /**
+     * Per-frame contact-event buffer. Populated by the manifold diff
+     * pass at end-of-step and consumed by the dispatch pass.
+     * @type {ContactEventBuffer}
+     */
+    contactEvents: ContactEventBuffer;
+    /**
+     * Per-frame island partitioning of the awake-body + contact graph.
+     * Rebuilt after narrowphase, consumed by the solver (and, in the
+     * follow-up slice, by the per-island atomic sleep test). Bodies
+     * static and kinematic act as constraint anchors and do not enlarge
+     * islands.
+     * @type {IslandBuilder}
+     */
+    islands: IslandBuilder;
+    /**
+     * Velocity-squared threshold below which a body is eligible to start
+     * accumulating sleep time. Combined linear + angular kinetic-ish
+     * metric: `vx²+vy²+vz² + ωx²+ωy²+ωz²`. Default 0.01 corresponds to
+     * ~0.1 m/s linear or ~0.1 rad/s angular.
+     * @type {number}
+     */
+    sleepVelocitySqrThreshold: number;
+    /**
+     * Seconds of below-threshold motion before a body is moved to the
+     * sleeping set. Box2D default is 0.5 s.
+     * @type {number}
+     */
+    sleepTimeThreshold: number;
+    /**
+     * Number of TGS substeps per `fixedUpdate`. Each substep re-runs the
+     * velocity + position solve at `dt / substeps` against contacts whose
+     * penetration is re-derived analytically from the bodies' moved poses
+     * — narrowphase still runs once per outer step. Higher counts buy
+     * stack stability, high-mass-ratio robustness, and smoother
+     * trajectories at a near-linear solver cost (sleeping islands are
+     * unaffected — they never enter the loop).
+     *
+     * `1` reproduces the non-substepped (single-step) solve.
+     * @type {number}
+     */
+    substeps: number;
+    /**
+     * Velocity iterations per substep. Lower than a single-step solver
+     * would need, because the substep loop revisits the contact set
+     * `substeps` times.
+     * @type {number}
+     */
+    velocityIterations: number;
+    /**
+     * Position (split-impulse) iterations per substep.
+     * @type {number}
+     */
+    positionIterations: number;
+    /**
+     * Reusable contact-event payload. Listeners must copy any fields they
+     * intend to retain past their own scope. Reset before each dispatch.
+     * @private
+     */
+    private __contact_payload;
+    /**
+     * World gravity, m/s². Applied each step scaled by per-body gravityScale.
+     * @readonly
+     * @type {Vector3}
+     */
+    readonly gravity: Vector3;
+    /**
+     * Emitted at end-of-step for newly established contact pairs.
+     * @readonly
+     * @type {Signal}
+     */
+    readonly onContactBegin: Signal;
+    /**
+     * Emitted at end-of-step for contact pairs that persisted from the previous step.
+     * @readonly
+     * @type {Signal}
+     */
+    readonly onContactStay: Signal;
+    /**
+     * Emitted at end-of-step for contact pairs that disappeared.
+     * @readonly
+     * @type {Signal}
+     */
+    readonly onContactEnd: Signal;
+    /**
+     * Optional global contact filter. Called for each surviving broadphase
+     * pair; returning `false` discards the pair.
+     * @type {((entityA: number, entityB: number, colliderA: Collider, colliderB: Collider) => boolean) | null}
+     * @private
+     */
+    private __contact_filter;
+    /**
+     * Per-body component side-tables indexed by body index (NOT packed id).
+     * Sparse arrays — populated at link, cleared at unlink. The hot loop
+     * iterates `storage.awake_at(i)` and dereferences these.
+     * @type {RigidBody[]}
+     */
+    __bodies: RigidBody[];
+    /** @type {Transform[]} */
+    __transforms: Transform[];
+    /**
+     * Per-body list of attached colliders. Each entry stores the
+     * Collider component, its world Transform, the entity that owns
+     * it (the body entity for same-entity attachments, a child entity
+     * for compound bodies), and the BVH leaf id assigned at attach
+     * time. A body may have zero or more attached colliders.
+     *
+     * @type {Array<Array<{collider: Collider, transform: Transform, entity: number, bvhNode: number}>>}
+     */
+    __body_collider_lists: Array<Array<{
+        collider: Collider;
+        transform: Transform;
+        entity: number;
+        bvhNode: number;
+    }>>;
+    /**
+     * Per-body pseudo-velocity for the Catto split-impulse position
+     * pass (TGS Phase 1). Flat layout, 6 doubles per body slot index:
+     * `[lin.x, lin.y, lin.z, ang.x, ang.y, ang.z]`. Sized to
+     * `storage.high_water_mark * 6` at the top of each fixedUpdate
+     * and zeroed in place so unwritten slots contribute nothing to
+     * `integrate_position`.
+     *
+     * The solver writes during its position pass; `integrate_position`
+     * reads and folds into the pose update on the same tick, then
+     * the next tick's zero-pass wipes the state. It NEVER lands in
+     * `linearVelocity` / `angularVelocity` — that's the point of
+     * split impulse: depth correction does not contaminate persistent
+     * velocity (so a `restitution = 0` impact stops cleanly).
+     *
+     * @type {Float64Array}
+     */
+    __pseudo_velocity: Float64Array;
+    /**
+     * Bound reference to {@link __pair_filter} so we hand the same
+     * callable to {@link generate_pairs} each step without per-step
+     * allocation.
+     * @private
+     */
+    private __pair_filter_bound;
+    /**
+     * Symmetric layer/mask check + optional user callback. Called per
+     * candidate pair during broadphase. Returns `true` to accept the pair.
+     *
+     * Layer/mask rule: pair (A, B) collides iff
+     *   `(A.layer & B.mask) !== 0 && (B.layer & A.mask) !== 0`.
+     * The user's contact-filter callback is consulted only for pairs that
+     * pass the bitmask test (cheap gate first).
+     *
+     * @private
+     * @param {number} idA packed body id
+     * @param {number} idB packed body id
+     * @returns {boolean}
+     */
+    private __pair_filter;
+    /**
+     * First attached collider of a body, or `null` if none. Used by the
+     * solver to read material parameters (friction / restitution) when the
+     * per-contact source-collider identity isn't tracked yet (v1 limitation
+     * — multi-collider bodies with mixed materials lose precision here).
+     *
+     * @private
+     * @param {number} body_idx
+     * @returns {Collider|null}
+     */
+    private __primary_collider;
+    /**
+     * Resize {@link __pseudo_velocity} to cover every live body slot and
+     * zero its contents. Called at the top of each fixedUpdate so the
+     * split-impulse position pass starts from a clean state — bodies the
+     * solver doesn't touch contribute zero pseudo-velocity to
+     * {@link integrate_position}.
+     *
+     * Doubles on growth like the other physics scratches; never shrinks.
+     *
+     * @private
+     */
+    private __reset_pseudo_velocity;
+    /**
+     * Replace the world gravity vector. Effective on the next step.
+     * @param {Vector3|{x:number,y:number,z:number}} v
+     */
+    setGravity(v: Vector3 | {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    /**
+     * Install (or remove with `null`) the contact filter callback.
+     * @param {((entityA:number, entityB:number, colliderA:Collider, colliderB:Collider) => boolean) | null} fn
+     */
+    setContactFilter(fn: (entityA: number, entityB: number, colliderA: Collider, colliderB: Collider) => boolean): void;
+    /**
+     * @returns {((entityA:number, entityB:number, colliderA:Collider, colliderB:Collider) => boolean) | null}
+     */
+    getContactFilter(): (entityA: number, entityB: number, colliderA: Collider, colliderB: Collider) => boolean;
+    /**
+     * @private
+     * @param {RigidBody} rb
+     * @param {Collider} collider
+     * @param {Transform} transform
+     * @returns {number} BVH node id
+     */
+    private __insert_into_broadphase;
+    /**
+     * @private
+     * @param {RigidBody} rb
+     * @param {number} node
+     */
+    private __remove_from_broadphase;
+    /**
+     * Lifecycle entry: invoked when an entity gains the (RigidBody, Transform)
+     * tuple. Allocates the body's slot in storage and seeds an empty collider
+     * list. Colliders are attached separately via {@link attach_collider} (the
+     * paired {@link ColliderObserverSystem} drives this from the dataset; in
+     * tests, call manually).
+     *
+     * @param {RigidBody} rigidBody
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    link(rigidBody: RigidBody, transform: Transform, entity: number): void;
+    /**
+     * Detach every collider attached to this body, free its slot, and clear
+     * the side-tables.
+     *
+     * @param {RigidBody} rigidBody
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    unlink(rigidBody: RigidBody, transform: Transform, entity: number): void;
+    /**
+     * Attach a collider to an existing body. The collider can live on the
+     * same entity as the body (single-collider body) or on a child entity
+     * (compound body). The world transform passed here is the collider's
+     * own — for a same-entity collider it is the body's Transform; for a
+     * child collider it is the child entity's Transform.
+     *
+     * Idempotent — re-attaching the same collider is a no-op.
+     *
+     * @param {number} body_entity entity that owns the body
+     * @param {Collider} collider
+     * @param {Transform} transform world transform of the collider
+     * @param {number} [collider_entity] entity owning the collider (defaults to body_entity)
+     */
+    attach_collider(body_entity: number, collider: Collider, transform: Transform, collider_entity?: number): void;
+    /**
+     * Reverse of {@link attach_collider}. Idempotent.
+     *
+     * @param {number} body_entity
+     * @param {Collider} collider
+     */
+    detach_collider(body_entity: number, collider: Collider): void;
+    /**
+     * Linear scan over body slots looking for the one whose entity matches.
+     * O(N) where N is the live body count — only called on the link/unlink
+     * paths, not during simulation, so the scan cost is bounded.
+     *
+     * @private
+     * @param {number} entity
+     * @returns {number} body index or -1
+     */
+    private __find_body_index_by_entity;
+    /**
+     * Resolve a packed body id to its entity, or `-1` if the id is stale.
+     * @param {number} packed_body_id
+     * @returns {number}
+     */
+    entityOf(packed_body_id: number): number;
+    /**
+     * Number of live bodies (regardless of awake/sleeping state).
+     * @returns {number}
+     */
+    get bodyCount(): number;
+    /**
+     * Apply an instantaneous change of momentum at the body's centre of mass.
+     * Linear-only — see {@link applyImpulseAt} for an off-centre impulse that
+     * also produces angular response.
+     *
+     * Wakes the body if it is asleep.
+     *
+     * @param {RigidBody} rigidBody
+     * @param {Vector3|{x:number,y:number,z:number}} impulse
+     */
+    applyImpulse(rigidBody: RigidBody, impulse: Vector3 | {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    /**
+     * Apply an instantaneous change of momentum at a specific world-space point.
+     * Off-centre impulses produce both linear (Δv = P/m) and angular
+     * (Δω = I_w⁻¹·(r × P)) response.
+     *
+     * Wakes the body if it is asleep.
+     *
+     * @param {RigidBody} rigidBody
+     * @param {Transform} transform body's current world Transform (used for r and I_w)
+     * @param {Vector3|{x:number,y:number,z:number}} impulse
+     * @param {Vector3|{x:number,y:number,z:number}} worldPoint
+     */
+    applyImpulseAt(rigidBody: RigidBody, transform: Transform, impulse: Vector3 | {
+        x: number;
+        y: number;
+        z: number;
+    }, worldPoint: Vector3 | {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    /**
+     * Accumulate a continuous torque (world-space) for integration on the
+     * next fixedUpdate. Pairs with {@link applyForce} for the rotational case.
+     *
+     * Wakes the body if asleep.
+     *
+     * @param {RigidBody} rigidBody
+     * @param {Vector3|{x:number,y:number,z:number}} torque
+     */
+    applyTorque(rigidBody: RigidBody, torque: Vector3 | {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    /**
+     * Apply a continuous force at a specific world-space point. The force
+     * generates both a linear acceleration (F/m) and a torque (r × F) about
+     * the body's centre of mass.
+     *
+     * Wakes the body if asleep.
+     *
+     * @param {RigidBody} rigidBody
+     * @param {Transform} transform body's current world Transform
+     * @param {Vector3|{x:number,y:number,z:number}} force
+     * @param {Vector3|{x:number,y:number,z:number}} worldPoint
+     */
+    applyForceAt(rigidBody: RigidBody, transform: Transform, force: Vector3 | {
+        x: number;
+        y: number;
+        z: number;
+    }, worldPoint: Vector3 | {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    /**
+     * Accumulate a continuous force to be integrated next fixedUpdate step.
+     * Wakes the body if asleep.
+     *
+     * @param {RigidBody} rigidBody
+     * @param {Vector3|{x:number,y:number,z:number}} force
+     */
+    applyForce(rigidBody: RigidBody, force: Vector3 | {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    /**
+     * Replace the linear velocity. Wakes the body if asleep.
+     *
+     * @param {RigidBody} rigidBody
+     * @param {Vector3|{x:number,y:number,z:number}} v
+     */
+    setLinearVelocity(rigidBody: RigidBody, v: Vector3 | {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    /**
+     * Force the body awake. Static bodies are ignored.
+     * @param {RigidBody} rigidBody
+     */
+    wake(rigidBody: RigidBody): void;
+    /**
+     * Force the body asleep. Dynamic bodies will not re-enter the active list
+     * until a wake event occurs.
+     * @param {RigidBody} rigidBody
+     */
+    sleep(rigidBody: RigidBody): void;
+    /**
+     * Wake a body and atomically wake every other body it was last sleeping
+     * with (its "sleep group"). Sleep groups are circular doubly-linked lists
+     * threaded through every member of an island when it sleeps atomically;
+     * waking any one member walks the chain and wakes the rest in the same
+     * call.
+     *
+     * Without this, a 100-block stack hit at the base would wake one block
+     * per frame as the broadphase propagated awareness up the stack — a
+     * visible ~1.6 s wave at 60 fps. Atomic wake eliminates the wave.
+     *
+     * No-op for non-dynamic bodies. Idempotent for already-awake bodies.
+     * @private
+     * @param {RigidBody} rb
+     */
+    private __wake_body;
+    /**
+     * Atomically put every body in a contiguous range of island members to
+     * sleep. Members are threaded into a circular doubly-linked list so any
+     * future `wake` on any member walks the chain and revives them all.
+     *
+     * Velocities are zeroed because the body is by definition at rest at
+     * this point — the alternative (storing residual velocities for "softer"
+     * wake) is what Bullet does, but for a deterministic game-physics target
+     * fully resetting is simpler and avoids drift while sleeping.
+     *
+     * @private
+     * @param {Uint32Array} member_array view (or full array) of body indices
+     * @param {number} start
+     * @param {number} end
+     */
+    private __atomic_sleep_island_range;
+    /**
+     * Get the body index for a packed body id without revalidation. Used by
+     * query traversals that already trust the id came from a live BVH leaf.
+     * @param {number} packed_body_id
+     * @returns {number}
+     */
+    __index_of(packed_body_id: number): number;
+    /**
+     * Broadphase raycast against both BVHs. Fills `result` with the nearest
+     * hit and returns `true` on hit, `false` on miss.
+     *
+     * Narrowphase refinement against the actual shape geometry is a
+     * follow-up — for now `result.t` is the distance to the leaf's
+     * inflated AABB and `result.normal` is the AABB face normal. Both are
+     * exact for AABB-shaped colliders.
+     *
+     * @param {Ray3} ray  origin + unit direction + `tMax`
+     * @param {PhysicsSurfacePoint} result populated on hit; untouched on miss
+     * @param {(entity:number, collider:Collider)=>boolean} [filter] defaults
+     *   to {@link returnTrue} (accept every candidate)
+     * @returns {boolean}
+     */
+    raycast(ray: Ray3, result: PhysicsSurfacePoint, filter?: (entity: number, collider: Collider) => boolean): boolean;
+    /**
+     * Sweep a convex shape along a ray and find the first body it
+     * would hit. The shape starts at `ray.origin` oriented by
+     * `rotation` and translates along `ray.direction` for up to
+     * `ray.tMax` units. Returns the nearest impact within that
+     * interval.
+     *
+     * The "swept AABB" broadphase finds candidate bodies whose BVH
+     * leaves overlap the shape's swept volume; the narrowphase then
+     * bisects [0, t] on GJK overlap to find the time-of-impact for
+     * each candidate. Best-t early termination skips candidates that
+     * can't tighten the answer.
+     *
+     * @param {Ray3} ray  origin + unit direction + `tMax`
+     * @param {AbstractShape3D} shape
+     * @param {{x:number,y:number,z:number,w:number}} rotation
+     * @param {PhysicsSurfacePoint} result populated on hit; untouched on miss
+     * @param {(entity:number, collider:Collider)=>boolean} [filter]
+     * @returns {boolean}
+     */
+    shapeCast(ray: Ray3, shape: AbstractShape3D, rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }, result: PhysicsSurfacePoint, filter?: (entity: number, collider: Collider) => boolean): boolean;
+    /**
+     * Speculative overlap query: find all bodies whose collider would
+     * overlap the given convex shape placed at the given world pose,
+     * without mutating the simulation. Intended for kinematic /
+     * character controllers that need to test "would I collide if I
+     * moved here?" before committing the move.
+     *
+     * Pipeline:
+     *   1. The shape's world AABB is computed from `position` + `rotation`.
+     *   2. Both broadphase trees (static + dynamic) are queried for
+     *      bodies whose leaf AABB overlaps that envelope.
+     *   3. Each candidate is GJK-tested in world frame. Convex
+     *      candidates run one GJK call; concave candidates (heightmap,
+     *      mesh) run per-triangle GJK via the decomposition path.
+     *   4. The optional `filter` is consulted before the GJK test —
+     *      useful for skipping the caller's own body, allies, sensors,
+     *      etc.
+     *
+     * The output buffer is filled with overlapping bodies' `body_id`
+     * values (uint32 with packed generation), starting at
+     * `output_offset`. The caller is responsible for sizing the buffer;
+     * IDs past its end are dropped silently and the count caps at the
+     * available space.
+     *
+     * The query shape must be convex. Concave query shapes throw —
+     * they're typically static terrain and not used as kinematic
+     * probes; the M×N triangle-pair cost wouldn't be worth the rare
+     * use case.
+     *
+     * @param {AbstractShape3D} shape convex query shape, in its local frame
+     * @param {{x:number,y:number,z:number}} position world position of
+     *   the query shape
+     * @param {{x:number,y:number,z:number,w:number}} rotation world
+     *   rotation (unit quaternion)
+     * @param {Uint32Array|number[]} output buffer to receive body_ids
+     * @param {number} output_offset starting index in output
+     * @param {(entity:number, collider:Collider)=>boolean} [filter]
+     *   defaults to {@link returnTrue}
+     * @returns {number} number of overlapping bodies written
+     */
+    overlap(shape: AbstractShape3D, position: {
+        x: number;
+        y: number;
+        z: number;
+    }, rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }, output: Uint32Array | number[], output_offset: number, filter?: (entity: number, collider: Collider) => boolean): number;
+    /**
+     * Run one simulation step. v1 pipeline: integrate velocity → integrate
+     * position → refit broadphase AABBs. Narrowphase, solver, islands and
+     * contact-event emission land in subsequent slices.
+     *
+     * @param {number} dt
+     */
+    /**
+     * Wake any sleeping body that appears in this step's broadphase pair list.
+     * A pair means the BVH AABBs overlap — even if the sleeper hasn't moved,
+     * an awake neighbour has come into contact range and the sleeper must
+     * participate in narrowphase / solve.
+     * @private
+     */
+    private __wake_pairs;
+    /**
+     * Per-island atomic sleep test. Walks each island once and applies the
+     * decision uniformly across all members:
+     *
+     *  - If any member carries {@link RigidBodyFlags.DisableSleep}, the
+     *    entire island is exempt; every member's sleep_timer is reset.
+     *  - If `max(|v|² + |ω|²)` across all members is below
+     *    {@link sleepVelocitySqrThreshold}, every member's sleep_timer is
+     *    incremented by `dt`. When the smallest member's timer crosses
+     *    {@link sleepTimeThreshold}, the whole island sleeps atomically in
+     *    the same step (members get threaded into a sleep-group chain so
+     *    {@link __wake_body} can wake them all in one call).
+     *  - Otherwise the island has at least one active member, so every
+     *    member's timer is reset.
+     *
+     * This is the design-plan atomic-island sleep — replaces the per-body
+     * approximation that lived in this slot during the previous slice.
+     * Weakly-connected piles no longer chatter awake when a single member
+     * blips above threshold; piles fall asleep and wake up as one.
+     *
+     * @private
+     * @param {number} dt
+     */
+    private __sleep_test;
+    /**
+     * Dispatch every buffered contact event through:
+     *  - the system-level Signals ({@link onContactBegin}/Stay/End), always; and
+     *  - the entity-level event channel via `dataset.sendEvent(entity, name, payload)`,
+     *    when a dataset is attached.
+     *
+     * Payload is a reused scratch object; listeners must copy anything they
+     * intend to retain past the listener body.
+     * @private
+     */
+    private __dispatch_contact_events;
+    fixedUpdate(dt: any): void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isPhysicsSystem: boolean;
+}
+import { System } from "../../ecs/System.js";
+import { Transform } from "../../ecs/transform/Transform.js";
+import { RigidBody } from "./RigidBody.js";
+import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
+import { Collider } from "./Collider.js";
+import { BodyStorage } from "../body/BodyStorage.js";
+import { BVH } from "../../../core/bvh2/bvh3/BVH.js";
+import { ManifoldStore } from "../contact/ManifoldStore.js";
+import { PairList } from "../broadphase/PairList.js";
+import { ContactEventBuffer } from "../events/ContactEventBuffer.js";
+import { IslandBuilder } from "../island/IslandBuilder.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import Signal from "../../../core/events/signal/Signal.js";
+import { BodyKind } from "./BodyKind.js";
+import { RigidBodyFlags } from "./RigidBodyFlags.js";
+export { BodyKind, RigidBodyFlags };
+//# sourceMappingURL=PhysicsSystem.d.ts.map

package/src/engine/physics/ecs/PhysicsSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/PhysicsSystem.js"],"names":[],"mappings":"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"}