Enum trackball::Delta

pub enum Delta<N: Copy + RealField> {
    Frame,
    First {
        pitch: N,
        yaw: N,
        yaw_axis: Unit<Vector3<N>>,
    },
    Track {
        vec: Vector3<N>,
    },
    Orbit {
        rot: UnitQuaternion<N>,
        pos: Point3<N>,
    },
    Slide {
        vec: Vector3<N>,
    },
    Scale {
        rat: N,
        pos: Point3<N>,
    },
}

Delta transform from initial to final Frame.

Variants

Frame

Yields frame as identity transform (default).

First

Orbits target around eye by pitch and yaw preserving roll attitude aka first person view.

See Frame::look_around().

Fields

pitch: N

Pitch angle.

yaw: N

Yaw angle.

yaw_axis: Unit<Vector3<N>>

Yaw axis.

Track

Tracks target which slides by vector in world space.

Preserves eye position inclusive its roll attitude.

Fields

vec: Vector3<N>

Vector in world space of a sliding target to track.

Orbit

Orbits eye by rotation in camera space around point in camera space.

See Frame::local_orbit_around().

Fields

rot: UnitQuaternion<N>

Rotation in camera space.

pos: Point3<N>

Point in camera space.

Slide

Slides camera eye and target by vector in camera space.

See Frame::local_slide().

Fields

vec: Vector3<N>

Vector in camera space.

Scale

Scales distance between eye and point in camera space by ratio preserving target position.

See Frame::local_scale_around().

Fields

rat: N

Scale ratio.

pos: Point3<N>

Point in camera space.

Implementations

impl<N: Copy + RealField> Delta<N>

pub fn transform(&self, frame: &Frame<N>) -> Frame<N>

Transforms from initial to final frame.

pub fn inverse(self) -> Self

Inverses delta transform.

Effectively swaps initial with final frame.

pub fn lerp_slerp(&self, t: N) -> Self

Interpolates delta transform to a fraction using linear interpolation for the translation part, and spherical linear interpolation for the rotation part.

Arguments

• self: The delta transform to interpolate from.
• t: The interpolation parameter between 0 and 1.

pub fn cast<M: Copy + RealField>(self) -> Delta<M>

where N: SubsetOf<M>,

Casts components to another type, e.g., between f32 and f64.

Trait Implementations

impl<N: Clone + Copy + RealField> Clone for Delta<N>

fn clone(&self) -> Delta<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Debug + Copy + RealField> Debug for Delta<N>

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

Formats the value using the given formatter.

impl<N: Copy + RealField> Default for Delta<N>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, N> Deserialize<'de> for Delta<N>

where N: Deserialize<'de> + Copy + RealField,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<N: PartialEq + Copy + RealField> PartialEq for Delta<N>

fn eq(&self, other: &Delta<N>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N> Serialize for Delta<N>

where N: Serialize + Copy + RealField,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<N: Copy + Copy + RealField> Copy for Delta<N>

impl<N: Eq + Copy + RealField> Eq for Delta<N>

impl<N: Copy + RealField> StructuralPartialEq for Delta<N>