Struct gdnative::core_types::Vector3

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

3D vector class.

See also Vector3 in the Godot API doc.

Fields

x: f32

y: f32

z: f32

Implementations

impl Vector3

Helper methods for Vector3.

See the official Godot documentation.

pub const ZERO: Vector3 = Self::new(0.0, 0.0, 0.0)

The zero vector.

pub const ONE: Vector3 = Self::new(1.0, 1.0, 1.0)

A vector with all components set to 1. Typically used for scaling.

pub const INF: Vector3 = Self::new(f32::INFINITY, f32::INFINITY, f32::INFINITY)

A vector with all components set to +infinity.

pub const LEFT: Vector3 = Self::new(-1.0, 0.0, 0.0)

Unit vector in -X direction.

pub const RIGHT: Vector3 = Self::new(1.0, 0.0, 0.0)

Unit vector in +X direction.

pub const UP: Vector3 = Self::new(0.0, 1.0, 0.0)

Unit vector in +Y direction.

pub const DOWN: Vector3 = Self::new(0.0, -1.0, 0.0)

Unit vector in -Y direction.

pub const FORWARD: Vector3 = Self::new(0.0, 0.0, -1.0)

Unit vector in -Z direction.

pub const BACK: Vector3 = Self::new(0.0, 0.0, 1.0)

Unit vector in +Z direction.

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

Returns a Vector3 with the given components.

pub fn abs(self) -> Vector3

Returns a new vector with all components in absolute values (i.e. positive).

pub fn angle_to(self, to: Vector3) -> f32

Returns the minimum angle to the given vector, in radians.

pub fn bounce(self, n: Vector3) -> Vector3

Returns the vector “bounced off” from a plane defined by the given normal.

pub fn ceil(self) -> Vector3

Returns a new vector with all components rounded up (towards positive infinity).

pub fn cross(self, b: Vector3) -> Vector3

Returns the cross product of this vector and b.

pub fn cubic_interpolate(
    self,
    b: Vector3,
    pre_a: Vector3,
    post_b: Vector3,
    t: f32
) -> Vector3

Performs a cubic interpolation between vectors pre_a, a, b, post_b (a is current), by the given amount t. t is on the range of 0.0 to 1.0, representing the amount of interpolation.

pub fn direction_to(self, other: Vector3) -> Vector3

Returns the normalized vector pointing from this vector to other.

pub fn distance_squared_to(self, other: Vector3) -> f32

Returns the squared distance to other.

This method runs faster than distance_to, so prefer it if you need to compare vectors or need the squared distance for some formula.

pub fn distance_to(self, other: Vector3) -> f32

Returns the distance to other.

pub fn dot(self, other: Vector3) -> f32

Returns the dot product of this vector and b. This can be used to compare the angle between two vectors. For example, this can be used to determine whether an enemy is facing the player.

The dot product will be 0 for a straight angle (90 degrees), greater than 0 for angles narrower than 90 degrees and lower than 0 for angles wider than 90 degrees.

When using unit (normalized) vectors, the result will always be between -1.0 (180 degree angle) when the vectors are facing opposite directions, and 1.0 (0 degree angle) when the vectors are aligned.

Note: a.dot(b) is equivalent to b.dot(a).

pub fn floor(self) -> Vector3

Returns a new vector with all components rounded down (towards negative infinity).

pub fn inverse(self) -> Vector3

Returns the inverse of the vector. This is the same as Vector3::new(1.0 / self.x, 1.0 / self.y, 1.0 / self.z).

pub fn is_equal_approx(self, v: Vector3) -> bool

Returns true if this vector and v are approximately equal, by running relative_eq on each component.

pub fn is_normalized(self) -> bool

Returns true if the vector is normalized, and false otherwise.

pub fn length(self) -> f32

Returns the length (magnitude) of this vector.

pub fn length_squared(self) -> f32

Returns the squared length (squared magnitude) of this vector.

This method runs faster than length, so prefer it if you need to compare vectors or need the squared distance for some formula.

pub fn linear_interpolate(self, b: Vector3, t: f32) -> Vector3

Returns the result of the linear interpolation between this vector and b by amount t. t is on the range of 0.0 to 1.0, representing the amount of interpolation.

pub fn max_axis(self) -> Axis

Returns the axis of the vector’s largest value. See Axis enum.

If multiple components are equal, this method returns in preferred order Axis::X, Axis::Y, Axis::Z.

pub fn min_axis(self) -> Axis

Returns the axis of the vector’s smallest value. See Axis enum.

If multiple components are equal, this method returns in preferred order Axis::X, Axis::Y, Axis::Z.

pub fn move_toward(self, to: Vector3, delta: f32) -> Vector3

Moves this vector toward to by the fixed delta amount.

pub fn normalized(self) -> Vector3

Returns the vector scaled to unit length. Equivalent to v / v.length().

pub fn outer(self, b: Vector3) -> Basis

Returns the outer product with b.

pub fn posmod(self, rem: f32) -> Vector3

Returns a vector composed of the rem_euclid of this vector’s components and mod.

pub fn posmodv(self, remv: Vector3) -> Vector3

Returns a vector composed of the rem_euclid of this vector’s components and remv components.

pub fn project(self, b: Vector3) -> Vector3

Returns this vector projected onto another vector b.

pub fn reflect(self, n: Vector3) -> Vector3

Returns this vector reflected from a plane defined by the given normal.

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

Rotates this vector around a given axis by phi radians. The axis must be a normalized vector.

pub fn round(self) -> Vector3

Returns this vector with all components rounded to the nearest integer, with halfway cases rounded away from zero.

pub fn sign(self) -> Vector3

Returns a vector with each component set to one or negative one, depending on the signs of this vector’s components, or zero if the component is zero, by calling signum on each component.

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

Returns the result of spherical linear interpolation between this vector and b, by amount t. t is on the range of 0.0 to 1.0, representing the amount of interpolation.

Note: Both vectors must be normalized.

pub fn slide(self, n: Vector3) -> Vector3

Returns this vector slid along a plane defined by the given normal.

pub fn snapped(self, by: Vector3) -> Vector3

Returns this vector with each component snapped to the nearest multiple of step. This can also be used to round to an arbitrary number of decimals.

pub fn to_diagonal_matrix(self) -> Basis

Returns a diagonal matrix with the vector as main diagonal.

This is equivalent to a Basis with no rotation or shearing and this vector’s components set as the scale.

Trait Implementations

impl Add<Vector3> for Vector3

type Output = Vector3

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<Vector3> for Vector3

fn add_assign(&mut self, with: Vector3)

Performs the += operation.

impl AsRef<[f32; 3]> for Vector3

fn as_ref(&self) -> &[f32; 3]

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

impl Clone for Vector3

fn clone(&self) -> Vector3

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CoerceFromVariant for Vector3

fn coerce_from_variant(v: &Variant) -> Vector3

impl Debug for Vector3

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

Formats the value using the given formatter.

impl Default for Vector3

fn default() -> Vector3

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Vector3

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

Deserialize this value from the given Serde deserializer.

impl Div<Vector3> for Vector3

type Output = Vector3

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f32> for Vector3

type Output = Vector3

The resulting type after applying the / operator.

fn div(self, with: f32) -> Vector3

Performs the / operation.

impl DivAssign<Vector3> for Vector3

fn div_assign(&mut self, with: Vector3)

Performs the /= operation.

impl DivAssign<f32> for Vector3

fn div_assign(&mut self, with: f32)

Performs the /= operation.

impl Export for Vector3

type Hint = NoHint

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

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

Returns ExportInfo given an optional typed hint.

impl FromVariant for Vector3

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

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

type Output = Vector3

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for Vector3

type Output = Vector3

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<Vector3> for Vector3

fn mul_assign(&mut self, with: Vector3)

Performs the *= operation.

impl MulAssign<f32> for Vector3

fn mul_assign(&mut self, with: f32)

Performs the *= operation.

impl Neg for Vector3

type Output = Vector3

The resulting type after applying the - operator.

fn neg(self) -> Vector3

Performs the unary - operation.

impl PartialEq<Vector3> for Vector3

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

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 Sub<Vector3> for Vector3

type Output = Vector3

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<Vector3> for Vector3

fn sub_assign(&mut self, with: Vector3)

Performs the -= operation.

impl ToVariant for Vector3

fn to_variant(&self) -> Variant

impl Copy for Vector3

impl PoolElement for Vector3

impl StructuralPartialEq for Vector3