Struct tge::prelude::Region

pub struct Region<N: Number = f32> {
    pub x: N,
    pub y: N,
    pub width: N,
    pub height: N,
}

Fields

x: N

y: N

width: N

height: N

Implementations

impl<N: Number> Region<N>

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

pub fn position_size(position: Position<N>, size: Size<N>) -> Self

pub fn min_max(min: Position<N>, max: Position<N>) -> Self

pub fn edge(left: N, right: N, top: N, bottom: N) -> Self

pub fn zero() -> Self

pub fn none() -> Option<Self>

pub fn position(&self) -> Position<N>

pub fn set_position(&mut self, position: Position<N>)

pub fn size(&self) -> Size<N>

pub fn set_size(&mut self, size: Size<N>)

pub fn min_x(&self) -> N

pub fn set_min_x(&mut self, min_x: N)

pub fn min_y(&self) -> N

pub fn set_min_y(&mut self, min_y: N)

pub fn min(&self) -> Position<N>

pub fn set_min(&mut self, min: Position<N>)

pub fn max_x(&self) -> N

pub fn set_max_x(&mut self, max_x: N)

pub fn max_y(&self) -> N

pub fn set_max_y(&mut self, max_y: N)

pub fn max(&self) -> Position<N>

pub fn set_max(&mut self, max: Position<N>)

pub fn left(&self) -> N

pub fn set_left(&mut self, left: N)

pub fn right(&self) -> N

pub fn set_right(&mut self, right: N)

pub fn top(&self) -> N

pub fn set_top(&mut self, top: N)

pub fn bottom(&self) -> N

pub fn set_bottom(&mut self, bottom: N)

pub fn top_left(&self) -> Position<N>

pub fn top_right(&self) -> Position<N>

pub fn bottom_left(&self) -> Position<N>

pub fn bottom_right(&self) -> Position<N>

Trait Implementations

impl<N: Clone + Number> Clone for Region<N>

fn clone(&self) -> Region<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Copy + Number> Copy for Region<N>

impl<N: Debug + Number> Debug for Region<N>

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

Formats the value using the given formatter.

impl<N: Number> From<(N, N, N, N)> for Region<N>

fn from((x, y, width, height): (N, N, N, N)) -> Self

Performs the conversion.

impl<N: Number> Into<(N, N, N, N)> for Region<N>

fn into(self) -> (N, N, N, N)

Performs the conversion.

impl<N: PartialEq + Number> PartialEq<Region<N>> for Region<N>

fn eq(&self, other: &Region<N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Region<N>) -> bool

This method tests for !=.

impl<N: Number> StructuralPartialEq for Region<N>