Struct FrameBuffer 

pub struct FrameBuffer<M: PixelMap, const N: usize> { /* private fields */ }

Available on crate feature framebuffer only.

Frame buffer in the native GRAM layout M, drawn in the logical orientation rotation.

Pixel coordinates and rows are logical, the bytes (Self::as_bytes) are always native and are sent to the panel as they are. Changing the rotation does not move the existing pixels: redraw the frame after Self::set_rotation.

Implementations

impl<M: PixelMap, const N: usize> FrameBuffer<M, N>

pub const fn new() -> Self

Empty (all pixels off) buffer in Rotation::Deg0. N must equal M::BUFFER_LEN (checked at compile time).

pub const fn with_rotation(self, rotation: Rotation) -> Self

Same buffer with another orientation, see Self::set_rotation.

pub const fn rotation(&self) -> Rotation

Current orientation.

pub fn set_rotation(&mut self, rotation: Rotation)

Changes the orientation of the coordinates. The buffer content is not touched, so the image turns into noise until it is redrawn.

pub const fn logical_size(&self) -> (u32, u32)

Logical (width, height) for the current rotation.

pub fn set_pixel(&mut self, x: u32, y: u32, on: bool)

Sets the logical pixel (x, y); coordinates outside the logical size are ignored.

pub fn get_pixel(&self, x: u32, y: u32) -> Option<bool>

Reads the logical pixel (x, y), None outside the logical size.

pub fn fill(&mut self, on: bool)

Sets every pixel on or off. Same as DrawTarget::clear with BinaryColor.

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

Native bytes, ready to be sent to the panel (write_ram_data).

pub fn window(&self, area: Rectangle) -> Option<Window>

The GRAM window that covers the logical rectangle area (clipped to the logical size), None if nothing of area is on the panel. Takes the rotation into account; see Window::covering for the native version.

pub fn copy_window<'a>(&self, window: &Window, out: &'a mut [u8]) -> &'a [u8]

The bytes of window taken from the frame into out, ready for RAMWR after set_address_window; returns &out[..window.byte_len()]. The window must come from Self::window or Window::covering for the same M.

Panics

If out is shorter than window.byte_len().

pub fn as_bytes_mut(&mut self) -> &mut [u8]

Mutable native bytes. The layout is that of M, independent of the rotation.

pub fn fill_with(&mut self, f: impl FnMut() -> u8)

Fills the native bytes with values from f, in buffer order.

pub fn read_row(&self, y: u32, out: &mut [bool]) -> bool

Reads a logical row y into out (out.len() == logical width). Returns true if at least one pixel in the row is on.

A logical row is a native row (Deg0, Deg180) or a native column (Deg90, Deg270), possibly in the reverse order, so every orientation uses a whole-line path.

pub fn write_row(&mut self, y: u32, row: &[bool])

Writes a logical row y from row (row.len() == logical width). Only sets pixels, never clears them: the row must be cleared beforehand (see PixelMap::write_row).

Trait Implementations

impl<M: PixelMap, const N: usize> Debug for FrameBuffer<M, N>

Prints the geometry and the rotation, not the bytes.

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<M: PixelMap, const N: usize> Default for FrameBuffer<M, N>

fn default() -> Self

Returns the “default value” for a type.

impl<M: PixelMap, const N: usize> DrawTarget for FrameBuffer<M, N>

fn clear(&mut self, color: Self::Color) -> Result<(), Self::Error>

Fills the whole buffer at once instead of pixel by pixel.

type Color = BinaryColor

The pixel color type the targetted display supports.

type Error = !

Error type to return when a drawing operation fails.

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

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

Draw individual pixels to the display without a defined order.

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.

fn fill_solid( &mut self, area: &Rectangle, color: Self::Color, ) -> Result<(), Self::Error>

Fill a given area with a solid color.

impl<M: PixelMap, const N: usize> OriginDimensions for FrameBuffer<M, N>

fn size(&self) -> Size

Returns the size of the bounding box.