Struct RgbaIndexedFrameBuffer 

pub struct RgbaIndexedFrameBuffer<C: ColorIndex = GbColor> {
    pub palette: Palette<C>,
    /* private fields */
}

An IndexedFrameBuffer with an RGBA-facing facade: RGBA writes are quantized through a fixed base palette (so drawing is stable no matter what display effect is active), while a separate display palette is applied at present time.

Fades and flashes become palette operations, the way real GB hardware does them: swap the display palette (Self::set_palette, Self::remap_shades, Self::scale_shades, Self::apply_bgp) instead of touching every pixel. The buffer itself stays packed 2bpp — 5,760 bytes for a 160×144 screen instead of 92,160.

base doubles as the initial display palette; Self::reset_palette restores it. The indexed API remains reachable via Self::indexed / Self::indexed_mut.

Fields

palette: Palette<C>

Display palette applied at present time; fades/flashes remap this.

Implementations

impl<C: ColorIndex> RgbaIndexedFrameBuffer<C>

pub fn with_palette(config: RenderConfig, clear: Rgba, base: Palette<C>) -> Self

Create a config-sized buffer with an explicit base palette, cleared to clear (quantized through base).

pub fn display_palette(&self) -> &Palette<C>

The current display palette.

pub fn set_palette(&mut self, palette: Palette<C>)

Replace the display palette (fade/flash effect).

pub fn reset_palette(&mut self)

Restore the display palette to the base palette.

pub fn remap_shades(&mut self, map: &[u8])

Remap every display shade through map: display color i becomes the base palette entry map[i]. This is the indexed-buffer equivalent of the per-pixel remap_shades loops (rBGP-style register writes).

pub fn scale_shades(&mut self, scale: f32)

Scale the display colors toward black by scale (0.0 = black, 1.0 = base palette). Alpha is preserved. Mirrors the per-pixel “brighten/darken” loops (e.g. the Ghost Marowak reveal).

pub fn indexed(&self) -> &IndexedFrameBuffer<C>

Read-only access to the underlying indexed buffer.

pub fn indexed_mut(&mut self) -> &mut IndexedFrameBuffer<C>

Mutable access to the underlying indexed buffer (C-index API).

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

Raw packed 2bpp storage (see IndexedFrameBuffer::packed).

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

Mutable raw packed storage.

pub fn to_rgba(&self, out: &mut [u8]) -> bool

Expand the buffer into RGBA using the display palette. Writes width * height * 4 bytes into out; returns false (and writes nothing) if out is too small.

pub fn copy_from(&mut self, other: &Self)

Copy the pixels and display palette of other into this buffer. Both buffers must have the same dimensions.

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

Set a single pixel by palette index. Returns false if out of bounds.

pub fn get_index(&self, x: u32, y: u32) -> Option<C>

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

pub fn clear_index(&mut self, color: C)

Clear the entire buffer to a single palette index.

pub fn len(&self) -> usize

Total number of pixels.

pub fn width(&self) -> u32

Screen width in pixels.

pub fn height(&self) -> u32

Screen height in pixels.

pub fn is_empty(&self) -> bool

Whether the buffer holds no pixels.

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

Set a single pixel, quantized through the base palette. Returns false if out of bounds.

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

Get the current display color of a single pixel (through the display palette). Returns None if out of bounds.

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

Clear the entire buffer to a single color (quantized through the base palette).

Also restores the display palette to the base palette. This mirrors the RGBA buffer’s contract — after a clear the framebuffer is in a pristine state — and is what prevents fade/flash palettes from leaking into the next frame: every frame starts with a clear, so the display mapping always begins from the base and effects re-apply their palette at the end of the frame.

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 (quantized through the base palette). Coordinates are clamped to buffer 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 buffer (each pixel quantized through the base palette). src must be exactly count * 4 bytes. Returns false if the line goes out of bounds.

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

Save the framebuffer as a PNG file (display palette applied).

impl<C: ColorIndex + DefaultPalette> RgbaIndexedFrameBuffer<C>

pub fn new(config: RenderConfig, clear: Rgba) -> Self

Create a config-sized buffer using the type’s default base palette, cleared to clear.

impl RgbaIndexedFrameBuffer<GbColor>

pub fn apply_bgp(&mut self, bgp: u8)

Apply a DMG BGP register byte: display color i becomes the base palette’s shade (bgp >> (2 * i)) & 3. This is exactly how the original hardware performs fades (by writing the BGP register).

Trait Implementations

impl<C: Clone + ColorIndex> Clone for RgbaIndexedFrameBuffer<C>

fn clone(&self) -> RgbaIndexedFrameBuffer<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug + ColorIndex> Debug for RgbaIndexedFrameBuffer<C>

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

Formats the value using the given formatter.

impl<C: Eq + ColorIndex> Eq for RgbaIndexedFrameBuffer<C>

impl<C: ColorIndex + DefaultPalette> FbSurface for RgbaIndexedFrameBuffer<C>

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<C: PartialEq + ColorIndex> PartialEq for RgbaIndexedFrameBuffer<C>

fn eq(&self, other: &RgbaIndexedFrameBuffer<C>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<C: PartialEq + ColorIndex> StructuralPartialEq for RgbaIndexedFrameBuffer<C>

impl<C: ColorIndex> TransitionFb for RgbaIndexedFrameBuffer<C>

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.