Struct rapier2d::dynamics::RigidBodyBuilder

pub struct RigidBodyBuilder {

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

A builder for rigid-bodies.

Fields

position: Isometry<Real>

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

linvel: Vector<Real>

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

angvel: AngVector<Real>

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

gravity_scale: Real

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

linear_damping: Real

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

angular_damping: Real

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

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: Real

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.

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

Initializes the builder of a new fixed rigid body.

pub fn kinematic_velocity_based() -> Self

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

pub fn kinematic_position_based() -> Self

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

pub fn dynamic() -> Self

Initializes the builder of a new dynamic rigid body.

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: Real) -> 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 of this rigid-body.

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

Sets the initial translation of the rigid-body to be created.

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

Sets the initial orientation of the rigid-body to be created.

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

Sets the initial position (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: Real) -> 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 the axes along which this rigid-body cannot translate or rotate.

pub fn lock_translations(self) -> Self

Prevents this rigid-body from translating because of forces.

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

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

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 this rigid-body from rotating because of forces.

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

Sets the damping factor for the linear part of the rigid-body motion.

The higher the linear damping factor is, the more quickly the rigid-body will slow-down its translational movement.

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

Sets the damping factor for the angular part of the rigid-body motion.

The higher the angular damping factor is, the more quickly the rigid-body will slow-down its rotational movement.

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

Sets the initial linear velocity of the rigid-body to be created.

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

Sets the initial angular velocity of the rigid-body to be created.

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

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

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

Sets whether Continuous Collision-Detection is enabled for this rigid-body.

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

pub fn soft_ccd_prediction(self, prediction_distance: Real) -> 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 copy 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 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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for RigidBodyBuilder