Struct RemappedFrameBuffer 

pub struct RemappedFrameBuffer<F, M: PixelRemapper>(/* private fields */);

Coordinate-remapping wrapper for any framebuffer

This is a generic wrapper around any framebuffer implementation that remaps pixel coordinates before forwarding them to the inner framebuffer. It can be used for:

• Tiling multiple panels into a larger virtual display (see ChainTopRightDown)
• Scan-pattern remapping for panels with non-standard row interleaving (e.g. 1/16 scan on 64×64 panels — see QuarterScan)

Unlike TiledFrameBuffer, this wrapper uses only two type parameters and works with all four framebuffer types (plain, latched, bitplane::plain, bitplane::latched).

Type Parameters

• F — The underlying framebuffer type
• M — The pixel remapping strategy (see implementors of PixelRemapper)

Example with tiled plain framebuffer

use hub75_framebuffer::{compute_frame_count, compute_rows};
use hub75_framebuffer::plain::DmaFrameBuffer;
use hub75_framebuffer::tiling::{RemappedFrameBuffer, ChainTopRightDown, compute_tiled_cols};

const TILED_COLS: usize = 3;
const TILED_ROWS: usize = 3;
const ROWS: usize = 32;
const PANEL_COLS: usize = 64;
const FB_COLS: usize = compute_tiled_cols(PANEL_COLS, TILED_ROWS, TILED_COLS);
const BITS: u8 = 2;
const NROWS: usize = compute_rows(ROWS);
const FRAME_COUNT: usize = compute_frame_count(BITS);

type FBType = DmaFrameBuffer<ROWS, FB_COLS, NROWS, BITS, FRAME_COUNT>;
type Remapper = ChainTopRightDown<ROWS, PANEL_COLS, TILED_ROWS, TILED_COLS>;
type Display = RemappedFrameBuffer<FBType, Remapper>;

let mut fb = Display::new();
// fb is a 192×96 virtual canvas

Example with tiled bitplane framebuffer

use hub75_framebuffer::bitplane::plain::DmaFrameBuffer;
use hub75_framebuffer::tiling::{RemappedFrameBuffer, ChainTopRightDown, compute_tiled_cols};

const TILED_COLS: usize = 3;
const TILED_ROWS: usize = 3;
const ROWS: usize = 32;
const NROWS: usize = ROWS / 2;
const PANEL_COLS: usize = 64;
const FB_COLS: usize = compute_tiled_cols(PANEL_COLS, TILED_ROWS, TILED_COLS);
const PLANES: usize = 8;

type FBType = DmaFrameBuffer<NROWS, FB_COLS, PLANES>;
type Remapper = ChainTopRightDown<ROWS, PANEL_COLS, TILED_ROWS, TILED_COLS>;
type Display = RemappedFrameBuffer<FBType, Remapper>;

let mut fb = Display::new();
// fb is a 192×96 virtual canvas backed by a bitplane framebuffer

Implementations

impl<F: Default, M: PixelRemapper> RemappedFrameBuffer<F, M>

pub fn new() -> Self

Create a new remapped framebuffer that takes ownership of a default-constructed inner framebuffer and remaps any pixel writes through the given PixelRemapper.

Trait Implementations

impl<F: Debug, M: Debug + PixelRemapper> Debug for RemappedFrameBuffer<F, M>

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

Formats the value using the given formatter.

impl<F: Default, M: PixelRemapper> Default for RemappedFrameBuffer<F, M>

fn default() -> Self

Returns the “default value” for a type.

impl<F: DrawTarget<Error = Infallible, Color = Color>, M: PixelRemapper> DrawTarget for RemappedFrameBuffer<F, M>

type Color = Rgb888

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.

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

Fill the entire display with a solid color.

impl<F: FrameBuffer, M: PixelRemapper> FrameBuffer for RemappedFrameBuffer<F, M>

const BCM_SEQUENCE: [BcmLenReps; 10] = F::BCM_SEQUENCE

Static (len, reps) of the segments in one sequence, in scan order.

const BCM_SEQUENCE_LEN: usize = F::BCM_SEQUENCE_LEN

Number of BCM segments in one sequence, i.e. the number of meaningful entries in BCM_SEQUENCE.

const BCM_SEQUENCE_COUNT: usize = F::BCM_SEQUENCE_COUNT

Number of times the sequence repeats in one complete panel refresh: NROWS for row-major framebuffers (one sequence per row), 1 for frame-major and threshold framebuffers (the sequence covers the whole frame).

const BCM_SEGMENTS_PER_GROUP: usize = F::BCM_SEGMENTS_PER_GROUP

Number of consecutive segments that a driver may chain into a single DMA transfer. Must divide BCM_SEQUENCE_LEN: groups never straddle a sequence boundary.

type Word = <F as FrameBuffer>::Word

The DMA word type used by this framebuffer (u8 for latched, u16 for direct-drive). Driver implementations can use this to enforce that pin configurations match the framebuffer at compile time.

fn bcm_segment_ptr(&self, index: usize) -> *const u8

Returns the byte pointer for the index-th BCM segment.

const BCM_SEGMENT_COUNT: usize = _

Total number of BCM segments streamed for one complete panel refresh (all rows, all planes).

fn bcm_segment_count(&self) -> usize

Total number of BCM segments streamed for one complete panel refresh.

fn bcm_segment(&self, index: usize) -> BcmSegment

Returns the index-th BCM segment.

fn bcm_segments_per_group(&self) -> usize

Number of consecutive segments that form one transfer group.

impl<F: FrameBufferOperations + FrameBuffer, M: PixelRemapper> FrameBufferOperations for RemappedFrameBuffer<F, M>

fn erase(&mut self)

Erase pixel colors while preserving control bits. This is much faster than format() and is the typical way to clear the display.

fn set_pixel(&mut self, p: Point, color: Color)

Set a pixel in the framebuffer.

impl<F: MutableFrameBuffer, M: PixelRemapper> MutableFrameBuffer for RemappedFrameBuffer<F, M>

impl<F: DrawTarget<Error = Infallible, Color = Color>, M: PixelRemapper> OriginDimensions for RemappedFrameBuffer<F, M>

fn size(&self) -> Size

Returns the size of the bounding box.