Struct RuntimeStepContext 

#[non_exhaustive]
pub struct RuntimeStepContext<'a> {
    pub priority: i32,
    pub dt: f32,
    pub scene: &'a Scene,
    pub writeback: &'a mut TransformWriteback,
    pub output: &'a mut RuntimeOutput,
    pub pick_hit: Option<PickHit>,
    pub resources: &'a mut RuntimeResources,
}

Context passed to each plugin during its execution step.

Provides read-only scene access and write access to the transform writeback buffer, output accumulator, and shared resource registry. To write transforms, call TransformWriteback::set on self.writeback. To share state between plugins, use self.resources.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

priority: i32

The numeric priority of the plugin executing in this context.

dt: f32

Delta time for this step. For plugins in the simulate range with a fixed timestep this is the fixed step size, not the wall dt.

scene: &'a Scene

Read-only scene access. To write transforms, use writeback.

writeback: &'a mut TransformWriteback

Accumulate transform writes here. The runtime flushes them to the scene after the writeback phase.

output: &'a mut RuntimeOutput

Accumulate selection changes and contact events here.

pick_hit: Option<PickHit>

Forwarded from RuntimeFrameContext for plugins that need the current pick result.

resources: &'a mut RuntimeResources

Shared typed resource registry. Plugins use this to coordinate through engine-owned state without custom wiring in the application.

In submit (called with &RuntimeStepContext), only get and contains are accessible through the shared reference. In step, collect, and on_event (called with &mut RuntimeStepContext), full insert/get_mut/remove access is available.

Implementations

impl<'a> RuntimeStepContext<'a>

pub fn as_simulation(&mut self, step_index: u64) -> SimulationStepContext<'_>

Construct a SimulationStepContext from this context.

Pass the step count from super::ViewportRuntime::step_index so the simulation context reflects the current runtime step. The runtime does not thread the step index into RuntimeStepContext automatically – you must supply it.

fn step(&mut self, ctx: &mut RuntimeStepContext) {
    let sim = ctx.as_simulation(runtime.step_index());
    // use sim.step_index for deterministic seeding or replay
}

Note: within a fixed-timestep frame that runs N simulate steps, runtime.step_index() returns the count at the start of that frame. If you need a per-sub-step index (0..N) within a single frame, maintain a local counter in your plugin.

Passing an incorrect value does not cause undefined behavior, but physics code that uses step_index for deterministic seeding or replay will produce wrong results.