Struct FrameBuffer 

pub struct FrameBuffer {
    pub data: Vec<u8>,
    pub width: u32,
    pub height: u32,
    pub dirty_region: DirtyRegion,
}

A pixel RGBA framebuffer with configurable dimensions.

The internal buffer is a flat array of RGBA bytes in row-major order. Pixel (x, y) starts at byte offset (y * width + x) * 4.

Fields

data: Vec<u8>

Raw RGBA pixel data, width * height * 4 bytes.

width: u32

Screen width in pixels.

height: u32

Screen height in pixels.

dirty_region: DirtyRegion

Accumulated dirty region for incremental rendering. Callers mark areas that need redrawing; render functions may skip pixels outside this region.

Implementations

impl FrameBuffer

pub fn new(config: RenderConfig, clear_color: Rgba) -> FrameBuffer

Create a new framebuffer with the given render config, cleared to the given color.

pub fn mark_all_dirty(&mut self)

Mark the entire framebuffer as dirty (force full redraw).

pub fn mark_dirty_rect(&mut self, x: i32, y: i32, w: u32, h: u32)

Mark a rectangular region as dirty.

pub fn mark_dirty_tile(&mut self, tx: i32, ty: i32)

Mark a tile as dirty given its tile coordinates (tx, ty).

pub fn clear_dirty(&mut self)

Clear all dirty regions (nothing to redraw).

pub fn is_dirty_pixel(&self, x: u32, y: u32) -> bool

Check whether a pixel is in a dirty region (needs redrawing). If no dirty region is present, all pixels are considered dirty.

pub fn width(&self) -> u32

Returns the width of this framebuffer in pixels.

pub fn height(&self) -> u32

Returns the height of this framebuffer in pixels.

pub fn clear(&mut self, color: Rgba)

Clear the entire framebuffer to a single color.

pub fn set_pixel(&mut self, x: u32, y: u32, color: Rgba) -> bool

Set a single pixel. Returns false if out of bounds.

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

Get the color of a single pixel. Returns None if out of bounds.

pub fn fill_rect( &mut self, x: u32, y: u32, rect_width: u32, rect_height: u32, color: Rgba, )

Fill a rectangular region with a color. Coordinates are clamped to screen bounds.

pub fn row_slice(&self, y: u32) -> Option<&[u8]>

Get a slice of one pixel row’s RGBA data. Returns None if y is out of bounds.

pub fn row_slice_mut(&mut self, y: u32) -> Option<&mut [u8]>

Get a mutable slice of one pixel row’s RGBA data. Returns None if y is out of bounds.

pub fn blit_row(&mut self, x: u32, y: u32, src: &[u8], count: u32) -> bool

Copy a horizontal line of RGBA data into the framebuffer. src must be exactly count * 4 bytes. Returns false if the line goes out of bounds.

pub fn save_png(&self, path: &Path) -> Result<(), Error>

Save the framebuffer as a PNG file.

Uses the image crate to encode the raw RGBA data.

Trait Implementations

impl Clone for FrameBuffer

fn clone(&self) -> FrameBuffer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FrameBuffer

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

Formats the value using the given formatter.

impl FbSurface for FrameBuffer

fn new_screen(width: u32, height: u32) -> Self

Create a new width × height surface, cleared to black.

fn width(&self) -> u32

Screen width in pixels.

fn height(&self) -> u32

Screen height in pixels.

fn set_pixel(&mut self, x: u32, y: u32, color: Rgba) -> bool

Set a single pixel. Returns false if out of bounds.

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

Get the current color of a single pixel. Returns None if out of bounds.

fn clear(&mut self, color: Rgba)

Clear the entire surface to a single color.

fn fill_rect( &mut self, x: u32, y: u32, rect_width: u32, rect_height: u32, color: Rgba, )

Fill a rectangular region with a color (clamped to bounds).

fn present_into(&self, out: &mut [u8])

Dump the whole surface as row-major RGBA into out, which must hold at least width * height * 4 bytes.

fn pixel_rgba(&self, x: u32, y: u32) -> Rgba

Read a single pixel as RGBA; out-of-bounds reads return transparent.

impl TransitionFb for FrameBuffer

fn size(&self) -> (usize, usize)

(width, height) in pixels.

fn tile_black(&mut self, tx: usize, ty: usize)

Fill the 8×8 tile at tile coordinates (tx, ty) with black. Out-of-bounds tiles are clamped to the visible area.

fn tile_copy( &mut self, tx: usize, ty: usize, src: &Self, stx: usize, sty: usize, )

Copy the 8×8 tile at tile coordinates (stx, sty) of src into tile (tx, ty) of self. Out-of-bounds areas are clamped.