pub struct SoftwareRenderer { /* private fields */ }
Expand description

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

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast for Twhere T: Any,

§

fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

§

impl<T> Pointable for T

§

const ALIGN: usize = mem::align_of::<T>()

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.