Struct Clip 

#[repr(C)]
pub struct Clip {
    pub rect: Rect,
    pub radius: [f32; 4],
    pub transform: Transform,
    pub inner: Rect,
    pub inner_radius: [f32; 4],
}

The clip a node inherits: a rect, and the radii to round its corners by.

A node that clips (clip, scroll_x, scroll_y) and has a radius rounds what it clips — the way CSS rounds overflow: hidden under a border-radius — so the children of a rounded card stay inside its corners instead of poking out of them. Nothing declares this: the radii are the clipping node’s own.

One rounded rect cannot name the intersection of two, so nesting is approximated by Clip::intersect, which says what it gives up.

An entry is the space a quad is painted in, not only what cuts it (ADR 0043): transform is the similarity every quad naming it is drawn through — the identity on every entry of a frame with no rotate or scale — and inner is a second clip in the quad’s own space, before the transform, from clipping nodes inside a turned subtree. rect and radius stay the clip in framebuffer space, from clipping nodes outside any turn. A backend that reads only rect and radius draws a turned subtree upright and cut by its outer clip, which is what every backend did before.

Fields

rect: Rect

radius: [f32; 4]

Clockwise from the top-left: [tl, tr, br, bl]. All zero = a plain rect clip.

transform: Transform

The turn, scale and move every quad naming this entry is drawn through: pixel = R(angle) · scale · p + (tx, ty) for p a point of the quad’s own rect. The identity when nothing turns.

inner: Rect

The clip in the quad’s own space, before transform: what a clipping node inside a turned subtree cuts. NO_CLIP when nothing inside the turn clips, and on every entry of a frame with no turn.

inner_radius: [f32; 4]

inner’s corner radii, as radius is rect’s.

Implementations

impl Clip

pub const NONE: Clip

A clip that clips nothing.

pub fn rect(rect: Rect) -> Clip

A plain rect clip.

pub fn scaled(&self, s: f32) -> Clip

Logical to physical pixels.

pub fn turned(&self) -> bool

Whether every quad naming this entry is drawn through a turn or a scale.

pub fn turned_by(&self, own: Transform) -> Clip

This space, entered by a node that turns by own (about its pivot, in this space’s own coordinates): the transform composes, the outer clip is untouched, and the inner clip is pulled back into the new space as its bounding box there, its corners square (ADR 0043, decision 4: a clip between two nested turns is approximated).

pub fn visible(&self) -> Rect

The rect, in the quad’s own space, outside which nothing it draws can show: rect itself when nothing turns, else the inner clip narrowed by the outer one pulled back through the transform. What a glyph cull and a visibility test read, since both compare positions in the quad’s space.

pub fn shown(&self, rect: Rect) -> Rect

Where rect, a box in the quad’s own space, shows on screen: itself cut to the clip when nothing turns, else the bounding box of its turned shape, cut to the outer clip. What the access tree reports (ADR 0043, decision 7).

pub fn intersect(&self, box_rect: Rect, box_radius: [f32; 4]) -> Clip

This clip narrowed by a clipping node’s box and that node’s radii.

The rect is the plain intersection, as it has always been. The radii are decided per corner: a corner takes whichever of the two shapes rounds it more (the intersection of two rounded corners is the tighter one), and only while that corner of the result is still the same point as that corner of the shape it came from — a corner an ancestor’s straight edge has already cut away is square, which is what that ancestor made it.

The one case it approximates: an ancestor edge that cuts partway into a rounded corner moves that corner, so its radius drops to zero and a sliver at the very corner goes unclipped. A second clipper offset from the first, both rounded, is the shape that does it.

Under a turn the box is in the quad’s own space, so it narrows the inner clip and leaves the framebuffer one alone (ADR 0043).

Trait Implementations

impl Clone for Clip

fn clone(&self) -> Clip

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Clip

impl Debug for Clip

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

Formats the value using the given formatter.

impl PartialEq for Clip

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Clip