Struct Vector4

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

Expand description

Vector used for 4D math using floating point coordinates.

4-element structure that can be used to represent any quadruplet of numeric values.

It uses floating-point coordinates of 32-bit precision, unlike the engine’s float type which is always 64-bit. The engine can be compiled with the option precision=double to use 64-bit vectors; use the gdext library with the double-precision feature in that case.

Conversions are provided via various from_* and to_* functions, not via the From trait. This encourages new() as the main way to construct vectors, is explicit about the conversion taking place, needs no type inference, and works in const contexts.

§Navigation to `impl` blocks within this page

Constants
Constructors and general vector functions
Specialized Vector4 functions
Float-specific functions
4D functions
3D and 4D functions
Trait impls + operators

§All vector types

Dimension	Floating-point	Integer
2D	`Vector2`	`Vector2i`
3D	`Vector3`	`Vector3i`
4D	`Vector4`	`Vector4i`

§Godot docs

Vector4 (stable)

Fields§

§x: f32

The vector’s X component.

§y: f32

The vector’s Y component.

§z: f32

The vector’s Z component.

§w: f32

The vector’s W component.

Implementations§

§

impl Vector4

§Constants

pub const ZERO: Vector4 = _

Zero vector, a vector with all components set to 0.

pub const ONE: Vector4 = _

One vector, a vector with all components set to 1.

pub const INF: Vector4 = _

Infinity vector, a vector with all components set to real::INFINITY.

§

impl Vector4

§Constructors and general vector functions

The following associated functions and methods are available on all vectors (2D, 3D, 4D; float and int).

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

Creates a vector with the given components.

pub const fn splat(v: f32) -> Vector4

Creates a vector with all components set to v.

pub const fn from_tuple(tuple: (f32, f32, f32, f32)) -> Vector4

Creates a vector from the given tuple.

pub const fn from_array(array: [f32; 4]) -> Vector4

Creates a vector from the given array.

pub const fn to_tuple(&self) -> (f32, f32, f32, f32)

Returns a tuple with the components of the vector.

pub const fn to_array(&self) -> [f32; 4]

Returns an array with the components of the vector.

pub fn abs(self) -> Vector4

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

pub fn clamp(self, min: Vector4, max: Vector4) -> Vector4

Returns a new vector with all components clamped between the components of min and max.

§Panics

If min > max, min is NaN, or max is NaN.

pub fn length(self) -> f32

Returns the length (magnitude) of this vector.

pub fn length_squared(self) -> f32

Squared length (squared magnitude) of this vector.

Runs faster than length(), so prefer it if you need to compare vectors or need the squared distance for some formula.

pub fn coord_min(self, other: Vector4) -> Vector4

Returns a new vector containing the minimum of the two vectors, component-wise.

You may consider using the fully-qualified syntax Vector4::coord_min(a, b) for symmetry.

pub fn coord_max(self, other: Vector4) -> Vector4

Returns a new vector containing the maximum of the two vectors, component-wise.

You may consider using the fully-qualified syntax Vector4::coord_max(a, b) for symmetry.

pub fn sign(self) -> Vector4

Returns a new vector with each component set to 1 if the component is positive, -1 if negative, and 0 if zero.

§

impl Vector4

§Specialized `Vector4` functions

pub const fn from_vector4i(v: Vector4i) -> Vector4

👎Deprecated: Moved to Vector4i::cast_float()

§

impl Vector4

§Float-specific functions

The following methods are only available on floating-point vectors.

pub const fn cast_int(self) -> Vector4i

Converts to a vector with integer components, using as casts.

pub fn floor(self) -> Vector4

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

pub fn ceil(self) -> Vector4

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

pub fn cubic_interpolate( self, b: Vector4, pre_a: Vector4, post_b: Vector4, weight: f32, ) -> Vector4

Cubic interpolation between self and b using pre_a and post_b as handles, and returns the result at position weight.

weight is on the range of 0.0 to 1.0, representing the amount of interpolation.

pub fn cubic_interpolate_in_time( self, b: Vector4, pre_a: Vector4, post_b: Vector4, weight: f32, b_t: f32, pre_a_t: f32, post_b_t: f32, ) -> Vector4

Cubic interpolation between self and b using pre_a and post_b as handles, and returns the result at position weight.

weight is on the range of 0.0 to 1.0, representing the amount of interpolation. It can perform smoother interpolation than cubic_interpolate() by the time values.