Struct FrameComposer 

pub struct FrameComposer<'a> { /* private fields */ }

Frame Composer

Holds all context references needed to render a single frame and provides a fluent API for injecting custom RDG passes via hooks.

Implementations

impl<'a> FrameComposer<'a>

pub fn device(&self) -> &Device

Returns a reference to the wgpu device.

pub fn resource_manager(&self) -> &ResourceManager

Returns a reference to the resource manager.

Useful for user-land passes that need to resolve engine resources (e.g. texture handles) before the RDG prepare phase.

pub fn add_custom_pass<F>(self, stage: HookStage, hook: F) -> FrameComposer<'a>

where F: FnOnce(&mut RenderGraph<'a>, GraphBlackboard) -> GraphBlackboard + 'a,

Registers a custom pass hook that will be invoked during graph building.

The closure receives a mutable reference to the RenderGraph and the GraphBlackboard containing the frame’s well-known resource slots. It must return an (optionally updated) GraphBlackboard — the Rust type system enforces that every hook path returns a valid blackboard.

Hooks registered with HookStage::AfterPostProcess run after all built-in post-processing (Bloom, ToneMap, FXAA) and are typically used for UI rendering.

Example

composer
    .add_custom_pass(HookStage::AfterPostProcess, |rdg, bb| {
        let new_surface = rdg.add_pass("MyPass", |builder| {
            let out = builder.mutate_texture(bb.surface_out, "Surface_MyPass");
            (MyPassNode { target: out }, out)
        });
        GraphBlackboard { surface_out: new_surface, ..bb }
    })
    .render();

pub fn render(self)

Executes the full rendering pipeline.

In windowed mode the result is presented to the swap-chain surface. In headless mode the result is written to the offscreen render target (available for readback via [Renderer::readback_pixels]).

Architecture

1. Acquire Render Target — swap-chain back buffer or headless texture
2. Build RDG — register resources, wire passes (compute, shadow, scene, post-processing), invoke user hooks
3. Compile & Execute — topological sort, allocate transients, prepare, execute, submit
4. Present — present swap-chain (windowed only)

Consumes self; the composer cannot be reused after render.