[−][src]Struct ezcgmath::matrix::Matrix3x3

#[repr(C)]pub struct Matrix3x3 {
    pub c00: Scalar,
    pub c10: Scalar,
    pub c20: Scalar,
    pub c01: Scalar,
    pub c11: Scalar,
    pub c21: Scalar,
    pub c02: Scalar,
    pub c12: Scalar,
    pub c22: Scalar,
}

A 3 x 3 Matrix.

Fields

c00: Scalarc10: Scalarc20: Scalarc01: Scalarc11: Scalarc21: Scalarc02: Scalarc12: Scalarc22: Scalar

Implementations

`impl Matrix3x3`[src]

`pub const fn identity() -> Self`[src]

`pub fn from_look_at(forward: Vector3, up: Vector3) -> Self`[src]

Creates a new so called "look at" rotation. This rotation will point in the forward direction with the given up direction.

As a reminder, this will create a left-handed rotation matrix. If you require a right-handed coordinate system, you'll have to convert to it with with a reflection matrix.

Trait Implementations

`impl AbsDiffEq<Matrix3x3> for Matrix3x3`[src]

`type Epsilon = Scalar`

Used for specifying relative comparisons.

`fn default_epsilon() -> Self::Epsilon`[src]

`fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool`[src]

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

`impl Add<Matrix3x3> for Matrix3x3`[src]

`type Output = Self`

The resulting type after applying the + operator.

`fn add(self, rhs: Self) -> Self`[src]

`impl AddAssign<Matrix3x3> for Matrix3x3`[src]

`fn add_assign(&mut self, rhs: Self)`[src]

`impl Clone for Matrix3x3`[src]

`fn clone(&self) -> Matrix3x3`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl Copy for Matrix3x3`[src]

`impl Debug for Matrix3x3`[src]

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

`impl Default for Matrix3x3`[src]

`fn default() -> Matrix3x3`[src]

`impl Mul<Matrix1x3> for Matrix3x3`[src]

`type Output = Matrix1x3`

The resulting type after applying the * operator.

`fn mul(self, rhs: Matrix1x3) -> Matrix1x3`[src]

`impl Mul<Matrix3x3> for Matrix3x3`[src]

`type Output = Matrix3x3`

The resulting type after applying the * operator.

`fn mul(self, rhs: Matrix3x3) -> Matrix3x3`[src]

`impl Mul<Matrix3x3> for Vector3`[src]

`type Output = Vector3`

The resulting type after applying the * operator.

`fn mul(self, rhs: Matrix3x3) -> Vector3`[src]

`impl Mul<f32> for Matrix3x3`[src]

`type Output = Self`

The resulting type after applying the * operator.

`fn mul(self, rhs: Scalar) -> Self`[src]

`impl MulAssign<Matrix3x3> for Matrix3x3`[src]

`fn mul_assign(&mut self, rhs: Matrix3x3)`[src]

`impl MulAssign<Matrix3x3> for Vector3`[src]

`fn mul_assign(&mut self, rhs: Matrix3x3)`[src]

`impl MulAssign<f32> for Matrix3x3`[src]

`fn mul_assign(&mut self, rhs: Scalar)`[src]

`impl PartialEq<Matrix3x3> for Matrix3x3`[src]

`fn eq(&self, other: &Matrix3x3) -> bool`[src]

`fn ne(&self, other: &Matrix3x3) -> bool`[src]

`impl RelativeEq<Matrix3x3> for Matrix3x3`[src]

`fn default_max_relative() -> Self::Epsilon`[src]

`fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon ) -> bool`[src]

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

`impl StructuralPartialEq for Matrix3x3`[src]

`impl Sub<Matrix3x3> for Matrix3x3`[src]

`type Output = Self`

The resulting type after applying the - operator.

`fn sub(self, rhs: Matrix3x3) -> Self`[src]

`impl SubAssign<Matrix3x3> for Matrix3x3`[src]

`fn sub_assign(&mut self, rhs: Matrix3x3)`[src]

`impl UlpsEq<Matrix3x3> for Matrix3x3`[src]

`fn default_max_ulps() -> u32`[src]

`fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool`[src]

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

Auto Trait Implementations

`impl RefUnwindSafe for Matrix3x3`

`impl Send for Matrix3x3`

`impl Sync for Matrix3x3`

`impl Unpin for Matrix3x3`

`impl UnwindSafe for Matrix3x3`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into<U> for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom<U> for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

`impl<T, U> TryInto<U> for T where U: TryFrom<T>,` [src]

`type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]