Struct Runtime 

pub struct Runtime {
    pub scene: Scene,
    pub physics: Physics,
    pub scripts: ScriptRuntime,
    pub input: Input,
    pub time: Time,
    pub log: Vec<String>,
    /* private fields */
}

Owned gameplay state shared by editor Play mode and the standalone player. Dropping the runtime destroys script instances before unloading their library.

Fields

scene: Scene

Mutable gameplay world and environment.

physics: Physics

Rapier simulation and ray queries, updated at the fixed cadence.

scripts: ScriptRuntime

Script instances and hot-reload host.

input: Input

Input snapshot supplied by the hosting shell before each tick.

time: Time

Scaled simulation time visible to scripts.

log: Vec<String>

Script messages and runtime diagnostics. The host may drain these at any time.

Implementations

impl Runtime

pub fn set_bindings<S: AsRef<str>>(&mut self, defs: &[(String, Vec<S>)])

Applies the project’s input bindings (call right after new).

pub fn new(scene: Scene, host: Option<ScriptHost>) -> Self

Creates a 60 Hz runtime, initializing world transforms before the first tick.

pub fn with_config( scene: Scene, host: Option<ScriptHost>, config: RuntimeConfig, ) -> Result<Self, String>

Creates a runtime with a validated timing policy. Returns an error for non-finite/non-positive intervals or a zero step limit.

pub fn config(&self) -> &RuntimeConfig

Active timing configuration. Construct a new runtime to change the fixed cadence.

pub fn is_paused(&self) -> bool

Whether regular ticks are suspended.

pub fn set_paused(&mut self, paused: bool)

Suspends or resumes ticks. Existing fractional fixed time is preserved.

pub fn time_scale(&self) -> f32

Current simulation speed multiplier.

pub fn set_time_scale(&mut self, scale: f32) -> Result<(), String>

Sets speed in [0, 100]; rejects invalid values without changing state. Zero freezes simulation time like pause. Wall-frame clamping occurs before scaling.

pub fn frame_stats(&self) -> FrameStats

Timing diagnostics from the most recent tick (zeroed on a skipped tick).

pub fn step_once(&mut self)

Advances one fixed-size simulation frame even when paused or time scale is zero. Useful for editor single-step controls. It does not consume shell input.

pub fn drain_log(&mut self) -> Drain<'_, String>

Drains pending script/runtime log messages, preserving their order.

pub fn tick(&mut self, dt: f32)

Advances a wall-clock frame. Negative/non-finite intervals and paused frames are skipped. Large intervals are clamped before applying time scale.

impl Runtime

pub fn apply_scene_request( &mut self, reg: &Registry, read: impl Fn(&str) -> Result<String, String>, ) -> Option<Result<String, String>>

Applies a scene change a script asked for during the last tick: read returns the text of a scene asset. Returns None when nothing was asked, else the outcome (the running scene stays as it was on error).

pub fn replace_scene(&mut self, scene: Scene)

Swaps the running scene for another: script instances and the physics world start over, time, input bindings and the cursor state carry on.

Trait Implementations

impl Drop for Runtime

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.