Struct Frame

pub struct Frame<N>
where
    N: Copy + RealField,
{ /* private fields */ }

Frame wrt camera eye and target.

Implementations

impl<N> Frame<N>

where N: Copy + RealField,

pub fn look_at( target: OPoint<N, Const<3>>, eye: &OPoint<N, Const<3>>, up: &Matrix<N, Const<3>, Const<1>, ArrayStorage<N, 3, 1>>, ) -> Frame<N>

Sets eye position inclusive its roll attitude and target position in world space.

pub fn eye(&self) -> OPoint<N, Const<3>>

Eye position in world space.

pub fn set_eye( &mut self, eye: &OPoint<N, Const<3>>, up: &Matrix<N, Const<3>, Const<1>, ArrayStorage<N, 3, 1>>, )

Sets eye position inclusive its roll attitude in world space preserving target position.

pub const fn target(&self) -> &OPoint<N, Const<3>>

Target position in world space.

pub fn set_target(&mut self, pos: OPoint<N, Const<3>>)

Sets target position in world space preserving eye position inclusive its roll attitude.

Allows to track a moving object.

pub const fn distance(&self) -> N

Distance between eye and target.

pub fn set_distance(&mut self, zat: N)

Sets distance between eye and target preserving target position.

pub fn scale(&mut self, rat: N)

Scales distance between eye and target by ratio preserving target position.

pub fn local_scale_around(&mut self, rat: N, pos: &OPoint<N, Const<3>>)

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

pub fn scale_around(&mut self, rat: N, pos: &OPoint<N, Const<3>>)

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

pub fn local_slide( &mut self, vec: &Matrix<N, Const<3>, Const<1>, ArrayStorage<N, 3, 1>>, )

Slides camera eye and target by vector in camera space.

pub fn slide( &mut self, vec: &Matrix<N, Const<3>, Const<1>, ArrayStorage<N, 3, 1>>, )

Slides camera eye and target by vector in world space.

pub fn local_orbit(&mut self, rot: &Unit<Quaternion<N>>)

Orbits eye by rotation in camera space around target.

pub fn local_orbit_around( &mut self, rot: &Unit<Quaternion<N>>, pos: &OPoint<N, Const<3>>, )

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

pub fn orbit(&mut self, rot: &Unit<Quaternion<N>>)

Orbits eye by rotation in world space around target.

pub fn orbit_around( &mut self, rot: &Unit<Quaternion<N>>, pos: &OPoint<N, Const<3>>, )

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

pub fn look_around( &mut self, pitch: N, yaw: N, yaw_axis: &Unit<Matrix<N, Const<3>, Const<1>, ArrayStorage<N, 3, 1>>>, )

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

Use fixed Self::yaw_axis() by capturing it when entering first person view.

pub fn local_pitch_axis( &self, ) -> Unit<Matrix<N, Const<3>, Const<1>, ArrayStorage<N, 3, 1>>>

Positive x-axis in camera space pointing from left to right.

pub fn local_yaw_axis( &self, ) -> Unit<Matrix<N, Const<3>, Const<1>, ArrayStorage<N, 3, 1>>>

Positive y-axis in camera space pointing from bottom to top.

pub fn local_roll_axis( &self, ) -> Unit<Matrix<N, Const<3>, Const<1>, ArrayStorage<N, 3, 1>>>

Positive z-axis in camera space pointing from back to front.

pub fn pitch_axis( &self, ) -> Unit<Matrix<N, Const<3>, Const<1>, ArrayStorage<N, 3, 1>>>

Positive x-axis in world space pointing from left to right.

pub fn yaw_axis( &self, ) -> Unit<Matrix<N, Const<3>, Const<1>, ArrayStorage<N, 3, 1>>>

Positive y-axis in world space pointing from bottom to top.

pub fn roll_axis( &self, ) -> Unit<Matrix<N, Const<3>, Const<1>, ArrayStorage<N, 3, 1>>>

Positive z-axis in world space pointing from back to front.

pub fn try_lerp_slerp( &self, other: &Frame<N>, t: N, epsilon: N, ) -> Option<Frame<N>>

Attempts to interpolate between two frames using linear interpolation for the translation part, and spherical linear interpolation for the rotation part.

Returns None if the angle between both rotations is 180 degrees (in which case the interpolation is not well-defined).

Arguments

• self: The initial frame to interpolate from.
• other: The final frame to interpolate toward.
• t: The interpolation parameter between 0 and 1.
• epsilon: The value below which the sinus of the angle separating both quaternion must be to return None.

pub fn renormalize(&mut self) -> N

Renormalizes eye rotation and returns its norm.

pub fn view(&self) -> Isometry<N, Unit<Quaternion<N>>, 3>

View transformation from camera to world space.

pub fn inverse_view(&self) -> Isometry<N, Unit<Quaternion<N>>, 3>

Inverse view transformation from world to camera space.

Uses less computations than Self::view().inverse().

pub fn cast<M>(self) -> Frame<M>

where M: Copy + RealField, N: SubsetOf<M>,

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

Trait Implementations

impl<N> AbsDiffEq for Frame<N>

where N: Copy + RealField + AbsDiffEq, <N as AbsDiffEq>::Epsilon: Copy,

type Epsilon = <N as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> <N as AbsDiffEq>::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq( &self, other: &Frame<N>, epsilon: <N as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<N> Clone for Frame<N>

where N: Clone + Copy + RealField,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N> Debug for Frame<N>

where N: Debug + Copy + RealField,

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

Formats the value using the given formatter.

impl<N> Default for Frame<N>

where N: Default + Copy + RealField,

fn default() -> Frame<N>

Returns the “default value” for a type.

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

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

fn deserialize<__D>( __deserializer: __D, ) -> Result<Frame<N>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<N> PartialEq for Frame<N>

where N: PartialEq + Copy + RealField,

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<N> RelativeEq for Frame<N>

where N: Copy + RealField + RelativeEq, <N as AbsDiffEq>::Epsilon: Copy,

fn default_max_relative() -> <N as AbsDiffEq>::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Frame<N>, epsilon: <N as AbsDiffEq>::Epsilon, max_relative: <N as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl<N> Serialize for Frame<N>

where N: Copy + RealField + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<N> UlpsEq for Frame<N>

where N: Copy + RealField + UlpsEq, <N as AbsDiffEq>::Epsilon: Copy,

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq( &self, other: &Frame<N>, epsilon: <N as AbsDiffEq>::Epsilon, max_ulps: u32, ) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of UlpsEq::ulps_eq.

impl<N> Copy for Frame<N>

where N: Copy + RealField,

impl<N> Eq for Frame<N>

where N: Eq + Copy + RealField,

impl<N> StructuralPartialEq for Frame<N>

where N: Copy + RealField,