Struct RigidBodyBuilder 

pub struct RigidBodyBuilder {

    pub position: Isometry<f32>,
    pub linvel: Vector<f32>,
    pub angvel: AngVector<f32>,
    pub gravity_scale: f32,
    pub linear_damping: f32,
    pub angular_damping: f32,
    pub body_type: RigidBodyType,
    pub can_sleep: bool,
    pub sleeping: bool,
    pub ccd_enabled: bool,
    pub soft_ccd_prediction: f32,
    pub dominance_group: i8,
    pub enabled: bool,
    pub user_data: u128,
    pub additional_solver_iterations: usize,
    pub gyroscopic_forces_enabled: bool,
    /* private fields */
}

A builder for creating rigid bodies with custom properties.

This builder lets you configure all properties of a rigid body before adding it to your world. Start with one of the type constructors (dynamic(), fixed(), kinematic_position_based(), or kinematic_velocity_based()), then chain property setters, and finally call build().

Example

let body = RigidBodyBuilder::dynamic()
    .translation(vector![0.0, 5.0, 0.0])  // Start 5 units above ground
    .linvel(vector![1.0, 0.0, 0.0])       // Initial velocity to the right
    .can_sleep(false)                      // Keep always active
    .build();

Fields

position: Isometry<f32>

The initial position of the rigid-body to be built.

linvel: Vector<f32>

The linear velocity of the rigid-body to be built.

angvel: AngVector<f32>

The angular velocity of the rigid-body to be built.

gravity_scale: f32

The scale factor applied to the gravity affecting the rigid-body to be built, 1.0 by default.

linear_damping: f32

Damping factor for gradually slowing down the translational motion of the rigid-body, 0.0 by default.

angular_damping: f32

Damping factor for gradually slowing down the angular motion of the rigid-body, 0.0 by default.

body_type: RigidBodyType

The type of rigid-body being constructed.

can_sleep: bool

Whether the rigid-body to be created can sleep if it reaches a dynamic equilibrium.

sleeping: bool

Whether the rigid-body is to be created asleep.

ccd_enabled: bool

Whether Continuous Collision-Detection is enabled for the rigid-body to be built.

CCD prevents tunneling, but may still allow limited interpenetration of colliders.

soft_ccd_prediction: f32

The maximum prediction distance Soft Continuous Collision-Detection.

When set to 0, soft CCD is disabled. Soft-CCD helps prevent tunneling especially of slow-but-thin to moderately fast objects. The soft CCD prediction distance indicates how far in the object’s path the CCD algorithm is allowed to inspect. Large values can impact performance badly by increasing the work needed from the broad-phase.

It is a generally cheaper variant of regular CCD (that can be enabled with RigidBodyBuilder::ccd_enabled since it relies on predictive constraints instead of shape-cast and substeps.

dominance_group: i8

The dominance group of the rigid-body to be built.

enabled: bool

Will the rigid-body being built be enabled?

user_data: u128

An arbitrary user-defined 128-bit integer associated to the rigid-bodies built by this builder.

additional_solver_iterations: usize

The additional number of solver iterations run for this rigid-body and everything interacting with it.

See RigidBody::set_additional_solver_iterations for additional information.

gyroscopic_forces_enabled: bool

Are gyroscopic forces enabled for this rigid-body?

Implementations

impl RigidBodyBuilder

pub fn new(body_type: RigidBodyType) -> Self

Initialize a new builder for a rigid body which is either fixed, dynamic, or kinematic.

pub fn new_static() -> Self

👎Deprecated: use RigidBodyBuilder::fixed() instead

Initializes the builder of a new fixed rigid body.

pub fn new_kinematic_velocity_based() -> Self

👎Deprecated: use RigidBodyBuilder::kinematic_velocity_based() instead

Initializes the builder of a new velocity-based kinematic rigid body.

pub fn new_kinematic_position_based() -> Self

👎Deprecated: use RigidBodyBuilder::kinematic_position_based() instead

Initializes the builder of a new position-based kinematic rigid body.

pub fn fixed() -> Self

Creates a builder for a fixed (static) rigid body.

Fixed bodies never move and are not affected by any forces. Use them for:

• Walls, floors, and ceilings
• Static terrain and level geometry
• Any object that should never move in your simulation

Fixed bodies have infinite mass and never sleep.

pub fn kinematic_velocity_based() -> Self

Creates a builder for a velocity-based kinematic rigid body.

Kinematic bodies are moved by directly setting their velocity (not by applying forces). They can push dynamic bodies but are not affected by them. Use for:

• Moving platforms and elevators
• Doors and sliding panels
• Any object you want to control directly while still affecting other physics objects

Set velocity with RigidBody::set_linvel and RigidBody::set_angvel.

pub fn kinematic_position_based() -> Self

Creates a builder for a position-based kinematic rigid body.

Similar to velocity-based kinematic, but you control it by setting its next position directly rather than setting velocity. Rapier will automatically compute the velocity needed to reach that position. Use for objects animated by external systems.

pub fn dynamic() -> Self

Creates a builder for a dynamic rigid body.

Dynamic bodies are fully simulated - they respond to gravity, forces, collisions, and constraints. This is the most common type for interactive objects. Use for:

• Physics objects that should fall and bounce (boxes, spheres, ragdolls)
• Projectiles and debris
• Vehicles and moving characters (when not using kinematic control)
• Any object that should behave realistically under physics

Dynamic bodies can sleep (become inactive) when at rest to save performance.

pub fn additional_solver_iterations(self, additional_iterations: usize) -> Self

Sets the additional number of solver iterations run for this rigid-body and everything interacting with it.

See RigidBody::set_additional_solver_iterations for additional information.

pub fn gravity_scale(self, scale_factor: f32) -> Self

Sets the scale applied to the gravity force affecting the rigid-body to be created.

pub fn dominance_group(self, group: i8) -> Self

Sets the dominance group (advanced collision priority system).

Higher dominance groups can push lower ones but not vice versa. Rarely needed - most games don’t use this. Default is 0 (all equal priority).

Use case: Heavy objects that should always push lighter ones in contacts.

pub fn translation(self, translation: Vector<f32>) -> Self

Sets the initial position (XYZ coordinates) where this body will be created.

Example

let body = RigidBodyBuilder::dynamic()
    .translation(vector![10.0, 5.0, -3.0])
    .build();

pub fn rotation(self, angle: AngVector<f32>) -> Self

Sets the initial rotation/orientation of the body to be created.

Example

// Rotate 45 degrees around Y axis (in 3D)
let body = RigidBodyBuilder::dynamic()
    .rotation(vector![0.0, std::f32::consts::PI / 4.0, 0.0])
    .build();

pub fn position(self, pos: Isometry<f32>) -> Self

👎Deprecated: renamed to RigidBodyBuilder::pose

Sets the initial position (translation and orientation) of the rigid-body to be created.

pub fn pose(self, pos: Isometry<f32>) -> Self

Sets the initial pose (translation and orientation) of the rigid-body to be created.

pub fn user_data(self, data: u128) -> Self

An arbitrary user-defined 128-bit integer associated to the rigid-bodies built by this builder.

pub fn additional_mass_properties(self, mprops: MassProperties) -> Self

Sets the additional mass-properties of the rigid-body being built.

This will be overridden by a call to Self::additional_mass so it only makes sense to call either Self::additional_mass or Self::additional_mass_properties.

Note that “additional” means that the final mass-properties of the rigid-bodies depends on the initial mass-properties of the rigid-body (set by this method) to which is added the contributions of all the colliders with non-zero density attached to this rigid-body.

Therefore, if you want your provided mass-properties to be the final mass-properties of your rigid-body, don’t attach colliders to it, or only attach colliders with densities equal to zero.

pub fn additional_mass(self, mass: f32) -> Self

Sets the additional mass of the rigid-body being built.

This will be overridden by a call to Self::additional_mass_properties so it only makes sense to call either Self::additional_mass or Self::additional_mass_properties.

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.

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.

Parameters

• mass- The mass that will be added to the created rigid-body.

pub fn locked_axes(self, locked_axes: LockedAxes) -> Self

Sets which movement axes are locked (cannot move/rotate).

See LockedAxes for examples of constraining movement to specific directions.

pub fn lock_translations(self) -> Self

Prevents all translational movement (body can still rotate).

Use for turrets, spinning objects fixed in place, etc.

pub fn enabled_translations( self, allow_translations_x: bool, allow_translations_y: bool, ) -> Self

Locks translation along specific axes.

Example

// 2D game in 3D: lock Z movement
let body = RigidBodyBuilder::dynamic()
    .enabled_translations(true, true, false)  // X, Y free; Z locked
    .build();

pub fn restrict_translations( self, allow_translations_x: bool, allow_translations_y: bool, ) -> Self

👎Deprecated: Use enabled_translations instead

Only allow translations of this rigid-body around specific coordinate axes.

pub fn lock_rotations(self) -> Self

Prevents all rotational movement (body can still translate).

Use for characters that shouldn’t tip over, objects that should only slide, etc.

pub fn linear_damping(self, factor: f32) -> Self

Sets linear damping (how quickly linear velocity decreases over time).

Models air resistance, drag, etc. Higher values = faster slowdown.

• 0.0 = no drag (space)
• 0.1 = light drag (air)
• 1.0+ = heavy drag (underwater)

pub fn angular_damping(self, factor: f32) -> Self

Sets angular damping (how quickly rotation speed decreases over time).

Models rotational drag. Higher values = spinning stops faster.

pub fn linvel(self, linvel: Vector<f32>) -> Self

Sets the initial linear velocity (movement speed and direction).

The body will start moving at this velocity when created.

pub fn angvel(self, angvel: AngVector<f32>) -> Self

Sets the initial angular velocity (rotation speed).

The body will start rotating at this speed when created.

pub fn can_sleep(self, can_sleep: bool) -> Self

Sets whether this body can go to sleep when at rest (default: true).

Sleeping bodies are excluded from simulation until disturbed, saving CPU. Set to false if you need the body always active (e.g., for continuous queries).

pub fn ccd_enabled(self, enabled: bool) -> Self

Enables Continuous Collision Detection to prevent fast objects from tunneling.

CCD prevents “tunneling” where fast-moving objects pass through thin walls. Enable this for:

• Bullets and fast projectiles
• Small objects moving at high speed
• Objects that must never pass through walls

Trade-off: More accurate but more expensive. Most objects don’t need CCD.

Example

// Bullet that should never tunnel through walls
let bullet = RigidBodyBuilder::dynamic()
    .ccd_enabled(true)
    .build();

pub fn soft_ccd_prediction(self, prediction_distance: f32) -> Self

Sets the maximum prediction distance Soft Continuous Collision-Detection.

When set to 0, soft-CCD is disabled. Soft-CCD helps prevent tunneling especially of slow-but-thin to moderately fast objects. The soft CCD prediction distance indicates how far in the object’s path the CCD algorithm is allowed to inspect. Large values can impact performance badly by increasing the work needed from the broad-phase.

It is a generally cheaper variant of regular CCD (that can be enabled with RigidBodyBuilder::ccd_enabled since it relies on predictive constraints instead of shape-cast and substeps.

pub fn sleeping(self, sleeping: bool) -> Self

Sets whether the rigid-body is to be created asleep.

pub fn enabled(self, enabled: bool) -> Self

Enable or disable the rigid-body after its creation.

pub fn build(&self) -> RigidBody

Build a new rigid-body with the parameters configured with this builder.

Trait Implementations

impl Clone for RigidBodyBuilder

fn clone(&self) -> RigidBodyBuilder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RigidBodyBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RigidBodyBuilder

fn default() -> Self

Returns the “default value” for a type.

impl From<RigidBodyBuilder> for RigidBody

fn from(val: RigidBodyBuilder) -> RigidBody

Converts to this type from the input type.

impl PartialEq for RigidBodyBuilder

fn eq(&self, other: &RigidBodyBuilder) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for RigidBodyBuilder