Struct Vector4 

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

Fields

x: f32

y: f32

z: f32

w: f32

Implementations

impl Vector4

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

Construct a new Vector4.

pub fn zero() -> Self

Zero vector. (raymath Vector4Zero)

pub fn one() -> Self

Vector with all components set to 1. (raymath Vector4One)

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

Add scalar to all components. (raymath Vector4AddValue)

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

Subtract scalar from all components. (raymath Vector4SubtractValue)

pub fn length(self) -> f32

Vector length. (raymath Vector4Length)

pub fn length_sqr(self) -> f32

Squared vector length. (raymath Vector4LengthSqr)

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

Dot product. (raymath Vector4DotProduct)

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

Distance between two vectors. (raymath Vector4Distance)

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

Squared distance between two vectors. (raymath Vector4DistanceSqr)

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

Scale vector by scalar. (raymath Vector4Scale)

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

Component-wise multiply. (raymath Vector4Multiply)

pub fn negate(self) -> Self

Negate vector. (raymath Vector4Negate)

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

Component-wise divide. (raymath Vector4Divide)

pub fn normalize(self) -> Self

Normalize vector. (raymath Vector4Normalize)

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

Component-wise minimum. (raymath Vector4Min)

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

Component-wise maximum. (raymath Vector4Max)

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

Linear interpolation. (raymath Vector4Lerp)

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

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

pub fn invert(self) -> Self

Invert components (1/x, 1/y, 1/z, 1/w). (raymath Vector4Invert)

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

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

Trait Implementations

impl Add for Vector4

type Output = Vector4

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for Vector4

fn add_assign(&mut self, rhs: Vector4)

Performs the += operation.

impl Clone for Vector4

fn clone(&self) -> Vector4

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Vector4

impl Debug for Vector4

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

Formats the value using the given formatter.

impl Default for Vector4

fn default() -> Vector4

Returns the “default value” for a type.

impl Div for Vector4

type Output = Vector4

The resulting type after applying the / operator.

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

Performs the / operation.

impl From<(f32, f32, f32, f32)> for Vector4

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

Construct from an (x, y, z, w) tuple.

impl From<Color> for Vector4

fn from(v: Color) -> Self

Converts to this type from the input type.

impl From<Quaternion> for Vector4

fn from(q: Quaternion) -> Self

Converts to this type from the input type.

impl From<Vector4> for Quaternion

fn from(v: Vector4) -> Self

Converts to this type from the input type.

impl From<[f32; 4]> for Vector4

fn from([x, y, z, w]: [f32; 4]) -> Self

Construct from an [x, y, z, w] array.

impl Mul for Vector4

type Output = Vector4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for Vector4

type Output = Vector4

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<f32> for Vector4

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl Neg for Vector4

type Output = Vector4

The resulting type after applying the - operator.

fn neg(self) -> Vector4

Performs the unary - operation.

impl PartialEq for Vector4

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

impl Sub for Vector4

type Output = Vector4

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for Vector4

fn sub_assign(&mut self, rhs: Vector4)

Performs the -= operation.