Struct HcPoint 

pub struct HcPoint<T: Scalar, const N: usize, S: Space = WorldSpace> {
    pub weight: T,
    /* private fields */
}

A location in N-dimensional space represented by homogeneous coordinates (with N + 1 values).

Any given point can not only be represented in the familiar cartesian coordinates, but also in so called homogeneous coordinates. In fact, it has infinitely many representations in homogeneous coordinates! To represent a point in N-dimensional space, homogeneous coordinates store N+1 values: N normal coordinates and a weight. The cartesian coordinates (x, y, z) and the homogeneous coordinates (W·x, W·y, W·z; W) (for any W != 0) all represent the same point in 3D space! E.g., (1, 2, 3), (1, 2, 3; 1) and (2, 4, 6; 2) represent the same point.

Homogeneous coordinates are used to represent affine and projective transformations of N-dimensional points as (N+1)x(N+1) matrix. You usually only ever encounter them in that context.

The most important functions of this type is to convert from and to Point via the From impls or Self::to_point.

use lina::{HcPoint, point2};

let mut hc = HcPoint::from(point2(7.0, 5.0));
assert_eq!(hc.x, 7.0);
assert_eq!(hc.y, 5.0);
assert_eq!(hc.weight, 1.0);

hc.weight = 2.0;
assert_eq!(hc.to_point(), point2(3.5, 2.5));

Fields

weight: T

Implementations

impl<T: Scalar, const N: usize, S: Space> HcPoint<T, N, S>

pub fn origin() -> Self

Returns a representation of the origin in N-dimensional space.

pub fn new(coords: impl Into<[T; N]>, weight: T) -> Self

Creates a new point with the given coordinates and weight.

pub fn to_point(self) -> Point<T, N, S>

Converts this homogeneous coordinates point into a cartesian coordinate point (by dividing all components by the weight).

use lina::{HcPoint, point3};

let hc = HcPoint::new([1.0, 2.0, 3.0], 2.0);
assert_eq!(hc.to_point(), point3(0.5, 1.0, 1.5));

pub const fn in_space<Target: Space>(self) -> HcPoint<T, N, Target>

Reinterprets this points as being in the space Target instead of S. Before calling this, make sure this operation makes semantic sense and don’t just use it to get rid of compiler errors.

pub fn to_f32(self) -> HcPoint<f32, N, S>

where T: NumCast,

Casts self to using f32 as scalar.

pub fn to_f64(self) -> HcPoint<f64, N, S>

where T: NumCast,

Casts self to using f64 as scalar.

pub fn as_bytes(&self) -> &[u8]

Returns a byte slice of this point representing the full raw data (components + weight). Useful to pass to graphics APIs.

impl<T: Scalar, S: Space> HcPoint<T, 2, S>

pub fn to_array(self) -> [T; 3]

Converts this to an array of size N+1 with all the stored values (components + weight). This is equivalent to using the corresponding From<Self> for [T; N + 1] impl.

Trait Implementations

impl<T: Scalar, S: Space> AsMut<[T; 3]> for HcPoint<T, 2, S>

fn as_mut(&mut self) -> &mut [T; 3]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T: Scalar, S: Space> AsRef<[T; 3]> for HcPoint<T, 2, S>

fn as_ref(&self) -> &[T; 3]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Scalar, const N: usize, S: Space> Clone for HcPoint<T, N, S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Scalar, const N: usize, S: Space> Debug for HcPoint<T, N, S>

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

Formats the value using the given formatter.

impl<T: Scalar, S: Space> Deref for HcPoint<T, 2, S>

type Target = View2<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Scalar, S: Space> Deref for HcPoint<T, 3, S>

type Target = View3<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Scalar, S: Space> DerefMut for HcPoint<T, 2, S>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Scalar, S: Space> DerefMut for HcPoint<T, 3, S>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Scalar, S: Space> From<[T; 3]> for HcPoint<T, 2, S>

fn from(src: [T; 3]) -> Self

Converts to this type from the input type.

impl<T: Scalar, S: Space> From<HcPoint<T, 2, S>> for [T; 3]

fn from(src: HcPoint<T, 2, S>) -> Self

Converts to this type from the input type.

impl<T: Scalar, const N: usize, S: Space> From<HcPoint<T, N, S>> for Point<T, N, S>

fn from(src: HcPoint<T, N, S>) -> Self

Converts to this type from the input type.

impl<T: Scalar, const N: usize, S: Space> From<Point<T, N, S>> for HcPoint<T, N, S>

fn from(src: Point<T, N, S>) -> Self

Converts to this type from the input type.

impl<T: Scalar + Hash, const N: usize, S: Space> Hash for HcPoint<T, N, S>

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<T: Scalar, const N: usize, S: Space> Index<usize> for HcPoint<T, N, S>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Scalar, const N: usize, S: Space> IndexMut<usize> for HcPoint<T, N, S>

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

Performs the mutable indexing (container[index]) operation.

impl<T: Scalar, const C: usize, const R: usize, Src: Space, Dst: Space> Mul<HcPoint<T, C, Src>> for &HcMatrix<T, C, R, Src, Dst>

See HcMatrix::transform.

type Output = HcPoint<T, R, Dst>

The resulting type after applying the * operator.

fn mul(self, rhs: HcPoint<T, C, Src>) -> Self::Output

Performs the * operation.

impl<T: Scalar, const C: usize, const R: usize, Src: Space, Dst: Space> Mul<HcPoint<T, C, Src>> for &Matrix<T, C, R, Src, Dst>

See Matrix::transform.

type Output = HcPoint<T, R, Dst>

The resulting type after applying the * operator.

fn mul(self, rhs: HcPoint<T, C, Src>) -> Self::Output

Performs the * operation.

impl<T: Scalar, const N: usize, S: Space> PartialEq for HcPoint<T, N, S>

fn eq(&self, other: &Self) -> 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<T: Scalar + Zeroable, const N: usize, S: Space> Zeroable for HcPoint<T, N, S>

Due to the T: Zeroable bound, all our fields are zeroable. weight trivially is, coords is as [T; N] implements Zeroable as well. And PhantomData is zero sized, so implements it as well. Further, due to repr(C), this type has no padding bytes.

fn zeroed() -> Self

Calls zeroed.

impl<T: Scalar, const N: usize, S: Space> Copy for HcPoint<T, N, S>

impl<T: Scalar + Eq, const N: usize, S: Space> Eq for HcPoint<T, N, S>

impl<T: Scalar + Pod, const N: usize, S: Space> Pod for HcPoint<T, N, S>

This type, with the T: Pod bounds, satisfies all properties required by Pod. All bit patterns are allowed, no padding bytes, trivially inhabiteda nad repr(C).