Add button and shortcut to focus the selected object

Author: Birdy2014

include/core/CameraController.hpp

@@ -23,9 +23,19 @@ struct CameraController {
 
     float zoom_speed{1.0f};
 
-    void update(float delta_time, bool handle_scroll);
+    void update(float delta_time, bool handle_input, bool handle_scroll);
+    void animate_to(glm::vec3 position, glm::vec3 target, float duration);
+    void focus_on(InstancedNode const& node);
 
 private:
+    struct {
+        bool active{false};
+        glm::vec3 position;
+        glm::vec3 target;
+        float remaining_time;
+    } m_animation;
+
+    void update_animation(float delta_time);
     void update_freecam(float delta_time, bool handle_scroll);
     void update_blender(float delta_time, bool handle_scroll);
     void update_unity(float delta_time, bool handle_scroll);

include/ui/ObjectDetails.hpp

@@ -1,6 +1,10 @@
 #pragma once
 
+struct CameraController;
+
 struct ObjectDetails {
     ObjectDetails();
-    void render();
+
+    // FIXME: Avoid passing the camera controller to this function
+    void render(CameraController&);
 };

include/ui/Viewport.hpp

@@ -17,6 +17,8 @@ struct Viewport {
     Viewport();
     void render(double delta_time);
 
+    CameraController& camera_controller() { return m_camera_controller; }
+
 private:
     Framebuffer m_framebuffer;
     Framebuffer m_blitted_framebuffer;

src/core/CameraController.cpp

@@ -10,8 +10,17 @@ CameraController::CameraController(Type type, glm::vec3 camera_position)
     camera = std::make_unique<Camera>(camera_position, camera_position + direction);
 }
 
-void CameraController::update(float delta_time, bool handle_scroll)
+void CameraController::update(float delta_time, bool handle_input, bool handle_scroll)
 {
+    if (m_animation.active) {
+        update_animation(delta_time);
+        return;
+    }
+
+    if (!handle_input) {
+        return;
+    }
+
     switch (type) {
     case Type::FREECAM:
         update_freecam(delta_time, handle_scroll);
@@ -25,6 +34,71 @@ void CameraController::update(float delta_time, bool handle_scroll)
     }
 }
 
+void CameraController::animate_to(glm::vec3 position, glm::vec3 target, float duration)
+{
+    m_animation.active = true;
+    m_animation.position = position;
+    m_animation.target = target;
+    m_animation.remaining_time = duration;
+}
+
+void CameraController::focus_on(InstancedNode const& node)
+{
+    auto const duration = 0.3f;
+
+    auto const world_center = glm::vec3{node.model_matrix * glm::vec4{0.0f, 0.0f, 0.0f, 1.0f}};
+    auto radius = 0.0f;
+    node.traverse([&](glm::mat4 model_matrix, Node const& node) {
+        for (auto const& mesh : node.meshes) {
+            auto const world_aabb_min = model_matrix * glm::vec4{mesh.aabb.min, 1.0f};
+            auto const world_aabb_max = model_matrix * glm::vec4{mesh.aabb.max, 1.0f};
+            radius = std::max(radius, std::abs(world_center.x - world_aabb_min.x));
+            radius = std::max(radius, std::abs(world_center.y - world_aabb_min.y));
+            radius = std::max(radius, std::abs(world_center.z - world_aabb_min.z));
+            radius = std::max(radius, std::abs(world_center.x - world_aabb_max.x));
+            radius = std::max(radius, std::abs(world_center.y - world_aabb_max.y));
+            radius = std::max(radius, std::abs(world_center.z - world_aabb_max.z));
+        }
+    });
+
+    if (radius < 0.1f) {
+        return;
+    }
+
+    auto const distance = radius * 1.5f;
+
+    auto const look_direction = glm::normalize(camera->target - camera->position);
+
+    switch (type) {
+    case Type::FREECAM:
+    case Type::UNITY: {
+        auto const target_position = world_center - look_direction * distance;
+        animate_to(target_position, target_position + look_direction, duration);
+        break;
+    }
+    case Type::BLENDER: {
+    }
+        animate_to(world_center - look_direction * distance, world_center, duration);
+    }
+}
+
+void CameraController::update_animation(float delta_time)
+{
+    if (!m_animation.active) {
+        return;
+    }
+
+    auto factor = delta_time / m_animation.remaining_time;
+    m_animation.remaining_time -= delta_time;
+    if (factor >= 1.0f) {
+        factor = 1.0f;
+        m_animation.active = false;
+    }
+
+    camera->target = factor * m_animation.target + (1 - factor) * camera->target;
+    camera->position = factor * m_animation.position + (1 - factor) * camera->position;
+}
+
 std::pair<float, float> direction_to_yaw_pitch(glm::vec3 direction)
 {
     float pitch = std::asin(direction.y);

src/main.cpp

@@ -172,7 +172,7 @@ int main()
 
         setup_dock_builder(); // create docking layout before components are rendered
 
-        object_details_pane.render();
+        object_details_pane.render(viewport_window.camera_controller());
         object_selection_tree.render();
         asset_browser.render();
         settings_pane.render();

src/ui/ObjectDetails.cpp

@@ -1,5 +1,6 @@
 #include "ui/ObjectDetails.hpp"
 #include "core/Project.hpp"
+#include "ui/Viewport.hpp"
 #include <imgui.h>
 #include <string>
 
@@ -49,7 +50,7 @@ void reset_instance_transform(InstancedNode* node)
 
 char object_label[128] = {""};
 
-void ObjectDetails::render()
+void ObjectDetails::render(CameraController& camera_controller)
 {
     auto transform_changed = false;
     auto project = Project::get_current();
@@ -126,6 +127,11 @@ void ObjectDetails::render()
         if (ImGui::Button("Reset")) {
             ImGui::OpenPopup("reset_mode");
         }
+
+        ImGui::SameLine();
+        if (ImGui::Button("Focus Camera [F]")) {
+            camera_controller.focus_on(*project->selected_node);
+        }
     }
 
     if (project->scene && transform_changed) {

src/ui/Viewport.cpp

@@ -35,9 +35,7 @@ void Viewport::render(double delta_time)
         m_camera_controller.camera->position = config.camera_position;
         m_camera_controller.camera->target = config.camera_target;
 
-        if (ImGui::IsWindowFocused()) {
-            m_camera_controller.update(delta_time, ImGui::IsWindowHovered());
-        }
+        m_camera_controller.update(delta_time, ImGui::IsWindowFocused(), ImGui::IsWindowHovered());
 
         auto size = ImGui::GetContentRegionAvail();
         if (size.x != m_framebuffer.width || size.y != m_framebuffer.height) {
@@ -211,6 +209,10 @@ void Viewport::render(double delta_time)
                 project->selected_node = nullptr;
             }
         }
+
+        if (ImGui::IsWindowFocused() && project->selected_node && ImGui::IsKeyPressed(ImGuiKey_F, false)) {
+            m_camera_controller.focus_on(*project->selected_node);
+        }
     }
 
     // Focus Viewport window not only with the left, but also the middle and right mouse button.