Enum QuadKind 

#[repr(u32)]
pub enum QuadKind {
    Solid = 0,
    GlyphMask = 1,
    GlyphColor = 2,
    Image = 3,
    GlyphSubpixel = 4,
    Shadow = 5,
    Segment = 6,
    Fragment = 7,
    Texture = 8,
    Backdrop = 9,
}

Variants

Solid = 0

Rounded rect with optional border; ignores uv.

GlyphMask = 1

Alpha-mask glyph: atlas alpha times color.

GlyphColor = 2

Color bitmap glyph (emoji): atlas rgb, alpha times color.a.

Image = 3

Registered image blitted into the atlas: atlas rgba tinted by color (white = as-is), rounded by radius like a solid. border_w is the sampling flag — 0 linear, 1 nearest — a slot this kind had no other use for; blur is 0.

GlyphSubpixel = 4

LCD subpixel glyph: atlas rgb is per-channel coverage (times color.a), color.rgb the text color. Needs per-channel (dual source) blending; a backend without it treats the atlas alpha as a plain mask.

Shadow = 5

Drop shadow: color filling a rounded rect inset from rect by blur on every side, its edge ramped over blur px. The core emits it just before the node’s own quads, already offset and spread, so a backend only has to soften the SDF it already computes. Ignores uv, border_color and border_w.

Segment = 6

A round-capped stroke between two endpoints. uv holds the endpoints as [x0, y0, x1, y1] in physical px, each an f32 stored through to_bits — Quad::segment_ends reads them back — border_w is the stroke width and color the stroke. rect is the bounding box, the endpoints inflated by half the width plus two logical px so the edge ramp is never cut by the quad’s own edge. A backend evaluates an SDF capsule against the fragment’s position. Ignores radius, border_color and blur.

Fragment = 7

A box a host-registered WGSL function paints. uv[0] indexes DisplayList::fragments, which carries the handle and the sixteen parameters; the other three words of uv are zero. rect, radius, clip and clip_radius are the node’s and mean what they mean everywhere else — the backend rounds and clips a fragment exactly as it rounds and clips a solid. color carries the group opacity in its alpha and nothing else (rgb is zero), because a fragment returns its own colour and a faded subtree still has to fade it. border_color, border_w and blur are zero and ignored. A backend that cannot draw one — anything predating this kind — draws nothing, which is what a missing handle does too.

Texture = 8

A registered image drawn from a texture of its own rather than the atlas: one that did not fit a page, or whose pixels the app has replaced. uv[0] indexes DisplayList::textures, which carries the handle and the texel rect in that texture; the other three words of uv are zero. Everything else is what an Image quad’s is — rect, radius, clip, color as a tint (white = as-is) with the group opacity in its alpha, and border_w the sampling flag. A backend binds the texture in place of the atlas for the run and draws it as an Image; one that predates the kind draws nothing.

Backdrop = 9

Blur what is already drawn beneath rect — CSS’s backdrop-filter: blur(), a node’s backdrop_blur (backlog F129). blur is the radius in physical px; radius, clip and the clip’s radii shape the region as they shape a solid; color carries the group opacity in its alpha (rgb zero), how much of the blurred picture replaces the sharp one. The core emits it just before the node’s own background, so what the node paints lies on top of the blur. It paints nothing of its own: a backend reads back the pixels drawn so far under the rect (plus a margin of blur so the edge pulls in what lies outside it), blurs them, and writes them back inside the shape. A backend that cannot read its target — the CPU raster, anything predating the kind — draws nothing, which leaves the node over an unblurred backdrop.

Implementations

impl QuadKind

pub const ALL: [QuadKind; 10]

Every kind, in discriminant order — what the conformance report’s kinds line counts and the C header’s KUI_QUAD_* mirror.

Trait Implementations

impl Clone for QuadKind

fn clone(&self) -> QuadKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for QuadKind

impl Debug for QuadKind

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

Formats the value using the given formatter.

impl Eq for QuadKind

impl PartialEq for QuadKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for QuadKind