Struct Interactive 

pub struct Interactive {
    worlds: SceneHandles,
    render: Entity,
    renderer: Entity,
    pub render_world: Entity,
    pub target: ResHandle<Texture>,
    stepper: SceneStepper,
    frame: Frame,
    samples: Vec<f32>,
    recording: Option<RecordingHandle>,
    device: Device,
    queue: Queue,
}

An interactive scene stepping inline: one frame per call, no pacing of its own.

Fields

worlds: SceneHandles

render: Entity

renderer: Entity

render_world: Entity

The entity the render sub-world is spawned under.

target: ResHandle<Texture>

The texture the offscreen pass draws into. Its resource id is what a caller reads frames back through.

stepper: SceneStepper

frame: Frame

samples: Vec<f32>

recording: Option<RecordingHandle>

device: Device

queue: Queue

Implementations

impl Interactive

pub fn step(&mut self, host: &World, frames: u32)

Step frames frames: dispatch the queued input, advance every world and pull the mix the frames would have played.

Nothing is drawn here, so a run that only reads the state back rather than the picture costs no draw calls. Interactive::draw draws the frame where the scene then stands, which is the same frame a step would have drawn: a draw does not advance the scene, and what it does write is only what a frame publishes for its readers, which the next frame replaces anyway.

pub fn frame(&self) -> u32

The frame the next step draws.

pub fn worlds_handle(&self) -> &SceneHandles

The handles the scene’s worlds were spawned under.

pub fn panel_buttons( host: &World, worlds: &SceneHandles, ) -> Vec<(&'static str, Rect)>

The panel buttons the last drawn frame laid out, keyed by label.

The layout lives on the gameplay world, refreshed on every tick.

pub fn render_frame(&self, host: &World) -> Vec<u8>

Draw the frame where the scene stands and read its pixels back.

The readback blocks until the copy lands. Drawing is what publishes the target the panels lay out against, so nothing is laid out until one frame has been drawn.

pub fn draw(&self, host: &World)

Draw the frame where the scene stands, into the offscreen texture.

The render sub-world catches up on the jobs queued for it first, so the frame draws the scene as the steps left it rather than as the jobs found it.

pub fn samples(&self) -> &[f32]

The samples the last step pulled from the audio world.

pub fn click(&mut self, host: &World, position: [f32; 2])

Click at position: move the pointer there, then press and release before the next frame, the sequence the MCP input tool sends.

pub fn start_recording(&mut self, host: &World, max_seconds: f32)

Start recording the mix the audio world fills.

The recording lives on the audio world, so its fills are counted even though the world is stepped from here.

pub fn stop_recording(&mut self, host: &World) -> Option<Recording>

Stop the recording and take the samples it captured.