Struct nphysics3d::object::RigidBody

pub struct RigidBody<N: RealField> { /* fields omitted */ }

A rigid body.

Methods

impl<N: RealField> RigidBody<N>

pub fn user_data(&self) -> Option<&(dyn Any + Send + Sync)>

Retrieves a reference to the user-defined user-data attached to this object.

pub fn user_data_mut(&mut self) -> Option<&mut (dyn Any + Send + Sync)>

Retrieves a mutable reference to the user-defined user-data attached to this object.

pub fn set_user_data(
    &mut self,
    data: Option<Box<dyn Any + Send + Sync>>
) -> Option<Box<dyn Any + Send + Sync>>

Sets the user-defined data attached to this object.

pub fn take_user_data(&mut self) -> Option<Box<dyn Any + Send + Sync>>

Replace by None the user-defined data attached to this object and returns the old value.

pub fn set_translations_kinematic(&mut self, is_kinematic: Vector<bool>)

Mark some translational degrees of freedom as kinematic.

pub fn set_rotations_kinematic(&mut self, is_kinematic: Vector<bool>)

Mark some rotational degrees of freedom as kinematic.

pub fn kinematic_translations(&self) -> Vector<bool>

Flags indicating which translational degrees of freedoms are kinematic.

pub fn kinematic_rotations(&self) -> Vector<bool>

Flags indicating which rotational degrees of freedoms are kinematic.

pub fn disable_all_rotations(&mut self)

Disable all rotations of this rigid body.

This is the same as setting all the rotations of this rigid body as kinematic and setting its angular velocity to zero. The rotations will still be controllable at the velocity level by the user afterwards.

pub fn enable_all_rotations(&mut self)

Enable all rotations for this rigid body.

This is the same as setting all the rotations of this rigid body as non-kinematic.

pub fn disable_all_translations(&mut self)

Disable all translations of this rigid body.

This is the same as setting all the translations of this rigid body as kinematic and setting its linear velocity to zero. The translations will still be controllable at the velocity level by the user afterwards.

pub fn enable_all_translations(&mut self)

Enable all translations for this rigid body.

This is the same as setting all the translations of this rigid body as non-kinematic.

pub fn handle(&self) -> BodyHandle

The handle of this rigid body.

pub fn part_handle(&self) -> BodyPartHandle

The part-handle of this rigid body.

The part id is set to 0 though any value is acceptable.

pub fn activation_status_mut(&mut self) -> &mut ActivationStatus<N>

Mutable information regarding activation and deactivation (sleeping) of this rigid body.

pub fn set_local_center_of_mass(&mut self, local_com: Point<N>)

Set the center of mass of this rigid body, expressed in its local space.

pub fn set_local_inertia(&mut self, local_inertia: Inertia<N>)

Set the local inertia of this rigid body, expressed in its local space.

pub fn set_mass(&mut self, mass: N)

Set the mass of this rigid body.

pub fn set_angular_inertia(&mut self, angular_inertia: Matrix3<N>)

Set the angular inertia of this rigid body, expressed in its local space.

pub fn set_position(&mut self, pos: Isometry<N>)

Sets the position of this rigid body.

pub fn set_velocity(&mut self, vel: Velocity<N>)

Set the velocity of this rigid body.

pub fn set_linear_velocity(&mut self, vel: Vector<N>)

Set the linear velocity of this rigid body.

pub fn set_angular_velocity(&mut self, vel: AngularVector<N>)

Set the angular velocity of this rigid body.

pub fn augmented_mass(&self) -> &Inertia<N>

The augmented mass (inluding gyroscropic terms) in world-space of this rigid body.

pub fn inv_augmented_mass(&self) -> &Inertia<N>

The inverse augmented mass (inluding gyroscropic terms) in world-space of this rigid body.

pub fn position(&self) -> &Isometry<N>

The position of this rigid body.

pub fn velocity(&self) -> &Velocity<N>

The velocity of this rigid body.

Trait Implementations

impl<N: RealField> Body<N> for RigidBody<N>

fn name(&self) -> &str

The name of this body.

fn set_name(&mut self, name: String)

Sets the name of this body.

fn activation_status(&self) -> &ActivationStatus<N>

Information regarding activation and deactivation (sleeping) of this body.

fn activate_with_energy(&mut self, energy: N)

Force the activation of this body with the given level of energy.

fn deactivate(&mut self)

Put this body to sleep.

fn set_deactivation_threshold(&mut self, threshold: Option<N>)

Sets the energy bellow which this body is put to sleep.

fn update_status(&self) -> BodyUpdateStatus

The flags tracking what modifications were applied to a body.

fn status(&self) -> BodyStatus

The status of this body.

fn set_status(&mut self, status: BodyStatus)

Set the status of this body.

fn deformed_positions(&self) -> Option<(DeformationsType, &[N])>

If this is a deformable body, returns its deformed positions.

fn deformed_positions_mut(&mut self) -> Option<(DeformationsType, &mut [N])>

If this is a deformable body, returns a mutable reference to its deformed positions.

fn companion_id(&self) -> usize

The companion ID of this body.

fn set_companion_id(&mut self, id: usize)

Set the companion ID of this body (may be reinitialized by nphysics).

fn handle(&self) -> BodyHandle

The handle of this body.

fn ndofs(&self) -> usize

The number of degrees of freedom of this body.

fn generalized_velocity(&self) -> DVectorSlice<N>

The generalized velocities of this body.

fn generalized_velocity_mut(&mut self) -> DVectorSliceMut<N>

The mutable generalized velocities of this body.

fn generalized_acceleration(&self) -> DVectorSlice<N>

The generalized accelerations at each degree of freedom of this body.

fn integrate(&mut self, params: &IntegrationParameters<N>)

Integrate the position of this body.

fn clear_forces(&mut self)

Reset the timestep-specific dynamic information of this body.

fn clear_update_flags(&mut self)

Clear all the update flags of this body.

fn update_kinematics(&mut self)

Updates the kinematics, e.g., positions and jacobians, of this body.

fn update_dynamics(&mut self, dt: N)

Update the dynamics property of this body.

fn update_acceleration(
    &mut self,
    gravity: &Vector<N>,
    _: &IntegrationParameters<N>
)

Update the acceleration of this body given the forces it is subject to and the gravity.

fn part(&self, _: usize) -> Option<&dyn BodyPart<N>>

A reference to the specified body part.

fn apply_displacement(&mut self, displacement: &[N])

Applies a generalized displacement to this body.

fn world_point_at_material_point(
    &self,
    _: &dyn BodyPart<N>,
    point: &Point<N>
) -> Point<N>

Transform the given point expressed in material coordinates to world-space.

fn position_at_material_point(
    &self,
    _: &dyn BodyPart<N>,
    point: &Point<N>
) -> Isometry<N>

Transform the given point expressed in material coordinates to world-space.

fn material_point_at_world_point(
    &self,
    _: &dyn BodyPart<N>,
    point: &Point<N>
) -> Point<N>

Transform the given point expressed in material coordinates to world-space.

fn gravity_enabled(&self) -> bool

Whether this body is affected by gravity.

fn enable_gravity(&mut self, enabled: bool)

Enable or disable gravity for this body.

fn fill_constraint_geometry(
    &self,
    _: &dyn BodyPart<N>,
    _: usize,
    point: &Point<N>,
    force_dir: &ForceDirection<N>,
    j_id: usize,
    wj_id: usize,
    jacobians: &mut [N],
    inv_r: &mut N,
    ext_vels: Option<&DVectorSlice<N>>,
    out_vel: Option<&mut N>
)

Fills all the jacobians (and the jacobians multiplied by the inverse augmented mass matrix) for a constraint applying a force at the point center (relative to the body part's center of mass) and the direction dir.

fn has_active_internal_constraints(&mut self) -> bool

Returns true if this bodies contains internal constraints that need to be solved.

fn setup_internal_velocity_constraints(
    &mut self,
    _: &DVectorSlice<N>,
    _: &IntegrationParameters<N>
)

Initializes the internal velocity constraints of a body.

fn warmstart_internal_velocity_constraints(
    &mut self,
    _: &mut DVectorSliceMut<N>
)

For warmstarting the solver, modifies the delta velocity applied by the internal constraints of this body.

fn step_solve_internal_velocity_constraints(
    &mut self,
    _: &mut DVectorSliceMut<N>
)

Execute one step for the iterative resolution of this body's internal velocity constraints.

fn step_solve_internal_position_constraints(
    &mut self,
    _: &IntegrationParameters<N>
)

Execute one step for the iterative resolution of this body's internal position constraints.

fn add_local_inertia_and_com(
    &mut self,
    _: usize,
    com: Point<N>,
    inertia: Inertia<N>
)

Add the given inertia to the local inertia of this body part.

fn apply_force(
    &mut self,
    _: usize,
    force: &Force<N>,
    force_type: ForceType,
    auto_wake_up: bool
)

Apply a force at the center of mass of a part of this body.

fn apply_local_force(
    &mut self,
    _: usize,
    force: &Force<N>,
    force_type: ForceType,
    auto_wake_up: bool
)

Apply a local force at the center of mass of a part of this body.

fn apply_force_at_point(
    &mut self,
    _: usize,
    force: &Vector<N>,
    point: &Point<N>,
    force_type: ForceType,
    auto_wake_up: bool
)

Apply a force at a given point of a part of this body.

fn apply_local_force_at_point(
    &mut self,
    _: usize,
    force: &Vector<N>,
    point: &Point<N>,
    force_type: ForceType,
    auto_wake_up: bool
)

Apply a local force at a given point of a part of this body.

fn apply_force_at_local_point(
    &mut self,
    _: usize,
    force: &Vector<N>,
    point: &Point<N>,
    force_type: ForceType,
    auto_wake_up: bool
)

Apply a force at a given local point of a part of this body.

fn apply_local_force_at_local_point(
    &mut self,
    _: usize,
    force: &Vector<N>,
    point: &Point<N>,
    force_type: ForceType,
    auto_wake_up: bool
)

Apply a local force at a given local point of a part of this body.

fn is_ground(&self) -> bool

Returns true if this body is the ground.

fn update_activation_status(&mut self)

Update whether this body needs to be waken up after a user-interaction.

fn status_dependent_ndofs(&self) -> usize

The number of degrees of freedom (DOF) of this body, taking its status into account.

fn status_dependent_body_part_velocity(
    &self,
    part: &dyn BodyPart<N>
) -> Velocity<N>

The velocity of the specified body part, taking this body status into account.

fn is_active(&self) -> bool

Check if this body is active.

fn is_dynamic(&self) -> bool

Whether or not the status of this body is dynamic.

fn is_kinematic(&self) -> bool

Whether or not the status of this body is kinematic.

fn is_static(&self) -> bool

Whether or not the status of this body is static.

fn activate(&mut self)

Force the activation of this body.

impl<N: RealField> BodyPart<N> for RigidBody<N>

fn is_ground(&self) -> bool

Returns true if this body part is the ground.

fn part_handle(&self) -> BodyPartHandle

The handle of this body part.

fn velocity(&self) -> Velocity<N>

The velocity of this body part.

fn position(&self) -> Isometry<N>

The position of this body part wrt. the ground.

fn local_inertia(&self) -> Inertia<N>

The local-space inertia of this body part.

fn inertia(&self) -> Inertia<N>

The world-space inertia of this body part.

fn center_of_mass(&self) -> Point<N>

The center of mass of this body part.

impl<N: Debug + RealField> Debug for RigidBody<N>

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

Formats the value using the given formatter.