Class SoftwareRenderer

Nested Relationships

Nested Types

Inheritance Relationships

Base Type

Class Documentation

class SoftwareRenderer : public slint::platform::AbstractRenderer

Slint’s software renderer.

To be used as a template parameter of the WindowAdapter.

Use the render() function to render in a buffer

Public Types

enum class RepaintBufferType : uint32_t

This enum describes which parts of the buffer passed to the SoftwareRenderer may be re-used to speed up painting.

Values:

enumerator NewBuffer

The full window is always redrawn. No attempt at partial rendering will be made.

enumerator ReusedBuffer

Only redraw the parts that have changed since the previous call to render(). 

    This variant assumes that the same buffer is passed on every call to render() and
    that it still contains the previously rendered frame.

enumerator SwappedBuffers

Redraw the part that have changed since the last two frames were drawn. 

    This is used when using double buffering and swapping of the buffers.

enum class RenderingRotation

This enum describes the rotation that is applied to the buffer when rendering. To be used in set_rendering_rotation()

Values:

enumerator NoRotation

No rotation.

enumerator Rotate90

Rotate 90° to the left.

enumerator Rotate180

180° rotation (upside-down)

enumerator Rotate270

Rotate 90° to the right.

Public Functions

inline virtual ~SoftwareRenderer()
SoftwareRenderer(const SoftwareRenderer&) = delete
SoftwareRenderer &operator=(const SoftwareRenderer&) = delete
inline explicit SoftwareRenderer(RepaintBufferType buffer_type)

Constructs a new SoftwareRenderer with the buffer_type as strategy for handling the differences between rendering buffers.

inline PhysicalRegion render(std::span<slint::Rgb8Pixel> buffer, std::size_t pixel_stride) const

Render the window scene into a pixel buffer

The buffer must be at least as large as the associated slint::Window

The stride is the amount of pixels between two lines in the buffer. It is must be at least as large as the width of the window.

inline PhysicalRegion render(std::span<Rgb565Pixel> buffer, std::size_t pixel_stride) const

Render the window scene into an RGB 565 encoded pixel buffer

The buffer must be at least as large as the associated slint::Window

The stride is the amount of pixels between two lines in the buffer. It is must be at least as large as the width of the window.

template<typename PixelType, typename Callback>
inline PhysicalRegion render_by_line(Callback process_line_callback) const

Render the window scene, line by line. The provided Callback will be invoked for each line that needs to rendered.

The renderer uses a cache internally and will only render the part of the window which are dirty.

This function returns the physical region that was rendered considering the rotation.

The callback must be an invocable with the signature (size_t line, size_t begin, size_t end, auto render_fn). It is invoked with the line number as first parameter, and the start x and end x coordinates of the line as second and third parameter. The implementation must provide a line buffer (as std::span) and invoke the provided fourth parameter (render_fn) with it, to fill it with pixels. After the line buffer is filled with pixels, your implementation is free to flush that line to the screen for display.

The first template parameter (PixelType) must be specified and can be either Rgb565Pixel or Rgb8Pixel.

inline PhysicalRegion render(TargetPixelBuffer<Rgb8Pixel> *buffer) const

Renders into the given TargetPixelBuffer.

Note: This class is still experimental - it’s API is subject to changes and not stabilized yet. To use the class, you must enable the SLINT_FEATURE_EXPERIMENTAL=ON CMake option.

inline PhysicalRegion render(TargetPixelBuffer<Rgb565Pixel> *buffer) const

Renders into the given TargetPixelBuffer.

Note: This class is still experimental - it’s API is subject to changes and not stabilized yet. To use the class, you must enable the SLINT_FEATURE_EXPERIMENTAL=ON CMake option.

inline void set_rendering_rotation(RenderingRotation rotation)

Set how the window need to be rotated in the buffer.

This is typically used to implement screen rotation in software

struct PhysicalRegion

Represents a region on the screen, used for partial rendering.

The region may be composed of multiple sub-regions.

Public Functions

inline PhysicalSize bounding_box_size() const

Returns the size of the bounding box of this region.

inline PhysicalPosition bounding_box_origin() const

Returns the origin of the bounding box of this region.

inline auto rectangles() const

Returns a view on all the rectangles in this region. The rectangles do not overlap. The returned type is a C++ view over PhysicalRegion::Rect structs.

It can be used like so: 

for (auto [origin, size] : region.rectangles()) {
    // Do something with the rect
}

struct Rect

A Rectangle defined with an origin and a size. The PhysicalRegion::rectangles() function returns a view over them

Public Members

PhysicalPosition origin

The origin of the rectangle.

PhysicalSize size

The size of the rectangle.