Struct Session 

pub struct Session {

    pub name: String,
    pub wasm: Vec<u8>,
    pub assets: Assets,
    pub params: HashMap<String, String>,
    pub allow_net: bool,
    pub allow_hosts: Vec<String>,
    pub fetch: FetchMode,
    pub app_id: Option<String>,
    pub save: SaveTarget,
    pub consent: Option<Consent>,
    pub manifest: Option<Manifest>,
    pub mod_requests: Vec<(String, Vec<String>)>,
    pub storage: Storage,
    pub load: LoadOptions,
    pub gl_lib: Option<PathBuf>,
    pub gl_software: bool,
    pub gl_stats: bool,
    pub profile: Option<PathBuf>,
    pub media: MediaPolicy,
    pub fullscreen: Option<bool>,
    pub watch_assets: Vec<AssetWatch>,
}

Fields

name: String

shown in logs and the window title

wasm: Vec<u8>

a .wasm module, or a .cwasm if load.allow_precompiled

assets: Assets

params: HashMap<String, String>

allow_net: bool

allow_hosts: Vec<String>

with allow_net: only these hosts (--allow-net=a.org,*.b.org; empty: all)

fetch: FetchMode

gasm:fetch: live, recording or replaying responses (headless)

app_id: Option<String>

--app-id: the game’s identity in gasm:fetch’s User-Agent

save: SaveTarget

gasm:files: where the game’s saves for the player go

consent: Option<Consent>

the window runner: ask the player about hosts and saves the command line didn’t allow

manifest: Option<Manifest>

the game’s capabilities manifest (embedded, asset gasm.manifest or --manifest)

mod_requests: Vec<(String, Vec<String>)>

mounted mods whose manifests ask for hosts: (file, hosts); each needs the player’s yes (or hosts –allow-net covers), else it’s unmounted before the game starts

storage: Storage

load: LoadOptions

gl_lib: Option<PathBuf>

where ANGLE is (gasm:gl games): None searches the usual places (angle::find)

gl_software: bool

gasm:gl on SwiftShader (software Vulkan) instead of the GPU

gl_stats: bool

--gl-stats: count gasm:gl calls and print them when the game ends

profile: Option<PathBuf>

--profile <out.json>: the main thread’s guest stacks (host::Profile)

media: MediaPolicy

gasm:media: --allow-media (the manifest’s “media” and the player’s consent are added when the game starts)

fullscreen: Option<bool>

a window that can go fullscreen (the window runner), and whether it starts so: what set_fullscreen and is_fullscreen answer from the first call (gasm_init’s too)

watch_assets: Vec<AssetWatch>

--watch-asset name=path: files re-read as assets whenever they change (create each watch before opening its file, so no change is missed)

Implementations

impl Session

pub fn uses_gl(&self) -> bool

Whether the game imports gasm:gl (it then needs ANGLE to draw).

pub fn open_gl( &self, window: Option<NativeWindow>, size: (u32, u32), ) -> Result<Angle, String>

ANGLE for this session’s gasm:gl game: offscreen at w×h, or in a window.

pub fn compile_in_background(&self) -> JoinHandle<Result<Module, Stop>>

Instantiate the guest and run its init. reproducible: headless rules (virtual time, fixed random sequence, hashing). gl: the GL that executes a gasm:gl guest’s calls (None: the null GL). Compile the module on a background thread (the window runner shows the splash meanwhile); hand the result to Session::start_compiled.

pub fn start( self, audio: Option<Box<dyn AudioOut>>, gfx: Gfx, gl: Option<Angle>, reproducible: bool, hashing: bool, ) -> Result<Game, Stop>

pub fn start_compiled( self, module: Module, audio: Option<Box<dyn AudioOut>>, gfx: Gfx, gl: Option<Angle>, ) -> Result<Game, Stop>

Session::start with a module compiled earlier (compile_in_background).