Struct Framebuffer 

pub struct Framebuffer<const W: usize, const H: usize> { /* private fields */ }

A W×H RGB565 framebuffer in display wire format.

At 240×135 it is 64 800 bytes, so it should live in a static, never on the stack. Framebuffer::new is const and all-zero, which places the buffer in .bss: it costs RAM but no flash. A non-zero initial value would put 64 KB of initialiser data in the firmware image.

use oxstack_gfx::{Framebuffer, Rgb565};
use embedded_graphics::prelude::*;

static mut FB: Framebuffer<240, 135> = Framebuffer::new();
fb.clear(Rgb565::BLUE).unwrap();
let dirty = fb.take_dirty().unwrap();
assert_eq!((dirty.y, dirty.rows), (0, 135));
assert_eq!(dirty.bytes.len(), 240 * 135 * 2);

Implementations

impl<const W: usize, const H: usize> Framebuffer<W, H>

pub const fn new() -> Self

An all-black framebuffer with nothing marked dirty.

pub const fn width(&self) -> usize

Width in pixels.

pub const fn height(&self) -> usize

Height in pixels.

pub fn pixel(&self, x: usize, y: usize) -> Option<Rgb565>

Colour at (x, y), or None outside the buffer.

pub fn mark_all_dirty(&mut self)

Marks every row as changed, e.g. after the panel lost its contents.

pub fn take_dirty(&mut self) -> Option<DirtyRows<'_>>

Hands out the changed rows and marks the buffer clean. The caller must send them to the display before drawing again.

pub fn wire_rows_mut(&mut self, rows: Range<usize>) -> &mut [[u16; W]]

Mutable access to rows rows in wire format, for renderers that write pixels one by one (a 3D rasteriser testing depth per pixel cannot use fill_solid). Those rows are marked dirty, so a flush cannot miss them. Store colours converted with wire_color.

Panics

If rows is out of bounds or decreasing, like slice indexing.

use oxstack_gfx::{Framebuffer, Rgb565, wire_color};
use embedded_graphics::prelude::*;

let mut fb = Framebuffer::<8, 6>::new();
let red = wire_color(Rgb565::RED);
for row in fb.wire_rows_mut(2..4) {
    row[1..3].fill(red);
}
assert_eq!(fb.pixel(1, 3), Some(Rgb565::RED));
let dirty = fb.take_dirty().unwrap();
assert_eq!((dirty.y, dirty.rows), (2, 2));

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

The whole buffer in wire format.

Trait Implementations

impl<const W: usize, const H: usize> Default for Framebuffer<W, H>

fn default() -> Self

Returns the “default value” for a type.

impl<const W: usize, const H: usize> DrawTarget for Framebuffer<W, H>

type Color = Rgb565

The pixel color type the targetted display supports.

type Error = Infallible

Error type to return when a drawing operation fails.

fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Infallible>

where I: IntoIterator<Item = Pixel<Rgb565>>,

Draw individual pixels to the display without a defined order.

fn fill_solid( &mut self, area: &Rectangle, color: Rgb565, ) -> Result<(), Infallible>

Fill a given area with a solid color.

fn clear(&mut self, color: Rgb565) -> Result<(), Infallible>

Fill the entire display with a solid color.

fn fill_contiguous<I>( &mut self, area: &Rectangle, colors: I, ) -> Result<(), Self::Error>

where I: IntoIterator<Item = Self::Color>,

Fill a given area with an iterator providing a contiguous stream of pixel colors.

impl<const W: usize, const H: usize> OriginDimensions for Framebuffer<W, H>

fn size(&self) -> Size

Returns the size of the bounding box.