cleanup and refactoring

raytracer/nvpro_core/nvvkhl/element_camera.hpp

@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-FileCopyrightText: Copyright (c) 2014-2023 NVIDIA CORPORATION
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <imgui.h>
+#include <imgui_internal.h>
+#include "nvh/cameramanipulator.hpp"
+#include "nvvkhl/application.hpp"
+
+/** @DOC_START
+# class nvvkhl::ElementCamera
+
+This class is an element of the application that is responsible for the camera manipulation. It is using the `nvh::CameraManipulator` to handle the camera movement and interaction.
+
+To use this class, you need to add it to the `nvvkhl::Application` using the `addElement` method.
+
+@DOC_END */
+
+
+namespace nvvkhl {
+
+struct ElementCamera : public nvvkhl::IAppElement
+{
+  // Return true if the current window is active
+  bool isWindowHovered(ImGuiWindow* ref_window, ImGuiHoveredFlags flags)
+  {
+    ImGuiContext& g = *ImGui::GetCurrentContext();
+    if(g.HoveredWindow != ref_window)
+      return false;
+    if(!ImGui::IsWindowContentHoverable(ref_window, ImGuiFocusedFlags_RootWindow))
+      return false;
+    if(g.ActiveId != 0 && !g.ActiveIdAllowOverlap && g.ActiveId != ref_window->MoveId)
+      return false;
+
+    // Cancel if over the title bar
+    {
+      if(g.IO.ConfigWindowsMoveFromTitleBarOnly)
+        if(!(ref_window->Flags & ImGuiWindowFlags_NoTitleBar) || ref_window->DockIsActive)
+          if(ref_window->TitleBarRect().Contains(g.IO.MousePos))
+            return false;
+    }
+
+    return true;
+  }
+
+  void onUIRender() override
+  {
+    CameraManip.updateAnim();  // This makes the camera to transition smoothly to the new position
+
+    ImGuiWindow* viewportWindow = ImGui::FindWindowByName("Viewport");
+    if(!viewportWindow)
+      return;
+
+    // If the mouse cursor is over the "Viewport", check for all inputs that can manipulate
+    // the camera.
+    if(isWindowHovered(viewportWindow, ImGuiFocusedFlags_RootWindow))
+    {
+      updateCamera();
+    }
+  }
+
+  void onResize(uint32_t width, uint32_t height) override { CameraManip.setWindowSize(width, height); }
+
+  //--------------------------------------------------------------------------------------------------
+  // Fit the camera to the Bounding box
+  //
+  void fitCamera(const glm::vec3& boxMin, const glm::vec3& boxMax, bool instantFit /*= true*/) const
+  {
+    float aspect_ratio = static_cast<float>(m_viewportSize.x / m_viewportSize.y);
+    CameraManip.fit(boxMin, boxMax, instantFit, false, aspect_ratio);
+  }
+
+  void setSceneRadius(float r) { m_sceneRadius = r; }
+
+private:
+  void updateCamera()
+  {
+    // measure one frame at a time
+    float factor = ImGui::GetIO().DeltaTime * 5.0F * m_sceneRadius;
+
+    m_inputs.lmb   = ImGui::IsMouseDown(ImGuiMouseButton_Left);
+    m_inputs.rmb   = ImGui::IsMouseDown(ImGuiMouseButton_Right);
+    m_inputs.mmb   = ImGui::IsMouseDown(ImGuiMouseButton_Middle);
+    m_inputs.ctrl  = ImGui::IsKeyDown(ImGuiKey_LeftCtrl) || ImGui::IsKeyDown(ImGuiKey_RightCtrl);
+    m_inputs.shift = ImGui::IsKeyDown(ImGuiKey_LeftShift) || ImGui::IsKeyDown(ImGuiKey_RightShift);
+    m_inputs.alt   = ImGui::IsKeyDown(ImGuiKey_LeftAlt) || ImGui::IsKeyDown(ImGuiKey_RightAlt);
+    auto mouse_pos = ImGui::GetMousePos();
+
+    // For all pressed keys - apply the action
+    CameraManip.keyMotion(0, 0, nvh::CameraManipulator::NoAction);
+
+    if(!(ImGui::IsKeyDown(ImGuiMod_Alt) || ImGui::IsKeyDown(ImGuiMod_Ctrl) || ImGui::IsKeyDown(ImGuiMod_Shift)))
+    {
+      if(ImGui::IsKeyDown(ImGuiKey_W))
+      {
+        CameraManip.keyMotion(factor, 0, nvh::CameraManipulator::Dolly);
+      }
+
+      if(ImGui::IsKeyDown(ImGuiKey_S))
+      {
+        CameraManip.keyMotion(-factor, 0, nvh::CameraManipulator::Dolly);
+      }
+
+      if(ImGui::IsKeyDown(ImGuiKey_D) || ImGui::IsKeyDown(ImGuiKey_RightArrow))
+      {
+        CameraManip.keyMotion(factor, 0, nvh::CameraManipulator::Pan);
+      }
+
+      if(ImGui::IsKeyDown(ImGuiKey_A) || ImGui::IsKeyDown(ImGuiKey_LeftArrow))
+      {
+        CameraManip.keyMotion(-factor, 0, nvh::CameraManipulator::Pan);
+      }
+
+      if(ImGui::IsKeyDown(ImGuiKey_UpArrow))
+      {
+        CameraManip.keyMotion(0, factor, nvh::CameraManipulator::Pan);
+      }
+
+      if(ImGui::IsKeyDown(ImGuiKey_DownArrow))
+      {
+        CameraManip.keyMotion(0, -factor, nvh::CameraManipulator::Pan);
+      }
+    }
+
+    if(ImGui::IsMouseClicked(ImGuiMouseButton_Left) || ImGui::IsMouseClicked(ImGuiMouseButton_Middle)
+       || ImGui::IsMouseClicked(ImGuiMouseButton_Right))
+    {
+      CameraManip.setMousePosition(static_cast<int>(mouse_pos.x), static_cast<int>(mouse_pos.y));
+    }
+
+    if(ImGui::IsMouseDragging(ImGuiMouseButton_Left, 1.0F) || ImGui::IsMouseDragging(ImGuiMouseButton_Middle, 1.0F)
+       || ImGui::IsMouseDragging(ImGuiMouseButton_Right, 1.0F))
+    {
+      CameraManip.mouseMove(static_cast<int>(mouse_pos.x), static_cast<int>(mouse_pos.y), m_inputs);
+    }
+
+    // Mouse Wheel
+    if(ImGui::GetIO().MouseWheel != 0.0F)
+    {
+      CameraManip.wheel(static_cast<int>(ImGui::GetIO().MouseWheel * 3), m_inputs);
+    }
+  }
+
+  ImVec2                         m_viewportSize{0, 0};
+  float                          m_sceneRadius{10.0F};
+  nvh::CameraManipulator::Inputs m_inputs;  // Mouse button pressed
+};
+
+}  // namespace nvvkhl