Design a renderer based on frame graph

[zuiyu1998]

Summary

Frame graph based renderer design.

Motivation

Frame graph will add two features:

• Efficient resource management: Accurately track when and where each resource is created, used, and destroyed. Automatic resource lifecycle management.
• Easy to debug: Based on DAG, it is very convenient to visualize the rendering graph, which is used to analyze the dependencies and execution order between rendering stages, as well as node status, performance analysis, statistics, etc.

User-facing explanation

The frame graph is DAG. It consists of pass nodes and resource nodes. The render node describes how to draw the resource to the GPU. The resource node describes how to use the resource.
The frame graph divides the rendering of a frame into three stages: Setup, Compile, and Execute. In the Setup stage, the user can freely build the frame graph. In the Compile stage, the frame graph will confirm the life cycle of each resource. In the Execute stage, the frame graph will match the resources with the GPU resources one by one and execute the rendering described by the pass node.

Resource

One of the most important feature of the frame graph is to automatically manage the creation, use, and destruction of resources. The resources here are not GPU resources. They are frame graph-defined resources. Resources usually do not correspond to actual GPU resources. Only in the Execute Stage of the frame graph will they correspond to GPU resources one-to-one. Therefore, resources usually have two states: resource descriptor and resource instance. The definition in rust is as follows:

pub enum AnyFrameGraphResource {
    OwnedBuffer(FrameGraphBuffer),
    ImportedBuffer(Arc<FrameGraphBuffer>),
    OwnedTexture(FrameGraphTexture),
    ImportedTexture(Arc<FrameGraphTexture>),
}

pub struct FrameGraphBuffer {
    pub resource: wgpu::Buffer,
    pub desc: BufferInfo,
}

#[derive(Clone, Hash, PartialEq, Eq)]
pub struct BufferInfo {
    pub label: Option<Cow<'static, str>>,
    pub size: wgpu::BufferAddress,
    pub usage: wgpu::BufferUsages,
    pub mapped_at_creation: bool,
}

impl BufferInfo {
    pub fn get_buffer_desc(&self) -> wgpu::BufferDescriptor {
        wgpu::BufferDescriptor {
            label: self.label.as_deref(),
            size: self.size,
            usage: self.usage,
            mapped_at_creation: self.mapped_at_creation,
        }
    }
}

pub struct FrameGraphTexture {
    pub resource: wgpu::Texture,
    pub desc: TextureInfo,
}

#[derive(Clone, Hash, PartialEq, Eq)]
pub struct TextureInfo {
    pub label: Option<Cow<'static, str>>,
    pub size: wgpu::Extent3d,
    pub mip_level_count: u32,
    pub sample_count: u32,
    pub dimension: wgpu::TextureDimension,
    pub format: wgpu::TextureFormat,
    pub usage: wgpu::TextureUsages,
    pub view_formats: Vec<wgpu::TextureFormat>,
}

impl TextureInfo {
    pub fn get_texture_desc(&self) -> wgpu::TextureDescriptor {
        wgpu::TextureDescriptor {
            label: self.label.as_deref(),
            size: self.size,
            mip_level_count: self.mip_level_count,
            sample_count: self.sample_count,
            dimension: self.dimension,
            format: self.format,
            usage: self.usage,
            view_formats: &self.view_formats,
        }
    }
}

pub enum AnyFrameGraphResourceDescriptor {
    Texture(TextureInfo),
    Buffer(BufferInfo),
}

Two types of resources are defined here: buffer and texture. If necessary, you can easily expand AnyFrameGraphResourceDescriptor, AnyFrameGraphResource.

How to build a render pass

In Bevy's current design, GPU resources are directly obtained for rendering.

let mut render_pass = render_context
    .command_encoder()
    .begin_render_pass(&pass_descriptor);

render_pass.set_pipeline(pipeline);
render_pass.set_bind_group(0, bind_group, &[]);
render_pass.draw(0..3, 0..1);

In the new design, rendering is done through a layer of encapsulation, and all resources are obtained from render_context.

pub struct TrackedRenderPass<'a> {
    command_encoder: wgpu::CommandEncoder,
    render_pass: wgpu::RenderPass<'static>,
    render_context: &'a mut RenderContext,
}

impl<'a> TrackedRenderPass<'a> {
    pub fn draw_indexed(&mut self, indices: Range<u32>, base_vertex: i32, instances: Range<u32>) {
        self.render_pass
            .draw_indexed(indices, base_vertex, instances);
    }

    pub fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>) {
        self.render_pass.draw(vertices, instances);
    }

    pub fn set_vertex_buffer(
        &mut self,
        slot: u32,
        buffer_ref: &ResourceRef<FrameGraphBuffer, ResourceRead>,
    ) -> Result<(), FrameGraphError> {
        let buffer = self.render_context.get_resource(&buffer_ref)?;
        self.render_pass
            .set_vertex_buffer(slot, buffer.resource.slice(0..));

        Ok(())
    }

    pub fn set_index_buffer(
        &mut self,
        buffer_ref: &ResourceRef<FrameGraphBuffer, ResourceRead>,
        index_format: wgpu::IndexFormat,
    ) -> Result<(), FrameGraphError> {
        let buffer = self.render_context.get_resource(&buffer_ref)?;

        self.render_pass
            .set_index_buffer(buffer.resource.slice(0..), index_format);

        Ok(())
    }

    fn end(self) {
        drop(self.render_pass);

        let command_buffer = self.command_encoder.finish();

        self.render_context
            .command_buffer_queue
            .push(command_buffer);
    }
}

In this design there is no need to know when the relationship resources are created.

How to build pass

let swap_chain_texture = FrameGraphTexture::new_arc_with_surface(surface);

            let mut builder = frame_graph.create_pass_node_bulder("no_camera_clear_pass");

            let swap_chain_texture_key = Self::get_camera_texure_key(*id);

            let swap_chain_texture_handle =
                builder.import(&swap_chain_texture_key, swap_chain_texture);

            let swap_chain_texture_read = builder.read(swap_chain_texture_handle);

            let mut render_pass = RenderPass::default();

            render_pass.add_color_attachment(ColorAttachmentRef {
                view_ref: TextureViewRef {
                    texture_ref: swap_chain_texture_read,
                    desc: TextureViewInfo::default(),
                },
                resolve_target: None,
                ops: Operations {
                    load: LoadOp::Clear(clear_color_global.to_linear().into()),
                    store: StoreOp::Store,
                },
            });

            builder.set_pass(render_pass);