Struct bevy::render::pipelined_rendering::PipelinedRenderingPlugin

pub struct PipelinedRenderingPlugin;

The PipelinedRenderingPlugin can be added to your application to enable pipelined rendering. This moves rendering into a different thread, so that the Nth frame’s rendering can be run at the same time as the N + 1 frame’s simulation.

|--------------------|--------------------|--------------------|--------------------|
| simulation thread  | frame 1 simulation | frame 2 simulation | frame 3 simulation |
|--------------------|--------------------|--------------------|--------------------|
| rendering thread   |                    | frame 1 rendering  | frame 2 rendering  |
|--------------------|--------------------|--------------------|--------------------|

The plugin is dependent on the RenderApp added by crate::RenderPlugin and so must be added after that plugin. If it is not added after, the plugin will do nothing.

A single frame of execution looks something like below

|--------------------------------------------------------------------|
|         | RenderExtractApp schedule | winit events | main schedule |
| extract |----------------------------------------------------------|
|         | extract commands | rendering schedule                    |
|--------------------------------------------------------------------|

• extract is the step where data is copied from the main world to the render world. This is run on the main app’s thread.
• On the render thread, we first apply the extract commands. This is not run during extract, so the main schedule can start sooner.
• Then the rendering schedule is run. See RenderSet for the standard steps in this process.
• In parallel to the rendering thread the RenderExtractApp schedule runs. By default this schedule is empty. But it is useful if you need something to run before I/O processing.
• Next all the winit events are processed.
• And finally the main app schedule is run.
• Once both the main app schedule and the render schedule are finished running, extract is run again.

Trait Implementations

impl Default for PipelinedRenderingPlugin

fn default() -> PipelinedRenderingPlugin

Returns the “default value” for a type.

impl Plugin for PipelinedRenderingPlugin

fn build(&self, app: &mut App)

Configures the App to which this plugin is added.

fn cleanup(&self, app: &mut App)

Runs after all plugins are built and finished, but before the app schedule is executed. This can be useful if you have some resource that other plugins need during their build step, but after build you want to remove it and send it to another thread.

fn ready(&self, _app: &App) -> bool

Has the plugin finished its setup? This can be useful for plugins that need something asynchronous to happen before they can finish their setup, like the initialization of a renderer. Once the plugin is ready, finish should be called.

fn finish(&self, _app: &mut App)

Finish adding this plugin to the App, once all plugins registered are ready. This can be useful for plugins that depends on another plugin asynchronous setup, like the renderer.

fn name(&self) -> &str

Configures a name for the Plugin which is primarily used for checking plugin uniqueness and debugging.

fn is_unique(&self) -> bool

If the plugin can be meaningfully instantiated several times in an App, override this method to return false.