Trait RenderBackend 

pub trait RenderBackend {
    // Required methods
    fn clear(&mut self, color: Color);
    fn fill_rect(&mut self, x: f32, y: f32, w: f32, h: f32, color: Color);
    fn fill_circle(&mut self, cx: f32, cy: f32, radius: f32, color: Color);
    fn stroke_circle(
        &mut self,
        cx: f32,
        cy: f32,
        radius: f32,
        color: Color,
        width: f32,
    );
    fn stroke_arc(
        &mut self,
        cx: f32,
        cy: f32,
        radius: f32,
        start_angle: f32,
        end_angle: f32,
        color: Color,
        width: f32,
    );
    fn draw_line(
        &mut self,
        x1: f32,
        y1: f32,
        x2: f32,
        y2: f32,
        color: Color,
        width: f32,
    );
    fn draw_text(&mut self, text: &str, x: f32, y: f32, size: f32, color: Color);
    fn text_width(&self, text: &str, size: f32) -> f32;

    // Provided methods
    fn present(&mut self) { ... }
    fn register_image(
        &mut self,
        _rgba: &[u8],
        _width: u32,
        _height: u32,
    ) -> ImageId { ... }
    fn unregister_image(&mut self, _id: ImageId) { ... }
    fn draw_image(&mut self, _id: ImageId, x: f32, y: f32, w: f32, h: f32) { ... }
}

Abstraction over rendering backends (CPU via tiny-skia, GPU via wgpu).

Coordinate contract. All coordinates and font sizes are in logical points. Backends own the display scale factor internally and multiply inputs by it at raster time, so a widget drawn at (100, 100) with size = 14.0 has the same apparent size on 1× and 2× displays. Callers must not pre-multiply by scale.

Required Methods

fn clear(&mut self, color: Color)

Clear the entire surface with a solid color.

fn fill_rect(&mut self, x: f32, y: f32, w: f32, h: f32, color: Color)

Fill a rectangle.

fn fill_circle(&mut self, cx: f32, cy: f32, radius: f32, color: Color)

Fill a circle.

fn stroke_circle( &mut self, cx: f32, cy: f32, radius: f32, color: Color, width: f32, )

Stroke a circle outline.

fn stroke_arc( &mut self, cx: f32, cy: f32, radius: f32, start_angle: f32, end_angle: f32, color: Color, width: f32, )

Stroke an arc (portion of a circle).

fn draw_line( &mut self, x1: f32, y1: f32, x2: f32, y2: f32, color: Color, width: f32, )

Draw a line between two points.

fn draw_text(&mut self, text: &str, x: f32, y: f32, size: f32, color: Color)

Draw text using the embedded TrueType font (fontdue).

fn text_width(&self, text: &str, size: f32) -> f32

Measure the width of a text string in logical points, at the given logical-point font size.

Provided Methods

fn present(&mut self)

Flush rendering to the display surface.

No-op for CPU backends (pixels are read directly from the buffer). GPU backends submit their command buffer and present here.

fn register_image(&mut self, _rgba: &[u8], _width: u32, _height: u32) -> ImageId

Register an RGBA8 image (premultiplied alpha, row-major, tightly packed).

Returned id is valid until unregister_image is called or the backend is dropped. Returns ImageId::INVALID if the backend does not support images.

fn unregister_image(&mut self, _id: ImageId)

Remove a previously-registered image. No-op if the id is invalid or already unregistered.

fn draw_image(&mut self, _id: ImageId, x: f32, y: f32, w: f32, h: f32)

Draw a previously-registered image at (x, y) sized w × h.

Sampling is linear. The image is scaled to fill the target rect. The default impl draws a magenta rect so missing backend support is visually obvious.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors