Struct physx::articulation_reduced_coordinate::PxArticulationReducedCoordinate

#[repr(transparent)]
pub struct PxArticulationReducedCoordinate<U, Link: ArticulationLink> { /* private fields */ }

A new type wrapper for PxArticulationReducedCoordinate. Parametrized by it’s user data type, and the type of it’s ArticulationLinks.

Trait Implementations

impl<U, Link: ArticulationLink> ArticulationBase for PxArticulationReducedCoordinate<U, Link>

type ArticulationLink = Link

fn set_solver_iteration_counts(
    &mut self,
    min_position_iters: u32,
    min_velocity_iters: u32
)

Sets the number of iterations the solver should perform. If the articulation is behaving erratically, increasing the iteration counts may improve stability.

fn get_solver_iteration_counts(&self) -> (u32, u32)

Get the number of (position, velocity) iterations the solver will perform.

fn is_sleeping(&self) -> bool

Check if the articulation is sleeping

fn set_sleep_threshold(&mut self, threshold: f32)

Set the inactivity threshold for sleeping this articulation

fn get_sleep_threshold(&self) -> f32

Read back the inactivity threshold

fn set_stabilization_threshold(&mut self, threshold: f32)

Set the stabilization threshold for this articulation

fn get_stabilization_threshold(&self) -> f32

Get the stabilization threshold for this articulation

fn set_wake_counter(&mut self, threshold: f32)

Set the counter for how many steps more the articulation will be awake if below the energy threshold. When this is non-zero, the articulation may sleep but is not required to do so depending on other factors.

fn get_wake_counter(&self) -> f32

Get the counter for how many steps more the agent will be awake if below the energy threshold.

fn wake_up(&mut self)

Wake up the articulation

fn put_to_sleep(&mut self)

Put the articulation to sleep immediately

fn get_nb_links(&self) -> usize

Get the total number of links on this articulation

fn root_link(&self) -> Option<&Self::ArticulationLink>

Get a reference the root link of this articulation if it has one

fn root_link_mut(&mut self) -> Option<&mut Self::ArticulationLink>

Get a mutable reference to the root link of this articulation if it has one

fn get_links(&self) -> Vec<&Self::ArticulationLink>

Get a vec of all the links

fn get_links_mut(&mut self) -> Vec<&mut Self::ArticulationLink>

Get a mutable vec of all the links

fn get_world_bounds(&self, inflation: f32) -> PxBounds3

Get the world bounds of this articulation

fn create_link(
    &mut self,
    parent: Option<&mut Self::ArticulationLink>,
    pose: &PxTransform,
    user_data: <Self::ArticulationLink as UserData>::UserData
) -> Option<&mut Self::ArticulationLink>

Add a link to this articulation

fn create_articulation_joint<J: ArticulationJointBase>(
    &mut self,
    parent: &mut Self::ArticulationLink,
    parent_frame: &PxTransform,
    child: &mut Self::ArticulationLink,
    child_frame: &PxTransform
) -> Option<&mut J>

Create a joint between two articulation Links

unsafe fn release_articulation_joint(
    &mut self,
    joint: &mut impl ArticulationJointBase
)

Release an articulation joint, freeing it.

impl<U, L: ArticulationLink> ArticulationReducedCoordinate for PxArticulationReducedCoordinate<U, L>

unsafe fn from_raw(
    ptr: *mut PxArticulationReducedCoordinate,
    user_data: Self::UserData
) -> Option<Owner<Self>>

Safety

fn get_user_data(&self) -> &Self::UserData

Get a reference to the user data.

fn get_user_data_mut(&mut self) -> &mut Self::UserData

Get a mutable reference to the user data.

fn common_init(&mut self)

fn get_dofs(&self) -> usize

Get the number of dofs for the body

fn set_articulation_flag(&mut self, flag: ArticulationFlag, value: bool)

Set an articulation flag

fn set_articulation_flags(&mut self, flag: ArticulationFlag)

Set the articulation flags

fn get_articulation_flags(&self) -> ArticulationFlags

Get the articulation flags

fn teleport_to(&mut self, pose: &PxTransform)

Teleport the whole body to the transform and and orientation given by Pose

fn create_cache(&self) -> Option<ArticulationCache>

Create a new cache for this articulation

fn release_cache(&self, cache: ArticulationCache)

Release the cache and free the memory

fn get_cache_data_size(&self) -> u32

Get the memory size of this cache

fn zero_cache(&mut self, cache: &mut ArticulationCache)

Zero everything in the cache

fn apply_cache(
    &mut self,
    cache: &mut ArticulationCache,
    flag: BitFlags<ArticulationCacheFlag>,
    autowake: bool
)

Apply the cache to the articulation

fn copy_internal_state_to_cache(
    &self,
    cache: &mut ArticulationCache,
    flag: BitFlags<ArticulationCacheFlag>
)

Copy from the articulation to the cache based on the flags

fn compute_generalized_gravity_force(&self, cache: &mut ArticulationCache)

Compute generalized gravity forces acting upon the body and store in cache

fn compute_coriolis_and_centrifugal_force(&self, cache: &mut ArticulationCache)

Compute the coriolis and centrifugal forces acting upon the multibody

fn compute_generalized_external_force(&self, cache: &mut ArticulationCache)

Compute joint force changes caused by external forces

fn compute_joint_acceleration(&self, cache: &mut ArticulationCache)

Compute joint acceleration caused by current joint forces

fn compute_joint_force(&self, cache: &mut ArticulationCache)

Compute joint force caused by changes in joint acceleration

fn compute_dense_jacobian(&self, cache: &mut ArticulationCache) -> (u32, u32)

Compute dense jacobian and store into the cache. Returns: (cols, rows)

fn compute_coefficient_matrix(&self, cache: &mut ArticulationCache)

Compute the coefficient matrix and store into cache

fn compute_lambda(
    &self,
    cache: &mut ArticulationCache,
    initial_state: &mut ArticulationCache,
    joint_torques: &[f32],
    max_iter: u32
) -> bool

Compute the force needed to match the velocity and acceleration values given in initial_state

fn compute_generalized_mass_matrix(&self, cache: &mut ArticulationCache)

Compute the generalized mass matrix and store into the cache

fn pack_joint_data(&self, maximum: &[f32], reduced: &mut [f32])

Pack the maximum coordinates data in maximum into the reduced coordinates data.

fn unpack_joint_data(&self, reduced: &[f32], maximum: &mut [f32])

Unpack the reduced/generalized coordinates data in reduced into maximum. Maximum needs to have six slots for every joint.

fn get_center_of_mass(&self) -> PxVec3

Compute the total center of mass w.r.t. all attached shapes

fn get_center_of_mass_and_velocity(&self) -> (PxVec3, PxVec3)

Compute the total center of mass and velocity w.r.t. all attached shapes

fn set_collision_filter(
    &mut self,
    this_layer: BitFlags<CollisionLayer>,
    other_layer: BitFlags<CollisionLayer>
)

Set the collision layer on all links and shapes of this body

fn set_query_filter(&mut self, this_layer: BitFlags<CollisionLayer>)

Set the collision layer on all links and shapes of this body

impl<S, U, Link: ArticulationLink> Class<S> for PxArticulationReducedCoordinate<U, Link>where
    PxArticulationReducedCoordinate: Class<S>,

fn as_ptr(&self) -> *const S

Returns a raw const pointer to the wrapped type. Retrieving a raw pointer is safe. However, pretty much any use of a raw pointer is unsafe. In particular: this pointer should not be used to construct a second owning wrapper around the pointer.

fn as_mut_ptr(&mut self) -> *mut S

Returns a raw mut pointer to the wrapped type. Retrieving a raw pointer is safe. However, pretty much any use of a raw pointer is unsafe. In particular: this pointer should not be used to construct a second owning wrapper around the pointer.

impl<U, Link: ArticulationLink> Drop for PxArticulationReducedCoordinate<U, Link>

fn drop(&mut self)

Executes the destructor for this type.

impl<U: Send, Link: ArticulationLink + Send> Send for PxArticulationReducedCoordinate<U, Link>

impl<U: Sync, Link: ArticulationLink + Send> Sync for PxArticulationReducedCoordinate<U, Link>