Struct Point2d

pub struct Point2d<T = i64> {
    pub x: T,
    pub y: T,
}

A 2d point where you can choose the type and thus precision of the x and y indices. By default uses i64 which is the world coordinate type.

Fields

x: T

x position

y: T

y position

Implementations

impl<C: Chunk> Point2d<GridIndex<C>>

pub fn into_same_chunk_size<D: Chunk>(self) -> GridPoint<D>

When two Chunks have the same size, all their coordinates are trivially the same and we can convert them with just a compile-time check.

impl<T: Copy> Point2d<T>

pub const fn splat(arg: T) -> Self

Set x and y to the same value

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

Basic constructor for when struct constructors are too inconvenient

pub fn map<U>(&self, f: impl Fn(T) -> U) -> Point2d<U>

Apply a closure to both x and y

pub fn to(self, other: Self) -> Line<T>

Connect a line segment from this point to the argument.

impl<T: Neg<Output = T>> Point2d<T>

pub fn perp(self) -> Self

Return the perpendicular (right facing) vector of the same length.

impl<T: Copy + Sub<Output = T> + Mul<Output = T> + Add<Output = T> + Abs> Point2d<T>

pub fn dist_squared(self, center: Point2d<T>) -> T

The square of the distance between two points

pub fn len_squared(self) -> T

The square of the distance between the origin (0, 0) and this point.

pub fn manhattan_dist(self, city: Point2d<T>) -> T

The manhattan distance between two points.

pub fn manhattan_len(&self) -> T

The manhattan distance to the origin.

impl Point2d<i64>

pub const fn sub(self, rhs: Point2d) -> Point2d

Subtract two points element wise.

pub const fn mul(self, rhs: Point2d) -> Point2d

Multiply two points element wise.

pub fn to_ne_bytes(&self) -> [u8; 16]

Get the bytes of this point in native byte order.

Trait Implementations

impl<T: Add<Output = T>> Add for Point2d<T>

type Output = Point2d<T>

The resulting type after applying the + operator.

fn add(self, rhs: Point2d<T>) -> Point2d<T>

Performs the + operation.

impl<T: AddAssign> AddAssign for Point2d<T>

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

Performs the += operation.

impl<T: Clone> Clone for Point2d<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Point2d<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Point2d<T>

fn default() -> Point2d<T>

Returns the “default value” for a type.

impl<T> Distribution<Point2d<T>> for StandardUniform

where StandardUniform: Distribution<T>,

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Point2d<T>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl<T: DivAssign + Copy> Div<Point2d<T>> for Bounds<T>

type Output = Bounds<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: DivAssign + Copy> Div<T> for Point2d<T>

type Output = Point2d<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Div<Output = T>> Div for Point2d<T>

type Output = Point2d<T>

The resulting type after applying the / operator.

fn div(self, rhs: Point2d<T>) -> Point2d<T>

Performs the / operation.

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

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: DivAssign> DivAssign for Point2d<T>

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

Performs the /= operation.

impl From<Point2d<NonZero<u16>>> for Point2d

fn from(value: Point2d<NonZeroU16>) -> Self

Converts to this type from the input type.

impl<T: MulAssign + Copy> Mul<T> for Point2d<T>

type Output = Point2d<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Mul<Output = T>> Mul for Point2d<T>

type Output = Point2d<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Point2d<T>) -> Point2d<T>

Performs the * operation.

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

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: MulAssign> MulAssign for Point2d<T>

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

Performs the *= operation.

impl<T: Ord> Ord for Point2d<T>

fn cmp(&self, other: &Point2d<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 Point2d<T>

fn eq(&self, other: &Point2d<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 Point2d<T>

fn partial_cmp(&self, other: &Point2d<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: Sub<Output = T>> Sub for Point2d<T>

type Output = Point2d<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Point2d<T>) -> Point2d<T>

Performs the - operation.

impl<T: SubAssign> SubAssign for Point2d<T>

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

Performs the -= operation.

impl<T: Copy> Copy for Point2d<T>

impl<T: Eq> Eq for Point2d<T>

impl<T> StructuralPartialEq for Point2d<T>