Struct FramePair 

pub struct FramePair<const N: usize, S: 'static> { /* private fields */ }

Two FrameStorages in the usual ping-pong: build frame N+1 into one while the GPU walks frame N from the other.

loop {
    pair.build(|frame, packets| { /* add packets */ });
    pair.wait();                // frame N's walk is done
    psx_gpu::arm_draw_done();   // anything that must precede the kick
    pair.kick();                // frame N+1 goes out; storages swap
}

Implementations

impl<const N: usize, S> FramePair<N, S>

pub fn new( a: &'static mut FrameStorage<N, S>, b: &'static mut FrameStorage<N, S>, dma: GpuDma, ) -> Self

Ping-pong between a and b, owning the GPU DMA token.

pub fn build<R>( &mut self, build: impl for<'f> FnOnce(&mut OtFrame<'f, N>, &'f mut S) -> R, ) -> R

Build the next frame into the storage the GPU is not walking.

Building again before kick starts that frame over.

pub fn wait(&mut self) -> &mut GpuDma

Wait until the frame kicked last has been walked, and lend the token for work that must not overlap it (VRAM uploads, immediate GP0).

pub fn kick(&mut self)

Wait for the previous walk, kick the frame built last, and switch build to the other storage.

pub fn release(self) -> ([&'static mut FrameStorage<N, S>; 2], GpuDma)

Wait for the last walk, then hand back both storages and the token.

pub fn present<R>( &mut self, build: impl for<'f> FnOnce(&mut OtFrame<'f, N>, &'f mut S) -> R, ) -> R

build, then kick.

Trait Implementations

impl<const N: usize, S: Debug + 'static> Debug for FramePair<N, S>

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

Formats the value using the given formatter.