Struct AppConfig 

pub struct AppConfig {

    pub title: String,
    pub width: u32,
    pub height: u32,
    pub vsync: bool,
    pub fixed_timestep: Option<Duration>,
    pub max_frame_time: Duration,
    pub asset_root: PathBuf,
    pub web_preload: Option<Vec<String>>,
    pub canvas_id: Option<String>,
    pub random_seed: u64,
    pub depth_format: Option<TextureFormat>,
    pub msaa_samples: u32,
    pub touch_emulates_mouse: bool,
    pub required_limits: Option<Limits>,
    pub required_features: Features,
    pub preferred_limits: Option<Limits>,
    pub preferred_features: Features,
    pub continue_without_requirements: bool,
    pub device_hook: Option<Arc<dyn Fn(&Adapter, &mut DeviceDescriptor<Option<&str>>) + Send + Sync>>,
    pub virtual_resolution: Option<(u32, u32)>,
    pub scale_mode: ScaleMode,
    pub scale_filter: ScaleFilter,
    pub border_color: Color,
}

Runtime configuration passed to run.

Construct it with ..Default::default() so new fields added in future minor releases don’t break your call site: AppConfig { title: "game".into(), ..Default::default() }.

Fields

title: String

width: u32

height: u32

vsync: bool

fixed_timestep: Option<Duration>

Some(step) calls update with a fixed dt of step: zero, one or several times per frame, as many as the real time elapsed allows. None (default) calls it once per frame with the frame’s dt. Either way render runs once per frame; with a fixed step, Time::alpha says how far the frame is into the next step, for interpolating motion between steps.

Leave this None if the game steps a simulation itself, e.g. a sillyecs world whose apply_system_phases runs its own fixed phases from real time; otherwise those fixed phases nest inside the toolkit’s steps.

Input edges (key_pressed, mouse_delta, …) are seen by the first update of a frame and carried over to the next frame when no step ran, so presses aren’t dropped.

max_frame_time: Duration

Upper bound on the time one frame advances the game (default 250 ms). After a long frame - the window was dragged, the tab was in the background, a breakpoint hit - the game slows down for that frame instead of fast-forwarding through the gap: dt is capped at this, and with a fixed timestep at most max_frame_time / step updates run. Time::delta still reports the real frame time. Duration::ZERO disables the cap.

asset_root: PathBuf

Asset root directory. Defaults to ./assets. On the web it is a URL path relative to the page, and the files listed in its manifest.txt are fetched before Game::init.

web_preload: Option<Vec<String>>

Web only: asset paths to preload instead of reading manifest.txt. Ignored natively.

canvas_id: Option<String>

Web only: id of an existing <canvas> to render into. None (default) appends a new canvas to <body>. Ignored natively.

random_seed: u64

Seed for deterministic runtime RNG (ctx.rng).

depth_format: Option<TextureFormat>

Depth attachment format. None (default) keeps the 2D path depth-less; Some(fmt) (e.g. wgpu::TextureFormat::Depth32Float) allocates a depth buffer for depth-tested rendering. The built-in 2D pipelines never write depth, so enabling it is harmless.

msaa_samples: u32

MSAA sample count for the surface. 1 (default) disables MSAA; 2/4/8 enable it (the value must be supported by the adapter for the surface format).

touch_emulates_mouse: bool

Let the first finger on a touchscreen act as the mouse: it moves the cursor and presses, holds and releases MouseButton::Left, so a game written for the mouse also works on a phone. Off by default; toggle later with Input::set_touch_emulates_mouse, which has the details. No effect on Windows, where the OS already does this.

required_limits: Option<Limits>

Device limits the game needs beyond the toolkit’s own, for compute or render passes it records itself through ctx.gfx.device(). None (default) requests only what the toolkit needs (Limits::downlevel_defaults(), or Limits::default() with the vector feature); with Some, each limit is the better of the two, e.g. Some(wgpu::Limits { max_storage_buffers_per_shader_stage: 8, ..wgpu::Limits::downlevel_defaults() }). Init fails with a DeviceRequirementsError naming any limit the adapter can’t provide. WebGL2 has no compute at all; to fall back gracefully instead, use Self::preferred_limits and check Graphics::supports_compute in Game::init, or set Self::continue_without_requirements.

required_features: Features

Optional device features the game needs (SHADER_F16, TIMESTAMP_QUERY, …). Default empty. Missing ones fail init like missing limits.

preferred_limits: Option<Limits>

Device limits the game would like but can do without: each is requested up to what the adapter offers, so init never fails on them. Read what you got from ctx.gfx.device().limits(). E.g. Some(wgpu::Limits { max_storage_buffers_per_shader_stage: 8, ..wgpu::Limits::downlevel_defaults() }) gets 8 on WebGPU and native and stays at WebGL2’s 0 there. See GraphicsConfig::preferred_limits.

preferred_features: Features

Device features the game would like but can do without; enabled where the adapter has them. Check ctx.gfx.device().features().

continue_without_requirements: bool

true: when the adapter can’t meet required_limits / required_features, start anyway without them and report it through Graphics::unmet_requirements, so Game::init can draw a “WebGPU required” screen. false (default): init fails.

device_hook: Option<Arc<dyn Fn(&Adapter, &mut DeviceDescriptor<Option<&str>>) + Send + Sync>>

Last look at the device request, with the adapter at hand, for decisions the fields above can’t express; see DeviceHook.

virtual_resolution: Option<(u32, u32)>

Draw into a fixed-size canvas of (width, height) pixels (e.g. (320, 180)) and scale it onto the window, for crisp pixel art. None (default) draws straight into the window. With a canvas, ctx.gfx.size(), the cameras and everything the painter draws use canvas pixels, and so do Input::mouse_pos and touch positions; see GraphicsConfig::virtual_resolution.

scale_mode: ScaleMode

How the canvas is scaled onto the window: ScaleMode::Integer (default; whole multiples, the rest is border), Fit (fractional) or Stretch.

scale_filter: ScaleFilter

Nearest (default) or linear filtering when scaling the canvas.

border_color: Color

Colour of the border around the canvas (default black).

Implementations

impl AppConfig

pub fn graphics_config(&self) -> GraphicsConfig

The GraphicsConfig this config creates the renderer with.

Trait Implementations

impl Clone for AppConfig

fn clone(&self) -> AppConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for AppConfig

fn default() -> AppConfig

Returns the “default value” for a type.