zoom scale dependency and depth with lod

Author: MrNeRF

src/visualizer/input/input_controller.cpp

@@ -6,6 +6,7 @@
 #include "core/event_bridge/localization_manager.hpp"
 #include "core/logger.hpp"
 #include "core/path_utils.hpp"
+#include "core/splat_data_transform.hpp"
 #include "gui/bounds_gizmo.hpp"
 #include "gui/gui_focus_state.hpp"
 #include "gui/gui_manager.hpp"
@@ -49,11 +50,22 @@ namespace lfs::vis {
         constexpr double kCameraFrustumClickThreshold = 5.0;
         namespace string_keys = lichtfeld::Strings;
 
-        // Expand [world_min, world_max] by a node's local AABB transformed to world space.
+        // Expand [world_min, world_max] by a node's local AABB transformed to world
+        // space. With use_percentile, the splat/point-cloud box is the trimmed
+        // (1st/99th percentile) AABB so far-flung floaters don't inflate it; meshes
+        // and other geometry fall back to the full node bounds.
         void expandNodeWorldBounds(const core::Scene& scene, const core::SceneNode& node,
-                                   glm::vec3& world_min, glm::vec3& world_max) {
+                                   glm::vec3& world_min, glm::vec3& world_max,
+                                   bool use_percentile = false) {
             glm::vec3 local_min, local_max;
-            if (!scene.getNodeBounds(node.id, local_min, local_max))
+            bool have_local = false;
+            if (use_percentile) {
+                if (node.model && node.model->size() > 0)
+                    have_local = core::compute_bounds(*node.model, local_min, local_max, 0.0f, true);
+                else if (node.point_cloud && node.point_cloud->size() > 0)
+                    have_local = core::compute_bounds(*node.point_cloud, local_min, local_max, 0.0f, true);
+            }
+            if (!have_local && !scene.getNodeBounds(node.id, local_min, local_max))
                 return;
 
             const glm::mat4 world_xform = scene_coords::nodeVisualizerWorldTransform(scene, node.id);
@@ -343,12 +355,14 @@ namespace lfs::vis {
             clearViewportDragState();
             clearWasdMomentumViewport();
             scene_extent_ = 0.0f;
+            depth_range_initialized_ = false;
             focusSplitPanel(SplitViewPanelId::Left);
         });
         scene_loaded_handler_id_ = state::SceneLoaded::when([this](const auto&) {
             clearViewportDragState();
             clearWasdMomentumViewport();
             scene_extent_ = 0.0f;
+            depth_range_initialized_ = false;
             focusSplitPanel(SplitViewPanelId::Left);
         });
 
@@ -1816,6 +1830,8 @@ namespace lfs::vis {
     }
 
     void InputController::update(float delta_time) {
+        maybeInitializeDepthViewRange();
+
         if (input_router_) {
             const bool any_mouse_buttons_pressed = SDL_GetMouseState(nullptr, nullptr) != 0;
             input_router_->syncPressedMouseButtons(any_mouse_buttons_pressed);
@@ -2350,7 +2366,9 @@ namespace lfs::vis {
     }
 
     // Whole-scene world AABB, skipping container nodes that carry no geometry.
-    bool InputController::computeWholeSceneBounds(glm::vec3& out_min, glm::vec3& out_max) const {
+    // use_percentile yields the trimmed (outlier-excluding) box.
+    bool InputController::computeWholeSceneBounds(glm::vec3& out_min, glm::vec3& out_max,
+                                                  const bool use_percentile) const {
         if (!tool_context_)
             return false;
         auto* const sm = tool_context_->getSceneManager();
@@ -2366,27 +2384,54 @@ namespace lfs::vis {
                 node->type == core::NodeType::CAMERA_GROUP ||
                 node->type == core::NodeType::IMAGE_GROUP)
                 continue;
-            expandNodeWorldBounds(scene, *node, out_min, out_max);
+            expandNodeWorldBounds(scene, *node, out_min, out_max, use_percentile);
         }
 
         return out_min.x <= out_max.x;
     }
 
     // Cached whole-scene radius used to scale WASD speed and pan distance with
-    // splat size. Lazily computed after load (bounds may not exist the instant
-    // SceneLoaded fires) and invalidated on scene load/clear. Returns 0 while no
-    // geometry is present.
+    // splat size. Uses the trimmed (1st/99th percentile) bounds so a few far-flung
+    // floaters can't blow up the extent and make navigation far too fast. Lazily
+    // computed after load (bounds may not exist the instant SceneLoaded fires) and
+    // invalidated on scene load/clear. Returns 0 while no geometry is present.
     float InputController::sceneExtent() {
         if (scene_extent_ > 0.0f)
             return scene_extent_;
 
         glm::vec3 min, max;
-        if (computeWholeSceneBounds(min, max))
+        if (computeWholeSceneBounds(min, max, /*use_percentile=*/true))
             scene_extent_ = glm::length(max - min) * 0.5f;
 
         return scene_extent_;
     }
 
+    // Seed the depth-map range from the trimmed scene scale once the extent is
+    // known after a load, so the palette spans the actual content instead of the
+    // fixed 0.1..100 default that is useless on large RAD scenes. Runs once per
+    // scene; the user owns the range after that.
+    void InputController::maybeInitializeDepthViewRange() {
+        if (depth_range_initialized_)
+            return;
+
+        const float radius = sceneExtent();
+        if (radius <= 0.0f)
+            return;
+
+        auto* const rendering = services().renderingOrNull();
+        if (!rendering)
+            return;
+
+        constexpr float kDepthViewInitNear = 1.0f;
+        auto settings = rendering->getSettings();
+        settings.depth_view_min = kDepthViewInitNear;
+        settings.depth_view_max = radius;
+        sanitizeDepthViewSettings(settings);
+        rendering->updateSettings(settings);
+
+        depth_range_initialized_ = true;
+    }
+
     bool InputController::focusSelection() {
         return handleFocusSelection(activeKeyboardViewport());
     }

src/visualizer/input/input_controller.hpp

@@ -148,8 +148,10 @@ namespace lfs::vis {
 
         void handleGoToCamView(const lfs::core::events::cmd::GoToCamView& event);
         bool handleFocusSelection(Viewport& target_viewport);
-        bool computeWholeSceneBounds(glm::vec3& out_min, glm::vec3& out_max) const;
+        bool computeWholeSceneBounds(glm::vec3& out_min, glm::vec3& out_max,
+                                     bool use_percentile = false) const;
         float sceneExtent();
+        void maybeInitializeDepthViewRange();
 
         // WASD processing with proper frame timing
         void processWASDMovement();
@@ -232,6 +234,10 @@ namespace lfs::vis {
         // speed and pan distance with splat size; 0 means "recompute" (after scene
         // load/clear).
         float scene_extent_ = 0.0f;
+        // One-shot guard: the depth-view range is seeded from the trimmed scene
+        // radius the first frame the extent is known after a load, then left to
+        // the user. Reset on scene load/clear.
+        bool depth_range_initialized_ = false;
         SplitViewPanelId drag_split_panel_ = SplitViewPanelId::Left;
         SplitViewPanelId node_rect_panel_ = SplitViewPanelId::Left;
         int node_rect_button_ = -1;