Struct godot::builtin::Vector2

#[repr(C)]
pub struct Vector2 { pub x: f32, pub y: f32, }
Expand description

Vector used for 2D math using floating point coordinates.

2-element structure that can be used to represent positions in 2D space or any other pair 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.

See Vector2i for its integer counterpart.

Fields§

§x: f32

The vector’s X component.

§y: f32

The vector’s Y component.

Implementations§

§

impl Vector2

pub const ZERO: Vector2 = _

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

pub const ONE: Vector2 = _

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

§

impl Vector2

pub const INF: Vector2 = _

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

§

impl Vector2

pub const LEFT: Vector2 = _

Left unit vector. Represents the direction of left.

pub const RIGHT: Vector2 = _

Right unit vector. Represents the direction of right.

pub const UP: Vector2 = _

Up unit vector. Y is down in 2D, so this vector points -Y.

pub const DOWN: Vector2 = _

Down unit vector. Y is down in 2D, so this vector points +Y.

§

impl Vector2

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

Returns a vector with the given components.

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

Returns a new vector with all components set to v.

pub fn abs(self) -> Vector2

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

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

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 Self::length, so prefer it if you need to compare vectors or need the squared distance for some formula.

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

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

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

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

pub fn sign(self) -> Vector2

Returns a new vector with each component set to 1 if it’s positive, -1 if it’s negative, and 0 if it’s zero.

§

impl Vector2

pub fn ceil(self) -> Vector2

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

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

Performs a cubic interpolation between this vector 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: Vector2, pre_a: Vector2, post_b: Vector2, weight: f32, b_t: f32, pre_a_t: f32, post_b_t: f32, ) -> Vector2

Performs a cubic interpolation between this vector 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 Self::cubic_interpolate by the time values.

pub fn try_direction_to(self, to: Vector2) -> Option<Vector2>

Returns the normalized vector pointing from this vector to to or None, if self and to are equal.

This is equivalent to using (b - a).try_normalized(). See also direction_to().

pub fn direction_to(self, to: Vector2) -> Vector2

⚠️ Returns the normalized vector pointing from this vector to to.

This is equivalent to using (b - a).normalized(). See also try_direction_to().

§Panics

If self and to are equal.

pub fn distance_squared_to(self, to: Vector2) -> f32

Returns the squared distance between this vector and to.

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

pub fn distance_to(self, to: Vector2) -> f32

Returns the distance between this vector and to.

pub fn dot(self, with: Vector2) -> f32

Returns the dot product of this vector and with.

pub fn floor(self) -> Vector2

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

pub fn is_finite(self) -> bool

Returns true if each component of this vector is finite.

pub fn is_normalized(self) -> bool

Returns true if the vector is normalized, i.e. its length is approximately equal to 1.

pub fn is_zero_approx(self) -> bool

Returns true if this vector’s values are approximately zero.

This method is faster than using approx_eq() with one value as a zero vector.

pub fn lerp(self, other: Vector2, weight: f32) -> Vector2

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

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

pub fn try_normalized(self) -> Option<Vector2>

Returns the vector scaled to unit length or None, if called on a zero vector.

Computes self / self.length(). See also normalized() and is_normalized().

pub fn normalized(self) -> Vector2

⚠️ Returns the vector scaled to unit length.

Computes self / self.length(). See also try_normalized() and is_normalized().

§Panics

If called on a zero vector.

pub fn normalized_or_zero(self) -> Vector2

Returns the vector scaled to unit length or Self::ZERO, if called on a zero vector.

Computes self / self.length(). See also try_normalized() and is_normalized().

pub fn posmod(self, pmod: f32) -> Vector2

Returns a vector composed of the FloatExt::fposmod of this vector’s components and pmod.

pub fn posmodv(self, modv: Vector2) -> Vector2

Returns a vector composed of the FloatExt::fposmod of this vector’s components and modv’s components.

pub fn round(self) -> Vector2

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

pub fn snapped(self, step: Vector2) -> Vector2

A new vector with each component snapped to the closest multiple of the corresponding component in step.

§

impl Vector2

pub fn aspect(self) -> f32

Returns the aspect ratio of this vector, the ratio of Self::x to Self::y.

pub fn max_axis(self) -> Option<Vector2Axis>

Returns the axis of the vector’s highest value. See Vector2Axis enum. If all components are equal, this method returns None.

To mimic Godot’s behavior, unwrap this function’s result with unwrap_or(Vector2Axis::X).

pub fn min_axis(self) -> Option<Vector2Axis>

Returns the axis of the vector’s lowest value. See Vector2Axis enum. If all components are equal, this method returns None.

To mimic Godot’s behavior, unwrap this function’s result with unwrap_or(Vector2Axis::Y).

§

impl Vector2

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

Returns the angle to the given vector, in radians.

pub fn bezier_derivative( self, control_1: Vector2, control_2: Vector2, end: Vector2, t: f32, ) -> Vector2

Returns the derivative at the given t on the Bézier curve defined by this vector and the given control_1, control_2, and end points.

pub fn bezier_interpolate( self, control_1: Vector2, control_2: Vector2, end: Vector2, t: f32, ) -> Vector2

Returns the point at the given t on the Bézier curve defined by this vector and the given control_1, control_2, and end points.

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

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

§Panics

If n is not normalized.

pub fn limit_length(self, length: Option<f32>) -> Vector2

Returns the vector with a maximum length by limiting its length to length.

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

Returns a new vector moved toward to by the fixed delta amount. Will not go past the final value.

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

Returns the result of projecting the vector onto the given vector b.

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

Returns the result of reflecting the vector defined by the given direction vector n.

§Panics

If n is not normalized.

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

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

§Panics

If n is not normalized.

§

impl Vector2

pub const fn from_vector2i(v: Vector2i) -> Vector2

Constructs a new Vector2 from a Vector2i.

pub fn angle(self) -> f32

Returns this vector’s angle with respect to the positive X axis, or (1.0, 0.0) vector, in radians.

For example, Vector2::RIGHT.angle() will return zero, Vector2::DOWN.angle() will return PI / 2 (a quarter turn, or 90 degrees), and Vector2::new(1.0, -1.0).angle() will return -PI / 4 (a negative eighth turn, or -45 degrees).

Illustration of the returned angle.

Equivalent to the result of y.atan2(x).

pub fn angle_to_point(self, to: Vector2) -> f32

Returns the angle to the given vector, in radians.

Illustration of the returned angle.

pub fn cross(self, with: Vector2) -> f32

Returns the 2D analog of the cross product for this vector and with.

This is the signed area of the parallelogram formed by the two vectors. If the second vector is clockwise from the first vector, then the cross product is the positive area. If counter-clockwise, the cross product is the negative area. If the two vectors are parallel this returns zero, making it useful for testing if two vectors are parallel.

Note: Cross product is not defined in 2D mathematically. This method embeds the 2D vectors in the XY plane of 3D space and uses their cross product’s Z component as the analog.

pub fn from_angle(angle: f32) -> Vector2

Creates a unit Vector2 rotated to the given angle in radians. This is equivalent to doing Vector2::new(angle.cos(), angle.sin()) or Vector2::RIGHT.rotated(angle).

use godot::prelude::*;

let a = Vector2::from_angle(0.0);                       // (1.0, 0.0)
let b = Vector2::new(1.0, 0.0).angle();                 // 0.0
let c = Vector2::from_angle(real_consts::PI / 2.0);     // (0.0, 1.0)

pub fn orthogonal(self) -> Vector2

Returns a perpendicular vector rotated 90 degrees counter-clockwise compared to the original, with the same length.

pub fn rotated(self, angle: f32) -> Vector2

Returns the result of rotating this vector by angle (in radians).

pub fn slerp(self, to: Vector2, weight: f32) -> Vector2

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

This method also handles interpolating the lengths if the input vectors have different lengths. For the special case of one or both input vectors having zero length, this method behaves like Vector2::lerp.

Trait Implementations§

§

impl Add for Vector2

§

type Output = Vector2

The resulting type after applying the + operator.
§

fn add(self, rhs: Vector2) -> <Vector2 as Add>::Output

Performs the + operation. Read more
§

impl AddAssign for Vector2

§

fn add_assign(&mut self, rhs: Vector2)

Performs the += operation. Read more
§

impl ApproxEq for Vector2

§

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

Returns true if this vector and to are approximately equal.

§

impl Clone for Vector2

§

fn clone(&self) -> Vector2

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
§

impl Debug for Vector2

§

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

Formats the value using the given formatter. Read more
§

impl Default for Vector2

§

fn default() -> Vector2

Returns the “default value” for a type. Read more
§

impl Display for Vector2

Formats the vector like Godot: (x, y).

§

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

Formats the value using the given formatter. Read more
§

impl Div<f32> for Vector2

§

type Output = Vector2

The resulting type after applying the / operator.
§

fn div(self, rhs: f32) -> <Vector2 as Div<f32>>::Output

Performs the / operation. Read more
§

impl Div for Vector2

§

type Output = Vector2

The resulting type after applying the / operator.
§

fn div(self, rhs: Vector2) -> <Vector2 as Div>::Output

Performs the / operation. Read more
§

impl DivAssign<f32> for Vector2

§

fn div_assign(&mut self, rhs: f32)

Performs the /= operation. Read more
§

impl DivAssign for Vector2

§

fn div_assign(&mut self, rhs: Vector2)

Performs the /= operation. Read more
§

impl Export for Vector2

§

fn default_export_info() -> PropertyHintInfo

The export info to use for an exported field of this type, if no other export info is specified.
§

impl Extend<Vector2> for PackedVector2Array

Extends aPackedVector2Array with the contents of an iterator

§

fn extend<I>(&mut self, iter: I)
where I: IntoIterator<Item = Vector2>,

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)
Reserves capacity in a collection for the given number of additional elements. Read more
§

impl FromGodot for Vector2

§

fn try_from_godot( via: <Vector2 as GodotConvert>::Via, ) -> Result<Vector2, ConvertError>

Converts the Godot representation to this type, returning Err on failure.
§

fn from_godot(via: Self::Via) -> Self

⚠️ Converts the Godot representation to this type. Read more
§

fn try_from_variant(variant: &Variant) -> Result<Self, ConvertError>

Performs the conversion from a Variant, returning Err on failure.
§

fn from_variant(variant: &Variant) -> Self

⚠️ Performs the conversion from a Variant. Read more
§

impl FromIterator<Vector2> for PackedVector2Array

Creates a PackedVector2Array from an iterator.

§

fn from_iter<I>(iter: I) -> PackedVector2Array
where I: IntoIterator<Item = Vector2>,

Creates a value from an iterator. Read more
§

impl GodotConvert for Vector2

§

type Via = Vector2

The type through which Self is represented in Godot.
§

impl Index<Vector2Axis> for Vector2

§

type Output = f32

The returned type after indexing.
§

fn index(&self, axis: Vector2Axis) -> &f32

Performs the indexing (container[index]) operation. Read more
§

impl IndexMut<Vector2Axis> for Vector2

§

fn index_mut(&mut self, axis: Vector2Axis) -> &mut f32

Performs the mutable indexing (container[index]) operation. Read more
§

impl Mul<Vector2> for Transform2D

§

type Output = Vector2

The resulting type after applying the * operator.
§

fn mul(self, rhs: Vector2) -> <Transform2D as Mul<Vector2>>::Output

Performs the * operation. Read more
§

impl Mul<f32> for Vector2

§

type Output = Vector2

The resulting type after applying the * operator.
§

fn mul(self, rhs: f32) -> <Vector2 as Mul<f32>>::Output

Performs the * operation. Read more
§

impl Mul for Vector2

§

type Output = Vector2

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl MulAssign<f32> for Vector2

§

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation. Read more
§

impl MulAssign for Vector2

§

fn mul_assign(&mut self, rhs: Vector2)

Performs the *= operation. Read more
§

impl Neg for Vector2

§

type Output = Vector2

The resulting type after applying the - operator.
§

fn neg(self) -> <Vector2 as Neg>::Output

Performs the unary - operation. Read more
§

impl PartialEq for Vector2

§

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

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

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<'a> Product<&'a Vector2> for Vector2

§

fn product<I>(iter: I) -> Vector2
where I: Iterator<Item = &'a Vector2>,

Element-wise product of all vectors in the iterator.

§

impl Product for Vector2

§

fn product<I>(iter: I) -> Vector2
where I: Iterator<Item = Vector2>,

Element-wise product of all vectors in the iterator.

§

impl Sub for Vector2

§

type Output = Vector2

The resulting type after applying the - operator.
§

fn sub(self, rhs: Vector2) -> <Vector2 as Sub>::Output

Performs the - operation. Read more
§

impl SubAssign for Vector2

§

fn sub_assign(&mut self, rhs: Vector2)

Performs the -= operation. Read more
§

impl<'a> Sum<&'a Vector2> for Vector2

§

fn sum<I>(iter: I) -> Vector2
where I: Iterator<Item = &'a Vector2>,

Element-wise sum of all vectors in the iterator.

§

impl Sum for Vector2

§

fn sum<I>(iter: I) -> Vector2
where I: Iterator<Item = Vector2>,

Element-wise sum of all vectors in the iterator.

§

impl ToGodot for Vector2

§

fn to_godot(&self) -> <Vector2 as GodotConvert>::Via

Converts this type to the Godot type by reference, usually by cloning.
§

fn into_godot(self) -> <Vector2 as GodotConvert>::Via

Converts this type to the Godot type. Read more
§

fn to_variant(&self) -> Variant

Converts this type to a Variant.
§

impl TypeStringHint for Vector2

§

fn type_string() -> String

Returns the representation of this type as a type string. Read more
§

impl Var for Vector2

§

impl ArrayElement for Vector2

§

impl Copy for Vector2

§

impl GodotType for Vector2

§

impl StructuralPartialEq for Vector2

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Copy,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.