Removed per-item pipeline

packages/ranim-render/src/graph/mod.rs

@@ -5,11 +5,14 @@ pub mod view;
 pub mod clear;
 pub use clear::*;
 
+pub mod oit_resolve;
+pub use oit_resolve::*;
+
 use variadics_please::all_tuples;
 
 use crate::{
     RenderContext,
-    primitives::{viewport::ViewportGpuPacket, vitem::VItemRenderInstance},
+    primitives::viewport::ViewportGpuPacket,
     resource::Handle,
     utils::collections::{Graph, TypeBinnedVec},
 };
@@ -102,7 +105,6 @@ pub trait RenderPacketsQuery {
 
 /// A marker trait to make compiler happy.
 pub trait RenderPacketMark {}
-impl RenderPacketMark for VItemRenderInstance {}
 impl RenderPacketMark for ViewportGpuPacket {}
 
 impl<T: RenderPacketMark + Send + Sync + 'static> RenderPacketsQuery for T {

packages/ranim-render/src/graph/view/oit_resolve.rs → packages/ranim-render/src/graph/oit_resolve.rs

@@ -1,21 +1,19 @@
 use crate::{
     RenderContext, RenderTextures,
-    graph::{RenderPacketsQuery, view::ViewRenderNodeTrait},
+    graph::{GlobalRenderNodeTrait, RenderPacketsQuery},
     pipelines::OITResolvePipeline,
-    primitives::viewport::ViewportGpuPacket,
 };
 
 pub struct OITResolveNode;
 
-impl ViewRenderNodeTrait for OITResolveNode {
+impl GlobalRenderNodeTrait for OITResolveNode {
     type Query = ();
     fn run(
         &self,
         #[cfg(not(feature = "profiling"))] encoder: &mut wgpu::CommandEncoder,
         #[cfg(feature = "profiling")] encoder: &mut wgpu_profiler::Scope<'_, wgpu::CommandEncoder>,
         _packets: <Self::Query as RenderPacketsQuery>::Output<'_>,
         ctx: RenderContext,
-        viewport: &ViewportGpuPacket,
     ) {
         let RenderTextures {
             render_view,
@@ -58,7 +56,6 @@ impl ViewRenderNodeTrait for OITResolveNode {
                     .get_or_init::<OITResolvePipeline>(ctx.wgpu_ctx),
             );
             rpass.set_bind_group(0, &ctx.resolution_info.bind_group, &[]);
-            rpass.set_bind_group(1, &viewport.uniforms_bind_group.bind_group, &[]);
             rpass.draw(0..3, 0..1);
         }
         // Clear OIT pixel count buffer

packages/ranim-render/src/graph/view.rs

@@ -1,20 +1,11 @@
-pub mod vitem_color;
 use std::ops::{Deref, DerefMut};
 
-pub use vitem_color::*;
 pub mod vitem_compute;
 pub use vitem_compute::*;
 pub mod vitem_depth;
 pub use vitem_depth::*;
-pub mod oit_resolve;
-pub use oit_resolve::*;
-
-pub mod merged_vitem_compute;
-pub use merged_vitem_compute::*;
-pub mod merged_vitem_depth;
-pub use merged_vitem_depth::*;
-pub mod merged_vitem_color;
-pub use merged_vitem_color::*;
+pub mod vitem_color;
+pub use vitem_color::*;
 
 use crate::{
     RenderContext,

packages/ranim-render/src/graph/view/vitem_color.rs

@@ -2,29 +2,36 @@ use crate::{
     RenderContext, RenderTextures,
     graph::{RenderPacketsQuery, view::ViewRenderNodeTrait},
     pipelines::VItemColorPipeline,
-    primitives::{viewport::ViewportGpuPacket, vitem::VItemRenderInstance},
+    primitives::viewport::ViewportGpuPacket,
 };
 
-pub struct VItemColorNode;
+pub struct MergedVItemColorNode;
+
+impl ViewRenderNodeTrait for MergedVItemColorNode {
+    type Query = ();
 
-impl ViewRenderNodeTrait for VItemColorNode {
-    type Query = VItemRenderInstance;
     fn run(
         &self,
         #[cfg(not(feature = "profiling"))] encoder: &mut wgpu::CommandEncoder,
         #[cfg(feature = "profiling")] encoder: &mut wgpu_profiler::Scope<'_, wgpu::CommandEncoder>,
-        vitem2d_packets: <Self::Query as RenderPacketsQuery>::Output<'_>,
+        _packets: <Self::Query as RenderPacketsQuery>::Output<'_>,
         ctx: RenderContext,
         viewport: &ViewportGpuPacket,
     ) {
-        // VItem2d Render Pass
+        let Some(merged) = ctx.merged_buffer else {
+            return;
+        };
+        if merged.item_count() == 0 {
+            return;
+        }
+
         let RenderTextures {
             render_view,
             depth_stencil_view,
             ..
         } = ctx.render_textures;
         let rpass_desc = wgpu::RenderPassDescriptor {
-            label: Some("VItem2d Render Pass"),
+            label: Some("Merged VItem Color Render Pass"),
             color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                 view: render_view,
                 resolve_target: None,
@@ -46,7 +53,7 @@ impl ViewRenderNodeTrait for VItemColorNode {
             occlusion_query_set: None,
         };
         #[cfg(feature = "profiling")]
-        let mut rpass = encoder.scoped_render_pass("VItem2d Render Pass", rpass_desc);
+        let mut rpass = encoder.scoped_render_pass("Merged VItem Color Render Pass", rpass_desc);
         #[cfg(not(feature = "profiling"))]
         let mut rpass = encoder.begin_render_pass(&rpass_desc);
         rpass.set_pipeline(
@@ -55,9 +62,7 @@ impl ViewRenderNodeTrait for VItemColorNode {
         );
         rpass.set_bind_group(0, &ctx.resolution_info.bind_group, &[]);
         rpass.set_bind_group(1, &viewport.uniforms_bind_group.bind_group, &[]);
-        vitem2d_packets
-            .iter()
-            .map(|h| ctx.render_pool.get_packet(h))
-            .for_each(|vitem| vitem.encode_render_pass_command(&mut rpass));
+        rpass.set_bind_group(2, merged.render_bind_group.as_ref().unwrap(), &[]);
+        rpass.draw(0..4, 0..merged.item_count());
     }
 }

packages/ranim-render/src/graph/view/vitem_compute.rs

@@ -2,41 +2,46 @@ use crate::{
     RenderContext,
     graph::{RenderPacketsQuery, view::ViewRenderNodeTrait},
     pipelines::VItemComputePipeline,
-    primitives::{viewport::ViewportGpuPacket, vitem::VItemRenderInstance},
+    primitives::viewport::ViewportGpuPacket,
 };
-pub struct VItemComputeNode;
 
-impl ViewRenderNodeTrait for VItemComputeNode {
-    type Query = VItemRenderInstance;
+pub struct MergedVItemComputeNode;
+
+impl ViewRenderNodeTrait for MergedVItemComputeNode {
+    type Query = ();
 
     fn run(
         &self,
         #[cfg(not(feature = "profiling"))] encoder: &mut wgpu::CommandEncoder,
         #[cfg(feature = "profiling")] encoder: &mut wgpu_profiler::Scope<'_, wgpu::CommandEncoder>,
-        vitem2d_packets: <Self::Query as RenderPacketsQuery>::Output<'_>,
+        _packets: <Self::Query as RenderPacketsQuery>::Output<'_>,
         ctx: RenderContext,
         _viewport: &ViewportGpuPacket,
     ) {
+        let Some(merged) = ctx.merged_buffer else {
+            return;
+        };
+        if merged.item_count() == 0 {
+            return;
+        }
+
         #[cfg(feature = "profiling")]
-        let mut encoder = encoder.scope("Compute Pass");
-        // VItem2d Compute Pass
+        let mut encoder = encoder.scope("Merged Compute Pass");
+
         {
             #[cfg(feature = "profiling")]
-            let mut cpass = encoder.scoped_compute_pass("VItem2d Map Points Compute Pass");
+            let mut cpass = encoder.scoped_compute_pass("Merged VItem Map Points Compute Pass");
             #[cfg(not(feature = "profiling"))]
             let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
-                label: Some("VItem2d Map Points Compute Pass"),
+                label: Some("Merged VItem Map Points Compute Pass"),
                 timestamp_writes: None,
             });
             cpass.set_pipeline(
                 &ctx.pipelines
                     .get_or_init::<VItemComputePipeline>(ctx.wgpu_ctx),
             );
-
-            vitem2d_packets
-                .iter()
-                .map(|h| ctx.render_pool.get_packet(h))
-                .for_each(|vitem| vitem.encode_compute_pass_command(&mut cpass));
+            cpass.set_bind_group(0, merged.compute_bind_group.as_ref().unwrap(), &[]);
+            cpass.dispatch_workgroups(merged.total_points().div_ceil(256), 1, 1);
         }
     }
 }