Struct cgl_rs::math::Vector2

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

A 2-dimensional vector with x and y components.

Fields

x: f32

y: f32

Implementations

impl Vector2

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

Creates a new Vector2 with the given x and y components.

Arguments

• x - The x component of the vector.
• y - The y component of the vector.

Returns

A new Vector2 with the given x and y components.

Examples

use cgl_rs::math::Vector2;
 
let vec = Vector2::new(1.0, 2.0);

pub fn zero() -> Vector2

Creates a new Vector2 with x and y components set to 0.0.

Returns

A new Vector2 with x and y components set to 0.0.

Examples

use cgl_rs::math::Vector2;

let vec = Vector2::zero();

pub fn one() -> Vector2

Creates a new Vector2 with x and y components set to 1.0.

Returns

A new Vector2 with x and y components set to 1.0.

Examples

use cgl_rs::math::Vector2;

let vec = Vector2::one();

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

Calculates the dot product of this vector and another vector.

Arguments

• other - The other vector to calculate the dot product with.

Returns

The dot product of this vector and the other vector.

Examples

use cgl_rs::math::Vector2;

let vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector2::new(3.0, 4.0);
let dot_product = vec1.dot(&vec2);

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

Calculates the cross product of this vector and another vector.

Arguments

• other - The other vector to calculate the cross product with.

Returns

The cross product of this vector and the other vector.

Examples

use cgl_rs::math::Vector2;
 
let vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector2::new(3.0, 4.0);
let cross_product = vec1.cross(&vec2);

pub fn length(&self) -> f32

Calculates the length of this vector.

Returns

The length of this vector.

Examples

use cgl_rs::math::Vector2;

let vec = Vector2::new(3.0, 4.0);
let length = vec.length();

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

Rotates this vector about the origin by the given angle (in radians).

Arguments

• angle - The angle (in radians) to rotate this vector by.

Returns

A new Vector2 representing the result of rotating this vector about the origin by the given angle.

Examples

use cgl_rs::math::Vector2;

let vec = Vector2::new(1.0, 0.0);
let rotated_vec = vec.rotate_about_origin(std::f32::consts::PI / 2.0);

pub fn from_angle(angle: f32) -> Vector2

Creates a new Vector2 from the given angle (in radians).

Arguments

• angle - The angle (in radians) to create the vector from.

Returns

A new Vector2 representing the given angle.

Examples

use cgl_rs::math::Vector2;

let vec = Vector2::from_angle(std::f32::consts::PI / 4.0);

pub fn angle(&self) -> f32

Calculates the angle (in radians) between this vector and the positive x-axis.

Returns

The angle (in radians) between this vector and the positive x-axis.

Examples

use cgl_rs::math::Vector2;

let vec = Vector2::new(1.0, 1.0);
let angle = vec.angle();

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

Calculates the angle (in radians) between this vector and another vector.

Arguments

• other - The other vector to calculate the angle between.

Returns

The angle (in radians) between this vector and the other vector.

Examples

use cgl_rs::math::Vector2;

let vec1 = Vector2::new(1.0, 0.0);
let vec2 = Vector2::new(0.0, 1.0);
let angle = vec1.angle_between(&vec2);

pub fn normalize(&mut self)

Normalizes this vector in place.

Examples

use cgl_rs::math::Vector2;

let mut vec = Vector2::new(3.0, 4.0);
vec.normalize();

See also

• normalized

pub fn normalized(&self) -> Vector2

Returns a new normalized Vector2 representing this vector.

Returns

A new Vector2 representing this vector, normalized.

Examples

use cgl_rs::math::Vector2;

let vec = Vector2::new(3.0, 4.0);
let normalized_vec = vec.normalized();

See also

• normalize

pub fn perpendicular(&self) -> Vector2

Returns a new Vector2 that is perpendicular to this vector.

Returns

A new Vector2 that is perpendicular to this vector.

Examples

use cgl_rs::math::Vector2;

let vec = Vector2::new(1.0, 2.0);
let perp_vec = vec.perpendicular();

See also

• dot
• angle_between

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

Returns the reflection of this vector off a surface with the given normal.

Arguments

• normal - The normal of the surface being reflected off of.

Returns

The reflection of this vector off the surface with the given normal.

Examples

use cgl_rs::math::Vector2;

let vec = Vector2::new(1.0, 2.0);
let normal = Vector2::new(0.0, 1.0);
let reflected_vec = vec.reflect(&normal);

Trait Implementations

impl Add<Vector2> for Vector2

type Output = Vector2

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for Vector2

fn clone(&self) -> Vector2

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Vector2

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

Formats the value using the given formatter.

impl Display for Vector2

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

Formats the vector as a string.

Arguments

• f - The formatter to use.

Returns

A string representation of the vector.

Examples

use cgl_rs::math::Vector2;
let vec = Vector2::new(1.0, 2.0);

impl Div<Vector2> for Vector2

type Output = Vector2

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f32> for Vector2

type Output = Vector2

The resulting type after applying the / operator.

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

Performs the / operation.

impl Index<usize> for Vector2

Allows indexing into a Vector2 by usize index.

fn index(&self, index: usize) -> &f32

Returns a reference to the f32 value at the given index.

Arguments

• index - The index of the value to retrieve. Must be 0 or 1.

Returns

A reference to the f32 value at the given index.

Panics

Panics if the index is not 0 or 1.

Examples

use cgl_rs::math::Vector2;
let vec = Vector2::new(1.0, 2.0);
assert_eq!(vec[0], 1.0);
assert_eq!(vec[1], 2.0);

type Output = f32

The returned type after indexing.

impl IndexMut<usize> for Vector2

Allows mutable indexing into a Vector2 by usize index.

fn index_mut(&mut self, index: usize) -> &mut f32

Returns a mutable reference to the f32 value at the given index.

Arguments

• index - The index of the value to retrieve. Must be 0 or 1.

Returns

A mutable reference to the f32 value at the given index.

Panics

Panics if the index is not 0 or 1.

Examples

use cgl_rs::math::Vector2;
let mut vec = Vector2::new(1.0, 2.0);
vec[0] = 3.0;
assert_eq!(vec.x, 3.0);

impl Mul<Vector2> 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 Neg for Vector2

type Output = Vector2

The resulting type after applying the - operator.

fn neg(self) -> Vector2

Performs the unary - operation.

impl PartialEq<Vector2> for Vector2

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

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

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 Sub<Vector2> for Vector2

type Output = Vector2

The resulting type after applying the - operator.

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

Performs the - operation.

impl Copy for Vector2

impl StructuralPartialEq for Vector2