Struct Host 

pub struct Host {

    pub virtual_time_ms: Option<f64>,
    pub frame_rate: f64,
    pub pads: [u32; 4],
    pub assets: HashMap<String, Vec<u8>>,
    pub params: HashMap<String, String>,
    pub audio: Option<AudioSink>,
    pub gfx: Gfx,
    pub net: Net,
    pub storage: Storage,
    pub show_frame: bool,
    pub rgba: Vec<u8>,
    pub width: usize,
    pub height: usize,
    pub frames_presented: u64,
    pub hashing: bool,
    pub video_hash: Fnv,
    pub audio_hash: Fnv,
    pub audio_frames: u64,
    /* private fields */
}

Fields

virtual_time_ms: Option<f64>

Headless runs use frame-derived time so results are reproducible.

frame_rate: f64

pads: [u32; 4]

assets: HashMap<String, Vec<u8>>

params: HashMap<String, String>

audio: Option<AudioSink>

gfx: Gfx

net: Net

storage: Storage

show_frame: bool

false during catch-up frames: gfx begin_frame returns 0

rgba: Vec<u8>

Last presented frame as RGBA8, tightly packed.

width: usize

height: usize

frames_presented: u64

hashing: bool

video_hash: Fnv

audio_hash: Fnv

audio_frames: u64

Implementations

impl Host

pub fn new( assets: HashMap<String, Vec<u8>>, params: HashMap<String, String>, audio: Option<AudioSink>, gfx: Gfx, net: Net, storage: Storage, ) -> Self

Examples found in repository

examples/embed.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let host = Host::new(HashMap::new(), HashMap::new(), None, Gfx::null(), Net::new(false), Storage::memory());
    let mut game = Game::load(&std::fs::read("game.wasm")?, host)?;
    for _ in 0..600 {
        game.frame()?;                    // call at game.host().frame_rate Hz
    }
    let h = game.host();
    println!("{}x{}, video hash {:08x}", h.width, h.height, h.video_hash.0);
    Ok(())
}