Struct runa_orbiter::utils::geometry::Point

#[repr(C)]
pub struct Point<N, Kind: CoordinateSpace> {
    pub x: N,
    pub y: N,
    /* private fields */
}

A point as defined by its x and y coordinates

Operations on points are saturating.

Fields

x: N

horizontal coordinate

y: N

vertical coordinate

Implementations

impl<N, Kind: CoordinateSpace> Point<N, Kind>

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

Create a new point

impl<N: Sign + Copy + Debug, Kind: CoordinateSpace> Point<N, Kind>

pub fn to_size(self) -> Extent<N, Kind>

Convert this Point to a Extent with the same coordinates

Checks that the coordinates are positive with a debug_assert!().

pub fn to_size_abs(self) -> Extent<N, Kind>

Convert this Point to a Extent with the same coordinates

Ensures that the coordinates are positive by taking their absolute value

impl<N: Copy + SaturatingMul, Kind: CoordinateSpace> Point<N, Kind>

pub fn saturating_mul(self, scale: Scale<N>) -> Point<N, Kind>

Multiply this point by a scale, if the result will overflow, saturate to the maximum value.

impl<N: Ord + Copy, Kind: CoordinateSpace> Point<N, Kind>

pub fn clamp(self, rect: Rectangle<N, Kind>) -> Point<N, Kind>

Clamp this Point to within a Rectangle with in the same coordinate space.

The Point returned is guaranteed to be within the Rectangle

impl<N: Approx, Kind: CoordinateSpace> Point<N, Kind>

pub fn round(self) -> Self

Round the coordinates to the nearest integer

pub fn floor(self) -> Self

Truncate the coordinates to the largest integer less than or equal to the coordinate.

pub fn ceil(self) -> Self

Round up the coordinates to the smallest integer greater than or equal to the coordinate.

impl<N, Kind: CoordinateSpace> Point<N, Kind>

pub fn to<M: Copy + 'static>(self) -> Point<M, Kind>where N: AsPrimitive<M>,

Convert the number type of a point.

Trait Implementations

impl<N: Add<Output = N> + Copy, Kind: CoordinateSpace> Add<Extent<N, Kind>> for Point<N, Kind>

type Output = Point<N, Kind>

The resulting type after applying the + operator.

fn add(self, other: Extent<N, Kind>) -> Point<N, Kind>

Performs the + operation.

impl<N: Add<Output = N> + Copy, Kind: CoordinateSpace> Add<Point<N, Kind>> for Point<N, Kind>

type Output = Point<N, Kind>

The resulting type after applying the + operator.

fn add(self, other: Point<N, Kind>) -> Point<N, Kind>

Performs the + operation.

impl<N: Add<Output = N> + Copy, Kind: CoordinateSpace> AddAssign<Point<N, Kind>> for Point<N, Kind>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<N: Clone, Kind: Clone + CoordinateSpace> Clone for Point<N, Kind>

fn clone(&self) -> Point<N, Kind>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Debug, Kind: Debug + CoordinateSpace> Debug for Point<N, Kind>

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

Formats the value using the given formatter.

impl<N: Zero + Copy, Kind: CoordinateSpace> Default for Point<N, Kind>

fn default() -> Self

Returns the “default value” for a type.

impl<N: Copy + Div<Output = N>, Kind: CoordinateSpace> Div<Scale<N>> for Point<N, Kind>

type Output = Point<N, Kind>

The resulting type after applying the / operator.

fn div(self, scale: Scale<N>) -> Self::Output

Performs the / operation.

impl<N: Hash, Kind: Hash + CoordinateSpace> Hash for Point<N, Kind>

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<N, Kind: CoordinateSpace> Map for Point<N, Kind>

type Output<Kind2> where Kind2: CoordinateSpace = Point<N, Kind2>

The output type with the new coordinate space.

fn map<Kind2: CoordinateSpace>( self, f: impl FnOnce(Point<N, Kind2>) -> Point<N, Kind2> ) -> Point<N, Kind2>

Map from one coordinate space to another by applying a function.

impl<N: Copy + Mul<Output = N>, Kind: CoordinateSpace> Mul<Scale<N>> for Point<N, Kind>

type Output = Point<N, Kind>

The resulting type after applying the * operator.

fn mul(self, scale: Scale<N>) -> Self::Output

Performs the * operation.

impl<N: PartialEq, Kind: PartialEq + CoordinateSpace> PartialEq<Point<N, Kind>> for Point<N, Kind>

fn eq(&self, other: &Point<N, Kind>) -> 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<N: SaturatingAdd + Copy, Kind: CoordinateSpace> SaturatingAdd for Point<N, Kind>

fn saturating_add(&self, other: &Self) -> Self

Saturating addition. Computes self + other, saturating at the relevant high or low boundary of the type.

impl<N: Sub<Output = N> + Copy, Kind: CoordinateSpace> Sub<Extent<N, Kind>> for Point<N, Kind>

type Output = Point<N, Kind>

The resulting type after applying the - operator.

fn sub(self, other: Extent<N, Kind>) -> Point<N, Kind>

Performs the - operation.

impl<N: Sub<Output = N> + Copy, Kind: CoordinateSpace> Sub<Point<N, Kind>> for Point<N, Kind>

type Output = Point<N, Kind>

The resulting type after applying the - operator.

fn sub(self, other: Point<N, Kind>) -> Point<N, Kind>

Performs the - operation.

impl<N: Sub<Output = N> + Copy, Kind: CoordinateSpace> SubAssign<Point<N, Kind>> for Point<N, Kind>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<N: Copy, Kind: Copy + CoordinateSpace> Copy for Point<N, Kind>

impl<N: Eq, Kind: Eq + CoordinateSpace> Eq for Point<N, Kind>

impl<N, Kind: CoordinateSpace> StructuralEq for Point<N, Kind>

impl<N, Kind: CoordinateSpace> StructuralPartialEq for Point<N, Kind>