Struct DoubleBuffer 

pub struct DoubleBuffer { /* private fields */ }

Two framebuffers stacked in VRAM: the GPU shows one while the other is drawn, and swap exchanges them.

The first buffer sits at VRAM line 0 and the second stride lines below it, so a 320×240 pair fits beside textures in the 1024×512 VRAM.

use psx_gpu::display::{DoubleBuffer, Resolution};
let buffers = DoubleBuffer::with_stride(Resolution::R320X240, 256);
assert_eq!(buffers.draw_origin(), (0, 0));
assert_eq!(buffers.display_origin(), (0, 256));

Implementations

impl DoubleBuffer

pub const fn new(resolution: Resolution) -> Self

Buffers of resolution, the second directly below the first.

pub const fn with_stride(resolution: Resolution, stride: u16) -> Self

Buffers stride VRAM lines apart, leaving the lines between them free (palettes, say). A stride below the height is raised to it so the buffers never overlap.

Panics

If the second buffer would end past VRAM line 512 (a 480-line resolution can’t be double-buffered this way).

pub const fn size(&self) -> (u16, u16)

Width and height of each buffer, in pixels.

pub const fn stride(&self) -> u16

VRAM lines between the two buffers’ top edges.

pub const fn draw_origin(&self) -> (u16, u16)

Top-left VRAM corner of the buffer being drawn.

pub const fn display_origin(&self) -> (u16, u16)

Top-left VRAM corner of the buffer being shown.

pub fn swap(&mut self, gpu: &mut Gpu)

Show the buffer just drawn and draw into the other one from now on.

Flips at once (GP1(05h)); the hardware latches the start at the next frame. Drawing must be finished (crate::Gpu::wait_idle) first.

pub fn begin_swap(&mut self, gpu: &mut Gpu) -> u32

Switch the draw side now and program its draw area and offset, and return the GP1(05h) word that shows the finished buffer, for the caller to apply at a blank edge (psx-rt’s queued flip). Drawing must be finished (crate::Gpu::wait_idle) first.

pub fn begin_deferred_swap(&mut self) -> u32

Select the next draw buffer without touching the GPU, and return the GP1(05h) word that shows the finished one.

The non-blocking first half of a pipelined swap: queue the word for a VBlank edge whose handler applies it once the frame’s closing GP0(1Fh) has run (psx_rt::interrupts::queue_display_control_at_vblank, see crate::is_draw_done), wait until it has been applied, then call apply_draw_target before drawing. Safe to call while the previous frame still rasterises.

pub fn apply_draw_target(&self, _gpu: &mut Gpu)

Program the draw area and draw offset for the buffer being drawn.

pub fn clear(&self, gpu: &mut Gpu, color: (u8, u8, u8))

Fill the buffer being drawn with color (GP0(02h)).

Trait Implementations

impl Clone for DoubleBuffer

fn clone(&self) -> DoubleBuffer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DoubleBuffer

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

Formats the value using the given formatter.

impl Hash for DoubleBuffer

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given [Hasher].

impl PartialEq for DoubleBuffer

fn eq(&self, other: &DoubleBuffer) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for DoubleBuffer

impl Eq for DoubleBuffer

impl StructuralPartialEq for DoubleBuffer