Struct Framebuffer 

pub struct Framebuffer {
    info: FramebufferInfo,
    pub canvas: CanvasBuffer,
    double_buffer: Option<*mut u8>,
    use_double_buffer: bool,
    fb_size: usize,
    console_defer_present: bool,
    zero_copy_backing: bool,
}

Main framebuffer structure

Fields

info: FramebufferInfo

canvas: CanvasBuffer

Shared double-buffered canvas (dirty tracking, present throttling, SIMD ops)

double_buffer: Option<*mut u8>

Raw double buffer for VirtIO GPU (physically contiguous)

use_double_buffer: bool

Whether the raw double buffer should be used

fb_size: usize

Total framebuffer size in bytes

console_defer_present: bool

Whether console deferred present is active

zero_copy_backing: bool

True when the VirtIO backing IS our double buffer (zero-copy present)

Implementations

impl Framebuffer

fn request_present(&mut self)

fn present_if_due(&mut self, force: bool)

pub fn init_bootloader( addr: u64, width: u32, height: u32, stride: u32, format: PixelFormat, ) -> Result<(), &'static str>

Initialize framebuffer with bootloader-provided buffer

pub fn init_virtio_gpu() -> Result<(), &'static str>

Initialize framebuffer with VirtIO GPU

G3: the double buffer is allocated FIRST and attached as the scanout resource backing itself, so draws land directly in what TRANSFER_TO_HOST_2D reads : presentation becomes zero-copy.

pub fn init_amd_gpu() -> Result<(), &'static str>

Initialize framebuffer with AMDGPU

pub fn info() -> Option<FramebufferInfo>

Get framebuffer info (lockless: reads the init-time snapshot)

pub fn width() -> u32

Get framebuffer width (lockless)

pub fn height() -> u32

Get framebuffer height (lockless)

pub fn stride() -> u32

Get stride in bytes per row (lockless)

pub fn is_available() -> bool

Check if framebuffer is initialized

pub fn source() -> FramebufferSource

Get framebuffer source (lockless)

pub fn render_stats() -> Option<FramebufferRenderStats>

pub fn set_pixel(x: u32, y: u32, r: u8, g: u8, b: u8)

Set a pixel at (x, y) with RGB color.

Delegates to CanvasBuffer::write_pixel (S6: single implementation of target selection). Takes the framebuffer lock for a single pixel: fine for sparse dots, but batched drawing MUST go through Self::blit_rect instead.

pub fn fill_rect(x: u32, y: u32, width: u32, height: u32, r: u8, g: u8, b: u8)

Fill rectangle with color.

Delegates to CanvasBuffer::fill_rect (S6: one implementation of clipping, SIMD dispatch, target selection and dirty marking). Takes the framebuffer lock once for the whole rectangle. Does NOT present; call swap_buffers() after a batch of draw operations.

pub fn blit_rect(src: &[u8], x: u32, y: u32, w: u32, h: u32)

Blit a packed 32bpp XRGB rectangle into the current draw target (double buffer when enabled, else the hardware framebuffer).

This is the batch primitive: the framebuffer lock is taken exactly once and a single dirty rectangle is marked, whatever the size. src holds h rows of w pixels with a tight row stride of w*4 bytes; the rect is clipped against screen bounds.

pub fn draw_hline(x: u32, y: u32, length: u32, r: u8, g: u8, b: u8)

Draw a horizontal line

pub fn draw_vline(x: u32, y: u32, length: u32, r: u8, g: u8, b: u8)

Draw a vertical line

pub fn clear()

Clear screen to black

pub fn swap_buffers()

Swap buffers (for double buffering)

pub fn set_double_buffering(enable: bool)

Enable/disable double buffering

Trait Implementations

impl Send for Framebuffer

impl Sync for Framebuffer