Struct cgmath::Point2

pub struct Point2<S> {
    pub x: S,
    pub y: S,
}

A point in 2-dimensional space.

Fields

x
y

Methods

impl<S: BaseNum> Point2<S>

fn new(x: S, y: S) -> Point2<S>

Trait Implementations

impl<S> FixedArray<[S; 2]> for Point2<S>

fn into_fixed(self) -> [S; 2]

fn as_fixed<'a>(&'a self) -> &'a [S; 2]

fn as_mut_fixed<'a>(&'a mut self) -> &'a mut [S; 2]

fn from_fixed(_v: [S; 2]) -> Point2<S>

fn from_fixed_ref<'a>(v: &'a [S; 2]) -> &'a Point2<S>

fn from_fixed_mut<'a>(v: &'a mut [S; 2]) -> &'a mut Point2<S>

impl<S: BaseNum> Index<usize> for Point2<S>

type Output = S

fn index<'a>(&'a self, i: usize) -> &'a S

impl<S: BaseNum> IndexMut<usize> for Point2<S>

fn index_mut<'a>(&'a mut self, i: usize) -> &'a mut S

impl<S: BaseNum> Array1<S> for Point2<S>

fn map<F>(&mut self, op: F) -> Point2<S> where F: FnMut(S) -> S

fn ptr<'a>(&'a self) -> &'a Element

fn mut_ptr<'a>(&'a mut self) -> &'a mut Element

fn swap_elems(&mut self, i: usize, j: usize)

fn replace_elem(&mut self, i: usize, src: Element) -> Element

impl<S: BaseNum> Point<S, Vector2<S>> for Point2<S>

fn origin() -> Point2<S>

fn from_vec(v: &Vector2<S>) -> Point2<S>

fn to_vec(&self) -> Vector2<S>

fn mul_s(&self, s: S) -> Point2<S>

fn div_s(&self, s: S) -> Point2<S>

fn rem_s(&self, s: S) -> Point2<S>

fn add_v(&self, v: &Vector2<S>) -> Point2<S>

fn sub_p(&self, p: &Point2<S>) -> Vector2<S>

fn mul_self_s(&mut self, s: S)

fn div_self_s(&mut self, s: S)

fn rem_self_s(&mut self, s: S)

fn add_self_v(&mut self, v: &Vector2<S>)

fn dot(&self, v: &Vector2<S>) -> S

fn min(&self, p: &Point2<S>) -> Point2<S>

fn max(&self, p: &Point2<S>) -> Point2<S>

impl<S: BaseFloat> ApproxEq<S> for Point2<S>

fn approx_eq_eps(&self, other: &Point2<S>, epsilon: &S) -> bool

fn approx_epsilon(_hack: Option<Self>) -> T

fn approx_eq(&self, other: &Self) -> bool

impl<S: BaseNum> Debug for Point2<S>

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

Derived Implementations

impl<S: Decodable> Decodable for Point2<S>

fn decode<__D: Decoder>(__arg_0: &mut __D) -> Result<Point2<S>, __D::Error>

impl<S: Encodable> Encodable for Point2<S>

fn encode<__S: Encoder>(&self, __arg_0: &mut __S) -> Result<(), __S::Error>

impl<S: Hash> Hash for Point2<S>

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

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

impl<S: Clone> Clone for Point2<S>

fn clone(&self) -> Point2<S>

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

impl<S: Copy> Copy for Point2<S>

impl<S: Eq> Eq for Point2<S>

impl<S: PartialEq> PartialEq for Point2<S>

fn eq(&self, __arg_0: &Point2<S>) -> bool

fn ne(&self, __arg_0: &Point2<S>) -> bool