# Struct euclid::point::Point3D

``````#[repr(C)]pub struct Point3D<T, U> {
pub x: T,
pub y: T,
pub z: T,
/* private fields */
}``````
Expand description

A 3d Point tagged with a unit.

## Fields§

§`x: T`§`y: T`§`z: T`

## Implementations§

source§

### impl<T, U> Point3D<T, U>

source

#### pub fn origin() -> Selfwhere T: Zero,

Constructor, setting all components to zero.

source

source

#### pub const fn new(x: T, y: T, z: T) -> Self

Constructor taking scalar values directly.

source

#### pub fn from_lengths(x: Length<T, U>, y: Length<T, U>, z: Length<T, U>) -> Self

Constructor taking properly Lengths instead of scalar values.

source

#### pub fn splat(v: T) -> Selfwhere T: Clone,

Constructor setting all components to the same value.

source

#### pub fn from_untyped(p: Point3D<T, UnknownUnit>) -> Self

Tag a unitless value with units.

source

#### pub fn map<V, F: FnMut(T) -> V>(self, f: F) -> Point3D<V, U>

Apply the function `f` to each component of this point.

##### §Example

This may be used to perform unusual arithmetic which is not already offered as methods.

``````use euclid::default::Point3D;

let p = Point3D::<u32>::new(5, 11, 15);
assert_eq!(p.map(|coord| coord.saturating_sub(10)), Point3D::new(0, 1, 5));``````
source

#### pub fn zip<V, F: FnMut(T, T) -> V>(self, rhs: Self, f: F) -> Vector3D<V, U>

Apply the function `f` to each pair of components of this point and `rhs`.

##### §Example

This may be used to perform unusual arithmetic which is not already offered as methods.

``````use euclid::{default::{Point3D, Vector3D}, point2};

let a: Point3D<u32> = Point3D::new(50, 200, 400);
let b: Point3D<u32> = Point3D::new(100, 100, 150);
assert_eq!(a.zip(b, u32::saturating_sub), Vector3D::new(0, 100, 250));``````
source§

### impl<T: Copy, U> Point3D<T, U>

source

#### pub fn to_vector(self) -> Vector3D<T, U>

Cast this point into a vector.

Equivalent to subtracting the origin to this point.

source

#### pub fn xy(self) -> Point2D<T, U>

Returns a 2d point using this point’s x and y coordinates

source

#### pub fn xz(self) -> Point2D<T, U>

Returns a 2d point using this point’s x and z coordinates

source

#### pub fn yz(self) -> Point2D<T, U>

Returns a 2d point using this point’s x and z coordinates

source

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

Cast into an array with x, y and z.

##### §Example
``````enum Mm {}

let point: Point3D<_, Mm> = point3(1, -8, 0);

assert_eq!(point.to_array(), [1, -8, 0]);``````
source

source

#### pub fn to_tuple(self) -> (T, T, T)

Cast into a tuple with x, y and z.

##### §Example
``````enum Mm {}

let point: Point3D<_, Mm> = point3(1, -8, 0);

assert_eq!(point.to_tuple(), (1, -8, 0));``````
source

source

#### pub fn to_untyped(self) -> Point3D<T, UnknownUnit>

Drop the units, preserving only the numeric value.

##### §Example
``````enum Mm {}

let point: Point3D<_, Mm> = point3(1, -8, 0);

assert_eq!(point.x, point.to_untyped().x);
assert_eq!(point.y, point.to_untyped().y);
assert_eq!(point.z, point.to_untyped().z);``````
source

#### pub fn cast_unit<V>(self) -> Point3D<T, V>

Cast the unit, preserving the numeric value.

##### §Example
``````enum Mm {}
enum Cm {}

let point: Point3D<_, Mm> = point3(1, -8, 0);

assert_eq!(point.x, point.cast_unit::<Cm>().x);
assert_eq!(point.y, point.cast_unit::<Cm>().y);
assert_eq!(point.z, point.cast_unit::<Cm>().z);``````
source

#### pub fn to_2d(self) -> Point2D<T, U>

Convert into a 2d point.

source

#### pub fn round(self) -> Selfwhere T: Round,

Rounds each component to the nearest integer value.

This behavior is preserved for negative values (unlike the basic cast).

``````enum Mm {}

assert_eq!(point3::<_, Mm>(-0.1, -0.8, 0.4).round(), point3::<_, Mm>(0.0, -1.0, 0.0))``````
source

#### pub fn ceil(self) -> Selfwhere T: Ceil,

Rounds each component to the smallest integer equal or greater than the original value.

This behavior is preserved for negative values (unlike the basic cast).

``````enum Mm {}

assert_eq!(point3::<_, Mm>(-0.1, -0.8, 0.4).ceil(), point3::<_, Mm>(0.0, 0.0, 1.0))``````
source

#### pub fn floor(self) -> Selfwhere T: Floor,

Rounds each component to the biggest integer equal or lower than the original value.

This behavior is preserved for negative values (unlike the basic cast).

``````enum Mm {}

assert_eq!(point3::<_, Mm>(-0.1, -0.8, 0.4).floor(), point3::<_, Mm>(-1.0, -1.0, 0.0))``````
source

#### pub fn lerp(self, other: Self, t: T) -> Selfwhere T: One + Sub<Output = T> + Mul<Output = T> + Add<Output = T>,

Linearly interpolate between this point and another point.

##### §Example
``````use euclid::point3;
use euclid::default::Point3D;

let from: Point3D<_> = point3(0.0, 10.0, -1.0);
let to:  Point3D<_> = point3(8.0, -4.0,  0.0);

assert_eq!(from.lerp(to, -1.0), point3(-8.0,  24.0, -2.0));
assert_eq!(from.lerp(to,  0.0), point3( 0.0,  10.0, -1.0));
assert_eq!(from.lerp(to,  0.5), point3( 4.0,   3.0, -0.5));
assert_eq!(from.lerp(to,  1.0), point3( 8.0,  -4.0,  0.0));
assert_eq!(from.lerp(to,  2.0), point3(16.0, -18.0,  1.0));``````
source§

### impl<T: PartialOrd, U> Point3D<T, U>

source

source

source

#### pub fn clamp(self, start: Self, end: Self) -> Selfwhere T: Copy,

Returns the point each component of which clamped by corresponding components of `start` and `end`.

Shortcut for `self.max(start).min(end)`.

source§

### impl<T: NumCast + Copy, U> Point3D<T, U>

source

#### pub fn cast<NewT: NumCast>(self) -> Point3D<NewT, U>

Cast from one numeric representation to another, preserving the units.

When casting from floating point to integer coordinates, the decimals are truncated as one would expect from a simple cast, but this behavior does not always make sense geometrically. Consider using `round()`, `ceil()` or `floor()` before casting.

source

#### pub fn try_cast<NewT: NumCast>(self) -> Option<Point3D<NewT, U>>

Fallible cast from one numeric representation to another, preserving the units.

When casting from floating point to integer coordinates, the decimals are truncated as one would expect from a simple cast, but this behavior does not always make sense geometrically. Consider using `round()`, `ceil()` or `floor()` before casting.

source

#### pub fn to_f32(self) -> Point3D<f32, U>

Cast into an `f32` point.

source

#### pub fn to_f64(self) -> Point3D<f64, U>

Cast into an `f64` point.

source

#### pub fn to_usize(self) -> Point3D<usize, U>

Cast into an `usize` point, truncating decimals if any.

When casting from floating point points, it is worth considering whether to `round()`, `ceil()` or `floor()` before the cast in order to obtain the desired conversion behavior.

source

#### pub fn to_u32(self) -> Point3D<u32, U>

Cast into an `u32` point, truncating decimals if any.

When casting from floating point points, it is worth considering whether to `round()`, `ceil()` or `floor()` before the cast in order to obtain the desired conversion behavior.

source

#### pub fn to_i32(self) -> Point3D<i32, U>

Cast into an `i32` point, truncating decimals if any.

When casting from floating point points, it is worth considering whether to `round()`, `ceil()` or `floor()` before the cast in order to obtain the desired conversion behavior.

source

#### pub fn to_i64(self) -> Point3D<i64, U>

Cast into an `i64` point, truncating decimals if any.

When casting from floating point points, it is worth considering whether to `round()`, `ceil()` or `floor()` before the cast in order to obtain the desired conversion behavior.

source§

### impl<T: Float, U> Point3D<T, U>

source

#### pub fn is_finite(self) -> bool

Returns true if all members are finite.

source§

source

source§

source

source§

### impl<T: Euclid, U> Point3D<T, U>

source

#### pub fn rem_euclid(&self, other: &Size3D<T, U>) -> Self

Calculates the least nonnegative remainder of `self (mod other)`.

##### §Example
``````use euclid::point3;
use euclid::default::{Point3D, Size3D};

let p = Point3D::new(7.0, -7.0, 0.0);
let s = Size3D::new(4.0, -4.0, 12.0);
assert_eq!(p.rem_euclid(&s), point3(3.0, 1.0, 0.0));
assert_eq!((-p).rem_euclid(&s), point3(1.0, 3.0, 0.0));
assert_eq!(p.rem_euclid(&-s), point3(3.0, 1.0, 0.0));``````
source

#### pub fn div_euclid(&self, other: &Size3D<T, U>) -> Self

Calculates Euclidean division, the matching method for `rem_euclid`.

##### §Example
``````use euclid::point3;
use euclid::default::{Point3D, Size3D};

let p = Point3D::new(7.0, -7.0, 0.0);
let s = Size3D::new(4.0, -4.0, 12.0);

assert_eq!(p.div_euclid(&s), point3(1.0, 2.0, 0.0));
assert_eq!((-p).div_euclid(&s), point3(-2.0, -1.0, 0.0));
assert_eq!(p.div_euclid(&-s), point3(-1.0, -2.0, 0.0));``````

## Trait Implementations§

source§

§

#### type Output = Point3D<<T as Add>::Output, U>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Size3D<T, U>) -> Self::Output

Performs the `+` operation. Read more
source§

§

#### type Output = Point3D<<T as Add>::Output, U>

The resulting type after applying the `+` operator.
source§

#### fn add(self, other: Vector3D<T, U>) -> Self::Output

Performs the `+` operation. Read more
source§

source§

#### fn add_assign(&mut self, other: Size3D<T, U>)

Performs the `+=` operation. Read more
source§

### impl<T: Copy + Add<T, Output = T>, U> AddAssign<Vector3D<T, U>> for Point3D<T, U>

source§

#### fn add_assign(&mut self, other: Vector3D<T, U>)

Performs the `+=` operation. Read more
source§

### impl<T: ApproxEq<T>, U> ApproxEq<Point3D<T, U>> for Point3D<T, U>

source§

#### fn approx_epsilon() -> Self

Default epsilon value
source§

#### fn approx_eq_eps(&self, other: &Self, eps: &Self) -> bool

Returns `true` is this object is approximately equal to the other one, using a provided epsilon value.
source§

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

Returns `true` is this object is approximately equal to the other one, using the `approx_epsilon()` epsilon value.
source§

source§

source§

### impl<T: Clone, U> Clone for Point3D<T, U>

source§

#### fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from `source`. Read more
source§

### impl<T: Debug, U> Debug for Point3D<T, U>

source§

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

Formats the value using the given formatter. Read more
source§

### impl<T: Default, U> Default for Point3D<T, U>

source§

#### fn default() -> Self

Returns the “default value” for a type. Read more
source§

### impl<'de, T, U> Deserialize<'de> for Point3D<T, U>where T: Deserialize<'de>,

source§

#### fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

### impl<T: Copy + Div, U1, U2> Div<Scale<T, U1, U2>> for Point3D<T, U2>

§

#### type Output = Point3D<<T as Div>::Output, U1>

The resulting type after applying the `/` operator.
source§

#### fn div(self, scale: Scale<T, U1, U2>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<T: Copy + Div, U> Div<T> for Point3D<T, U>

§

#### type Output = Point3D<<T as Div>::Output, U>

The resulting type after applying the `/` operator.
source§

#### fn div(self, scale: T) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<T: Copy + DivAssign, U> DivAssign<Scale<T, U, U>> for Point3D<T, U>

source§

#### fn div_assign(&mut self, scale: Scale<T, U, U>)

Performs the `/=` operation. Read more
source§

### impl<T: Copy + DivAssign, U> DivAssign<T> for Point3D<T, U>

source§

#### fn div_assign(&mut self, scale: T)

Performs the `/=` operation. Read more
source§

source§

source§

### impl<T, U> From<[T; 3]> for Point3D<T, U>

source§

#### fn from([x, y, z]: [T; 3]) -> Self

Converts to this type from the input type.
source§

### impl<T, U> From<(T, T, T)> for Point3D<T, U>

source§

#### fn from(tuple: (T, T, T)) -> Self

Converts to this type from the input type.
source§

### impl<T, U> From<Point3D<T, U>> for [T; 3]

source§

#### fn from(p: Point3D<T, U>) -> Self

Converts to this type from the input type.
source§

### impl<T, U> From<Point3D<T, U>> for (T, T, T)

source§

#### fn from(p: Point3D<T, U>) -> Self

Converts to this type from the input type.
source§

### impl<T: One, U> From<Point3D<T, U>> for HomogeneousVector<T, U>

source§

#### fn from(p: Point3D<T, U>) -> Self

Converts to this type from the input type.
source§

### impl<T, U> Hash for Point3D<T, U>where T: Hash,

source§

#### fn hash<H: Hasher>(&self, h: &mut H)

Feeds this value into the given `Hasher`. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given `Hasher`. Read more
source§

### impl<T: Copy + Mul, U1, U2> Mul<Scale<T, U1, U2>> for Point3D<T, U1>

§

#### type Output = Point3D<<T as Mul>::Output, U2>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, scale: Scale<T, U1, U2>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<T: Copy + Mul, U> Mul<T> for Point3D<T, U>

§

#### type Output = Point3D<<T as Mul>::Output, U>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, scale: T) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<T: Copy + MulAssign, U> MulAssign<Scale<T, U, U>> for Point3D<T, U>

source§

#### fn mul_assign(&mut self, scale: Scale<T, U, U>)

Performs the `*=` operation. Read more
source§

### impl<T: Copy + MulAssign, U> MulAssign<T> for Point3D<T, U>

source§

#### fn mul_assign(&mut self, scale: T)

Performs the `*=` operation. Read more
source§

### impl<T: Neg, U> Neg for Point3D<T, U>

§

#### type Output = Point3D<<T as Neg>::Output, U>

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> Self::Output

Performs the unary `-` operation. Read more
source§

### impl<T, U> PartialEq for Point3D<T, U>where T: PartialEq,

source§

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

This method tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · source§

#### 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.
source§

source§

source§

### impl<T, U> Serialize for Point3D<T, U>where T: Serialize,

source§

#### fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

### impl<T: Sub, U> Sub<Size3D<T, U>> for Point3D<T, U>

§

#### type Output = Point3D<<T as Sub>::Output, U>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Size3D<T, U>) -> Self::Output

Performs the `-` operation. Read more
source§

### impl<T: Sub, U> Sub<Vector3D<T, U>> for Point3D<T, U>

§

#### type Output = Point3D<<T as Sub>::Output, U>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Vector3D<T, U>) -> Self::Output

Performs the `-` operation. Read more
source§

### impl<T: Sub, U> Sub for Point3D<T, U>

§

#### type Output = Vector3D<<T as Sub>::Output, U>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, other: Self) -> Self::Output

Performs the `-` operation. Read more
source§

### impl<T: SubAssign, U> SubAssign<Size3D<T, U>> for Point3D<T, U>

source§

#### fn sub_assign(&mut self, other: Size3D<T, U>)

Performs the `-=` operation. Read more
source§

### impl<T: Copy + Sub<T, Output = T>, U> SubAssign<Vector3D<T, U>> for Point3D<T, U>

source§

#### fn sub_assign(&mut self, other: Vector3D<T, U>)

Performs the `-=` operation. Read more
source§

source§

source§

source§

§

§

§

§

§

§

## Blanket Implementations§

source§

### impl<T> Any for Twhere T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for Twhere T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T, U> Into<U> for Twhere U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<T> ToOwned for Twhere T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

### impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§