Struct jumpy::core::physics::dynamic_body::DynamicBody

#[repr(C)]
pub struct DynamicBody {
    pub is_dynamic: bool,
    last_rapier_synced_transform: Transform,
    command_queue: Arc<Mutex<Vec<Box<SimulationCommand>>>>,
}

Bodies with DynamicBody will be simulated dynamically if is_dynamic is True. Currently DynamicBody requires component KinematicBody, as it shares shape.

if is_dynamic is false, body is treated as kinematic.

Fields

is_dynamic: bool

Is body simulating or kinematic mode?

last_rapier_synced_transform: Transform

This transform is used to determine if position has moved in gameplay code outside of rapier sim. Is only relevant when is_dynamic = true. It is updated whenever transform is synced to or from rapier.

If this does not match entity Transform at beginning of physics update, rapier simulation body will be teleported to match gameplay.

See Self::simulation_transform_needs_update for context.

command_queue: Arc<Mutex<Vec<Box<SimulationCommand>>>>

Simulation command queue. See Self::push_simulation_command for details.

Implementations

impl DynamicBody

pub fn new(is_dynamic: bool) -> Self

Create new DynamicBody. is_dynamic = true simulates physics, false remains kinematic.

pub fn simulation_transform_needs_update( &mut self, transform: &Transform, ) -> bool

Check if rapier simulation’s body’s transform is dirty (If it was modified outside of physics simulation). Always returns true if object is not simulating.

Updates last_rapier_synced_transform if called, should only be called before updating rapier positions from gameplay.

pub fn update_last_rapier_synced_transform( &mut self, translation: Vec3, rotation: Quat, )

Update last_rapier_synced_transform from simulation output so we can determine when gameplay has modified transform outside of rapier for Self::simulation_transform_needs_update.

This does NOT update position of entity.

pub fn push_simulation_command(&mut self, command: Box<SimulationCommand>)

Push command that is executed before next physics step, after body is guranteed to be initialized in rapier and set to rapier::RigidBodyType::Dynamic (if transitioning from Kinematic to Dynamic).

Commands are only executed if is_dynamic = true (body is simulating) next frame! Otherwise they are discarded. This restriction is in place to prevent switching back to kinematic and modifying simulation state in an unintentional way.

Commands are executed in order they are pushed. If you need to immediately apply changes, use CollisionWorld::mutate_rigidbody.

pub fn simulation_commands(&mut self) -> Vec<Box<SimulationCommand>>

Retrieve SimulationCommand queue for processing. Values are moved out of self, flushing queue.

Trait Implementations

impl Clone for DynamicBody

fn clone(&self) -> DynamicBody

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for DynamicBody

fn default() -> DynamicBody

Returns the “default value” for a type.

impl HasSchema for DynamicBody

fn schema() -> &'static Schema

Get this type’s [Schema].

fn register_schema()

Register this schema with the global schema registry.

fn cast<T>(this: &Self) -> &T

where T: HasSchema,

Cast a reference of this type to a reference of another type with the same memory layout.

fn try_cast<T>(this: &Self) -> Result<&T, SchemaMismatchError>

where T: HasSchema,

Cast a reference of this type to a reference of another type with the same memory layout.

fn cast_mut<T>(this: &mut Self) -> &mut T

where T: HasSchema,

Cast a mutable reference of this type to a reference of another type with the same memory layout.

fn try_cast_mut<T>(this: &mut Self) -> Result<&mut T, SchemaMismatchError>

where T: HasSchema,

Cast a mutable reference of this type to a reference of another type with the same memory layout.

fn as_schema_ref(&self) -> SchemaRef<'_>

where Self: Sized,

Converts a reference of T to a SchemaRef

fn as_schema_mut(&mut self) -> SchemaRefMut<'_>

where Self: Sized,

Converts a reference of T to a SchemaRefMut