Struct ludomath::vec2d::Vector

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

Represents a cartesian vector in the 2D euclidean plane.

Fields

x: f32

The X component of the vector.

y: f32

The Y component of the vector.

Methods

impl Vector

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

Constructs a new vector.

pub fn unit_from_radians(angle: f32) -> Vector

Constructs a unit-length vector with a certain angle in radians.

pub fn unit_from_degrees(angle: f32) -> Vector

Constructs a unit-length vector with a certain angle in degrees.

pub fn new_polar_rad(radius: f32, angle: f32) -> Vector

Constructs a vector of a certain magnitude and angle (in radians).

pub fn new_polar_deg(radius: f32, angle: f32) -> Vector

Constructs a vector of a certain magnitude and angle (in degrees).

pub fn magnitude(self) -> f32

Computes the magnitude/length of a vector.

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

Computes the dot product of two vectors.

pub fn scale(self, other: Vector) -> Vector

Computes the component-wise product of two vectors.

pub fn scale_mut(&mut self, other: Vector)

Computes the component-wise product of two vectors, assigning the result to the first one.

pub fn rotate(self, rotation: Rotation) -> Vector

Rotates a vector by a Rotation struct.

pub fn rotate_mut(&mut self, rotation: Rotation)

Rotates a vector, mutating it.

pub fn rotate_rad(self, angle: f32) -> Vector

Rotates a vector by an angle in radians.

pub fn rotate_rad_mut(&mut self, angle: f32)

Rotates a vector by an angle in radians, mutating it.

pub fn rotate_deg(self, angle: f32) -> Vector

Rotates a vector by an angle in degrees.

pub fn rotate_deg_mut(&mut self, angle: f32)

Rotates a vector by an angle in degrees, mutating it.

pub fn normalize(self) -> Vector

Normalizes a vector to unit length.

If the vector is zero, returns (1, 0).

pub fn normalize_mut(&mut self)

Sets a vector to unit length.

If the vector is zero, sets to (1, 0).

pub fn dist(self, other: Vector) -> f32

Computes the euclidean distance between two vectors.

pub fn grid_dist(self, other: Vector) -> f32

Computes the grid-based distance between two vectors.

This is the length of the shortest path between the vectors, if the only movement allowed is parallel to the x- or y-axis.

pub fn angle_rad(self) -> f32

Computes the angle between a vector and the positive x-axis, in radians.

Return values are contained in (-τ/2, τ/2], aka. (-π, π].

pub fn angle_deg(self) -> f32

Computes the angle between a vector and the positive x-axis, in degrees.

Return values are approximately contained in (-180, 180].

pub fn angle_between_rad(self, other: Vector) -> f32

Computes the angle between two vectors, in radians.

Rotating the first vector by the resulting angle will give it the same angle as the second.

Return values are contained in (-τ/2, τ/2], aka (-π, π].

pub fn angle_between_deg(self, other: Vector) -> f32

Computes the angle between two vectors, in degrees.

Return values are approximately contained in (-180, 180].

pub fn map<F: Fn(f32) -> f32>(self, func: &F) -> Vector

Calls a function on each component of a vector, returning the result as a new vector.

pub fn map_mut<F: Fn(f32) -> f32>(&mut self, func: &F)

Sets each component to the result of calling a function on the component's value.

pub fn lerp(self, other: Vector, t: f32) -> Vector

Linearly interpolates from one vector to another by t.

t < 0 or t > 1 gives results outside the rectangular bounds of the vectors.

pub fn is_in_rect(self, vert1: Vector, vert2: Vector) -> bool

Returns true if self is within the (inclusive) bounds of the rectangle defined by two vertices.

pub fn clamp_to_rect(self, vert1: Vector, vert2: Vector) -> Vector

Clamps a vector to within the (inclusive) bounds of the rectangle defined by two vertices.

pub fn as_point(self) -> Point

Reinterprets the x- and y-components of a vector as a point.

pub fn from_vec2(vec2: [f32; 2]) -> Vector

Converts a OpenGL-style vec2 to a Vector.

Optimizes into a simple copy, since the types have the same layout.

pub fn to_vec2(self) -> [f32; 2]

Converts a Vector to a OpenGL-style vec2.

Optimizes into a simple copy, since the types have the same layout.

pub fn to_vec3(self) -> [f32; 3]

Converts a Vector to a OpenGL-style vec3.

The result is padded to [x, y, 0].

pub fn to_vec4(self) -> [f32; 4]

Converts a Vector to a OpenGL-style vec4.

The result is padded to [x, y, 0, 0].

pub fn arr_from_vec2s(arr: &[[f32; 2]]) -> &[Vector]

Reinterprets a slice of vec2s as Vectors.

Does not allocate a new array, only changes the type of the pointer.

pub fn arr_to_vec2s(arr: &[Vector]) -> &[[f32; 2]]

Reinterprets a slice of Vectors as vec2s.

Does not allocate a new array, only changes the type of the pointer.

Trait Implementations

impl Clone for Vector

fn clone(&self) -> Vector

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Vector

impl Default for Vector

fn default() -> Vector

Returns the "default value" for a type.

impl PartialEq for Vector

fn eq(&self, __arg_0: &Vector) -> bool

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

fn ne(&self, __arg_0: &Vector) -> bool

This method tests for !=.

impl Debug for Vector

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Transformation<Vector> for Transform

fn transform(self, vec: Vector) -> Vector

Returns a transformed copy of an object.

fn inverse_transform(self, vec: Vector) -> Vector

Transforms an object by the inverse of a transformation.

fn transform_mut(self, operand: &mut T) where
    T: Copy, 

Transforms an object, mutating it.

fn inverse_transform_checked(self, operand: T) -> Option<T>

Transforms an object by the inverse of a transformation.

impl Add<Vector> for Vector

type Output = Vector

The resulting type after applying the + operator.

fn add(self, other: Vector) -> Vector

Performs the + operation.

impl Add<Vector> for Point

type Output = Point

The resulting type after applying the + operator.

fn add(self, other: Vector) -> Point

Performs the + operation.

impl Add<Point> for Vector

type Output = Point

The resulting type after applying the + operator.

fn add(self, other: Point) -> Point

Performs the + operation.

impl Sub<Vector> for Vector

type Output = Vector

The resulting type after applying the - operator.

fn sub(self, other: Vector) -> Vector

Performs the - operation.

impl Sub<Vector> for Point

type Output = Point

The resulting type after applying the - operator.

fn sub(self, other: Vector) -> Point

Performs the - operation.

impl AddAssign<Vector> for Vector

fn add_assign(&mut self, other: Vector)

Performs the += operation.

impl AddAssign<Vector> for Point

fn add_assign(&mut self, other: Vector)

Performs the += operation.

impl SubAssign<Vector> for Vector

fn sub_assign(&mut self, other: Vector)

Performs the -= operation.

impl SubAssign<Vector> for Point

fn sub_assign(&mut self, other: Vector)

Performs the -= operation.

impl Mul<f32> for Vector

type Output = Vector

The resulting type after applying the * operator.

fn mul(self, scalar: f32) -> Vector

Performs the * operation.

impl Mul<Vector> for f32

type Output = Vector

The resulting type after applying the * operator.

fn mul(self, vec: Vector) -> Vector

Performs the * operation.

impl MulAssign<f32> for Vector

fn mul_assign(&mut self, scalar: f32)

Performs the *= operation.

impl Div<f32> for Vector

type Output = Vector

The resulting type after applying the / operator.

fn div(self, scalar: f32) -> Vector

Performs the / operation.

impl DivAssign<f32> for Vector

fn div_assign(&mut self, scalar: f32)

Performs the /= operation.

impl Neg for Vector

type Output = Vector

The resulting type after applying the - operator.

fn neg(self) -> Vector

Performs the unary - operation.