@dimforge/rapier3d-compat - npm Package Compare versions

Comparing version 0.0.0-3666fff-20220701 to 0.0.0-4699217-20230304

dynamics/impulse_joint.d.ts

@@ -65,3 +65,3 @@ import { Rotation, Vector } from "../math";
      *
-     * The first anchor gives the position of the points application point on the
+     * The first anchor gives the position of the application point on the
      * local frame of the first rigid-body it is attached to.
@@ -73,6 +73,30 @@ */
      *
-     * The second anchor gives the position of the points application point on the
+     * 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;
 }
@@ -96,2 +120,9 @@ export declare class UnitImpulseJoint extends ImpulseJoint {
     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;
@@ -98,0 +129,0 @@ configureMotorVelocity(targetVel: number, factor: number): void;

dynamics/multibody_joint.d.ts

@@ -16,2 +16,12 @@ import { RawJointAxis, RawMultibodyJointSet } from "../raw";
     isValid(): boolean;
+    /**
+     * 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;
 }
@@ -18,0 +28,0 @@ export declare class UnitMultibodyJoint extends MultibodyJoint {

dynamics/rigid_body.d.ts

 import { RawRigidBodySet } from "../raw";
 import { Rotation, Vector } from "../math";
+import { SdpMatrix3 } from "../math";
 import { Collider, ColliderSet } from "../geometry";
@@ -80,2 +81,12 @@ /**
      */
+    setEnabledTranslations(enableX: boolean, enableY: boolean, enableZ: boolean, wakeUp: boolean): void;
+    /**
+     * Locks or unlocks the ability of this rigid-body to translate along individual coordinate axes.
+     *
+     * @param enableX - If `false`, this rigid-body will no longer translate due to torques and impulses, along the X coordinate axis.
+     * @param enableY - If `false`, this rigid-body will no longer translate due to torques and impulses, along the Y coordinate axis.
+     * @param enableZ - If `false`, this rigid-body will no longer translate due to torques and impulses, along the Z coordinate axis.
+     * @param wakeUp - If `true`, this rigid-body will be automatically awaken if it is currently asleep.
+     * @deprecated use `this.setEnabledTranslations` with the same arguments instead.
+     */
     restrictTranslations(enableX: boolean, enableY: boolean, enableZ: boolean, wakeUp: boolean): void;
@@ -90,2 +101,12 @@ /**
      */
+    setEnabledRotations(enableX: boolean, enableY: boolean, enableZ: boolean, wakeUp: boolean): void;
+    /**
+     * Locks or unlocks the ability of this rigid-body to rotate along individual coordinate axes.
+     *
+     * @param enableX - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the X coordinate axis.
+     * @param enableY - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the Y coordinate axis.
+     * @param enableZ - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the Z coordinate axis.
+     * @param wakeUp - If `true`, this rigid-body will be automatically awaken if it is currently asleep.
+     * @deprecated use `this.setEnabledRotations` with the same arguments instead.
+     */
     restrictRotations(enableX: boolean, enableY: boolean, enableZ: boolean, wakeUp: boolean): void;
@@ -215,2 +236,44 @@ /**
     /**
+     * The inverse mass taking into account translation locking.
+     */
+    effectiveInvMass(): Vector;
+    /**
+     * The inverse of the mass of a rigid-body.
+     *
+     * If this is zero, the rigid-body is assumed to have infinite mass.
+     */
+    invMass(): number;
+    /**
+     * The center of mass of a rigid-body expressed in its local-space.
+     */
+    localCom(): Vector;
+    /**
+     * The world-space center of mass of the rigid-body.
+     */
+    worldCom(): Vector;
+    /**
+     * The inverse of the principal angular inertia of the rigid-body.
+     *
+     * Components set to zero are assumed to be infinite along the corresponding principal axis.
+     */
+    invPrincipalInertiaSqrt(): Vector;
+    /**
+     * The angular inertia along the principal inertia axes of the rigid-body.
+     */
+    principalInertia(): Vector;
+    /**
+     * The principal vectors of the local angular inertia tensor of the rigid-body.
+     */
+    principalInertiaLocalFrame(): Rotation;
+    /**
+     * The square-root of the world-space inverse angular inertia tensor of the rigid-body,
+     * taking into account rotation locking.
+     */
+    effectiveWorldInvInertiaSqrt(): SdpMatrix3;
+    /**
+     * The effective world-space angular inertia (that takes the potential rotation locking into account) of
+     * this rigid-body.
+     */
+    effectiveAngularInertia(): SdpMatrix3;
+    /**
      * Put this rigid body to sleep.
@@ -236,3 +299,3 @@ *
      */
-    isCcdEnabled(): void;
+    isCcdEnabled(): boolean;
     /**
@@ -250,2 +313,12 @@ * The number of colliders attached to this rigid-body.
     /**
+     * Sets whether this rigid-body is enabled or not.
+     *
+     * @param enabled - Set to `false` to disable this rigid-body and all its attached colliders.
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Is this rigid-body enabled?
+     */
+    isEnabled(): boolean;
+    /**
      * The status of this rigid-body: static, dynamic, or kinematic.
@@ -257,3 +330,3 @@ */
      */
-    setBodyType(type: RigidBodyType): void;
+    setBodyType(type: RigidBodyType, wakeUp: boolean): void;
     /**
@@ -294,2 +367,43 @@ * Is this rigid-body sleeping?
     /**
+     * Recompute the mass-properties of this rigid-bodies based on its currently attached colliders.
+     */
+    recomputeMassPropertiesFromColliders(): void;
+    /**
+     * Sets the rigid-body's additional mass.
+     *
+     * The total angular inertia of the rigid-body will be scaled automatically based on this additional mass. If this
+     * scaling effect isn’t desired, use Self::additional_mass_properties instead of this method.
+     *
+     * This is only the "additional" mass because the total mass of the rigid-body is equal to the sum of this
+     * additional mass and the mass computed from the colliders (with non-zero densities) attached to this rigid-body.
+     *
+     * That total mass (which includes the attached colliders’ contributions) will be updated at the name physics step,
+     * or can be updated manually with `this.recomputeMassPropertiesFromColliders`.
+     *
+     * This will override any previous additional mass-properties set by `this.setAdditionalMass`,
+     * `this.setAdditionalMassProperties`, `RigidBodyDesc::setAdditionalMass`, or
+     * `RigidBodyDesc.setAdditionalMassfProperties` for this rigid-body.
+     *
+     * @param mass - The additional mass to set.
+     * @param wakeUp - If `true` then the rigid-body will be woken up if it was put to sleep because it did not move for a while.
+     */
+    setAdditionalMass(mass: number, wakeUp: boolean): void;
+    /**
+     * Sets the rigid-body's additional mass-properties.
+     *
+     * This is only the "additional" mass-properties because the total mass-properties of the rigid-body is equal to the
+     * sum of this additional mass-properties and the mass computed from the colliders (with non-zero densities) attached
+     * to this rigid-body.
+     *
+     * That total mass-properties (which include the attached colliders’ contributions) will be updated at the name
+     * physics step, or can be updated manually with `this.recomputeMassPropertiesFromColliders`.
+     *
+     * This will override any previous mass-properties set by `this.setAdditionalMass`,
+     * `this.setAdditionalMassProperties`, `RigidBodyDesc.setAdditionalMass`, or `RigidBodyDesc.setAdditionalMassProperties`
+     * for this rigid-body.
+     *
+     * If `wake_up` is true then the rigid-body will be woken up if it was put to sleep because it did not move for a while.
+     */
+    setAdditionalMassProperties(mass: number, centerOfMass: Vector, principalAngularInertia: Vector, angularInertiaLocalFrame: Rotation, wakeUp: boolean): void;
+    /**
      * Sets the linear damping factor applied to this rigid-body.
@@ -358,2 +472,3 @@ *
 export declare class RigidBodyDesc {
+    enabled: boolean;
     translation: Vector;
@@ -363,2 +478,3 @@ rotation: Rotation;
     mass: number;
+    massOnly: boolean;
     centerOfMass: Vector;
@@ -426,2 +542,7 @@ translationsEnabledX: boolean;
     /**
+     * Sets whether the created rigid-body will be enabled or disabled.
+     * @param enabled − If set to `false` the rigid-body will be disabled at creation.
+     */
+    setEnabled(enabled: boolean): RigidBodyDesc;
+    /**
      * Sets the initial translation of the rigid-body to create.
@@ -487,7 +608,8 @@ *
     /**
-     * Sets the mass properties of the rigid-body being built.
-     *
-     * @param principalAngularInertia − The initial principal angular inertia of the rigid-body to create.
+     * Allow translation of this rigid-body only along specific axes.
+     * @param translationsEnabledX - Are translations along the X axis enabled?
+     * @param translationsEnabledY - Are translations along the y axis enabled?
+     * @param translationsEnabledZ - Are translations along the Z axis enabled?
      */
-    setAdditionalPrincipalAngularInertia(principalAngularInertia: Vector): RigidBodyDesc;
+    enabledTranslations(translationsEnabledX: boolean, translationsEnabledY: boolean, translationsEnabledZ: boolean): RigidBodyDesc;
     /**
@@ -498,2 +620,3 @@ * Allow translation of this rigid-body only along specific axes.
      * @param translationsEnabledZ - Are translations along the Z axis enabled?
+     * @deprecated use `this.enabledTranslations` with the same arguments instead.
      */
@@ -512,2 +635,10 @@ restrictTranslations(translationsEnabledX: boolean, translationsEnabledY: boolean, translationsEnabledZ: boolean): RigidBodyDesc;
      */
+    enabledRotations(rotationsEnabledX: boolean, rotationsEnabledY: boolean, rotationsEnabledZ: boolean): RigidBodyDesc;
+    /**
+     * Allow rotation of this rigid-body only along specific axes.
+     * @param rotationsEnabledX - Are rotations along the X axis enabled?
+     * @param rotationsEnabledY - Are rotations along the y axis enabled?
+     * @param rotationsEnabledZ - Are rotations along the Z axis enabled?
+     * @deprecated use `this.enabledRotations` with the same arguments instead.
+     */
     restrictRotations(rotationsEnabledX: boolean, rotationsEnabledY: boolean, rotationsEnabledZ: boolean): RigidBodyDesc;
@@ -514,0 +645,0 @@ /**

exports.d.ts

@@ -7,1 +7,2 @@ export declare function version(): string;
 export * from "./init";
+export * from "./control";

geometry/collider_set.d.ts

@@ -20,2 +20,4 @@ import { RawColliderSet } from "../raw";
     /** @internal */
+    castClosure<Res>(f?: (collider: Collider) => Res): (handle: ColliderHandle) => Res | undefined;
+    /** @internal */
     finalizeDeserialization(bodies: RigidBodySet): void;
@@ -22,0 +24,0 @@ /**

geometry/collider.d.ts

@@ -11,10 +11,46 @@ import { Rotation, Vector } from "../math";
 import { ColliderSet } from "./collider_set";
+/**
+ * Flags affecting whether collision-detection happens between two colliders
+ * depending on the type of rigid-bodies they are attached to.
+ */
 export declare enum ActiveCollisionTypes {
+    /**
+     * Enable collision-detection between a collider attached to a dynamic body
+     * and another collider attached to a dynamic body.
+     */
     DYNAMIC_DYNAMIC = 1,
+    /**
+     * Enable collision-detection between a collider attached to a dynamic body
+     * and another collider attached to a kinematic body.
+     */
     DYNAMIC_KINEMATIC = 12,
+    /**
+     * Enable collision-detection between a collider attached to a dynamic body
+     * and another collider attached to a fixed body (or not attached to any body).
+     */
     DYNAMIC_FIXED = 2,
+    /**
+     * Enable collision-detection between a collider attached to a kinematic body
+     * and another collider attached to a kinematic body.
+     */
     KINEMATIC_KINEMATIC = 52224,
+    /**
+     * Enable collision-detection between a collider attached to a kinematic body
+     * and another collider attached to a fixed body (or not attached to any body).
+     */
     KINEMATIC_FIXED = 8704,
+    /**
+     * Enable collision-detection between a collider attached to a fixed body (or
+     * not attached to any body) and another collider attached to a fixed body (or
+     * not attached to any body).
+     */
     FIXED_FIXED = 32,
+    /**
+     * The default active collision types, enabling collisions between a dynamic body
+     * and another body of any type, but not enabling collisions between two non-dynamic bodies.
+     */
     DEFAULT = 15,
+    /**
+     * Enable collisions between any kind of rigid-bodies (including between two non-dynamic bodies).
+     */
     ALL = 60943
@@ -71,2 +107,12 @@ }
     /**
+     * Sets whether this collider is enabled or not.
+     *
+     * @param enabled - Set to `false` to disable this collider (its parent rigid-body won’t be disabled automatically by this).
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Is this collider enabled?
+     */
+    isEnabled(): boolean;
+    /**
      * Sets the restitution coefficient of the collider to be created.
@@ -159,2 +205,12 @@ *
     /**
+     * Sets the total force magnitude beyond which a contact force event can be emitted.
+     *
+     * @param threshold - The new force threshold.
+     */
+    setContactForceEventThreshold(threshold: number): void;
+    /**
+     * The total force magnitude beyond which a contact force event can be emitted.
+     */
+    contactForceEventThreshold(): number;
+    /**
      * Set the collision types active for this collider.
@@ -166,2 +222,32 @@ *
     /**
+     * Sets the uniform density of this collider.
+     *
+     * This will override any previous mass-properties set by `this.setDensity`,
+     * `this.setMass`, `this.setMassProperties`, `ColliderDesc.density`,
+     * `ColliderDesc.mass`, or `ColliderDesc.massProperties` for this collider.
+     *
+     * The mass and angular inertia of this collider will be computed automatically based on its
+     * shape.
+     */
+    setDensity(density: number): void;
+    /**
+     * Sets the mass of this collider.
+     *
+     * This will override any previous mass-properties set by `this.setDensity`,
+     * `this.setMass`, `this.setMassProperties`, `ColliderDesc.density`,
+     * `ColliderDesc.mass`, or `ColliderDesc.massProperties` for this collider.
+     *
+     * The angular inertia of this collider will be computed automatically based on its shape
+     * and this mass value.
+     */
+    setMass(mass: number): void;
+    /**
+     * Sets the mass of this collider.
+     *
+     * This will override any previous mass-properties set by `this.setDensity`,
+     * `this.setMass`, `this.setMassProperties`, `ColliderDesc.density`,
+     * `ColliderDesc.mass`, or `ColliderDesc.massProperties` for this collider.
+     */
+    setMassProperties(mass: number, centerOfMass: Vector, principalAngularInertia: Vector, angularInertiaLocalFrame: Rotation): void;
+    /**
      * Sets the translation of this collider.
@@ -208,2 +294,8 @@ *
     /**
+     * Sets the half-extents of this collider if it is a cuboid shape.
+     *
+     * @param newHalfExtents - desired half extents.
+     */
+    setHalfExtents(newHalfExtents: Vector): void;
+    /**
      * The radius of this collider if it is a ball, cylinder, capsule, or cone shape.
@@ -214,2 +306,8 @@ * @deprecated this field will be removed in the future, please access this field on `shape` member instead.
     /**
+     * Sets the radius of this collider if it is a ball, cylinder, capsule, or cone shape.
+     *
+     * @param newRadius - desired radius.
+     */
+    setRadius(newRadius: number): void;
+    /**
      * The radius of the round edges of this collider if it is a round cylinder.
@@ -220,2 +318,8 @@ * @deprecated this field will be removed in the future, please access this field on `shape` member instead.
     /**
+     * Sets the radius of the round edges of this collider if it has round edges.
+     *
+     * @param newBorderRadius - desired round edge radius.
+     */
+    setRoundRadius(newBorderRadius: number): void;
+    /**
      * The half height of this collider if it is a cylinder, capsule, or cone shape.
@@ -226,2 +330,8 @@ * @deprecated this field will be removed in the future, please access this field on `shape` member instead.
     /**
+     * Sets the half height of this collider if it is a cylinder, capsule, or cone shape.
+     *
+     * @param newHalfheight - desired half height.
+     */
+    setHalfHeight(newHalfheight: number): void;
+    /**
      * If this collider has a triangle mesh, polyline, convex polygon, or convex polyhedron shape,
@@ -280,2 +390,10 @@ * this returns the vertex buffer of said shape.
     /**
+     * The mass of this collider.
+     */
+    mass(): number;
+    /**
+     * The volume of this collider.
+     */
+    volume(): number;
+    /**
      * The collision groups of this collider.
@@ -313,4 +431,4 @@ */
     intersectsRay(ray: Ray, maxToi: number): boolean;
-    castShape(collider1Vel: Vector, shape2: Shape, shape2Pos: Vector, shape2Rot: Rotation, shape2Vel: Vector, maxToi: number): ShapeTOI | null;
-    castCollider(collider1Vel: Vector, collider2: Collider, collider2Vel: Vector, maxToi: number): ShapeColliderTOI | null;
+    castShape(collider1Vel: Vector, shape2: Shape, shape2Pos: Vector, shape2Rot: Rotation, shape2Vel: Vector, maxToi: number, stopAtPenetration: boolean): ShapeTOI | null;
+    castCollider(collider1Vel: Vector, collider2: Collider, collider2Vel: Vector, maxToi: number, stopAtPenetration: boolean): ShapeColliderTOI | null;
     intersectsShape(shape2: Shape, shapePos2: Vector, shapeRot2: Rotation): boolean;
@@ -349,5 +467,11 @@ /**
 }
+export declare enum MassPropsMode {
+    Density = 0,
+    Mass = 1,
+    MassProps = 2
+}
 export declare class ColliderDesc {
+    enabled: boolean;
     shape: Shape;
-    useMassProps: boolean;
+    massPropsMode: MassPropsMode;
     mass: number;
@@ -370,2 +494,3 @@ centerOfMass: Vector;
     activeCollisionTypes: ActiveCollisionTypes;
+    contactForceEventThreshold: number;
     /**
@@ -534,8 +659,15 @@ * Initializes a collider descriptor from the collision shape.
      *
-     * @param is - Set to `true` of the collider built is to be a sensor.
+     * @param sensor - Set to `true` of the collider built is to be a sensor.
      */
-    setSensor(is: boolean): ColliderDesc;
+    setSensor(sensor: boolean): ColliderDesc;
     /**
+     * Sets whether the created collider will be enabled or disabled.
+     * @param enabled − If set to `false` the collider will be disabled at creation.
+     */
+    setEnabled(enabled: boolean): ColliderDesc;
+    /**
      * Sets the density of the collider being built.
      *
+     * The mass and angular inertia tensor will be computed automatically based on this density and the collider’s shape.
+     *
      * @param density - The density to set, must be greater or equal to 0. A density of 0 means that this collider
@@ -546,2 +678,10 @@ *                  will not affect the mass or angular inertia of the rigid-body it is attached to.
     /**
+     * Sets the mass of the collider being built.
+     *
+     * The angular inertia tensor will be computed automatically based on this mass and the collider’s shape.
+     *
+     * @param mass - The mass to set, must be greater or equal to 0.
+     */
+    setMass(mass: number): ColliderDesc;
+    /**
      * Sets the mass properties of the collider being built.
@@ -631,2 +771,8 @@ *
     setActiveCollisionTypes(activeCollisionTypes: ActiveCollisionTypes): ColliderDesc;
+    /**
+     * Sets the total force magnitude beyond which a contact force event can be emitted.
+     *
+     * @param threshold - The force threshold to set.
+     */
+    setContactForceEventThreshold(threshold: number): ColliderDesc;
 }

geometry/shape.d.ts

@@ -27,8 +27,11 @@ import { Vector, Rotation } from "../math";
      * @param shapeVel2 - The velocity of the second shape.
-     * @param maxToi - The maximum time when the inpact can happen.
-     * @returns If the two moving shapes collider at some point along their trajectories, this retruns the
-     *  time at which the two shape collider as well as the contact information durning the impact. Returns
+     * @param maxToi - The maximum time when the impact can happen.
+     * @param stopAtPenetration - If set to `false`, the linear shape-cast won’t immediately stop if
+     *   the shape is penetrating another shape at its starting point **and** its trajectory is such
+     *   that it’s on a path to exist that penetration state.
+     * @returns If the two moving shapes collider at some point along their trajectories, this returns the
+     *  time at which the two shape collider as well as the contact information during the impact. Returns
      *  `null`if the two shapes never collide along their paths.
      */
-    castShape(shapePos1: Vector, shapeRot1: Rotation, shapeVel1: Vector, shape2: Shape, shapePos2: Vector, shapeRot2: Rotation, shapeVel2: Vector, maxToi: number): ShapeTOI | null;
+    castShape(shapePos1: Vector, shapeRot1: Rotation, shapeVel1: Vector, shape2: Shape, shapePos2: Vector, shapeRot2: Rotation, shapeVel2: Vector, maxToi: number, stopAtPenetration: boolean): ShapeTOI | null;
     /**
@@ -82,3 +85,4 @@ * Tests if this shape intersects another shape.
     RoundCone = 15,
-    RoundConvexPolyhedron = 16
+    RoundConvexPolyhedron = 16,
+    HalfSpace = 17
 }
@@ -101,2 +105,16 @@ /**
 }
+export declare class HalfSpace extends Shape {
+    readonly type = ShapeType.HalfSpace;
+    /**
+     * The outward normal of the half-space.
+     */
+    normal: Vector;
+    /**
+     * Creates a new halfspace delimited by an infinite plane.
+     *
+     * @param normal - The outward normal of the plane.
+     */
+    constructor(normal: Vector);
+    intoRaw(): RawShape;
+}
 /**
@@ -103,0 +121,0 @@ * A shape that is a box in 3D and a rectangle in 2D.

math.d.ts

 import { RawVector, RawRotation } from "./raw";
+import { RawSdpMatrix3 } from "./raw";
 export interface Vector {
@@ -21,2 +22,3 @@ x: number;
     static fromRaw(raw: RawVector): Vector;
+    static copy(out: Vector, input: Vector): void;
 }
@@ -43,2 +45,52 @@ export interface Rotation {
     static intoRaw(rot: Rotation): RawRotation;
+    static copy(out: Rotation, input: Rotation): void;
 }
+/**
+ * A 3D symmetric-positive-definite matrix.
+ */
+export declare class SdpMatrix3 {
+    /**
+     * Row major list of the upper-triangular part of the symmetric matrix.
+     */
+    elements: Float32Array;
+    /**
+     * Matrix element at row 1, column 1.
+     */
+    get m11(): number;
+    /**
+     * Matrix element at row 1, column 2.
+     */
+    get m12(): number;
+    /**
+     * Matrix element at row 2, column 1.
+     */
+    get m21(): number;
+    /**
+     * Matrix element at row 1, column 3.
+     */
+    get m13(): number;
+    /**
+     * Matrix element at row 3, column 1.
+     */
+    get m31(): number;
+    /**
+     * Matrix element at row 2, column 2.
+     */
+    get m22(): number;
+    /**
+     * Matrix element at row 2, column 3.
+     */
+    get m23(): number;
+    /**
+     * Matrix element at row 3, column 2.
+     */
+    get m32(): number;
+    /**
+     * Matrix element at row 3, column 3.
+     */
+    get m33(): number;
+    constructor(elements: Float32Array);
+}
+export declare class SdpMatrix3Ops {
+    static fromRaw(raw: RawSdpMatrix3): SdpMatrix3;
+}

package.json

@@ -7,3 +7,3 @@ {
   "description": "3-dimensional physics engine in Rust - official JS bindings. Compatibility package with inlined webassembly as base64.",
-  "version": "0.0.0-3666fff-20220701",
+  "version": "0.0.0-4699217-20230304",
   "license": "Apache-2.0",
@@ -10,0 +10,0 @@ "repository": {

pipeline/event_queue.d.ts

@@ -1,7 +0,57 @@
-import { RawEventQueue } from "../raw";
+import { RawContactForceEvent, RawEventQueue } from "../raw";
 import { ColliderHandle } from "../geometry";
+import { Vector } from "../math";
+/**
+ * Flags indicating what events are enabled for colliders.
+ */
 export declare enum ActiveEvents {
-    COLLISION_EVENTS = 1
+    /**
+     * Enable collision events.
+     */
+    COLLISION_EVENTS = 1,
+    /**
+     * Enable contact force events.
+     */
+    CONTACT_FORCE_EVENTS = 2
 }
 /**
+ * Event occurring when the sum of the magnitudes of the
+ * contact forces between two colliders exceed a threshold.
+ *
+ * This object should **not** be stored anywhere. Its properties can only be
+ * read from within the closure given to `EventHandler.drainContactForceEvents`.
+ */
+export declare class TempContactForceEvent {
+    raw: RawContactForceEvent;
+    free(): void;
+    /**
+     * The first collider involved in the contact.
+     */
+    collider1(): ColliderHandle;
+    /**
+     * The second collider involved in the contact.
+     */
+    collider2(): ColliderHandle;
+    /**
+     * The sum of all the forces between the two colliders.
+     */
+    totalForce(): Vector;
+    /**
+     * The sum of the magnitudes of each force between the two colliders.
+     *
+     * Note that this is **not** the same as the magnitude of `self.total_force`.
+     * Here we are summing the magnitude of all the forces, instead of taking
+     * the magnitude of their sum.
+     */
+    totalForceMagnitude(): number;
+    /**
+     * The world-space (unit) direction of the force with strongest magnitude.
+     */
+    maxForceDirection(): Vector;
+    /**
+     * The magnitude of the largest force at a contact point of this contact pair.
+     */
+    maxForceMagnitude(): number;
+}
+/**
  * A structure responsible for collecting events generated
@@ -39,2 +89,10 @@ * by the physics engine.
     /**
+     * Applies the given javascript closure on each contact force event of this collector, then clear
+     * the internal collision event buffer.
+     *
+     * @param f - JavaScript closure applied to each collision event. The
+     *            closure must take one `TempContactForceEvent` argument.
+     */
+    drainContactForceEvents(f: (event: TempContactForceEvent) => void): void;
+    /**
      * Removes all events contained by this collector
@@ -41,0 +99,0 @@ */

pipeline/index.d.ts

@@ -7,1 +7,2 @@ export * from "./world";
 export * from "./debug_render_pipeline";
+export * from "./query_pipeline";

pipeline/query_pipeline.d.ts

 import { RawQueryPipeline } from "../raw";
 import { ColliderHandle, ColliderSet, InteractionGroups, PointColliderProjection, Ray, RayColliderIntersection, RayColliderToi, Shape, ShapeColliderTOI } from "../geometry";
-import { IslandManager, RigidBodySet } from "../dynamics";
+import { RigidBodyHandle, RigidBodySet } from "../dynamics";
 import { Rotation, Vector } from "../math";
 /**
+ * Flags for excluding whole sets of colliders from a scene query.
+ */
+export declare enum QueryFilterFlags {
+    /**
+     * Exclude from the query any collider attached to a fixed rigid-body and colliders with no rigid-body attached.
+     */
+    EXCLUDE_FIXED = 1,
+    /**
+     * Exclude from the query any collider attached to a dynamic rigid-body.
+     */
+    EXCLUDE_KINEMATIC = 2,
+    /**
+     * Exclude from the query any collider attached to a kinematic rigid-body.
+     */
+    EXCLUDE_DYNAMIC = 4,
+    /**
+     * Exclude from the query any collider that is a sensor.
+     */
+    EXCLUDE_SENSORS = 8,
+    /**
+     * Exclude from the query any collider that is not a sensor.
+     */
+    EXCLUDE_SOLIDS = 16,
+    /**
+     * Excludes all colliders not attached to a dynamic rigid-body.
+     */
+    ONLY_DYNAMIC = 3,
+    /**
+     * Excludes all colliders not attached to a kinematic rigid-body.
+     */
+    ONLY_KINEMATIC = 5,
+    /**
+     * Exclude all colliders attached to a non-fixed rigid-body
+     * (this will not exclude colliders not attached to any rigid-body).
+     */
+    ONLY_FIXED = 6
+}
+/**
  * A pipeline for performing queries on all the colliders of a scene.
@@ -23,3 +61,3 @@ *
      */
-    update(islands: IslandManager, bodies: RigidBodySet, colliders: ColliderSet): void;
+    update(bodies: RigidBodySet, colliders: ColliderSet): void;
     /**
@@ -38,3 +76,3 @@ * Find the closest intersection between a ray and a set of collider.
      */
-    castRay(colliders: ColliderSet, ray: Ray, maxToi: number, solid: boolean, groups: InteractionGroups, filter?: (collider: ColliderHandle) => boolean): RayColliderToi | null;
+    castRay(bodies: RigidBodySet, colliders: ColliderSet, ray: Ray, maxToi: number, solid: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean): RayColliderToi | null;
     /**
@@ -53,3 +91,3 @@ * Find the closest intersection between a ray and a set of collider.
      */
-    castRayAndGetNormal(colliders: ColliderSet, ray: Ray, maxToi: number, solid: boolean, groups: InteractionGroups, filter?: (collider: ColliderHandle) => boolean): RayColliderIntersection | null;
+    castRayAndGetNormal(bodies: RigidBodySet, colliders: ColliderSet, ray: Ray, maxToi: number, solid: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean): RayColliderIntersection | null;
     /**
@@ -69,3 +107,3 @@ * Cast a ray and collects all the intersections between a ray and the scene.
      */
-    intersectionsWithRay(colliders: ColliderSet, ray: Ray, maxToi: number, solid: boolean, groups: InteractionGroups, callback: (intersect: RayColliderIntersection) => boolean, filter?: (collider: ColliderHandle) => boolean): void;
+    intersectionsWithRay(bodies: RigidBodySet, colliders: ColliderSet, ray: Ray, maxToi: number, solid: boolean, callback: (intersect: RayColliderIntersection) => boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean): void;
     /**
@@ -81,3 +119,3 @@ * Gets the handle of up to one collider intersecting the given shape.
      */
-    intersectionWithShape(colliders: ColliderSet, shapePos: Vector, shapeRot: Rotation, shape: Shape, groups: InteractionGroups, filter?: (collider: ColliderHandle) => boolean): ColliderHandle | null;
+    intersectionWithShape(bodies: RigidBodySet, colliders: ColliderSet, shapePos: Vector, shapeRot: Rotation, shape: Shape, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean): ColliderHandle | null;
     /**
@@ -96,3 +134,3 @@ * Find the projection of a point on the closest collider.
      */
-    projectPoint(colliders: ColliderSet, point: Vector, solid: boolean, groups: InteractionGroups, filter?: (collider: ColliderHandle) => boolean): PointColliderProjection | null;
+    projectPoint(bodies: RigidBodySet, colliders: ColliderSet, point: Vector, solid: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean): PointColliderProjection | null;
     /**
@@ -106,3 +144,3 @@ * Find the projection of a point on the closest collider.
      */
-    projectPointAndGetFeature(colliders: ColliderSet, point: Vector, groups: InteractionGroups, filter?: (collider: ColliderHandle) => boolean): PointColliderProjection | null;
+    projectPointAndGetFeature(bodies: RigidBodySet, colliders: ColliderSet, point: Vector, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean): PointColliderProjection | null;
     /**
@@ -118,3 +156,3 @@ * Find all the colliders containing the given point.
      */
-    intersectionsWithPoint(colliders: ColliderSet, point: Vector, groups: InteractionGroups, callback: (handle: ColliderHandle) => boolean, filter?: (collider: ColliderHandle) => boolean): void;
+    intersectionsWithPoint(bodies: RigidBodySet, colliders: ColliderSet, point: Vector, callback: (handle: ColliderHandle) => boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean): void;
     /**
@@ -132,6 +170,9 @@ * Casts a shape at a constant linear velocity and retrieve the first collider it hits.
      *   limits the distance traveled by the shape to `shapeVel.norm() * maxToi`.
+     * @param stopAtPenetration - If set to `false`, the linear shape-cast won’t immediately stop if
+     *   the shape is penetrating another shape at its starting point **and** its trajectory is such
+     *   that it’s on a path to exist that penetration state.
      * @param groups - The bit groups and filter associated to the shape to cast, in order to only
      *   test on colliders with collision groups compatible with this group.
      */
-    castShape(colliders: ColliderSet, shapePos: Vector, shapeRot: Rotation, shapeVel: Vector, shape: Shape, maxToi: number, groups: InteractionGroups, filter?: (collider: ColliderHandle) => boolean): ShapeColliderTOI | null;
+    castShape(bodies: RigidBodySet, colliders: ColliderSet, shapePos: Vector, shapeRot: Rotation, shapeVel: Vector, shape: Shape, maxToi: number, stopAtPenetration: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean): ShapeColliderTOI | null;
     /**
@@ -148,3 +189,3 @@ * Retrieve all the colliders intersecting the given shape.
      */
-    intersectionsWithShape(colliders: ColliderSet, shapePos: Vector, shapeRot: Rotation, shape: Shape, groups: InteractionGroups, callback: (handle: ColliderHandle) => boolean, filter?: (collider: ColliderHandle) => boolean): void;
+    intersectionsWithShape(bodies: RigidBodySet, colliders: ColliderSet, shapePos: Vector, shapeRot: Rotation, shape: Shape, callback: (handle: ColliderHandle) => boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean): void;
     /**
@@ -151,0 +192,0 @@ * Finds the handles of all the colliders with an AABB intersecting the given AABB.

pipeline/world.d.ts

@@ -6,3 +6,3 @@ import { RawBroadPhase, RawCCDSolver, RawColliderSet, RawDeserializedWorld, RawIntegrationParameters, RawIslandManager, RawImpulseJointSet, RawMultibodyJointSet, RawNarrowPhase, RawPhysicsPipeline, RawQueryPipeline, RawRigidBodySet, RawSerializationPipeline, RawDebugRenderPipeline } from "../raw";
 import { PhysicsPipeline } from "./physics_pipeline";
-import { QueryPipeline } from "./query_pipeline";
+import { QueryFilterFlags, QueryPipeline } from "./query_pipeline";
 import { SerializationPipeline } from "./serialization_pipeline";
@@ -12,2 +12,3 @@ import { EventQueue } from "./event_queue";
 import { DebugRenderBuffers, DebugRenderPipeline } from "./debug_render_pipeline";
+import { KinematicCharacterController } from "../control";
 /**
@@ -34,2 +35,3 @@ * The physics world.
     debugRenderPipeline: DebugRenderPipeline;
+    characterControllers: Set<KinematicCharacterController>;
     /**
@@ -71,2 +73,16 @@ * Release the WASM memory occupied by this physics world.
     /**
+     * Update colliders positions after rigid-bodies moved.
+     *
+     * When a rigid-body moves, the positions of the colliders attached to it need to be updated. This update is
+     * generally automatically done at the beginning and the end of each simulation step with World.step.
+     * If the positions need to be updated without running a simulation step this method can be called manually.
+     */
+    propagateModifiedBodyPositionsToColliders(): void;
+    /**
+     * Ensure subsequent scene queries take into account the collider positions set before this method is called.
+     *
+     * This does not step the physics simulation forward.
+     */
+    updateSceneQueries(): void;
+    /**
      * The current simulation timestep.
@@ -132,2 +148,14 @@ */
     /**
+     * Creates a new character controller.
+     *
+     * @param offset - The artificial gap added between the character’s chape and its environment.
+     */
+    createCharacterController(offset: number): KinematicCharacterController;
+    /**
+     * Removes a character controller from this world.
+     *
+     * @param controller - The character controller to remove.
+     */
+    removeCharacterController(controller: KinematicCharacterController): void;
+    /**
      * Creates a new collider.
@@ -245,3 +273,3 @@ *
      */
-    castRay(ray: Ray, maxToi: number, solid: boolean, groups: InteractionGroups, filter?: (collider: Collider) => boolean): RayColliderToi | null;
+    castRay(ray: Ray, maxToi: number, solid: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): RayColliderToi | null;
     /**
@@ -259,3 +287,3 @@ * Find the closest intersection between a ray and the physics world.
      */
-    castRayAndGetNormal(ray: Ray, maxToi: number, solid: boolean, groups: InteractionGroups, filter?: (collider: Collider) => boolean): RayColliderIntersection | null;
+    castRayAndGetNormal(ray: Ray, maxToi: number, solid: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): RayColliderIntersection | null;
     /**
@@ -274,3 +302,3 @@ * Cast a ray and collects all the intersections between a ray and the scene.
      */
-    intersectionsWithRay(ray: Ray, maxToi: number, solid: boolean, groups: InteractionGroups, callback: (intersect: RayColliderIntersection) => boolean, filter?: (collider: Collider) => boolean): void;
+    intersectionsWithRay(ray: Ray, maxToi: number, solid: boolean, callback: (intersect: RayColliderIntersection) => boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): void;
     /**
@@ -285,3 +313,3 @@ * Gets the handle of up to one collider intersecting the given shape.
      */
-    intersectionWithShape(shapePos: Vector, shapeRot: Rotation, shape: Shape, groups: InteractionGroups, filter?: (collider: Collider) => boolean): Collider | null;
+    intersectionWithShape(shapePos: Vector, shapeRot: Rotation, shape: Shape, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): Collider | null;
     /**
@@ -299,3 +327,3 @@ * Find the projection of a point on the closest collider.
      */
-    projectPoint(point: Vector, solid: boolean, groups: InteractionGroups, filter?: (collider: Collider) => boolean): PointColliderProjection | null;
+    projectPoint(point: Vector, solid: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): PointColliderProjection | null;
     /**
@@ -308,3 +336,3 @@ * Find the projection of a point on the closest collider.
      */
-    projectPointAndGetFeature(point: Vector, groups: InteractionGroups, filter?: (collider: Collider) => boolean): PointColliderProjection | null;
+    projectPointAndGetFeature(point: Vector, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): PointColliderProjection | null;
     /**
@@ -319,3 +347,3 @@ * Find all the colliders containing the given point.
      */
-    intersectionsWithPoint(point: Vector, groups: InteractionGroups, callback: (handle: Collider) => boolean, filter?: (collider: Collider) => boolean): void;
+    intersectionsWithPoint(point: Vector, callback: (handle: Collider) => boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): void;
     /**
@@ -332,6 +360,9 @@ * Casts a shape at a constant linear velocity and retrieve the first collider it hits.
      *   limits the distance traveled by the shape to `shapeVel.norm() * maxToi`.
+     * @param stopAtPenetration - If set to `false`, the linear shape-cast won’t immediately stop if
+     *   the shape is penetrating another shape at its starting point **and** its trajectory is such
+     *   that it’s on a path to exist that penetration state.
      * @param groups - The bit groups and filter associated to the shape to cast, in order to only
      *   test on colliders with collision groups compatible with this group.
      */
-    castShape(shapePos: Vector, shapeRot: Rotation, shapeVel: Vector, shape: Shape, maxToi: number, groups: InteractionGroups, filter?: (collider: Collider) => boolean): ShapeColliderTOI | null;
+    castShape(shapePos: Vector, shapeRot: Rotation, shapeVel: Vector, shape: Shape, maxToi: number, stopAtPenetration: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): ShapeColliderTOI | null;
     /**
@@ -347,3 +378,3 @@ * Retrieve all the colliders intersecting the given shape.
      */
-    intersectionsWithShape(shapePos: Vector, shapeRot: Rotation, shape: Shape, groups: InteractionGroups, callback: (handle: Collider) => boolean, filter?: (collider: Collider) => boolean): void;
+    intersectionsWithShape(shapePos: Vector, shapeRot: Rotation, shape: Shape, callback: (collider: Collider) => boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): void;
     /**
@@ -350,0 +381,0 @@ * Finds the handles of all the colliders with an AABB intersecting the given AABB.

rapier_wasm3d_bg.wasm.d.ts

@@ -5,2 +5,39 @@ /* tslint:disable */
 export function version(a: number): void;
+export function __wbg_rawkinematiccharactercontroller_free(a: number): void;
+export function rawkinematiccharactercontroller_new(a: number): number;
+export function rawkinematiccharactercontroller_up(a: number): number;
+export function rawkinematiccharactercontroller_setUp(a: number, b: number): void;
+export function rawkinematiccharactercontroller_offset(a: number): number;
+export function rawkinematiccharactercontroller_setOffset(a: number, b: number): void;
+export function rawkinematiccharactercontroller_slideEnabled(a: number): number;
+export function rawkinematiccharactercontroller_setSlideEnabled(a: number, b: number): void;
+export function rawkinematiccharactercontroller_autostepMaxHeight(a: number, b: number): void;
+export function rawkinematiccharactercontroller_autostepMinWidth(a: number, b: number): void;
+export function rawkinematiccharactercontroller_autostepIncludesDynamicBodies(a: number): number;
+export function rawkinematiccharactercontroller_autostepEnabled(a: number): number;
+export function rawkinematiccharactercontroller_enableAutostep(a: number, b: number, c: number, d: number): void;
+export function rawkinematiccharactercontroller_disableAutostep(a: number): void;
+export function rawkinematiccharactercontroller_maxSlopeClimbAngle(a: number): number;
+export function rawkinematiccharactercontroller_setMaxSlopeClimbAngle(a: number, b: number): void;
+export function rawkinematiccharactercontroller_minSlopeSlideAngle(a: number): number;
+export function rawkinematiccharactercontroller_setMinSlopeSlideAngle(a: number, b: number): void;
+export function rawkinematiccharactercontroller_snapToGroundDistance(a: number, b: number): void;
+export function rawkinematiccharactercontroller_enableSnapToGround(a: number, b: number): void;
+export function rawkinematiccharactercontroller_disableSnapToGround(a: number): void;
+export function rawkinematiccharactercontroller_snapToGroundEnabled(a: number): number;
+export function rawkinematiccharactercontroller_computeColliderMovement(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number): void;
+export function rawkinematiccharactercontroller_computedMovement(a: number): number;
+export function rawkinematiccharactercontroller_computedGrounded(a: number): number;
+export function rawkinematiccharactercontroller_numComputedCollisions(a: number): number;
+export function rawkinematiccharactercontroller_computedCollision(a: number, b: number, c: number): number;
+export function __wbg_rawcharactercollision_free(a: number): void;
+export function rawcharactercollision_new(): number;
+export function rawcharactercollision_handle(a: number): number;
+export function rawcharactercollision_translationApplied(a: number): number;
+export function rawcharactercollision_translationRemaining(a: number): number;
+export function rawcharactercollision_toi(a: number): number;
+export function rawcharactercollision_worldWitness1(a: number): number;
+export function rawcharactercollision_worldWitness2(a: number): number;
+export function rawcharactercollision_worldNormal1(a: number): number;
+export function rawcharactercollision_worldNormal2(a: number): number;
 export function __wbg_rawccdsolver_free(a: number): void;
@@ -15,5 +52,10 @@ export function rawccdsolver_new(): number;
 export function rawimpulsejointset_jointAnchor2(a: number, b: number): number;
+export function rawimpulsejointset_jointSetAnchor1(a: number, b: number, c: number): void;
+export function rawimpulsejointset_jointSetAnchor2(a: number, b: number, c: number): void;
+export function rawimpulsejointset_jointContactsEnabled(a: number, b: number): number;
+export function rawimpulsejointset_jointSetContactsEnabled(a: number, b: number, c: number): void;
 export function rawimpulsejointset_jointLimitsEnabled(a: number, b: number, c: number): number;
 export function rawimpulsejointset_jointLimitsMin(a: number, b: number, c: number): number;
 export function rawimpulsejointset_jointLimitsMax(a: number, b: number, c: number): number;
+export function rawimpulsejointset_jointSetLimits(a: number, b: number, c: number, d: number, e: number): void;
 export function rawimpulsejointset_jointConfigureMotorModel(a: number, b: number, c: number, d: number): void;
@@ -34,3 +76,2 @@ export function rawimpulsejointset_jointConfigureMotorVelocity(a: number, b: number, c: number, d: number, e: number): void;
 export function rawintegrationparameters_dt(a: number): number;
-export function rawintegrationparameters_erp(a: number): number;
 export function rawintegrationparameters_allowedLinearError(a: number): number;
@@ -65,2 +106,4 @@ export function rawintegrationparameters_predictionDistance(a: number): number;
 export function rawmultibodyjointset_jointAnchor2(a: number, b: number): number;
+export function rawmultibodyjointset_jointContactsEnabled(a: number, b: number): number;
+export function rawmultibodyjointset_jointSetContactsEnabled(a: number, b: number, c: number): void;
 export function rawmultibodyjointset_jointLimitsEnabled(a: number, b: number, c: number): number;
@@ -89,8 +132,11 @@ export function rawmultibodyjointset_jointLimitsMin(a: number, b: number, c: number): number;
 export function rawrigidbodyset_rbSetNextKinematicRotation(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function rawrigidbodyset_rbRecomputeMassPropertiesFromColliders(a: number, b: number, c: number): void;
+export function rawrigidbodyset_rbSetAdditionalMass(a: number, b: number, c: number, d: number): void;
+export function rawrigidbodyset_rbSetAdditionalMassProperties(a: number, b: number, c: number, d: number, e: number, f: number, g: number): void;
 export function rawrigidbodyset_rbLinvel(a: number, b: number): number;
 export function rawrigidbodyset_rbAngvel(a: number, b: number): number;
 export function rawrigidbodyset_rbLockTranslations(a: number, b: number, c: number, d: number): void;
-export function rawrigidbodyset_rbRestrictTranslations(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function rawrigidbodyset_rbSetEnabledTranslations(a: number, b: number, c: number, d: number, e: number, f: number): void;
 export function rawrigidbodyset_rbLockRotations(a: number, b: number, c: number, d: number): void;
-export function rawrigidbodyset_rbRestrictRotations(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function rawrigidbodyset_rbSetEnabledRotations(a: number, b: number, c: number, d: number, e: number, f: number): void;
 export function rawrigidbodyset_rbDominanceGroup(a: number, b: number): number;
@@ -100,2 +146,11 @@ export function rawrigidbodyset_rbSetDominanceGroup(a: number, b: number, c: number): void;
 export function rawrigidbodyset_rbMass(a: number, b: number): number;
+export function rawrigidbodyset_rbInvMass(a: number, b: number): number;
+export function rawrigidbodyset_rbEffectiveInvMass(a: number, b: number): number;
+export function rawrigidbodyset_rbLocalCom(a: number, b: number): number;
+export function rawrigidbodyset_rbWorldCom(a: number, b: number): number;
+export function rawrigidbodyset_rbInvPrincipalInertiaSqrt(a: number, b: number): number;
+export function rawrigidbodyset_rbPrincipalInertiaLocalFrame(a: number, b: number): number;
+export function rawrigidbodyset_rbPrincipalInertia(a: number, b: number): number;
+export function rawrigidbodyset_rbEffectiveWorldInvInertiaSqrt(a: number, b: number): number;
+export function rawrigidbodyset_rbEffectiveAngularInertia(a: number, b: number): number;
 export function rawrigidbodyset_rbWakeUp(a: number, b: number): void;
@@ -106,3 +161,3 @@ export function rawrigidbodyset_rbIsCcdEnabled(a: number, b: number): number;
 export function rawrigidbodyset_rbBodyType(a: number, b: number): number;
-export function rawrigidbodyset_rbSetBodyType(a: number, b: number, c: number): void;
+export function rawrigidbodyset_rbSetBodyType(a: number, b: number, c: number, d: number): void;
 export function rawrigidbodyset_rbIsFixed(a: number, b: number): number;
@@ -115,2 +170,4 @@ export function rawrigidbodyset_rbIsKinematic(a: number, b: number): number;
 export function rawrigidbodyset_rbSetAngularDamping(a: number, b: number, c: number): void;
+export function rawrigidbodyset_rbSetEnabled(a: number, b: number, c: number): void;
+export function rawrigidbodyset_rbIsEnabled(a: number, b: number): number;
 export function rawrigidbodyset_rbGravityScale(a: number, b: number): number;
@@ -130,3 +187,3 @@ export function rawrigidbodyset_rbSetGravityScale(a: number, b: number, c: number, d: number): void;
 export function rawrigidbodyset_new(): number;
-export function rawrigidbodyset_createRigidBody(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number): number;
+export function rawrigidbodyset_createRigidBody(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number): number;
 export function rawrigidbodyset_remove(a: number, b: number, c: number, d: number, e: number, f: number): void;
@@ -136,2 +193,3 @@ export function rawrigidbodyset_len(a: number): number;
 export function rawrigidbodyset_forEachRigidBodyHandle(a: number, b: number): void;
+export function rawrigidbodyset_propagateModifiedBodyPositionsToColliders(a: number, b: number): void;
 export function __wbg_rawbroadphase_free(a: number): void;
@@ -147,6 +205,11 @@ export function rawbroadphase_new(): number;
 export function rawcolliderset_coShapeType(a: number, b: number): number;
+export function rawcolliderset_coHalfspaceNormal(a: number, b: number): number;
 export function rawcolliderset_coHalfExtents(a: number, b: number): number;
+export function rawcolliderset_coSetHalfExtents(a: number, b: number, c: number): void;
 export function rawcolliderset_coRadius(a: number, b: number, c: number): void;
+export function rawcolliderset_coSetRadius(a: number, b: number, c: number): void;
 export function rawcolliderset_coHalfHeight(a: number, b: number, c: number): void;
+export function rawcolliderset_coSetHalfHeight(a: number, b: number, c: number): void;
 export function rawcolliderset_coRoundRadius(a: number, b: number, c: number): void;
+export function rawcolliderset_coSetRoundRadius(a: number, b: number, c: number): void;
 export function rawcolliderset_coVertices(a: number, b: number, c: number): void;
@@ -159,5 +222,9 @@ export function rawcolliderset_coIndices(a: number, b: number, c: number): void;
 export function rawcolliderset_coParent(a: number, b: number, c: number): void;
+export function rawcolliderset_coSetEnabled(a: number, b: number, c: number): void;
+export function rawcolliderset_coIsEnabled(a: number, b: number): number;
 export function rawcolliderset_coFriction(a: number, b: number): number;
 export function rawcolliderset_coRestitution(a: number, b: number): number;
-export function rawcolliderset_coDensity(a: number, b: number, c: number): void;
+export function rawcolliderset_coDensity(a: number, b: number): number;
+export function rawcolliderset_coMass(a: number, b: number): number;
+export function rawcolliderset_coVolume(a: number, b: number): number;
 export function rawcolliderset_coCollisionGroups(a: number, b: number): number;
@@ -168,5 +235,6 @@ export function rawcolliderset_coSolverGroups(a: number, b: number): number;
 export function rawcolliderset_coActiveEvents(a: number, b: number): number;
+export function rawcolliderset_coContactForceEventThreshold(a: number, b: number): number;
 export function rawcolliderset_coContainsPoint(a: number, b: number, c: number): number;
-export function rawcolliderset_coCastShape(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): number;
-export function rawcolliderset_coCastCollider(a: number, b: number, c: number, d: number, e: number, f: number): number;
+export function rawcolliderset_coCastShape(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number): number;
+export function rawcolliderset_coCastCollider(a: number, b: number, c: number, d: number, e: number, f: number, g: number): number;
 export function rawcolliderset_coIntersectsShape(a: number, b: number, c: number, d: number, e: number): number;
@@ -192,2 +260,6 @@ export function rawcolliderset_coContactShape(a: number, b: number, c: number, d: number, e: number, f: number): number;
 export function rawcolliderset_coSetShape(a: number, b: number, c: number): void;
+export function rawcolliderset_coSetContactForceEventThreshold(a: number, b: number, c: number): void;
+export function rawcolliderset_coSetDensity(a: number, b: number, c: number): void;
+export function rawcolliderset_coSetMass(a: number, b: number, c: number): void;
+export function rawcolliderset_coSetMassProperties(a: number, b: number, c: number, d: number, e: number, f: number): void;
 export function __wbg_rawcolliderset_free(a: number): void;
@@ -197,3 +269,3 @@ export function rawcolliderset_new(): number;
 export function rawcolliderset_contains(a: number, b: number): number;
-export function rawcolliderset_createCollider(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number): void;
+export function rawcolliderset_createCollider(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number): void;
 export function rawcolliderset_remove(a: number, b: number, c: number, d: number, e: number): void;
@@ -203,5 +275,2 @@ export function rawcolliderset_forEachColliderHandle(a: number, b: number): void;
 export function rawshapecontact_distance(a: number): number;
-export function rawshapecontact_point2(a: number): number;
-export function rawshapecontact_normal1(a: number): number;
-export function rawshapecontact_normal2(a: number): number;
 export function __wbg_rawnarrowphase_free(a: number): void;
@@ -239,12 +308,7 @@ export function rawnarrowphase_new(): number;
 export function __wbg_rawpointprojection_free(a: number): void;
-export function rawpointprojection_point(a: number): number;
-export function rawpointprojection_isInside(a: number): number;
 export function __wbg_rawpointcolliderprojection_free(a: number): void;
 export function rawpointcolliderprojection_colliderHandle(a: number): number;
-export function rawpointcolliderprojection_point(a: number): number;
-export function rawpointcolliderprojection_isInside(a: number): number;
 export function rawpointcolliderprojection_featureType(a: number): number;
 export function rawpointcolliderprojection_featureId(a: number, b: number): void;
 export function __wbg_rawrayintersection_free(a: number): void;
-export function rawrayintersection_normal(a: number): number;
 export function rawrayintersection_featureType(a: number): number;
@@ -254,2 +318,4 @@ export function rawrayintersection_featureId(a: number, b: number): void;
 export function rawraycolliderintersection_toi(a: number): number;
+export function rawraycolliderintersection_featureType(a: number): number;
+export function rawraycolliderintersection_featureId(a: number, b: number): void;
 export function __wbg_rawraycollidertoi_free(a: number): void;
@@ -260,2 +326,3 @@ export function __wbg_rawshape_free(a: number): void;
 export function rawshape_ball(a: number): number;
+export function rawshape_halfspace(a: number): number;
 export function rawshape_capsule(a: number, b: number): number;
@@ -276,3 +343,3 @@ export function rawshape_cylinder(a: number, b: number): number;
 export function rawshape_roundConvexMesh(a: number, b: number, c: number, d: number, e: number): number;
-export function rawshape_castShape(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number): number;
+export function rawshape_castShape(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number): number;
 export function rawshape_intersectsShape(a: number, b: number, c: number, d: number, e: number, f: number): number;
@@ -286,3 +353,3 @@ export function rawshape_contactShape(a: number, b: number, c: number, d: number, e: number, f: number, g: number): number;
 export function __wbg_rawshapetoi_free(a: number): void;
-export function rawshapetoi_witness2(a: number): number;
+export function rawshapetoi_witness1(a: number): number;
 export function rawshapetoi_normal1(a: number): number;
@@ -292,3 +359,2 @@ export function rawshapetoi_normal2(a: number): number;
 export function rawshapecollidertoi_witness2(a: number): number;
-export function rawshapecollidertoi_normal1(a: number): number;
 export function rawshapecollidertoi_normal2(a: number): number;
@@ -308,2 +374,3 @@ export function rawrotation_new(a: number, b: number, c: number, d: number): number;
 export function rawvector_zyx(a: number): number;
+export function rawsdpmatrix3_elements(a: number): number;
 export function __wbg_rawdebugrenderpipeline_free(a: number): void;
@@ -315,4 +382,11 @@ export function rawdebugrenderpipeline_new(): number;
 export function __wbg_raweventqueue_free(a: number): void;
+export function __wbg_rawcontactforceevent_free(a: number): void;
+export function rawcontactforceevent_collider2(a: number): number;
+export function rawcontactforceevent_total_force(a: number): number;
+export function rawcontactforceevent_total_force_magnitude(a: number): number;
+export function rawcontactforceevent_max_force_direction(a: number): number;
+export function rawcontactforceevent_max_force_magnitude(a: number): number;
 export function raweventqueue_new(a: number): number;
 export function raweventqueue_drainCollisionEvents(a: number, b: number): void;
+export function raweventqueue_drainContactForceEvents(a: number, b: number): void;
 export function raweventqueue_clear(a: number): void;
@@ -325,12 +399,12 @@ export function __wbg_rawphysicspipeline_free(a: number): void;
 export function rawquerypipeline_new(): number;
-export function rawquerypipeline_update(a: number, b: number, c: number, d: number): void;
-export function rawquerypipeline_castRay(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): number;
-export function rawquerypipeline_castRayAndGetNormal(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): number;
-export function rawquerypipeline_intersectionsWithRay(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number): void;
-export function rawquerypipeline_intersectionWithShape(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): void;
-export function rawquerypipeline_projectPoint(a: number, b: number, c: number, d: number, e: number, f: number): number;
-export function rawquerypipeline_projectPointAndGetFeature(a: number, b: number, c: number, d: number, e: number): number;
-export function rawquerypipeline_intersectionsWithPoint(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function rawquerypipeline_castShape(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number): number;
-export function rawquerypipeline_intersectionsWithShape(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): void;
+export function rawquerypipeline_update(a: number, b: number, c: number): void;
+export function rawquerypipeline_castRay(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number): number;
+export function rawquerypipeline_castRayAndGetNormal(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number): number;
+export function rawquerypipeline_intersectionsWithRay(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number): void;
+export function rawquerypipeline_intersectionWithShape(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number): void;
+export function rawquerypipeline_projectPoint(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number): number;
+export function rawquerypipeline_projectPointAndGetFeature(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number): number;
+export function rawquerypipeline_intersectionsWithPoint(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number): void;
+export function rawquerypipeline_castShape(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number): number;
+export function rawquerypipeline_intersectionsWithShape(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number): void;
 export function rawquerypipeline_collidersWithAabbIntersectingAabb(a: number, b: number, c: number, d: number): void;
@@ -353,6 +427,24 @@ export function __wbg_rawdeserializedworld_free(a: number): void;
 export function __wbg_rawvector_free(a: number): void;
+export function __wbg_rawsdpmatrix3_free(a: number): void;
+export function rawvector_set_x(a: number, b: number): void;
+export function rawvector_set_z(a: number, b: number): void;
+export function rawpointprojection_isInside(a: number): number;
+export function rawpointcolliderprojection_isInside(a: number): number;
+export function rawcolliderset_isHandleValid(a: number, b: number): number;
+export function rawshapecontact_point1(a: number): number;
+export function rawshapecontact_point2(a: number): number;
+export function rawshapecontact_normal2(a: number): number;
+export function rawpointprojection_point(a: number): number;
+export function rawpointcolliderprojection_point(a: number): number;
+export function rawrayintersection_normal(a: number): number;
+export function rawshapecollidertoi_witness1(a: number): number;
+export function rawshapecontact_normal1(a: number): number;
+export function rawshapecollidertoi_normal1(a: number): number;
+export function rawshapetoi_witness2(a: number): number;
 export function rawserializationpipeline_new(): number;
-export function rawraycolliderintersection_featureType(a: number): number;
+export function rawintegrationparameters_erp(a: number): number;
 export function rawrayintersection_toi(a: number): number;
+export function rawraycollidertoi_toi(a: number): number;
 export function rawshapetoi_toi(a: number): number;
+export function rawshapecollidertoi_toi(a: number): number;
 export function rawrotation_x(a: number): number;
@@ -363,15 +455,7 @@ export function rawrotation_z(a: number): number;
 export function rawvector_z(a: number): number;
-export function rawcolliderset_isHandleValid(a: number, b: number): number;
-export function rawvector_set_x(a: number, b: number): void;
-export function rawvector_set_z(a: number, b: number): void;
-export function __wbg_rawserializationpipeline_free(a: number): void;
-export function rawshapecontact_point1(a: number): number;
-export function rawshapetoi_witness1(a: number): number;
-export function rawraycollidertoi_toi(a: number): number;
-export function rawshapecollidertoi_toi(a: number): number;
-export function rawshapecollidertoi_witness1(a: number): number;
-export function rawraycolliderintersection_featureId(a: number, b: number): void;
 export function rawraycolliderintersection_colliderHandle(a: number): number;
 export function rawraycollidertoi_colliderHandle(a: number): number;
 export function rawshapecollidertoi_colliderHandle(a: number): number;
+export function rawcontactforceevent_collider1(a: number): number;
+export function __wbg_rawserializationpipeline_free(a: number): void;
 export function __wbindgen_add_to_stack_pointer(a: number): number;
@@ -378,0 +462,0 @@ export function __wbindgen_free(a: number, b: number): void;

No alert changes

Improved metrics

Total package byte prevSize

7160909

increased by8.33%

Number of package files

50

increased by2.04%

Lines of code

28142

increased by13.09%

No dependency changes