re_renderer: Arrow buffers as (optional) first-class citizen (#1482)

* implement depth cloud renderer

* proper rp config

* self-review

* handle breaking changes from main

* upload depth textures through staging belt

* addressing PR comments part 1 of N

* work around wgpu d16 web issue

* addressing PR comments part 2 of N

* big refactoring of the whole quad spanning story

* accomodating breaking changes

* bring back coverage

* todos

* procedural example

* clean

* fix wasm cranky

* set up entity props & selection panel for backprojection

* integrate depth clouds into rerun

* last merge conflicts

* huh, nasty

* everything working as i want

* cleanin up

* self review

* arrow as a first-class citizen

* compute auto heuristics properly

* gentle radius scale

* explicitly enable arrow for re_viewer

crates/re_renderer/Cargo.toml

@@ -24,7 +24,10 @@ targets = ["x86_64-unknown-linux-gnu", "wasm32-unknown-unknown"]
 
 
 [features]
-default = ["import-obj", "import-gltf"]
+default = ["arrow", "import-obj", "import-gltf"]
+
+## Support for Arrow datatypes for end-to-end zero-copy.
+arrow = ["dep:arrow2"]
 
 ## Support importing .obj files
 import-obj = ["dep:tobj"]
@@ -61,6 +64,7 @@ thiserror.workspace = true
 type-map = "0.5"
 
 # optional
+arrow2 = { workspace = true, optional = true }
 gltf = { workspace = true, optional = true }
 serde = { version = "1", features = ["derive"], optional = true }
 tobj = { version = "3.2", optional = true }

crates/re_renderer/examples/depth_cloud.rs

@@ -440,7 +440,7 @@ impl DepthTexture {
         spiral(dimensions).for_each(|(texcoords, d)| {
             data[(texcoords.x + texcoords.y * dimensions.x) as usize] = d;
         });
-        let data = DepthCloudDepthData::F32(data);
+        let data = DepthCloudDepthData::F32(data.into());
 
         Self { dimensions, data }
     }

crates/re_renderer/src/lib.rs

@@ -60,6 +60,16 @@ pub use ecolor::{Color32, Rgba};
 
 // ---------------------------------------------------------------------------
 
+// Make Arrow integration as transparent as possible.
+
+#[cfg(feature = "arrow")]
+pub type Buffer<T> = arrow2::buffer::Buffer<T>;
+
+#[cfg(not(feature = "arrow"))]
+pub type Buffer<T> = Vec<T>;
+
+// ---------------------------------------------------------------------------
+
 /// Profiling macro for puffin
 #[doc(hidden)]
 #[macro_export]

crates/re_renderer/src/renderer/depth_cloud.rs

@@ -60,8 +60,14 @@ mod gpu_data {
 // TODO(cmc): expose knobs to linearize/normalize/flip/cam-to-plane depth.
 #[derive(Debug, Clone)]
 pub enum DepthCloudDepthData {
-    U16(Vec<u16>),
-    F32(Vec<f32>),
+    U16(crate::Buffer<u16>),
+    F32(crate::Buffer<f32>),
+}
+
+impl Default for DepthCloudDepthData {
+    fn default() -> Self {
+        Self::F32(Default::default())
+    }
 }
 
 pub struct DepthCloud {
@@ -92,7 +98,7 @@ impl Default for DepthCloud {
             depth_camera_intrinsics: glam::Mat3::IDENTITY,
             radius_scale: 1.0,
             depth_dimensions: glam::UVec2::ZERO,
-            depth_data: DepthCloudDepthData::F32(Vec::new()),
+            depth_data: DepthCloudDepthData::default(),
         }
     }
 }

crates/re_viewer/Cargo.toml

@@ -50,7 +50,7 @@ re_log_types = { workspace = true, features = [
 ] }
 re_memory.workspace = true
 re_query.workspace = true
-re_renderer = { workspace = true, features = ["serde"] }
+re_renderer = { workspace = true, features = ["arrow", "serde"] }
 re_smart_channel.workspace = true
 re_string_interner.workspace = true
 re_tensor_ops.workspace = true

crates/re_viewer/src/ui/view_spatial/scene/scene_part/images.rs

@@ -287,11 +287,9 @@ impl ImagesPart {
 
         // TODO(cmc): automagically convert as needed for non-natively supported datatypes?
         let data = match &tensor.data {
-            // TODO(cmc): re_renderer needs native interop with Arrow, we shouldn't need to
-            // allocate this massive buffer and do a memcpy when we could just carry arround the
-            // original `arrow::Buffer`.
-            TensorData::U16(data) => DepthCloudDepthData::U16(data.to_vec()),
-            TensorData::F32(data) => DepthCloudDepthData::F32(data.to_vec()),
+            // NOTE: Shallow clone if feature `arrow` is enabled, full alloc + memcpy otherwise.
+            TensorData::U16(data) => DepthCloudDepthData::U16(data.clone()),
+            TensorData::F32(data) => DepthCloudDepthData::F32(data.clone()),
             _ => {
                 let discriminant = std::mem::discriminant(&tensor.data);
                 re_log::warn_once!(