Struct slint::platform::software_renderer::SoftwareRenderer

pub struct SoftwareRenderer { /* private fields */ }

A Renderer that do the rendering in software

The renderer can remember what items needs to be redrawn from the previous iteration.

There are two kind of possible rendering

1. Using render() to render the window in a buffer
2. Using render_by_line() to render the window line by line. This is only useful if the device does not have enough memory to render the whole window in one single buffer

Implementations

impl SoftwareRenderer

pub fn new( repaint_buffer_type: RepaintBufferType, window: Weak<dyn WindowAdapter + 'static> ) -> SoftwareRenderer

Create a new Renderer for a given window.

The repaint_buffer_type parameter specify what kind of buffer are passed to Self::render

The window parameter can be coming from Rc::new_cyclic() since the WindowAdapter most likely own the Renderer

pub fn render( &self, buffer: &mut [impl TargetPixel], pixel_stride: usize ) -> PhysicalRegion

Render the window to the given frame buffer.

The renderer uses a cache internally and will only render the part of the window which are dirty. The extra_draw_region is an extra regin which will also be rendered. (eg: the previous dirty region in case of double buffering) This function returns the region that was rendered.

returns the dirty region for this frame (not including the extra_draw_region)

pub fn render_by_line( &self, line_buffer: impl LineBufferProvider ) -> PhysicalRegion

Render the window, line by line, into the line buffer provided by the LineBufferProvider.

The renderer uses a cache internally and will only render the part of the window which are dirty, depending on the dirty tracking policy set in SoftwareRenderer::new This function returns the region that was rendered.

The LineBufferProvider::process_line() function will be called for each line and should provide a buffer to draw into.

As an example, let’s imagine we want to render into a plain buffer. (You wouldn’t normally use render_by_line for that because the Self::render would then be more efficient)

struct FrameBuffer<'a>{ frame_buffer: &'a mut [Rgb565Pixel], stride: usize }
impl<'a> LineBufferProvider for FrameBuffer<'a> {
    type TargetPixel = Rgb565Pixel;
    fn process_line(
        &mut self,
        line: usize,
        range: core::ops::Range<usize>,
        render_fn: impl FnOnce(&mut [Self::TargetPixel]),
    ) {
        let line_begin = line * self.stride;
        render_fn(&mut self.frame_buffer[line_begin..][range]);
        // The line has been rendered and there could be code here to
        // send the pixel to the display
    }
}
renderer.render_by_line(FrameBuffer{ frame_buffer: the_frame_buffer, stride: display_width });