Struct Vector2

pub struct Vector2<W = Generic> {
    pub x: f64,
    pub y: f64,
    /* private fields */
}

Fields

x: f64

y: f64

Implementations

impl<W> Vector2<W>

where W: Space,

pub fn new(x: f64, y: f64) -> Vector2<W>

pub fn x() -> Vector2<W>

pub fn y() -> Vector2<W>

pub fn normal(&self) -> Vector2<W>

pub fn normalize(self) -> Vector2<W>

pub fn length_squared(&self) -> f64

pub fn length(&self) -> f64

pub fn coord_abs(&self) -> Vector2<W>

pub fn project_onto(self, axis: Vector2<W>) -> Vector2<W>

pub fn project_axis_aligned(self, other: Vector2<W>) -> Vector2<W>

pub fn angle_to(self, other: Vector2<W>) -> Rotation

Returns the angle walking from self to other counter clockwise

pub fn cross(self, other: Vector2<W>) -> f64

Returns the magnitude of the cross product as if both vectors had z value 0.0

pub fn to_signums_of(&self, other: Vector2<W>) -> Vector2<W>

pub fn to_point(&self) -> Point2<W>

pub fn cast_space<WNew>(&self) -> Vector2<WNew>

where WNew: Space,

pub fn rotate(&self, angle: Rotation) -> Vector2<W>

pub fn rotate90(self) -> Vector2<W>

pub fn mult(&self, other: Vector2<W>) -> Vector2<W>

Trait Implementations

impl<W> Add<Point2<W>> for Vector2<W>

where W: Space,

type Output = Point2<W>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<W> Add<Vector2<W>> for Point2<W>

where W: Space,

type Output = Point2<W>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<W> Add<f64> for Vector2<W>

where W: Space,

type Output = Vector2<W>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<W> Add for Vector2<W>

where W: Space,

type Output = Vector2<W>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<W> Clone for Vector2<W>

where W: Space,

fn clone(&self) -> Vector2<W>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CoercionRules for Vector2

fn try_coerce(value: PaxValue) -> Result<Vector2, String>

impl<W> Debug for Vector2<W>

where W: Space,

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

Formats the value using the given formatter.

impl<W> Default for Vector2<W>

where W: Space,

fn default() -> Vector2<W>

Returns the “default value” for a type.

impl<W> Div<f64> for Vector2<W>

where W: Space,

type Output = Vector2<W>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<W> Div for Vector2<W>

where W: Space,

type Output = Vector2<W>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<W> Interpolatable for Vector2<W>

where W: Space,

fn interpolate(&self, _other: &Self, _t: f64) -> Self

impl<F, T> Mul<Vector2<F>> for Transform2<F, T>

where F: Space, T: Space,

type Output = Vector2<T>

The resulting type after applying the * operator.

fn mul(self, other: Vector2<F>) -> <Transform2<F, T> as Mul<Vector2<F>>>::Output

Performs the * operation.

impl<W> Mul<f64> for Vector2<W>

where W: Space,

type Output = Vector2<W>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<W> Mul for Vector2<W>

where W: Space,

type Output = f64

The resulting type after applying the * operator.

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

Performs the * operation.

impl<W> Neg for Vector2<W>

where W: Space,

type Output = Vector2<W>

The resulting type after applying the - operator.

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

Performs the unary - operation.

impl<W> PartialEq for Vector2<W>

where W: Space,

fn eq(&self, other: &Vector2<W>) -> 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<W> Sub<Vector2<W>> for Point2<W>

where W: Space,

type Output = Point2<W>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<W> Sub<f64> for Vector2<W>

where W: Space,

type Output = Vector2<W>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<W> Sub for Vector2<W>

where W: Space,

type Output = Vector2<W>

The resulting type after applying the - operator.

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

Performs the - operation.

impl ToPaxValue for Vector2

fn to_pax_value(self) -> PaxValue

impl<W> Copy for Vector2<W>

where W: Space,