Struct jumpy::core::physics::collisions::rapier::RigidBodyBuilder

pub struct RigidBodyBuilder {

    pub position: Isometry<f32, Unit<Complex<f32>>, 2>,
    pub linvel: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>,
    pub angvel: f32,
    pub gravity_scale: f32,
    pub linear_damping: f32,
    pub angular_damping: f32,
    body_type: RigidBodyType,
    mprops_flags: LockedAxes,
    additional_mass_properties: RigidBodyAdditionalMassProps,
    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,
}

A builder for rigid-bodies.

Fields

position: Isometry<f32, Unit<Complex<f32>>, 2>

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

linvel: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>

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

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

mprops_flags: LockedAxes

additional_mass_properties: RigidBodyAdditionalMassProps

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.

Implementations

impl RigidBodyBuilder

pub fn new(body_type: RigidBodyType) -> RigidBodyBuilder

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

pub fn new_static() -> RigidBodyBuilder

👎Deprecated: use RigidBodyBuilder::fixed() instead

Initializes the builder of a new fixed rigid body.

pub fn new_kinematic_velocity_based() -> RigidBodyBuilder

👎Deprecated: use RigidBodyBuilder::kinematic_velocity_based() instead

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

pub fn new_kinematic_position_based() -> RigidBodyBuilder

👎Deprecated: use RigidBodyBuilder::kinematic_position_based() instead

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

pub fn fixed() -> RigidBodyBuilder

Initializes the builder of a new fixed rigid body.

pub fn kinematic_velocity_based() -> RigidBodyBuilder

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

pub fn kinematic_position_based() -> RigidBodyBuilder

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

pub fn dynamic() -> RigidBodyBuilder

Initializes the builder of a new dynamic rigid body.

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

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) -> RigidBodyBuilder

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

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

Sets the dominance group of this rigid-body.

pub fn translation( self, translation: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, ) -> RigidBodyBuilder

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

pub fn rotation(self, angle: f32) -> RigidBodyBuilder

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

pub fn position( self, pos: Isometry<f32, Unit<Complex<f32>>, 2>, ) -> RigidBodyBuilder

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

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

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

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

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) -> RigidBodyBuilder

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) -> RigidBodyBuilder

Sets the axes along which this rigid-body cannot translate or rotate.

pub fn lock_translations(self) -> RigidBodyBuilder

Prevents this rigid-body from translating because of forces.

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

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

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

👎Deprecated: Use enabled_translations instead

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

pub fn lock_rotations(self) -> RigidBodyBuilder

Prevents this rigid-body from rotating because of forces.

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

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: f32) -> RigidBodyBuilder

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: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, ) -> RigidBodyBuilder

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

pub fn angvel(self, angvel: f32) -> RigidBodyBuilder

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

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

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

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

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: f32) -> RigidBodyBuilder

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) -> RigidBodyBuilder

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

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

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<(), Error>

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