@perplexdotgg/bounce 1.7.0 → 1.8.0

package/build/bounce.d.ts

@@ -274,65 +274,155 @@ scale: number;
 
 declare class Body_2 extends Body_base {
     world: World | null;
+    /** The current shape of the body. */
     get shape(): Shape | null;
     set shape(newShape: Shape);
-    setShape(newShape: Shape | null, updateBroadphase?: boolean): void;
+    /** Mainly for internal use. Sets the shape of the body. Typically you should use body.shape = newShape; */
+    setShape(newShape: Shape | null, shouldUpdateBody?: boolean): void;
     /**
-     * integrates the linear velocity of a body
+     * Mainly for internal use. Integrates the linear velocity of a body
      */
     applyLinearVelocityIntegration(timeStepSizeSeconds: number): void;
     applyAngularVelocityIntegration(timeStepSizeSeconds: number): void;
     /**
-     * applies gravity to a body
+     * Mainly for internal use. Applies gravity to a body
      */
     applyAccelerationIntegration(timeStepSizeSeconds: number, gravity: Vec3, isGravityEnabled: boolean, linearDamping: number, angularDamping: number, maxLinearSpeed: number, maxLinearSpeedSquared: number, maxAngularSpeed: number, maxAngularSpeedSquared: number): void;
+    /**
+     * Mainly for internal use. Subtracts a rotation delta from the body's orientation.
+     */
     subRotationDelta(rotationDelta: Vec3): void;
     addRotationDelta(rotationDelta: Vec3): void;
+    /** Mainly for internal use. Applies a rotation impulse to the body. */
     addRotationPositionImpulse(impulse: Vec3, inverseEffectiveMass: Mat3): void;
+    /** Mainly for internal use. Subtracts a rotation impulse from the body's orientation. */
     subRotationPositionImpulse(impulse: Vec3, inverseEffectiveMass: Mat3): void;
+    /** Computes the velocity of a point on the body, mainly for internal use but can be useful for spawning debris with the right velocity as well. */
     computePointVelocity(out: Vec3, point: Vec3): void;
+    /** Mainly for internal use. Computes the effective inverse inertia vector of the body. */
     computeEffectiveInverseInertiaVector(out: Vec3, rotation: Quat, axis: Vec3): void;
+    /** Mainly for internal use. Computes the inverse inertia tensor of the body. */
     computeInverseInertiaTensor(out: Mat3): void;
+    /** Mainly for internal use. Computes the velocity of a point relative to the center of mass. */
     computeVelocityOfPointRelativeToCenterOfMass(out: Vec3, point: Vec3): void;
+    /** Mainly for internal use. Computes the inverse effective mass of the body in a given direction. */
     computeInverseEffectiveMass(direction: Vec3): number;
+    /** Mainly for internal use. Damps the linear velocity of the body. */
     dampLinearVelocity(timeStepSizeSeconds: number, linearDamping: number): void;
+    /** Mainly for internal use. Damps the angular velocity of the body. */
     dampAngularVelocity(timeStepSizeSeconds: number, angularDamping: number): void;
+    /** Mainly for internal use. Clamps the linear velocity of the body. */
     clampLinearVelocity(maxSpeed: number, maxSpeedSquared: number): void;
+    /** Mainly for internal use. Clamps the angular velocity of the body. */
     clampAngularVelocity(maxSpeed: number, maxSpeedSquared: number): void;
-    /**
-     * direction is in world space
-     */
+    /** Mainly for internal use. Computes the supporting face of the body in a given direction. */
     computeSupportingFace(out: Face, subShapeId: number, direction: Vec3, baseOffset: Vec3): void;
+    /** Mainly for internal use. Computes the world space surface normal of the body at a given position. */
     computeWorldSpaceSurfaceNormal(outWorldSpaceNormal: Vec3, inWorldSpacePosition: Vec3, subShapeId?: number): void;
+    /** Mainly for internal use. Checks if the body has changed since the last commit. */
     hasChanged(): boolean;
+    /** Commits the changes of the body, you should call this after changing the position, orientation or mass properties */
     commitChanges(): void;
+    /** Applies a linear force to the body. */
     applyLinearForce(force: Vec3): void;
+    /** Applies an angular force to the body. */
     applyAngularForce(force: Vec3): void;
+    /** Applies a force to the body at a given point. useLocalFrame determines if the point is in local or world space (defaults to world space). */
     applyForce(force: Vec3, point: Vec3, useLocalFrame?: boolean): void;
+    /** Applies a linear impulse to the body. */
     applyLinearImpulse(impulse: Vec3): void;
+    /** Applies an angular impulse to the body. */
     applyAngularImpulse(impulse: Vec3): void;
+    /** Applies an impulse to the body at a given point. useLocalFrame determines if the point is in local or world space (defaults to world space). */
     applyImpulse(impulse: Vec3, point: Vec3, useLocalFrame?: boolean): void;
+    /** Clears the linear forces applied to the body. */
     clearLinearForces(): void;
+    /** Clears the angular forces applied to the body. */
     clearAngularForces(): void;
+    /** Clears both linear and angular forces applied to the body. */
     clearForces(): void;
+    /** Mainly for internal use.Checks if the body is ready to sleep based on the sleep time threshold. */
     isReadyToSleep(sleepTimeThreshold: number): boolean;
     sleep(): void;
     wakeUp(): void;
     markBodyAsDirty(): void;
+    updateCenterOfMassPosition(): void;
+    updateWorldBounds(): void;
 }
 export { Body_2 as Body }
 
 declare const Body_base: Monomorph<Body_2, ConvertedInputPropertyDefinitionMap<{
+/** BodyType.static, BodyType.kinematic or BodyType.dynamic */
 type: PropertyDefinition_2<BodyType, true>;
+/** Position of the body's center in world space
+* @default { x: 0, y: 0, z: 0 }
+*/
 position: typeof Vec3;
+/** Orientation of the body in world space. Accepts both quat and eul angle (treated as XYZ order) as input when using .create(), .set() and .reset().
+* @default { x: 0, y: 0, z: 0, w: 1 }
+*/
 orientation: typeof Quat;
+/** Linear velocity of the body
+* @default { x: 0, y: 0, z: 0 }
+*/
 linearVelocity: typeof Vec3;
+/** Angular velocity of the body
+* @default { x: 0, y: 0, z: 0 }
+*/
 angularVelocity: typeof Vec3;
+/** Coefficient of friction of the body, typically between 0 and 1.
+* @default the friction value set in the world options (which itself defaults to 0.5)
+*/
+friction: number;
+/** Whether to use the minimum, maximum or average (default) value for friction between the two bodies involved in a collision
+* @default CoefficientFunctionType.average
+*/
+frictionFunction: PropertyDefinition_2<CoefficientFunctionType, true>;
+/** Coefficient of restitution of the body, typically between 0 and 1. 0 means no bounciness or elasticity. 1 means full bouncy or elastic.
+* @default the restitution value set in the world options (which itself defaults to 0.5)
+*/
+restitution: number;
+/** Whether to use the minimum, maximum or average (default) value for restitution between the two bodies involved in a collision
+* @default CoefficientFunctionType.average
+*/
+restitutionFunction: PropertyDefinition_2<CoefficientFunctionType, true>;
+/** Whether the body is currently sleeping (this is automatically managed) */
+isSleeping: PropertyDefinitionBoolean<true>;
+/** Scale factor for gravity applied to the body. Set to 0 to disable gravity on this body. */
+gravityScale: number;
+/** Density of the body in kilograms per cubic meter. If unspecified, density will be derived from the body's mass and its shape's volume */
+density: number;
+/** Mass of the body in kilograms. Mass is automatically derived from the body's density and its shape's volume, unless the density is set to 0, in which case, the density is derived from the mass. */
+mass: number;
+/** Collision groups the body belongs to
+* @default AllFlag, which means the body belongs to all groups
+*/
+belongsToGroups: PropertyDefinitionNumber<true>;
+/** Collision groups the body can collide with
+* @default AllFlag, which means the body can collide with all groups
+*/
+collidesWithGroups: PropertyDefinitionNumber<true>;
+/** Whether the body is allowed to sleep
+* @default true
+*/
+isSleepingEnabled: PropertyDefinitionBoolean<true>;
+/** Linear damping applied to the body. Set to a negative value to use the world's default linear damping
+* @default -1, which means to use the world's default linear damping
+*/
+linearDamping: number;
+/** Angular damping applied to the body. Set to a negative value to use the world's default angular damping.
+* @default -1, which means to use the world's default angular damping
+*/
+angularDamping: number;
+/** Mainly for internal use. Time the body has been without moving, automatically maintained and used for sleep detection */
+timeWithoutMoving: PropertyDefinitionNumber<true>;
+/** Mainly for internal use. Computed center of mass position in world space. This is automatically updated when the body's shape, position or orientation changes (after commitChanged is called) */
 computedCenterOfMassPosition: PropertyDefinition_2<NoInfer<number[] | {
 x?: number;
 y?: number;
 z?: number;
 } | undefined>, true, typeof Vec3>;
+/** Mainly for internal use. Computed axis-aligned bounding box of the body in world space. This is automatically updated when the body's shape, position or orientation changes (after commitChanged is called) */
 computedBounds: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<{
 min: typeof Vec3;
 max: typeof Vec3;
@@ -342,6 +432,7 @@ y?: number;
 z?: number;
 } | undefined>, true, typeof Vec3>;
 }>> | undefined>, true, typeof Aabb>;
+/** Mainly for internal use. Computed expanded axis-aligned bounding box of the body in world space. This is automatically updated when the body's shape, position or orientation changes (after commitChanged is called) */
 computedExpandedBounds: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<{
 min: typeof Vec3;
 max: typeof Vec3;
@@ -351,21 +442,31 @@ y?: number;
 z?: number;
 } | undefined>, true, typeof Vec3>;
 }>> | undefined>, true, typeof Aabb>;
-previousPosition: PropertyDefinition_2<NoInfer<number[] | {
-x?: number;
-y?: number;
-z?: number;
-} | undefined>, true, typeof Vec3>;
-previousOrientation: PropertyDefinition_2<NoInfer<QuatInput>, true, typeof Quat>;
-isSleeping: PropertyDefinitionBoolean<true>;
-timeWithoutMoving: PropertyDefinitionNumber<true>;
-friction: number;
-restitution: number;
-frictionFunction: PropertyDefinition_2<CoefficientFunctionType, true>;
-restitutionFunction: PropertyDefinition_2<CoefficientFunctionType, true>;
-mass: number;
-density: number;
+/** Mainly for internal use. */
+/** Mainly for internal use. */
+/** Mainly for internal use. This is the type of the current shape, e.g. sphere, box, etc */
+shapeType: PropertyDefinition_2<ShapeType, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape0: PropertyDefinitionReference<Box | null, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape1: PropertyDefinitionReference<Capsule | null, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape2: PropertyDefinitionReference<CompoundShape | null, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape3: PropertyDefinitionReference<ConvexHull | null, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape4: PropertyDefinitionReference<Cylinder | null, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape5: PropertyDefinitionReference<HeightMap | null, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape6: PropertyDefinitionReference<Sphere | null, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape7: PropertyDefinitionReference<TriangleMesh | null, true>;
+/** Mainly for internal use. Used for tracking sleep islands */
+sleepVisitGeneration: PropertyDefinitionNumber<true>;
+/** Mainly for internal use. Inverse mass of the body in kilograms. This is automatically derived from the body's mass. */
 inverseMass: PropertyDefinitionNumber<true>;
+/** Mainly for internal use. Computed local inverse inertia tensor of the body. This is automatically updated when the body's shape changes (after commitChanged is called) */
 computedLocalInverseInertia: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<{
 e0: number;
 e1: number;
@@ -377,6 +478,7 @@ e6: number;
 e7: number;
 e8: number;
 }>> | undefined>, true, typeof Mat3>;
+/** Mainly for internal use. Computed world inverse inertia tensor of the body. This is automatically updated when the body's shape, position or orientation changes (after commitChanged is called) */
 computedWorldInverseInertia: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<{
 e0: number;
 e1: number;
@@ -388,48 +490,96 @@ e6: number;
 e7: number;
 e8: number;
 }>> | undefined>, true, typeof Mat3>;
-colliderType: PropertyDefinition_2<ColliderType, true>;
-gravityScale: number;
+/** Mainly for internal use. Accumulated linear forces applied to the body. Typically you would use applyForce or applyImpulse instead of directly modifying this property. */
 linearForces: PropertyDefinition_2<NoInfer<number[] | {
 x?: number;
 y?: number;
 z?: number;
 } | undefined>, true, typeof Vec3>;
+/** Mainly for internal use. Accumulated angular forces applied to the body.Typically you would use applyForce or applyImpulse instead of directly modifying this property. */
 angularForces: PropertyDefinition_2<NoInfer<number[] | {
 x?: number;
 y?: number;
 z?: number;
 } | undefined>, true, typeof Vec3>;
+/** Mainly for internal use. Copy of the body used to check what has changed when commiting changes. */
 copyForDiff: PropertyDefinitionReference<NoInfer<Body_2> | null, true>;
+/** Mainly for internal use. A linked list of contact pair references for the body, to allow us to quickly destroy them when the body is destroyed. */
 firstPotentialPairEdge: PropertyDefinitionReference<NoInfer<BodyPairEdge> | null, true>;
-belongsToGroups: PropertyDefinitionNumber<true>;
-collidesWithGroups: PropertyDefinitionNumber<true>;
-node: PropertyDefinitionReference<NoInfer<BvhNode> | null, true>;
-shapeType: PropertyDefinition_2<ShapeType, true>;
-shape0: PropertyDefinitionReference<Box | null, true>;
-shape1: PropertyDefinitionReference<Capsule | null, true>;
-shape2: PropertyDefinitionReference<CompoundShape | null, true>;
-shape3: PropertyDefinitionReference<ConvexHull | null, true>;
-shape4: PropertyDefinitionReference<Cylinder | null, true>;
-shape5: PropertyDefinitionReference<HeightMap | null, true>;
-shape6: PropertyDefinitionReference<Sphere | null, true>;
-shape7: PropertyDefinitionReference<TriangleMesh | null, true>;
-isSleepingEnabled: PropertyDefinitionBoolean<true>;
-linearDamping: number;
-angularDamping: number;
+/** Mainly for internal use. A linked list of constraint pair references for the body, to allow us to quickly destroy them when the body is destroyed. */
 firstPotentialConstraintPairEdge: PropertyDefinitionReference<NoInfer<ConstraintPairEdge> | null, true>;
-visitGeneration: PropertyDefinitionNumber<true>;
 }>, PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<{
+/** BodyType.static, BodyType.kinematic or BodyType.dynamic */
 type: PropertyDefinition_2<BodyType, true>;
+/** Position of the body's center in world space
+* @default { x: 0, y: 0, z: 0 }
+*/
 position: typeof Vec3;
+/** Orientation of the body in world space. Accepts both quat and eul angle (treated as XYZ order) as input when using .create(), .set() and .reset().
+* @default { x: 0, y: 0, z: 0, w: 1 }
+*/
 orientation: typeof Quat;
+/** Linear velocity of the body
+* @default { x: 0, y: 0, z: 0 }
+*/
 linearVelocity: typeof Vec3;
+/** Angular velocity of the body
+* @default { x: 0, y: 0, z: 0 }
+*/
 angularVelocity: typeof Vec3;
+/** Coefficient of friction of the body, typically between 0 and 1.
+* @default the friction value set in the world options (which itself defaults to 0.5)
+*/
+friction: number;
+/** Whether to use the minimum, maximum or average (default) value for friction between the two bodies involved in a collision
+* @default CoefficientFunctionType.average
+*/
+frictionFunction: PropertyDefinition_2<CoefficientFunctionType, true>;
+/** Coefficient of restitution of the body, typically between 0 and 1. 0 means no bounciness or elasticity. 1 means full bouncy or elastic.
+* @default the restitution value set in the world options (which itself defaults to 0.5)
+*/
+restitution: number;
+/** Whether to use the minimum, maximum or average (default) value for restitution between the two bodies involved in a collision
+* @default CoefficientFunctionType.average
+*/
+restitutionFunction: PropertyDefinition_2<CoefficientFunctionType, true>;
+/** Whether the body is currently sleeping (this is automatically managed) */
+isSleeping: PropertyDefinitionBoolean<true>;
+/** Scale factor for gravity applied to the body. Set to 0 to disable gravity on this body. */
+gravityScale: number;
+/** Density of the body in kilograms per cubic meter. If unspecified, density will be derived from the body's mass and its shape's volume */
+density: number;
+/** Mass of the body in kilograms. Mass is automatically derived from the body's density and its shape's volume, unless the density is set to 0, in which case, the density is derived from the mass. */
+mass: number;
+/** Collision groups the body belongs to
+* @default AllFlag, which means the body belongs to all groups
+*/
+belongsToGroups: PropertyDefinitionNumber<true>;
+/** Collision groups the body can collide with
+* @default AllFlag, which means the body can collide with all groups
+*/
+collidesWithGroups: PropertyDefinitionNumber<true>;
+/** Whether the body is allowed to sleep
+* @default true
+*/
+isSleepingEnabled: PropertyDefinitionBoolean<true>;
+/** Linear damping applied to the body. Set to a negative value to use the world's default linear damping
+* @default -1, which means to use the world's default linear damping
+*/
+linearDamping: number;
+/** Angular damping applied to the body. Set to a negative value to use the world's default angular damping.
+* @default -1, which means to use the world's default angular damping
+*/
+angularDamping: number;
+/** Mainly for internal use. Time the body has been without moving, automatically maintained and used for sleep detection */
+timeWithoutMoving: PropertyDefinitionNumber<true>;
+/** Mainly for internal use. Computed center of mass position in world space. This is automatically updated when the body's shape, position or orientation changes (after commitChanged is called) */
 computedCenterOfMassPosition: PropertyDefinition_2<NoInfer<number[] | {
 x?: number;
 y?: number;
 z?: number;
 } | undefined>, true, typeof Vec3>;
+/** Mainly for internal use. Computed axis-aligned bounding box of the body in world space. This is automatically updated when the body's shape, position or orientation changes (after commitChanged is called) */
 computedBounds: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<{
 min: typeof Vec3;
 max: typeof Vec3;
@@ -439,6 +589,7 @@ y?: number;
 z?: number;
 } | undefined>, true, typeof Vec3>;
 }>> | undefined>, true, typeof Aabb>;
+/** Mainly for internal use. Computed expanded axis-aligned bounding box of the body in world space. This is automatically updated when the body's shape, position or orientation changes (after commitChanged is called) */
 computedExpandedBounds: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<{
 min: typeof Vec3;
 max: typeof Vec3;
@@ -448,21 +599,31 @@ y?: number;
 z?: number;
 } | undefined>, true, typeof Vec3>;
 }>> | undefined>, true, typeof Aabb>;
-previousPosition: PropertyDefinition_2<NoInfer<number[] | {
-x?: number;
-y?: number;
-z?: number;
-} | undefined>, true, typeof Vec3>;
-previousOrientation: PropertyDefinition_2<NoInfer<QuatInput>, true, typeof Quat>;
-isSleeping: PropertyDefinitionBoolean<true>;
-timeWithoutMoving: PropertyDefinitionNumber<true>;
-friction: number;
-restitution: number;
-frictionFunction: PropertyDefinition_2<CoefficientFunctionType, true>;
-restitutionFunction: PropertyDefinition_2<CoefficientFunctionType, true>;
-mass: number;
-density: number;
+/** Mainly for internal use. */
+/** Mainly for internal use. */
+/** Mainly for internal use. This is the type of the current shape, e.g. sphere, box, etc */
+shapeType: PropertyDefinition_2<ShapeType, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape0: PropertyDefinitionReference<Box | null, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape1: PropertyDefinitionReference<Capsule | null, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape2: PropertyDefinitionReference<CompoundShape | null, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape3: PropertyDefinitionReference<ConvexHull | null, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape4: PropertyDefinitionReference<Cylinder | null, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape5: PropertyDefinitionReference<HeightMap | null, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape6: PropertyDefinitionReference<Sphere | null, true>;
+/** Mainly for internal use. References to the specific shape instances based on the shape type */
+shape7: PropertyDefinitionReference<TriangleMesh | null, true>;
+/** Mainly for internal use. Used for tracking sleep islands */
+sleepVisitGeneration: PropertyDefinitionNumber<true>;
+/** Mainly for internal use. Inverse mass of the body in kilograms. This is automatically derived from the body's mass. */
 inverseMass: PropertyDefinitionNumber<true>;
+/** Mainly for internal use. Computed local inverse inertia tensor of the body. This is automatically updated when the body's shape changes (after commitChanged is called) */
 computedLocalInverseInertia: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<{
 e0: number;
 e1: number;
@@ -474,6 +635,7 @@ e6: number;
 e7: number;
 e8: number;
 }>> | undefined>, true, typeof Mat3>;
+/** Mainly for internal use. Computed world inverse inertia tensor of the body. This is automatically updated when the body's shape, position or orientation changes (after commitChanged is called) */
 computedWorldInverseInertia: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<{
 e0: number;
 e1: number;
@@ -485,37 +647,24 @@ e6: number;
 e7: number;
 e8: number;
 }>> | undefined>, true, typeof Mat3>;
-colliderType: PropertyDefinition_2<ColliderType, true>;
-gravityScale: number;
+/** Mainly for internal use. Accumulated linear forces applied to the body. Typically you would use applyForce or applyImpulse instead of directly modifying this property. */
 linearForces: PropertyDefinition_2<NoInfer<number[] | {
 x?: number;
 y?: number;
 z?: number;
 } | undefined>, true, typeof Vec3>;
+/** Mainly for internal use. Accumulated angular forces applied to the body.Typically you would use applyForce or applyImpulse instead of directly modifying this property. */
 angularForces: PropertyDefinition_2<NoInfer<number[] | {
 x?: number;
 y?: number;
 z?: number;
 } | undefined>, true, typeof Vec3>;
+/** Mainly for internal use. Copy of the body used to check what has changed when commiting changes. */
 copyForDiff: PropertyDefinitionReference<NoInfer<Body_2> | null, true>;
+/** Mainly for internal use. A linked list of contact pair references for the body, to allow us to quickly destroy them when the body is destroyed. */
 firstPotentialPairEdge: PropertyDefinitionReference<NoInfer<BodyPairEdge> | null, true>;
-belongsToGroups: PropertyDefinitionNumber<true>;
-collidesWithGroups: PropertyDefinitionNumber<true>;
-node: PropertyDefinitionReference<NoInfer<BvhNode> | null, true>;
-shapeType: PropertyDefinition_2<ShapeType, true>;
-shape0: PropertyDefinitionReference<Box | null, true>;
-shape1: PropertyDefinitionReference<Capsule | null, true>;
-shape2: PropertyDefinitionReference<CompoundShape | null, true>;
-shape3: PropertyDefinitionReference<ConvexHull | null, true>;
-shape4: PropertyDefinitionReference<Cylinder | null, true>;
-shape5: PropertyDefinitionReference<HeightMap | null, true>;
-shape6: PropertyDefinitionReference<Sphere | null, true>;
-shape7: PropertyDefinitionReference<TriangleMesh | null, true>;
-isSleepingEnabled: PropertyDefinitionBoolean<true>;
-linearDamping: number;
-angularDamping: number;
+/** Mainly for internal use. A linked list of constraint pair references for the body, to allow us to quickly destroy them when the body is destroyed. */
 firstPotentialConstraintPairEdge: PropertyDefinitionReference<NoInfer<ConstraintPairEdge> | null, true>;
-visitGeneration: PropertyDefinitionNumber<true>;
 }>> & {
 shape: Shape;
 world?: World | null;
@@ -600,16 +749,6 @@ export declare const enum BodyType {
     static = 2
 }
 
-declare interface BodyVisitor {
-    shouldExit: boolean;
-    visit(body: Body_2): void;
-}
-
-declare interface BodyVisitor_2 {
-    shouldExit: boolean;
-    visit(body: Body_2): void;
-}
-
 export declare class Box extends Box_base implements ConvexShapeInterface {
     type: ShapeType.box;
     world: World | null;
@@ -735,6 +874,7 @@ declare interface BuildTriangleMeshParams {
 declare class BvhModule {
     _intersectTargetBody: Body_2 | null;
     _createPairCallback(bodyB: Body_2): boolean;
+    bvhNodePool: PoolClass<BvhNode>;
     world: World;
     options: BvhModuleOptions;
     dynamicTree: BvhTree;
@@ -742,6 +882,7 @@ declare class BvhModule {
     pairs: BodyPairsModule;
     bodiesThatDidRefit: Set<Body_2>;
     constructor(world: World, options?: Partial<BvhModuleOptions>);
+    removeBody(body: WithPool<Body_2>): void;
     toArray(array: NumberArray, startOffset: number): number;
     fromArray(array: NumberArray, startOffset: number): number;
     markStaticBodyAsDirty(body: WithPool<Body_2>): void;
@@ -754,9 +895,9 @@ declare class BvhModule {
     removeKinematicBody(body: WithPool<Body_2>): void;
     removeStaticBody(body: WithPool<Body_2>): void;
     iteratePairs(): Generator<BodyPairNode, void, unknown>;
-    visitBodiesWithCollision(bodyVisitor: BodyVisitor_2, aabb: Aabb, belongsToGroups: number, collidesWithGroups: number): void;
-    visitBodiesWithCast(bodyVisitor: BodyVisitor_2, aabb: Aabb, displacement: Vec3, belongsToGroups: number, collidesWithGroups: number): void;
-    raycastBodies(bodyVisitor: BodyVisitor_2, ray: Ray, belongsToGroups: number, collidesWithGroups: number): void;
+    visitBodiesWithCollision(visitCallback: VisitBodyCallback, aabb: Aabb, belongsToGroups: number, collidesWithGroups: number): void;
+    visitBodiesWithCast(visitCallback: VisitBodyCallback, aabb: Aabb, displacement: Vec3, belongsToGroups: number, collidesWithGroups: number): void;
+    raycastBodies(visitCallback: VisitBodyCallback, ray: Ray, belongsToGroups: number, collidesWithGroups: number): void;
 }
 
 declare interface BvhModuleOptions {
@@ -803,7 +944,8 @@ objects: PropertyDefinitionReferenceList<Body_2, ReferenceListInputType<typeof B
 
 export declare class BvhTree {
     options: BvhTreeOptions;
-    nodes: typeof BvhNode.ReferenceList;
+    bvhTreeNodes: typeof BvhNode.ReferenceList;
+    bodyToBvhNodeMap: typeof BvhNode.ReferenceList;
     bodyPool: typeof Body_2.Pool;
     root: BvhNode | null;
     optimizeQueue: BvhNode[];
@@ -817,6 +959,8 @@ export declare class BvhTree {
     rebalance(node: BvhNode): BvhNode;
     refit(node: BvhNode | null): boolean;
     optimizeOncePerFrame(maxNodesToCheck: number): void;
+    getBodyNode(body: Body_2): WithPool<BvhNode> | null;
+    setBodyNode(body: Body_2 | WithPool<Body_2>, node: BvhNode | WithPool<BvhNode> | null): void;
     splitObjects(outLeft: BvhNode, outRight: BvhNode, nodeToSplit: BvhNode): void;
     createBvhNode(): MonomorphInstanceWithPool<ConvertedInputPropertyDefinitionMap<    {
     parent: PropertyDefinitionReference<NoInfer<BvhNode> | null, true>;
@@ -850,16 +994,16 @@ export declare class BvhTree {
     objects: PropertyDefinitionReferenceList<Body_2, ReferenceListInputType<typeof Body_2>>;
     }>> | undefined, BvhNode>;
     destroyBvhNode(node: WithPool<BvhNode>): void;
-    insert(object: WithPool<Body_2>): boolean;
-    remove(object: WithPool<Body_2>, shouldRemoveFromDirtyObjects?: boolean): boolean | undefined;
+    insert(bodyToInsert: WithPool<Body_2>): boolean;
+    remove(bodyToRemove: WithPool<Body_2>, shouldRemoveFromDirtyObjects?: boolean): boolean | undefined;
     update(object: WithPool<Body_2>, shouldUpdateDirtyObjects?: boolean): boolean;
     intersectBody(onHit: (Body: Body_2) => boolean | undefined, bodyToIntersect: Body_2, shouldUpdateDirtyObjects?: boolean): void;
     intersectAabb(onHit: (Body: Body_2) => boolean, bounds: Aabb, shouldUpdateDirtyObjects?: boolean): void;
     walk(onNode: (node: BvhNode) => boolean): void;
     isEmpty(): boolean;
-    visitBodiesWithCollision(bodyVisitor: BodyVisitor, bounds: Aabb, belongsToGroups: number, collidesWithGroups: number, shouldUpdateDirtyObjects?: boolean): void;
-    raycastBodies(bodyVisitor: BodyVisitor, ray: Ray, belongsToGroups: number, collidesWithGroups: number, shouldUpdateDirtyObjects?: boolean): void;
-    visitBodiesWithCast(bodyVisitor: BodyVisitor, bounds: Aabb, displacement: Vec3, belongsToGroups: number, collidesWithGroups: number, shouldUpdateDirtyObjects?: boolean): void;
+    visitBodiesWithCollision(visitCallback: VisitBodyCallback, bounds: Aabb, belongsToGroups: number, collidesWithGroups: number, shouldUpdateDirtyObjects?: boolean): void;
+    raycastBodies(visitCallback: VisitBodyCallback, ray: Ray, belongsToGroups: number, collidesWithGroups: number, shouldUpdateDirtyObjects?: boolean): void;
+    visitBodiesWithCast(visitCallback: VisitBodyCallback, bounds: Aabb, displacement: Vec3, belongsToGroups: number, collidesWithGroups: number, shouldUpdateDirtyObjects?: boolean): void;
 }
 
 export declare type BvhTreeOptions = {
@@ -972,7 +1116,6 @@ radius: number;
 
 export declare class CastCollector {
     static initialEarlyOutFraction: number;
-    static shouldEarlyOutFraction: number;
     earlyOutFraction: number;
     body2: Body_2 | null;
     getEarlyOutFraction(): number;
@@ -983,11 +1126,6 @@ export declare class CastCollector {
     addMiss(): void;
 }
 
-export declare interface CastRayResult {
-    body: Body_2;
-    fraction: number;
-}
-
 export declare class CastResult extends CastResult_base {
     /**
      * swaps the A and B data
@@ -1102,7 +1240,8 @@ declare class CollideBodiesModule {
     collideBodies(bodyA: Body_2, bodyB: Body_2, collideShapesSettings: CollisionSettings, collideBodiesSettings: CollideBodiesSettings, timeStepSizeSeconds: number, isWarmStartingEnabled: boolean, minVelocityForElasticContact: number): void;
     collideShape(inShape: Shape, inShapeScale: number, inCenterOfMassTransform: Isometry, ioCollector: CollisionCollector, inCollideShapeSettings: CollisionSettings, inbaseTranslation?: Vec3, mask?: number): void;
     castShape(inShape: Shape, inShapeScale: number, inCenterOfMassTransform: Isometry, inDisplacement: Vec3, inShapeCastSettings: CastSettings, inbaseTranslation: Vec3, ioCollector: CastCollector, mask?: number): void;
-    castRay(onHit: (result: CastRayResult) => boolean | undefined, ray: Ray, settings: RayCastSettings, belongsToGroups?: number, collidesWithGroups?: number): void;
+    castRayApproximate(onHit: (body: Body_2) => boolean | undefined, ray: Ray, belongsToGroups?: number, collidesWithGroups?: number): void;
+    castRay(onHit: (result: CastResult) => boolean | undefined, ray: Ray, returnClosestOnly?: boolean, belongsToGroups?: number, collidesWithGroups?: number): void;
     estimateCollisionResponse(result: EstimateCollisionResponseResult, bodyA: Body_2, bodyB: Body_2, timeStepSizeSeconds: number): void;
 }
 
@@ -1111,10 +1250,7 @@ declare interface CollideBodiesSettings {
 }
 
 export declare const enum ColliderType {
-    hasIntersectionOnly = 0,
-    findContactManifoldOnly = 1,
-    resolveContact = 2,
-    attractor = 3
+    resolveContact = 0
 }
 
 export declare class CollideShapesModule {
@@ -1125,7 +1261,6 @@ export declare class CollideShapesModule {
 
 export declare class CollisionCollector {
     static initialEarlyOutFraction: number;
-    static shouldEarlyOutFraction: number;
     earlyOutFraction: number;
     body2: Body_2 | null;
     getEarlyOutFraction(): number;
@@ -1183,6 +1318,9 @@ faceB: typeof Face;
 }>> | undefined>;
 
 export declare interface CollisionSettings {
+    /** maximum separation in meters between shapes that will generate collision information. increasing this can improve performance of fast-moving objects at the cost of accuracy and can cause jitter when resting on surfaces. decreasing it can improve accuracy and reduce jitter but may cause fast-moving objects to tunnel through thin geometry or miss collisions, especially if the `speculativeContactDistance` is also small.
+     * @default 0.02
+     */
     maxSeparation: number;
     collisionTolerance: number;
     activeEdgeMode: ActiveEdgeMode;
@@ -3400,11 +3538,6 @@ direction: typeof Vec3;
 length: number;
 }>> | undefined>;
 
-declare interface RayCastSettings {
-    precision?: QueryPrecision;
-    returnClosestOnly?: boolean;
-}
-
 export declare const enum ReferenceFrame {
     local = 0,
     world = 1
@@ -4231,6 +4364,8 @@ declare type Vec3Input = {
     z?: number;
 } | number[] | undefined;
 
+declare type VisitBodyCallback = (body: Body_2) => boolean | undefined | void;
+
 /**
  * a container and API for a physics simulation
  */
@@ -4248,9 +4383,6 @@ export declare class World {
     convexHullBuilder: ConvexHullBuilder;
     triangleMeshBuilder: TriangleMeshBuilder;
     constraintSolver: ConstraintSolver;
-    dynamicBodyCopies: typeof Body_2.ReferenceList;
-    kinematicBodyCopies: typeof Body_2.ReferenceList;
-    staticBodyCopies: typeof Body_2.ReferenceList;
     dynamicBodies: typeof Body_2.ReferenceList;
     kinematicBodies: typeof Body_2.ReferenceList;
     staticBodies: typeof Body_2.ReferenceList;
@@ -4282,7 +4414,6 @@ export declare class World {
         triangleMeshCopy: typeof TriangleMesh.Pool;
         compoundShapeCopy: typeof CompoundShape.Pool;
         heightMapCopy: typeof HeightMap.Pool;
-        bvhNodes: typeof BvhNode.Pool;
         constraintPairNode: typeof ConstraintPairNode.Pool;
         constraintPairEdge: typeof ConstraintPairEdge.Pool;
         body: typeof Body_2.Pool;
@@ -4299,7 +4430,6 @@ export declare class World {
     constructor(options?: PartialRecursive<WorldOptions>);
     collideBodiesWithBroadphase(timeStepSizeSeconds: number, isWarmStartingEnabled: boolean, minVelocityForElasticContact: number): void;
     iterateOverBodyPairsBruteForce(): Generator<NoInfer<[WithPool<Body_2>, WithPool<Body_2>]>, void, unknown>;
-    collideBodiesWithoutBroadphase(timeStepSizeSeconds: number, isWarmStartingEnabled: boolean, minVelocityForElasticContact: number): void;
     /**
      * integrates the acceleration of all bodies
      */
@@ -4360,7 +4490,8 @@ export declare class World {
     didBodiesCollide(bodyA: Body_2, bodyB: Body_2): boolean;
     iterateContactManifolds(bodyA?: Body_2, bodyB?: Body_2): Generator<ContactManifold, void, unknown>;
     intersectShape(onHit: (result: CollisionResult) => boolean | undefined, shape: Shape, transform: BasicTransform | InputType<BasicTransform>, settings?: ShapeIntersectSettings): void;
-    castRay(onHit: (result: CastRayResult) => boolean | undefined, ray: Ray, settings?: RayCastSettings): void;
+    castRayApproximate(onHit: (body: Body_2) => boolean | undefined, ray: Ray, belongsToGroups?: number, collidesWithGroups?: number): void;
+    castRay(onHit: (result: CastResult) => boolean | undefined, ray: Ray, returnClosestOnly?: boolean, belongsToGroups?: number, collidesWithGroups?: number): void;
     castShape(onHit: (result: CastShapeResult) => boolean, shape: Shape, transform: BasicTransform, displacementOrEndPosition: Vec3, settings?: ShapeCastSettings): void;
     estimateCollisionResponse(result: EstimateCollisionResponseResult, bodyA: Body_2, bodyB: Body_2, settings?: Partial<EstimateCollisionResponseSettings>): void;
     toArray(array: number[] | Float32Array | Float64Array, startOffset?: number): number;
@@ -4373,31 +4504,95 @@ export declare class World {
 }
 
 declare interface WorldOptions {
+    /** gravity in m/s^2
+     * @default earth gravity ([0, -9.80665, 0])
+     */
     gravity: InputType<Vec3>;
-    broadphaseOptions: PartialRecursive<BvhModuleOptions>;
+    /** enables/disables gravity on the whole world
+     * @default true
+     */
     isGravityEnabled: boolean;
+    /** default restitution (how elastic/bouncy collisions will be) for created/reset bodies, if unspecified on the body.
+     * @default 0.2
+     */
     restitution: number;
+    /** default friction for created/reset bodies, if unspecified on the body
+     * @default 0.5
+     */
     friction: number;
+    /** the number of iterations to solve velocity constraints. lower is more performant, higher has better results, especially for stacks or conflicting constraints.
+     * @default 6
+     */
     solveVelocityIterations: number;
+    /** the number of iterations to solve position constraints. lower is more performant, higher has better results, especially for stacks or conflicting constraints.
+     * @default 2
+     */
     solvePositionIterations: number;
+    /** default linear damping for created/reset bodies, if unspecified on the body
+     * @default 0.05
+     * @note this is not applied as a constant factor each step, but rather integrated as part of the velocity integration, so it should be stable across different time step sizes
+     */
     linearDamping: number;
+    /** default angular damping for created/reset bodies, if unspecified on the body
+     * @default 0.05
+     * @note this is not applied as a constant factor each step, but rather integrated as part of the velocity integration, so it should be stable across different time step sizes
+     */
     angularDamping: number;
+    /** default friction function for created/reset bodies, if unspecified on the body
+     * @default CoefficientFunctionType.max
+     */
     frictionFunction: CoefficientFunctionType;
+    /** default restitution function for created/reset bodies, if unspecified on the body
+     * @default CoefficientFunctionType.max
+     */
     restitutionFunction: CoefficientFunctionType;
+    /** minimum velocity in m/s for a contact to be treated as elastic instead of inelastic. this is used to prevent jittery resting contacts, while still allowing for elastic collisions at higher speeds. tuning this can help with the stability of stacks and resting contacts. if you are seeing jittery behavior in resting contacts, try increasing this value. if you are seeing objects that should be bouncing not bounce, try decreasing this value.
+     * @default 2
+     */
     minVelocityForElasticContact: number;
+    /** the baumgarte factor to use for position correction. higher values will correct positions faster, but can lead to instability if too high. lower values will be more stable, but can lead to more noticeable sinking and jitter. tuning this can help with the stability of stacks and resting contacts. if you are seeing sinking or noticeable jitter in resting contacts, try increasing this value. if you are seeing instability, try decreasing this value.
+     * @default 0.2
+     */
     baumgarte: number;
+    /** the penetration slop in meters. this is the distance that contact points can penetrate before the solver starts to apply correction. having a small penetration slop can help with the stability of stacks and resting contacts, but can lead to more noticeable jitter. tuning this can help with the stability of stacks and resting contacts. if you are seeing sinking or noticeable jitter in resting contacts, try increasing this value. if you are seeing instability, try decreasing this value.
+     * @default 0.02
+     */
     penetrationSlop: number;
+    /** the maximum penetration distance in meters. this is the maximum distance that the solver will apply correction for penetrations in one solver step.
+     * @default 0.2
+     */
     maxPenetrationDistance: number;
+    /** the speculative contact distance in meters. basically this is the minimum distance two bodies need to be apart before they can be considered to be in contact, to reduce the chance of tunneling, or missed collisions from tiny bounces when at rest.
+     * @default 0.02
+     */
     speculativeContactDistance: number;
-    collisionTolerance: number;
+    /** maximum linear speed in m/s, used to avoid excessively high speeds that can cause instability in the solver and tunneling through collision geometry. applied during acceleration integration and velocity clamping.
+     * @default 30
+     */
     maxLinearSpeed: number;
+    /** maximum angular speed in rad/s, used to avoid excessively high angular speeds that can cause instability in the solver and tunneling through collision geometry. applied during acceleration integration and velocity clamping.
+     * @default 20
+     */
     maxAngularSpeed: number;
+    /** enables warm starting of contact and constraint impulses by reusing cached lambdas between steps. improves stacking stability but can add jitter if contacts change rapidly.
+     * @default true
+     */
     isWarmStartingEnabled: boolean;
+    /** base collision settings for narrowphase shape-vs-shape tests. `maxSeparation` and active-edge movement direction are overwritten per-pair in the collide-bodies pass.
+     * @default { maxSeparation: 0.02, collisionTolerance: 1e-4, activeEdgeMode: ActiveEdgeMode.CollideOnlyWithActive, collectFacesMode: CollectFacesMode.NoFaces, penetrationTolerance: 1e-4, activeEdgeMovementDirectionX: 0, activeEdgeMovementDirectionY: 0, activeEdgeMovementDirectionZ: 0, backFaceMode: BackFaceMode.IgnoreBackFaces }
+     */
     collideShapeSettings: CollisionSettings;
+    /** fixed time step size in seconds used by `takeOneStep`, `advanceTime`, and collision response estimation. Ignored if `takeOneStep` is called with a specific time step size. A smaller time step size can lead to a more stable simulation, but will be more computationally expensive.
+     * @default 1 / 60
+     */
     timeStepSizeSeconds: number;
+    /** maximum real-time delta to simulate in a single `advanceTime` call to prevent spiral-of-death on slow frames.
+     * @default .2
+     */
     maxTimeToSimulateSeconds: number;
     sleepOptions?: PartialRecursive<SleepOptions>;
     contactManifoldOptions?: PartialRecursive<ManifoldCacheOptions>;
+    broadphaseOptions: PartialRecursive<BvhModuleOptions>;
 }
 
 export { }