@tushar-br/desktop 1.0.173 → 1.0.174

package/staging_area/desktop/car gaem/node_modules/@dimforge/rapier3d-compat/control/ray_cast_vehicle_controller.d.ts

@@ -0,0 +1,252 @@
+import { Vector } from "../math";
+import { Collider, ColliderSet, InteractionGroups } from "../geometry";
+import { QueryFilterFlags, QueryPipeline } 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 bodies;
+    private colliders;
+    private queries;
+    private _chassis;
+    constructor(chassis: RigidBody, bodies: RigidBodySet, colliders: ColliderSet, queries: QueryPipeline);
+    /** @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.
+     */
+    wheelChassisConnectionPointCs(i: number): 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.
+     */
+    wheelDirectionCs(i: number): 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.
+     */
+    wheelAxleCs(i: number): 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.
+     */
+    wheelContactNormal(i: number): Vector | null;
+    /**
+     *  The (world-space) point hit by the wheel’s ray-cast for the i-th wheel.
+     */
+    wheelContactPoint(i: number): 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.
+     */
+    wheelHardPoint(i: number): 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/staging_area/desktop/car gaem/node_modules/@dimforge/rapier3d-compat/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/staging_area/desktop/car gaem/node_modules/@dimforge/rapier3d-compat/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
+}

package/staging_area/desktop/car gaem/node_modules/@dimforge/rapier3d-compat/dynamics/impulse_joint.d.ts

@@ -0,0 +1,259 @@
+import { Rotation, Vector } from "../math";
+import { RawGenericJoint, RawImpulseJointSet, RawJointAxis } from "../raw";
+import { RigidBody } from "./rigid_body";
+import { RigidBodySet } from "./rigid_body_set";
+/**
+ * The integer identifier of a collider added to a `ColliderSet`.
+ */
+export declare type ImpulseJointHandle = number;
+/**
+ * An enum grouping all possible types of joints:
+ *
+ * - `Revolute`: A revolute joint that removes all degrees of freedom between the affected
+ *               bodies except for the rotation along one axis.
+ * - `Fixed`: A fixed joint that removes all relative degrees of freedom between the affected bodies.
+ * - `Prismatic`: A prismatic joint that removes all degrees of freedom between the affected
+ *                bodies except for the translation along one axis.
+ * - `Spherical`: (3D only) A spherical joint that removes all relative linear degrees of freedom between the affected bodies.
+ * - `Generic`: (3D only) A joint with customizable degrees of freedom, allowing any of the 6 axes to be locked.
+ */
+export declare enum JointType {
+    Revolute = 0,
+    Fixed = 1,
+    Prismatic = 2,
+    Rope = 3,
+    Spring = 4,
+    Spherical = 5,
+    Generic = 6
+}
+export declare enum MotorModel {
+    AccelerationBased = 0,
+    ForceBased = 1
+}
+/**
+ * An enum representing the possible joint axes of a generic joint.
+ * They can be ORed together, like:
+ * JointAxesMask.X || JointAxesMask.Y
+ * to get a joint that is only free in the X and Y translational (positional) axes.
+ *
+ * Possible free axes are:
+ *
+ * - `X`: X translation axis
+ * - `Y`: Y translation axis
+ * - `Z`: Z translation axis
+ * - `AngX`: X angular rotation axis
+ * - `AngY`: Y angular rotations axis
+ * - `AngZ`: Z angular rotation axis
+ */
+export declare enum JointAxesMask {
+    X = 1,
+    Y = 2,
+    Z = 4,
+    AngX = 8,
+    AngY = 16,
+    AngZ = 32
+}
+export declare class ImpulseJoint {
+    protected rawSet: RawImpulseJointSet;
+    protected bodySet: RigidBodySet;
+    handle: ImpulseJointHandle;
+    constructor(rawSet: RawImpulseJointSet, bodySet: RigidBodySet, handle: ImpulseJointHandle);
+    static newTyped(rawSet: RawImpulseJointSet, bodySet: RigidBodySet, handle: ImpulseJointHandle): ImpulseJoint;
+    /** @internal */
+    finalizeDeserialization(bodySet: RigidBodySet): void;
+    /**
+     * Checks if this joint is still valid (i.e. that it has
+     * not been deleted from the joint set yet).
+     */
+    isValid(): boolean;
+    /**
+     * The first rigid-body this joint it attached to.
+     */
+    body1(): RigidBody;
+    /**
+     * The second rigid-body this joint is attached to.
+     */
+    body2(): RigidBody;
+    /**
+     * The type of this joint given as a string.
+     */
+    type(): JointType;
+    /**
+     * The rotation quaternion that aligns this joint's first local axis to the `x` axis.
+     */
+    frameX1(): Rotation;
+    /**
+     * The rotation matrix that aligns this joint's second local axis to the `x` axis.
+     */
+    frameX2(): Rotation;
+    /**
+     * The position of the first anchor of this joint.
+     *
+     * The first anchor gives the position of the application point on the
+     * local frame of the first rigid-body it is attached to.
+     */
+    anchor1(): Vector;
+    /**
+     * The position of the second anchor of this joint.
+     *
+     * The second anchor gives the position of the application point on the
+     * local frame of the second rigid-body it is attached to.
+     */
+    anchor2(): Vector;
+    /**
+     * Sets the position of the first anchor of this joint.
+     *
+     * The first anchor gives the position of the application point on the
+     * local frame of the first rigid-body it is attached to.
+     */
+    setAnchor1(newPos: Vector): void;
+    /**
+     * Sets the position of the second anchor of this joint.
+     *
+     * The second anchor gives the position of the application point on the
+     * local frame of the second rigid-body it is attached to.
+     */
+    setAnchor2(newPos: Vector): void;
+    /**
+     * Controls whether contacts are computed between colliders attached
+     * to the rigid-bodies linked by this joint.
+     */
+    setContactsEnabled(enabled: boolean): void;
+    /**
+     * Indicates if contacts are enabled between colliders attached
+     * to the rigid-bodies linked by this joint.
+     */
+    contactsEnabled(): boolean;
+}
+export declare class UnitImpulseJoint extends ImpulseJoint {
+    /**
+     * The axis left free by this joint.
+     */
+    protected rawAxis?(): RawJointAxis;
+    /**
+     * Are the limits enabled for this joint?
+     */
+    limitsEnabled(): boolean;
+    /**
+     * The min limit of this joint.
+     */
+    limitsMin(): number;
+    /**
+     * The max limit of this joint.
+     */
+    limitsMax(): number;
+    /**
+     * Sets the limits of this joint.
+     *
+     * @param min - The minimum bound of this joint’s free coordinate.
+     * @param max - The maximum bound of this joint’s free coordinate.
+     */
+    setLimits(min: number, max: number): void;
+    configureMotorModel(model: MotorModel): void;
+    configureMotorVelocity(targetVel: number, factor: number): void;
+    configureMotorPosition(targetPos: number, stiffness: number, damping: number): void;
+    configureMotor(targetPos: number, targetVel: number, stiffness: number, damping: number): void;
+}
+export declare class FixedImpulseJoint extends ImpulseJoint {
+}
+export declare class RopeImpulseJoint extends ImpulseJoint {
+}
+export declare class SpringImpulseJoint extends ImpulseJoint {
+}
+export declare class PrismaticImpulseJoint extends UnitImpulseJoint {
+    rawAxis(): RawJointAxis;
+}
+export declare class RevoluteImpulseJoint extends UnitImpulseJoint {
+    rawAxis(): RawJointAxis;
+}
+export declare class GenericImpulseJoint extends ImpulseJoint {
+}
+export declare class SphericalImpulseJoint extends ImpulseJoint {
+}
+export declare class JointData {
+    anchor1: Vector;
+    anchor2: Vector;
+    axis: Vector;
+    frame1: Rotation;
+    frame2: Rotation;
+    jointType: JointType;
+    limitsEnabled: boolean;
+    limits: Array<number>;
+    axesMask: JointAxesMask;
+    stiffness: number;
+    damping: number;
+    length: number;
+    private constructor();
+    /**
+     * Creates a new joint descriptor that builds a Fixed joint.
+     *
+     * A fixed joint removes all the degrees of freedom between the affected bodies, ensuring their
+     * anchor and local frames coincide in world-space.
+     *
+     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param frame1 - The reference orientation of the joint wrt. the first rigid-body.
+     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param frame2 - The reference orientation of the joint wrt. the second rigid-body.
+     */
+    static fixed(anchor1: Vector, frame1: Rotation, anchor2: Vector, frame2: Rotation): JointData;
+    static spring(rest_length: number, stiffness: number, damping: number, anchor1: Vector, anchor2: Vector): JointData;
+    static rope(length: number, anchor1: Vector, anchor2: Vector): JointData;
+    /**
+     * Create a new joint descriptor that builds generic joints.
+     *
+     * A generic joint allows customizing its degrees of freedom
+     * by supplying a mask of the joint axes that should remain locked.
+     *
+     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param axis - The X axis of the joint, expressed in the local-space of the rigid-bodies it is attached to.
+     * @param axesMask - Mask representing the locked axes of the joint. You can use logical OR to select these from
+     *                   the JointAxesMask enum. For example, passing (JointAxesMask.AngX || JointAxesMask.AngY) will
+     *                   create a joint locked in the X and Y rotational axes.
+     */
+    static generic(anchor1: Vector, anchor2: Vector, axis: Vector, axesMask: JointAxesMask): JointData;
+    /**
+     * Create a new joint descriptor that builds spherical joints.
+     *
+     * A spherical joint allows three relative rotational degrees of freedom
+     * by preventing any relative translation between the anchors of the
+     * two attached rigid-bodies.
+     *
+     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     */
+    static spherical(anchor1: Vector, anchor2: Vector): JointData;
+    /**
+     * Creates a new joint descriptor that builds a Prismatic joint.
+     *
+     * A prismatic joint removes all the degrees of freedom between the
+     * affected bodies, except for the translation along one axis.
+     *
+     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param axis - Axis of the joint, expressed in the local-space of the rigid-bodies it is attached to.
+     */
+    static prismatic(anchor1: Vector, anchor2: Vector, axis: Vector): JointData;
+    /**
+     * Create a new joint descriptor that builds Revolute joints.
+     *
+     * A revolute joint removes all degrees of freedom between the affected
+     * bodies except for the rotation along one axis.
+     *
+     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param axis - Axis of the joint, expressed in the local-space of the rigid-bodies it is attached to.
+     */
+    static revolute(anchor1: Vector, anchor2: Vector, axis: Vector): JointData;
+    intoRaw(): RawGenericJoint;
+}

package/staging_area/desktop/car gaem/node_modules/@dimforge/rapier3d-compat/dynamics/impulse_joint_set.d.ts

@@ -0,0 +1,79 @@
+import { RawImpulseJointSet } from "../raw";
+import { RigidBodySet } from "./rigid_body_set";
+import { ImpulseJoint, ImpulseJointHandle, JointData } from "./impulse_joint";
+import { RigidBodyHandle } from "./rigid_body";
+/**
+ * A set of joints.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `jointSet.free()`
+ * once you are done using it (and all the joints it created).
+ */
+export declare class ImpulseJointSet {
+    raw: RawImpulseJointSet;
+    private map;
+    /**
+     * Release the WASM memory occupied by this joint set.
+     */
+    free(): void;
+    constructor(raw?: RawImpulseJointSet);
+    /** @internal */
+    finalizeDeserialization(bodies: RigidBodySet): void;
+    /**
+     * Creates a new joint and return its integer handle.
+     *
+     * @param bodies - The set of rigid-bodies containing the bodies the joint is attached to.
+     * @param desc - The joint's parameters.
+     * @param parent1 - The handle of the first rigid-body this joint is attached to.
+     * @param parent2 - The handle of the second rigid-body this joint is attached to.
+     * @param wakeUp - Should the attached rigid-bodies be awakened?
+     */
+    createJoint(bodies: RigidBodySet, desc: JointData, parent1: RigidBodyHandle, parent2: RigidBodyHandle, wakeUp: boolean): ImpulseJoint;
+    /**
+     * Remove a joint from this set.
+     *
+     * @param handle - The integer handle of the joint.
+     * @param wakeUp - If `true`, the rigid-bodies attached by the removed joint will be woken-up automatically.
+     */
+    remove(handle: ImpulseJointHandle, wakeUp: boolean): void;
+    /**
+     * Calls the given closure with the integer handle of each impulse joint attached to this rigid-body.
+     *
+     * @param f - The closure called with the integer handle of each impulse joint attached to the rigid-body.
+     */
+    forEachJointHandleAttachedToRigidBody(handle: RigidBodyHandle, f: (handle: ImpulseJointHandle) => void): void;
+    /**
+     * Internal function, do not call directly.
+     * @param handle
+     */
+    unmap(handle: ImpulseJointHandle): void;
+    /**
+     * The number of joints on this set.
+     */
+    len(): number;
+    /**
+     * Does this set contain a joint with the given handle?
+     *
+     * @param handle - The joint handle to check.
+     */
+    contains(handle: ImpulseJointHandle): boolean;
+    /**
+     * Gets the joint with the given handle.
+     *
+     * Returns `null` if no joint with the specified handle exists.
+     *
+     * @param handle - The integer handle of the joint to retrieve.
+     */
+    get(handle: ImpulseJointHandle): ImpulseJoint | null;
+    /**
+     * Applies the given closure to each joint contained by this set.
+     *
+     * @param f - The closure to apply.
+     */
+    forEach(f: (joint: ImpulseJoint) => void): void;
+    /**
+     * Gets all joints in the list.
+     *
+     * @returns joint list.
+     */
+    getAll(): ImpulseJoint[];
+}

package/staging_area/desktop/car gaem/node_modules/@dimforge/rapier3d-compat/dynamics/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./rigid_body";
+export * from "./rigid_body_set";
+export * from "./integration_parameters";
+export * from "./impulse_joint";
+export * from "./impulse_joint_set";
+export * from "./multibody_joint";
+export * from "./multibody_joint_set";
+export * from "./coefficient_combine_rule";
+export * from "./ccd_solver";
+export * from "./island_manager";