Improve Visible History to support more general time queries

crates/re_data_store/src/entity_properties.rs

@@ -1,5 +1,6 @@
 #[cfg(feature = "serde")]
 use re_log_types::EntityPath;
+use re_log_types::TimeInt;
 
 #[cfg(feature = "serde")]
 use crate::EditableAutoValue;
@@ -172,25 +173,91 @@ impl EntityProperties {
 
 // ----------------------------------------------------------------------------
 
+/// One of the boundary of the visible history.
+///
+/// The for [`VisibleHistoryBoundary::Relative`] and [`VisibleHistoryBoundary::Absolute`], the value
+/// are either nanos or frames, depending on the type of timeline.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum VisibleHistoryBoundary {
+    /// Boundary is a value relative to the time cursor
+    Relative(i64),
+
+    /// Boundary is an absolute value
+    Absolute(i64),
+
+    /// The boundary extends to infinity.
+    Infinite,
+}
+
+impl VisibleHistoryBoundary {
+    pub const AT_CURSOR: Self = Self::Relative(0);
+}
+
+impl Default for VisibleHistoryBoundary {
+    fn default() -> Self {
+        Self::AT_CURSOR
+    }
+}
+
+/// Visible history bounds.
+#[derive(Clone, Copy, Default, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct VisibleHistory {
+    /// Low time boundary.
+    pub from: VisibleHistoryBoundary,
+
+    /// High time boundary.
+    pub to: VisibleHistoryBoundary,
+}
+
+impl VisibleHistory {
+    /// Value with the visible history feature is disabled.
+    pub const OFF: Self = Self {
+        from: VisibleHistoryBoundary::AT_CURSOR,
+        to: VisibleHistoryBoundary::AT_CURSOR,
+    };
+
+    pub fn from(&self, cursor: TimeInt) -> TimeInt {
+        match self.from {
+            VisibleHistoryBoundary::Absolute(value) => TimeInt::from(value),
+            VisibleHistoryBoundary::Relative(value) => cursor + TimeInt::from(value),
+            VisibleHistoryBoundary::Infinite => TimeInt::MIN,
+        }
+    }
+
+    pub fn to(&self, cursor: TimeInt) -> TimeInt {
+        match self.to {
+            VisibleHistoryBoundary::Absolute(value) => TimeInt::from(value),
+            VisibleHistoryBoundary::Relative(value) => cursor + TimeInt::from(value),
+            VisibleHistoryBoundary::Infinite => TimeInt::MAX,
+        }
+    }
+}
+
 /// When showing an entity in the history view, add this much history to it.
 #[derive(Clone, Copy, Default, Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[cfg_attr(feature = "serde", serde(default))]
 pub struct ExtraQueryHistory {
-    /// Zero = off.
-    pub nanos: i64,
+    /// Is the feature enabled?
+    pub enabled: bool,
 
-    /// Zero = off.
-    pub sequences: i64,
+    /// Visible history settings for time timelines
+    pub nanos: VisibleHistory,
+
+    /// Visible history settings for frame timelines
+    pub sequences: VisibleHistory,
 }
 
 impl ExtraQueryHistory {
     /// Multiply/and these together.
     #[allow(dead_code)]
     fn with_child(&self, child: &Self) -> Self {
-        Self {
-            nanos: self.nanos.max(child.nanos),
-            sequences: self.sequences.max(child.sequences),
+        if child.enabled {
+            *child
+        } else {
+            *self
         }
     }
 } // ----------------------------------------------------------------------------

crates/re_data_store/src/store_db.rs

@@ -296,6 +296,10 @@ impl StoreDb {
         &self.entity_db.times_per_timeline
     }
 
+    pub fn time_histogram(&self, timeline: &Timeline) -> Option<&crate::TimeHistogram> {
+        self.entity_db().tree.prefix_times.get(timeline)
+    }
+
     pub fn num_timeless_messages(&self) -> usize {
         self.entity_db.tree.num_timeless_messages()
     }

crates/re_query/src/util.rs

@@ -1,5 +1,5 @@
 use re_arrow_store::{DataStore, LatestAtQuery, RangeQuery, TimeInt, TimeRange, Timeline};
-use re_data_store::ExtraQueryHistory;
+use re_data_store::{ExtraQueryHistory, VisibleHistory};
 use re_log_types::EntityPath;
 use re_types_core::Archetype;
 
@@ -17,14 +17,15 @@ pub fn query_archetype_with_history<'a, A: Archetype + 'a, const N: usize>(
         re_log_types::TimeType::Sequence => history.sequences,
     };
 
-    if visible_history == 0 {
+    if !history.enabled || visible_history == VisibleHistory::OFF {
         let latest_query = LatestAtQuery::new(*timeline, *time);
         let latest = query_archetype::<A>(store, &latest_query, ent_path)?;
 
         Ok(itertools::Either::Left(std::iter::once(latest)))
     } else {
-        let min_time = *time - TimeInt::from(visible_history);
-        let range_query = RangeQuery::new(*timeline, TimeRange::new(min_time, *time));
+        let min_time = visible_history.from(*time);
+        let max_time = visible_history.to(*time);
+        let range_query = RangeQuery::new(*timeline, TimeRange::new(min_time, max_time));
 
         let range = range_archetype::<A, N>(store, &range_query, ent_path);
 

crates/re_time_panel/src/lib.rs

@@ -822,10 +822,7 @@ fn initialize_time_ranges_ui(
 
     if let Some(times) = ctx
         .store_db
-        .entity_db()
-        .tree
-        .prefix_times
-        .get(ctx.rec_cfg.time_ctrl.timeline())
+        .time_histogram(ctx.rec_cfg.time_ctrl.timeline())
     {
         // NOTE: `times` can be empty if a GC wiped everything.
         if !times.is_empty() {

crates/re_ui/src/lib.rs

@@ -15,6 +15,7 @@ pub use command_palette::CommandPalette;
 pub use design_tokens::DesignTokens;
 pub use icons::Icon;
 pub use layout_job_builder::LayoutJobBuilder;
+use std::ops::RangeInclusive;
 pub use toggle_switch::toggle_switch;
 
 // ---------------------------------------------------------------------------
@@ -445,6 +446,41 @@ impl ReUi {
         .inner
     }
 
+    /// Shows a `egui::DragValue` for a time in nanoseconds.
+    ///
+    /// The value and unit displayed adapts to the provided allowable time range.
+    #[allow(clippy::unused_self)]
+    pub fn time_drag_value(
+        &self,
+        ui: &mut egui::Ui,
+        value: &mut i64,
+        time_range: &RangeInclusive<i64>,
+    ) {
+        let span = time_range.end() - time_range.start();
+
+        let (unit, factor) = if span / 1_000_000_000 > 0 {
+            ("s", 1_000_000_000.)
+        } else if span / 1_000_000 > 0 {
+            ("ms", 1_000_000.)
+        } else if span / 1_000 > 0 {
+            ("μs", 1_000.)
+        } else {
+            ("ns", 1.)
+        };
+
+        let mut time_unit = *value as f32 / factor;
+        let time_range = *time_range.start() as f32 / factor..=*time_range.end() as f32 / factor;
+        let speed = (time_range.end() - time_range.start()) * 0.005;
+
+        ui.add(
+            egui::DragValue::new(&mut time_unit)
+                .clamp_range(time_range)
+                .speed(speed)
+                .suffix(unit),
+        );
+        *value = (time_unit * factor).round() as _;
+    }
+
     pub fn large_button(&self, ui: &mut egui::Ui, icon: &Icon) -> egui::Response {
         self.large_button_impl(ui, icon, None, None)
     }