Struct gdnative::core_types::Quat

#[repr(C)]
pub struct Quat {
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub w: f32,
}

Quaternion, used to represent 3D rotations.

Quaternions need to be normalized before all operations.

See also Quat in the Godot API doc.

Fields

x: f32

y: f32

z: f32

w: f32

Implementations

impl Quat

Helper methods for Quat.

See the official Godot documentation.

pub const IDENTITY: Quat = Self::new(0.0, 0.0, 0.0, 1.0)

The identity quaternion, representing no rotation. Equivalent to an identity Basis matrix. If a vector is transformed by an identity quaternion, it will not change.

pub const fn new(x: f32, y: f32, z: f32, w: f32) -> Quat

Constructs a quaternion defined by the given values.

pub fn from_basis(basis: &Basis) -> Quat

Constructs a quaternion from the given Basis

pub fn from_euler(euler: Vector3) -> Quat

Constructs a quaternion that will perform a rotation specified by Euler angles (in the YXZ convention: when decomposing, first Z, then X, and Y last), given in the vector format as (X angle, Y angle, Z angle).

pub fn from_axis_angle(axis: Vector3, angle: f32) -> Quat

Constructs a quaternion that will rotate around the given axis by the specified angle. The axis must be a normalized vector.

pub fn cubic_slerp(self, b: Quat, pre_a: Quat, post_b: Quat, t: f32) -> Quat

Performs a cubic spherical interpolation between quaternions pre_a, this quaternion, b, and post_b, by the given amount t.

pub fn dot(self, b: Quat) -> f32

Returns the dot product of two quaternions.

pub fn to_euler(self) -> Vector3

Returns Euler angles (in the YXZ convention: when decomposing, first Z, then X, and Y last) corresponding to the rotation represented by the unit quaternion. Returned vector contains the rotation angles in the format (X angle, Y angle, Z angle).

pub fn inverse(self) -> Quat

Returns the inverse of the quaternion.

pub fn is_equal_approx(self, to: Quat) -> bool

Returns true if this quaternion and quat are approximately equal, by running is_equal_approx on each component

pub fn is_normalized(self) -> bool

Returns whether the quaternion is normalized or not.

pub fn length(self) -> f32

Returns the length of the quaternion.

pub fn length_squared(self) -> f32

Returns the length of the quaternion, squared.

pub fn normalized(self) -> Quat

Returns a copy of the quaternion, normalized to unit length.

Normalization is necessary before transforming vectors through xform() or *.

pub fn slerp(self, b: Quat, t: f32) -> Quat

Returns the result of the spherical linear interpolation between this quaternion and to by amount weight.

Note: Both quaternions must be normalized.

pub fn slerpni(self, b: Quat, t: f32) -> Quat

Returns the result of the spherical linear interpolation between this quaternion and t by amount t, but without checking if the rotation path is not bigger than 90 degrees.

pub fn xform(self, v: Vector3) -> Vector3

Returns a vector transformed (multiplied) by this quaternion. This is the same as mul

Note: The quaternion must be normalized.

Trait Implementations

impl Clone for Quat

fn clone(&self) -> Quat

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CoerceFromVariant for Quat

fn coerce_from_variant(v: &Variant) -> Quat

impl Debug for Quat

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Quat

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

Deserialize this value from the given Serde deserializer.

impl Export for Quat

type Hint = NoHint

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

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

Returns ExportInfo given an optional typed hint.

impl FromVariant for Quat

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

impl Mul<Quat> for Quat

fn mul(self, with: Quat) -> Quat

Returns another quaternion transformed (multiplied) by this quaternion.

type Output = Quat

The resulting type after applying the * operator.

impl Mul<Vector3> for Quat

fn mul(self, with: Vector3) -> Vector3

Returns a vector transformed (multiplied) by this quaternion. This is the same as xform

Note: The quaternion must be normalized.

type Output = Vector3

The resulting type after applying the * operator.

impl Neg for Quat

type Output = Quat

The resulting type after applying the - operator.

fn neg(self) -> Quat

Performs the unary - operation.

impl PartialEq<Quat> for Quat

fn eq(&self, other: &Quat) -> 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 Quat

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 Quat

fn to_variant(&self) -> Variant

impl Copy for Quat

impl StructuralPartialEq for Quat