ranim_render/

lib.rs

//! Rendering stuff in ranim
// #![warn(missing_docs)]
#![cfg_attr(docsrs, feature(doc_cfg))]
#![allow(rustdoc::private_intra_doc_links)]
#![doc(
    html_logo_url = "https://raw.githubusercontent.com/AzurIce/ranim/refs/heads/main/assets/ranim.svg",
    html_favicon_url = "https://raw.githubusercontent.com/AzurIce/ranim/refs/heads/main/assets/ranim.svg"
)]
/// Render Graph
pub mod graph;
/// The pipelines
pub mod pipelines;
/// The basic renderable structs
pub mod primitives;
pub mod resource;
/// Rendering related utils
pub mod utils;

use glam::{UVec3, uvec3};

use crate::{
    graph::{AnyGlobalRenderNodeTrait, GlobalRenderGraph, RenderPackets},
    primitives::{mesh_items::MeshItemsBuffer, viewport::ViewportUniform, vitems::VItemsBuffer},
    resource::{PipelinesPool, RenderPool, RenderTextures},
    utils::{WgpuBuffer, WgpuVecBuffer},
};
use ranim_core::store::CoreItemStore;
use utils::WgpuContext;

#[cfg(feature = "profiling")]
// Since the timing information we get from WGPU may be several frames behind the CPU, we can't report these frames to
// the singleton returned by `puffin::GlobalProfiler::lock`. Instead, we need our own `puffin::GlobalProfiler` that we
// can be several frames behind puffin's main global profiler singleton.
pub static PUFFIN_GPU_PROFILER: std::sync::LazyLock<std::sync::Mutex<puffin::GlobalProfiler>> =
    std::sync::LazyLock::new(|| std::sync::Mutex::new(puffin::GlobalProfiler::default()));

#[allow(unused)]
#[cfg(feature = "profiling")]
mod profiling_utils {
    use wgpu_profiler::GpuTimerQueryResult;

    pub fn scopes_to_console_recursive(results: &[GpuTimerQueryResult], indentation: u32) {
        for scope in results {
            if indentation > 0 {
                print!("{:<width$}", "|", width = 4);
            }

            if let Some(time) = &scope.time {
                println!(
                    "{:.3}μs - {}",
                    (time.end - time.start) * 1000.0 * 1000.0,
                    scope.label
                );
            } else {
                println!("n/a - {}", scope.label);
            }

            if !scope.nested_queries.is_empty() {
                scopes_to_console_recursive(&scope.nested_queries, indentation + 1);
            }
        }
    }

    pub fn console_output(
        results: &Option<Vec<GpuTimerQueryResult>>,
        enabled_features: wgpu::Features,
    ) {
        puffin::profile_scope!("console_output");
        print!("\x1B[2J\x1B[1;1H"); // Clear terminal and put cursor to first row first column
        println!("Welcome to wgpu_profiler demo!");
        println!();
        println!(
            "Press space to write out a trace file that can be viewed in chrome's chrome://tracing"
        );
        println!();
        match results {
            Some(results) => {
                scopes_to_console_recursive(results, 0);
            }
            None => println!("No profiling results available yet!"),
        }
    }
}

#[derive(Clone, Copy)]
pub struct RenderContext<'a> {
    pub render_textures: &'a RenderTextures,
    pub render_pool: &'a RenderPool,
    pub render_packets: &'a RenderPackets,
    pub pipelines: &'a PipelinesPool,
    pub wgpu_ctx: &'a WgpuContext,
    pub resolution_info: &'a ResolutionInfo,
    pub clear_color: wgpu::Color,
    /// Present when using the merged rendering path.
    pub merged_buffer: Option<&'a VItemsBuffer>,
    /// Present when using the merged mesh rendering path.
    pub merged_mesh_buffer: Option<&'a MeshItemsBuffer>,
}

// MARK: Renderer
pub struct Renderer {
    width: u32,
    height: u32,
    pub(crate) resolution_info: ResolutionInfo,
    pub(crate) pipelines: PipelinesPool,
    packets: RenderPackets,
    render_graph: GlobalRenderGraph,

    /// Present when using the merged rendering path (lazily initialized on first use).
    merged_buffer: Option<VItemsBuffer>,
    /// Present when using the merged mesh rendering path (lazily initialized on first use).
    merged_mesh_buffer: Option<MeshItemsBuffer>,

    #[cfg(feature = "profiling")]
    pub(crate) profiler: wgpu_profiler::GpuProfiler,
}

impl Renderer {
    pub fn width(&self) -> u32 {
        self.width
    }

    pub fn height(&self) -> u32 {
        self.height
    }

    pub fn ratio(&self) -> f32 {
        self.width as f32 / self.height as f32
    }

    fn build_render_graph() -> GlobalRenderGraph {
        use graph::*;
        let mut render_graph = GlobalRenderGraph::new();
        let clear = render_graph.insert_node(ClearNode);
        let view_render = render_graph.insert_node({
            use graph::view::*;
            let mut render_graph = ViewRenderGraph::new();
            let vitem_compute = render_graph.insert_node(MergedVItemComputeNode);
            let vitem_depth = render_graph.insert_node(MergedVItemDepthNode);
            let mesh_depth = render_graph.insert_node(MergedMeshItemDepthNode);
            let vitem_color = render_graph.insert_node(MergedVItemColorNode);
            let mesh_color = render_graph.insert_node(MergedMeshItemColorNode);

            render_graph.insert_edge(vitem_compute, vitem_depth);
            render_graph.insert_edge(vitem_depth, vitem_color);
            render_graph.insert_edge(vitem_depth, mesh_color);
            render_graph.insert_edge(mesh_depth, mesh_color);
            render_graph.insert_edge(mesh_depth, vitem_color);
            render_graph
        });
        let oit_resolve = render_graph.insert_node(OITResolveNode);
        render_graph.insert_edge(clear, view_render);
        render_graph.insert_edge(view_render, oit_resolve);
        render_graph
    }

    /// Create a new renderer with default [`Self::build_render_graph`]
    pub fn new(ctx: &WgpuContext, width: u32, height: u32, oit_layers: usize) -> Self {
        Self::new_with_graph(ctx, width, height, oit_layers, Self::build_render_graph())
    }

    /// Create a new renderer with the given render graph
    pub fn new_with_graph(
        ctx: &WgpuContext,
        width: u32,
        height: u32,
        oit_layers: usize,
        render_graph: GlobalRenderGraph,
    ) -> Self {
        let resolution_info = ResolutionInfo::new(ctx, width, height, oit_layers);

        #[cfg(feature = "profiling")]
        let profiler = wgpu_profiler::GpuProfiler::new(
            &ctx.device,
            wgpu_profiler::GpuProfilerSettings::default(),
        )
        .unwrap();

        Self {
            width,
            height,
            resolution_info,
            pipelines: PipelinesPool::default(),
            packets: RenderPackets::default(),
            render_graph,
            merged_buffer: None,
            merged_mesh_buffer: None,
            #[cfg(feature = "profiling")]
            profiler,
        }
    }

    pub fn new_render_textures(&self, ctx: &WgpuContext) -> RenderTextures {
        RenderTextures::new(ctx, self.width, self.height)
    }

    /// Render a frame. Pushes viewport + VItem packets via pool, then execs the render graph.
    pub fn render_store_with_pool(
        &mut self,
        ctx: &WgpuContext,
        render_textures: &mut RenderTextures,
        clear_color: wgpu::Color,
        store: &CoreItemStore,
        pool: &mut RenderPool,
    ) {
        // Viewport — always needed
        let camera_frame = &store.camera_frames[0];
        let viewport = ViewportUniform::from_camera_frame(camera_frame, self.width, self.height);
        self.packets.push(pool.alloc_packet(ctx, &viewport));

        // Merged buffer (merged nodes read this; old nodes ignore it)
        let merged = self
            .merged_buffer
            .get_or_insert_with(|| VItemsBuffer::new(ctx));
        merged.update(ctx, &store.vitems);

        // Merged mesh buffer
        let merged_mesh = self
            .merged_mesh_buffer
            .get_or_insert_with(|| MeshItemsBuffer::new(ctx));
        merged_mesh.update(ctx, &store.mesh_items);

        // Encode & submit
        {
            #[cfg(feature = "profiling")]
            profiling::scope!("render");

            let mut encoder = ctx
                .device
                .create_command_encoder(&wgpu::CommandEncoderDescriptor::default());

            {
                #[cfg(feature = "profiling")]
                let mut scope = self.profiler.scope("render", &mut encoder);

                let render_ctx = RenderContext {
                    pipelines: &self.pipelines,
                    render_textures,
                    render_packets: &self.packets,
                    render_pool: pool,
                    wgpu_ctx: ctx,
                    resolution_info: &self.resolution_info,
                    clear_color,
                    merged_buffer: self.merged_buffer.as_ref(),
                    merged_mesh_buffer: self.merged_mesh_buffer.as_ref(),
                };

                self.render_graph.exec(
                    #[cfg(not(feature = "profiling"))]
                    &mut encoder,
                    #[cfg(feature = "profiling")]
                    &mut scope,
                    render_ctx,
                );
            }

            #[cfg(not(feature = "profiling"))]
            ctx.queue.submit(Some(encoder.finish()));

            #[cfg(feature = "profiling")]
            {
                self.profiler.resolve_queries(&mut encoder);
                {
                    profiling::scope!("submit");
                    ctx.queue.submit(Some(encoder.finish()));
                }

                self.profiler.end_frame().unwrap();

                ctx.device
                    .poll(wgpu::PollType::wait_indefinitely())
                    .unwrap();
                let latest_profiler_results = self
                    .profiler
                    .process_finished_frame(ctx.queue.get_timestamp_period());
                let mut gpu_profiler = PUFFIN_GPU_PROFILER.lock().unwrap();
                wgpu_profiler::puffin::output_frame_to_puffin(
                    &mut gpu_profiler,
                    &latest_profiler_results.unwrap(),
                );
                gpu_profiler.new_frame();
            }

            render_textures.mark_dirty();
        }

        self.packets.clear();
    }
}

#[allow(unused)]
pub struct ResolutionInfo {
    buffer: WgpuBuffer<UVec3>,
    pub(crate) pixel_count_buffer: WgpuVecBuffer<u32>,
    oit_colors_buffer: WgpuVecBuffer<u32>,
    oit_depths_buffer: WgpuVecBuffer<f32>,
    bind_group: wgpu::BindGroup,
}

impl ResolutionInfo {
    pub fn new(ctx: &WgpuContext, width: u32, height: u32, oit_layers: usize) -> Self {
        let buffer = WgpuBuffer::new_init(
            ctx,
            Some("ResolutionInfo Buffer"),
            wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
            uvec3(width, height, oit_layers as u32),
        );

        let pixel_count = (width * height) as usize;
        let total_nodes = pixel_count * oit_layers;

        let pixel_count_buffer = WgpuVecBuffer::new(
            ctx,
            Some("OIT Pixel Count Buffer"),
            wgpu::BufferUsages::STORAGE
                | wgpu::BufferUsages::COPY_DST
                | wgpu::BufferUsages::COPY_SRC,
            pixel_count,
        );
        let oit_colors_buffer = WgpuVecBuffer::new(
            ctx,
            Some("OIT Colors Buffer"),
            wgpu::BufferUsages::STORAGE
                | wgpu::BufferUsages::COPY_SRC
                | wgpu::BufferUsages::COPY_DST,
            total_nodes,
        );
        let oit_depths_buffer = WgpuVecBuffer::new(
            ctx,
            Some("OIT Depths Buffer"),
            wgpu::BufferUsages::STORAGE
                | wgpu::BufferUsages::COPY_SRC
                | wgpu::BufferUsages::COPY_DST,
            total_nodes,
        );

        let bind_group = ctx.device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("ResolutionInfo BindGroup"),
            layout: &Self::create_bind_group_layout(ctx),
            entries: &[
                wgpu::BindGroupEntry {
                    binding: 0,
                    resource: buffer.as_ref().as_entire_binding(),
                },
                wgpu::BindGroupEntry {
                    binding: 1,
                    resource: wgpu::BindingResource::Buffer(
                        pixel_count_buffer.buffer.as_entire_buffer_binding(),
                    ),
                },
                wgpu::BindGroupEntry {
                    binding: 2,
                    resource: wgpu::BindingResource::Buffer(
                        oit_colors_buffer.buffer.as_entire_buffer_binding(),
                    ),
                },
                wgpu::BindGroupEntry {
                    binding: 3,
                    resource: wgpu::BindingResource::Buffer(
                        oit_depths_buffer.buffer.as_entire_buffer_binding(),
                    ),
                },
            ],
        });

        Self {
            buffer,
            bind_group,
            oit_colors_buffer,
            oit_depths_buffer,
            pixel_count_buffer,
        }
    }
    // This may never be used?
    // pub fn update(&mut self, ctx: &WgpuContext, resolution: UVec2) {
    //     self.buffer.set(ctx, resolution);

    //     let pixel_count = (data.screen_size[0] * data.screen_size[1]) as usize;
    //     let layers = data.oit_layers as usize;
    //     let total_nodes = pixel_count * layers;

    //     let mut bind_group_dirty = false;

    //     if self.pixel_count_buffer.len() != pixel_count {
    //         self.pixel_count_buffer.resize(ctx, pixel_count);
    //         bind_group_dirty = true;
    //     }

    //     if self.oit_colors_buffer.len() != total_nodes {
    //         self.oit_colors_buffer.resize(ctx, total_nodes);
    //         bind_group_dirty = true;
    //     }

    //     if self.oit_depths_buffer.len() != total_nodes {
    //         self.oit_depths_buffer.resize(ctx, total_nodes);
    //         bind_group_dirty = true;
    //     }

    //     if bind_group_dirty {
    //         self.uniforms_bind_group = ViewportBindGroup::new(
    //             ctx,
    //             &self.uniforms_buffer,
    //             &self.pixel_count_buffer,
    //             &self.oit_colors_buffer,
    //             &self.oit_depths_buffer,
    //         );
    //     }
    // }
    pub fn create_bind_group_layout(ctx: &WgpuContext) -> wgpu::BindGroupLayout {
        ctx.device
            .create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                label: Some("ResolutionInfo BindGroupLayout"),
                entries: &[
                    wgpu::BindGroupLayoutEntry {
                        binding: 0,
                        visibility: wgpu::ShaderStages::VERTEX_FRAGMENT
                            | wgpu::ShaderStages::COMPUTE,
                        ty: wgpu::BindingType::Buffer {
                            ty: wgpu::BufferBindingType::Uniform,
                            has_dynamic_offset: false,
                            min_binding_size: None,
                        },
                        count: None,
                    },
                    wgpu::BindGroupLayoutEntry {
                        binding: 1,
                        visibility: wgpu::ShaderStages::FRAGMENT,
                        ty: wgpu::BindingType::Buffer {
                            ty: wgpu::BufferBindingType::Storage { read_only: false },
                            has_dynamic_offset: false,
                            min_binding_size: None,
                        },
                        count: None,
                    },
                    wgpu::BindGroupLayoutEntry {
                        binding: 2,
                        visibility: wgpu::ShaderStages::FRAGMENT,
                        ty: wgpu::BindingType::Buffer {
                            ty: wgpu::BufferBindingType::Storage { read_only: false },
                            has_dynamic_offset: false,
                            min_binding_size: None,
                        },
                        count: None,
                    },
                    wgpu::BindGroupLayoutEntry {
                        binding: 3,
                        visibility: wgpu::ShaderStages::FRAGMENT,
                        ty: wgpu::BindingType::Buffer {
                            ty: wgpu::BufferBindingType::Storage { read_only: false },
                            has_dynamic_offset: false,
                            min_binding_size: None,
                        },
                        count: None,
                    },
                ],
            })
    }
}