Struct DualQuat

Source

#[repr(C, align(16))]pub struct DualQuat {
    pub real: Quat,
    pub dual: Quat,
}

Expand description

Represents a rigid body transformation which can be thought of as a “screw” motion which is the combination of a translation along a vector and a rotation around that vector.

Represents the same kind of transformation as an IsoTransform but interpolates and transforms in a way that preserves volume.

Fields§

§real: Quat

The real quaternion part, i.e. the rotator

§dual: Quat

The dual quaternion part, i.e. the translator

Implementations§

Source §

impl DualQuat

Source

pub const IDENTITY: Self

The identity transform: doesn’t transform at all. Like multiplying with 1.

Source

pub const ZERO: Self

Not a valid quaternion in and of itself. All values filled with 0s. Can be useful when blending a set of transforms.

Source

pub fn from_iso_transform(iso_transform: IsoTransform) -> Self

Create a dual quaternion from an IsoTransform

Source

pub fn from_rotation_translation(rotation: Quat, translation: Vec3) -> Self

Create a dual quaternion that rotates and then translates by the specified amount. rotation is assumed to be normalized.

Source

pub fn from_translation(translation: Vec3) -> Self

A pure translation without any rotation.

Source

pub fn from_quat(rotation: Quat) -> Self

A pure rotation without any translation.

Source

pub fn to_rotation_translation(self) -> (Quat, Vec3)

Returns this transform decomposed into (rotation, translation). Assumes self is already normalized. If not, consider using normalize_to_rotation_translation

You can then apply this to a point by doing rotation.mul_vec3(point) + translation.

Source

pub fn conjugate(self) -> Self

Quaternion conjugate of this dual quaternion, which is given q = (real + dual), q* = (real* + dual*). This form of conjugate is also the inverse as long as this dual quaternion is unit.

Source

pub fn inverse(self) -> Self

Gives the inverse of this dual quaternion such that self * self.inverse() = identity.

This function should only be used if self is unit, i.e if self.is_normalized() is true. Will panic in debug builds if it is not normalized.

Source

pub fn norm_squared(self) -> DualScalar

Gives the norm squared of the dual quaternion.

self is normalized if real = 1.0 and dual = 0.0.

Source

pub fn norm(self) -> DualScalar

Gives the norm of the dual quaternion.

self is normalized if real = 1.0 and dual = 0.0.

Source

pub fn is_normalized(self) -> bool

Whether self is normalized, i.e. a unit dual quaternion.

Source

pub fn normalize_full(self) -> Self

Normalizes self to make it a unit dual quaternion.

If you will immediately apply the normalized dual quat to transform a point/vector, consider using normalize_to_rotation_translation instead.

Source

pub fn normalize_to_rotation_translation(self) -> (Quat, Vec3)

Normalize self and then extract its rotation and translation components which can be applied to a point by doing rotation.mul_vec3(point) + translation

This will be faster than self.normalize().to_rotation_translation() as we can use the full expansion of the operation to cancel out some calculations that would otherwise need to be performed. For justification of this, see https://users.cs.utah.edu/~ladislav/kavan07skinning/kavan07skinning.pdf particularly equation (4) and section 3.4.

You can then apply this to a point by doing (rotation * point + translation)

Source