Enum DrawPrimitive 

pub enum DrawPrimitive {
    Content,
    Blend {
        primitive: Box<DrawPrimitive>,
        blend_mode: BlendMode,
    },
    Rect {
        rect: Rect,
        brush: Brush,
        stroke: Option<Stroke>,
    },
    RoundRect {
        rect: Rect,
        brush: Brush,
        radii: CornerRadii,
        stroke: Option<Stroke>,
    },
    Arc {
        rect: Rect,
        brush: Brush,
        center: Point,
        radius: f32,
        start_angle: f32,
        sweep_angle: f32,
        stroke: Option<Stroke>,
        inner_radius: f32,
    },
    Line {
        rect: Rect,
        brush: Brush,
        start: Point,
        end: Point,
        stroke: Stroke,
    },
    Trapezoid {
        rect: Rect,
        brush: Brush,
        trapezoid: Trapezoid,
    },
    Image {
        rect: Rect,
        image: ImageBitmap,
        alpha: f32,
        color_filter: Option<ColorFilter>,
        sampling: ImageSampling,
        src_rect: Option<Rect>,
    },
    Text(Box<TextPrimitive>),
    Shadow(ShadowPrimitive),
}

One recorded draw operation, in scope coordinates. Renderers consume these in draw order.

Variants

Content

Marker emitted by draw_content() inside draw_with_content. This is consumed by the modifier pipeline and never rendered directly.

Blend

Wrapper to associate a draw primitive with a non-default blend mode.

Fields

primitive: Box<DrawPrimitive>

The primitive drawn with blend_mode.

blend_mode: BlendMode

How the wrapped primitive combines with what is already drawn.

Rect

A rectangle, filled or stroked.

Fields

rect: Rect

The rectangle in scope coordinates.

brush: Brush

Paint for the fill or the stroke.

stroke: Option<Stroke>

None fills the rect; Some strokes its outline, centered on the edge (so it bleeds width / 2 outside rect).

RoundRect

A rectangle with rounded corners, filled or stroked.

Fields

rect: Rect

The rectangle in scope coordinates.

brush: Brush

Paint for the fill or the stroke.

radii: CornerRadii

Corner radii of the rectangle, in logical pixels.

stroke: Option<Stroke>

None fills the rounded rect; Some strokes its outline, centered on the edge.

Arc

A circular band: a stroked arc, or a filled annular sector / pie wedge.

Angles are radians, 0 = +X, increasing clockwise on screen (see crate::stroke for the full convention).

• stroke = Some(_) — the band is radius ± width/2, its ends shaped by the stroke cap. inner_radius is ignored.
• stroke = None — the band is inner_radius ..= radius with flat (butt) radial ends; inner_radius = 0 is a filled pie wedge.

Fields

rect: Rect

Tight bounding box of the rendered band, caps included. Kept as the first field (like every other variant) so bbox/culling/clip logic treats an arc exactly like any other primitive.

brush: Brush

Paint for the arc.

center: Point

Center of the circle the arc lies on, in scope coordinates.

radius: f32

Radius of the stroked centerline, or the outer radius of a filled sector, in logical pixels.

start_angle: f32

Where the arc starts, in radians. 0 points along +X and angles increase clockwise on screen.

sweep_angle: f32

Angle swept from start_angle, in radians. A negative value sweeps counter-clockwise.

stroke: Option<Stroke>

Some strokes the arc; None fills the sector between inner_radius and radius.

inner_radius: f32

> 0 turns a filled wedge into an annular sector.

Line

A stroked straight segment from start to end, its ends shaped by the stroke’s cap: Compose’s drawLine.

Fields

rect: Rect

The box of the two ends; the stroke reaches half its width past it, as a stroked rect’s does past its rect.

brush: Brush

Paint for the line.

start: Point

Start of the segment, in scope coordinates.

end: Point

End of the segment, in scope coordinates.

stroke: Stroke

Width and cap of the line.

Trapezoid

One slice of a filled path, which the draw scope cuts a fill into so the GPU draws it: see Trapezoid.

Fields

rect: Rect

The rect brush resolves against: the draw scope’s own, as a path’s brush resolves in Compose.

brush: Brush

Paint for the slice.

trapezoid: Trapezoid

The slice to fill.

Image

An image drawn into a destination rectangle.

Fields

rect: Rect

Destination rectangle in scope coordinates. The image is stretched to fill it.

image: ImageBitmap

The image to draw.

alpha: f32

Opacity from 0.0 (transparent) to 1.0 (opaque).

color_filter: Option<ColorFilter>

Color filter applied to the image, or None for none.

sampling: ImageSampling

How pixels are sampled when the image is scaled.

src_rect: Option<Rect>

Optional source rectangle in image-pixel coordinates. When None, the entire image is drawn. When Some, only the specified sub-region of the source image is sampled.

Text(Box<TextPrimitive>)

A laid-out run of text. See TextPrimitive.

Shadow(ShadowPrimitive)

Shadow that requires blur processing. The renderer decides technique (GPU blur, CPU approximation, etc.).

Implementations

impl DrawPrimitive

pub fn translate(self, dx: f32, dy: f32) -> Self

The primitive moved by dx, dy. Brush geometry is relative to the primitive’s rect, so it moves along.

Trait Implementations

impl Clone for DrawPrimitive

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DrawPrimitive

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

Formats the value using the given formatter.

impl PartialEq for DrawPrimitive

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

Equality operator ==.

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

Inequality operator !=.

impl RenderHash for DrawPrimitive

fn render_hash(&self) -> u64

Returns a hash over exactly the values that change what is drawn. Equal values give equal hashes.

impl StructuralPartialEq for DrawPrimitive