Struct runa_orbiter::utils::geometry::Rectangle

#[repr(C)]
pub struct Rectangle<N, Kind: CoordinateSpace> {
    pub loc: Point<N, Kind>,
    pub size: Extent<N, Kind>,
}

A rectangle defined by its top-left corner and dimensions

Operations on rectangles are saturating.

Fields

loc: Point<N, Kind>

Location of the top-left corner of the rectangle

size: Extent<N, Kind>

Extent of the rectangle, as (width, height)

Implementations

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

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

Convert the underlying numerical type to another

impl<N: SaturatingMul + Sign + Copy, Kind: CoordinateSpace> Rectangle<N, Kind>

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

Upscale this Rectangle by the supplied Scale

impl<N: Zero + Eq, Kind: CoordinateSpace> Rectangle<N, Kind>

pub fn is_empty(&self) -> bool

Check if this Rectangle is empty

Returns true if either the width or the height of the Extent is zero

impl<N: Approx + Sign + Sub<Output = N> + Add<Output = N> + Copy, Kind: CoordinateSpace> Rectangle<N, Kind>

pub fn round(self) -> Rectangle<N, Kind>

Round the rectangle’s position and size to the nearest integer.

pub fn shrink(self) -> Rectangle<N, Kind>

Shrink the rectangle to the biggest integer sized and positioned rectangle within the original rectangle.

pub fn expand(self) -> Rectangle<N, Kind>

Expand the rectangle to the smallest integer sized and positioned rectangle encapsulating the original rectangle.

impl<N: Copy, Kind: CoordinateSpace> Rectangle<N, Kind>

pub fn from_loc_and_size(loc: Point<N, Kind>, size: Extent<N, Kind>) -> Self

Create a new Rectangle from the coordinates of its top-left corner and its dimensions

impl<N: Sign + Sub<Output = N> + Copy, Kind: CoordinateSpace> Rectangle<N, Kind>

pub fn from_extemities( topleft: Point<N, Kind>, bottomright: Point<N, Kind> ) -> Self

Create a new Rectangle from the coordinates of its top-left corner and its bottom-right corner

impl<N: Sub<Output = N> + Ord, Kind: CoordinateSpace> Rectangle<N, Kind>

pub fn contains(self, p: Point<N, Kind>) -> bool

Checks whether given Point is inside the rectangle

pub fn contains_rect<R: Into<Rectangle<N, Kind>>>(self, rect: R) -> bool

Checks whether given Rectangle is inside the rectangle

This includes rectangles with the same location and size

impl<N: Ord + Sign + Sub<Output = N> + Zero + Copy, Kind: CoordinateSpace> Rectangle<N, Kind>

pub fn bounding_box(points: impl IntoIterator<Item = Point<N, Kind>>) -> Self

Compute the bounding box of a given set of points

pub fn merge(self, other: Self) -> Self

Merge two Rectangle by producing the smallest rectangle that contains both

impl<N: SaturatingAdd + Ord, Kind: CoordinateSpace> Rectangle<N, Kind>

pub fn overlaps(self, other: &Rectangle<N, Kind>) -> bool

Checks whether a given Rectangle overlaps with this one

Trait Implementations

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

fn clone(&self) -> Rectangle<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 Rectangle<N, Kind>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

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

fn div(self, scale: Scale<N>) -> Rectangle<N, Kind>

Upscale this Rectangle by the supplied Scale

type Output = Rectangle<N, Kind>

The resulting type after applying the / operator.

impl<N: Hash, Kind: Hash + CoordinateSpace> Hash for Rectangle<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: Sign + Copy, Kind: CoordinateSpace> Map for Rectangle<N, Kind>

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

Convert this physical rectangle to logical coordinate space according to given scale factor

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

The output type with the new coordinate space.

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

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

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

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

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