Struct rgx::math::algebra::Point2D

#[repr(C)]
pub struct Point2D<S = f32, U = ()> {
    pub x: S,
    pub y: S,
    /* private fields */
}

2D point.

Fields

x: S

y: S

Implementations

impl<T: Zero + PartialEq> Point2D<T>

pub const ORIGIN: Self = Point2D::ZERO

impl<S, U> Point2D<S, U>

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

pub fn map<F, T>(self, f: F) -> Point2D<T>where F: FnMut(S) -> T,

impl Point2D<i32>

pub fn clamp(&mut self, rect: Rect<i32>)

Trait Implementations

impl<T: Add<Output = T>> Add<Size<T>> for Point2D<T>

type Output = Point2D<T, ()>

The resulting type after applying the + operator.

fn add(self, other: Size<T>) -> Self

Performs the + operation.

impl<S, T, U> Add<T> for Point2D<S, U>where S: Add<Output = S> + Copy, T: Into<Vector2D<S, U>>,

type Output = Point2D<S, U>

The resulting type after applying the + operator.

fn add(self, other: T) -> Self

Performs the + operation.

impl<S: Clone, U: Clone> Clone for Point2D<S, U>

fn clone(&self) -> Point2D<S, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug, U: Debug> Debug for Point2D<S, U>

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

Formats the value using the given formatter.

impl<S: Default, U: Default> Default for Point2D<S, U>

fn default() -> Point2D<S, U>

Returns the “default value” for a type.

impl<S, U> Display for Point2D<S, U>where S: Display,

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

Formats the value using the given formatter.

impl<S, U> Div<S> for Point2D<S, U>where S: Div<Output = S> + Copy,

type Output = Point2D<S, U>

The resulting type after applying the / operator.

fn div(self, s: S) -> Self

Performs the / operation.

impl<T: Copy> From<[T; 2]> for Point2D<T>

fn from(array: [T; 2]) -> Self

Converts to this type from the input type.

impl<T: Copy> From<(T, T)> for Point2D<T>

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

Converts to this type from the input type.

impl<S: One + Zero + Copy> From<Point2D<S, ()>> for Transform3D<S>

fn from(other: Point2D<S>) -> Self

Converts to this type from the input type.

impl<S, U: Copy> From<Point2D<S, U>> for Vector2D<S, U>

fn from(p: Point2D<S, U>) -> Self

Converts to this type from the input type.

impl From<Point2D<f32, ()>> for Point2D<i32>

fn from(other: Point2D<f32>) -> Self

Converts to this type from the input type.

impl From<Point2D<f32, ()>> for Vector4D<f32>

fn from(other: Point2D<f32>) -> Self

Converts to this type from the input type.

impl From<Point2D<f64, ()>> for Point2D<f32>

fn from(other: Point2D<f64>) -> Self

Converts to this type from the input type.

impl<S, U> From<Vector2D<S, U>> for Point2D<S, U>

fn from(v: Vector2D<S, U>) -> Self

Converts to this type from the input type.

impl Geometry for Point2D<f32>

fn transform(self, t: impl Into<Transform>) -> Self

Return a transformed object.

fn untransform(self, t: impl Into<Transform>) -> Self

Undos a transform.

impl<S: Hash, U: Hash> Hash for Point2D<S, U>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Mul<Point2D<f32, ()>> for Transform2D

type Output = Point2D<f32, ()>

The resulting type after applying the * operator.

fn mul(self, point: Point2D<f32>) -> Point2D<f32>

Performs the * operation.

impl Mul<Point2D<f32, ()>> for Transform3D<f32>

Transform a Point2D with a Transform3D.

use rgx::math::*;
let m = Transform3D::from_translation(Vector3D::new(8., 8., 0.));
let p = Point2D::new(1., 1.);

assert_eq!(m * p, Point2D::new(9., 9.));

type Output = Point2D<f32, ()>

The resulting type after applying the * operator.

fn mul(self, p: Point2D<f32>) -> Point2D<f32>

Performs the * operation.

impl<S, U> Mul<S> for Point2D<S, U>where S: Mul<Output = S> + Copy,

type Output = Point2D<S, U>

The resulting type after applying the * operator.

fn mul(self, s: S) -> Self

Performs the * operation.

impl<S: PartialEq, U: PartialEq> PartialEq<Point2D<S, U>> for Point2D<S, U>

fn eq(&self, other: &Point2D<S, U>) -> 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<S, U> Sub<Point2D<S, U>> for Point2D<S, U>where S: Sub<Output = S> + Copy,

type Output = Vector2D<S, U>

The resulting type after applying the - operator.

fn sub(self, other: Point2D<S, U>) -> Vector2D<S, U>

Performs the - operation.

impl<S, U> Sub<Vector2D<S, U>> for Point2D<S, U>where S: Sub<Output = S> + Copy,

type Output = Point2D<S, U>

The resulting type after applying the - operator.

fn sub(self, other: Vector2D<S, U>) -> Self

Performs the - operation.

impl<T: Zero + PartialEq> Zero for Point2D<T>

const ZERO: Self = _

fn is_zero(&self) -> bool

impl<S: Copy, U: Copy> Copy for Point2D<S, U>

impl<S: Eq, U: Eq> Eq for Point2D<S, U>

impl<S, U> StructuralEq for Point2D<S, U>

impl<S, U> StructuralPartialEq for Point2D<S, U>