Struct Projection 

#[repr(C)]
pub struct Projection<T> {
    pub min: T,
    pub max: T,
}

Represents the projection of a 2D shape on an axis.

This primitive does not contain the axis itself, merely the start and end bounds of the projection. This is used in overlap checks for convex shapes.

Fields

min: T

max: T

Implementations

impl<T: Pod + NoUninit> Projection<T>

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

This type re-interpreted as a slice of bytes.

pub fn as_bytes_mut(&mut self) -> &mut [u8]

This type re-interpreted as a mutable slice of bytes.

impl<T: Copy + AbsDiffEq<Epsilon = T>> Projection<T>

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

Returns true if the two values are approximately equal according to the absolute difference between their components.

impl<T: Copy + RelativeEq<Epsilon = T>> Projection<T>

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

Returns true if the two values are approximately equal according to the absolute difference between their components, as well as relative-based comparisons.

impl<T: Copy + UlpsEq<Epsilon = T>> Projection<T>

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

Returns true if the two values are approximately equal according to the absolute difference between their components, as well as ULPs (Units in Last Place).

impl<T> Projection<T>

pub const fn new(min: T, max: T) -> Self

Create a new projection.

impl<T: Num> Projection<T>

pub const ZERO: Self

A projection of range [0, 0].

pub fn contains(&self, value: T) -> bool

pub fn overlaps(&self, other: Projection<T>) -> bool

Returns true if this projection overlaps the other.

pub fn overlap(&self, other: Projection<T>) -> Option<T>

If this projection overlaps the other, returns the amount which it overlaps.

pub fn len(&self) -> T

Length of the projection.

pub fn center(&self) -> T

Center of the projection.

Trait Implementations

impl<T> AbsDiffEq for Projection<T>

where T: AbsDiffEq, T::Epsilon: Copy,

type Epsilon = <T as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T: Copy + Add<T, Output = T>> Add<&Projection<T>> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Projection<T>) -> Self::Output

Performs the + operation.

impl<T: Copy + Add<T, Output = T>> Add<&Projection<T>> for Projection<T>

type Output = Projection<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Projection<T>) -> Self::Output

Performs the + operation.

impl<T: Copy + Add<T, Output = T>> Add<Projection<T>> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the + operator.

fn add(self, rhs: Projection<T>) -> Self::Output

Performs the + operation.

impl<T: Copy + Add<T, Output = T>> Add<T> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T: Copy + Add<T, Output = T>> Add<T> for Projection<T>

type Output = Projection<T>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T: Add<T, Output = T>> Add for Projection<T>

type Output = Projection<T>

The resulting type after applying the + operator.

fn add(self, rhs: Projection<T>) -> Self::Output

Performs the + operation.

impl<T: Copy + AddAssign<T>> AddAssign<&Projection<T>> for Projection<T>

fn add_assign(&mut self, rhs: &Projection<T>)

Performs the += operation.

impl<T: Copy + AddAssign<T>> AddAssign<&T> for Projection<T>

fn add_assign(&mut self, rhs: &T)

Performs the += operation.

impl<T: Copy + AddAssign<T>> AddAssign<T> for Projection<T>

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T: AddAssign<T>> AddAssign for Projection<T>

fn add_assign(&mut self, rhs: Projection<T>)

Performs the += operation.

impl<T: Clone> Clone for Projection<T>

fn clone(&self) -> Projection<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Projection<T>

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

Formats the value using the given formatter.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for Projection<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Copy + Div<T, Output = T>> Div<&Projection<T>> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the / operator.

fn div(self, rhs: &Projection<T>) -> Self::Output

Performs the / operation.

impl<T: Copy + Div<T, Output = T>> Div<&Projection<T>> for Projection<T>

type Output = Projection<T>

The resulting type after applying the / operator.

fn div(self, rhs: &Projection<T>) -> Self::Output

Performs the / operation.

impl<T: Copy + Div<T, Output = T>> Div<Projection<T>> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the / operator.

fn div(self, rhs: Projection<T>) -> Self::Output

Performs the / operation.

impl<T: Copy + Div<T, Output = T>> Div<T> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Copy + Div<T, Output = T>> Div<T> for Projection<T>

type Output = Projection<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Div<T, Output = T>> Div for Projection<T>

type Output = Projection<T>

The resulting type after applying the / operator.

fn div(self, rhs: Projection<T>) -> Self::Output

Performs the / operation.

impl<T: Copy + DivAssign<T>> DivAssign<&Projection<T>> for Projection<T>

fn div_assign(&mut self, rhs: &Projection<T>)

Performs the /= operation.

impl<T: Copy + DivAssign<T>> DivAssign<&T> for Projection<T>

fn div_assign(&mut self, rhs: &T)

Performs the /= operation.

impl<T: Copy + DivAssign<T>> DivAssign<T> for Projection<T>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: DivAssign<T>> DivAssign for Projection<T>

fn div_assign(&mut self, rhs: Projection<T>)

Performs the /= operation.

impl<T> From<[T; 2]> for Projection<T>

fn from([min, max]: [T; 2]) -> Self

Converts to this type from the input type.

impl<T> From<(T, T)> for Projection<T>

fn from((min, max): (T, T)) -> Self

Converts to this type from the input type.

impl<T> From<Projection<T>> for [T; 2]

fn from(_: Projection<T>) -> [T; 2]

Converts to this type from the input type.

impl<T> From<Projection<T>> for (T, T)

fn from(_: Projection<T>) -> (T, T)

Converts to this type from the input type.

impl<T: Hash> Hash for Projection<T>

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: Copy + Mul<T, Output = T>> Mul<&Projection<T>> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Projection<T>) -> Self::Output

Performs the * operation.

impl<T: Copy + Mul<T, Output = T>> Mul<&Projection<T>> for Projection<T>

type Output = Projection<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Projection<T>) -> Self::Output

Performs the * operation.

impl<T: Copy + Mul<T, Output = T>> Mul<Projection<T>> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Projection<T>) -> Self::Output

Performs the * operation.

impl<T: Copy + Mul<T, Output = T>> Mul<T> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Copy + Mul<T, Output = T>> Mul<T> for Projection<T>

type Output = Projection<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Mul<T, Output = T>> Mul for Projection<T>

type Output = Projection<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Projection<T>) -> Self::Output

Performs the * operation.

impl<T: Copy + MulAssign<T>> MulAssign<&Projection<T>> for Projection<T>

fn mul_assign(&mut self, rhs: &Projection<T>)

Performs the *= operation.

impl<T: Copy + MulAssign<T>> MulAssign<&T> for Projection<T>

fn mul_assign(&mut self, rhs: &T)

Performs the *= operation.

impl<T: Copy + MulAssign<T>> MulAssign<T> for Projection<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: MulAssign<T>> MulAssign for Projection<T>

fn mul_assign(&mut self, rhs: Projection<T>)

Performs the *= operation.

impl<T: Neg<Output = T>> Neg for Projection<T>

type Output = Projection<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Numeric<AsU8 = u8, AsU16 = u16, AsU32 = u32, AsU64 = u64, AsU128 = u128, AsUSize = usize, AsI8 = i8, AsI16 = i16, AsI32 = i32, AsI64 = i64, AsI128 = i128, AsISize = isize, AsF32 = f32, AsF64 = f64>> Numeric for Projection<T>

type AsU8 = Projection<u8>

type AsU16 = Projection<u16>

type AsU32 = Projection<u32>

type AsU64 = Projection<u64>

type AsU128 = Projection<u128>

type AsUSize = Projection<usize>

type AsI8 = Projection<i8>

type AsI16 = Projection<i16>

type AsI32 = Projection<i32>

type AsI64 = Projection<i64>

type AsI128 = Projection<i128>

type AsISize = Projection<isize>

type AsF32 = Projection<f32>

type AsF64 = Projection<f64>

fn to_u8(self) -> Projection<u8>

fn to_u16(self) -> Projection<u16>

fn to_u32(self) -> Projection<u32>

fn to_u64(self) -> Projection<u64>

fn to_u128(self) -> Projection<u128>

fn to_usize(self) -> Projection<usize>

fn to_i8(self) -> Projection<i8>

fn to_i16(self) -> Projection<i16>

fn to_i32(self) -> Projection<i32>

fn to_i64(self) -> Projection<i64>

fn to_i128(self) -> Projection<i128>

fn to_isize(self) -> Projection<isize>

fn to_f32(self) -> Projection<f32>

fn to_f64(self) -> Projection<f64>

impl<T: Ord> Ord for Projection<T>

fn cmp(&self, other: &Projection<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for Projection<T>

fn eq(&self, other: &Projection<T>) -> 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: PartialOrd> PartialOrd for Projection<T>

fn partial_cmp(&self, other: &Projection<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> RelativeEq for Projection<T>

where T: RelativeEq, T::Epsilon: Copy,

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl<T: Copy + Rem<T, Output = T>> Rem<&Projection<T>> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &Projection<T>) -> Self::Output

Performs the % operation.

impl<T: Copy + Rem<T, Output = T>> Rem<&Projection<T>> for Projection<T>

type Output = Projection<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &Projection<T>) -> Self::Output

Performs the % operation.

impl<T: Copy + Rem<T, Output = T>> Rem<Projection<T>> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Projection<T>) -> Self::Output

Performs the % operation.

impl<T: Copy + Rem<T, Output = T>> Rem<T> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

impl<T: Copy + Rem<T, Output = T>> Rem<T> for Projection<T>

type Output = Projection<T>

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

impl<T: Rem<T, Output = T>> Rem for Projection<T>

type Output = Projection<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Projection<T>) -> Self::Output

Performs the % operation.

impl<T: Copy + RemAssign<T>> RemAssign<&Projection<T>> for Projection<T>

fn rem_assign(&mut self, rhs: &Projection<T>)

Performs the %= operation.

impl<T: Copy + RemAssign<T>> RemAssign<&T> for Projection<T>

fn rem_assign(&mut self, rhs: &T)

Performs the %= operation.

impl<T: Copy + RemAssign<T>> RemAssign<T> for Projection<T>

fn rem_assign(&mut self, rhs: T)

Performs the %= operation.

impl<T: RemAssign<T>> RemAssign for Projection<T>

fn rem_assign(&mut self, rhs: Projection<T>)

Performs the %= operation.

impl<T: Serialize> Serialize for Projection<T>

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Copy + Sub<T, Output = T>> Sub<&Projection<T>> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Projection<T>) -> Self::Output

Performs the - operation.

impl<T: Copy + Sub<T, Output = T>> Sub<&Projection<T>> for Projection<T>

type Output = Projection<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Projection<T>) -> Self::Output

Performs the - operation.

impl<T: Copy + Sub<T, Output = T>> Sub<Projection<T>> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Projection<T>) -> Self::Output

Performs the - operation.

impl<T: Copy + Sub<T, Output = T>> Sub<T> for &Projection<T>

type Output = Projection<T>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T: Copy + Sub<T, Output = T>> Sub<T> for Projection<T>

type Output = Projection<T>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T: Sub<T, Output = T>> Sub for Projection<T>

type Output = Projection<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Projection<T>) -> Self::Output

Performs the - operation.

impl<T: Copy + SubAssign<T>> SubAssign<&Projection<T>> for Projection<T>

fn sub_assign(&mut self, rhs: &Projection<T>)

Performs the -= operation.

impl<T: Copy + SubAssign<T>> SubAssign<&T> for Projection<T>

fn sub_assign(&mut self, rhs: &T)

Performs the -= operation.

impl<T: Copy + SubAssign<T>> SubAssign<T> for Projection<T>

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T: SubAssign<T>> SubAssign for Projection<T>

fn sub_assign(&mut self, rhs: Projection<T>)

Performs the -= operation.

impl<T> UlpsEq for Projection<T>

where T: UlpsEq, T::Epsilon: Copy,

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of UlpsEq::ulps_eq.

impl<T: Zeroable> Zeroable for Projection<T>

fn zeroed() -> Self

Calls zeroed.

impl<T: Copy> Copy for Projection<T>

impl<T: Eq> Eq for Projection<T>

impl<T: Pod> Pod for Projection<T>

impl<T> StructuralPartialEq for Projection<T>