From 53ff95973725faa8e597ac002b6cfd6fbd349afa Mon Sep 17 00:00:00 2001
From: Clement Rey <cr.rey.clement@gmail.com>
Date: Tue, 8 Nov 2022 15:01:00 +0100
Subject: [PATCH] independent scenes and retiring `Objects` (#270)

* preparing the field

* some more setup and decoupling text-entry UI from Objects

* decoupling tensor UI from Objects and fusing old & new

* decoupling 3D scenes from Objects

* moving view_text_entry over to new logical organization

* moving view_tensor over to new logical organization

* view2d: no more wildcard imports

* decoupling 2D scenes from Objects (part 1)

* TextEntry are now Objects-free end to end

* dont need em sticky objects no more

* Tensors are now Objects-free end to end

* Point3Ds are now Objects-free end to end

* InstanceHash::from_props => InstanceHash::from_path_and_index

* abstracting away object store retrieval

* random cleanups

* Box3Ds are now Objects-free end to end

* cleaning up the DataVec::as_vec situation

* Path3Ds are now Objects-free end to end + a lot segments cleanup

* LineSegments3D are now Objects-free end to end + related improvements

* Mesh3Ds are now Objects-free end to end + related improvements

* Arrow3Ds are now Objects-free end to end + related improvements

* keeping em warnings under control

* Tensor & TextEntry moving towards independent scenes

* start independentizing view_3d too

* tensor mapping UI now lives with the rest of its kind

* cleaning up view_3d's module situation

* Images are now Objects-free end to end

* BBox2Ds are now Objects-free end to end

* Point2Ds are now Objects-free end to end

* Legends/ClassDescr are now Objects-free, and Objects is gone for good

* plugging back legends into images

* bringing back data store benchmarks

* independent view_2d

* some more clean up

* bringing the tooltip back

* no need for this i guess

* scene cleanup and doc

* TODO hunting, cleanup....

* 2d: naming and making loading phase more digestible

* 2d: cleanup and document frame delay for hovering

* more fixes and TODO hunting

* 3d: naming and making loading phase more digestible

* tensor: naming and making loading phase more digestible

* text: naming and making loading phase more digestible

* bring back bench assertion

* last cleanup

* more profiling

* addressing PR comments
---
 Cargo.lock                                    |   1 +
 .../benches/obj_query_benchmark.rs            |  45 +-
 crates/re_data_store/src/instance.rs          |  21 +-
 crates/re_data_store/src/lib.rs               |   2 -
 crates/re_data_store/src/objects.rs           | 854 ------------------
 crates/re_log_types/Cargo.toml                |   1 +
 crates/re_log_types/src/data.rs               |  24 +
 crates/re_viewer/src/app.rs                   |   2 +-
 crates/re_viewer/src/misc/mod.rs              |  43 +-
 .../re_viewer/src/misc/tensor_image_cache.rs  |  19 +-
 crates/re_viewer/src/misc/viewer_context.rs   |  28 +-
 crates/re_viewer/src/ui/data_ui.rs            |   7 +-
 crates/re_viewer/src/ui/mod.rs                |  26 +-
 crates/re_viewer/src/ui/scene.rs              |  64 ++
 crates/re_viewer/src/ui/selection_panel.rs    |   2 +-
 crates/re_viewer/src/ui/space_view.rs         | 133 ++-
 crates/re_viewer/src/ui/text_entry_view.rs    | 249 -----
 .../ui/{ => view_2d}/class_description_ui.rs  |   0
 .../src/ui/{ => view_2d}/image_ui.rs          |   7 +-
 .../re_viewer/src/ui/{ => view_2d}/legend.rs  |  72 +-
 crates/re_viewer/src/ui/view_2d/mod.rs        |  16 +
 crates/re_viewer/src/ui/view_2d/scene.rs      | 503 +++++++++++
 .../src/ui/{view2d.rs => view_2d/ui.rs}       | 222 ++---
 .../src/ui/{view3d => view_3d}/eye.rs         |   8 +-
 .../{view3d => view_3d}/glow_rendering/mod.rs |  27 +-
 .../glow_rendering/sphere_renderer.rs         |   0
 .../src/ui/{view3d => view_3d}/mesh_cache.rs  |   0
 crates/re_viewer/src/ui/view_3d/mod.rs        |  19 +
 .../src/ui/{view3d => view_3d}/scene.rs       | 626 ++++++++-----
 .../ui/{view3d => view_3d}/space_camera.rs    |   0
 .../src/ui/{view3d/mod.rs => view_3d/ui.rs}   | 118 ++-
 crates/re_viewer/src/ui/view_tensor/mod.rs    |   8 +
 crates/re_viewer/src/ui/view_tensor/scene.rs  |  85 ++
 .../tensor_dimension_mapper.rs                |   0
 .../ui/{view_tensor.rs => view_tensor/ui.rs}  | 196 ++--
 crates/re_viewer/src/ui/view_text/mod.rs      |   5 +
 crates/re_viewer/src/ui/view_text/scene.rs    |  97 ++
 crates/re_viewer/src/ui/view_text/ui.rs       | 198 ++++
 crates/re_viewer/src/ui/viewport.rs           | 117 +--
 scripts/build_web.sh                          |   2 +-
 40 files changed, 1880 insertions(+), 1967 deletions(-)
 delete mode 100644 crates/re_data_store/src/objects.rs
 create mode 100644 crates/re_viewer/src/ui/scene.rs
 delete mode 100644 crates/re_viewer/src/ui/text_entry_view.rs
 rename crates/re_viewer/src/ui/{ => view_2d}/class_description_ui.rs (100%)
 rename crates/re_viewer/src/ui/{ => view_2d}/image_ui.rs (99%)
 rename crates/re_viewer/src/ui/{ => view_2d}/legend.rs (51%)
 create mode 100644 crates/re_viewer/src/ui/view_2d/mod.rs
 create mode 100644 crates/re_viewer/src/ui/view_2d/scene.rs
 rename crates/re_viewer/src/ui/{view2d.rs => view_2d/ui.rs} (79%)
 rename crates/re_viewer/src/ui/{view3d => view_3d}/eye.rs (98%)
 rename crates/re_viewer/src/ui/{view3d => view_3d}/glow_rendering/mod.rs (95%)
 rename crates/re_viewer/src/ui/{view3d => view_3d}/glow_rendering/sphere_renderer.rs (100%)
 rename crates/re_viewer/src/ui/{view3d => view_3d}/mesh_cache.rs (100%)
 create mode 100644 crates/re_viewer/src/ui/view_3d/mod.rs
 rename crates/re_viewer/src/ui/{view3d => view_3d}/scene.rs (56%)
 rename crates/re_viewer/src/ui/{view3d => view_3d}/space_camera.rs (100%)
 rename crates/re_viewer/src/ui/{view3d/mod.rs => view_3d/ui.rs} (91%)
 create mode 100644 crates/re_viewer/src/ui/view_tensor/mod.rs
 create mode 100644 crates/re_viewer/src/ui/view_tensor/scene.rs
 rename crates/re_viewer/src/ui/{ => view_tensor}/tensor_dimension_mapper.rs (100%)
 rename crates/re_viewer/src/ui/{view_tensor.rs => view_tensor/ui.rs} (96%)
 create mode 100644 crates/re_viewer/src/ui/view_text/mod.rs
 create mode 100644 crates/re_viewer/src/ui/view_text/scene.rs
 create mode 100644 crates/re_viewer/src/ui/view_text/ui.rs

diff --git a/Cargo.lock b/Cargo.lock
index 4d5911b05b19..64574f803e93 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3063,6 +3063,7 @@ dependencies = [
  "macaw",
  "nohash-hasher",
  "puffin",
+ "re_log",
  "re_string_interner",
  "rmp-serde",
  "ruzstd",
diff --git a/crates/re_data_store/benches/obj_query_benchmark.rs b/crates/re_data_store/benches/obj_query_benchmark.rs
index 3191e2e5eca8..fd2d71cc1506 100644
--- a/crates/re_data_store/benches/obj_query_benchmark.rs
+++ b/crates/re_data_store/benches/obj_query_benchmark.rs
@@ -5,7 +5,7 @@ use criterion::{criterion_group, criterion_main, Criterion};
 
 use itertools::Itertools;
 use nohash_hasher::IntMap;
-use re_data_store::*;
+use re_data_store::{query::visit_type_data_3, *};
 use re_log_types::*;
 
 #[cfg(not(debug_assertions))]
@@ -23,16 +23,43 @@ fn timeline() -> Timeline {
     Timeline::new("frame", TimeType::Sequence)
 }
 
-fn do_query<'s>(
-    obj_types: &IntMap<ObjTypePath, ObjectType>,
-    data_store: &'s DataStore,
-) -> Objects<'s> {
+#[allow(dead_code)]
+#[derive(Clone, Copy)]
+struct Point {
+    pos: [f32; 3],
+    color: Option<[u8; 4]>,
+}
+
+fn do_query(obj_types: &IntMap<ObjTypePath, ObjectType>, data_store: &DataStore) -> Vec<Point> {
     let time_query = TimeQuery::LatestAt(NUM_FRAMES / 2);
-    let mut objects = Objects::default();
     let timeline_store = data_store.get(&timeline()).unwrap();
-    objects.query(timeline_store, &time_query, obj_types);
-    assert_eq!(objects.point3d.len(), NUM_POINTS as usize);
-    objects
+
+    let mut points = Vec::new();
+
+    for (obj_path, obj_store) in timeline_store.iter() {
+        let _ = obj_types.get(obj_path.obj_type_path()).unwrap();
+        visit_type_data_3(
+            obj_store,
+            &FieldName::from("pos"),
+            &time_query,
+            ("_visible", "color", "radius"),
+            |_instance_index: Option<&IndexHash>,
+             _time: i64,
+             _msg_id: &MsgId,
+             pos: &[f32; 3],
+             _visible: Option<&bool>,
+             color: Option<&[u8; 4]>,
+             _radius: Option<&f32>| {
+                points.push(Point {
+                    pos: *pos,
+                    color: color.cloned(),
+                });
+            },
+        );
+    }
+
+    assert_eq!(points.len(), NUM_POINTS as usize);
+    points
 }
 
 fn mono_data_messages() -> Vec<DataMsg> {
diff --git a/crates/re_data_store/src/instance.rs b/crates/re_data_store/src/instance.rs
index d44277682c8f..d77512a8e957 100644
--- a/crates/re_data_store/src/instance.rs
+++ b/crates/re_data_store/src/instance.rs
@@ -2,7 +2,7 @@ use std::hash::Hash;
 
 use re_log_types::{Index, IndexHash, ObjPath, ObjPathHash};
 
-use crate::{DataStore, InstanceProps};
+use crate::DataStore;
 
 // ----------------------------------------------------------------------------
 
@@ -27,12 +27,12 @@ impl InstanceId {
 
     /// Does this object match this instance id?
     #[inline]
-    pub fn is_instance(&self, props: &InstanceProps<'_>) -> bool {
-        &self.obj_path == props.obj_path
+    pub fn is_instance(&self, obj_path: &ObjPath, instance_index: IndexHash) -> bool {
+        &self.obj_path == obj_path
             && if let Some(index) = &self.instance_index {
-                index.hash() == props.instance_index
+                index.hash() == instance_index
             } else {
-                props.instance_index.is_none()
+                instance_index.is_none()
             }
     }
 
@@ -72,10 +72,10 @@ impl InstanceIdHash {
     };
 
     #[inline]
-    pub fn from_props(props: &InstanceProps<'_>) -> Self {
+    pub fn from_path_and_index(obj_path: &ObjPath, instance_index: IndexHash) -> Self {
         Self {
-            obj_path_hash: *props.obj_path.hash(),
-            instance_index_hash: props.instance_index,
+            obj_path_hash: *obj_path.hash(),
+            instance_index_hash: instance_index,
         }
     }
 
@@ -93,8 +93,7 @@ impl InstanceIdHash {
 
     /// Does this object match this instance id?
     #[inline]
-    pub fn is_instance(&self, props: &InstanceProps<'_>) -> bool {
-        &self.obj_path_hash == props.obj_path.hash()
-            && self.instance_index_hash == props.instance_index
+    pub fn is_instance(&self, obj_path: &ObjPath, instance_index: IndexHash) -> bool {
+        &self.obj_path_hash == obj_path.hash() && self.instance_index_hash == instance_index
     }
 }
diff --git a/crates/re_data_store/src/lib.rs b/crates/re_data_store/src/lib.rs
index 895d2f3be0f5..d0c440389dfe 100644
--- a/crates/re_data_store/src/lib.rs
+++ b/crates/re_data_store/src/lib.rs
@@ -23,7 +23,6 @@ mod instance;
 pub mod log_db;
 pub mod object_tree;
 pub mod object_tree_properties;
-pub mod objects;
 pub mod query;
 mod stores;
 
@@ -32,7 +31,6 @@ pub use instance::*;
 pub use log_db::LogDb;
 pub use object_tree::*;
 pub use object_tree_properties::*;
-pub use objects::*;
 pub use stores::*;
 
 use re_log_types::DataType;
diff --git a/crates/re_data_store/src/objects.rs b/crates/re_data_store/src/objects.rs
deleted file mode 100644
index ed00c944d056..000000000000
--- a/crates/re_data_store/src/objects.rs
+++ /dev/null
@@ -1,854 +0,0 @@
-use std::collections::BTreeMap;
-
-use ahash::HashMap;
-use nohash_hasher::IntMap;
-use re_log_types::{objects::*, DataVec, FieldName, IndexHash, MsgId, ObjPath, ObjTypePath};
-
-use crate::{query::*, ObjStore, TimeQuery, TimelineStore};
-
-/// Common properties of an object instance.
-#[derive(Copy, Clone, Debug)]
-pub struct InstanceProps<'s> {
-    // NOTE: While we would normally make InstanceProps generic over time
-    // (`InstanceProps<'s, Time`>), doing so leads to a gigantic template-leak that
-    // propagates all over the codebase.
-    // So for now we will constrain ourselves to an i64 here, which is the only unit
-    // of time we currently use in practice anyway.
-    pub time: i64,
-    pub msg_id: &'s MsgId,
-    pub color: Option<[u8; 4]>,
-
-    /// Use this to test if the object should be visible, etc.
-    pub obj_path: &'s ObjPath,
-
-    /// If it is a multi-object, this is the instance index,
-    /// else it is [`IndexHash::NONE`].
-    pub instance_index: IndexHash,
-
-    /// Whether or not the object is visible
-    pub visible: bool,
-}
-
-#[derive(Copy, Clone, Debug)]
-struct Object<'s, T: Copy + Clone + std::fmt::Debug> {
-    pub props: InstanceProps<'s>,
-    pub data: T,
-}
-
-#[derive(Clone, Debug)]
-pub struct ObjectVec<'s, T: Copy + Clone + std::fmt::Debug>(Vec<Object<'s, T>>);
-
-impl<'s, T: Clone + Copy + std::fmt::Debug> Default for ObjectVec<'s, T> {
-    fn default() -> Self {
-        Self(Default::default())
-    }
-}
-
-impl<'s, T: Clone + Copy + std::fmt::Debug> ObjectVec<'s, T> {
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-
-    pub fn iter(&self) -> impl ExactSizeIterator<Item = (&InstanceProps<'s>, &T)> {
-        self.0.iter().map(|obj| (&obj.props, &obj.data))
-    }
-
-    pub fn first(&self) -> Option<(&InstanceProps<'s>, &T)> {
-        self.0.first().map(|obj| (&obj.props, &obj.data))
-    }
-
-    pub fn last(&self) -> Option<(&InstanceProps<'s>, &T)> {
-        self.0.last().map(|obj| (&obj.props, &obj.data))
-    }
-
-    pub fn get(&self, idx: usize) -> Option<(&InstanceProps<'s>, &T)> {
-        self.0.get(idx).map(|obj| (&obj.props, &obj.data))
-    }
-
-    pub fn filter(&self, keep: &impl Fn(&InstanceProps<'_>) -> bool) -> Self {
-        crate::profile_function!();
-        Self(
-            self.0
-                .iter()
-                .filter(|obj| keep(&obj.props))
-                .copied()
-                .collect(),
-        )
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct Image<'s> {
-    pub tensor: &'s re_log_types::Tensor,
-
-    /// If this is a depth map, how long is a meter?
-    ///
-    /// For instance, with a `u16` dtype one might have
-    /// `meter == 1000.0` for millimeter precision
-    /// up to a ~65m range.
-    pub meter: Option<f32>,
-
-    /// A thing that provides additional semantic context for your dtype
-    /// Currrently must point to a SegmentationMap
-    pub legend: Option<&'s ObjPath>,
-}
-
-impl<'s> Image<'s> {
-    fn query<Time: 'static + Copy + Ord + Into<i64>>(
-        obj_path: &'s ObjPath,
-        obj_store: &'s ObjStore<Time>,
-        time_query: &TimeQuery<Time>,
-        out: &mut Objects<'s>,
-    ) {
-        crate::profile_function!();
-
-        visit_type_data_4(
-            obj_store,
-            &FieldName::from("tensor"),
-            time_query,
-            ("_visible", "color", "meter", "legend"),
-            |instance_index: Option<&IndexHash>,
-             time: Time,
-             msg_id: &MsgId,
-             tensor: &re_log_types::Tensor,
-             visible: Option<&bool>,
-             color: Option<&[u8; 4]>,
-             meter: Option<&f32>,
-             legend: Option<&ObjPath>| {
-                out.image.0.push(Object {
-                    props: InstanceProps {
-                        time: time.into(),
-                        msg_id,
-                        color: color.copied(),
-                        obj_path,
-                        instance_index: instance_index.copied().unwrap_or(IndexHash::NONE),
-                        visible: *visible.unwrap_or(&true),
-                    },
-                    data: Image {
-                        tensor,
-                        meter: meter.copied(),
-                        legend,
-                    },
-                });
-            },
-        );
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct Point2D<'s> {
-    pub pos: &'s [f32; 2],
-    pub radius: Option<f32>,
-}
-
-impl<'s> Point2D<'s> {
-    fn query<Time: 'static + Copy + Ord + Into<i64>>(
-        obj_path: &'s ObjPath,
-        obj_store: &'s ObjStore<Time>,
-        time_query: &TimeQuery<Time>,
-        out: &mut Objects<'s>,
-    ) {
-        crate::profile_function!();
-
-        visit_type_data_3(
-            obj_store,
-            &FieldName::from("pos"),
-            time_query,
-            ("_visible", "color", "radius"),
-            |instance_index: Option<&IndexHash>,
-             time: Time,
-             msg_id: &MsgId,
-             pos: &[f32; 2],
-             visible: Option<&bool>,
-             color: Option<&[u8; 4]>,
-             radius: Option<&f32>| {
-                out.point2d.0.push(Object {
-                    props: InstanceProps {
-                        time: time.into(),
-                        msg_id,
-                        color: color.copied(),
-                        obj_path,
-                        instance_index: instance_index.copied().unwrap_or(IndexHash::NONE),
-                        visible: *visible.unwrap_or(&true),
-                    },
-                    data: Point2D {
-                        pos,
-                        radius: radius.copied(),
-                    },
-                });
-            },
-        );
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct Point3D<'s> {
-    pub pos: &'s [f32; 3],
-    pub radius: Option<f32>,
-}
-
-impl<'s> Point3D<'s> {
-    fn query<Time: 'static + Copy + Ord + Into<i64>>(
-        obj_path: &'s ObjPath,
-        obj_store: &'s ObjStore<Time>,
-        time_query: &TimeQuery<Time>,
-        out: &mut Objects<'s>,
-    ) {
-        crate::profile_function!();
-
-        visit_type_data_3(
-            obj_store,
-            &FieldName::from("pos"),
-            time_query,
-            ("_visible", "color", "radius"),
-            |instance_index: Option<&IndexHash>,
-             time: Time,
-             msg_id: &MsgId,
-             pos: &[f32; 3],
-             visible: Option<&bool>,
-             color: Option<&[u8; 4]>,
-             radius: Option<&f32>| {
-                out.point3d.0.push(Object {
-                    props: InstanceProps {
-                        time: time.into(),
-                        msg_id,
-                        color: color.copied(),
-                        obj_path,
-                        instance_index: instance_index.copied().unwrap_or(IndexHash::NONE),
-                        visible: *visible.unwrap_or(&true),
-                    },
-                    data: Point3D {
-                        pos,
-                        radius: radius.copied(),
-                    },
-                });
-            },
-        );
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct BBox2D<'s> {
-    pub bbox: &'s re_log_types::BBox2D,
-    pub stroke_width: Option<f32>,
-    pub label: Option<&'s str>,
-}
-
-impl<'s> BBox2D<'s> {
-    fn query<Time: 'static + Copy + Ord + Into<i64>>(
-        obj_path: &'s ObjPath,
-        obj_store: &'s ObjStore<Time>,
-        time_query: &TimeQuery<Time>,
-        out: &mut Objects<'s>,
-    ) {
-        crate::profile_function!();
-
-        visit_type_data_4(
-            obj_store,
-            &FieldName::from("bbox"),
-            time_query,
-            ("_visible", "color", "stroke_width", "label"),
-            |instance_index: Option<&IndexHash>,
-             time: Time,
-             msg_id: &MsgId,
-             bbox: &re_log_types::BBox2D,
-             visible: Option<&bool>,
-             color: Option<&[u8; 4]>,
-             stroke_width: Option<&f32>,
-             label: Option<&String>| {
-                out.bbox2d.0.push(Object {
-                    props: InstanceProps {
-                        time: time.into(),
-                        msg_id,
-                        color: color.copied(),
-                        obj_path,
-                        instance_index: instance_index.copied().unwrap_or(IndexHash::NONE),
-                        visible: *visible.unwrap_or(&true),
-                    },
-                    data: BBox2D {
-                        bbox,
-                        stroke_width: stroke_width.copied(),
-                        label: label.map(|s| s.as_str()),
-                    },
-                });
-            },
-        );
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct Box3D<'s> {
-    pub obb: &'s re_log_types::Box3,
-    pub stroke_width: Option<f32>,
-    pub label: Option<&'s str>,
-}
-
-impl<'s> Box3D<'s> {
-    fn query<Time: 'static + Copy + Ord + Into<i64>>(
-        obj_path: &'s ObjPath,
-        obj_store: &'s ObjStore<Time>,
-        time_query: &TimeQuery<Time>,
-        out: &mut Objects<'s>,
-    ) {
-        crate::profile_function!();
-
-        visit_type_data_4(
-            obj_store,
-            &FieldName::from("obb"),
-            time_query,
-            ("_visible", "color", "stroke_width", "label"),
-            |instance_index: Option<&IndexHash>,
-             time: Time,
-             msg_id: &MsgId,
-             obb: &re_log_types::Box3,
-             visible: Option<&bool>,
-             color: Option<&[u8; 4]>,
-             stroke_width: Option<&f32>,
-             label: Option<&String>| {
-                out.box3d.0.push(Object {
-                    props: InstanceProps {
-                        time: time.into(),
-                        msg_id,
-                        color: color.copied(),
-                        obj_path,
-                        instance_index: instance_index.copied().unwrap_or(IndexHash::NONE),
-                        visible: *visible.unwrap_or(&true),
-                    },
-                    data: Box3D {
-                        obb,
-                        stroke_width: stroke_width.copied(),
-                        label: label.map(|s| s.as_str()),
-                    },
-                });
-            },
-        );
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct Path3D<'s> {
-    pub points: &'s Vec<[f32; 3]>,
-    pub stroke_width: Option<f32>,
-}
-
-impl<'s> Path3D<'s> {
-    fn query<Time: 'static + Copy + Ord + Into<i64>>(
-        obj_path: &'s ObjPath,
-        obj_store: &'s ObjStore<Time>,
-        time_query: &TimeQuery<Time>,
-        out: &mut Objects<'s>,
-    ) {
-        crate::profile_function!();
-
-        visit_type_data_3(
-            obj_store,
-            &FieldName::from("points"),
-            time_query,
-            ("_visible", "color", "stroke_width"),
-            |instance_index: Option<&IndexHash>,
-             time: Time,
-             msg_id: &MsgId,
-             points: &DataVec,
-             visible: Option<&bool>,
-             color: Option<&[u8; 4]>,
-             stroke_width: Option<&f32>| {
-                if let Some(points) = as_vec_of_vec3("Path3D::points", points) {
-                    out.path3d.0.push(Object {
-                        props: InstanceProps {
-                            time: time.into(),
-                            msg_id,
-                            color: color.copied(),
-                            obj_path,
-                            instance_index: instance_index.copied().unwrap_or(IndexHash::NONE),
-                            visible: *visible.unwrap_or(&true),
-                        },
-                        data: Path3D {
-                            points,
-                            stroke_width: stroke_width.copied(),
-                        },
-                    });
-                }
-            },
-        );
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct LineSegments2D<'s> {
-    /// Connected pair-wise even-odd.
-    pub points: &'s Vec<[f32; 2]>,
-    pub stroke_width: Option<f32>,
-}
-
-impl<'s> LineSegments2D<'s> {
-    fn query<Time: 'static + Copy + Ord + Into<i64>>(
-        obj_path: &'s ObjPath,
-        obj_store: &'s ObjStore<Time>,
-        time_query: &TimeQuery<Time>,
-        out: &mut Objects<'s>,
-    ) {
-        crate::profile_function!();
-
-        visit_type_data_3(
-            obj_store,
-            &FieldName::from("points"),
-            time_query,
-            ("_visible", "color", "stroke_width"),
-            |instance_index: Option<&IndexHash>,
-             time: Time,
-             msg_id: &MsgId,
-             points: &DataVec,
-             visible: Option<&bool>,
-             color: Option<&[u8; 4]>,
-             stroke_width: Option<&f32>| {
-                if let Some(points) = as_vec_of_vec2("LineSegments2D::points", points) {
-                    out.line_segments2d.0.push(Object {
-                        props: InstanceProps {
-                            time: time.into(),
-                            msg_id,
-                            color: color.copied(),
-                            obj_path,
-                            instance_index: instance_index.copied().unwrap_or(IndexHash::NONE),
-                            visible: *visible.unwrap_or(&true),
-                        },
-                        data: LineSegments2D {
-                            points,
-                            stroke_width: stroke_width.copied(),
-                        },
-                    });
-                }
-            },
-        );
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct LineSegments3D<'s> {
-    /// Connected pair-wise even-odd.
-    pub points: &'s Vec<[f32; 3]>,
-    pub stroke_width: Option<f32>,
-}
-
-impl<'s> LineSegments3D<'s> {
-    fn query<Time: 'static + Copy + Ord + Into<i64>>(
-        obj_path: &'s ObjPath,
-        obj_store: &'s ObjStore<Time>,
-        time_query: &TimeQuery<Time>,
-        out: &mut Objects<'s>,
-    ) {
-        crate::profile_function!();
-
-        visit_type_data_3(
-            obj_store,
-            &FieldName::from("points"),
-            time_query,
-            ("_visible", "color", "stroke_width"),
-            |instance_index: Option<&IndexHash>,
-             time: Time,
-             msg_id: &MsgId,
-             points: &DataVec,
-             visible: Option<&bool>,
-             color: Option<&[u8; 4]>,
-             stroke_width: Option<&f32>| {
-                if let Some(points) = as_vec_of_vec3("LineSegments3D::points", points) {
-                    out.line_segments3d.0.push(Object {
-                        props: InstanceProps {
-                            time: time.into(),
-                            msg_id,
-                            color: color.copied(),
-                            obj_path,
-                            instance_index: instance_index.copied().unwrap_or(IndexHash::NONE),
-                            visible: *visible.unwrap_or(&true),
-                        },
-                        data: LineSegments3D {
-                            points,
-                            stroke_width: stroke_width.copied(),
-                        },
-                    });
-                }
-            },
-        );
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct Mesh3D<'s> {
-    pub mesh: &'s re_log_types::Mesh3D,
-}
-
-impl<'s> Mesh3D<'s> {
-    fn query<Time: 'static + Copy + Ord + Into<i64>>(
-        obj_path: &'s ObjPath,
-        obj_store: &'s ObjStore<Time>,
-        time_query: &TimeQuery<Time>,
-        out: &mut Objects<'s>,
-    ) {
-        crate::profile_function!();
-
-        visit_type_data_2(
-            obj_store,
-            &FieldName::from("mesh"),
-            time_query,
-            ("_visible", "color"),
-            |instance_index: Option<&IndexHash>,
-             time: Time,
-             msg_id: &MsgId,
-             mesh: &re_log_types::Mesh3D,
-             visible: Option<&bool>,
-             color: Option<&[u8; 4]>| {
-                out.mesh3d.0.push(Object {
-                    props: InstanceProps {
-                        time: time.into(),
-                        msg_id,
-                        color: color.copied(),
-                        obj_path,
-                        instance_index: instance_index.copied().unwrap_or(IndexHash::NONE),
-                        visible: *visible.unwrap_or(&true),
-                    },
-                    data: Mesh3D { mesh },
-                });
-            },
-        );
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct Arrow3D<'s> {
-    pub arrow: &'s re_log_types::Arrow3D,
-    pub label: Option<&'s str>,
-    pub width_scale: Option<f32>,
-}
-
-impl<'s> Arrow3D<'s> {
-    fn query<Time: 'static + Copy + Ord + Into<i64>>(
-        obj_path: &'s ObjPath,
-        obj_store: &'s ObjStore<Time>,
-        time_query: &TimeQuery<Time>,
-        out: &mut Objects<'s>,
-    ) {
-        crate::profile_function!();
-
-        visit_type_data_4(
-            obj_store,
-            &FieldName::from("arrow3d"),
-            time_query,
-            ("_visible", "color", "width_scale", "label"),
-            |instance_index: Option<&IndexHash>,
-             time: Time,
-             msg_id: &MsgId,
-             arrow: &re_log_types::Arrow3D,
-             visible: Option<&bool>,
-             color: Option<&[u8; 4]>,
-             width_scale: Option<&f32>,
-             label: Option<&String>| {
-                out.arrow3d.0.push(Object {
-                    props: InstanceProps {
-                        time: time.into(),
-                        msg_id,
-                        color: color.copied(),
-                        obj_path,
-                        instance_index: instance_index.copied().unwrap_or(IndexHash::NONE),
-                        visible: *visible.unwrap_or(&true),
-                    },
-                    data: Arrow3D {
-                        arrow,
-                        label: label.map(|s| s.as_str()),
-                        width_scale: width_scale.cloned(),
-                    },
-                });
-            },
-        );
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct TextEntry<'s> {
-    pub body: &'s str,
-    pub level: Option<&'s str>,
-}
-
-impl<'s> TextEntry<'s> {
-    fn query<Time: 'static + Copy + Ord + Into<i64>>(
-        obj_path: &'s ObjPath,
-        obj_store: &'s ObjStore<Time>,
-        time_query: &TimeQuery<Time>,
-        out: &mut Objects<'s>,
-    ) {
-        crate::profile_function!();
-
-        visit_type_data_3(
-            obj_store,
-            &FieldName::from("body"),
-            time_query,
-            ("_visible", "level", "color"),
-            |instance_index: Option<&IndexHash>,
-             time: Time,
-             msg_id: &MsgId,
-             body: &String,
-             visible: Option<&bool>,
-             level: Option<&String>,
-             color: Option<&[u8; 4]>| {
-                out.text_entry.0.push(Object {
-                    props: InstanceProps {
-                        time: time.into(),
-                        msg_id,
-                        color: color.copied(),
-                        obj_path,
-                        instance_index: instance_index.copied().unwrap_or(IndexHash::NONE),
-                        visible: *visible.unwrap_or(&true),
-                    },
-                    data: TextEntry {
-                        body: body.as_str(),
-                        level: level.map(|s| s.as_str()),
-                    },
-                });
-            },
-        );
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct ClassDescriptionMap<'s> {
-    pub msg_id: &'s MsgId,
-    pub map: HashMap<i32, ClassDescription<'s>>,
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct ClassDescription<'s> {
-    pub label: Option<&'s str>,
-    pub color: Option<[u8; 4]>,
-}
-
-impl<'s> ClassDescription<'s> {
-    fn query<Time: 'static + Copy + Ord + Into<i64>>(
-        obj_path: &'s ObjPath,
-        obj_store: &'s ObjStore<Time>,
-        time_query: &TimeQuery<Time>,
-        out: &mut Objects<'s>,
-    ) {
-        crate::profile_function!();
-
-        visit_type_data_2(
-            obj_store,
-            &FieldName::from("id"),
-            time_query,
-            ("label", "color"),
-            |_instance_index: Option<&IndexHash>,
-             _time,
-             msg_id: &MsgId,
-             id: &i32,
-             label: Option<&String>,
-             color: Option<&[u8; 4]>| {
-                let class_description_map = out
-                    .class_description_map
-                    .entry(obj_path)
-                    .or_insert_with(|| ClassDescriptionMap {
-                        msg_id,
-                        map: HashMap::<i32, ClassDescription<'s>>::default(),
-                    });
-
-                class_description_map.map.insert(
-                    *id,
-                    ClassDescription {
-                        label: label.map(|s| s.as_str()),
-                        color: color.cloned(),
-                    },
-                );
-            },
-        );
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct Objects<'s> {
-    pub class_description_map: BTreeMap<&'s ObjPath, ClassDescriptionMap<'s>>,
-
-    pub text_entry: ObjectVec<'s, TextEntry<'s>>,
-
-    pub image: ObjectVec<'s, Image<'s>>,
-    pub point2d: ObjectVec<'s, Point2D<'s>>,
-    pub bbox2d: ObjectVec<'s, BBox2D<'s>>,
-    pub line_segments2d: ObjectVec<'s, LineSegments2D<'s>>,
-
-    pub point3d: ObjectVec<'s, Point3D<'s>>,
-    pub box3d: ObjectVec<'s, Box3D<'s>>,
-    pub path3d: ObjectVec<'s, Path3D<'s>>,
-    pub line_segments3d: ObjectVec<'s, LineSegments3D<'s>>,
-    pub mesh3d: ObjectVec<'s, Mesh3D<'s>>,
-    pub arrow3d: ObjectVec<'s, Arrow3D<'s>>,
-}
-
-impl<'s> Objects<'s> {
-    pub fn query<Time: 'static + Copy + Ord + Into<i64>>(
-        &mut self,
-        store: &'s TimelineStore<Time>,
-        time_query: &'_ TimeQuery<Time>,
-        obj_types: &IntMap<ObjTypePath, ObjectType>,
-    ) {
-        crate::profile_function!();
-
-        for (obj_path, obj_store) in store.iter() {
-            if let Some(obj_type) = obj_types.get(obj_path.obj_type_path()) {
-                self.query_object(obj_store, time_query, obj_path, obj_type);
-            } else {
-                // Not every path is an object, and that's fine.
-                // Some paths just contains a `_transform`, for instance.
-            }
-        }
-    }
-
-    pub fn query_object<Time: 'static + Copy + Ord + Into<i64>>(
-        &mut self,
-        obj_store: &'s ObjStore<Time>,
-        time_query: &'_ TimeQuery<Time>,
-        obj_path: &'s ObjPath,
-        obj_type: &ObjectType,
-    ) {
-        let query_fn = match obj_type {
-            ObjectType::ClassDescription => ClassDescription::query,
-            ObjectType::TextEntry => TextEntry::query,
-            ObjectType::Image => Image::query,
-            ObjectType::Point2D => Point2D::query,
-            ObjectType::BBox2D => BBox2D::query,
-            ObjectType::LineSegments2D => LineSegments2D::query,
-            ObjectType::Point3D => Point3D::query,
-            ObjectType::Box3D => Box3D::query,
-            ObjectType::Path3D => Path3D::query,
-            ObjectType::LineSegments3D => LineSegments3D::query,
-            ObjectType::Mesh3D => Mesh3D::query,
-            ObjectType::Arrow3D => Arrow3D::query,
-        };
-
-        query_fn(obj_path, obj_store, time_query, self);
-    }
-
-    pub fn filter(&self, keep: impl Fn(&InstanceProps<'_>) -> bool) -> Self {
-        crate::profile_function!();
-
-        Self {
-            class_description_map: self.class_description_map.clone(), // SPECIAL - can't filter
-
-            text_entry: self.text_entry.filter(&keep),
-
-            image: self.image.filter(&keep),
-            point2d: self.point2d.filter(&keep),
-            bbox2d: self.bbox2d.filter(&keep),
-            line_segments2d: self.line_segments2d.filter(&keep),
-
-            point3d: self.point3d.filter(&keep),
-            box3d: self.box3d.filter(&keep),
-            path3d: self.path3d.filter(&keep),
-            line_segments3d: self.line_segments3d.filter(&keep),
-            mesh3d: self.mesh3d.filter(&keep),
-            arrow3d: self.arrow3d.filter(&keep),
-        }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        let Self {
-            class_description_map,
-            text_entry,
-            image,
-            point2d,
-            bbox2d,
-            line_segments2d,
-            point3d,
-            box3d,
-            path3d,
-            line_segments3d,
-            mesh3d,
-            arrow3d,
-        } = self;
-        class_description_map.is_empty()
-            && image.is_empty()
-            && text_entry.is_empty()
-            && point2d.is_empty()
-            && bbox2d.is_empty()
-            && line_segments2d.is_empty()
-            && point3d.is_empty()
-            && box3d.is_empty()
-            && path3d.is_empty()
-            && line_segments3d.is_empty()
-            && mesh3d.is_empty()
-            && arrow3d.is_empty()
-    }
-
-    pub fn len(&self) -> usize {
-        let Self {
-            class_description_map,
-            text_entry,
-            image,
-            point2d,
-            bbox2d,
-            line_segments2d,
-            point3d,
-            box3d,
-            path3d,
-            line_segments3d,
-            mesh3d,
-            arrow3d,
-        } = self;
-        class_description_map.len()
-            + image.len()
-            + text_entry.len()
-            + point2d.len()
-            + bbox2d.len()
-            + line_segments2d.len()
-            + point3d.len()
-            + box3d.len()
-            + path3d.len()
-            + line_segments3d.len()
-            + mesh3d.len()
-            + arrow3d.len()
-    }
-
-    pub fn has_any_2d(&self) -> bool {
-        !self.image.is_empty()
-            || !self.point2d.is_empty()
-            || !self.bbox2d.is_empty()
-            || !self.line_segments2d.is_empty()
-    }
-
-    pub fn has_any_3d(&self) -> bool {
-        !self.point3d.is_empty()
-            || !self.box3d.is_empty()
-            || !self.path3d.is_empty()
-            || !self.line_segments3d.is_empty()
-            || !self.mesh3d.is_empty()
-            || !self.arrow3d.is_empty()
-    }
-
-    pub fn has_any_text_entries(&self) -> bool {
-        !self.text_entry.is_empty()
-    }
-}
-
-// ----------------------------------------------------------------------------
-
-fn as_vec_of_vec2<'s>(what: &str, data_vec: &'s DataVec) -> Option<&'s Vec<[f32; 2]>> {
-    if let DataVec::Vec2(vec) = data_vec {
-        Some(vec)
-    } else {
-        re_log::warn_once!(
-            "Expected {what} to be Vec<Vec2>, got Vec<{:?}>",
-            data_vec.element_data_type()
-        );
-        None
-    }
-}
-
-fn as_vec_of_vec3<'s>(what: &str, data_vec: &'s DataVec) -> Option<&'s Vec<[f32; 3]>> {
-    if let DataVec::Vec3(vec) = data_vec {
-        Some(vec)
-    } else {
-        re_log::warn_once!(
-            "Expected {what} to be Vec<Vec3>, got Vec<{:?}>",
-            data_vec.element_data_type()
-        );
-        None
-    }
-}
diff --git a/crates/re_log_types/Cargo.toml b/crates/re_log_types/Cargo.toml
index c72aac12941d..42ce99c91e1b 100644
--- a/crates/re_log_types/Cargo.toml
+++ b/crates/re_log_types/Cargo.toml
@@ -33,6 +33,7 @@ chrono = { version = "0.4", features = ["js-sys", "wasmbind"] }
 derive_more = "0.99"
 document-features = "0.2"
 nohash-hasher = "0.2"
+re_log = { path = "../re_log" }
 re_string_interner = { path = "../re_string_interner" }
 thiserror = "1.0"
 uuid = { version = "1.1", features = ["serde", "v4", "js"] }
diff --git a/crates/re_log_types/src/data.rs b/crates/re_log_types/src/data.rs
index f8b72b1b1460..84b9ac91e04a 100644
--- a/crates/re_log_types/src/data.rs
+++ b/crates/re_log_types/src/data.rs
@@ -397,6 +397,30 @@ impl DataVec {
             Self::ViewCoordinates(vec) => vec.last().cloned().map(Data::ViewCoordinates),
         }
     }
+
+    pub fn as_vec_of_vec2(&self, what: &str) -> Option<&[[f32; 2]]> {
+        if let DataVec::Vec2(vec) = self {
+            Some(vec)
+        } else {
+            re_log::warn_once!(
+                "Expected {what} to be Vec<Vec2>, got Vec<{:?}>",
+                self.element_data_type()
+            );
+            None
+        }
+    }
+
+    pub fn as_vec_of_vec3(&self, what: &str) -> Option<&[[f32; 3]]> {
+        if let DataVec::Vec3(vec) = self {
+            Some(vec)
+        } else {
+            re_log::warn_once!(
+                "Expected {what} to be Vec<Vec3>, got Vec<{:?}>",
+                self.element_data_type()
+            );
+            None
+        }
+    }
 }
 
 impl std::fmt::Debug for DataVec {
diff --git a/crates/re_viewer/src/app.rs b/crates/re_viewer/src/app.rs
index cbdb97ea4aa8..d6de55fcc0f3 100644
--- a/crates/re_viewer/src/app.rs
+++ b/crates/re_viewer/src/app.rs
@@ -442,7 +442,7 @@ struct AppState {
     /// Configuration for the current recording (found in [`LogDb`]).
     recording_configs: IntMap<RecordingId, RecordingConfig>,
 
-    blueprints: HashMap<ApplicationId, crate::ui::viewport::Blueprint>,
+    blueprints: HashMap<ApplicationId, crate::ui::Blueprint>,
 
     panel_selection: PanelSelection,
     event_log_view: crate::event_log_view::EventLogView,
diff --git a/crates/re_viewer/src/misc/mod.rs b/crates/re_viewer/src/misc/mod.rs
index 016617f3d092..dc61b00ebeee 100644
--- a/crates/re_viewer/src/misc/mod.rs
+++ b/crates/re_viewer/src/misc/mod.rs
@@ -1,9 +1,5 @@
-#[cfg(not(target_arch = "wasm32"))]
-mod clipboard;
 pub(crate) mod color_map;
 pub(crate) mod mesh_loader;
-#[cfg(all(feature = "puffin", not(target_arch = "wasm32")))]
-pub(crate) mod profiler;
 pub(crate) mod space_info;
 pub(crate) mod tensor_image_cache;
 pub(crate) mod time_axis;
@@ -23,9 +19,11 @@ pub(crate) use time_range::{TimeRange, TimeRangeF};
 pub(crate) use time_real::TimeReal;
 pub(crate) use viewer_context::*;
 
-// ----------------------------------------------------------------------------
+#[cfg(all(feature = "puffin", not(target_arch = "wasm32")))]
+pub(crate) mod profiler;
 
-use egui::emath;
+#[cfg(not(target_arch = "wasm32"))]
+pub mod clipboard;
 
 // ----------------------------------------------------------------------------
 
@@ -60,36 +58,3 @@ pub fn random_rgb(seed: u64) -> [u8; 3] {
         }
     }
 }
-
-// ----------------------------------------------------------------------------
-
-pub fn calc_bbox_2d(objects: &re_data_store::Objects<'_>) -> emath::Rect {
-    crate::profile_function!();
-
-    let mut bbox = emath::Rect::NOTHING;
-
-    for (_, obj) in objects.image.iter() {
-        if obj.tensor.shape.len() >= 2 {
-            let [h, w] = [obj.tensor.shape[0].size, obj.tensor.shape[1].size];
-            bbox.extend_with(emath::Pos2::ZERO);
-            bbox.extend_with(emath::pos2(w as _, h as _));
-        }
-    }
-
-    for (_, obj) in objects.point2d.iter() {
-        bbox.extend_with(obj.pos.into());
-    }
-
-    for (_, obj) in objects.bbox2d.iter() {
-        bbox.extend_with(obj.bbox.min.into());
-        bbox.extend_with(obj.bbox.max.into());
-    }
-
-    for (_, obj) in objects.line_segments2d.iter() {
-        for point in obj.points {
-            bbox.extend_with(point.into());
-        }
-    }
-
-    bbox
-}
diff --git a/crates/re_viewer/src/misc/tensor_image_cache.rs b/crates/re_viewer/src/misc/tensor_image_cache.rs
index af904df92eb5..602b3fd62a6b 100644
--- a/crates/re_viewer/src/misc/tensor_image_cache.rs
+++ b/crates/re_viewer/src/misc/tensor_image_cache.rs
@@ -1,10 +1,11 @@
 use egui::{Color32, ColorImage};
 use egui_extras::RetainedImage;
-
 use image::DynamicImage;
-use re_log_types::*;
+use re_log_types::{MsgId, Tensor, TensorDataStore, TensorDataType};
+
+use crate::ui::view_2d::{ColorMapping, Legend};
 
-use crate::ui::legend::{ColorMapping, Legend};
+// ---
 
 /// The `TensorImageView` is a wrapper on top of `re_log_types::Tensor`
 ///
@@ -21,7 +22,7 @@ pub struct TensorImageView<'store, 'cache> {
     pub tensor: &'store Tensor,
 
     /// Legend used to create the view
-    pub legend: &'store Legend<'store>,
+    pub legend: &'store Legend,
 
     /// DynamicImage helper for things like zoom
     pub dynamic_img: &'cache DynamicImage,
@@ -68,13 +69,13 @@ impl ImageCache {
         &'cache mut self,
         msg_id: &MsgId,
         tensor: &'store Tensor,
-        legend: &'store Legend<'store>,
+        legend: &'store Legend,
     ) -> TensorImageView<'store, 'cache> {
         let ci = self
             .images
             .entry(ImageCacheKey {
                 image_msg_id: *msg_id,
-                legend_msg_id: legend.and_then(|seg_map| Some(*seg_map.msg_id)),
+                legend_msg_id: legend.as_ref().map(|seg_map| seg_map.msg_id),
             })
             .or_insert_with(|| {
                 // TODO(emilk): proper debug name for images
@@ -143,7 +144,7 @@ struct CachedImage {
 }
 
 impl CachedImage {
-    fn from_tensor<'store>(debug_name: String, tensor: &Tensor, legend: &Legend<'store>) -> Self {
+    fn from_tensor(debug_name: String, tensor: &Tensor, legend: &Legend) -> Self {
         crate::profile_function!();
         let dynamic_img = match tensor_to_dynamic_image(tensor, legend) {
             Ok(dynamic_image) => dynamic_image,
@@ -175,7 +176,7 @@ impl CachedImage {
     }
 }
 
-fn tensor_to_dynamic_image(tensor: &Tensor, legend: &Legend<'_>) -> anyhow::Result<DynamicImage> {
+fn tensor_to_dynamic_image(tensor: &Tensor, legend: &Legend) -> anyhow::Result<DynamicImage> {
     crate::profile_function!();
     use anyhow::Context as _;
 
@@ -211,7 +212,7 @@ fn tensor_to_dynamic_image(tensor: &Tensor, legend: &Legend<'_>) -> anyhow::Resu
                 "Tensor data length doesn't match tensor shape and dtype"
             );
 
-            match (*legend, depth, tensor.dtype) {
+            match (legend, depth, tensor.dtype) {
                 (Some(legend), 1, TensorDataType::U8) => {
                     // Apply legend mapping to raw bytes interpreted as u8
                     image::RgbaImage::from_raw(
diff --git a/crates/re_viewer/src/misc/viewer_context.rs b/crates/re_viewer/src/misc/viewer_context.rs
index 0a46640aa112..7426a968b9a9 100644
--- a/crates/re_viewer/src/misc/viewer_context.rs
+++ b/crates/re_viewer/src/misc/viewer_context.rs
@@ -139,16 +139,8 @@ impl<'a> ViewerContext<'a> {
         response
     }
 
-    pub fn random_color(&mut self, props: &re_data_store::InstanceProps<'_>) -> [u8; 3] {
-        // TODO(emilk): ignore "temporary" indices when calculating the hash.
-        let hash = props.obj_path.hash64();
-
-        let color = *self
-            .cache
-            .object_colors
-            .entry(hash)
-            .or_insert_with(|| crate::misc::random_rgb(hash));
-        color
+    pub fn random_color(&mut self, obj_path: &ObjPath) -> [u8; 3] {
+        self.cache.random_color(obj_path)
     }
 }
 
@@ -214,7 +206,7 @@ pub(crate) struct Caches {
     pub image: crate::misc::ImageCache,
 
     /// For displaying meshes efficiently in immediate mode.
-    pub cpu_mesh: crate::ui::view3d::CpuMeshCache,
+    pub cpu_mesh: crate::ui::view_3d::CpuMeshCache,
 
     /// Auto-generated colors.
     object_colors: nohash_hasher::IntMap<u64, [u8; 3]>,
@@ -226,6 +218,18 @@ impl Caches {
         let max_image_cache_use = 1_000_000_000;
         self.image.new_frame(max_image_cache_use);
     }
+
+    pub fn random_color(&mut self, obj_path: &ObjPath) -> [u8; 3] {
+        // TODO(emilk): ignore "temporary" indices when calculating the hash.
+        let hash = obj_path.hash64();
+
+        let color = *self
+            .object_colors
+            .entry(hash)
+            .or_insert_with(|| crate::misc::random_rgb(hash));
+
+        color
+    }
 }
 
 // ----------------------------------------------------------------------------
@@ -255,7 +259,7 @@ pub(crate) enum Selection {
     Instance(InstanceId),
     DataPath(DataPath),
     Space(ObjPath),
-    SpaceView(crate::SpaceViewId),
+    SpaceView(crate::ui::SpaceViewId),
 }
 
 impl Default for Selection {
diff --git a/crates/re_viewer/src/ui/data_ui.rs b/crates/re_viewer/src/ui/data_ui.rs
index 4c3f914c5d14..dde598ec9946 100644
--- a/crates/re_viewer/src/ui/data_ui.rs
+++ b/crates/re_viewer/src/ui/data_ui.rs
@@ -4,8 +4,9 @@ use re_data_store::InstanceId;
 pub use re_log_types::*;
 
 use crate::misc::ViewerContext;
+use crate::ui::view_2d::view_class_description_map;
 
-use super::{class_description_ui::view_class_description_map, Preview};
+use super::Preview;
 
 pub(crate) fn view_object(
     ctx: &mut ViewerContext<'_>,
@@ -135,7 +136,7 @@ pub(crate) fn show_detailed_data(
     data: &Data,
 ) {
     if let Data::Tensor(tensor) = data {
-        crate::image_ui::show_tensor(ctx, ui, msg_id, tensor);
+        crate::ui::view_2d::show_tensor(ctx, ui, msg_id, tensor);
     } else {
         crate::data_ui::ui_data(ctx, ui, msg_id, data, Preview::Medium);
     }
@@ -178,7 +179,7 @@ pub(crate) fn show_detailed_data_msg(
         });
 
     if let LoggedData::Single(Data::Tensor(tensor)) = &msg.data {
-        crate::image_ui::show_tensor(ctx, ui, msg_id, tensor);
+        crate::ui::view_2d::show_tensor(ctx, ui, msg_id, tensor);
     }
 }
 
diff --git a/crates/re_viewer/src/ui/mod.rs b/crates/re_viewer/src/ui/mod.rs
index 24d74759e877..1cb9f8d5eb8b 100644
--- a/crates/re_viewer/src/ui/mod.rs
+++ b/crates/re_viewer/src/ui/mod.rs
@@ -1,22 +1,22 @@
-pub(crate) mod class_description_ui;
+mod viewport;
+pub(crate) use self::viewport::{Blueprint, SpaceViewId};
+
+mod space_view;
+use self::space_view::SpaceView;
+
+mod scene;
+use self::scene::{Scene, SceneQuery};
+
 pub(crate) mod data_ui;
 pub(crate) mod event_log_view;
-pub(crate) mod image_ui;
 pub(crate) mod kb_shortcuts;
-pub(crate) mod legend;
 pub(crate) mod selection_panel;
-pub(crate) mod space_view;
-pub(crate) mod text_entry_view;
 pub(crate) mod time_panel;
-pub(crate) mod view2d;
-pub(crate) mod view3d;
-pub(crate) mod view_tensor;
-pub(crate) mod viewport;
-
-pub(crate) use space_view::SpaceView;
-pub(crate) use viewport::{Blueprint, SpaceViewId};
 
-mod tensor_dimension_mapper;
+pub(crate) mod view_2d;
+pub(crate) mod view_3d;
+mod view_tensor;
+mod view_text;
 
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub(crate) enum Preview {
diff --git a/crates/re_viewer/src/ui/scene.rs b/crates/re_viewer/src/ui/scene.rs
new file mode 100644
index 000000000000..98bb3927e11f
--- /dev/null
+++ b/crates/re_viewer/src/ui/scene.rs
@@ -0,0 +1,64 @@
+use nohash_hasher::IntSet;
+use re_data_store::{LogDb, ObjPath, ObjStore, ObjectTreeProperties, TimeQuery, Timeline};
+use re_log_types::ObjectType;
+
+use super::{view_2d, view_3d, view_tensor, view_text};
+
+// ---
+
+/// A fully self-contained scene, ready to be rendered as-is.
+#[derive(Default)]
+pub struct Scene {
+    pub two_d: view_2d::Scene2D,
+    pub three_d: view_3d::Scene3D,
+    pub text: view_text::SceneText,
+    pub tensor: view_tensor::SceneTensor,
+}
+
+#[derive(Debug)]
+pub struct SceneQuery<'s> {
+    pub obj_paths: &'s IntSet<ObjPath>,
+    pub timeline: Timeline,
+    pub time_query: TimeQuery<i64>,
+}
+impl<'s> SceneQuery<'s> {
+    /// Given a list of `ObjectType`s, this will return all relevant `ObjStore`s that should be
+    /// queried for datapoints.
+    ///
+    /// An `ObjStore` is considered relevant if it contains at least one of the types that we
+    /// are looking for, and is currently visible according to the state of the blueprint.
+    pub(crate) fn iter_object_stores<'a>(
+        &'a self,
+        log_db: &'a LogDb,
+        obj_tree_props: &'a ObjectTreeProperties,
+        obj_types: &'a [ObjectType],
+    ) -> impl Iterator<Item = (ObjectType, &ObjPath, &ObjStore<i64>)> + 'a {
+        // For the appropriate timeline store...
+        log_db
+            .obj_db
+            .store
+            .get(&self.timeline)
+            .into_iter()
+            .flat_map(|timeline_store| {
+                // ...and for all visible object paths within that timeline store...
+                self.obj_paths
+                    .iter()
+                    .filter(|obj_path| obj_tree_props.projected.get(obj_path).visible)
+                    .filter_map(|obj_path| {
+                        // ...whose datatypes are registered...
+                        let obj_type = log_db.obj_db.types.get(obj_path.obj_type_path());
+                        obj_type
+                            .and_then(|obj_type| {
+                                // ...and whose datatypes we care about...
+                                obj_types.contains(obj_type).then(|| {
+                                    // ...then return the actual object store!
+                                    timeline_store
+                                        .get(obj_path)
+                                        .map(|obj_store| (*obj_type, obj_path, obj_store))
+                                })
+                            })
+                            .flatten()
+                    })
+            })
+    }
+}
diff --git a/crates/re_viewer/src/ui/selection_panel.rs b/crates/re_viewer/src/ui/selection_panel.rs
index da971ebaea3e..2b0f8ca1963e 100644
--- a/crates/re_viewer/src/ui/selection_panel.rs
+++ b/crates/re_viewer/src/ui/selection_panel.rs
@@ -1,7 +1,7 @@
 use re_data_store::log_db::LogDb;
 use re_log_types::LogMsg;
 
-use crate::{data_ui::*, Blueprint, Preview, Selection, ViewerContext};
+use crate::{data_ui::*, ui::Blueprint, Preview, Selection, ViewerContext};
 
 use super::SpaceView;
 
diff --git a/crates/re_viewer/src/ui/space_view.rs b/crates/re_viewer/src/ui/space_view.rs
index 40796825aa68..66b5ef109c75 100644
--- a/crates/re_viewer/src/ui/space_view.rs
+++ b/crates/re_viewer/src/ui/space_view.rs
@@ -1,9 +1,9 @@
-use re_data_store::{ObjPath, ObjectTree, ObjectTreeProperties, Objects};
+use re_data_store::{ObjPath, ObjectTree, ObjectTreeProperties};
 use re_log_types::Transform;
 
 use crate::misc::{space_info::*, ViewerContext};
 
-use super::view3d::SpaceCamera;
+use super::{view_2d, view_3d, view_tensor, view_text, Scene};
 
 // ----------------------------------------------------------------------------
 
@@ -23,7 +23,7 @@ enum ViewCategory {
 pub(crate) struct SpaceView {
     pub name: String,
     pub space_path: ObjPath,
-    view_state: ViewState,
+    pub view_state: ViewState,
 
     /// In case we are a mix of 2d/3d/tensor/text, we show what?
     selected_category: ViewCategory,
@@ -46,43 +46,38 @@ impl SpaceView {
         self.obj_tree_properties.on_frame_start(obj_tree);
     }
 
-    pub fn objects_ui(
+    pub(crate) fn scene_ui(
         &mut self,
         ctx: &mut ViewerContext<'_>,
         ui: &mut egui::Ui,
         spaces_info: &SpacesInfo,
         space_info: &SpaceInfo,
-        time_objects: &Objects<'_>,
-        sticky_objects: &Objects<'_>,
+        // NOTE: mutable because the glow-based 3D view `take()`s the scene because reasons.
+        // TODO(cmc): remove this while removing glow.
+        scene: &mut Scene,
     ) -> egui::Response {
         crate::profile_function!();
 
-        let multidim_tensor = multidim_tensor(time_objects);
-        let has_2d =
-            time_objects.has_any_2d() && (multidim_tensor.is_none() || time_objects.len() > 1);
-        let has_3d = time_objects.has_any_3d();
-        let has_text = sticky_objects.has_any_text_entries();
-
-        let mut categories = vec![];
-        if has_2d {
-            categories.push(ViewCategory::TwoD);
-        }
-        if has_3d {
-            categories.push(ViewCategory::ThreeD);
-        }
-        if multidim_tensor.is_some() {
-            categories.push(ViewCategory::Tensor);
-        }
-        if has_text {
-            categories.push(ViewCategory::Text);
-        }
+        let has_2d = !scene.two_d.is_empty() && scene.tensor.is_empty();
+        let has_3d = !scene.three_d.is_empty();
+        let has_text = !scene.text.is_empty();
+        let has_tensor = !scene.tensor.is_empty();
+        let categories = [
+            has_2d.then_some(ViewCategory::TwoD),
+            has_3d.then_some(ViewCategory::ThreeD),
+            has_text.then_some(ViewCategory::Text),
+            has_tensor.then_some(ViewCategory::Tensor),
+        ]
+        .iter()
+        .filter_map(|cat| *cat)
+        .collect::<Vec<_>>();
 
         match categories.len() {
             0 => ui.label("(empty)"),
             1 => {
                 if has_2d {
                     self.view_state
-                        .ui_2d(ctx, ui, &self.space_path, time_objects)
+                        .ui_2d(ctx, ui, &self.space_path, &scene.two_d)
                 } else if has_3d {
                     self.view_state.ui_3d(
                         ctx,
@@ -90,12 +85,13 @@ impl SpaceView {
                         &self.space_path,
                         spaces_info,
                         space_info,
-                        time_objects,
+                        &mut scene.three_d,
                     )
-                } else if let Some(multidim_tensor) = multidim_tensor {
-                    self.view_state.ui_tensor(ui, multidim_tensor)
+                } else if has_tensor {
+                    self.view_state.ui_tensor(ui, &scene.tensor)
                 } else {
-                    self.view_state.ui_text(ctx, ui, sticky_objects)
+                    assert!(has_text);
+                    self.view_state.ui_text(ctx, ui, &scene.text)
                 }
             }
             _ => {
@@ -120,9 +116,15 @@ impl SpaceView {
                     ui.separator();
 
                     match self.selected_category {
+                        ViewCategory::Text => {
+                            self.view_state.ui_text(ctx, ui, &scene.text);
+                        }
+                        ViewCategory::Tensor => {
+                            self.view_state.ui_tensor(ui, &scene.tensor);
+                        }
                         ViewCategory::TwoD => {
                             self.view_state
-                                .ui_2d(ctx, ui, &self.space_path, time_objects);
+                                .ui_2d(ctx, ui, &self.space_path, &scene.two_d);
                         }
                         ViewCategory::ThreeD => {
                             self.view_state.ui_3d(
@@ -131,15 +133,9 @@ impl SpaceView {
                                 &self.space_path,
                                 spaces_info,
                                 space_info,
-                                time_objects,
+                                &mut scene.three_d,
                             );
                         }
-                        ViewCategory::Tensor => {
-                            self.view_state.ui_tensor(ui, multidim_tensor.unwrap());
-                        }
-                        ViewCategory::Text => {
-                            self.view_state.ui_text(ctx, ui, sticky_objects);
-                        }
                     }
                 })
                 .response
@@ -152,15 +148,11 @@ impl SpaceView {
 
 /// Camera position and similar.
 #[derive(Default, serde::Deserialize, serde::Serialize)]
-struct ViewState {
-    // per space
-    state_2d: crate::view2d::State2D,
-
-    state_3d: crate::view3d::State3D,
-
-    state_tensor: Option<crate::view_tensor::TensorViewState>,
-
-    state_text_entry: crate::text_entry_view::TextEntryState,
+pub(crate) struct ViewState {
+    pub state_2d: view_2d::View2DState,
+    pub state_3d: view_3d::View3DState,
+    pub state_tensor: Option<view_tensor::ViewTensorState>,
+    pub state_text_entry: view_text::ViewTextState,
 }
 
 impl ViewState {
@@ -169,9 +161,9 @@ impl ViewState {
         ctx: &mut ViewerContext<'_>,
         ui: &mut egui::Ui,
         space: &ObjPath,
-        objects: &Objects<'_>,
+        scene: &view_2d::Scene2D,
     ) -> egui::Response {
-        crate::view2d::view_2d(ctx, ui, &mut self.state_2d, Some(space), objects)
+        view_2d::view_2d(ctx, ui, &mut self.state_2d, Some(space), scene)
     }
 
     fn ui_3d(
@@ -181,15 +173,14 @@ impl ViewState {
         space: &ObjPath,
         spaces_info: &SpacesInfo,
         space_info: &SpaceInfo,
-        objects: &Objects<'_>,
+        scene: &mut view_3d::Scene3D,
     ) -> egui::Response {
         ui.vertical(|ui| {
             let state = &mut self.state_3d;
             let space_cameras = &space_cameras(spaces_info, space_info);
             let coordinates = space_info.coordinates;
-            let space_specs = crate::view3d::SpaceSpecs::from_view_coordinates(coordinates);
-            let scene = crate::view3d::scene::Scene::from_objects(ctx, objects);
-            crate::view3d::view_3d(
+            let space_specs = view_3d::SpaceSpecs::from_view_coordinates(coordinates);
+            view_3d::view_3d(
                 ctx,
                 ui,
                 state,
@@ -202,12 +193,13 @@ impl ViewState {
         .response
     }
 
-    fn ui_tensor(&mut self, ui: &mut egui::Ui, tensor: &re_log_types::Tensor) -> egui::Response {
+    fn ui_tensor(&mut self, ui: &mut egui::Ui, scene: &view_tensor::SceneTensor) -> egui::Response {
+        let tensor = &scene.tensors[0];
         let state_tensor = self
             .state_tensor
-            .get_or_insert_with(|| crate::ui::view_tensor::TensorViewState::create(tensor));
+            .get_or_insert_with(|| view_tensor::ViewTensorState::create(tensor));
         ui.vertical(|ui| {
-            crate::view_tensor::view_tensor(ui, state_tensor, tensor);
+            view_tensor::view_tensor(ui, state_tensor, tensor);
         })
         .response
     }
@@ -216,15 +208,15 @@ impl ViewState {
         &mut self,
         ctx: &mut ViewerContext<'_>,
         ui: &mut egui::Ui,
-        objects: &Objects<'_>,
+        scene: &view_text::SceneText,
     ) -> egui::Response {
-        self.state_text_entry.show(ui, ctx, objects)
+        view_text::view_text(ctx, ui, &mut self.state_text_entry, scene)
     }
 }
 
 /// Look for camera transform and pinhole in the transform hierarchy
 /// and return them as cameras.
-fn space_cameras(spaces_info: &SpacesInfo, space_info: &SpaceInfo) -> Vec<SpaceCamera> {
+fn space_cameras(spaces_info: &SpacesInfo, space_info: &SpaceInfo) -> Vec<view_3d::SpaceCamera> {
     crate::profile_function!();
 
     let mut space_cameras = vec![];
@@ -243,7 +235,7 @@ fn space_cameras(spaces_info: &SpacesInfo, space_info: &SpaceInfo) -> Vec<SpaceC
             if let Some(child_space_info) = spaces_info.spaces.get(child_path) {
                 for (grand_child_path, grand_child_transform) in &child_space_info.child_spaces {
                     if let Transform::Pinhole(pinhole) = grand_child_transform {
-                        space_cameras.push(SpaceCamera {
+                        space_cameras.push(view_3d::SpaceCamera {
                             camera_obj_path: child_path.clone(),
                             instance_index_hash: re_log_types::IndexHash::NONE,
                             camera_view_coordinates: view_space,
@@ -257,7 +249,7 @@ fn space_cameras(spaces_info: &SpacesInfo, space_info: &SpaceInfo) -> Vec<SpaceC
             }
 
             if !found_any_pinhole {
-                space_cameras.push(SpaceCamera {
+                space_cameras.push(view_3d::SpaceCamera {
                     camera_obj_path: child_path.clone(),
                     instance_index_hash: re_log_types::IndexHash::NONE,
                     camera_view_coordinates: view_space,
@@ -271,22 +263,3 @@ fn space_cameras(spaces_info: &SpacesInfo, space_info: &SpaceInfo) -> Vec<SpaceC
 
     space_cameras
 }
-
-fn multidim_tensor<'s>(objects: &Objects<'s>) -> Option<&'s re_log_types::Tensor> {
-    // We have a special tensor viewer that (currently) only works
-    // when we only have a single tensor (and no bounding boxes etc).
-    // It is also not as great for images as the normal 2d view (at least not yet).
-    // This is a hacky-way of detecting this special case.
-    // TODO(emilk): integrate the tensor viewer into the 2D viewer instead,
-    // so we can stack bounding boxes etc on top of it.
-    if objects.image.len() == 1 {
-        let image = objects.image.first().unwrap().1;
-        let tensor = image.tensor;
-
-        // Ignore tensors that likely represent images.
-        if tensor.num_dim() > 3 || tensor.num_dim() == 3 && tensor.shape.last().unwrap().size > 4 {
-            return Some(tensor);
-        }
-    }
-    None
-}
diff --git a/crates/re_viewer/src/ui/text_entry_view.rs b/crates/re_viewer/src/ui/text_entry_view.rs
deleted file mode 100644
index 3ceb37d89a21..000000000000
--- a/crates/re_viewer/src/ui/text_entry_view.rs
+++ /dev/null
@@ -1,249 +0,0 @@
-use crate::ViewerContext;
-use egui::{Color32, RichText};
-use re_data_store::{InstanceProps, Objects, TextEntry};
-use re_log_types::*;
-
-// -----------------------------------------------------------------------------
-
-#[derive(Clone, Default, serde::Deserialize, serde::Serialize)]
-#[serde(default)]
-pub(crate) struct TextEntryState {
-    /// Keeps track of the latest time selection made by the user.
-    ///
-    /// We need this because we want the user to be able to manually scroll the
-    /// text entry window however they please when the time cursor isn't moving.
-    latest_time: i64,
-}
-
-impl TextEntryState {
-    pub fn show(
-        &mut self,
-        ui: &mut egui::Ui,
-        ctx: &mut ViewerContext<'_>,
-        objects: &Objects<'_>,
-    ) -> egui::Response {
-        crate::profile_function!();
-
-        let text_entries = collect_text_entries(ctx, objects);
-
-        let time = ctx
-            .rec_cfg
-            .time_ctrl
-            .time_query()
-            .map_or(self.latest_time, |q| match q {
-                re_data_store::TimeQuery::LatestAt(time) => time,
-                re_data_store::TimeQuery::Range(range) => *range.start(),
-            });
-
-        // Did the time cursor move since last time?
-        // - If it did, time to autoscroll approriately.
-        // - Otherwise, let the user scroll around freely!
-        let time_cursor_moved = self.latest_time != time;
-        let scroll_to_row = time_cursor_moved.then(|| {
-            crate::profile_scope!("binsearch");
-            let index = text_entries.partition_point(|msg| msg.0.time < time);
-            usize::min(index, index.saturating_sub(1))
-        });
-
-        self.latest_time = time;
-
-        ui.with_layout(egui::Layout::top_down(egui::Align::Center), |ui| {
-            ui.label(format!("{} text entries", objects.text_entry.len()));
-            ui.separator();
-
-            egui::ScrollArea::horizontal().show(ui, |ui| {
-                crate::profile_scope!("render table");
-                show_table(ctx, ui, &text_entries, scroll_to_row);
-            })
-        })
-        .response
-    }
-}
-
-// -----------------------------------------------------------------------------
-
-fn collect_text_entries<'s>(
-    _ctx: &mut ViewerContext<'_>,
-    objects: &'s Objects<'_>,
-) -> Vec<(&'s InstanceProps<'s>, &'s TextEntry<'s>)> {
-    crate::profile_function!();
-
-    let mut text_entries = {
-        crate::profile_scope!("collect");
-
-        objects.text_entry.iter().collect::<Vec<_>>()
-    };
-
-    {
-        crate::profile_scope!("sort");
-
-        text_entries.sort_by(|a, b| {
-            a.0.time
-                .cmp(&b.0.time)
-                .then_with(|| a.0.obj_path.cmp(b.0.obj_path))
-        });
-    }
-
-    text_entries
-}
-
-struct CompleteTextEntry<'s> {
-    time_point: TimePoint,
-    props: &'s InstanceProps<'s>,
-    text_entry: &'s TextEntry<'s>,
-}
-
-impl<'s> CompleteTextEntry<'s> {
-    fn try_from_props(
-        ctx: &ViewerContext<'_>,
-        props: &'s InstanceProps<'s>,
-        text_entry: &'s TextEntry<'s>,
-    ) -> Option<Self> {
-        let msg = ctx.log_db.get_log_msg(props.msg_id).or_else(|| {
-            re_log::warn_once!("Missing LogMsg for {:?}", props.obj_path.obj_type_path());
-            None
-        })?;
-
-        let data_msg = if let LogMsg::DataMsg(data_msg) = msg {
-            data_msg
-        } else {
-            re_log::warn_once!(
-                "LogMsg must be a DataMsg ({:?})",
-                props.obj_path.obj_type_path()
-            );
-            return None;
-        };
-
-        Some(CompleteTextEntry {
-            time_point: data_msg.time_point.clone(),
-            props,
-            text_entry,
-        })
-    }
-}
-
-/// `scroll_to_row` indicates how far down we want to scroll in terms of logical rows,
-/// as opposed to `scroll_to_offset` (computed below) which is how far down we want to
-/// scroll in terms of actual points.
-fn show_table(
-    ctx: &mut ViewerContext<'_>,
-    ui: &mut egui::Ui,
-    text_entries: &[(&InstanceProps<'_>, &TextEntry<'_>)],
-    scroll_to_row: Option<usize>,
-) {
-    use egui_extras::Size;
-    const ROW_HEIGHT: f32 = 18.0;
-
-    let spacing_y = ui.spacing().item_spacing.y;
-
-    let mut builder = egui_extras::TableBuilder::new(ui)
-        .striped(true)
-        .resizable(true)
-        .scroll(true);
-
-    if let Some(index) = scroll_to_row {
-        let row_height_full = ROW_HEIGHT + spacing_y;
-        let scroll_to_offset = index as f32 * row_height_full;
-        builder = builder.vertical_scroll_offset(scroll_to_offset);
-    }
-
-    builder
-        .cell_layout(egui::Layout::left_to_right(egui::Align::Center))
-        .columns(
-            Size::initial(180.0).at_least(100.0),
-            ctx.log_db.time_points.0.len(),
-        ) // time(s)
-        .column(Size::initial(120.0).at_least(100.0)) // path
-        .column(Size::initial(60.0).at_least(60.0)) // level
-        .column(Size::remainder().at_least(200.0)) // body
-        .header(20.0, |mut header| {
-            for timeline in ctx.log_db.time_points.0.keys() {
-                header.col(|ui| {
-                    ui.heading(timeline.name().as_str());
-                });
-            }
-            header.col(|ui| {
-                ui.heading("Path");
-            });
-            header.col(|ui| {
-                ui.heading("Level");
-            });
-            header.col(|ui| {
-                ui.heading("Body");
-            });
-        })
-        .body(|body| {
-            body.rows(ROW_HEIGHT, text_entries.len(), |index, mut row| {
-                let (props, text_entry) = text_entries[index];
-
-                // NOTE: `try_from_props` is where we actually fetch data from the underlying
-                // store, which is a costly operation.
-                // Doing this here guarantees that it only happens for visible rows.
-                let text_entry =
-                    if let Some(te) = CompleteTextEntry::try_from_props(ctx, props, text_entry) {
-                        te
-                    } else {
-                        row.col(|ui| {
-                            ui.colored_label(
-                                Color32::RED,
-                                "<failed to load TextEntry from data store>",
-                            );
-                        });
-                        return;
-                    };
-
-                let CompleteTextEntry {
-                    time_point,
-                    props,
-                    text_entry,
-                } = text_entry;
-
-                // time(s)
-                for timeline in ctx.log_db.time_points.0.keys() {
-                    row.col(|ui| {
-                        if let Some(value) = time_point.0.get(timeline) {
-                            ctx.time_button(ui, timeline, *value);
-                        }
-                    });
-                }
-
-                // path
-                row.col(|ui| {
-                    ctx.obj_path_button(ui, props.obj_path);
-                });
-
-                // level
-                row.col(|ui| {
-                    if let Some(lvl) = text_entry.level {
-                        ui.label(level_to_rich_text(ui, lvl));
-                    } else {
-                        ui.label("-");
-                    }
-                });
-
-                // body
-                row.col(|ui| {
-                    if let Some(c) = props.color {
-                        let color = Color32::from_rgba_unmultiplied(c[0], c[1], c[2], c[3]);
-                        ui.colored_label(color, text_entry.body);
-                    } else {
-                        ui.label(text_entry.body);
-                    }
-                });
-            });
-        });
-}
-
-fn level_to_rich_text(ui: &egui::Ui, lvl: &str) -> RichText {
-    match lvl {
-        "CRITICAL" => RichText::new(lvl)
-            .color(Color32::WHITE)
-            .background_color(ui.visuals().error_fg_color),
-        "ERROR" => RichText::new(lvl).color(ui.visuals().error_fg_color),
-        "WARN" => RichText::new(lvl).color(ui.visuals().warn_fg_color),
-        "INFO" => RichText::new(lvl).color(Color32::LIGHT_GREEN),
-        "DEBUG" => RichText::new(lvl).color(Color32::LIGHT_BLUE),
-        "TRACE" => RichText::new(lvl).color(Color32::LIGHT_GRAY),
-        _ => RichText::new(lvl).color(ui.visuals().text_color()),
-    }
-}
diff --git a/crates/re_viewer/src/ui/class_description_ui.rs b/crates/re_viewer/src/ui/view_2d/class_description_ui.rs
similarity index 100%
rename from crates/re_viewer/src/ui/class_description_ui.rs
rename to crates/re_viewer/src/ui/view_2d/class_description_ui.rs
diff --git a/crates/re_viewer/src/ui/image_ui.rs b/crates/re_viewer/src/ui/view_2d/image_ui.rs
similarity index 99%
rename from crates/re_viewer/src/ui/image_ui.rs
rename to crates/re_viewer/src/ui/view_2d/image_ui.rs
index 9719d10cd318..13a2e084de82 100644
--- a/crates/re_viewer/src/ui/image_ui.rs
+++ b/crates/re_viewer/src/ui/view_2d/image_ui.rs
@@ -1,10 +1,9 @@
 use itertools::Itertools as _;
 use re_log_types::*;
 
-use crate::{
-    misc::{tensor_image_cache, ViewerContext},
-    ui::legend::LabelMapping,
-};
+use crate::misc::{tensor_image_cache, ViewerContext};
+
+use super::LabelMapping as _;
 
 pub(crate) fn show_tensor(
     ctx: &mut ViewerContext<'_>,
diff --git a/crates/re_viewer/src/ui/legend.rs b/crates/re_viewer/src/ui/view_2d/legend.rs
similarity index 51%
rename from crates/re_viewer/src/ui/legend.rs
rename to crates/re_viewer/src/ui/view_2d/legend.rs
index e100db98d9c7..45672e1a7245 100644
--- a/crates/re_viewer/src/ui/legend.rs
+++ b/crates/re_viewer/src/ui/view_2d/legend.rs
@@ -1,32 +1,54 @@
+use std::{borrow::Cow, collections::BTreeMap, sync::Arc};
+
 use ahash::HashMap;
 use lazy_static::lazy_static;
+use re_data_store::ObjPath;
 use re_log_types::MsgId;
 
-pub type Legend<'s> = Option<&'s re_data_store::ClassDescriptionMap<'s>>;
+// ---
+
+#[derive(Clone, Debug)]
+pub struct ClassDescription {
+    pub label: Option<Cow<'static, str>>,
+    pub color: Option<[u8; 4]>,
+}
+
+#[derive(Clone, Debug)]
+pub struct ClassDescriptionMap {
+    pub msg_id: MsgId,
+    pub map: HashMap<i32, ClassDescription>,
+}
+
+#[derive(Default, Clone, Debug)]
+pub struct Legends(pub BTreeMap<ObjPath, Arc<ClassDescriptionMap>>);
+
+impl Legends {
+    // If the object_path is set on the image, but it doesn't point to a valid legend
+    // we return the default MissingLegend which gives us "reasonable" behavior.
+    // TODO(jleibs): We should still surface a user-visible error in this case
+    pub fn find<'a>(&self, obj_path: impl Into<Option<&'a ObjPath>>) -> Legend {
+        let obj_path = obj_path.into();
+        self.0
+            .get(obj_path?)
+            .cloned() // Arc
+            .or_else(|| Some(Arc::clone(&MISSING_LEGEND)))
+    }
+}
+
+pub type Legend = Option<Arc<ClassDescriptionMap>>;
+
+// ---
 
 lazy_static! {
     static ref MISSING_MSGID: MsgId = MsgId::random();
-    static ref MISSING_LEGEND: re_data_store::ClassDescriptionMap<'static> = {
-        re_data_store::ClassDescriptionMap {
-            msg_id: &MISSING_MSGID,
-            map: HashMap::<i32, re_data_store::ClassDescription<'static>>::default(),
-        }
+    static ref MISSING_LEGEND: Arc<ClassDescriptionMap> = {
+        Arc::new(ClassDescriptionMap {
+            msg_id: *MISSING_MSGID,
+            map: Default::default(),
+        })
     };
 }
 
-// If the object_path is set on the image, but it doesn't point to a valid legend
-// we return the default MissingLegend which gives us "reasonable" behavior.
-// TODO(jleibs): We should still surface a user-visible error in this case
-pub(crate) fn find_legend<'s>(
-    obj_path: Option<&re_data_store::ObjPath>,
-    objects: &'s re_data_store::Objects<'s>,
-) -> Legend<'s> {
-    objects
-        .class_description_map
-        .get(obj_path?)
-        .or(Some(&MISSING_LEGEND))
-}
-
 // default colors
 // Borrowed from `egui::PlotUi`
 pub fn auto_color(val: u16) -> [u8; 4] {
@@ -38,11 +60,11 @@ pub fn auto_color(val: u16) -> [u8; 4] {
 
 // Currently using a pair [u8;4] since it converts more easily
 // to DynamicImage
-pub(crate) trait ColorMapping {
+pub trait ColorMapping {
     fn map_color(&self, val: u16) -> [u8; 4];
 }
 
-impl<'s> ColorMapping for re_data_store::ClassDescriptionMap<'s> {
+impl ColorMapping for ClassDescriptionMap {
     fn map_color(&self, val: u16) -> [u8; 4] {
         if let Some(seg_label) = self.map.get(&(val as i32)) {
             if let Some(color) = seg_label.color {
@@ -64,15 +86,15 @@ impl<'s> ColorMapping for re_data_store::ClassDescriptionMap<'s> {
 }
 
 // TODO(jleibs): sort out lifetime of label
-pub(crate) trait LabelMapping {
+pub trait LabelMapping {
     fn map_label(&self, val: u16) -> String;
 }
 
-impl<'s> LabelMapping for re_data_store::ClassDescriptionMap<'s> {
+impl LabelMapping for ClassDescriptionMap {
     fn map_label(&self, val: u16) -> String {
         if let Some(seg_label) = self.map.get(&(val as i32)) {
-            if let Some(label) = seg_label.label {
-                label.to_owned()
+            if let Some(label) = seg_label.label.as_ref() {
+                label.to_string()
             } else {
                 (val as i32).to_string()
             }
diff --git a/crates/re_viewer/src/ui/view_2d/mod.rs b/crates/re_viewer/src/ui/view_2d/mod.rs
new file mode 100644
index 000000000000..4e76fd15f06f
--- /dev/null
+++ b/crates/re_viewer/src/ui/view_2d/mod.rs
@@ -0,0 +1,16 @@
+mod scene;
+pub use self::scene::{Box2D, Image, LineSegments2D, ObjectPaintProperties, Point2D, Scene2D};
+
+mod ui;
+pub(crate) use self::ui::{view_2d, View2DState};
+
+mod class_description_ui;
+pub(crate) use self::class_description_ui::view_class_description_map;
+
+mod legend;
+pub use self::legend::{
+    ClassDescription, ClassDescriptionMap, ColorMapping, LabelMapping, Legend, Legends,
+};
+
+mod image_ui;
+pub(crate) use self::image_ui::{show_tensor, show_zoomed_image_region_tooltip};
diff --git a/crates/re_viewer/src/ui/view_2d/scene.rs b/crates/re_viewer/src/ui/view_2d/scene.rs
new file mode 100644
index 000000000000..6603f0a958a8
--- /dev/null
+++ b/crates/re_viewer/src/ui/view_2d/scene.rs
@@ -0,0 +1,503 @@
+use std::sync::Arc;
+
+use egui::{pos2, Color32, Pos2, Rect, Stroke};
+use re_data_store::{
+    query::{visit_type_data_2, visit_type_data_3, visit_type_data_4},
+    FieldName, InstanceId, InstanceIdHash, ObjPath, ObjectTreeProperties,
+};
+use re_log_types::{DataVec, IndexHash, MsgId, ObjectType, Tensor};
+
+use crate::{ui::SceneQuery, ViewerContext};
+
+use super::{ClassDescription, ClassDescriptionMap, Legend, Legends, View2DState};
+
+// ---
+
+// TODO(cmc): just turn all colors into Color32?
+
+pub struct Image {
+    pub msg_id: MsgId,
+    pub obj_path: ObjPath,
+    pub instance_hash: InstanceIdHash,
+
+    pub tensor: Tensor,
+    /// If this is a depth map, how long is a meter?
+    ///
+    /// For instance, with a `u16` dtype one might have
+    /// `meter == 1000.0` for millimeter precision
+    /// up to a ~65m range.
+    pub meter: Option<f32>,
+    pub paint_props: ObjectPaintProperties,
+    /// A thing that provides additional semantic context for your dtype.
+    pub legend: Legend,
+}
+
+pub struct Box2D {
+    pub instance_hash: InstanceIdHash,
+
+    pub bbox: re_log_types::BBox2D,
+    pub stroke_width: Option<f32>,
+    pub label: Option<String>,
+    pub paint_props: ObjectPaintProperties,
+}
+
+pub struct LineSegments2D {
+    pub instance_hash: InstanceIdHash,
+
+    /// Connected pair-wise even-odd.
+    pub points: Vec<Pos2>,
+    pub stroke_width: Option<f32>,
+    pub paint_props: ObjectPaintProperties,
+}
+
+pub struct Point2D {
+    pub instance_hash: InstanceIdHash,
+
+    pub pos: Pos2,
+    pub radius: Option<f32>,
+    pub paint_props: ObjectPaintProperties,
+}
+
+/// A 2D scene, with everything needed to render it.
+pub struct Scene2D {
+    /// Estimated bounding box of all data. Accumulated.
+    pub bbox: Rect,
+    pub legends: Legends,
+
+    pub images: Vec<Image>,
+    pub boxes: Vec<Box2D>,
+    pub line_segments: Vec<LineSegments2D>,
+    pub points: Vec<Point2D>,
+}
+
+impl Default for Scene2D {
+    fn default() -> Self {
+        Self {
+            bbox: Rect::NOTHING,
+            legends: Default::default(),
+            images: Default::default(),
+            boxes: Default::default(),
+            line_segments: Default::default(),
+            points: Default::default(),
+        }
+    }
+}
+
+impl Scene2D {
+    /// Loads all 2D objects into the scene according to the given query.
+    ///
+    /// In addition to the query, we also pass in the 2D state from last frame, so that we can
+    /// compute custom paint properties for hovered items.
+    pub(crate) fn load_objects(
+        &mut self,
+        ctx: &mut ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+        state: &View2DState,
+    ) {
+        crate::profile_function!();
+
+        // NOTE: 1 frame delay here!
+        let hovered = state
+            .hovered_instance
+            .as_ref()
+            .map_or(InstanceIdHash::NONE, InstanceId::hash);
+
+        self.load_legends(ctx, obj_tree_props, query); // before images!
+        self.load_images(ctx, obj_tree_props, query, hovered);
+        self.load_boxes(ctx, obj_tree_props, query, hovered);
+        self.load_points(ctx, obj_tree_props, query, hovered);
+        self.load_line_segments(ctx, obj_tree_props, query, hovered);
+    }
+
+    fn load_legends(
+        &mut self,
+        ctx: &mut ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+    ) {
+        crate::profile_function!();
+
+        for (_obj_type, obj_path, obj_store) in
+            query.iter_object_stores(ctx.log_db, obj_tree_props, &[ObjectType::ClassDescription])
+        {
+            visit_type_data_2(
+                obj_store,
+                &FieldName::from("id"),
+                &query.time_query,
+                ("label", "color"),
+                |_instance_index: Option<&IndexHash>,
+                 _time: i64,
+                 msg_id: &MsgId,
+                 id: &i32,
+                 label: Option<&String>,
+                 color: Option<&[u8; 4]>| {
+                    let cdm = self.legends.0.entry(obj_path.clone()).or_insert_with(|| {
+                        Arc::new(ClassDescriptionMap {
+                            msg_id: *msg_id,
+                            map: Default::default(),
+                        })
+                    });
+
+                    Arc::get_mut(cdm).unwrap().map.insert(
+                        *id,
+                        ClassDescription {
+                            label: label.map(|s| s.clone().into()),
+                            color: color.cloned(),
+                        },
+                    );
+                },
+            );
+        }
+    }
+
+    fn load_images(
+        &mut self,
+        ctx: &mut ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+        hovered: InstanceIdHash,
+    ) {
+        crate::profile_function!();
+
+        let images = query
+            .iter_object_stores(ctx.log_db, obj_tree_props, &[ObjectType::Image])
+            .flat_map(|(_obj_type, obj_path, obj_store)| {
+                let mut batch = Vec::new();
+                visit_type_data_4(
+                    obj_store,
+                    &FieldName::from("tensor"),
+                    &query.time_query,
+                    ("_visible", "color", "meter", "legend"),
+                    |instance_index: Option<&IndexHash>,
+                     _time: i64,
+                     msg_id: &MsgId,
+                     tensor: &re_log_types::Tensor,
+                     visible: Option<&bool>,
+                     color: Option<&[u8; 4]>,
+                     meter: Option<&f32>,
+                     legend: Option<&ObjPath>| {
+                        let visible = *visible.unwrap_or(&true);
+                        let two_or_three_dims = 2 <= tensor.shape.len() && tensor.shape.len() <= 3;
+                        if !visible || !two_or_three_dims {
+                            return;
+                        }
+
+                        let instance_index = instance_index.copied().unwrap_or(IndexHash::NONE);
+
+                        let image = Image {
+                            msg_id: *msg_id,
+                            obj_path: obj_path.clone(),
+                            instance_hash: InstanceIdHash::from_path_and_index(
+                                obj_path,
+                                instance_index,
+                            ),
+                            tensor: tensor.clone(), // shallow
+                            meter: meter.copied(),
+                            legend: self.legends.find(legend),
+                            paint_props: paint_properties(
+                                ctx,
+                                &hovered,
+                                obj_path,
+                                instance_index,
+                                color.copied(),
+                                DefaultColor::White,
+                                &None,
+                            ),
+                        };
+
+                        batch.push(image);
+                    },
+                );
+                batch
+            });
+
+        self.images.extend(images);
+
+        for image in &self.images {
+            let [h, w] = [image.tensor.shape[0].size, image.tensor.shape[1].size];
+            self.bbox.extend_with(Pos2::ZERO);
+            self.bbox.extend_with(pos2(w as _, h as _));
+        }
+    }
+
+    fn load_boxes(
+        &mut self,
+        ctx: &mut ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+        hovered: InstanceIdHash,
+    ) {
+        crate::profile_function!();
+
+        let boxes = query
+            .iter_object_stores(ctx.log_db, obj_tree_props, &[ObjectType::BBox2D])
+            .flat_map(|(_obj_type, obj_path, obj_store)| {
+                let mut batch = Vec::new();
+                visit_type_data_4(
+                    obj_store,
+                    &FieldName::from("bbox"),
+                    &query.time_query,
+                    ("_visible", "color", "stroke_width", "label"),
+                    |instance_index: Option<&IndexHash>,
+                     _time: i64,
+                     _msg_id: &MsgId,
+                     bbox: &re_log_types::BBox2D,
+                     visible: Option<&bool>,
+                     color: Option<&[u8; 4]>,
+                     stroke_width: Option<&f32>,
+                     label: Option<&String>| {
+                        let visible = *visible.unwrap_or(&true);
+                        if !visible {
+                            return;
+                        }
+
+                        let instance_index = instance_index.copied().unwrap_or(IndexHash::NONE);
+                        let stroke_width = stroke_width.copied();
+
+                        let paint_props = paint_properties(
+                            ctx,
+                            &hovered,
+                            obj_path,
+                            instance_index,
+                            color.copied(),
+                            DefaultColor::Random,
+                            &stroke_width,
+                        );
+
+                        batch.push(Box2D {
+                            instance_hash: InstanceIdHash::from_path_and_index(
+                                obj_path,
+                                instance_index,
+                            ),
+                            bbox: bbox.clone(),
+                            stroke_width,
+                            label: label.map(ToOwned::to_owned),
+                            paint_props,
+                        });
+                    },
+                );
+                batch
+            });
+
+        self.boxes.extend(boxes);
+
+        for bbox in &self.boxes {
+            self.bbox.extend_with(bbox.bbox.min.into());
+            self.bbox.extend_with(bbox.bbox.max.into());
+        }
+    }
+
+    fn load_points(
+        &mut self,
+        ctx: &mut ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+        hovered: InstanceIdHash,
+    ) {
+        crate::profile_function!();
+
+        let points = query
+            .iter_object_stores(ctx.log_db, obj_tree_props, &[ObjectType::Point2D])
+            .flat_map(|(_obj_type, obj_path, obj_store)| {
+                let mut batch = Vec::new();
+                visit_type_data_3(
+                    obj_store,
+                    &FieldName::from("pos"),
+                    &query.time_query,
+                    ("_visible", "color", "radius"),
+                    |instance_index: Option<&IndexHash>,
+                     _time: i64,
+                     _msg_id: &MsgId,
+                     pos: &[f32; 2],
+                     visible: Option<&bool>,
+                     color: Option<&[u8; 4]>,
+                     radius: Option<&f32>| {
+                        let visible = *visible.unwrap_or(&true);
+                        if !visible {
+                            return;
+                        }
+
+                        let instance_index = instance_index.copied().unwrap_or(IndexHash::NONE);
+
+                        let paint_props = paint_properties(
+                            ctx,
+                            &hovered,
+                            obj_path,
+                            instance_index,
+                            color.copied(),
+                            DefaultColor::Random,
+                            &None,
+                        );
+
+                        batch.push(Point2D {
+                            instance_hash: InstanceIdHash::from_path_and_index(
+                                obj_path,
+                                instance_index,
+                            ),
+                            pos: Pos2::new(pos[0], pos[1]),
+                            radius: radius.copied(),
+                            paint_props,
+                        });
+                    },
+                );
+                batch
+            });
+
+        self.points.extend(points);
+
+        for point in &self.points {
+            self.bbox.extend_with(point.pos);
+        }
+    }
+
+    fn load_line_segments(
+        &mut self,
+        ctx: &mut ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+        hovered: InstanceIdHash,
+    ) {
+        crate::profile_function!();
+
+        let segments = query
+            .iter_object_stores(ctx.log_db, obj_tree_props, &[ObjectType::LineSegments2D])
+            .flat_map(|(_obj_type, obj_path, obj_store)| {
+                let mut batch = Vec::new();
+                visit_type_data_3(
+                    obj_store,
+                    &FieldName::from("points"),
+                    &query.time_query,
+                    ("_visible", "color", "stroke_width"),
+                    |instance_index: Option<&IndexHash>,
+                     _time: i64,
+                     _msg_id: &MsgId,
+                     points: &DataVec,
+                     visible: Option<&bool>,
+                     color: Option<&[u8; 4]>,
+                     stroke_width: Option<&f32>| {
+                        let visible = *visible.unwrap_or(&true);
+                        if !visible {
+                            return;
+                        }
+
+                        let Some(points) = points.as_vec_of_vec2("LineSegments2D::points")
+                                else { return };
+
+                        let instance_index = instance_index.copied().unwrap_or(IndexHash::NONE);
+                        let stroke_width = stroke_width.copied();
+
+                        let paint_props = paint_properties(
+                            ctx,
+                            &hovered,
+                            obj_path,
+                            instance_index,
+                            color.copied(),
+                            DefaultColor::Random,
+                            &None,
+                        );
+
+                        batch.push(LineSegments2D {
+                            instance_hash: InstanceIdHash::from_path_and_index(
+                                obj_path,
+                                instance_index,
+                            ),
+                            points: points.iter().map(|p| Pos2::new(p[0], p[1])).collect(),
+                            stroke_width,
+                            paint_props,
+                        });
+                    },
+                );
+                batch
+            });
+
+        self.line_segments.extend(segments);
+
+        for segment in &self.line_segments {
+            for &point in &segment.points {
+                self.bbox.extend_with(point);
+            }
+        }
+    }
+}
+
+impl Scene2D {
+    pub fn is_empty(&self) -> bool {
+        let Self {
+            bbox: _,
+            legends: _,
+            images,
+            boxes: bboxes,
+            line_segments,
+            points,
+        } = self;
+
+        images.is_empty() && bboxes.is_empty() && line_segments.is_empty() && points.is_empty()
+    }
+}
+
+// ---
+
+pub struct ObjectPaintProperties {
+    pub is_hovered: bool,
+    pub bg_stroke: Stroke,
+    pub fg_stroke: Stroke,
+}
+
+impl ObjectPaintProperties {
+    pub fn boost_radius_on_hover(&self, r: f32) -> f32 {
+        if self.is_hovered {
+            2.0 * r
+        } else {
+            r
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+enum DefaultColor {
+    White,
+    Random,
+}
+
+fn paint_properties(
+    ctx: &mut ViewerContext<'_>,
+    hovered: &InstanceIdHash,
+    obj_path: &ObjPath,
+    instance_index: IndexHash,
+    color: Option<[u8; 4]>,
+    default_color: DefaultColor,
+    stroke_width: &Option<f32>,
+) -> ObjectPaintProperties {
+    let bg_color = Color32::from_black_alpha(196);
+    let color = color.map_or_else(
+        || match default_color {
+            DefaultColor::White => Color32::WHITE,
+            DefaultColor::Random => {
+                let [r, g, b] = ctx.random_color(obj_path);
+                Color32::from_rgb(r, g, b)
+            }
+        },
+        to_egui_color,
+    );
+    let is_hovered = &InstanceIdHash::from_path_and_index(obj_path, instance_index) == hovered;
+    let fg_color = if is_hovered { Color32::WHITE } else { color };
+    let stroke_width = stroke_width.unwrap_or(1.5);
+    let stoke_width = if is_hovered {
+        2.0 * stroke_width
+    } else {
+        stroke_width
+    };
+    let bg_stroke = Stroke::new(stoke_width + 2.0, bg_color);
+    let fg_stroke = Stroke::new(stoke_width, fg_color);
+
+    ObjectPaintProperties {
+        is_hovered,
+        bg_stroke,
+        fg_stroke,
+    }
+}
+
+fn to_egui_color([r, g, b, a]: [u8; 4]) -> Color32 {
+    Color32::from_rgba_unmultiplied(r, g, b, a)
+}
diff --git a/crates/re_viewer/src/ui/view2d.rs b/crates/re_viewer/src/ui/view_2d/ui.rs
similarity index 79%
rename from crates/re_viewer/src/ui/view2d.rs
rename to crates/re_viewer/src/ui/view_2d/ui.rs
index 0882c4888bb5..6607904b0f67 100644
--- a/crates/re_viewer/src/ui/view2d.rs
+++ b/crates/re_viewer/src/ui/view_2d/ui.rs
@@ -1,17 +1,22 @@
 use eframe::{emath::RectTransform, epaint::text::TextWrapping};
-use egui::*;
+use egui::{
+    epaint, pos2, vec2, Align, Align2, Color32, NumExt as _, Pos2, Rect, Response, ScrollArea,
+    Shape, TextFormat, TextStyle, Vec2,
+};
+use re_data_store::{InstanceId, InstanceIdHash, ObjPath};
 
-use re_data_store::{InstanceId, InstanceIdHash};
-use re_log_types::*;
+use crate::{misc::HoveredSpace, Selection, ViewerContext};
 
-use crate::{legend::find_legend, misc::HoveredSpace, Selection, ViewerContext};
+use super::{show_zoomed_image_region_tooltip, Box2D, Image, LineSegments2D, Point2D, Scene2D};
+
+// ---
 
 #[derive(Clone, serde::Deserialize, serde::Serialize)]
 #[serde(default)]
-pub(crate) struct State2D {
+pub struct View2DState {
     /// What the mouse is hovering (from previous frame)
     #[serde(skip)]
-    hovered_instance: Option<InstanceId>,
+    pub hovered_instance: Option<InstanceId>,
 
     /// Estimated bounding box of all data. Accumulated.
     ///
@@ -26,7 +31,7 @@ pub(crate) struct State2D {
 
 #[derive(Clone, Copy)]
 /// Sub-state specific to the Zoom/Scale/Pan engine
-enum ZoomState {
+pub enum ZoomState {
     Auto,
     Scaled {
         /// Number of ui points per scene unit
@@ -44,7 +49,7 @@ impl Default for ZoomState {
     }
 }
 
-impl Default for State2D {
+impl Default for View2DState {
     fn default() -> Self {
         Self {
             hovered_instance: Default::default(),
@@ -54,7 +59,7 @@ impl Default for State2D {
     }
 }
 
-impl State2D {
+impl View2DState {
     /// Determine the optimal sub-region and size based on the `ZoomState` and
     /// available size. This will generally be used to construct the painter and
     /// subsequent transforms
@@ -213,9 +218,9 @@ impl State2D {
 pub(crate) fn view_2d(
     ctx: &mut ViewerContext<'_>,
     ui: &mut egui::Ui,
-    state: &mut State2D,
+    state: &mut View2DState,
     space: Option<&ObjPath>,
-    objects: &re_data_store::Objects<'_>, // Note: only the objects that belong to this space
+    scene: &Scene2D,
 ) -> egui::Response {
     crate::profile_function!();
 
@@ -241,7 +246,7 @@ pub(crate) fn view_2d(
         .auto_shrink([false, false]);
 
     let scroll_out = scroll_area.show(ui, |ui| {
-        view_2d_scrollable(desired_size, available_size, ctx, ui, state, space, objects)
+        view_2d_scrollable(desired_size, available_size, ctx, ui, state, space, scene)
     });
 
     // Update the scroll area based on the computed offset
@@ -256,14 +261,11 @@ fn view_2d_scrollable(
     available_size: Vec2,
     ctx: &mut ViewerContext<'_>,
     ui: &mut egui::Ui,
-    state: &mut State2D,
+    state: &mut View2DState,
     space: Option<&ObjPath>,
-    objects: &re_data_store::Objects<'_>, // Note: only the objects that belong to this space
+    scene: &Scene2D,
 ) -> egui::Response {
-    state.scene_bbox_accum = state
-        .scene_bbox_accum
-        .union(crate::misc::calc_bbox_2d(objects));
-
+    state.scene_bbox_accum = state.scene_bbox_accum.union(scene.bbox);
     let scene_bbox = state.scene_bbox_accum;
 
     let (mut response, painter) = ui.allocate_painter(desired_size, egui::Sense::click_and_drag());
@@ -272,18 +274,22 @@ fn view_2d_scrollable(
     let ui_from_space = egui::emath::RectTransform::from_to(scene_bbox, response.rect);
     let space_from_ui = ui_from_space.inverse();
 
-    // ------------------------------------------------------------------------
     state.update(&response, space_from_ui, available_size);
 
     // ------------------------------------------------------------------------
+
     if let Some(instance_id) = &state.hovered_instance {
         if response.clicked() {
             ctx.rec_cfg.selection = Selection::Instance(instance_id.clone());
         }
-        egui::containers::popup::show_tooltip_at_pointer(ui.ctx(), Id::new("2d_tooltip"), |ui| {
-            ctx.instance_id_button(ui, instance_id);
-            crate::ui::data_ui::view_instance(ctx, ui, instance_id, crate::ui::Preview::Small);
-        });
+        egui::containers::popup::show_tooltip_at_pointer(
+            ui.ctx(),
+            egui::Id::new("2d_tooltip"),
+            |ui| {
+                ctx.instance_id_button(ui, instance_id);
+                crate::ui::data_ui::view_instance(ctx, ui, instance_id, crate::ui::Preview::Small);
+            },
+        );
     }
 
     // ------------------------------------------------------------------------
@@ -297,7 +303,7 @@ fn view_2d_scrollable(
 
     // ------------------------------------------------------------------------
 
-    let total_num_images = objects.image.len();
+    let total_num_images = scene.images.len();
 
     let hover_radius = 5.0; // TODO(emilk): from egui?
 
@@ -305,10 +311,10 @@ fn view_2d_scrollable(
     let mut closest_instance_id_hash = InstanceIdHash::NONE;
     let pointer_pos = response.hover_pos();
 
-    let mut check_hovering = |props: &re_data_store::InstanceProps<'_>, dist: f32| {
+    let mut check_hovering = |instance_hash, dist: f32| {
         if dist <= closest_dist {
             closest_dist = dist;
-            closest_instance_id_hash = InstanceIdHash::from_props(props);
+            closest_instance_id_hash = instance_hash;
         }
     };
 
@@ -319,30 +325,18 @@ fn view_2d_scrollable(
         .as_ref()
         .map_or(InstanceIdHash::NONE, InstanceId::hash);
 
-    for (image_idx, (props, obj)) in objects.image.iter().enumerate() {
-        let re_data_store::Image {
+    for (image_idx, img) in scene.images.iter().enumerate() {
+        let Image {
+            msg_id,
+            obj_path,
+            instance_hash,
             tensor,
             meter,
+            paint_props,
             legend,
-        } = obj;
-        let paint_props = paint_properties(
-            ctx,
-            &hovered_instance_id_hash,
-            props,
-            DefaultColor::White,
-            &None,
-        );
-
-        if tensor.shape.len() < 2 {
-            continue; // not an image. don't know how to display this!
-        }
+        } = img;
 
-        let legend = find_legend(*legend, objects);
-
-        let tensor_view = ctx
-            .cache
-            .image
-            .get_view_with_legend(props.msg_id, tensor, &legend);
+        let tensor_view = ctx.cache.image.get_view_with_legend(msg_id, tensor, legend);
 
         let texture_id = tensor_view.retained_img.texture_id(ui.ctx());
 
@@ -368,10 +362,12 @@ fn view_2d_scrollable(
         if let Some(pointer_pos) = pointer_pos {
             let dist = rect_in_ui.distance_sq_to_pos(pointer_pos).sqrt();
             let dist = dist.at_least(hover_radius); // allow stuff on top of us to "win"
-            check_hovering(props, dist);
+            check_hovering(*instance_hash, dist);
 
-            if hovered_instance_id_hash.is_instance(props) && rect_in_ui.contains(pointer_pos) {
-                response = crate::ui::image_ui::show_zoomed_image_region_tooltip(
+            if hovered_instance_id_hash.is_instance(obj_path, instance_hash.instance_index_hash)
+                && rect_in_ui.contains(pointer_pos)
+            {
+                response = show_zoomed_image_region_tooltip(
                     ui,
                     response,
                     &tensor_view,
@@ -394,19 +390,14 @@ fn view_2d_scrollable(
         }
     }
 
-    for (props, obj) in objects.bbox2d.iter() {
-        let re_data_store::BBox2D {
+    for bbox in &scene.boxes {
+        let Box2D {
+            instance_hash,
             bbox,
-            stroke_width,
+            stroke_width: _,
             label,
-        } = obj;
-        let paint_props = paint_properties(
-            ctx,
-            &hovered_instance_id_hash,
-            props,
-            DefaultColor::Random,
-            stroke_width,
-        );
+            paint_props,
+        } = bbox;
 
         let rect_in_ui =
             ui_from_space.transform_rect(Rect::from_min_max(bbox.min.into(), bbox.max.into()));
@@ -432,13 +423,13 @@ fn view_2d_scrollable(
             let wrap_width = (rect_in_ui.width() - 4.0).at_least(60.0);
             let font_id = TextStyle::Body.resolve(ui.style());
             let galley = ui.fonts().layout_job({
-                text::LayoutJob {
-                    sections: vec![text::LayoutSection {
+                egui::text::LayoutJob {
+                    sections: vec![egui::text::LayoutSection {
                         leading_space: 0.0,
                         byte_range: 0..label.len(),
                         format: TextFormat::simple(font_id, paint_props.fg_stroke.color),
                     }],
-                    text: (*label).to_owned(),
+                    text: (*label).clone(),
                     wrap: TextWrapping {
                         max_width: wrap_width,
                         ..Default::default()
@@ -465,21 +456,16 @@ fn view_2d_scrollable(
             }
         }
 
-        check_hovering(props, hover_dist);
+        check_hovering(*instance_hash, hover_dist);
     }
 
-    for (props, obj) in objects.line_segments2d.iter() {
-        let re_data_store::LineSegments2D {
+    for segments in &scene.line_segments {
+        let LineSegments2D {
+            instance_hash,
             points,
-            stroke_width,
-        } = obj;
-        let paint_props = paint_properties(
-            ctx,
-            &hovered_instance_id_hash,
-            props,
-            DefaultColor::Random,
-            stroke_width,
-        );
+            stroke_width: _,
+            paint_props,
+        } = segments;
 
         let mut min_dist_sq = f32::INFINITY;
 
@@ -496,23 +482,21 @@ fn view_2d_scrollable(
             }
         }
 
-        check_hovering(props, min_dist_sq.sqrt());
+        check_hovering(*instance_hash, min_dist_sq.sqrt());
     }
 
-    for (props, obj) in objects.point2d.iter() {
-        let re_data_store::Point2D { pos, radius } = obj;
-        let paint_props = paint_properties(
-            ctx,
-            &hovered_instance_id_hash,
-            props,
-            DefaultColor::Random,
-            &None,
-        );
+    for point in &scene.points {
+        let Point2D {
+            instance_hash,
+            pos,
+            radius,
+            paint_props,
+        } = point;
 
         let radius = radius.unwrap_or(1.5);
         let radius = paint_props.boost_radius_on_hover(radius);
 
-        let pos_in_ui = ui_from_space.transform_pos(pos2(pos[0], pos[1]));
+        let pos_in_ui = ui_from_space.transform_pos(*pos);
         shapes.push(Shape::circle_filled(
             pos_in_ui,
             radius + 1.0,
@@ -525,7 +509,7 @@ fn view_2d_scrollable(
         ));
 
         if let Some(pointer_pos) = pointer_pos {
-            check_hovering(props, pos_in_ui.distance(pointer_pos));
+            check_hovering(*instance_hash, pos_in_ui.distance(pointer_pos));
         }
     }
 
@@ -625,67 +609,3 @@ fn show_projections_from_3d_space(
         }
     }
 }
-
-// ------------------------------------------------------------------------
-
-struct ObjectPaintProperties {
-    is_hovered: bool,
-    bg_stroke: Stroke,
-    fg_stroke: Stroke,
-}
-
-impl ObjectPaintProperties {
-    pub fn boost_radius_on_hover(&self, r: f32) -> f32 {
-        if self.is_hovered {
-            2.0 * r
-        } else {
-            r
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-enum DefaultColor {
-    White,
-    Random,
-}
-
-fn paint_properties(
-    ctx: &mut ViewerContext<'_>,
-    hovered: &InstanceIdHash,
-    props: &re_data_store::InstanceProps<'_>,
-    default_color: DefaultColor,
-    stroke_width: &Option<f32>,
-) -> ObjectPaintProperties {
-    let bg_color = Color32::from_black_alpha(196);
-    let color = props.color.map_or_else(
-        || match default_color {
-            DefaultColor::White => Color32::WHITE,
-            DefaultColor::Random => {
-                let [r, g, b] = ctx.random_color(props);
-                Color32::from_rgb(r, g, b)
-            }
-        },
-        to_egui_color,
-    );
-    let is_hovered = &InstanceIdHash::from_props(props) == hovered;
-    let fg_color = if is_hovered { Color32::WHITE } else { color };
-    let stroke_width = stroke_width.unwrap_or(1.5);
-    let stoke_width = if is_hovered {
-        2.0 * stroke_width
-    } else {
-        stroke_width
-    };
-    let bg_stroke = Stroke::new(stoke_width + 2.0, bg_color);
-    let fg_stroke = Stroke::new(stoke_width, fg_color);
-
-    ObjectPaintProperties {
-        is_hovered,
-        bg_stroke,
-        fg_stroke,
-    }
-}
-
-fn to_egui_color([r, g, b, a]: [u8; 4]) -> Color32 {
-    Color32::from_rgba_unmultiplied(r, g, b, a)
-}
diff --git a/crates/re_viewer/src/ui/view3d/eye.rs b/crates/re_viewer/src/ui/view_3d/eye.rs
similarity index 98%
rename from crates/re_viewer/src/ui/view3d/eye.rs
rename to crates/re_viewer/src/ui/view_3d/eye.rs
index 6fdd483a067c..9b735c9374b3 100644
--- a/crates/re_viewer/src/ui/view3d/eye.rs
+++ b/crates/re_viewer/src/ui/view_3d/eye.rs
@@ -4,8 +4,6 @@ use macaw::{vec3, IsoTransform, Mat4, Quat, Vec3};
 
 use super::SpaceCamera;
 
-pub const DEFAULT_FOV_Y: f32 = 55.0_f32 * std::f32::consts::TAU / 360.0;
-
 /// An eye in a 3D view.
 ///
 /// Note: we prefer the word "eye" to not confuse it with logged cameras.
@@ -18,11 +16,13 @@ pub struct Eye {
 }
 
 impl Eye {
+    pub const DEFAULT_FOV_Y: f32 = 55.0_f32 * std::f32::consts::TAU / 360.0;
+
     pub fn from_camera(space_cameras: &SpaceCamera) -> Option<Eye> {
         let fov_y = space_cameras
             .pinhole
             .and_then(|i| i.fov_y())
-            .unwrap_or(DEFAULT_FOV_Y);
+            .unwrap_or(Self::DEFAULT_FOV_Y);
 
         Some(Self {
             world_from_view: space_cameras.world_from_rub_view()?,
@@ -76,7 +76,7 @@ impl Eye {
 
 /// Note: we use "eye" so we don't confuse this with logged camera.
 #[derive(Clone, Copy, Debug, serde::Deserialize, serde::Serialize)]
-pub(crate) struct OrbitEye {
+pub struct OrbitEye {
     pub orbit_center: Vec3,
     pub orbit_radius: f32,
     pub world_from_view_rot: Quat,
diff --git a/crates/re_viewer/src/ui/view3d/glow_rendering/mod.rs b/crates/re_viewer/src/ui/view_3d/glow_rendering/mod.rs
similarity index 95%
rename from crates/re_viewer/src/ui/view3d/glow_rendering/mod.rs
rename to crates/re_viewer/src/ui/view_3d/glow_rendering/mod.rs
index 379488ee91e2..a5632f519006 100644
--- a/crates/re_viewer/src/ui/view3d/glow_rendering/mod.rs
+++ b/crates/re_viewer/src/ui/view_3d/glow_rendering/mod.rs
@@ -85,10 +85,10 @@ impl GpuScene {
         }
     }
 
-    pub fn set(&mut self, three_d: &three_d::Context, scene: &Scene) {
+    pub fn set(&mut self, three_d: &three_d::Context, scene: &Scene3D) {
         crate::profile_function!();
 
-        let Scene {
+        let Scene3D {
             points,
             line_segments,
             meshes,
@@ -247,7 +247,7 @@ fn default_material() -> three_d::PhysicalMaterial {
     }
 }
 
-fn allocate_points(points: &[Point]) -> sphere_renderer::SphereInstances {
+fn allocate_points(points: &[Point3D]) -> sphere_renderer::SphereInstances {
     crate::profile_function!();
     use three_d::*;
 
@@ -270,7 +270,7 @@ fn allocate_points(points: &[Point]) -> sphere_renderer::SphereInstances {
     }
 }
 
-fn allocate_line_segments(line_segments: &[LineSegments]) -> three_d::Instances {
+fn allocate_line_segments(line_segments: &[LineSegments3D]) -> three_d::Instances {
     crate::profile_function!();
     use three_d::*;
 
@@ -280,8 +280,8 @@ fn allocate_line_segments(line_segments: &[LineSegments]) -> three_d::Instances
     let mut colors = vec![];
 
     for line_segments in line_segments {
-        let LineSegments {
-            instance_id: _,
+        let LineSegments3D {
+            instance_id_hash: _,
             segments,
             radius,
             color,
@@ -291,18 +291,13 @@ fn allocate_line_segments(line_segments: &[LineSegments]) -> three_d::Instances
             .scene()
             .expect("size should have been translated to scene-coordinates");
 
-        for &[p0, p1] in segments {
+        for &(start, end) in segments {
             rotations.push(three_d::Quat::from(mint::Quaternion::from(
-                glam::Quat::from_rotation_arc(
-                    glam::Vec3::X,
-                    (glam::Vec3::from(p1) - glam::Vec3::from(p0)).normalize(),
-                ),
+                glam::Quat::from_rotation_arc(glam::Vec3::X, (end - start).normalize()),
             )));
 
-            let p0 = vec3(p0[0], p0[1], p0[2]);
-            let p1 = vec3(p1[0], p1[1], p1[2]);
-            translations.push(p0);
-            scales.push(vec3((p0 - p1).magnitude(), radius, radius));
+            translations.push(vec3(start.x, start.y, start.z));
+            scales.push(vec3((start - end).length(), radius, radius));
             colors.push(color_to_three_d(*color));
         }
     }
@@ -320,7 +315,7 @@ pub fn paint_with_three_d(
     rendering: &mut RenderingContext,
     eye: &Eye,
     info: &egui::PaintCallbackInfo,
-    scene: &Scene,
+    scene: &Scene3D,
     dark_mode: bool,
     show_axes: bool, // TODO(emilk): less bool arguments
     painter: &egui_glow::Painter,
diff --git a/crates/re_viewer/src/ui/view3d/glow_rendering/sphere_renderer.rs b/crates/re_viewer/src/ui/view_3d/glow_rendering/sphere_renderer.rs
similarity index 100%
rename from crates/re_viewer/src/ui/view3d/glow_rendering/sphere_renderer.rs
rename to crates/re_viewer/src/ui/view_3d/glow_rendering/sphere_renderer.rs
diff --git a/crates/re_viewer/src/ui/view3d/mesh_cache.rs b/crates/re_viewer/src/ui/view_3d/mesh_cache.rs
similarity index 100%
rename from crates/re_viewer/src/ui/view3d/mesh_cache.rs
rename to crates/re_viewer/src/ui/view_3d/mesh_cache.rs
diff --git a/crates/re_viewer/src/ui/view_3d/mod.rs b/crates/re_viewer/src/ui/view_3d/mod.rs
new file mode 100644
index 000000000000..57312c847d61
--- /dev/null
+++ b/crates/re_viewer/src/ui/view_3d/mod.rs
@@ -0,0 +1,19 @@
+mod eye;
+pub use self::eye::{Eye, OrbitEye};
+
+mod mesh_cache;
+pub use mesh_cache::CpuMeshCache;
+
+mod space_camera;
+pub use self::space_camera::SpaceCamera;
+
+mod scene;
+pub use self::scene::{
+    Label3D, LineSegments3D, MeshSource, MeshSourceData, Point3D, Scene3D, Size,
+};
+
+mod ui;
+pub(crate) use self::ui::{view_3d, SpaceSpecs, View3DState};
+
+#[cfg(feature = "glow")]
+mod glow_rendering;
diff --git a/crates/re_viewer/src/ui/view3d/scene.rs b/crates/re_viewer/src/ui/view_3d/scene.rs
similarity index 56%
rename from crates/re_viewer/src/ui/view3d/scene.rs
rename to crates/re_viewer/src/ui/view_3d/scene.rs
index 88191e9dfb82..4fb718a5d3bf 100644
--- a/crates/re_viewer/src/ui/view3d/scene.rs
+++ b/crates/re_viewer/src/ui/view_3d/scene.rs
@@ -1,13 +1,16 @@
 use std::sync::Arc;
 
-use egui::util::hash;
 use egui::NumExt as _;
 use glam::{vec3, Vec3};
 use itertools::Itertools as _;
 
-use re_data_store::InstanceIdHash;
+use re_data_store::query::{visit_type_data_2, visit_type_data_3, visit_type_data_4};
+use re_data_store::{FieldName, InstanceIdHash, ObjPath, ObjectTreeProperties};
+use re_log_types::{DataVec, IndexHash, MsgId, ObjectType};
 
 use crate::misc::mesh_loader::CpuMesh;
+use crate::misc::Caches;
+use crate::ui::SceneQuery;
 use crate::{math::line_segment_distance_sq_to_point_2d, misc::ViewerContext};
 
 #[cfg(feature = "wgpu")]
@@ -23,7 +26,7 @@ use super::{eye::Eye, SpaceCamera};
 /// * If positive, this is in scene units.
 /// * If negative, this is in ui points.
 /// * If NaN, auto-size it.
-/// Resolved in [`Scene::finalize_sizes_and_colors`].
+/// Resolved in [`Scene3D::finalize_sizes_and_colors`].
 #[derive(Clone, Copy, Debug)]
 pub struct Size(pub f32);
 
@@ -89,16 +92,16 @@ impl std::ops::MulAssign<f32> for Size {
 
 // ----------------------------------------------------------------------------
 
-pub struct Point {
-    pub instance_id: InstanceIdHash,
-    pub pos: [f32; 3],
+pub struct Point3D {
+    pub instance_id_hash: InstanceIdHash,
+    pub pos: Vec3,
     pub radius: Size,
     pub color: [u8; 4],
 }
 
-pub struct LineSegments {
-    pub instance_id: InstanceIdHash,
-    pub segments: Vec<[[f32; 3]; 2]>,
+pub struct LineSegments3D {
+    pub instance_id_hash: InstanceIdHash,
+    pub segments: Vec<(Vec3, Vec3)>,
     pub radius: Size,
     pub color: [u8; 4],
     #[cfg(feature = "wgpu")]
@@ -112,7 +115,7 @@ pub enum MeshSourceData {
 }
 
 pub struct MeshSource {
-    pub instance_id: InstanceIdHash,
+    pub instance_id_hash: InstanceIdHash,
     pub mesh_id: u64,
     // TODO(andreas): Make this Conformal3 once glow is gone?
     pub world_from_mesh: macaw::Affine3A,
@@ -120,25 +123,28 @@ pub struct MeshSource {
     pub tint: Option<[u8; 4]>,
 }
 
-pub struct Label {
+pub struct Label3D {
     pub(crate) text: String,
     /// Origin of the label
     pub(crate) origin: Vec3,
 }
 
 #[derive(Default)]
-pub struct Scene {
-    pub points: Vec<Point>,
-    pub line_segments: Vec<LineSegments>,
+pub struct Scene3D {
+    pub points: Vec<Point3D>,
+    pub line_segments: Vec<LineSegments3D>,
     pub meshes: Vec<MeshSource>,
-    pub labels: Vec<Label>,
+    pub labels: Vec<Label3D>,
 }
 
-impl Scene {
-    pub(crate) fn from_objects(
+impl Scene3D {
+    /// Loads all 3D objects into the scene according to the given query.
+    pub(crate) fn load_objects(
+        &mut self,
         ctx: &mut ViewerContext<'_>,
-        objects: &re_data_store::Objects<'_>,
-    ) -> Self {
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+    ) {
         crate::profile_function!();
 
         // hack because three-d handles colors wrong. TODO(emilk): fix three-d
@@ -147,12 +153,11 @@ impl Scene {
             .collect_vec();
         let gamma_lut = &gamma_lut[0..256]; // saves us bounds checks later.
 
-        let object_color = |ctx: &mut ViewerContext<'_>,
-                            props: &re_data_store::InstanceProps<'_>| {
-            let [r, g, b, a] = if let Some(color) = props.color {
+        let object_color = |caches: &mut Caches, color: Option<&[u8; 4]>, obj_path: &ObjPath| {
+            let [r, g, b, a] = if let Some(color) = color.copied() {
                 color
             } else {
-                let [r, g, b] = ctx.random_color(props);
+                let [r, g, b] = caches.random_color(obj_path);
                 [r, g, b, 255]
             };
 
@@ -162,136 +167,283 @@ impl Scene {
             [r, g, b, a]
         };
 
-        let mut scene = Scene::default();
+        self.load_points(ctx, obj_tree_props, query, object_color);
+        self.load_boxes(ctx, obj_tree_props, query, object_color);
+        self.load_segments(ctx, obj_tree_props, query, object_color);
+        self.load_arrows(ctx, obj_tree_props, query, object_color);
+        self.load_meshes(ctx, obj_tree_props, query);
+    }
 
-        {
-            crate::profile_scope!("point3d");
-            scene.points.reserve(objects.point3d.len());
-            for (props, obj) in objects.point3d.iter() {
-                let re_data_store::Point3D { pos, radius } = *obj;
-                scene.points.push(Point {
-                    instance_id: InstanceIdHash::from_props(props),
-                    pos: *pos,
-                    radius: radius.map_or(Size::AUTO, Size::new_scene),
-                    color: object_color(ctx, props),
-                });
-            }
-        }
+    fn load_points(
+        &mut self,
+        ctx: &mut ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+        mut object_color: impl FnMut(&mut Caches, Option<&[u8; 4]>, &ObjPath) -> [u8; 4],
+    ) {
+        crate::profile_function!();
 
-        {
-            crate::profile_scope!("box3d");
-            for (props, obj) in objects.box3d.iter() {
-                let re_data_store::Box3D {
-                    obb,
-                    stroke_width,
-                    label,
-                } = obj;
-                let line_radius = stroke_width.map_or(Size::AUTO, |w| Size::new_scene(w / 2.0));
-                let color = object_color(ctx, props);
-                scene.add_box(
-                    InstanceIdHash::from_props(props),
-                    color,
-                    line_radius,
-                    *label,
-                    obb,
+        let points = query
+            .iter_object_stores(ctx.log_db, obj_tree_props, &[ObjectType::Point3D])
+            .flat_map(|(_obj_type, obj_path, obj_store)| {
+                let mut batch = Vec::new();
+                visit_type_data_3(
+                    obj_store,
+                    &FieldName::from("pos"),
+                    &query.time_query,
+                    ("_visible", "color", "radius"),
+                    |instance_index: Option<&IndexHash>,
+                     _time: i64,
+                     _msg_id: &MsgId,
+                     pos: &[f32; 3],
+                     visible: Option<&bool>,
+                     color: Option<&[u8; 4]>,
+                     radius: Option<&f32>| {
+                        if !*visible.unwrap_or(&true) {
+                            return;
+                        }
+
+                        let instance_index = instance_index.copied().unwrap_or(IndexHash::NONE);
+                        let instance_id_hash =
+                            InstanceIdHash::from_path_and_index(obj_path, instance_index);
+
+                        batch.push(Point3D {
+                            instance_id_hash,
+                            pos: Vec3::from_slice(pos),
+                            radius: radius.copied().map_or(Size::AUTO, Size::new_scene),
+                            color: object_color(ctx.cache, color, obj_path),
+                        });
+                    },
                 );
-            }
-        }
+                batch
+            });
 
-        {
-            crate::profile_scope!("path3d");
-            for (props, obj) in objects.path3d.iter() {
-                let re_data_store::Path3D {
-                    points,
-                    stroke_width,
-                } = obj;
-
-                let radius = stroke_width.map_or(Size::AUTO, |w| Size::new_scene(w / 2.0));
-                let color = object_color(ctx, props);
-
-                let segments = points
-                    .iter()
-                    .tuple_windows()
-                    .map(|(a, b)| [*a, *b])
-                    .collect();
-
-                scene.line_segments.push(LineSegments {
-                    instance_id: InstanceIdHash::from_props(props),
-                    segments,
-                    radius,
-                    color,
-                    #[cfg(feature = "wgpu")]
-                    flags: Default::default(),
-                });
-            }
-        }
+        self.points.extend(points);
+    }
 
-        {
-            crate::profile_scope!("line_segments3d");
-            for (props, obj) in objects.line_segments3d.iter() {
-                let re_data_store::LineSegments3D {
-                    points,
-                    stroke_width,
-                } = *obj;
-
-                let radius = stroke_width.map_or(Size::AUTO, |w| Size::new_scene(w / 2.0));
-                let color = object_color(ctx, props);
-
-                scene.line_segments.push(LineSegments {
-                    instance_id: InstanceIdHash::from_props(props),
-                    segments: bytemuck::allocation::pod_collect_to_vec(points),
-                    radius,
-                    color,
-                    #[cfg(feature = "wgpu")]
-                    flags: Default::default(),
-                });
-            }
-        }
+    fn load_boxes(
+        &mut self,
+        ctx: &mut ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+        mut object_color: impl FnMut(&mut Caches, Option<&[u8; 4]>, &ObjPath) -> [u8; 4],
+    ) {
+        crate::profile_function!();
 
+        for (_obj_type, obj_path, obj_store) in
+            query.iter_object_stores(ctx.log_db, obj_tree_props, &[ObjectType::Box3D])
         {
-            crate::profile_scope!("mesh3d");
-            for (props, obj) in objects.mesh3d.iter() {
-                let re_data_store::Mesh3D { mesh } = *obj;
-                let mesh_id = egui::util::hash(props.msg_id);
-                if let Some(cpu_mesh) = ctx.cache.cpu_mesh.load(
-                    mesh_id,
-                    &props.obj_path.to_string(),
-                    &MeshSourceData::Mesh3D(mesh.clone()),
-                    #[cfg(feature = "wgpu")]
-                    &mut ctx.render_ctx.mesh_manager,
-                    #[cfg(feature = "wgpu")]
-                    &mut ctx.render_ctx.texture_manager_2d,
-                ) {
-                    // TODO(emilk): props.color
-                    scene.meshes.push(MeshSource {
-                        instance_id: InstanceIdHash::from_props(props),
-                        mesh_id,
-                        world_from_mesh: Default::default(),
-                        cpu_mesh,
-                        tint: None,
-                    });
-                }
-            }
+            visit_type_data_4(
+                obj_store,
+                &FieldName::from("obb"),
+                &query.time_query,
+                ("_visible", "color", "stroke_width", "label"),
+                |instance_index: Option<&IndexHash>,
+                 _time: i64,
+                 _msg_id: &MsgId,
+                 obb: &re_log_types::Box3,
+                 visible: Option<&bool>,
+                 color: Option<&[u8; 4]>,
+                 stroke_width: Option<&f32>,
+                 label: Option<&String>| {
+                    if !*visible.unwrap_or(&true) {
+                        return;
+                    }
+
+                    let instance_index = instance_index.copied().unwrap_or(IndexHash::NONE);
+                    let line_radius = stroke_width.map_or(Size::AUTO, |w| Size::new_scene(w / 2.0));
+                    let color = object_color(ctx.cache, color, obj_path);
+
+                    self.add_box(
+                        InstanceIdHash::from_path_and_index(obj_path, instance_index),
+                        color,
+                        line_radius,
+                        label.map(|s| s.as_str()),
+                        obb,
+                    );
+                },
+            );
         }
+    }
+
+    /// Both `Path3D` and `LineSegments3D`.
+    fn load_segments(
+        &mut self,
+        ctx: &mut ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+        mut object_color: impl FnMut(&mut Caches, Option<&[u8; 4]>, &ObjPath) -> [u8; 4],
+    ) {
+        crate::profile_function!();
 
+        let segments = query
+            .iter_object_stores(
+                ctx.log_db,
+                obj_tree_props,
+                &[ObjectType::Path3D, ObjectType::LineSegments3D],
+            )
+            .flat_map(|(obj_type, obj_path, obj_store)| {
+                let mut batch = Vec::new();
+                visit_type_data_3(
+                    obj_store,
+                    &FieldName::from("points"),
+                    &query.time_query,
+                    ("_visible", "color", "stroke_width"),
+                    |instance_index: Option<&IndexHash>,
+                     _time: i64,
+                     _msg_id: &MsgId,
+                     points: &DataVec,
+                     visible: Option<&bool>,
+                     color: Option<&[u8; 4]>,
+                     stroke_width: Option<&f32>| {
+                        if !*visible.unwrap_or(&true) {
+                            return;
+                        }
+
+                        let what = match obj_type {
+                            ObjectType::Path3D => "Path3D::points",
+                            ObjectType::LineSegments3D => "LineSegments3D::points",
+                            _ => return,
+                        };
+                        let Some(points) = points.as_vec_of_vec3(what) else { return };
+
+                        let instance_index = instance_index.copied().unwrap_or(IndexHash::NONE);
+                        let instance_id_hash =
+                            InstanceIdHash::from_path_and_index(obj_path, instance_index);
+
+                        let radius = stroke_width.map_or(Size::AUTO, |w| Size::new_scene(w / 2.0));
+                        let color = object_color(ctx.cache, color, obj_path);
+
+                        let segments = points
+                            .iter()
+                            .tuple_windows()
+                            .map(|(a, b)| (Vec3::from_slice(a), Vec3::from_slice(b)))
+                            .collect();
+
+                        batch.push(LineSegments3D {
+                            instance_id_hash,
+                            segments,
+                            radius,
+                            color,
+                            #[cfg(feature = "wgpu")]
+                            flags: Default::default(),
+                        });
+                    },
+                );
+                batch
+            });
+
+        self.line_segments.extend(segments);
+    }
+
+    fn load_arrows(
+        &mut self,
+        ctx: &mut ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+        mut object_color: impl FnMut(&mut Caches, Option<&[u8; 4]>, &ObjPath) -> [u8; 4],
+    ) {
+        crate::profile_function!();
+
+        for (_obj_type, obj_path, obj_store) in
+            query.iter_object_stores(ctx.log_db, obj_tree_props, &[ObjectType::Arrow3D])
         {
-            crate::profile_scope!("arrow3d");
-            for (props, obj) in objects.arrow3d.iter() {
-                let re_data_store::Arrow3D {
-                    arrow,
-                    label,
-                    width_scale,
-                } = obj;
-                let width = width_scale.unwrap_or(1.0);
-                let color = object_color(ctx, props);
-                let instance_id = InstanceIdHash::from_props(props);
-                scene.add_arrow(ctx, instance_id, color, Some(width), *label, arrow);
-            }
+            visit_type_data_4(
+                obj_store,
+                &FieldName::from("arrow3d"),
+                &query.time_query,
+                ("_visible", "color", "width_scale", "label"),
+                |instance_index: Option<&IndexHash>,
+                 _time: i64,
+                 _msg_id: &MsgId,
+                 arrow: &re_log_types::Arrow3D,
+                 visible: Option<&bool>,
+                 color: Option<&[u8; 4]>,
+                 width_scale: Option<&f32>,
+                 label: Option<&String>| {
+                    if !*visible.unwrap_or(&true) {
+                        return;
+                    }
+
+                    let instance_index = instance_index.copied().unwrap_or(IndexHash::NONE);
+                    let instance_id_hash =
+                        InstanceIdHash::from_path_and_index(obj_path, instance_index);
+
+                    let width = width_scale.copied().unwrap_or(1.0);
+                    let color = object_color(ctx.cache, color, obj_path);
+                    self.add_arrow(
+                        ctx.cache,
+                        instance_id_hash,
+                        color,
+                        Some(width),
+                        label.map(|s| s.as_str()),
+                        arrow,
+                    );
+                },
+            );
         }
+    }
+
+    fn load_meshes(
+        &mut self,
+        ctx: &mut ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+    ) {
+        crate::profile_function!();
 
-        scene
+        let meshes = query
+            .iter_object_stores(ctx.log_db, obj_tree_props, &[ObjectType::Mesh3D])
+            .flat_map(|(_obj_type, obj_path, obj_store)| {
+                let mut batch = Vec::new();
+                visit_type_data_2(
+                    obj_store,
+                    &FieldName::from("mesh"),
+                    &query.time_query,
+                    ("_visible", "color"),
+                    |instance_index: Option<&IndexHash>,
+                     _time: i64,
+                     msg_id: &MsgId,
+                     mesh: &re_log_types::Mesh3D,
+                     visible: Option<&bool>,
+                     _color: Option<&[u8; 4]>| {
+                        if !*visible.unwrap_or(&true) {
+                            return;
+                        }
+
+                        let instance_index = instance_index.copied().unwrap_or(IndexHash::NONE);
+                        let mesh_id = egui::util::hash(msg_id);
+                        let Some(mesh) = ctx.cache.cpu_mesh.load(
+                                mesh_id,
+                                &obj_path.to_string(),
+                                &MeshSourceData::Mesh3D(mesh.clone()),
+                                #[cfg(feature = "wgpu")]
+                                &mut ctx.render_ctx.mesh_manager,
+                                #[cfg(feature = "wgpu")]
+                                &mut ctx.render_ctx.texture_manager_2d,
+                            )
+                            .map(|cpu_mesh| MeshSource {
+                                instance_id_hash: InstanceIdHash::from_path_and_index(
+                                    obj_path,
+                                    instance_index,
+                                ),
+                                mesh_id,
+                                world_from_mesh: Default::default(),
+                                cpu_mesh,
+                                tint: None,
+                            }) else { return };
+
+                        batch.push(mesh);
+                    },
+                );
+                batch
+            });
+
+        self.meshes.extend(meshes);
     }
 
+    // ---
+
     pub(super) fn add_cameras(
         &mut self,
         ctx: &mut ViewerContext<'_>,
@@ -332,7 +484,7 @@ impl Scene {
 
                     let scale = Vec3::splat(scale);
 
-                    let mesh_id = hash("camera_mesh");
+                    let mesh_id = egui::util::hash("camera_mesh");
                     let world_from_mesh = world_from_rub_view * glam::Affine3A::from_scale(scale);
 
                     if let Some(cpu_mesh) = ctx.cache.cpu_mesh.load(
@@ -345,7 +497,7 @@ impl Scene {
                         &mut ctx.render_ctx.texture_manager_2d,
                     ) {
                         self.meshes.push(MeshSource {
-                            instance_id,
+                            instance_id_hash: instance_id,
                             mesh_id,
                             world_from_mesh,
                             cpu_mesh,
@@ -366,9 +518,9 @@ impl Scene {
                     let axis_end = world_from_cam.transform_point3(scale * *dir);
                     let color = axis_color(axis_index);
 
-                    self.line_segments.push(LineSegments {
-                        instance_id,
-                        segments: vec![[cam_origin.into(), axis_end.into()]],
+                    self.line_segments.push(LineSegments3D {
+                        instance_id_hash: instance_id,
+                        segments: vec![(cam_origin, axis_end)],
                         radius,
                         color,
                         #[cfg(feature = "wgpu")]
@@ -432,13 +584,11 @@ impl Scene {
                     point.radius = default_point_radius;
                 }
                 if let Some(size_in_points) = point.radius.ui() {
-                    let dist_to_eye = eye_camera_plane
-                        .distance(Vec3::from(point.pos))
-                        .at_least(0.0);
+                    let dist_to_eye = eye_camera_plane.distance(point.pos).at_least(0.0);
                     point.radius =
                         Size::new_scene(dist_to_eye * size_in_points * point_size_at_one_meter);
                 }
-                if point.instance_id == hovered_instance_id_hash {
+                if point.instance_id_hash == hovered_instance_id_hash {
                     point.radius *= hover_size_boost;
                     point.color = HOVER_COLOR;
                 }
@@ -455,17 +605,16 @@ impl Scene {
                     let dist_to_eye = if true {
                         // This works much better when one line segment is very close to the camera
                         let mut closest = f32::INFINITY;
-                        for segment in &line_segment.segments {
-                            for &endpoint in segment {
-                                closest = closest.min(eye_camera_plane.distance(endpoint.into()));
-                            }
+                        for &(start, end) in &line_segment.segments {
+                            closest = closest.min(eye_camera_plane.distance(start));
+                            closest = closest.min(eye_camera_plane.distance(end));
                         }
                         closest
                     } else {
                         let mut centroid = glam::DVec3::ZERO;
-                        for segment in &line_segment.segments {
-                            centroid += glam::Vec3::from(segment[0]).as_dvec3();
-                            centroid += glam::Vec3::from(segment[1]).as_dvec3();
+                        for (start, end) in &line_segment.segments {
+                            centroid += start.as_dvec3();
+                            centroid += end.as_dvec3();
                         }
                         let centroid =
                             centroid.as_vec3() / (2.0 * line_segment.segments.len() as f32);
@@ -476,7 +625,7 @@ impl Scene {
                     line_segment.radius =
                         Size::new_scene(dist_to_eye * size_in_points * point_size_at_one_meter);
                 }
-                if line_segment.instance_id == hovered_instance_id_hash {
+                if line_segment.instance_id_hash == hovered_instance_id_hash {
                     line_segment.radius *= hover_size_boost;
                     line_segment.color = HOVER_COLOR;
                 }
@@ -486,7 +635,7 @@ impl Scene {
         {
             crate::profile_scope!("meshes");
             for mesh in meshes {
-                if mesh.instance_id == hovered_instance_id_hash {
+                if mesh.instance_id_hash == hovered_instance_id_hash {
                     mesh.tint = Some(HOVER_COLOR);
                 }
             }
@@ -513,35 +662,27 @@ impl Scene {
         // or [-0.5, w-0.5] for the "pixels are tiny squares" interpretation of the frustum.
 
         let corners = [
-            world_from_image
-                .transform_point3(d * vec3(0.0, 0.0, 1.0))
-                .into(),
-            world_from_image
-                .transform_point3(d * vec3(0.0, h, 1.0))
-                .into(),
-            world_from_image
-                .transform_point3(d * vec3(w, h, 1.0))
-                .into(),
-            world_from_image
-                .transform_point3(d * vec3(w, 0.0, 1.0))
-                .into(),
+            world_from_image.transform_point3(d * vec3(0.0, 0.0, 1.0)),
+            world_from_image.transform_point3(d * vec3(0.0, h, 1.0)),
+            world_from_image.transform_point3(d * vec3(w, h, 1.0)),
+            world_from_image.transform_point3(d * vec3(w, 0.0, 1.0)),
         ];
 
-        let center = camera.position().into();
+        let center = camera.position();
 
         let segments = vec![
-            [center, corners[0]],     // frustum corners
-            [center, corners[1]],     // frustum corners
-            [center, corners[2]],     // frustum corners
-            [center, corners[3]],     // frustum corners
-            [corners[0], corners[1]], // `d` distance plane sides
-            [corners[1], corners[2]], // `d` distance plane sides
-            [corners[2], corners[3]], // `d` distance plane sides
-            [corners[3], corners[0]], // `d` distance plane sides
+            (center, corners[0]),     // frustum corners
+            (center, corners[1]),     // frustum corners
+            (center, corners[2]),     // frustum corners
+            (center, corners[3]),     // frustum corners
+            (corners[0], corners[1]), // `d` distance plane sides
+            (corners[1], corners[2]), // `d` distance plane sides
+            (corners[2], corners[3]), // `d` distance plane sides
+            (corners[3], corners[0]), // `d` distance plane sides
         ];
 
-        self.line_segments.push(LineSegments {
-            instance_id,
+        self.line_segments.push(LineSegments3D {
+            instance_id_hash: instance_id,
             segments,
             radius: line_radius,
             color,
@@ -554,8 +695,8 @@ impl Scene {
 
     fn add_arrow(
         &mut self,
-        _ctx: &mut ViewerContext<'_>,
-        instance_id: InstanceIdHash,
+        _caches: &mut Caches,
+        instance_id_hash: InstanceIdHash,
         color: [u8; 4],
         width_scale: Option<f32>,
         _label: Option<&str>,
@@ -569,8 +710,8 @@ impl Scene {
 
         #[cfg(feature = "glow")]
         {
-            let (cylinder_id, cylinder_mesh) = _ctx.cache.cpu_mesh.cylinder();
-            let (cone_id, cone_mesh) = _ctx.cache.cpu_mesh.cone();
+            let (cylinder_id, cylinder_mesh) = _caches.cpu_mesh.cylinder();
+            let (cone_id, cone_mesh) = _caches.cpu_mesh.cone();
 
             let rotation = glam::Quat::from_rotation_arc(Vec3::X, vector.normalize());
 
@@ -587,7 +728,7 @@ impl Scene {
             );
 
             self.meshes.push(MeshSource {
-                instance_id,
+                instance_id_hash,
                 mesh_id: cylinder_id,
                 world_from_mesh: cylinder_transform,
                 cpu_mesh: cylinder_mesh,
@@ -602,7 +743,7 @@ impl Scene {
             ) * glam::Affine3A::from_translation(-Vec3::X);
 
             self.meshes.push(MeshSource {
-                instance_id,
+                instance_id_hash,
                 mesh_id: cone_id,
                 world_from_mesh: cone_transform,
                 cpu_mesh: cone_mesh,
@@ -615,9 +756,9 @@ impl Scene {
             let tip_length = LineStripFlags::get_triangle_cap_tip_length(radius);
             let vector_len = vector.length();
             let end = origin + vector * ((vector_len - tip_length) / vector_len);
-            self.line_segments.push(LineSegments {
-                instance_id,
-                segments: vec![[origin.to_array(), end.to_array()]],
+            self.line_segments.push(LineSegments3D {
+                instance_id_hash,
+                segments: vec![(origin, end)],
                 radius: Size::new_scene(radius),
                 color,
                 flags: re_renderer::renderer::LineStripFlags::CAP_END_TRIANGLE,
@@ -645,45 +786,43 @@ impl Scene {
             glam::Affine3A::from_scale_rotation_translation(half_size, rotation, translation);
 
         let corners = [
-            transform
-                .transform_point3(vec3(-0.5, -0.5, -0.5))
-                .to_array(),
-            transform.transform_point3(vec3(-0.5, -0.5, 0.5)).to_array(),
-            transform.transform_point3(vec3(-0.5, 0.5, -0.5)).to_array(),
-            transform.transform_point3(vec3(-0.5, 0.5, 0.5)).to_array(),
-            transform.transform_point3(vec3(0.5, -0.5, -0.5)).to_array(),
-            transform.transform_point3(vec3(0.5, -0.5, 0.5)).to_array(),
-            transform.transform_point3(vec3(0.5, 0.5, -0.5)).to_array(),
-            transform.transform_point3(vec3(0.5, 0.5, 0.5)).to_array(),
+            transform.transform_point3(vec3(-0.5, -0.5, -0.5)),
+            transform.transform_point3(vec3(-0.5, -0.5, 0.5)),
+            transform.transform_point3(vec3(-0.5, 0.5, -0.5)),
+            transform.transform_point3(vec3(-0.5, 0.5, 0.5)),
+            transform.transform_point3(vec3(0.5, -0.5, -0.5)),
+            transform.transform_point3(vec3(0.5, -0.5, 0.5)),
+            transform.transform_point3(vec3(0.5, 0.5, -0.5)),
+            transform.transform_point3(vec3(0.5, 0.5, 0.5)),
         ];
 
         let segments = vec![
             // bottom:
-            [corners[0b000], corners[0b001]],
-            [corners[0b000], corners[0b010]],
-            [corners[0b011], corners[0b001]],
-            [corners[0b011], corners[0b010]],
+            (corners[0b000], corners[0b001]),
+            (corners[0b000], corners[0b010]),
+            (corners[0b011], corners[0b001]),
+            (corners[0b011], corners[0b010]),
             // top:
-            [corners[0b100], corners[0b101]],
-            [corners[0b100], corners[0b110]],
-            [corners[0b111], corners[0b101]],
-            [corners[0b111], corners[0b110]],
+            (corners[0b100], corners[0b101]),
+            (corners[0b100], corners[0b110]),
+            (corners[0b111], corners[0b101]),
+            (corners[0b111], corners[0b110]),
             // sides:
-            [corners[0b000], corners[0b100]],
-            [corners[0b001], corners[0b101]],
-            [corners[0b010], corners[0b110]],
-            [corners[0b011], corners[0b111]],
+            (corners[0b000], corners[0b100]),
+            (corners[0b001], corners[0b101]),
+            (corners[0b010], corners[0b110]),
+            (corners[0b011], corners[0b111]),
         ];
 
         if let Some(label) = label {
-            self.labels.push(Label {
+            self.labels.push(Label3D {
                 text: (*label).to_owned(),
                 origin: translation,
             });
         }
 
-        self.line_segments.push(LineSegments {
-            instance_id,
+        self.line_segments.push(LineSegments3D {
+            instance_id_hash: instance_id,
             segments,
             radius: line_radius,
             color,
@@ -692,6 +831,18 @@ impl Scene {
         });
     }
 
+    pub fn is_empty(&self) -> bool {
+        let Self {
+            points,
+            line_segments,
+            meshes,
+            labels,
+        } = self;
+
+        points.is_empty() && line_segments.is_empty() && meshes.is_empty() && labels.is_empty()
+    }
+
+    // TODO(cmc): maybe we just store that from the beginning once glow is gone?
     #[cfg(feature = "wgpu")]
     pub fn line_strips(&self) -> Vec<LineStrip> {
         let mut line_strips = Vec::with_capacity(self.line_segments.len());
@@ -702,18 +853,15 @@ impl Scene {
                 color: segments.color,
                 flags: segments.flags,
             };
-            for [a, b] in &segments.segments {
-                let a = glam::Vec3::from(*a);
-                let b = glam::Vec3::from(*b);
-
+            for &(start, end) in &segments.segments {
                 if let Some(prev) = current_strip.points.last() {
-                    if *prev == a {
-                        current_strip.points.push(b);
+                    if *prev == start {
+                        current_strip.points.push(end);
                     } else {
                         line_strips.push(std::mem::replace(
                             &mut current_strip,
                             LineStrip {
-                                points: vec![a, b],
+                                points: vec![start, end],
                                 radius: segments.radius.0,
                                 color: segments.color,
                                 flags: segments.flags,
@@ -721,8 +869,8 @@ impl Scene {
                         ));
                     }
                 } else {
-                    current_strip.points.push(a);
-                    current_strip.points.push(b);
+                    current_strip.points.push(start);
+                    current_strip.points.push(end);
                 }
             }
 
@@ -733,12 +881,13 @@ impl Scene {
         line_strips
     }
 
+    // TODO(cmc): maybe we just store that from the beginning once glow is gone?
     #[cfg(feature = "wgpu")]
     pub fn point_cloud_points(&self) -> Vec<PointCloudPoint> {
         self.points
             .iter()
             .map(|point| PointCloudPoint {
-                position: glam::Vec3::from(point.pos),
+                position: point.pos,
                 radius: point.radius.0,
                 srgb_color: point.color,
             })
@@ -781,9 +930,9 @@ impl Scene {
         {
             crate::profile_scope!("points");
             for point in points {
-                if point.instance_id.is_some() {
+                if point.instance_id_hash.is_some() {
                     // TODO(emilk): take point radius into account
-                    let pos_in_ui = ui_from_world.project_point3(point.pos.into());
+                    let pos_in_ui = ui_from_world.project_point3(point.pos);
                     if pos_in_ui.z < 0.0 {
                         continue; // TODO(emilk): don't we expect negative Z!? RHS etc
                     }
@@ -793,7 +942,7 @@ impl Scene {
                         if t < closest_z || dist_sq < closest_side_dist_sq {
                             closest_z = t;
                             closest_side_dist_sq = dist_sq;
-                            closest_instance_id = Some(point.instance_id);
+                            closest_instance_id = Some(point.instance_id_hash);
                         }
                     }
                 }
@@ -803,13 +952,13 @@ impl Scene {
         {
             crate::profile_scope!("line_segments");
             for line_segments in line_segments {
-                if line_segments.instance_id.is_some() {
+                if line_segments.instance_id_hash.is_some() {
                     // TODO(emilk): take line segment radius into account
                     use egui::pos2;
 
-                    for [a, b] in &line_segments.segments {
-                        let a = ui_from_world.project_point3((*a).into());
-                        let b = ui_from_world.project_point3((*b).into());
+                    for &(start, end) in &line_segments.segments {
+                        let a = ui_from_world.project_point3(start);
+                        let b = ui_from_world.project_point3(end);
                         let dist_sq = line_segment_distance_sq_to_point_2d(
                             [pos2(a.x, a.y), pos2(b.x, b.y)],
                             pointer_in_ui,
@@ -820,7 +969,7 @@ impl Scene {
                             if t < closest_z || dist_sq < closest_side_dist_sq {
                                 closest_z = t;
                                 closest_side_dist_sq = dist_sq;
-                                closest_instance_id = Some(line_segments.instance_id);
+                                closest_instance_id = Some(line_segments.instance_id_hash);
                             }
                         }
                     }
@@ -831,7 +980,7 @@ impl Scene {
         {
             crate::profile_scope!("meshes");
             for mesh in meshes {
-                if mesh.instance_id.is_some() {
+                if mesh.instance_id_hash.is_some() {
                     let ray_in_mesh = (mesh.world_from_mesh.inverse() * ray_in_world).normalize();
                     let t = crate::math::ray_bbox_intersect(&ray_in_mesh, mesh.cpu_mesh.bbox());
 
@@ -840,7 +989,7 @@ impl Scene {
                         if t < closest_z || dist_sq < closest_side_dist_sq {
                             closest_z = t; // TODO(emilk): I think this is wrong
                             closest_side_dist_sq = dist_sq;
-                            closest_instance_id = Some(mesh.instance_id);
+                            closest_instance_id = Some(mesh.instance_id_hash);
                         }
                     }
                 }
@@ -872,14 +1021,13 @@ impl Scene {
         } = self;
 
         for point in points {
-            bbox.extend(point.pos.into());
+            bbox.extend(point.pos);
         }
 
         for line_segments in line_segments {
-            for line_segment in &line_segments.segments {
-                for &endpoint in line_segment {
-                    bbox.extend(endpoint.into());
-                }
+            for &(start, end) in &line_segments.segments {
+                bbox.extend(start);
+                bbox.extend(end);
             }
         }
 
diff --git a/crates/re_viewer/src/ui/view3d/space_camera.rs b/crates/re_viewer/src/ui/view_3d/space_camera.rs
similarity index 100%
rename from crates/re_viewer/src/ui/view3d/space_camera.rs
rename to crates/re_viewer/src/ui/view_3d/space_camera.rs
diff --git a/crates/re_viewer/src/ui/view3d/mod.rs b/crates/re_viewer/src/ui/view_3d/ui.rs
similarity index 91%
rename from crates/re_viewer/src/ui/view3d/mod.rs
rename to crates/re_viewer/src/ui/view_3d/ui.rs
index 02ae39962663..70d48d0102bd 100644
--- a/crates/re_viewer/src/ui/view3d/mod.rs
+++ b/crates/re_viewer/src/ui/view_3d/ui.rs
@@ -1,21 +1,7 @@
-mod eye;
-pub(crate) mod scene;
-mod space_camera;
-
-#[cfg(feature = "glow")]
-mod glow_rendering;
-
-mod mesh_cache;
-pub use mesh_cache::CpuMeshCache;
-
-use eye::*;
-use re_data_store::{InstanceId, InstanceIdHash};
-use scene::*;
-pub use space_camera::SpaceCamera;
-
 use egui::NumExt as _;
 use glam::Affine3A;
 use macaw::{vec3, Quat, Ray3, Vec3};
+use re_data_store::{InstanceId, InstanceIdHash};
 use re_log_types::{ObjPath, ViewCoordinates};
 
 use crate::{
@@ -23,9 +9,16 @@ use crate::{
     ViewerContext,
 };
 
+use super::{Eye, LineSegments3D, OrbitEye, Point3D, Scene3D, Size, SpaceCamera};
+
+#[cfg(feature = "glow")]
+use super::glow_rendering;
+
+// ---
+
 #[derive(Clone, serde::Deserialize, serde::Serialize)]
 #[serde(default)]
-pub(crate) struct State3D {
+pub(crate) struct View3DState {
     orbit_eye: Option<OrbitEye>,
 
     #[serde(skip)]
@@ -50,7 +43,7 @@ pub(crate) struct State3D {
     last_eye_interact_time: f64,
 }
 
-impl Default for State3D {
+impl Default for View3DState {
     fn default() -> Self {
         Self {
             orbit_eye: Default::default(),
@@ -65,7 +58,7 @@ impl Default for State3D {
     }
 }
 
-impl State3D {
+impl View3DState {
     fn update_eye(
         &mut self,
         ctx: &mut ViewerContext<'_>,
@@ -185,7 +178,7 @@ impl EyeInterpolation {
 fn show_settings_ui(
     ctx: &mut ViewerContext<'_>,
     ui: &mut egui::Ui,
-    state: &mut State3D,
+    state: &mut View3DState,
     space_specs: &SpaceSpecs,
 ) {
     ui.horizontal(|ui| {
@@ -302,7 +295,7 @@ fn find_camera(space_cameras: &[SpaceCamera], needle: &InstanceId) -> Option<Eye
 fn click_object(
     ctx: &mut ViewerContext<'_>,
     space_cameras: &[SpaceCamera],
-    state: &mut State3D,
+    state: &mut View3DState,
     instance_id: &InstanceId,
 ) {
     ctx.rec_cfg.selection = crate::Selection::Instance(instance_id.clone());
@@ -324,10 +317,10 @@ fn click_object(
 pub(crate) fn view_3d(
     ctx: &mut ViewerContext<'_>,
     ui: &mut egui::Ui,
-    state: &mut State3D,
+    state: &mut View3DState,
     space: Option<&ObjPath>,
     space_specs: &SpaceSpecs,
-    mut scene: Scene,
+    scene: &mut Scene3D,
     space_cameras: &[SpaceCamera],
 ) -> egui::Response {
     crate::profile_function!();
@@ -391,7 +384,7 @@ pub(crate) fn view_3d(
     }
 
     project_onto_other_spaces(ctx, space_cameras, state, space, &response, orbit_eye);
-    show_projections_from_2d_space(ctx, space_cameras, state, &mut scene);
+    show_projections_from_2d_space(ctx, space_cameras, state, scene);
 
     {
         let orbit_center_alpha = egui::remap_clamp(
@@ -402,9 +395,9 @@ pub(crate) fn view_3d(
 
         if orbit_center_alpha > 0.0 {
             // Show center of orbit camera when interacting with camera (it's quite helpful).
-            scene.points.push(Point {
-                instance_id: InstanceIdHash::NONE,
-                pos: orbit_eye.orbit_center.to_array(),
+            scene.points.push(Point3D {
+                instance_id_hash: InstanceIdHash::NONE,
+                pos: orbit_eye.orbit_center,
                 radius: Size::new_scene(orbit_eye.orbit_radius * 0.01),
                 color: [255, 0, 255, (orbit_center_alpha * 255.0) as u8],
             });
@@ -425,8 +418,8 @@ fn paint_view(
     ui: &mut egui::Ui,
     eye: Eye,
     rect: egui::Rect,
-    scene: Scene,
-    _state: &mut State3D,
+    scene: &mut Scene3D,
+    _state: &mut View3DState,
     response: egui::Response,
 ) -> egui::Response {
     crate::profile_function!();
@@ -591,6 +584,7 @@ fn paint_view(
     let callback = {
         let dark_mode = ui.visuals().dark_mode;
         let show_axes = _state.show_axes;
+        let scene = std::mem::take(scene);
         egui::PaintCallback {
             rect,
             callback: std::sync::Arc::new(egui_glow::CallbackFn::new(move |info, painter| {
@@ -611,8 +605,8 @@ fn paint_view(
 fn show_projections_from_2d_space(
     ctx: &mut ViewerContext<'_>,
     space_cameras: &[SpaceCamera],
-    state: &mut State3D,
-    scene: &mut Scene,
+    state: &mut View3DState,
+    scene: &mut Scene3D,
 ) {
     if let HoveredSpace::TwoD { space_2d, pos } = &ctx.rec_cfg.hovered_space_previous_frame {
         for cam in space_cameras {
@@ -635,9 +629,9 @@ fn show_projections_from_2d_space(
                     let origin = ray.point_along(0.0);
                     let end = ray.point_along(length);
                     let radius = Size::new_ui(1.5);
-                    scene.line_segments.push(LineSegments {
-                        instance_id: InstanceIdHash::NONE,
-                        segments: vec![[origin.into(), end.into()]],
+                    scene.line_segments.push(LineSegments3D {
+                        instance_id_hash: InstanceIdHash::NONE,
+                        segments: vec![(origin, end)],
                         radius,
                         color: [255; 4],
                         #[cfg(feature = "wgpu")]
@@ -646,9 +640,9 @@ fn show_projections_from_2d_space(
 
                     if let Some(pos) = hit_pos {
                         // Show where the ray hits the depth map:
-                        scene.points.push(Point {
-                            instance_id: InstanceIdHash::NONE,
-                            pos: pos.into(),
+                        scene.points.push(Point3D {
+                            instance_id_hash: InstanceIdHash::NONE,
+                            pos,
                             radius: radius * 3.0,
                             color: [255; 4],
                         });
@@ -662,40 +656,40 @@ fn show_projections_from_2d_space(
 fn project_onto_other_spaces(
     ctx: &mut ViewerContext<'_>,
     space_cameras: &[SpaceCamera],
-    state: &mut State3D,
+    state: &mut View3DState,
     space: Option<&ObjPath>,
     response: &egui::Response,
     orbit_eye: OrbitEye,
 ) {
-    if let Some(pos_in_ui) = response.hover_pos() {
-        let ray_in_world = {
-            let eye = orbit_eye.to_eye();
-            let world_from_ui = eye.world_from_ui(&response.rect);
-            let ray_origin = eye.pos_in_world();
-            let ray_dir = world_from_ui.project_point3(glam::vec3(pos_in_ui.x, pos_in_ui.y, 1.0))
-                - ray_origin;
-            Ray3::from_origin_dir(ray_origin, ray_dir.normalize())
-        };
+    let Some(pos_in_ui) = response.hover_pos() else { return };
+
+    let ray_in_world = {
+        let eye = orbit_eye.to_eye();
+        let world_from_ui = eye.world_from_ui(&response.rect);
+        let ray_origin = eye.pos_in_world();
+        let ray_dir =
+            world_from_ui.project_point3(glam::vec3(pos_in_ui.x, pos_in_ui.y, 1.0)) - ray_origin;
+        Ray3::from_origin_dir(ray_origin, ray_dir.normalize())
+    };
 
-        let mut target_spaces = vec![];
-        for cam in space_cameras {
-            if let Some(target_space) = cam.target_space.clone() {
-                let ray_in_2d = cam
-                    .image_from_world()
-                    .map(|image_from_world| (image_from_world * ray_in_world).normalize());
+    let mut target_spaces = vec![];
+    for cam in space_cameras {
+        if let Some(target_space) = cam.target_space.clone() {
+            let ray_in_2d = cam
+                .image_from_world()
+                .map(|image_from_world| (image_from_world * ray_in_world).normalize());
 
-                let point_in_2d = state
-                    .hovered_point
-                    .and_then(|hovered_point| cam.project_onto_2d(hovered_point));
+            let point_in_2d = state
+                .hovered_point
+                .and_then(|hovered_point| cam.project_onto_2d(hovered_point));
 
-                target_spaces.push((target_space, ray_in_2d, point_in_2d));
-            }
-        }
-        ctx.rec_cfg.hovered_space_this_frame = HoveredSpace::ThreeD {
-            space_3d: space.cloned(),
-            target_spaces,
+            target_spaces.push((target_space, ray_in_2d, point_in_2d));
         }
     }
+    ctx.rec_cfg.hovered_space_this_frame = HoveredSpace::ThreeD {
+        space_3d: space.cloned(),
+        target_spaces,
+    }
 }
 
 fn default_eye(scene_bbox: &macaw::BoundingBox, space_specs: &SpaceSpecs) -> OrbitEye {
@@ -733,7 +727,7 @@ fn default_eye(scene_bbox: &macaw::BoundingBox, space_specs: &SpaceSpecs) -> Orb
         world_from_view_rot: Quat::from_affine3(
             &Affine3A::look_at_rh(eye_pos, center, look_up).inverse(),
         ),
-        fov_y: eye::DEFAULT_FOV_Y,
+        fov_y: Eye::DEFAULT_FOV_Y,
         up: space_specs.up.unwrap_or(Vec3::ZERO),
         velocity: Vec3::ZERO,
     }
diff --git a/crates/re_viewer/src/ui/view_tensor/mod.rs b/crates/re_viewer/src/ui/view_tensor/mod.rs
new file mode 100644
index 000000000000..349f77cc6aa4
--- /dev/null
+++ b/crates/re_viewer/src/ui/view_tensor/mod.rs
@@ -0,0 +1,8 @@
+mod scene;
+pub(crate) use self::scene::SceneTensor;
+
+mod ui;
+pub(crate) use self::ui::{view_tensor, ViewTensorState};
+
+mod tensor_dimension_mapper;
+pub use self::tensor_dimension_mapper::dimension_mapping_ui;
diff --git a/crates/re_viewer/src/ui/view_tensor/scene.rs b/crates/re_viewer/src/ui/view_tensor/scene.rs
new file mode 100644
index 000000000000..f8a444e57491
--- /dev/null
+++ b/crates/re_viewer/src/ui/view_tensor/scene.rs
@@ -0,0 +1,85 @@
+use re_data_store::{query::visit_type_data_1, FieldName, ObjectTreeProperties};
+use re_log_types::{IndexHash, MsgId, ObjectType, Tensor};
+
+use crate::{misc::ViewerContext, ui::SceneQuery};
+
+// ---
+
+/// A tensor scene, with everything needed to render it.
+#[derive(Default)]
+pub struct SceneTensor {
+    pub tensors: Vec<Tensor>,
+}
+
+impl SceneTensor {
+    /// Loads all tensor objects into the scene according to the given query.
+    pub(crate) fn load_objects(
+        &mut self,
+        ctx: &ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+    ) {
+        crate::profile_function!();
+
+        self.load_tensors(ctx, obj_tree_props, query);
+    }
+
+    fn load_tensors(
+        &mut self,
+        ctx: &ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+    ) {
+        crate::profile_function!();
+
+        let tensors = query
+            .iter_object_stores(ctx.log_db, obj_tree_props, &[ObjectType::Image])
+            .filter_map(|(_obj_type, _obj_path, obj_store)| {
+                let mut tensors = Vec::new();
+                visit_type_data_1(
+                    obj_store,
+                    &FieldName::from("tensor"),
+                    &query.time_query,
+                    ("_visible",),
+                    |_instance_index: Option<&IndexHash>,
+                     _time: i64,
+                     _msg_id: &MsgId,
+                     tensor: &re_log_types::Tensor,
+                     visible: Option<&bool>| {
+                        if *visible.unwrap_or(&true) {
+                            tensors.push(tensor.clone() /* shallow */);
+                        }
+                    },
+                );
+
+                // We have a special tensor viewer that (currently) only works
+                // when we only have a single tensor (and no bounding boxes etc).
+                // It is also not as great for images as the normal 2d view (at least not yet).
+                // This is a hacky-way of detecting this special case.
+                // TODO(emilk): integrate the tensor viewer into the 2D viewer instead,
+                // so we can stack bounding boxes etc on top of it.
+                if tensors.len() == 1 {
+                    let tensor = tensors.pop().unwrap();
+
+                    // Ignore tensors that likely represent images.
+                    if tensor.num_dim() > 3
+                        || tensor.num_dim() == 3 && tensor.shape.last().unwrap().size > 4
+                    {
+                        return Some(tensor);
+                    }
+                }
+
+                None
+            });
+
+        self.tensors.extend(tensors);
+    }
+}
+
+impl SceneTensor {
+    pub fn is_empty(&self) -> bool {
+        let Self { tensors } = self;
+
+        tensors.is_empty()
+    }
+}
diff --git a/crates/re_viewer/src/ui/tensor_dimension_mapper.rs b/crates/re_viewer/src/ui/view_tensor/tensor_dimension_mapper.rs
similarity index 100%
rename from crates/re_viewer/src/ui/tensor_dimension_mapper.rs
rename to crates/re_viewer/src/ui/view_tensor/tensor_dimension_mapper.rs
diff --git a/crates/re_viewer/src/ui/view_tensor.rs b/crates/re_viewer/src/ui/view_tensor/ui.rs
similarity index 96%
rename from crates/re_viewer/src/ui/view_tensor.rs
rename to crates/re_viewer/src/ui/view_tensor/ui.rs
index 467843dc41bb..db57911e7f48 100644
--- a/crates/re_viewer/src/ui/view_tensor.rs
+++ b/crates/re_viewer/src/ui/view_tensor/ui.rs
@@ -1,19 +1,17 @@
 use std::{collections::BTreeMap, fmt::Display};
 
 use eframe::emath::Align2;
+use egui::{epaint::TextShape, Color32, ColorImage, Vec2};
 use ndarray::{Axis, Ix2};
-
 use re_log_types::{Tensor, TensorDataType, TensorDimension};
 use re_tensor_ops::dimension_mapping::DimensionMapping;
 
-use egui::{epaint::TextShape, Color32, ColorImage, Vec2};
-
-use crate::ui::tensor_dimension_mapper::dimension_mapping_ui;
+use super::dimension_mapping_ui;
 
-// ----------------------------------------------------------------------------
+// ---
 
 #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
-pub struct TensorViewState {
+pub struct ViewTensorState {
     /// How we select which dimensions to project the tensor onto.
     dimension_mapping: DimensionMapping,
 
@@ -27,8 +25,8 @@ pub struct TensorViewState {
     texture_settings: TextureSettings,
 }
 
-impl TensorViewState {
-    pub(crate) fn create(tensor: &re_log_types::Tensor) -> TensorViewState {
+impl ViewTensorState {
+    pub fn create(tensor: &Tensor) -> ViewTensorState {
         Self {
             selector_values: Default::default(),
             dimension_mapping: DimensionMapping::create(tensor),
@@ -38,6 +36,93 @@ impl TensorViewState {
     }
 }
 
+pub(crate) fn view_tensor(ui: &mut egui::Ui, state: &mut ViewTensorState, tensor: &Tensor) {
+    crate::profile_function!();
+
+    ui.collapsing("Dimension Mapping", |ui| {
+        ui.label(format!("shape: {:?}", tensor.shape));
+        ui.label(format!("dtype: {:?}", tensor.dtype));
+        ui.add_space(12.0);
+
+        dimension_mapping_ui(ui, &mut state.dimension_mapping, &tensor.shape);
+    });
+
+    state.texture_settings.show(ui);
+    selectors_ui(ui, state, tensor);
+
+    let tensor_shape = &tensor.shape;
+
+    match tensor.dtype {
+        TensorDataType::U8 => match re_tensor_ops::as_ndarray::<u8>(tensor) {
+            Ok(tensor) => {
+                color_mapping_ui(ui, &mut state.color_mapping);
+
+                let color_from_value = |value: u8| {
+                    state
+                        .color_mapping
+                        .color_from_normalized(value as f32 / 255.0)
+                };
+
+                let slice = selected_tensor_slice(state, &tensor);
+                slice_ui(ui, state, tensor_shape, slice, color_from_value);
+            }
+            Err(err) => {
+                ui.colored_label(ui.visuals().error_fg_color, err.to_string());
+            }
+        },
+
+        TensorDataType::U16 => match re_tensor_ops::as_ndarray::<u16>(tensor) {
+            Ok(tensor) => {
+                let (tensor_min, tensor_max) = tensor_range_u16(&tensor);
+
+                ui.group(|ui| {
+                    ui.monospace(format!("Data range: [{tensor_min} - {tensor_max}]"));
+                    color_mapping_ui(ui, &mut state.color_mapping);
+                });
+
+                let color_from_value = |value: u16| {
+                    state.color_mapping.color_from_normalized(egui::remap(
+                        value as f32,
+                        tensor_min as f32..=tensor_max as f32,
+                        0.0..=1.0,
+                    ))
+                };
+
+                let slice = selected_tensor_slice(state, &tensor);
+                slice_ui(ui, state, tensor_shape, slice, color_from_value);
+            }
+            Err(err) => {
+                ui.colored_label(ui.visuals().error_fg_color, err.to_string());
+            }
+        },
+
+        TensorDataType::F32 => match re_tensor_ops::as_ndarray::<f32>(tensor) {
+            Ok(tensor) => {
+                let (tensor_min, tensor_max) = tensor_range_f32(&tensor);
+
+                ui.group(|ui| {
+                    ui.monospace(format!("Data range: [{tensor_min} - {tensor_max}]"));
+                    color_mapping_ui(ui, &mut state.color_mapping);
+                });
+
+                let color_from_value = |value: f32| {
+                    state.color_mapping.color_from_normalized(egui::remap(
+                        value,
+                        tensor_min..=tensor_max,
+                        0.0..=1.0,
+                    ))
+                };
+
+                let slice = selected_tensor_slice(state, &tensor);
+                slice_ui(ui, state, tensor_shape, slice, color_from_value);
+            }
+            Err(err) => {
+                ui.colored_label(ui.visuals().error_fg_color, err.to_string());
+            }
+        },
+    }
+}
+
 // ----------------------------------------------------------------------------
 
 /// How we map values to colors.
@@ -224,95 +309,8 @@ fn texture_filter_ui(ui: &mut egui::Ui, label: &str, filter: &mut egui::TextureF
 
 // ----------------------------------------------------------------------------
 
-pub(crate) fn view_tensor(ui: &mut egui::Ui, state: &mut TensorViewState, tensor: &Tensor) {
-    crate::profile_function!();
-
-    ui.collapsing("Dimension Mapping", |ui| {
-        ui.label(format!("shape: {:?}", tensor.shape));
-        ui.label(format!("dtype: {:?}", tensor.dtype));
-        ui.add_space(12.0);
-
-        dimension_mapping_ui(ui, &mut state.dimension_mapping, &tensor.shape);
-    });
-
-    state.texture_settings.show(ui);
-    selectors_ui(ui, state, tensor);
-
-    let tensor_shape = &tensor.shape;
-
-    match tensor.dtype {
-        TensorDataType::U8 => match re_tensor_ops::as_ndarray::<u8>(tensor) {
-            Ok(tensor) => {
-                color_mapping_ui(ui, &mut state.color_mapping);
-
-                let color_from_value = |value: u8| {
-                    state
-                        .color_mapping
-                        .color_from_normalized(value as f32 / 255.0)
-                };
-
-                let slice = selected_tensor_slice(state, &tensor);
-                slice_ui(ui, state, tensor_shape, slice, color_from_value);
-            }
-            Err(err) => {
-                ui.colored_label(ui.visuals().error_fg_color, err.to_string());
-            }
-        },
-
-        TensorDataType::U16 => match re_tensor_ops::as_ndarray::<u16>(tensor) {
-            Ok(tensor) => {
-                let (tensor_min, tensor_max) = tensor_range_u16(&tensor);
-
-                ui.group(|ui| {
-                    ui.monospace(format!("Data range: [{tensor_min} - {tensor_max}]"));
-                    color_mapping_ui(ui, &mut state.color_mapping);
-                });
-
-                let color_from_value = |value: u16| {
-                    state.color_mapping.color_from_normalized(egui::remap(
-                        value as f32,
-                        tensor_min as f32..=tensor_max as f32,
-                        0.0..=1.0,
-                    ))
-                };
-
-                let slice = selected_tensor_slice(state, &tensor);
-                slice_ui(ui, state, tensor_shape, slice, color_from_value);
-            }
-            Err(err) => {
-                ui.colored_label(ui.visuals().error_fg_color, err.to_string());
-            }
-        },
-
-        TensorDataType::F32 => match re_tensor_ops::as_ndarray::<f32>(tensor) {
-            Ok(tensor) => {
-                let (tensor_min, tensor_max) = tensor_range_f32(&tensor);
-
-                ui.group(|ui| {
-                    ui.monospace(format!("Data range: [{tensor_min} - {tensor_max}]"));
-                    color_mapping_ui(ui, &mut state.color_mapping);
-                });
-
-                let color_from_value = |value: f32| {
-                    state.color_mapping.color_from_normalized(egui::remap(
-                        value,
-                        tensor_min..=tensor_max,
-                        0.0..=1.0,
-                    ))
-                };
-
-                let slice = selected_tensor_slice(state, &tensor);
-                slice_ui(ui, state, tensor_shape, slice, color_from_value);
-            }
-            Err(err) => {
-                ui.colored_label(ui.visuals().error_fg_color, err.to_string());
-            }
-        },
-    }
-}
-
 fn selected_tensor_slice<'a, T: Copy>(
-    state: &TensorViewState,
+    state: &ViewTensorState,
     tensor: &'a ndarray::ArrayViewD<'_, T>,
 ) -> ndarray::ArrayViewD<'a, T> {
     let dim_mapping = &state.dimension_mapping;
@@ -353,7 +351,7 @@ fn selected_tensor_slice<'a, T: Copy>(
 
 fn slice_ui<T: Copy>(
     ui: &mut egui::Ui,
-    view_state: &TensorViewState,
+    view_state: &ViewTensorState,
     tensor_shape: &[TensorDimension],
     slice: ndarray::ArrayViewD<'_, T>,
     color_from_value: impl Fn(T) -> Color32,
@@ -425,7 +423,7 @@ fn into_image<T: Copy>(
 
 fn image_ui(
     ui: &mut egui::Ui,
-    view_state: &TensorViewState,
+    view_state: &ViewTensorState,
     image: ColorImage,
     dimension_labels: [(String, bool); 2],
 ) {
@@ -482,7 +480,7 @@ fn image_ui(
     });
 }
 
-fn selectors_ui(ui: &mut egui::Ui, state: &mut TensorViewState, tensor: &Tensor) {
+fn selectors_ui(ui: &mut egui::Ui, state: &mut ViewTensorState, tensor: &Tensor) {
     if state.dimension_mapping.selectors.is_empty() {
         return;
     }
diff --git a/crates/re_viewer/src/ui/view_text/mod.rs b/crates/re_viewer/src/ui/view_text/mod.rs
new file mode 100644
index 000000000000..687a838c364f
--- /dev/null
+++ b/crates/re_viewer/src/ui/view_text/mod.rs
@@ -0,0 +1,5 @@
+mod scene;
+pub(crate) use self::scene::{SceneText, TextEntry};
+
+mod ui;
+pub(crate) use self::ui::{view_text, ViewTextState};
diff --git a/crates/re_viewer/src/ui/view_text/scene.rs b/crates/re_viewer/src/ui/view_text/scene.rs
new file mode 100644
index 000000000000..bf9f623422e1
--- /dev/null
+++ b/crates/re_viewer/src/ui/view_text/scene.rs
@@ -0,0 +1,97 @@
+use crate::{ui::SceneQuery, ViewerContext};
+use re_data_store::{
+    query::visit_type_data_3, FieldName, ObjPath, ObjectTreeProperties, TimeQuery,
+};
+use re_log_types::{IndexHash, MsgId, ObjectType};
+
+// ---
+
+/// A single text entry.
+pub struct TextEntry {
+    // props
+    pub msg_id: MsgId,
+    pub obj_path: ObjPath,
+    pub time: i64,
+    pub color: Option<[u8; 4]>,
+
+    // text entry
+    pub level: Option<String>,
+    pub body: String,
+}
+
+/// A text scene, with everything needed to render it.
+#[derive(Default)]
+pub struct SceneText {
+    pub text_entries: Vec<TextEntry>,
+}
+
+impl SceneText {
+    /// Loads all text objects into the scene according to the given query.
+    pub(crate) fn load_objects(
+        &mut self,
+        ctx: &ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+    ) {
+        crate::profile_function!();
+
+        self.load_text_entries(ctx, obj_tree_props, query);
+    }
+
+    fn load_text_entries(
+        &mut self,
+        ctx: &ViewerContext<'_>,
+        obj_tree_props: &ObjectTreeProperties,
+        query: &SceneQuery<'_>,
+    ) {
+        crate::profile_function!();
+
+        let text_entries = query
+            .iter_object_stores(ctx.log_db, obj_tree_props, &[ObjectType::TextEntry])
+            .flat_map(|(_obj_type, obj_path, obj_store)| {
+                let mut batch = Vec::new();
+                // TODO(cmc): We're cloning full strings here, which is very much a bad idea.
+                // We need to change the internal storage so that we store ref-counted strings
+                // rather than plain strings.
+                //
+                // On the other hand:
+                // - A) We're about to change our storage engine.
+                // - B) Nobody is logging gazillon of text logs into Rerun yet.
+                visit_type_data_3(
+                    obj_store,
+                    &FieldName::from("body"),
+                    &TimeQuery::EVERYTHING, // always sticky!
+                    ("_visible", "level", "color"),
+                    |_instance_index: Option<&IndexHash>,
+                     time: i64,
+                     msg_id: &MsgId,
+                     body: &String,
+                     visible: Option<&bool>,
+                     level: Option<&String>,
+                     color: Option<&[u8; 4]>| {
+                        if *visible.unwrap_or(&true) {
+                            batch.push(TextEntry {
+                                msg_id: *msg_id,
+                                obj_path: obj_path.clone(),
+                                time,
+                                color: color.copied(),
+                                level: level.map(ToOwned::to_owned),
+                                body: body.clone(),
+                            });
+                        }
+                    },
+                );
+                batch
+            });
+
+        self.text_entries.extend(text_entries);
+    }
+}
+
+impl SceneText {
+    pub fn is_empty(&self) -> bool {
+        let Self { text_entries } = self;
+
+        text_entries.is_empty()
+    }
+}
diff --git a/crates/re_viewer/src/ui/view_text/ui.rs b/crates/re_viewer/src/ui/view_text/ui.rs
new file mode 100644
index 000000000000..fad7b90ae9c7
--- /dev/null
+++ b/crates/re_viewer/src/ui/view_text/ui.rs
@@ -0,0 +1,198 @@
+use crate::ViewerContext;
+use egui::{Color32, RichText};
+use re_log_types::{LogMsg, TimePoint};
+
+use super::{SceneText, TextEntry};
+
+// ---
+
+#[derive(Clone, Default, serde::Deserialize, serde::Serialize)]
+#[serde(default)]
+pub struct ViewTextState {
+    /// Keeps track of the latest time selection made by the user.
+    ///
+    /// We need this because we want the user to be able to manually scroll the
+    /// text entry window however they please when the time cursor isn't moving.
+    latest_time: i64,
+}
+
+pub(crate) fn view_text(
+    ctx: &mut ViewerContext<'_>,
+    ui: &mut egui::Ui,
+    state: &mut ViewTextState,
+    scene: &SceneText,
+) -> egui::Response {
+    crate::profile_function!();
+
+    let time = ctx
+        .rec_cfg
+        .time_ctrl
+        .time_query()
+        .map_or(state.latest_time, |q| match q {
+            re_data_store::TimeQuery::LatestAt(time) => time,
+            re_data_store::TimeQuery::Range(range) => *range.start(),
+        });
+
+    // Did the time cursor move since last time?
+    // - If it did, time to autoscroll approriately.
+    // - Otherwise, let the user scroll around freely!
+    let time_cursor_moved = state.latest_time != time;
+    let scroll_to_row = time_cursor_moved.then(|| {
+        crate::profile_scope!("TextEntryState - search scroll time");
+        let index = scene
+            .text_entries
+            .partition_point(|entry| entry.time < time);
+        usize::min(index, index.saturating_sub(1))
+    });
+
+    state.latest_time = time;
+
+    ui.with_layout(egui::Layout::top_down(egui::Align::Center), |ui| {
+        ui.label(format!("{} text entries", scene.text_entries.len()));
+        ui.separator();
+
+        egui::ScrollArea::horizontal().show(ui, |ui| {
+            crate::profile_scope!("render table");
+            show_table(ctx, ui, &scene.text_entries, scroll_to_row);
+        })
+    })
+    .response
+}
+
+// ---
+
+fn get_time_point(ctx: &ViewerContext<'_>, entry: &TextEntry) -> Option<TimePoint> {
+    let Some(msg) = ctx.log_db.get_log_msg(&entry.msg_id) else {
+        re_log::warn_once!("Missing LogMsg for {:?}", entry.obj_path.obj_type_path());
+        return None;
+    };
+
+    let LogMsg::DataMsg(data_msg) = msg else {
+        re_log::warn_once!(
+            "LogMsg must be a DataMsg ({:?})",
+            entry.obj_path.obj_type_path()
+        );
+        return None;
+    };
+
+    Some(data_msg.time_point.clone())
+}
+
+/// `scroll_to_row` indicates how far down we want to scroll in terms of logical rows,
+/// as opposed to `scroll_to_offset` (computed below) which is how far down we want to
+/// scroll in terms of actual points.
+fn show_table(
+    ctx: &mut ViewerContext<'_>,
+    ui: &mut egui::Ui,
+    text_entries: &[TextEntry],
+    scroll_to_row: Option<usize>,
+) {
+    use egui_extras::Size;
+    const ROW_HEIGHT: f32 = 18.0;
+
+    let spacing_y = ui.spacing().item_spacing.y;
+
+    let mut builder = egui_extras::TableBuilder::new(ui)
+        .striped(true)
+        .resizable(true)
+        .scroll(true);
+
+    if let Some(index) = scroll_to_row {
+        let row_height_full = ROW_HEIGHT + spacing_y;
+        let scroll_to_offset = index as f32 * row_height_full;
+        builder = builder.vertical_scroll_offset(scroll_to_offset);
+    }
+
+    builder
+        .cell_layout(egui::Layout::left_to_right(egui::Align::Center))
+        .columns(
+            Size::initial(180.0).at_least(100.0),
+            ctx.log_db.time_points.0.len(),
+        ) // time(s)
+        .column(Size::initial(120.0).at_least(100.0)) // path
+        .column(Size::initial(60.0).at_least(60.0)) // level
+        .column(Size::remainder().at_least(200.0)) // body
+        .header(20.0, |mut header| {
+            for timeline in ctx.log_db.time_points.0.keys() {
+                header.col(|ui| {
+                    ui.heading(timeline.name().as_str());
+                });
+            }
+            header.col(|ui| {
+                ui.heading("Path");
+            });
+            header.col(|ui| {
+                ui.heading("Level");
+            });
+            header.col(|ui| {
+                ui.heading("Body");
+            });
+        })
+        .body(|body| {
+            body.rows(ROW_HEIGHT, text_entries.len(), |index, mut row| {
+                let text_entry = &text_entries[index];
+
+                // NOTE: `try_from_props` is where we actually fetch data from the underlying
+                // store, which is a costly operation.
+                // Doing this here guarantees that it only happens for visible rows.
+                let time_point = if let Some(time_point) = get_time_point(ctx, text_entry) {
+                    time_point
+                } else {
+                    row.col(|ui| {
+                        ui.colored_label(
+                            Color32::RED,
+                            "<failed to load TextEntry from data store>",
+                        );
+                    });
+                    return;
+                };
+
+                // time(s)
+                for timeline in ctx.log_db.time_points.0.keys() {
+                    row.col(|ui| {
+                        if let Some(value) = time_point.0.get(timeline) {
+                            ctx.time_button(ui, timeline, *value);
+                        }
+                    });
+                }
+
+                // path
+                row.col(|ui| {
+                    ctx.obj_path_button(ui, &text_entry.obj_path);
+                });
+
+                // level
+                row.col(|ui| {
+                    if let Some(lvl) = &text_entry.level {
+                        ui.label(level_to_rich_text(ui, lvl));
+                    } else {
+                        ui.label("-");
+                    }
+                });
+
+                // body
+                row.col(|ui| {
+                    if let Some(c) = text_entry.color {
+                        let color = Color32::from_rgba_unmultiplied(c[0], c[1], c[2], c[3]);
+                        ui.colored_label(color, &text_entry.body);
+                    } else {
+                        ui.label(&text_entry.body);
+                    }
+                });
+            });
+        });
+}
+
+fn level_to_rich_text(ui: &egui::Ui, lvl: &str) -> RichText {
+    match lvl {
+        "CRITICAL" => RichText::new(lvl)
+            .color(Color32::WHITE)
+            .background_color(ui.visuals().error_fg_color),
+        "ERROR" => RichText::new(lvl).color(ui.visuals().error_fg_color),
+        "WARN" => RichText::new(lvl).color(ui.visuals().warn_fg_color),
+        "INFO" => RichText::new(lvl).color(Color32::LIGHT_GREEN),
+        "DEBUG" => RichText::new(lvl).color(Color32::LIGHT_BLUE),
+        "TRACE" => RichText::new(lvl).color(Color32::LIGHT_GRAY),
+        _ => RichText::new(lvl).color(ui.visuals().text_color()),
+    }
+}
diff --git a/crates/re_viewer/src/ui/viewport.rs b/crates/re_viewer/src/ui/viewport.rs
index 8a3700df273e..2dc4f968554f 100644
--- a/crates/re_viewer/src/ui/viewport.rs
+++ b/crates/re_viewer/src/ui/viewport.rs
@@ -12,14 +12,12 @@ use std::collections::BTreeMap;
 use ahash::HashMap;
 use itertools::Itertools as _;
 
-use re_data_store::{
-    log_db::ObjDb, ObjPath, ObjPathComp, ObjectTree, ObjectTreeProperties, Objects, TimeQuery,
-};
+use re_data_store::{log_db::ObjDb, ObjPath, ObjPathComp, ObjectTree, ObjectTreeProperties};
 use re_log_types::ObjectType;
 
 use crate::misc::{space_info::*, Selection, ViewerContext};
 
-use super::SpaceView;
+use super::{Scene, SceneQuery, SpaceView};
 
 // ----------------------------------------------------------------------------
 
@@ -419,88 +417,34 @@ fn space_view_ui(
     spaces_info: &SpacesInfo,
     space_view: &mut SpaceView,
 ) -> egui::Response {
-    if let Some(space_info) = spaces_info.spaces.get(&space_view.space_path) {
-        let obj_tree_properties = &space_view.obj_tree_properties;
-
-        // Get the latest objects for the currently selected time:
-        let mut time_objects = Objects::default();
-        {
-            crate::profile_scope!("time_query");
-            let timeline = ctx.rec_cfg.time_ctrl.timeline();
-            if let Some(timeline_store) = ctx.log_db.obj_db.store.get(timeline) {
-                if let Some(time_query) = ctx.rec_cfg.time_ctrl.time_query() {
-                    for obj_path in &space_info.objects {
-                        if obj_tree_properties.projected.get(obj_path).visible {
-                            if let Some(obj_store) = timeline_store.get(obj_path) {
-                                if let Some(obj_type) =
-                                    ctx.log_db.obj_db.types.get(obj_path.obj_type_path())
-                                {
-                                    if !is_sticky_type(obj_type) {
-                                        time_objects.query_object(
-                                            obj_store,
-                                            &time_query,
-                                            obj_path,
-                                            obj_type,
-                                        );
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        let time_objects = filter_objects(&time_objects);
-
-        // Get the "sticky" objects (e.g. text logs)
-        // that don't care about the current time:
-        let mut sticky_objects = Objects::default();
-        {
-            crate::profile_scope!("sticky_query");
-            let timeline = ctx.rec_cfg.time_ctrl.timeline();
-            if let Some(timeline_store) = ctx.log_db.obj_db.store.get(timeline) {
-                for obj_path in &space_info.objects {
-                    if obj_tree_properties.projected.get(obj_path).visible {
-                        if let Some(obj_store) = timeline_store.get(obj_path) {
-                            if let Some(obj_type) =
-                                ctx.log_db.obj_db.types.get(obj_path.obj_type_path())
-                            {
-                                if is_sticky_type(obj_type) {
-                                    sticky_objects.query_object(
-                                        obj_store,
-                                        &TimeQuery::EVERYTHING,
-                                        obj_path,
-                                        obj_type,
-                                    );
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        let sticky_objects = filter_objects(&sticky_objects);
+    let Some(space_info) = spaces_info.spaces.get(&space_view.space_path) else {
+        return unknown_space_label(ui, &space_view.space_path);
+    };
+    let Some(time_query) = ctx.rec_cfg.time_ctrl.time_query() else {
+        return invalid_space_label(ui, &space_view.space_path);
+    };
 
-        space_view.objects_ui(
-            ctx,
-            ui,
-            spaces_info,
-            space_info,
-            &time_objects,
-            &sticky_objects,
-        )
-    } else {
-        unknown_space_label(ui, &space_view.space_path)
-    }
-}
+    crate::profile_function!();
 
-fn is_sticky_type(obj_type: &ObjectType) -> bool {
-    obj_type == &ObjectType::TextEntry
-}
+    let obj_tree_props = &space_view.obj_tree_properties;
 
-fn filter_objects<'s>(objects: &'_ Objects<'s>) -> Objects<'s> {
-    crate::profile_function!();
-    objects.filter(|props| props.visible)
+    let mut scene = Scene::default();
+    {
+        let query = SceneQuery {
+            obj_paths: &space_info.objects,
+            timeline: *ctx.rec_cfg.time_ctrl.timeline(),
+            time_query,
+        };
+
+        scene
+            .two_d
+            .load_objects(ctx, obj_tree_props, &query, &space_view.view_state.state_2d);
+        scene.three_d.load_objects(ctx, obj_tree_props, &query);
+        scene.text.load_objects(ctx, obj_tree_props, &query);
+        scene.tensor.load_objects(ctx, obj_tree_props, &query);
+    }
+
+    space_view.scene_ui(ctx, ui, spaces_info, space_info, &mut scene)
 }
 
 fn unknown_space_label(ui: &mut egui::Ui, space_path: &ObjPath) -> egui::Response {
@@ -510,6 +454,13 @@ fn unknown_space_label(ui: &mut egui::Ui, space_path: &ObjPath) -> egui::Respons
     )
 }
 
+fn invalid_space_label(ui: &mut egui::Ui, space_path: &ObjPath) -> egui::Response {
+    ui.colored_label(
+        ui.visuals().warn_fg_color,
+        format!("Invalid space {space_path}: no time query"),
+    )
+}
+
 // ----------------------------------------------------------------------------
 
 /// Defines the layout of the whole Viewer (or will, eventually).
diff --git a/scripts/build_web.sh b/scripts/build_web.sh
index fd7377bd7c60..3ec9d15bb262 100755
--- a/scripts/build_web.sh
+++ b/scripts/build_web.sh
@@ -56,7 +56,7 @@ export RUSTFLAGS=--cfg=web_sys_unstable_apis
 # These pre-encoded flags are generally generated by Cargo itself when loading its
 # configuration from e.g. `$CARGO_HOME/config.toml`; which means they will contain
 # values that only make sense for the native target host, not for a wasm build.
-export CARGO_RUSTFLAGS_ENCODED=""
+export CARGO_ENCODED_RUSTFLAGS=""
 
 # Clear output from old stuff:
 rm -f ${BUILD_DIR}/${CRATE_NAME_SNAKE_CASE}_bg.wasm