Expose type erased draw data that can be consumed directly

crates/re_renderer/examples/2d.rs

@@ -272,9 +272,9 @@ impl framework::Example for Render2D {
                         ..Default::default()
                     },
                 );
-                view_builder.queue_draw(&line_strip_draw_data);
-                view_builder.queue_draw(&point_draw_data);
-                view_builder.queue_draw(&rectangle_draw_data);
+                view_builder.queue_draw(line_strip_draw_data.clone());
+                view_builder.queue_draw(point_draw_data.clone());
+                view_builder.queue_draw(rectangle_draw_data.clone());
                 let command_buffer = view_builder
                     .draw(re_ctx, ecolor::Rgba::TRANSPARENT)
                     .unwrap();
@@ -315,9 +315,9 @@ impl framework::Example for Render2D {
                     },
                 );
                 let command_buffer = view_builder
-                    .queue_draw(&line_strip_draw_data)
-                    .queue_draw(&point_draw_data)
-                    .queue_draw(&rectangle_draw_data)
+                    .queue_draw(line_strip_draw_data)
+                    .queue_draw(point_draw_data)
+                    .queue_draw(rectangle_draw_data)
                     .draw(re_ctx, ecolor::Rgba::TRANSPARENT)
                     .unwrap();
                 framework::ViewDrawResult {

crates/re_renderer/examples/depth_cloud.rs

@@ -61,8 +61,8 @@ impl RenderDepthClouds {
         pixels_from_point: f32,
         resolution_in_pixel: [u32; 2],
         target_location: glam::Vec2,
-        frame_draw_data: &FD,
-        image_draw_data: &ID,
+        frame_draw_data: FD,
+        image_draw_data: ID,
     ) -> framework::ViewDrawResult
     where
         FD: DrawData + Sync + Send + Clone + 'static,
@@ -131,8 +131,8 @@ impl RenderDepthClouds {
         );
 
         let command_buffer = view_builder
-            .queue_draw(&GenericSkyboxDrawData::new(re_ctx))
-            .queue_draw(&point_cloud_draw_data)
+            .queue_draw(GenericSkyboxDrawData::new(re_ctx))
+            .queue_draw(point_cloud_draw_data)
             .queue_draw(frame_draw_data)
             .queue_draw(image_draw_data)
             .draw(re_ctx, ecolor::Rgba::TRANSPARENT)
@@ -152,8 +152,8 @@ impl RenderDepthClouds {
         pixels_from_point: f32,
         resolution_in_pixel: [u32; 2],
         target_location: glam::Vec2,
-        frame_draw_data: &FD,
-        image_draw_data: &ID,
+        frame_draw_data: FD,
+        image_draw_data: ID,
     ) -> framework::ViewDrawResult
     where
         FD: DrawData + Sync + Send + Clone + 'static,
@@ -211,8 +211,8 @@ impl RenderDepthClouds {
         );
 
         let command_buffer = view_builder
-            .queue_draw(&GenericSkyboxDrawData::new(re_ctx))
-            .queue_draw(&depth_cloud_draw_data)
+            .queue_draw(GenericSkyboxDrawData::new(re_ctx))
+            .queue_draw(depth_cloud_draw_data)
             .queue_draw(frame_draw_data)
             .queue_draw(image_draw_data)
             .draw(re_ctx, ecolor::Rgba::TRANSPARENT)
@@ -333,16 +333,16 @@ impl framework::Example for RenderDepthClouds {
                 pixels_from_point,
                 splits[0].resolution_in_pixel,
                 splits[0].target_location,
-                &frame_draw_data,
-                &image_draw_data,
+                frame_draw_data.clone(),
+                image_draw_data.clone(),
             ),
             self.draw_depth_cloud(
                 re_ctx,
                 pixels_from_point,
                 splits[1].resolution_in_pixel,
                 splits[1].target_location,
-                &frame_draw_data,
-                &image_draw_data,
+                frame_draw_data,
+                image_draw_data,
             ),
         ]
     }

crates/re_renderer/examples/depth_offset.rs

@@ -114,7 +114,7 @@ impl framework::Example for Render2D {
             },
         );
         let command_buffer = view_builder
-            .queue_draw(&RectangleDrawData::new(re_ctx, &rectangles).unwrap())
+            .queue_draw(RectangleDrawData::new(re_ctx, &rectangles).unwrap())
             .draw(re_ctx, ecolor::Rgba::TRANSPARENT)
             .unwrap();
 

crates/re_renderer/examples/multiview.rs

@@ -213,8 +213,8 @@ impl Multiview {
         &mut self,
         re_ctx: &mut RenderContext,
         target_cfg: TargetConfiguration,
-        skybox: &GenericSkyboxDrawData,
-        draw_data: &D,
+        skybox: GenericSkyboxDrawData,
+        draw_data: D,
         index: u32,
     ) -> (ViewBuilder, wgpu::CommandBuffer) {
         let mut view_builder = ViewBuilder::new(re_ctx, target_cfg);
@@ -372,8 +372,8 @@ impl Example for Multiview {
                         pixels_from_point,
                         ..Default::default()
                     },
-                    &skybox,
-                    &$name,
+                    skybox.clone(),
+                    $name,
                     $n,
                 );
                 framework::ViewDrawResult {

crates/re_renderer/examples/outlines.rs

@@ -118,9 +118,9 @@ impl framework::Example for Outlines {
             })
             .collect_vec();
 
-        view_builder.queue_draw(&re_renderer::renderer::GenericSkyboxDrawData::new(re_ctx));
+        view_builder.queue_draw(re_renderer::renderer::GenericSkyboxDrawData::new(re_ctx));
         view_builder
-            .queue_draw(&re_renderer::renderer::MeshDrawData::new(re_ctx, &instances).unwrap());
+            .queue_draw(re_renderer::renderer::MeshDrawData::new(re_ctx, &instances).unwrap());
 
         let command_buffer = view_builder
             .draw(re_ctx, ecolor::Rgba::TRANSPARENT)

crates/re_renderer/examples/picking.rs

@@ -167,7 +167,7 @@ impl framework::Example for Picking {
                     point_set.picking_ids.iter().cloned(),
                 );
         }
-        view_builder.queue_draw(&point_builder.to_draw_data(re_ctx).unwrap());
+        view_builder.queue_draw(point_builder.to_draw_data(re_ctx).unwrap());
 
         let instances = self
             .model_mesh_instances
@@ -186,11 +186,11 @@ impl framework::Example for Picking {
             })
             .collect_vec();
 
-        view_builder.queue_draw(&re_renderer::renderer::GenericSkyboxDrawData::new(re_ctx));
+        view_builder.queue_draw(re_renderer::renderer::GenericSkyboxDrawData::new(re_ctx));
         view_builder
-            .queue_draw(&re_renderer::renderer::MeshDrawData::new(re_ctx, &instances).unwrap());
+            .queue_draw(re_renderer::renderer::MeshDrawData::new(re_ctx, &instances).unwrap());
 
-        view_builder.queue_draw(&re_renderer::renderer::GenericSkyboxDrawData::new(re_ctx));
+        view_builder.queue_draw(re_renderer::renderer::GenericSkyboxDrawData::new(re_ctx));
 
         let command_buffer = view_builder
             .draw(re_ctx, ecolor::Rgba::TRANSPARENT)

crates/re_renderer/src/lib.rs

@@ -24,6 +24,7 @@ mod depth_offset;
 mod global_bindings;
 mod line_strip_builder;
 mod point_cloud_builder;
+mod queuable_draw_data;
 mod size;
 mod transform;
 mod wgpu_buffer_types;
@@ -42,6 +43,7 @@ pub use debug_label::DebugLabel;
 pub use depth_offset::DepthOffset;
 pub use line_strip_builder::{LineStripBuilder, LineStripSeriesBuilder};
 pub use point_cloud_builder::{PointCloudBatchBuilder, PointCloudBuilder};
+pub use queuable_draw_data::QueueableDrawData;
 pub use rect::{RectF32, RectInt};
 pub use size::Size;
 pub use transform::RectTransform;

crates/re_renderer/src/queuable_draw_data.rs

@@ -0,0 +1,44 @@
+use anyhow::Context;
+
+use crate::{
+    draw_phases::DrawPhase,
+    renderer::{DrawData, Renderer},
+    RenderContext,
+};
+
+type DrawFn = dyn for<'a, 'b> Fn(
+        &'b RenderContext,
+        DrawPhase,
+        &'a mut wgpu::RenderPass<'b>,
+        &'b dyn std::any::Any,
+    ) -> anyhow::Result<()>
+    + Sync
+    + Send;
+
+/// Type erased draw data that can be submitted directly to the view builder.
+pub struct QueueableDrawData {
+    pub(crate) draw_func: Box<DrawFn>,
+    pub(crate) draw_data: Box<dyn std::any::Any + std::marker::Send + std::marker::Sync>,
+    pub(crate) renderer_name: &'static str,
+    pub(crate) participated_phases: &'static [DrawPhase],
+}
+
+impl<D: DrawData + Sync + Send + 'static> From<D> for QueueableDrawData {
+    fn from(draw_data: D) -> Self {
+        QueueableDrawData {
+            draw_func: Box::new(move |ctx, phase, pass, draw_data| {
+                let renderers = ctx.renderers.read();
+                let renderer = renderers
+                    .get::<D::Renderer>()
+                    .context("failed to retrieve renderer")?;
+                let draw_data = draw_data
+                    .downcast_ref::<D>()
+                    .expect("passed wrong type of draw data");
+                renderer.draw(&ctx.gpu_resources, phase, pass, draw_data)
+            }),
+            draw_data: Box::new(draw_data),
+            renderer_name: std::any::type_name::<D::Renderer>(),
+            participated_phases: D::Renderer::participated_phases(),
+        }
+    }
+}

crates/re_renderer/src/renderer/mod.rs

@@ -46,7 +46,6 @@ use crate::{
 /// GPU sided data used by a [`Renderer`] to draw things to the screen.
 ///
 /// Valid only for the frame in which it was created (typically uses temp allocations!).
-/// TODO(andreas): Add a mechanism to validate this.
 pub trait DrawData {
     type Renderer: Renderer<RendererDrawData = Self> + Send + Sync;
 }

crates/re_renderer/src/view_builder.rs

@@ -10,28 +10,13 @@ use crate::{
         ScreenshotProcessor,
     },
     global_bindings::FrameUniformBuffer,
-    renderer::{CompositorDrawData, DebugOverlayDrawData, DrawData, Renderer},
+    queuable_draw_data::QueueableDrawData,
+    renderer::{CompositorDrawData, DebugOverlayDrawData},
     transform::RectTransform,
     wgpu_resources::{GpuBindGroup, GpuTexture, PoolError, TextureDesc},
     DebugLabel, RectInt, Rgba, Size,
 };
 
-type DrawFn = dyn for<'a, 'b> Fn(
-        &'b RenderContext,
-        DrawPhase,
-        &'a mut wgpu::RenderPass<'b>,
-        &'b dyn std::any::Any,
-    ) -> anyhow::Result<()>
-    + Sync
-    + Send;
-
-struct QueuedDraw {
-    draw_func: Box<DrawFn>,
-    draw_data: Box<dyn std::any::Any + std::marker::Send + std::marker::Sync>,
-    renderer_name: &'static str,
-    participated_phases: &'static [DrawPhase],
-}
-
 #[derive(thiserror::Error, Debug)]
 pub enum ViewBuilderError {
     #[error("Screenshot was already scheduled.")]
@@ -48,7 +33,7 @@ pub enum ViewBuilderError {
 /// Used to build up/collect various resources and then send them off for rendering of a single view.
 pub struct ViewBuilder {
     setup: ViewTargetSetup,
-    queued_draws: Vec<QueuedDraw>,
+    queued_draws: Vec<QueueableDrawData>,
 
     // TODO(andreas): Consider making "render processors" a "thing" by establishing a form of hardcoded/limited-flexibility render-graph
     outline_mask_processor: Option<OutlineMaskProcessor>,
@@ -480,14 +465,14 @@ impl ViewBuilder {
             )
         });
 
-        let composition_draw = queued_draw(&CompositorDrawData::new(
+        let composition_draw = CompositorDrawData::new(
             ctx,
             &main_target_resolved,
             outline_mask_processor
                 .as_ref()
                 .map(|p| p.final_voronoi_texture()),
             &config.outline_config,
-        ));
+        );
 
         let setup = ViewTargetSetup {
             name: config.name,
@@ -501,7 +486,7 @@ impl ViewBuilder {
 
         Self {
             setup,
-            queued_draws: vec![composition_draw],
+            queued_draws: vec![composition_draw.into()],
             outline_mask_processor,
             screenshot_processor: Default::default(),
             picking_processor: Default::default(),
@@ -528,13 +513,8 @@ impl ViewBuilder {
         }
     }
 
-    pub fn queue_draw<D: DrawData + Sync + Send + Clone + 'static>(
-        &mut self,
-        draw_data: &D,
-    ) -> &mut Self {
-        re_tracing::profile_function!();
-        self.queued_draws.push(queued_draw(draw_data));
-
+    pub fn queue_draw(&mut self, draw_data: impl Into<QueueableDrawData>) -> &mut Self {
+        self.queued_draws.push(draw_data.into());
         self
     }
 
@@ -745,7 +725,7 @@ impl ViewBuilder {
         );
 
         if show_debug_view {
-            self.queue_draw(&DebugOverlayDrawData::new(
+            self.queue_draw(DebugOverlayDrawData::new(
                 ctx,
                 &picking_processor.picking_target,
                 self.setup.resolution_in_pixel.into(),
@@ -783,21 +763,3 @@ impl ViewBuilder {
         self.draw_phase(ctx, DrawPhase::Compositing, pass);
     }
 }
-
-fn queued_draw<D: DrawData + Sync + Send + Clone + 'static>(draw_data: &D) -> QueuedDraw {
-    QueuedDraw {
-        draw_func: Box::new(move |ctx, phase, pass, draw_data| {
-            let renderers = ctx.renderers.read();
-            let renderer = renderers
-                .get::<D::Renderer>()
-                .context("failed to retrieve renderer")?;
-            let draw_data = draw_data
-                .downcast_ref::<D>()
-                .expect("passed wrong type of draw data");
-            renderer.draw(&ctx.gpu_resources, phase, pass, draw_data)
-        }),
-        draw_data: Box::new(draw_data.clone()),
-        renderer_name: std::any::type_name::<D::Renderer>(),
-        participated_phases: D::Renderer::participated_phases(),
-    }
-}

crates/re_space_view_spatial/src/ui_renderer_bridge.rs

@@ -20,17 +20,14 @@ pub fn fill_view_builder(
     re_tracing::profile_function!();
 
     view_builder
-        .queue_draw(&DepthCloudDrawData::new(
+        .queue_draw(DepthCloudDrawData::new(
             render_ctx,
             &primitives.depth_clouds,
         )?)
-        .queue_draw(&MeshDrawData::new(
-            render_ctx,
-            &primitives.mesh_instances(),
-        )?)
-        .queue_draw(&primitives.line_strips.to_draw_data(render_ctx)?)
-        .queue_draw(&primitives.points.to_draw_data(render_ctx)?)
-        .queue_draw(&RectangleDrawData::new(
+        .queue_draw(MeshDrawData::new(render_ctx, &primitives.mesh_instances())?)
+        .queue_draw(primitives.line_strips.to_draw_data(render_ctx)?)
+        .queue_draw(primitives.points.to_draw_data(render_ctx)?)
+        .queue_draw(RectangleDrawData::new(
             render_ctx,
             &primitives
                 .images
@@ -40,7 +37,7 @@ pub fn fill_view_builder(
         )?);
 
     if matches!(background, ScreenBackground::GenericSkybox) {
-        view_builder.queue_draw(&GenericSkyboxDrawData::new(render_ctx));
+        view_builder.queue_draw(GenericSkyboxDrawData::new(render_ctx));
     }
 
     let command_buffer = view_builder.draw(

crates/re_viewer_context/src/gpu_bridge/mod.rs

@@ -207,7 +207,7 @@ pub fn render_image(
 
     let mut view_builder = ViewBuilder::new(render_ctx, target_config);
 
-    view_builder.queue_draw(&re_renderer::renderer::RectangleDrawData::new(
+    view_builder.queue_draw(re_renderer::renderer::RectangleDrawData::new(
         render_ctx,
         &[textured_rectangle],
     )?);