Optimize big point clouds by ~20%

crates/re_arrow_store/src/store_read.rs

@@ -201,8 +201,6 @@ impl DataStore {
         primary: ComponentName,
         components: &[ComponentName; N],
     ) -> Option<(RowId, [Option<DataCell>; N])> {
-        re_tracing::profile_function!();
-
         // TODO(cmc): kind & query_id need to somehow propagate through the span system.
         self.query_id.fetch_add(1, Ordering::Relaxed);
 
@@ -461,8 +459,6 @@ impl IndexedTable {
         primary: ComponentName,
         components: &[ComponentName; N],
     ) -> Option<(RowId, [Option<DataCell>; N])> {
-        re_tracing::profile_function!();
-
         // Early-exit if this entire table is unaware of this component.
         if !self.all_components.contains(&primary) {
             return None;
@@ -669,8 +665,6 @@ impl IndexedBucket {
         primary: ComponentName,
         components: &[ComponentName; N],
     ) -> Option<(RowId, [Option<DataCell>; N])> {
-        re_tracing::profile_function!();
-
         self.sort_indices_if_needed();
 
         let IndexedBucketInner {

crates/re_query/src/archetype_view.rs

@@ -43,6 +43,7 @@ impl ComponentWithInstances {
     pub fn iter_instance_keys(
         &self,
     ) -> impl Iterator<Item = re_types::components::InstanceKey> + '_ {
+        re_tracing::profile_function!();
         self.instance_keys.to_native::<InstanceKey>()
     }
 
@@ -268,6 +269,7 @@ impl<A: Archetype> ArchetypeView<A> {
     /// Iterate over the [`InstanceKey`]s.
     #[inline]
     pub fn iter_instance_keys(&self) -> impl Iterator<Item = InstanceKey> + '_ {
+        re_tracing::profile_function!();
         // TODO(https://github.com/rerun-io/rerun/issues/2750): Maybe make this an intersection instead
         self.required_comp().iter_instance_keys()
     }
@@ -284,6 +286,7 @@ impl<A: Archetype> ArchetypeView<A> {
     pub fn iter_required_component<'a, C: Component + Default + 'a>(
         &'a self,
     ) -> DeserializationResult<impl Iterator<Item = C> + '_> {
+        re_tracing::profile_function!();
         debug_assert!(A::required_components()
             .iter()
             .any(|c| c.as_ref() == C::name()));
@@ -311,6 +314,7 @@ impl<A: Archetype> ArchetypeView<A> {
     pub fn iter_optional_component<'a, C: Component + Clone + 'a>(
         &'a self,
     ) -> DeserializationResult<impl Iterator<Item = Option<C>> + '_> {
+        re_tracing::profile_function!();
         let component = self.components.get(&C::name());
 
         if let Some(component) = component {

crates/re_renderer/examples/2d.rs

@@ -1,4 +1,6 @@
 use ecolor::Hsva;
+use itertools::Itertools as _;
+
 use re_renderer::{
     renderer::{
         ColormappedTexture, LineStripFlags, RectangleDrawData, RectangleOptions, TextureFilterMag,
@@ -169,23 +171,20 @@ impl framework::Example for Render2D {
         // The third point is automatic thickness which is determined by the point renderer implementation.
         let mut point_cloud_builder = PointCloudBuilder::new(re_ctx);
         point_cloud_builder.batch("points").add_points_2d(
-            4,
-            [
-                glam::vec2(500.0, 120.0),
-                glam::vec2(520.0, 120.0),
-                glam::vec2(540.0, 120.0),
-                glam::vec2(560.0, 120.0),
-            ]
-            .into_iter(),
-            [
+            &[
+                glam::vec3(500.0, 120.0, 0.0),
+                glam::vec3(520.0, 120.0, 0.0),
+                glam::vec3(540.0, 120.0, 0.0),
+                glam::vec3(560.0, 120.0, 0.0),
+            ],
+            &[
                 Size::new_scene(4.0),
                 Size::new_points(4.0),
                 Size::AUTO,
                 Size::AUTO_LARGE,
-            ]
-            .into_iter(),
-            std::iter::repeat(Color32::from_rgb(55, 180, 1)),
-            std::iter::repeat(re_renderer::PickingLayerInstanceId::default()),
+            ],
+            &[Color32::from_rgb(55, 180, 1); 4],
+            &[re_renderer::PickingLayerInstanceId::default(); 4],
         );
 
         // Pile stuff to test for overlap handling.
@@ -214,22 +213,29 @@ impl framework::Example for Render2D {
 
             let num_points = 8;
             let size = Size::new_points(3.0);
+
+            let positions = (0..num_points)
+                .map(|i| {
+                    glam::vec3(
+                        30.0 * i as f32 + 20.0,
+                        y_range.start
+                            + (y_range.end - y_range.start) / num_points as f32 * i as f32,
+                        0.0,
+                    )
+                })
+                .collect_vec();
+
+            let sizes = std::iter::repeat(size).collect_vec();
+
+            let colors = std::iter::repeat(Color32::WHITE).collect_vec();
+
+            let picking_ids =
+                std::iter::repeat(re_renderer::PickingLayerInstanceId::default()).collect_vec();
+
             point_cloud_builder
                 .batch("points overlapping with lines")
                 .depth_offset(5)
-                .add_points_2d(
-                    num_points,
-                    (0..num_points).map(|i| {
-                        glam::vec2(
-                            30.0 * i as f32 + 20.0,
-                            y_range.start
-                                + (y_range.end - y_range.start) / num_points as f32 * i as f32,
-                        )
-                    }),
-                    std::iter::repeat(size),
-                    std::iter::repeat(Color32::WHITE),
-                    std::iter::repeat(re_renderer::PickingLayerInstanceId::default()),
-                );
+                .add_points_2d(&positions, &sizes, &colors, &picking_ids);
         }
 
         let line_strip_draw_data = line_strip_builder.into_draw_data(re_ctx).unwrap();

crates/re_renderer/examples/depth_cloud.rs

@@ -80,7 +80,6 @@ impl RenderDepthClouds {
         let offset = glam::Vec2::new(intrinsics.z_axis.x, intrinsics.z_axis.y);
 
         let point_cloud_draw_data = {
-            let num_points = depth.dimensions.x * depth.dimensions.y;
             let (points, colors, radii): (Vec<_>, Vec<_>, Vec<_>) = (0..depth.dimensions.y)
                 .flat_map(|y| (0..depth.dimensions.x).map(move |x| glam::UVec2::new(x, y)))
                 .map(|texcoords| {
@@ -98,13 +97,9 @@ impl RenderDepthClouds {
                 .multiunzip();
 
             let mut builder = PointCloudBuilder::new(re_ctx);
-            builder.batch("backprojected point cloud").add_points(
-                num_points as _,
-                points.into_iter(),
-                radii.into_iter(),
-                colors.into_iter(),
-                std::iter::empty::<re_renderer::PickingLayerInstanceId>(),
-            );
+            builder
+                .batch("backprojected point cloud")
+                .add_points(&points, &radii, &colors, &[]);
 
             builder.into_draw_data(re_ctx).unwrap()
         };

crates/re_renderer/examples/multiview.rs

@@ -327,11 +327,10 @@ impl Example for Multiview {
             .batch("Random Points")
             .world_from_obj(glam::Affine3A::from_rotation_x(seconds_since_startup))
             .add_points(
-                self.random_points_positions.len(),
-                self.random_points_positions.iter().cloned(),
-                self.random_points_radii.iter().cloned(),
-                self.random_points_colors.iter().cloned(),
-                std::iter::empty::<re_renderer::PickingLayerInstanceId>(),
+                &self.random_points_positions,
+                &self.random_points_radii,
+                &self.random_points_colors,
+                &[],
             );
 
         let point_cloud = builder.into_draw_data(re_ctx).unwrap();

crates/re_renderer/examples/picking.rs

@@ -160,11 +160,10 @@ impl framework::Example for Picking {
                 .batch(format!("Random Points {i}"))
                 .picking_object_id(re_renderer::PickingLayerObjectId(i as u64 + 1)) // offset by one since 0=default=no hit
                 .add_points(
-                    point_set.positions.len(),
-                    point_set.positions.iter().cloned(),
-                    point_set.radii.iter().cloned(),
-                    point_set.colors.iter().cloned(),
-                    point_set.picking_ids.iter().cloned(),
+                    &point_set.positions,
+                    &point_set.radii,
+                    &point_set.colors,
+                    &point_set.picking_ids,
                 );
         }
         view_builder.queue_draw(point_builder.into_draw_data(re_ctx).unwrap());

crates/re_renderer/src/allocator/cpu_write_gpu_read_belt.rs

@@ -79,6 +79,7 @@ where
     /// If the buffer is not big enough, only the first `self.remaining_capacity()` elements are pushed before returning an error.
     #[inline]
     pub fn extend_from_slice(&mut self, elements: &[T]) -> Result<(), CpuWriteGpuReadError> {
+        re_tracing::profile_function!();
         let (result, elements) = if elements.len() > self.remaining_capacity() {
             (
                 Err(CpuWriteGpuReadError::BufferFull {
@@ -106,6 +107,7 @@ where
         &mut self,
         elements: impl Iterator<Item = T>,
     ) -> Result<usize, CpuWriteGpuReadError> {
+        re_tracing::profile_function!();
         let num_written_before = self.num_written();
 
         for element in elements {
@@ -127,6 +129,7 @@ where
     ///
     /// If the buffer is not big enough, only the first `self.remaining_capacity()` elements are pushed before returning an error.
     pub fn fill_n(&mut self, element: T, num_elements: usize) -> Result<(), CpuWriteGpuReadError> {
+        re_tracing::profile_function!();
         let (result, num_elements) = if num_elements > self.remaining_capacity() {
             (
                 Err(CpuWriteGpuReadError::BufferFull {

crates/re_renderer/src/allocator/uniform_buffer_fill.rs

@@ -47,6 +47,8 @@ pub fn create_and_fill_uniform_buffer_batch<T: bytemuck::Pod>(
     label: DebugLabel,
     content: impl ExactSizeIterator<Item = T>,
 ) -> Vec<BindGroupEntry> {
+    re_tracing::profile_function!(label.get().unwrap_or_default());
+
     #[allow(clippy::let_unit_value)]
     let _ = UniformBufferAlignmentCheck::<T>::CHECK;