Struct gdnative::core_types::Basis

#[repr(C)]
pub struct Basis {
    pub elements: [Vector3; 3],
}

A 3x3 matrix, typically used as an orthogonal basis for Transform.

The basis vectors are the column vectors of the matrix, while the elements field represents the row vectors.

See also Basis in the Godot API doc.

Fields

elements: [Vector3; 3]

Matrix rows. These are not the basis vectors!

This is a transposed view for performance.
To read basis vectors, see a(), b(), c().
To write them, see set_a(), set_b(), set_c().

Implementations

impl Basis

pub const IDENTITY: Basis = Self{ elements: [Vector3::new(1.0, 0.0, 0.0), Vector3::new(0.0, 1.0, 0.0), Vector3::new(0.0, 0.0, 1.0)],}

The identity basis. Basis vectors are unit vectors along each axis X, Y and Z.

Equivalent to calling Basis::default().

pub const FLIP_X: Basis = Self::from_diagonal(Vector3::new(-1.0, 1.0, 1.0))

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

pub const FLIP_Y: Basis = Self::from_diagonal(Vector3::new(1.0, -1.0, 1.0))

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

pub const FLIP_Z: Basis = Self::from_diagonal(Vector3::new(1.0, 1.0, -1.0))

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

pub const fn from_basis_vectors(a: Vector3, b: Vector3, c: Vector3) -> Basis

Constructs a basis matrix from 3 linearly independent basis vectors (matrix columns).

This is the typical way to construct a basis. If you want to fill in the elements one-by-one, consider using Self::from_rows().

pub const fn from_rows(
    x_components: Vector3,
    y_components: Vector3,
    z_components: Vector3
) -> Basis

Creates a basis from 3 row vectors. These are not basis vectors.

This constructor is mostly useful if you want to write matrix elements in matrix syntax:

let basis = Basis::from_rows(
    Vector3::new(a.x, b.x, c.x),
    Vector3::new(a.y, b.y, c.y),
    Vector3::new(a.z, b.z, c.z),
);

The vectors a, b and c are the basis vectors.
In this particular case, you could also use Self::from_basis_vectors(a, b, c) instead.

pub const fn from_diagonal(scale: Vector3) -> Basis

Creates a diagonal matrix from the given vector.

Can be used as a basis for a scaling transform. Each component of scale represents the scale factor in the corresponding direction.

pub fn from_euler(euler_angles: Vector3) -> Basis

Creates a rotation matrix from Euler angles.

The angle vector has XYZ components. However, the angles are applied in YXZ convention: first Z, then X, and Y last.

pub fn from_quat(quat: Quat) -> Basis

Constructs a pure rotation basis matrix from the given quaternion.

pub fn from_axis_angle(axis: Vector3, phi: f32) -> Basis

Rotation matrix from axis and angle.

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

Panics

If axis is not normalized.

pub fn inverted(&self) -> Basis

Returns the inverse of the matrix.

Panics

If the determinant of self is zero.

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 orthonormalized(&self) -> Basis

Returns an orthonormalized version of the matrix: 3 orthogonal basis vectors of unit length.

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

Returns true if self and other are approximately equal.

pub fn rotated(&self, axis: Vector3, phi: f32) -> Basis

Multiplies the matrix from left with 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 scale(&self) -> Vector3

Returns the scale of the matrix.

pub fn scaled(&self, scale: Vector3) -> Basis

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

pub fn to_quat(&self) -> Quat

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_euler(&self) -> Vector3

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: Vector3) -> Vector3

Returns a vector transformed (multiplied) by the matrix.

pub fn xform_inv(&self, v: Vector3) -> Vector3

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 a(&self) -> Vector3

Get the 1st basis vector (first column vector of the matrix).

pub fn set_a(&mut self, v: Vector3)

Set the 1st basis vector (first column vector of the matrix).

pub fn b(&self) -> Vector3

Get the 2nd basis vector (second column vector of the matrix).

pub fn set_b(&mut self, v: Vector3)

Set the 2nd basis vector (second column vector of the matrix).

pub fn c(&self) -> Vector3

Get the 3rd basis vector (third column vector of the matrix).

pub fn set_c(&mut self, v: Vector3)

Set the 3rd basis vector (third column vector 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 CoerceFromVariant for Basis

fn coerce_from_variant(v: &Variant) -> 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<'de> Deserialize<'de> for Basis

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

Deserialize this value from the given Serde deserializer.

impl Export for Basis

type Hint = NoHint

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 Mul<Vector3> for Basis

type Output = Vector3

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: <Basis as Mul<Vector3>>::Output
) -> <Basis as Mul<Vector3>>::Output

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: &Rhs) -> bool

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

impl Serialize for Basis

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 ToVariant for Basis

fn to_variant(&self) -> Variant

impl Copy for Basis

impl StructuralPartialEq for Basis