@absolutejs/rapier3d 0.0.0-stage → 0.2.0

package/dist/types/coarena.d.ts

@@ -0,0 +1,15 @@
+export declare class Coarena<T> {
+    fconv: Float64Array;
+    uconv: Uint32Array;
+    data: Array<T>;
+    size: number;
+    constructor();
+    set(handle: number, data: T): void;
+    len(): number;
+    delete(handle: number): void;
+    clear(): void;
+    get(handle: number): T | null;
+    forEach(f: (elt: T) => void): void;
+    getAll(): Array<T>;
+    private index;
+}

package/dist/types/control/character_controller.d.ts

@@ -0,0 +1,191 @@
+import { Vector } from "../math";
+import { BroadPhase, Collider, ColliderSet, InteractionGroups, NarrowPhase } from "../geometry";
+import { QueryFilterFlags } from "../pipeline";
+import { IntegrationParameters, RigidBodySet } from "../dynamics";
+/**
+ * A collision between the character and an obstacle hit on its path.
+ */
+export declare class CharacterCollision {
+    /** The collider involved in the collision. Null if the collider no longer exists in the physics world. */
+    collider: Collider | null;
+    /** The translation delta applied to the character before this collision took place. */
+    translationDeltaApplied: Vector;
+    /** The translation delta the character would move after this collision if there is no other obstacles. */
+    translationDeltaRemaining: Vector;
+    /** The time-of-impact between the character and the obstacles. */
+    toi: number;
+    /** The world-space contact point on the collider when the collision happens. */
+    witness1: Vector;
+    /** The world-space contact point on the character when the collision happens. */
+    witness2: Vector;
+    /** The world-space outward contact normal on the collider when the collision happens. */
+    normal1: Vector;
+    /** The world-space outward contact normal on the character when the collision happens. */
+    normal2: Vector;
+}
+/**
+ * A character controller for controlling kinematic bodies and parentless colliders by hitting
+ * and sliding against obstacles.
+ */
+export declare class KinematicCharacterController {
+    private raw;
+    private rawCharacterCollision;
+    private params;
+    private broadPhase;
+    private narrowPhase;
+    private bodies;
+    private colliders;
+    private _applyImpulsesToDynamicBodies;
+    private _characterMass;
+    constructor(offset: number, params: IntegrationParameters, broadPhase: BroadPhase, narrowPhase: NarrowPhase, bodies: RigidBodySet, colliders: ColliderSet);
+    /** @internal */
+    free(): void;
+    /**
+     * The direction that goes "up". Used to determine where the floor is, and the floor’s angle.
+     */
+    up(): Vector;
+    /**
+     * Sets the direction that goes "up". Used to determine where the floor is, and the floor’s angle.
+     */
+    setUp(vector: Vector): void;
+    applyImpulsesToDynamicBodies(): boolean;
+    setApplyImpulsesToDynamicBodies(enabled: boolean): void;
+    /**
+     * Returns the custom value of the character mass, if it was set by `this.setCharacterMass`.
+     */
+    characterMass(): number | null;
+    /**
+     * Set the mass of the character to be used for impulse resolution if `self.applyImpulsesToDynamicBodies`
+     * is set to `true`.
+     *
+     * If no character mass is set explicitly (or if it is set to `null`) it is automatically assumed to be equal
+     * to the mass of the rigid-body the character collider is attached to; or equal to 0 if the character collider
+     * isn’t attached to any rigid-body.
+     *
+     * @param mass - The mass to set.
+     */
+    setCharacterMass(mass: number | null): void;
+    /**
+     * A small gap to preserve between the character and its surroundings.
+     *
+     * This value should not be too large to avoid visual artifacts, but shouldn’t be too small
+     * (must not be zero) to improve numerical stability of the character controller.
+     */
+    offset(): number;
+    /**
+     * Sets a small gap to preserve between the character and its surroundings.
+     *
+     * This value should not be too large to avoid visual artifacts, but shouldn’t be too small
+     * (must not be zero) to improve numerical stability of the character controller.
+     */
+    setOffset(value: number): void;
+    normalNudgeFactor(): number;
+    setNormalNudgeFactor(value: number): void;
+    /**
+     * Is sliding against obstacles enabled?
+     */
+    slideEnabled(): boolean;
+    /**
+     * Enable or disable sliding against obstacles.
+     */
+    setSlideEnabled(enabled: boolean): void;
+    /**
+     * The maximum step height a character can automatically step over.
+     */
+    autostepMaxHeight(): number | null;
+    /**
+     * The minimum width of free space that must be available after stepping on a stair.
+     */
+    autostepMinWidth(): number | null;
+    /**
+     * Can the character automatically step over dynamic bodies too?
+     */
+    autostepIncludesDynamicBodies(): boolean | null;
+    /**
+     * Is automatically stepping over small objects enabled?
+     */
+    autostepEnabled(): boolean;
+    /**
+     * Enabled automatically stepping over small objects.
+     *
+     * @param maxHeight - The maximum step height a character can automatically step over.
+     * @param minWidth - The minimum width of free space that must be available after stepping on a stair.
+     * @param includeDynamicBodies - Can the character automatically step over dynamic bodies too?
+     */
+    enableAutostep(maxHeight: number, minWidth: number, includeDynamicBodies: boolean): void;
+    /**
+     * Disable automatically stepping over small objects.
+     */
+    disableAutostep(): void;
+    /**
+     * The maximum angle (radians) between the floor’s normal and the `up` vector that the
+     * character is able to climb.
+     */
+    maxSlopeClimbAngle(): number;
+    /**
+     * Sets the maximum angle (radians) between the floor’s normal and the `up` vector that the
+     * character is able to climb.
+     */
+    setMaxSlopeClimbAngle(angle: number): void;
+    /**
+     * The minimum angle (radians) between the floor’s normal and the `up` vector before the
+     * character starts to slide down automatically.
+     */
+    minSlopeSlideAngle(): number;
+    /**
+     * Sets the minimum angle (radians) between the floor’s normal and the `up` vector before the
+     * character starts to slide down automatically.
+     */
+    setMinSlopeSlideAngle(angle: number): void;
+    /**
+     * If snap-to-ground is enabled, should the character be automatically snapped to the ground if
+     * the distance between the ground and its feet are smaller than the specified threshold?
+     */
+    snapToGroundDistance(): number | null;
+    /**
+     * Enables automatically snapping the character to the ground if the distance between
+     * the ground and its feet are smaller than the specified threshold.
+     */
+    enableSnapToGround(distance: number): void;
+    /**
+     * Disables automatically snapping the character to the ground.
+     */
+    disableSnapToGround(): void;
+    /**
+     * Is automatically snapping the character to the ground enabled?
+     */
+    snapToGroundEnabled(): boolean;
+    /**
+     * Computes the movement the given collider is able to execute after hitting and sliding on obstacles.
+     *
+     * @param collider - The collider to move.
+     * @param desiredTranslationDelta - The desired collider movement.
+     * @param filterFlags - Flags for excluding whole subsets of colliders from the obstacles taken into account.
+     * @param filterGroups - Groups for excluding colliders with incompatible collision groups from the obstacles
+     *                       taken into account.
+     * @param filterPredicate - Any collider for which this closure returns `false` will be excluded from the
+     *                          obstacles taken into account.
+     */
+    computeColliderMovement(collider: Collider, desiredTranslationDelta: Vector, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterPredicate?: (collider: Collider) => boolean): void;
+    /**
+     * The movement computed by the last call to `this.computeColliderMovement`.
+     */
+    computedMovement(target?: Vector): Vector;
+    /**
+     * The result of ground detection computed by the last call to `this.computeColliderMovement`.
+     */
+    computedGrounded(): boolean;
+    /**
+     * The number of collisions against obstacles detected along the path of the last call
+     * to `this.computeColliderMovement`.
+     */
+    numComputedCollisions(): number;
+    /**
+     * Returns the collision against one of the obstacles detected along the path of the last
+     * call to `this.computeColliderMovement`.
+     *
+     * @param i - The i-th collision will be returned.
+     * @param out - If this argument is set, it will be filled with the collision information.
+     */
+    computedCollision(i: number, out?: CharacterCollision): CharacterCollision | null;
+}

package/dist/types/control/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./character_controller";
+export * from "./pid_controller";
+export * from "./ray_cast_vehicle_controller";

package/dist/types/control/pid_controller.d.ts

@@ -0,0 +1,50 @@
+import { Rotation, Vector } from "../math";
+import { IntegrationParameters, RigidBody, RigidBodySet } from "../dynamics";
+/**
+ * An enum representing the possible joint axes controlled by a PidController.
+ * They can be ORed together, like:
+ * PidAxesMask.LinX || PidAxesMask.LinY
+ * to get a pid controller that only constraints the translational X and Y axes.
+ *
+ * Possible axes are:
+ *
+ * - `X`: X translation axis
+ * - `Y`: Y translation axis
+ * - `Z`: Z translation axis
+ * - `AngX`: X angular rotation axis (3D only)
+ * - `AngY`: Y angular rotation axis (3D only)
+ * - `AngZ`: Z angular rotation axis
+ */
+export declare enum PidAxesMask {
+    None = 0,
+    LinX = 1,
+    LinY = 2,
+    LinZ = 4,
+    AngX = 8,
+    AngY = 16,
+    AngZ = 32,
+    AllLin = 7,
+    AllAng = 56,
+    All = 63
+}
+/**
+ * A controller for controlling dynamic bodies using the
+ * Proportional-Integral-Derivative correction model.
+ */
+export declare class PidController {
+    private raw;
+    private params;
+    private bodies;
+    constructor(params: IntegrationParameters, bodies: RigidBodySet, kp: number, ki: number, kd: number, axes: PidAxesMask);
+    /** @internal */
+    free(): void;
+    setKp(kp: number, axes: PidAxesMask): void;
+    setKi(ki: number, axes: PidAxesMask): void;
+    setKd(kd: number, axes: PidAxesMask): void;
+    setAxes(axes: PidAxesMask): void;
+    resetIntegrals(): void;
+    applyLinearCorrection(body: RigidBody, targetPosition: Vector, targetLinvel: Vector): void;
+    applyAngularCorrection(body: RigidBody, targetRotation: Rotation, targetAngVel: Vector): void;
+    linearCorrection(body: RigidBody, targetPosition: Vector, targetLinvel: Vector, target?: Vector): Vector;
+    angularCorrection(body: RigidBody, targetRotation: Rotation, targetAngVel: Vector, target?: Vector): Vector;
+}

package/dist/types/control/ray_cast_vehicle_controller.d.ts

@@ -0,0 +1,277 @@
+import { Vector } from "../math";
+import { BroadPhase, Collider, ColliderSet, InteractionGroups, NarrowPhase } from "../geometry";
+import { QueryFilterFlags } from "../pipeline";
+import { RigidBody, RigidBodySet } from "../dynamics";
+/**
+ * A character controller to simulate vehicles using ray-casting for the wheels.
+ */
+export declare class DynamicRayCastVehicleController {
+    private raw;
+    private broadPhase;
+    private narrowPhase;
+    private bodies;
+    private colliders;
+    private _chassis;
+    constructor(chassis: RigidBody, broadPhase: BroadPhase, narrowPhase: NarrowPhase, bodies: RigidBodySet, colliders: ColliderSet);
+    /** @internal */
+    free(): void;
+    /**
+     * Updates the vehicle’s velocity based on its suspension, engine force, and brake.
+     *
+     * This directly updates the velocity of its chassis rigid-body.
+     *
+     * @param dt - Time increment used to integrate forces.
+     * @param filterFlags - Flag to exclude categories of objects from the wheels’ ray-cast.
+     * @param filterGroups - Only colliders compatible with these groups will be hit by the wheels’ ray-casts.
+     * @param filterPredicate - Callback to filter out which collider will be hit by the wheels’ ray-casts.
+     */
+    updateVehicle(dt: number, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterPredicate?: (collider: Collider) => boolean): void;
+    /**
+     * The current forward speed of the vehicle.
+     */
+    currentVehicleSpeed(): number;
+    /**
+     * The rigid-body used as the chassis.
+     */
+    chassis(): RigidBody;
+    /**
+     * The chassis’ local _up_ direction (`0 = x, 1 = y, 2 = z`).
+     */
+    get indexUpAxis(): number;
+    /**
+     * Sets the chassis’ local _up_ direction (`0 = x, 1 = y, 2 = z`).
+     */
+    set indexUpAxis(axis: number);
+    /**
+     * The chassis’ local _forward_ direction (`0 = x, 1 = y, 2 = z`).
+     */
+    get indexForwardAxis(): number;
+    /**
+     * Sets the chassis’ local _forward_ direction (`0 = x, 1 = y, 2 = z`).
+     */
+    set setIndexForwardAxis(axis: number);
+    /**
+     * Adds a new wheel attached to this vehicle.
+     * @param chassisConnectionCs  - The position of the wheel relative to the chassis.
+     * @param directionCs - The direction of the wheel’s suspension, relative to the chassis. The ray-casting will
+     *                      happen following this direction to detect the ground.
+     * @param axleCs - The wheel’s axle axis, relative to the chassis.
+     * @param suspensionRestLength - The rest length of the wheel’s suspension spring.
+     * @param radius - The wheel’s radius.
+     */
+    addWheel(chassisConnectionCs: Vector, directionCs: Vector, axleCs: Vector, suspensionRestLength: number, radius: number): void;
+    /**
+     * The number of wheels attached to this vehicle.
+     */
+    numWheels(): number;
+    /**
+     * The position of the i-th wheel, relative to the chassis.
+     *
+     * @param {number} i
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    wheelChassisConnectionPointCs(i: number, target?: Vector): Vector | null;
+    /**
+     * Sets the position of the i-th wheel, relative to the chassis.
+     */
+    setWheelChassisConnectionPointCs(i: number, value: Vector): void;
+    /**
+     * The rest length of the i-th wheel’s suspension spring.
+     */
+    wheelSuspensionRestLength(i: number): number | null;
+    /**
+     * Sets the rest length of the i-th wheel’s suspension spring.
+     */
+    setWheelSuspensionRestLength(i: number, value: number): void;
+    /**
+     * The maximum distance the i-th wheel suspension can travel before and after its resting length.
+     */
+    wheelMaxSuspensionTravel(i: number): number | null;
+    /**
+     * Sets the maximum distance the i-th wheel suspension can travel before and after its resting length.
+     */
+    setWheelMaxSuspensionTravel(i: number, value: number): void;
+    /**
+     * The i-th wheel’s radius.
+     */
+    wheelRadius(i: number): number | null;
+    /**
+     * Sets the i-th wheel’s radius.
+     */
+    setWheelRadius(i: number, value: number): void;
+    /**
+     * The i-th wheel’s suspension stiffness.
+     *
+     * Increase this value if the suspension appears to not push the vehicle strong enough.
+     */
+    wheelSuspensionStiffness(i: number): number | null;
+    /**
+     * Sets the i-th wheel’s suspension stiffness.
+     *
+     * Increase this value if the suspension appears to not push the vehicle strong enough.
+     */
+    setWheelSuspensionStiffness(i: number, value: number): void;
+    /**
+     * The i-th wheel’s suspension’s damping when it is being compressed.
+     */
+    wheelSuspensionCompression(i: number): number | null;
+    /**
+     * The i-th wheel’s suspension’s damping when it is being compressed.
+     */
+    setWheelSuspensionCompression(i: number, value: number): void;
+    /**
+     * The i-th wheel’s suspension’s damping when it is being released.
+     *
+     * Increase this value if the suspension appears to overshoot.
+     */
+    wheelSuspensionRelaxation(i: number): number | null;
+    /**
+     * Sets the i-th wheel’s suspension’s damping when it is being released.
+     *
+     * Increase this value if the suspension appears to overshoot.
+     */
+    setWheelSuspensionRelaxation(i: number, value: number): void;
+    /**
+     * The maximum force applied by the i-th wheel’s suspension.
+     */
+    wheelMaxSuspensionForce(i: number): number | null;
+    /**
+     * Sets the maximum force applied by the i-th wheel’s suspension.
+     */
+    setWheelMaxSuspensionForce(i: number, value: number): void;
+    /**
+     * The maximum amount of braking impulse applied on the i-th wheel to slow down the vehicle.
+     */
+    wheelBrake(i: number): number | null;
+    /**
+     * Set the maximum amount of braking impulse applied on the i-th wheel to slow down the vehicle.
+     */
+    setWheelBrake(i: number, value: number): void;
+    /**
+     * The steering angle (radians) for the i-th wheel.
+     */
+    wheelSteering(i: number): number | null;
+    /**
+     * Sets the steering angle (radians) for the i-th wheel.
+     */
+    setWheelSteering(i: number, value: number): void;
+    /**
+     * The forward force applied by the i-th wheel on the chassis.
+     */
+    wheelEngineForce(i: number): number | null;
+    /**
+     * Sets the forward force applied by the i-th wheel on the chassis.
+     */
+    setWheelEngineForce(i: number, value: number): void;
+    /**
+     * The direction of the i-th wheel’s suspension, relative to the chassis.
+     *
+     * The ray-casting will happen following this direction to detect the ground.
+     *
+     * @param {number} i
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    wheelDirectionCs(i: number, target?: Vector): Vector | null;
+    /**
+     * Sets the direction of the i-th wheel’s suspension, relative to the chassis.
+     *
+     * The ray-casting will happen following this direction to detect the ground.
+     */
+    setWheelDirectionCs(i: number, value: Vector): void;
+    /**
+     * The i-th wheel’s axle axis, relative to the chassis.
+     *
+     * The axis index defined as 0 = X, 1 = Y, 2 = Z.
+     *
+     * @param {number} i
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    wheelAxleCs(i: number, target?: Vector): Vector | null;
+    /**
+     * Sets the i-th wheel’s axle axis, relative to the chassis.
+     *
+     * The axis index defined as 0 = X, 1 = Y, 2 = Z.
+     */
+    setWheelAxleCs(i: number, value: Vector): void;
+    /**
+     * Parameter controlling how much traction the tire has.
+     *
+     * The larger the value, the more instantaneous braking will happen (with the risk of
+     * causing the vehicle to flip if it’s too strong).
+     */
+    wheelFrictionSlip(i: number): number | null;
+    /**
+     * Sets the parameter controlling how much traction the tire has.
+     *
+     * The larger the value, the more instantaneous braking will happen (with the risk of
+     * causing the vehicle to flip if it’s too strong).
+     */
+    setWheelFrictionSlip(i: number, value: number): void;
+    /**
+     * The multiplier of friction between a tire and the collider it’s on top of.
+     *
+     * The larger the value, the stronger side friction will be.
+     */
+    wheelSideFrictionStiffness(i: number): number | null;
+    /**
+     * The multiplier of friction between a tire and the collider it’s on top of.
+     *
+     * The larger the value, the stronger side friction will be.
+     */
+    setWheelSideFrictionStiffness(i: number, value: number): void;
+    /**
+     *  The i-th wheel’s current rotation angle (radians) on its axle.
+     */
+    wheelRotation(i: number): number | null;
+    /**
+     *  The forward impulses applied by the i-th wheel on the chassis.
+     */
+    wheelForwardImpulse(i: number): number | null;
+    /**
+     *  The side impulses applied by the i-th wheel on the chassis.
+     */
+    wheelSideImpulse(i: number): number | null;
+    /**
+     *  The force applied by the i-th wheel suspension.
+     */
+    wheelSuspensionForce(i: number): number | null;
+    /**
+     *  The (world-space) contact normal between the i-th wheel and the floor.
+     *
+     * @param {number} i
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    wheelContactNormal(i: number, target?: Vector): Vector | null;
+    /**
+     *  The (world-space) point hit by the wheel’s ray-cast for the i-th wheel.
+     *
+     * @param {number} i
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    wheelContactPoint(i: number, target?: Vector): Vector | null;
+    /**
+     *  The suspension length for the i-th wheel.
+     */
+    wheelSuspensionLength(i: number): number | null;
+    /**
+     *  The (world-space) starting point of the ray-cast for the i-th wheel.
+     *
+     * @param {number} i
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    wheelHardPoint(i: number, target?: Vector): Vector | null;
+    /**
+     *  Is the i-th wheel in contact with the ground?
+     */
+    wheelIsInContact(i: number): boolean;
+    /**
+     *  The collider hit by the ray-cast for the i-th wheel.
+     */
+    wheelGroundObject(i: number): Collider | null;
+}

package/dist/types/dynamics/ccd_solver.d.ts

@@ -0,0 +1,15 @@
+import { RawCCDSolver } from "../raw";
+/**
+ * The CCD solver responsible for resolving Continuous Collision Detection.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `ccdSolver.free()`
+ * once you are done using it.
+ */
+export declare class CCDSolver {
+    raw: RawCCDSolver;
+    /**
+     * Release the WASM memory occupied by this narrow-phase.
+     */
+    free(): void;
+    constructor(raw?: RawCCDSolver);
+}

package/dist/types/dynamics/coefficient_combine_rule.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A rule applied to combine coefficients.
+ *
+ * Use this when configuring the `ColliderDesc` to specify
+ * how friction and restitution coefficient should be combined
+ * in a contact.
+ */
+export declare enum CoefficientCombineRule {
+    Average = 0,
+    Min = 1,
+    Multiply = 2,
+    Max = 3
+}