Struct CpuBackend 

pub struct CpuBackend { /* private fields */ }

CPU-based rendering backend.

Wraps a tiny-skia Pixmap and implements RenderBackend using software rasterization. Zero GPU dependencies.

Implementations

impl CpuBackend

pub fn new(logical_w: u32, logical_h: u32, scale: f32) -> Option<CpuBackend>

Create a new CPU backend.

logical_w / logical_h are in logical points; scale is the display scale factor (2.0 on Retina, 1.0 otherwise). The internal pixmap is sized at logical × scale physical pixels.

pub fn resize(&mut self, logical_w: u32, logical_h: u32, scale: f32) -> bool

Reallocate the internal pixmap for a new logical size and/or scale factor. Call from a host-reported resize / DPI-change handler; a no-op if the resulting physical dimensions match the current pixmap.

pub fn data(&self) -> &[u8]

Raw pixel data (RGBA premultiplied, row-major, physical pixels).

pub fn width(&self) -> u32

Pixel buffer width (physical pixels).

pub fn height(&self) -> u32

Pixel buffer height (physical pixels).

pub fn scale(&self) -> f32

Display scale factor baked at construction.

Trait Implementations

impl RenderBackend for CpuBackend

All RenderBackend methods accept coordinates in logical points. The backend multiplies by self.scale before handing off to tiny-skia, so the pixmap is rasterized at physical-pixel density.

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.

fn register_image(&mut self, rgba: &[u8], width: u32, height: u32) -> ImageId

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

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.

fn present(&mut self)

Flush rendering to the display surface.