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() -> SoftwareRenderer

Create a new Renderer

pub fn new_with_repaint_buffer_type( repaint_buffer_type: RepaintBufferType ) -> SoftwareRenderer

Create a new SoftwareRenderer.

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

pub fn set_repaint_buffer_type(&self, repaint_buffer_type: RepaintBufferType)

Change the what kind of buffer is being passed to Self::render

This may clear the internal caches

pub fn repaint_buffer_type(&self) -> RepaintBufferType

Returns the kind of buffer that must be passed to Self::render

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.

The pixel_stride is the size, in pixel, between two line in the buffer The buffer needs to be big enough to contain the window, so its size must be at least pixel_stride * height, or pixel_stride * width if the screen is rotated by 90°.

Returns the dirty region for this frame, excluding the extra_draw_region, in the window frame of reference. It is not affected by the screen rotation.

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 });

Trait Implementations

impl Default for SoftwareRenderer

fn default() -> SoftwareRenderer

Returns the “default value” for a type.