Struct RenderAgent 

pub struct RenderAgent { /* private fields */ }

The agent responsible for managing the state and logic of the rendering pipeline.

It orchestrates the various systems and lanes involved in preparing and translating scene data from the ECS into a format consumable by the low-level RenderSystem.

Implementations

impl RenderAgent

pub fn new() -> Self

Creates a new RenderAgent with default lanes and automatic strategy selection.

pub fn with_strategy(strategy: RenderingStrategy) -> Self

Creates a new RenderAgent with the specified rendering strategy.

pub fn add_lane(&mut self, lane: Box<dyn RenderLane>)

Adds a custom render lane to the available lanes.

pub fn set_strategy(&mut self, strategy: RenderingStrategy)

Sets the rendering strategy.

pub fn strategy(&self) -> RenderingStrategy

Returns the current rendering strategy.

pub fn lanes(&self) -> &[Box<dyn RenderLane>]

Returns a reference to the available lanes.

pub fn select_lane(&self) -> &dyn RenderLane

Selects the appropriate render lane based on the current strategy.

pub fn prepare_frame( &mut self, world: &mut World, cpu_meshes: &Assets<Mesh>, graphics_device: &dyn GraphicsDevice, )

Prepares all rendering data for the current frame.

This method runs the entire Control Plane logic for rendering:

1. Prepares GPU resources for any newly loaded meshes.
2. Extracts all visible objects from the ECS into the internal RenderWorld.

pub fn render( &mut self, world: &mut World, cpu_meshes: &Assets<Mesh>, graphics_device: &dyn GraphicsDevice, materials: &RwLock<Assets<Box<dyn Material>>>, encoder: &mut dyn CommandEncoder, render_ctx: &RenderContext<'_>, )

Renders a frame by preparing the scene data and encoding GPU commands.

This is the main rendering method that orchestrates the entire rendering pipeline:

1. Calls prepare_frame() to extract and prepare all renderable data
2. Calls produce_render_objects() to build the RenderObject list with proper pipelines
3. Delegates to the selected render lane to encode GPU commands

Arguments

• world: The ECS world containing scene data
• cpu_meshes: The cache of CPU-side mesh assets
• graphics_device: The graphics device for GPU resource creation
• materials: The cache of material assets
• encoder: The command encoder to record GPU commands into
• color_target: The texture view to render into (typically the swapchain)
• clear_color: The color to clear the framebuffer with

pub fn produce_render_objects( &self, materials: &RwLock<Assets<Box<dyn Material>>>, ) -> Vec<RenderObject>

Translates the prepared data from the RenderWorld into a list of RenderObjects.

This method should be called after prepare_frame. It reads the intermediate RenderWorld and produces the final, low-level data structure required by the RenderSystem.

This logic uses the render lane to determine the appropriate pipeline for each material, then builds the RenderObjects list.

Arguments

• materials: The cache of material assets for pipeline selection

pub fn extract_camera_view(&self, world: &World) -> ViewInfo

Extracts the active camera from the ECS world and generates a ViewInfo.

This method queries the ECS for entities with both a Camera and GlobalTransform component, finds the first active camera, and constructs a ViewInfo containing the camera’s view and projection matrices.

Arguments

• world: The ECS world containing camera entities

Returns

A ViewInfo containing the camera’s matrices and position. If no active camera is found, returns a default ViewInfo with identity matrices.

Trait Implementations

impl Default for RenderAgent

fn default() -> Self

Returns the “default value” for a type.