Struct Gb 

pub struct Gb<E: Executor = DirectExecutor> {
    pub cpustate: Gbz80State,
    pub mmu: Box<GbMmu>,
    pub button_states: ButtonStates,
    pub serial: SerialState,
    pub timer: TimerState,
    pub apu: ApuState,
    pub ppu: PpuState,
    /* private fields */
}

Represents a “real” gameboy, by explicitly using the GbMmu for memory.

Fields

cpustate: Gbz80State

State of the CPU in the system.

mmu: Box<GbMmu>

MMU for the system.

button_states: ButtonStates

Joypad button states

serial: SerialState

State of serial data transfer.

timer: TimerState

State of timer updates

apu: ApuState

State of audio rendering

ppu: PpuState

State of video rendering

Implementations

impl Gb

pub fn new(bios: BiosRom, cart: Cartridge) -> Self

Create a Gb with the given bios and cartridge, using the default executor.

impl Gb<MicrocodeExecutor>

pub fn new_microcode(bios: BiosRom, cart: Cartridge) -> Self

Create a Gb with the given bios and cartridge, using the microcode executor

impl Gb<DirectExecutorV2>

pub fn new_v2(bios: BiosRom, cart: Cartridge) -> Self

Create a Gb with the given bios and cartridge, using the V2 direct executor.

impl Gb<SteppingExecutor>

pub fn new_stepping(bios: BiosRom, cart: Cartridge) -> Self

Create a Gb with the given bios and cartridge, using the stepping executor

impl<E> Gb<E>

where E: Executor, E::State: Default,

pub fn for_executor(bios: BiosRom, cart: Cartridge) -> Self

Create a Gb with the given bios and cartridge, using the executor specified by this type. Works for executors with state types that implement Default.

impl<E: Executor> Gb<E>

pub fn for_config<C>(bios: BiosRom, cart: Cartridge, config: &C) -> Self

where C: ExecutorConfig<Executor = E>,

Create a Gb with the given bios and cartridge, using the provided config to create the initial state of the executor.

pub fn tick(&mut self)

Tick forward by one instruction, executing background and graphics processing operations as needed.

pub fn set_sample_rate(&mut self, sample_rate: u32)

Set the sample rate for the APU.

pub fn display_ready(&self) -> bool

Returns true if the PPU finished a frame this tick and the display is ready to be sent out.

pub fn get_ready_frame(&self) -> Option<&[(u8, u8, u8)]>

If the display is ready, get a reference to the PPU frame buffer.

pub fn elapsed_mcycles(&self) -> u64

Get the total number of mcycles elapsed since emulator start.

pub fn elapsed_time(&self) -> Duration

Get the total duration since the emulator started (based on the number of m-cycles elapsed.

Trait Implementations

impl<E: Executor> ApuContext for Gb<E>

fn apu(&self) -> &ApuState

fn apu_mut(&mut self) -> &mut ApuState

fn apu_regs(&self) -> &ApuRegs

fn apu_regs_mut(&mut self) -> &mut ApuRegs

impl<E: Clone + Executor> Clone for Gb<E>

where E::State: Clone,

fn clone(&self) -> Gb<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Executor> CpuContext for Gb<E>

fn cpu(&self) -> &Gbz80State

Gets the CPU state.

fn cpu_mut(&mut self) -> &mut Gbz80State

Gets a mutable reference to the CPU state.

impl<E: Debug + Executor> Debug for Gb<E>

where E::State: Debug,

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

Formats the value using the given formatter.

impl<E: Executor> ExecutorContext for Gb<E>

type State = <E as Executor>::State

fn executor(&self) -> &E::State

Get the state of the executor.

fn executor_mut(&mut self) -> &mut E::State

Mutably gets the state of the executor.

fn yield1m(&mut self)

Yields from CPU execution for 1 M clock cycle (4 T). This callback should step the clock forward and perform any work that needs to happen faster than instructions execute. Warning: It is undefined behavior to call tick again during a context yield.

impl<E: Executor> InputContext for Gb<E>

fn button_states(&self) -> ButtonStates

get the button state

fn set_button_states(&mut self, button_states: ButtonStates)

set the button state

fn button_reg(&self) -> ButtonRegister

Get the value of the button register.

fn set_button_reg(&mut self, buttons: ButtonRegister)

Set the value of the button register.

impl<E: Executor> InterruptContext for Gb<E>

type Interrupts = <GbMmu as InterruptContext>::Interrupts

The type which provides access to the interrupts.

fn interrupts(&self) -> &Self::Interrupts

Provides read access to the interrupt flags.

fn interrupts_mut(&mut self) -> &mut Self::Interrupts

Provides write-access to the interrupt flags.

impl<E: Executor> MemContext for Gb<E>

type Mem = GbMmu

Type of MemDevice in this context.

fn mem(&self) -> &Self::Mem

Gets the memory.

fn mem_mut(&mut self) -> &mut Self::Mem

Get a mutable reference to the memory.

impl<E: Executor> PpuContext for Gb<E>

fn ppu(&self) -> &PpuState

Get the ppu state.

fn ppu_mut(&mut self) -> &mut PpuState

Get mutable access to the ppu state.

fn ppu_regs(&self) -> &PpuRegs

fn ppu_regs_mut(&mut self) -> &mut PpuRegs

fn vram(&self) -> &Vram

fn vram_mut(&mut self) -> &mut Vram

fn oam(&self) -> &Oam

fn oam_mut(&mut self) -> &mut Oam

fn display_ready(&mut self)

impl<E: Executor> SaveData for Gb<E>

fn write_save_data(&self, writer: impl Write) -> Result<(), Error>

fn load_save_data(&mut self, reader: impl Read) -> Result<(), Error>

fn has_save_data(&self) -> bool

impl<E: Executor> SerialContext for Gb<E>

fn serial(&self) -> &SerialState

Get the serial state.

fn serial_mut(&mut self) -> &mut SerialState

Get mutable access to the serial state.

fn serial_regs(&self) -> &SerialRegs

fn serial_regs_mut(&mut self) -> &mut SerialRegs

impl<E: Executor> TimerContext for Gb<E>

fn timer(&self) -> &TimerState

Get the timer state.

fn timer_mut(&mut self) -> &mut TimerState

Get mutable access to the timer state.

fn timer_regs(&self) -> &TimerRegs

fn timer_regs_mut(&mut self) -> &mut TimerRegs