Enum Coverage 

pub enum Coverage {
    Empty,
    Bounded(Rect),
    Unbounded,
}

Where an entity lands, or that it lands nowhere, or that it lands wherever it is allowed to.

Three cases rather than a rectangle, because two of them are not rectangles. Nothing drawn has no bounds to report and must not be confused with a zero-area rectangle at the origin, which is a real place. And drawPaint covers whatever the clip admits, which is unbounded until a clip says otherwise – representing that as a very large rectangle would be a number chosen by whoever wrote it, and would be wrong at some scale.

Variants

Empty

Nothing is drawn.

Bounded(Rect)

Everything inside this rectangle, in device coordinates, may be.

Unbounded

Whatever the clip admits. Only a clip can bound this.

Implementations

impl Coverage

pub fn resolve(self, clip: Option<Rect>) -> Option<Rect>

The rectangle this covers, given what the clip admits.

None for nothing drawn. An unbounded coverage resolves to the clip, which is what makes an unclipped drawPaint the one case that cannot answer – the caller has to supply the target’s bounds as the clip.

pub fn clipped(self, clip: Rect) -> Self

Narrow by what a clip admits.

An unbounded coverage becomes the clip, which is the whole reason the unbounded case can be carried around at all rather than being resolved where it arises.

pub fn grown(self, reach: Vec2) -> Self

Grow outward by this much in each direction, in device pixels.

Growing nothing leaves nothing: a filter that reaches outward from a shape that was never drawn still draws nothing, and a blur of an empty region is empty rather than a soft patch of nowhere.

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

The smallest coverage containing both.

Trait Implementations

impl Clone for Coverage

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Coverage

impl Debug for Coverage

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

Formats the value using the given formatter.

impl PartialEq for Coverage

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Coverage