Struct runa_orbiter::utils::geometry::Extent

#[repr(C)]
pub struct Extent<N, Kind: CoordinateSpace> {
    pub w: N,
    pub h: N,
    /* private fields */
}

A size as defined by its width and height

Constructors of this type ensure that the values are always positive via debug_assert!(), however manually changing the values of the fields can break this invariant.

Operations on sizes are saturating.

Fields

w: N

width

h: N

height

Implementations

impl<N: Ord + Sign, Kind: CoordinateSpace> Extent<N, Kind>

pub fn clamp( self, min: Extent<N, Kind>, max: Extent<N, Kind> ) -> Extent<N, Kind>

Restrict this Extent to be within another Extent in the same coordinate system

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

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

Convert the underlying numerical type to f64 for floating point manipulations

impl<N: Sign, Kind: CoordinateSpace> Extent<N, Kind>

pub fn new(w: N, h: N) -> Self

Create a new extent from width and height

impl<N: Sign + Copy + Ord, Kind: CoordinateSpace> Extent<N, Kind>

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

Returns whether a point is contained in (0, 0)..=(w, h)

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

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

Upscale this Extent by a specified Scale

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

pub fn is_empty(&self) -> bool

Check if this Extent is empty

Returns true if either the width or the height is zero

impl<N: Approx + Sign, Kind: CoordinateSpace> Extent<N, Kind>

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

Convert to i32 for integer-space manipulations by rounding float values

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

Convert to i32 for integer-space manipulations by flooring float values

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

Convert to i32 for integer-space manipulations by ceiling float values

Trait Implementations

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

type Output = Extent<N, Kind>

The resulting type after applying the + operator.

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

Performs the + operation.

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> + Sign + Copy, Kind: CoordinateSpace> AddAssign<Extent<N, Kind>> for Extent<N, Kind>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

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

fn default() -> Self

Returns the “default value” for a type.

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

fn div(self, rhs: Extent<N, Kind>) -> Self::Output

Caculate the scale factor from one extent to another

type Output = Scale<N>

The resulting type after applying the / operator.

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

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

Downscale this Extent by a specified Scale

type Output = Extent<N, Kind>

The resulting type after applying the / operator.

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

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

Convert this physical point to logical coordinate space by scaling down according to given scale factor

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

The output type with the new coordinate space.

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

type Output = Extent<N, Kind>

The resulting type after applying the * operator.

fn mul(self, scale: Scale<N>) -> Extent<N, Kind>

Performs the * operation.

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

fn eq(&self, other: &Extent<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 + Sign + Copy, Kind: CoordinateSpace> SaturatingAdd for Extent<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: SaturatingSub + Ord + Sign + Copy + Debug, Kind: CoordinateSpace> SaturatingSub for Extent<N, Kind>

fn saturating_sub(&self, rhs: &Self) -> Self

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

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

type Output = Extent<N, Kind>

The resulting type after applying the - operator.

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

Performs the - operation.

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: Copy, Kind: Copy + CoordinateSpace> Copy for Extent<N, Kind>

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

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

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