Struct cgmath::Basis3

pub struct Basis3<S> { /* private fields */ }

A three-dimensional rotation matrix.

The matrix is guaranteed to be orthogonal, so some operations, specifically inversion, can be implemented more efficiently than the implementations for math::Matrix3. To ensure orthogonality is maintained, the operations have been restricted to a subeset of those implemented on Matrix3.

Implementations

impl<S: BaseFloat> Basis3<S>

pub fn from_quaternion(quaternion: &Quaternion<S>) -> Basis3<S>

Create a new rotation matrix from a quaternion.

Trait Implementations

impl<S: BaseFloat> ApproxEq for Basis3<S>

type Epsilon = S

fn approx_eq_eps(&self, other: &Basis3<S>, epsilon: &S) -> bool

fn approx_epsilon() -> Self::Epsilon

fn approx_eq(&self, other: &Self) -> bool

impl<S> AsRef<Matrix3<S>> for Basis3<S>

fn as_ref(&self) -> &Matrix3<S>

Converts this type into a shared reference of the (usually inferred) input type.

impl<S: Clone> Clone for Basis3<S>

fn clone(&self) -> Basis3<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Decodable> Decodable for Basis3<S>

fn decode<__D: Decoder>(d: &mut __D) -> Result<Basis3<S>, __D::Error>

Deserialize a value using a Decoder.

impl<S: Encodable> Encodable for Basis3<S>

fn encode<__S: Encoder>(&self, s: &mut __S) -> Result<(), __S::Error>

Serialize a value using an Encoder.

impl<S: BaseFloat> From<Basis3<S>> for Matrix3<S>

fn from(b: Basis3<S>) -> Matrix3<S>

Converts to this type from the input type.

impl<S: BaseFloat> From<Basis3<S>> for Quaternion<S>

fn from(b: Basis3<S>) -> Quaternion<S>

Converts to this type from the input type.

impl<S: BaseFloat> From<Quaternion<S>> for Basis3<S>

fn from(quat: Quaternion<S>) -> Basis3<S>

Converts to this type from the input type.

impl<S: PartialEq> PartialEq<Basis3<S>> for Basis3<S>

fn eq(&self, other: &Basis3<S>) -> 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<S: BaseFloat> Rotation<Point3<S>> for Basis3<S>

fn one() -> Basis3<S>

Create the identity transform (causes no transformation).

fn look_at(dir: Vector3<S>, up: Vector3<S>) -> Basis3<S>

Create a rotation to a given direction with an ‘up’ vector

fn between_vectors(a: Vector3<S>, b: Vector3<S>) -> Basis3<S>

Create a shortest rotation to transform vector ‘a’ into ‘b’. Both given vectors are assumed to have unit length.

fn rotate_vector(&self, vec: Vector3<S>) -> Vector3<S>

Rotate a vector using this rotation.

fn concat(&self, other: &Basis3<S>) -> Basis3<S>

Create a new rotation which combines both this rotation, and another.

fn concat_self(&mut self, other: &Basis3<S>)

Modify this rotation in-place by combining it with another.

fn invert(&self) -> Basis3<S>

Create a new rotation which “un-does” this rotation. That is, r.concat(r.invert()) is the identity.

fn invert_self(&mut self)

Invert this rotation in-place.

fn rotate_point(&self, point: P) -> P

Rotate a point using this rotation, by converting it to its representation as a vector.

impl<S: BaseFloat> Rotation3<S> for Basis3<S>

fn from_axis_angle(axis: Vector3<S>, angle: Rad<S>) -> Basis3<S>

Create a rotation using an angle around a given axis.

fn from_euler(x: Rad<S>, y: Rad<S>, z: Rad<S>) -> Basis3<S>

Create a rotation from a set of euler angles.

fn from_angle_x(theta: Rad<S>) -> Basis3<S>

Create a rotation from an angle around the x axis (pitch).

fn from_angle_y(theta: Rad<S>) -> Basis3<S>

Create a rotation from an angle around the y axis (yaw).

fn from_angle_z(theta: Rad<S>) -> Basis3<S>

Create a rotation from an angle around the z axis (roll).

impl<S: Copy> Copy for Basis3<S>

impl<S> StructuralPartialEq for Basis3<S>