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.

Design Notes

• Single unified graph: All rendering (scene + post + custom) flows through the RDG. No legacy graph system remains.
• Pure dataflow chain: Every Feature::add_to_graph returns a [TextureNodeId], enabling a strict functional pipeline where each pass’s output feeds the next pass’s input — no side-effect writes.
• Flattened macro-nodes: Complex multi-step effects (e.g. Bloom) are decomposed into individual RDG passes, exposing fine-grained dependencies to the compiler for optimal barrier and memory aliasing.
• Hook-based extensibility: External code (e.g. UI) injects passes via add_custom_pass closures that receive the GraphBlackboard for type-safe resource wiring.
• Lifetime safety: Lifetime 'a locks the mutable borrow on Renderer.
• Deferred Surface acquisition: The Surface is acquired only in .render() to minimise hold time.

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 and presents to the screen.

Architecture

1. Acquire Surface — get the swap-chain back buffer
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

Consumes self; the composer cannot be reused after render.