Struct gdnative::prelude::Basis

#[repr(C)]pub struct Basis {
    pub elements: [Vector3D<f32, UnknownUnit>; 3],
}

A 3x3 matrix.

Fields

elements: [Vector3D<f32, UnknownUnit>; 3]

Implementations

impl Basis

pub const fn identity() -> Basis

The identity basis.

Identical to calling Basis::default().

pub const fn flip_x() -> Basis

The basis that will flip something along the X Axis when used in a transformation.

pub const fn flip_y() -> Basis

The basis that will flip something along the Y axis when used in a transformation.

pub const fn flip_z() -> Basis

The basis that will flip something along the Z axis when used in a transformation.

pub const fn from_diagonal(p_diag: Vector3D<f32, UnknownUnit>) -> Basis

Creates a Basis from the given Vector3

pub const fn from_elements(elements: [Vector3D<f32, UnknownUnit>; 3]) -> Basis

Creates a Basis from 3 Vector3s

pub fn from_euler(euler: Vector3D<f32, UnknownUnit>) -> Basis

Creates a rotation matrix.

pub fn from_axis_angle(axis: &Vector3D<f32, UnknownUnit>, phi: f32) -> Basis

Rotation matrix from axis and angle.

See https://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_angle

Panics

If axis is not normalized.

pub fn invert(&mut self)

Inverts the matrix.

Panics

If the determinant of self is zero.

pub fn inverted(self) -> Basis

Returns the inverse of the matrix.

Panics

If the determinant of self is zero.

pub fn transpose(&mut self)

Transposes the matrix.

pub fn transposed(self) -> Basis

Returns the transposed version of the matrix.

pub fn determinant(&self) -> f32

Returns the determinant of the matrix.

pub fn orthonormalize(&mut self)

Orthonormalizes the matrix.

Performs a Gram-Schmidt orthonormalization on the basis of the matrix. This can be useful to call from time to time to avoid rounding errors for orthogonal matrices.

Panics

If the determinant of self is zero.

pub fn orthonormalized(self) -> Basis

Returns an orthonormalized version of the matrix.

See Basis::orthonormalize()

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

Returns true if self and other are approximately equal.

pub fn rotated(self, axis: Vector3D<f32, UnknownUnit>, phi: f32) -> Basis

Multiplies the matrix from left by the rotation matrix: M -> R.M

The main use of Basis is as a Transform.basis, which is used as the transformation matrix of the 3D object. rotated() here refers to rotation of the object (which is R * self), not the matrix itself.

pub fn rotate(&mut self, axis: Vector3D<f32, UnknownUnit>, phi: f32)

Rotates the matrix.

If object rotation is needed, see Basis::rotated()

pub fn to_quat(&self) -> Rotation3D<f32, UnknownUnit, UnknownUnit>

Converts matrix into a Quaternion

Quaternions are frequently used in 3D graphics, because they enable easy and cheap interpolation. However, they are less human-readable. For Euler angles, see Basis::to_euler().

Panics

If self is not normalized.

pub fn to_scale(&self) -> Vector3D<f32, UnknownUnit>

Returns the scale of the matrix.

pub fn scaled(self, scale: &Vector3D<f32, UnknownUnit>) -> Basis

Introduce an additional scaling specified by the given 3D scaling factor.

pub fn to_euler(&self) -> Vector3D<f32, UnknownUnit>

Returns the Basis’s rotation in the form of Euler angles.

In the YXZ convention: first Z, then X, and Y last.

The returned Vector3 contains the rotation angles in the format (X angle, Y angle, Z angle).

See Basis::to_quat if you need a quaternion instead.

pub fn xform(&self, v: Vector3D<f32, UnknownUnit>) -> Vector3D<f32, UnknownUnit>

Returns a vector transformed (multiplied) by the matrix.

pub fn xform_inv(
    &self,
    v: Vector3D<f32, UnknownUnit>
) -> Vector3D<f32, UnknownUnit>

Returns a vector transformed (multiplied) by the transposed matrix.

Note: This results in a multiplication by the inverse of the matrix only if it represents a rotation-reflection.

pub fn from_transform(
    transform: &Transform3D<f32, UnknownUnit, UnknownUnit>
) -> Basis

Creates a Basis from the rotation and scaling of the provided transform.

pub fn from_typed_transform<Src, Dst>(
    transform: &Transform3D<f32, Src, Dst>
) -> Basis

Creates a Basis from the rotation and scaling of the provided transform, in Dst space.

pub fn tdotx(&self, v: Vector3D<f32, UnknownUnit>) -> f32

Transposed dot product with the X Axis of the matrix.

pub fn tdoty(&self, v: Vector3D<f32, UnknownUnit>) -> f32

Transposed dot product with the Y axis of the matrix.

pub fn tdotz(&self, v: Vector3D<f32, UnknownUnit>) -> f32

Transposed dot product with the Z axis of the matrix.

pub fn x(&self) -> Vector3D<f32, UnknownUnit>

Get the X Axis of the matrix

pub fn set_x(&mut self, v: Vector3D<f32, UnknownUnit>)

Set the X Axis of the matrix

pub fn y(&self) -> Vector3D<f32, UnknownUnit>

Get the Y axis of the matrix

pub fn set_y(&mut self, v: Vector3D<f32, UnknownUnit>)

Set the Y axis of the matrix

pub fn z(&self) -> Vector3D<f32, UnknownUnit>

Get the Z axis of the matrix

pub fn set_z(&mut self, v: Vector3D<f32, UnknownUnit>)

Set the Z axis of the matrix

Trait Implementations

impl Clone for Basis

fn clone(&self) -> Basis

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Basis

impl Debug for Basis

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

Formats the value using the given formatter.

impl Default for Basis

fn default() -> Basis

Returns the "default value" for a type.

impl Export for Basis

type Hint = ()

A type-specific hint type that is valid for the type being exported.

fn export_info(_hint: Option<<Basis as Export>::Hint>) -> ExportInfo

Returns ExportInfo given an optional typed hint.

impl FromVariant for Basis

fn from_variant(variant: &Variant) -> Result<Basis, FromVariantError>

impl Mul<Basis> for Basis

type Output = Basis

The resulting type after applying the * operator.

fn mul(self, rhs: Basis) -> Basis

Performs the * operation.

impl PartialEq<Basis> for Basis

fn eq(&self, other: &Basis) -> bool

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

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

This method tests for !=.

impl StructuralPartialEq for Basis

impl ToVariant for Basis

fn to_variant(&self) -> Variant