Struct Vector2 

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

Fields

x: f32

y: f32

Implementations

impl Vector2

pub const ZERO: Self

The zero vector (0, 0).

pub const ONE: Self

The vector (1, 1).

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

Construct a new Vector2.

pub fn zero() -> Self

Zero vector. (raymath Vector2Zero)

pub fn one() -> Self

Vector with both components set to 1. (raymath Vector2One)

pub fn add_value(self, add: f32) -> Self

Add scalar to both components. (raymath Vector2AddValue)

pub fn sub_value(self, sub: f32) -> Self

Subtract scalar from both components. (raymath Vector2SubtractValue)

pub fn length(self) -> f32

Vector length. (raymath Vector2Length)

pub fn length_sqr(self) -> f32

Squared vector length. (raymath Vector2LengthSqr)

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

Dot product. (raymath Vector2DotProduct)

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

Cross product (scalar). (raymath Vector2CrossProduct)

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

Distance between two vectors. (raymath Vector2Distance)

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

Squared distance between two vectors. (raymath Vector2DistanceSqr)

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

Angle between two vectors (radians). (raymath Vector2Angle)

pub fn line_angle(start: Vector2, end: Vector2) -> f32

Angle of line defined by two points. (raymath Vector2LineAngle)

pub fn scale(self, scale: f32) -> Self

Scale vector by scalar. (raymath Vector2Scale)

pub fn multiply(self, other: Vector2) -> Self

Component-wise multiply. (raymath Vector2Multiply)

pub fn negate(self) -> Self

Negate vector. (raymath Vector2Negate)

pub fn divide(self, other: Vector2) -> Self

Component-wise divide. (raymath Vector2Divide)

pub fn normalize(self) -> Self

Normalize vector. (raymath Vector2Normalize)

pub fn transform(self, mat: Matrix) -> Self

Transform by matrix. (raymath Vector2Transform)

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

Linear interpolation. (raymath Vector2Lerp)

pub fn reflect(self, normal: Vector2) -> Self

Reflect vector about normal. (raymath Vector2Reflect)

pub fn min(self, other: Vector2) -> Self

Component-wise minimum. (raymath Vector2Min)

pub fn max(self, other: Vector2) -> Self

Component-wise maximum. (raymath Vector2Max)

pub fn rotate(self, angle: f32) -> Self

Rotate by angle (radians). (raymath Vector2Rotate)

pub fn move_towards(self, target: Vector2, max_distance: f32) -> Self

Move towards target by at most maxDistance. (raymath Vector2MoveTowards)

pub fn invert(self) -> Self

Invert components (1/x, 1/y). (raymath Vector2Invert)

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

Clamp components between min and max vectors. (raymath Vector2Clamp)

pub fn clamp_value(self, min: f32, max: f32) -> Self

Clamp length between min and max scalars. (raymath Vector2ClampValue)

pub fn equals(self, other: Vector2) -> bool

Approximate equality (uses raymath epsilon). (raymath Vector2Equals)

pub fn refract(self, n: Vector2, r: f32) -> Self

Refract through surface with index ratio r. (raymath Vector2Refract)

Trait Implementations

impl Add for Vector2

type Output = Vector2

The resulting type after applying the + operator.

fn add(self, rhs: Vector2) -> Vector2

Performs the + operation.

impl AddAssign for Vector2

fn add_assign(&mut self, rhs: Vector2)

Performs the += operation.

impl Clone for Vector2

fn clone(&self) -> Vector2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Vector2

impl Debug for Vector2

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

Formats the value using the given formatter.

impl Default for Vector2

fn default() -> Vector2

Returns the “default value” for a type.

impl Div for Vector2

type Output = Vector2

The resulting type after applying the / operator.

fn div(self, rhs: Vector2) -> Vector2

Performs the / operation.

impl From<(f32, f32)> for Vector2

fn from((x, y): (f32, f32)) -> Self

Construct from an (x, y) tuple.

impl From<[f32; 2]> for Vector2

fn from([x, y]: [f32; 2]) -> Self

Construct from an [x, y] array.

impl Mul for Vector2

type Output = Vector2

The resulting type after applying the * operator.

fn mul(self, rhs: Vector2) -> Vector2

Performs the * operation.

impl Mul<f32> for Vector2

type Output = Vector2

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Vector2

Performs the * operation.

impl MulAssign<f32> for Vector2

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl Neg for Vector2

type Output = Vector2

The resulting type after applying the - operator.

fn neg(self) -> Vector2

Performs the unary - operation.

impl PartialEq for Vector2

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

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

impl StructuralPartialEq for Vector2

impl Sub for Vector2

type Output = Vector2

The resulting type after applying the - operator.

fn sub(self, rhs: Vector2) -> Vector2

Performs the - operation.

impl SubAssign for Vector2

fn sub_assign(&mut self, rhs: Vector2)

Performs the -= operation.