Struct newton::body::DynamicBody

pub struct DynamicBody<'a> { /* fields omitted */ }

Dynamic body wrapper.

If a dynamic body has no mass, it is equivalent to a static body.

Methods

impl<'a> DynamicBody<'a>

pub unsafe fn from_raw(raw: *const NewtonBody, owned: bool) -> Self

pub fn release(self)

Forgets about this body. It will be freed along the world If you want to reference the object later, you should call into_handle instead.

pub fn create<C>(
    newton: &'a Newton,
    collision: &C,
    matrix: Mat4,
    name: Option<&'static str>
) -> Self where
    C: NewtonCollision, 

Trait Implementations

impl<'a> NewtonBody for DynamicBody<'a>

fn as_raw(&self) -> *const NewtonBody

fn matrix(&self) -> Mat4

fn set_continuous(&self, cont: bool)

fn is_continuous(&self) -> bool

fn set_matrix(&self, matrix: Mat4)

fn position(&self) -> Vec3

fn into_raw(self) -> *const NewtonBody where
    Self: Sized, 

fn velocity(&self) -> Vec3

fn aabb(&self) -> (Vec3, Vec3)

fn sleep_state(&self) -> SleepState

fn set_sleep_state(&self, state: SleepState)

fn set_active(&self)

fn set_sleeping(&self)

fn set_force(&self, force: Vec3)

fn set_collision<C: NewtonCollision>(&self, collision: C)

fn collision(&self) -> Collision

fn name(&self) -> Option<&'static str>

fn mass(&self) -> (f32, Vec3)

fn set_mass<C: NewtonCollision>(&self, mass: f32, collision: &C)

fn set_destroy_callback<F>(&self, callback: F) where
    F: FnMut(Body) + Send + 'static, 

fn set_transform_callback<F>(&self, callback: F) where
    F: FnMut(Body, Mat4, usize) + Send + 'static, 

Important traits for Joints<'a>

impl<'a> Iterator for Joints<'a> type Item = Joint<'a>;

fn joints(&self) -> Joints

fn set_force_and_torque_callback<F>(&self, callback: F) where
    F: FnMut(Body, Duration, usize) + Send + 'static, 

impl<'a> FromHandle<'a> for DynamicBody<'a>

fn from_handle(newton: &'a Newton, handle: Handle) -> Option<Self>

Borrows object from newton storage.

fn from_handle_owned(newton: &'a mut Newton, handle: Handle) -> Option<Self>

Retakes ownership of an object stored in Newton. The returned object is destroyed after drop.

impl<'a> IntoHandle for DynamicBody<'a>

fn into_handle(self, newton: &Newton) -> Handle

Moves the object into the given Newton and returns a handle to borrow it or retake ownership of it later.

impl<'a> AsHandle for DynamicBody<'a>

fn as_handle(&self, _: &Newton) -> Handle

Returns the same vale that would be returned by into_handle, but without moving the object.

impl<'a> PartialEq<DynamicBody<'a>> for DynamicBody<'a>

fn eq(&self, other: &DynamicBody<'a>) -> bool

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

fn ne(&self, other: &DynamicBody<'a>) -> bool

This method tests for !=.

impl<'a> From<DynamicBody<'a>> for Body<'a>

fn from(body: DynamicBody<'a>) -> Self

Performs the conversion.

impl<'a> Drop for DynamicBody<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> Eq for DynamicBody<'a>

impl<'a> Debug for DynamicBody<'a>

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

Formats the value using the given formatter.