Struct Recorder 

pub struct Recorder<'a> { /* private fields */ }

Renderer adapter that records structured AA draws into a CommandList. Unstructured ops (draw_text, draw_pixels) and blend_row forward immediately to a passthrough renderer rather than recording — see module docs for the lifetime/alloc rationale.

Typical usage:

let mut list = CommandList::new();
{
    let mut sink = NullRenderer::default(); // or any "do nothing" renderer
    let mut recorder = Recorder::new(&mut list, &mut sink);
    widget.draw(&mut recorder);
}
// list now contains the structured draws

Implementations

impl<'a> Recorder<'a>

pub fn new(list: &'a mut CommandList, passthrough: &'a mut dyn Renderer) -> Self

Create a recorder writing structured draws into list and forwarding unstructured ops to passthrough.

Trait Implementations

impl Renderer for Recorder<'_>

fn fill_rect(&mut self, rect: Rect, color: Color)

Fill the given rectangle with a solid color.

fn blend_rect(&mut self, rect: Rect, color: Color)

Blend a rectangle onto the target, honoring the alpha channel of color for source-over compositing.

fn fill_obb_aa(&mut self, obb: Obb, color: Color)

Fill an oriented bounding box with anti-aliased coverage.

fn fill_disc_aa(&mut self, center: PointF, radius: f32, color: Color)

Fill a disc (filled circle) with anti-aliased coverage at the boundary. Sub-pixel center; sqrt is restricted to the 1-pixel AA ring so the inner-area fast-path stays integer-arithmetic only.

fn fill_arc_aa( &mut self, center: PointF, r_outer: f32, r_inner: f32, start_cos: f32, start_sin: f32, end_cos: f32, end_sin: f32, extent: f32, color: Color, )

Fill an annular arc / pie slice with anti-aliased coverage. See raster::rasterize_arc for the angle convention; in short, (start_cos, start_sin) and (end_cos, end_sin) are pre-computed boundary-ray unit vectors and extent is the signed angular magnitude. r_inner = 0.0 produces a pie slice; r_inner > 0.0 produces a ring segment.

fn stroke_line_aa(&mut self, a: PointF, b: PointF, width: f32, color: Color)

Stroke a line between a and b with given width, anti-aliased. Endpoints are square-cut; see raster::rasterize_line.

fn draw_text(&mut self, position: (i32, i32), text: &str, color: Color)

Draw UTF‑8 text with its baseline anchored at the provided position using the color.

fn draw_pixels( &mut self, position: (i32, i32), pixels: &[Color], width: u32, height: u32, )

Blit a buffer of pixels to the target at the given position.

fn blend_row(&mut self, x: i32, y: i32, color: Color, coverage: &[u8])

Blend a horizontal run of pixels with per-pixel anti-aliased coverage.

fn draw_text_shaped( &mut self, shaped: &ShapedText<'_>, origin: (i32, i32), color: Color, )

Draw a pre-shaped text run using glyph extent information.

fn draw_glyph( &mut self, font: &dyn FontMetrics, ch: char, origin: (i32, i32), color: Color, )

Draw a single glyph’s coverage with its pen origin on the baseline at origin (the same anchor convention as draw_text).

fn blit_image( &mut self, dest: Rect, descriptor: &ImageDescriptor<'_>, opts: &BlitOpts, )

Blit an ImageDescriptor into dest using deterministic software sampling.

fn fill_masked(&mut self, rect: Rect, color: Color, mask: &dyn AlphaMask)

Fill rect with color modulated by an alpha mask.

fn fill_gradient(&mut self, rect: Rect, gradient: &GradientDesc<'_>)

Fill rect with a deterministic software gradient.

fn draw_shadow(&mut self, rect: Rect, radius: u8, shadow: &ShadowDesc)

Draw a deterministic software box shadow below rect.

fn submit(&mut self, list: &CommandList)

Execute a captured CommandList against this renderer.