Struct RuntimeOutput 

#[non_exhaustive]
pub struct RuntimeOutput {
    pub node_transform_ops: Vec<NodeTransformOp>,
    pub selection_ops: Vec<SelectionOp>,
    pub contact_events: Vec<ContactEvent>,
    pub camera_follow_target: Option<Vec3>,
    pub camera_commands: Vec<CameraCommand>,
    pub events: RuntimeEventBus,
    pub skinned_mesh_updates: Vec<SkinnedMeshUpdate>,
    pub skinned_pose_updates: Vec<SkinnedPoseUpdate>,
}

Output produced by one call to super::ViewportRuntime::step.

node_transform_ops have already been applied to the scene and the snapshot table when this is returned. The other fields are for the app to read and act on as needed.

Plugin-authored events of any type are collected in events. Use output.events.read::<T>() or output.events.drain::<T>() to consume them. Plugin-authored camera changes are in camera_commands; apply them with output.apply_camera_commands(&mut camera).

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.

node_transform_ops: Vec<NodeTransformOp>

Transform ops applied to the scene during this step.

selection_ops: Vec<SelectionOp>

Selection changes produced by runtime plugins, already applied to the app-owned Selection.

contact_events: Vec<ContactEvent>

Contact events from physics plugins. Empty if no physics plugin is active.

camera_follow_target: Option<Vec3>

Suggested camera center computed from the active super::CameraFollow binding.

Some when a CameraFollow::Node target was resolved this step; None when no follow binding is set or the target node was not found. Apply to camera.center for orbit-camera follow behavior.

camera_commands: Vec<CameraCommand>

Camera commands emitted by plugins this frame. Apply with Self::apply_camera_commands. Empty when no camera plugin is active.

events: RuntimeEventBus

Generic typed event bus. Plugins emit events via ctx.output.events.emit(MyEvent { .. }). The app reads them after step() via output.events.read::<MyEvent>() or output.events.drain::<MyEvent>(). Events are cleared each frame because RuntimeOutput is constructed fresh on every step call.

skinned_mesh_updates: Vec<SkinnedMeshUpdate>

Per-mesh deformation updates from skinning plugins on the CPU path. Apply after step() by calling write_mesh_positions_normals on each entry. Empty when no super::plugins::SkeletonPlugin is active on the CPU path.

skinned_pose_updates: Vec<SkinnedPoseUpdate>

Per-instance joint palette updates from skinning plugins on the GPU path. Apply after step() by calling crate::ViewportGpuResources::set_skin_palette on each entry. Empty when no skinning plugin is active on the GPU path.

Implementations

impl RuntimeOutput

pub fn apply_camera_commands(&self, camera: &mut Camera)

Apply all camera commands in emission order to camera.

Call this after super::ViewportRuntime::step returns, before rendering. Has no effect if camera_commands is empty.

Commands are applied sequentially: each one builds on the result of the previous. A BlendToward command blends from whatever state the camera is in after all prior commands, not from the frame-start state.

Trait Implementations

impl Default for RuntimeOutput

fn default() -> RuntimeOutput

Returns the “default value” for a type.