Struct Host 

pub struct Host {

    pub virtual_time_ms: Option<f64>,
    pub random: Option<Splitmix>,
    pub frame_rate: f64,
    pub pads: [u32; 4],
    pub text: Option<String>,
    pub input: RawInput,
    pub input_mode: u32,
    pub assets: Assets,
    pub params: HashMap<String, String>,
    pub audio: Option<Box<dyn AudioOut>>,
    pub gfx: Gfx,
    pub gl: Gl,
    pub frame_index: u64,
    pub net: Net,
    pub fetch: Fetch,
    pub media: Media,
    pub clipboard: Clipboard,
    pub files: Files,
    pub requires: Vec<String>,
    pub profile: Option<Profile>,
    pub storage: Storage,
    pub show_frame: bool,
    pub rgba: Vec<u8>,
    pub width: usize,
    pub height: usize,
    pub frames_presented: u64,
    pub aspect: Option<(u32, u32)>,
    pub title: Option<String>,
    pub title_changed: bool,
    pub fullscreen_capable: bool,
    pub fullscreen: bool,
    pub fullscreen_request: Option<bool>,
    pub hashing: bool,
    pub video_hash: Fnv,
    pub audio_hash: Fnv,
    pub audio_frames: u64,
    pub memory_limit: MemoryLimit,
    pub catch_up: bool,
    /* private fields */
}

Fields

virtual_time_ms: Option<f64>

Headless runs use frame-derived time so results are reproducible (also the WASI clocks).

random: Option<Splitmix>

Headless runs: a fixed random_get sequence; None = OS randomness.

frame_rate: f64

pads: [u32; 4]

text: Option<String>

UTF-8 typed since the previous frame (set by the runner before each frame); None: no keyboard, text_input returns -1

input: RawInput

input_mode: u32

GASM_INPUT_* flags requested by the guest (input_mode)

assets: Assets

params: HashMap<String, String>

audio: Option<Box<dyn AudioOut>>

gfx: Gfx

gl: Gl

gasm:gl state (the null GL: natively, gl guests run headless)

frame_index: u64

frames run so far (gl queries and syncs are ready from the next frame on)

net: Net

fetch: Fetch

gasm:fetch (denied until the runner sets a policy: Fetch::new)

media: Media

gasm:media: the game’s audio streams

clipboard: Clipboard

gasm:clipboard: what the game may read this frame and what it copied

files: Files

gasm:files: saves queued for the player (written between frames)

requires: Vec<String>

the manifest’s requires: the game is refused before it starts if one is missing

profile: Option<Profile>

--profile: the main thread’s guest stacks, sampled every millisecond

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

aspect: Option<(u32, u32)>

video_set_aspect (num, den); None: square pixels

title: Option<String>

set_title (cleaned); None: the runner’s default

title_changed: bool

set_title changed title since the runner last looked (it clears this)

fullscreen_capable: bool

set_fullscreen can be honoured here (the window runner sets it; headless: false)

fullscreen: bool

shown fullscreen now (is_fullscreen; the window runner keeps it up to date)

fullscreen_request: Option<bool>

set_fullscreen asked for this since the runner last looked (it takes it)

hashing: bool

video_hash: Fnv

audio_hash: Fnv

audio_frames: u64

memory_limit: MemoryLimit

the guest’s memory cap (LoadOptions::memory_limit)

catch_up: bool

a catch-up frame (the runner shows only the last of a batch): gasm:gl frame_shown is 0

Implementations

impl Host

pub fn new( assets: impl Into<Assets>, params: HashMap<String, String>, audio: Option<Box<dyn AudioOut>>, gfx: Gfx, net: Net, storage: Storage, ) -> Self

pub fn set_reproducible(&mut self)

Reproducible mode for headless runs: virtual time (starting at 0) and a fixed random sequence.