emeraldengine 3.0.0 → 3.1.0

package/dist/types/src/physics/DistanceJoint.d.ts

@@ -0,0 +1,90 @@
+export default DistanceJoint;
+/**
+ * @class DistanceJoint
+ * @extends Joint
+ * @description Holds two anchor points at a fixed distance apart, like a
+ * rigid rod. Passing `frequencyHz` turns it into a damped spring pulling the
+ * anchors toward that distance instead of holding it exactly, for tethers
+ * and camera rigs that should have some give.
+ * @param {Object} def - `{ bodyA, bodyB, localAnchorA, localAnchorB, length,
+ *   frequencyHz, dampingRatio, collideConnected, userData }`
+ */
+declare class DistanceJoint extends Joint {
+    localAnchorA: Vec2;
+    localAnchorB: Vec2;
+    length: any;
+    frequencyHz: any;
+    dampingRatio: any;
+    impulse: number;
+    gamma: number;
+    bias: number;
+    u: Vec2;
+    rA: Vec2;
+    rB: Vec2;
+    mass: number;
+    /** @private */
+    private indexA;
+    /** @private */
+    private indexB;
+    /**
+     * @method getAnchorA
+     * @returns {Vec2}
+     */
+    getAnchorA(): Vec2;
+    /**
+     * @method getAnchorB
+     * @returns {Vec2}
+     */
+    getAnchorB(): Vec2;
+    /**
+     * @method getReactionForce
+     * @param {number} invDt
+     * @returns {Vec2}
+     */
+    getReactionForce(invDt: number): Vec2;
+    /**
+     * @method getReactionTorque
+     * @returns {number}
+     */
+    getReactionTorque(): number;
+    /**
+     * @method setLength
+     * @param {number} length
+     */
+    setLength(length: number): void;
+    /**
+     * @method getLength
+     * @returns {number}
+     */
+    getLength(): number;
+    /**
+     * @method initVelocityConstraints
+     * @description Effective mass at the current anchor separation, plus (for
+     * a soft joint) the spring-damper bias for this step.
+     * @param {Object} step - `{ dt, warmStarting }`
+     * @param {Array<Object>} positions
+     * @param {Array<Object>} velocities
+     */
+    initVelocityConstraints(step: any, positions: Array<any>, velocities: Array<any>): void;
+    invMassA: any;
+    invMassB: any;
+    invIA: any;
+    invIB: any;
+    /**
+     * @method solveVelocityConstraints
+     * @param {Object} step - `{ dt }` (unused here, kept for a uniform joint interface)
+     * @param {Array<Object>} velocities
+     */
+    solveVelocityConstraints(step: any, velocities: Array<any>): void;
+    /**
+     * @method solvePositionConstraints
+     * @description Skipped for a soft (spring) joint: the bias already pulled
+     * it toward rest length during the velocity pass, and correcting position
+     * on top of that would fight the spring.
+     * @param {Array<Object>} positions
+     * @returns {boolean}
+     */
+    solvePositionConstraints(positions: Array<any>): boolean;
+}
+import { Joint } from "./Joint.js";
+import { Vec2 } from "./Math2D.js";

package/dist/types/src/physics/Fixture.d.ts

@@ -0,0 +1,221 @@
+/**
+ * @class Fixture
+ * @description A shape bound to a body, together with the material properties
+ * that decide how contacts behave: density (which feeds the body's mass),
+ * friction, restitution (bounciness), the sensor flag, and the collision
+ * filter. A body can carry any number of fixtures.
+ *
+ * Fixtures are created through {@link Body#createFixture}, never directly.
+ */
+export class Fixture {
+    constructor(body: any, shape: any, def?: {});
+    body: any;
+    shape: any;
+    density: any;
+    friction: any;
+    restitution: any;
+    sensor: boolean;
+    userData: any;
+    filter: {
+        categoryBits: any;
+        maskBits: any;
+        groupIndex: any;
+    };
+    /** @private */
+    private proxies;
+    /** @private */
+    private next;
+    /**
+     * @method getType
+     * @description Returns the underlying shape type ("circle" or "polygon").
+     * @returns {string}
+     */
+    getType(): string;
+    /**
+     * @method getShape
+     * @description Returns the fixture's shape.
+     * @returns {Shape}
+     */
+    getShape(): Shape;
+    /**
+     * @method getBody
+     * @description Returns the body this fixture is attached to.
+     * @returns {Body}
+     */
+    getBody(): Body;
+    /**
+     * @method getNext
+     * @description Returns the next fixture on the same body, or null.
+     * @returns {Fixture|null}
+     */
+    getNext(): Fixture | null;
+    /**
+     * @method setUserData
+     * @description Attaches arbitrary data to the fixture.
+     * @param {*} data
+     */
+    setUserData(data: any): void;
+    /**
+     * @method getUserData
+     * @description Returns the attached data.
+     * @returns {*}
+     */
+    getUserData(): any;
+    /**
+     * @method setSensor
+     * @description A sensor still reports contacts but never generates a
+     * collision response: the classic trigger volume.
+     * @param {boolean} value
+     */
+    setSensor(value: boolean): void;
+    /**
+     * @method isSensor
+     * @description Whether this fixture is a sensor.
+     * @returns {boolean}
+     */
+    isSensor(): boolean;
+    /**
+     * @method setFilterData
+     * @description Replaces the collision filter. Two fixtures collide only when
+     * each one's category bit appears in the other's mask (or they share a
+     * positive group index).
+     * @param {Object} filter - `{ categoryBits, maskBits, groupIndex }`
+     */
+    setFilterData(filter?: any): void;
+    /**
+     * @method getFilterData
+     * @description Returns the current collision filter.
+     * @returns {Object}
+     */
+    getFilterData(): any;
+    /**
+     * @method getFilterCategoryBits
+     * @description Returns the category bits.
+     * @returns {number}
+     */
+    getFilterCategoryBits(): number;
+    /**
+     * @method getFilterMaskBits
+     * @description Returns the mask bits.
+     * @returns {number}
+     */
+    getFilterMaskBits(): number;
+    /**
+     * @method getFilterGroupIndex
+     * @description Returns the group index.
+     * @returns {number}
+     */
+    getFilterGroupIndex(): number;
+    /**
+     * @method refilter
+     * @description Re-evaluates existing contacts after a filter change, so a
+     * fixture that just stopped colliding with a layer separates immediately
+     * instead of on its next move.
+     */
+    refilter(): void;
+    /**
+     * @method setDensity
+     * @description Sets the density. Call {@link Body#resetMassData} afterwards
+     * for it to take effect on the body's mass.
+     * @param {number} density
+     */
+    setDensity(density: number): void;
+    /**
+     * @method getDensity
+     * @description Returns the density.
+     * @returns {number}
+     */
+    getDensity(): number;
+    /**
+     * @method setFriction
+     * @description Sets the friction coefficient (0 = ice).
+     * @param {number} friction
+     */
+    setFriction(friction: number): void;
+    /**
+     * @method getFriction
+     * @description Returns the friction coefficient.
+     * @returns {number}
+     */
+    getFriction(): number;
+    /**
+     * @method setRestitution
+     * @description Sets the bounciness (0 = no bounce, 1 = perfectly elastic).
+     * @param {number} restitution
+     */
+    setRestitution(restitution: number): void;
+    /**
+     * @method getRestitution
+     * @description Returns the bounciness.
+     * @returns {number}
+     */
+    getRestitution(): number;
+    /**
+     * @method testPoint
+     * @description True when a world-space point is inside this fixture.
+     * @param {Object} p - `{ x, y }` in physics units
+     * @returns {boolean}
+     */
+    testPoint(p: any): boolean;
+    /**
+     * @method rayCast
+     * @description Casts a ray against this fixture's shape.
+     * @param {Object} output - Written as `{ fraction, normal }` on a hit
+     * @param {Object} input - `{ p1, p2, maxFraction }`
+     * @returns {boolean}
+     */
+    rayCast(output: any, input: any): boolean;
+    /**
+     * @method getMassData
+     * @description Computes this fixture's contribution to the body's mass.
+     * @param {Object} [massData]
+     * @returns {Object} - `{ mass, center, I }`
+     */
+    getMassData(massData?: any): any;
+    /**
+     * @method getAABB
+     * @description Returns the fixture's current world AABB.
+     * @param {number} [childIndex=0]
+     * @returns {AABB}
+     */
+    getAABB(childIndex?: number): AABB;
+    /**
+     * @method createProxies
+     * @description Registers this fixture with the broadphase.
+     * @param {BroadPhase} broadPhase
+     * @param {Transform2} xf
+     * @private
+     */
+    private createProxies;
+    /**
+     * @method destroyProxies
+     * @description Removes this fixture from the broadphase.
+     * @param {BroadPhase} broadPhase
+     * @private
+     */
+    private destroyProxies;
+    /**
+     * @method synchronize
+     * @description Re-fits the broadphase proxies after the body moved. The AABB
+     * spans both the old and the new transform so a fast body's proxy still
+     * covers the ground it swept over.
+     * @param {BroadPhase} broadPhase
+     * @param {Transform2} xf1
+     * @param {Transform2} xf2
+     * @private
+     */
+    private synchronize;
+}
+/**
+ * @class FixtureProxy
+ * @description The link between a fixture and its entry in the broadphase tree.
+ * @private
+ */
+export class FixtureProxy {
+    constructor(fixture: any, childIndex: any);
+    aabb: AABB;
+    fixture: any;
+    childIndex: any;
+    proxyId: number;
+}
+import AABB from "./AABB.js";

package/dist/types/src/physics/Island.d.ts

@@ -0,0 +1,52 @@
+export default Island;
+/**
+ * @class Island
+ * @description A connected group of bodies, everything reachable through
+ * touching contacts, solved together. Islands are what make sleeping work:
+ * a pile of crates only goes to sleep once *every* body in it has settled, so
+ * one crate still rolling keeps the whole pile simulated.
+ */
+declare class Island {
+    bodies: any[];
+    contacts: any[];
+    joints: any[];
+    /** @private */
+    private positions;
+    /** @private */
+    private velocities;
+    /**
+     * @method clear
+     * @description Empties the island for reuse on the next seed body.
+     */
+    clear(): void;
+    /**
+     * @method addBody
+     * @description Adds a body and records its index for the solver.
+     * @param {Body} body
+     */
+    addBody(body: Body): void;
+    /**
+     * @method addContact
+     * @description Adds a touching contact to be solved with this island.
+     * @param {Contact} contact
+     */
+    addContact(contact: Contact): void;
+    /**
+     * @method addJoint
+     * @description Adds a joint to be solved with this island.
+     * @param {Joint} joint
+     */
+    addJoint(joint: Joint): void;
+    /**
+     * @method solve
+     * @description Advances the island by one step: integrate velocities, solve
+     * contacts, integrate positions, fix leftover overlap, then decide whether
+     * the island can go to sleep.
+     * @param {Object} step - `{ dt, velocityIterations, positionIterations,
+     *   warmStarting, velocityThreshold }`
+     * @param {Vec2} gravity - World gravity in physics units
+     * @param {boolean} allowSleep - Whether sleeping is enabled world-wide
+     */
+    solve(step: any, gravity: Vec2, allowSleep: boolean): void;
+}
+import { Vec2 } from "./Math2D.js";

package/dist/types/src/physics/Joint.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @class Joint
+ * @description Base class for a constraint between two bodies. A joint is
+ * solved by the same island that solves contacts (see {@link Island}), right
+ * alongside them, so a body linked only by a joint (no touching fixtures)
+ * still wakes, sleeps and moves together with whatever it is jointed to.
+ *
+ * Concrete joints ({@link DistanceJoint}, {@link RevoluteJoint}) implement
+ * `initVelocityConstraints`, `solveVelocityConstraints` and
+ * `solvePositionConstraints`, matching {@link ContactSolver}'s per-step
+ * lifecycle.
+ * @param {Object} def - `{ type, bodyA, bodyB, collideConnected, userData }`
+ */
+export class Joint {
+    constructor(def: any);
+    type: any;
+    bodyA: any;
+    bodyB: any;
+    collideConnected: any;
+    userData: any;
+    /** @private */
+    private islandFlag;
+    /** @private */
+    private prev;
+    /** @private */
+    private next;
+    /**
+     * @method getType
+     * @returns {string}
+     */
+    getType(): string;
+    /**
+     * @method getBodyA
+     * @returns {Body}
+     */
+    getBodyA(): Body;
+    /**
+     * @method getBodyB
+     * @returns {Body}
+     */
+    getBodyB(): Body;
+    /**
+     * @method getUserData
+     * @returns {*}
+     */
+    getUserData(): any;
+    /**
+     * @method setUserData
+     * @param {*} data
+     */
+    setUserData(data: any): void;
+}
+/**
+ * @description Identifies a concrete {@link Joint} subclass.
+ */
+export const JointType: Readonly<{
+    DISTANCE: "distance";
+    REVOLUTE: "revolute";
+}>;