Struct VelocityTransform 

pub struct VelocityTransform<T: Copy + Debug + 'static> {
    pub linear: [T; 3],
    pub angular: [T; 3],
}

A struct representing linear and angular velocity in 3D space

The VelocityTransform encapsulates both linear and angular velocity components of a rigid body in 3D space. It complements the Transform3D struct which represents position and orientation.

Linear velocity is represented as a 3D vector [vx, vy, vz] in meters per second. Angular velocity is represented as a 3D vector [wx, wy, wz] in radians per second, where the vector represents the axis of rotation and the magnitude is the rate.

Examples

use cu_transform::VelocityTransform;

// Create a velocity with 1 m/s forward and 0.5 rad/s rotation around Z axis
let velocity = VelocityTransform::<f32> {
    linear: [1.0, 0.0, 0.0],
    angular: [0.0, 0.0, 0.5],
};

Velocities can be transformed between coordinate frames using the transform_velocity function, and new velocities can be computed from time-stamped transforms using StampedTransform::compute_velocity.

When using the TransformTree to look up velocities with lookup_velocity, results are automatically cached for improved performance on repeated lookups. The cache is invalidated when new transforms are added or when entries exceed their age limit.

Fields

linear: [T; 3]

Linear velocity components [vx, vy, vz] in meters per second

angular: [T; 3]

Angular velocity components [wx, wy, wz] in radians per second

Implementations

impl<T: Copy + Debug + Default + Zero + 'static> VelocityTransform<T>

pub fn zero() -> Self

Create a new velocity transform with zero velocities

impl<T> VelocityTransform<T>

where T: Copy + Debug + Default + 'static + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + Neg<Output = T>,

pub fn add(&self, other: &Self) -> Self

Add two velocity transforms component-wise

pub fn sub(&self, other: &Self) -> Self

Subtract two velocity transforms component-wise

pub fn scale(&self, scalar: T) -> Self

Scale a velocity transform by a scalar

pub fn negate(&self) -> Self

Negate a velocity transform

impl VelocityTransform<f64>

pub fn linear_velocity(&self) -> [Velocity64; 3]

Get linear velocity components with units

pub fn angular_velocity(&self) -> [AngularVelocity64; 3]

Get angular velocity components with units

impl VelocityTransform<f32>

pub fn linear_velocity(&self) -> [Velocity32; 3]

Get linear velocity components with units

pub fn angular_velocity(&self) -> [AngularVelocity32; 3]

Get angular velocity components with units

Trait Implementations

impl<T> Add for VelocityTransform<T>

where T: Copy + Debug + Default + 'static + Add<Output = T>,

type Output = VelocityTransform<T>

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl<'__de, T, __Context> BorrowDecode<'__de, __Context> for VelocityTransform<T>

where T: BorrowDecode<'__de, __Context> + Copy + Debug + 'static,

fn borrow_decode<__D: BorrowDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl<T: Clone + Copy + Debug + 'static> Clone for VelocityTransform<T>

fn clone(&self) -> VelocityTransform<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Copy + Debug + 'static> Debug for VelocityTransform<T>

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

Formats the value using the given formatter.

impl<T, __Context> Decode<__Context> for VelocityTransform<T>

where T: Decode<__Context> + Copy + Debug + 'static,

fn decode<__D: Decoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl<T: Copy + Debug + Default> Default for VelocityTransform<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for VelocityTransform<T>

where T: Deserialize<'de> + Copy + Debug + 'static,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Encode for VelocityTransform<T>

where T: Encode + Copy + Debug + 'static,

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl<T> Neg for VelocityTransform<T>

where T: Copy + Debug + Default + 'static + Neg<Output = T>,

type Output = VelocityTransform<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> Serialize for VelocityTransform<T>

where T: Serialize + Copy + Debug + 'static,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Sub for VelocityTransform<T>

where T: Copy + Debug + Default + 'static + Sub<Output = T>,

type Output = VelocityTransform<T>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.