Merge pull request #9670 from iwubcode/freelook-input-controller

Core / VideoCommon: refactor FreeLookCamera

1 files changed, 76 insertions, 93 deletions

diff --git a/Source/Core/VideoCommon/FreeLookCamera.cpp b/Source/Core/VideoCommon/FreeLookCamera.cpp
index 9c2987717b..55d86d9d27 100644
--- a/Source/Core/VideoCommon/FreeLookCamera.cpp
+++ b/Source/Core/VideoCommon/FreeLookCamera.cpp
@@ -35,12 +35,12 @@ std::string to_string(FreeLook::ControlType type)
   return "";
 }
 
-class SixAxisController final : public CameraController
+class SixAxisController final : public CameraControllerInput
 {
 public:
   SixAxisController() = default;
 
-  Common::Matrix44 GetView() override { return m_mat; }
+  Common::Matrix44 GetView() const override { return m_mat; }
 
   void MoveVertical(float amt) override
   {
@@ -64,18 +64,26 @@ public:
     m_mat = Common::Matrix44::FromQuaternion(quat) * m_mat;
   }
 
-  void Reset() override { m_mat = Common::Matrix44::Identity(); }
+  void Reset() override
+  {
+    CameraControllerInput::Reset();
+    m_mat = Common::Matrix44::Identity();
+  }
 
-  void DoState(PointerWrap& p) override { p.Do(m_mat); }
+  void DoState(PointerWrap& p) override
+  {
+    CameraControllerInput::DoState(p);
+    p.Do(m_mat);
+  }
 
 private:
   Common::Matrix44 m_mat = Common::Matrix44::Identity();
 };
 
-class FPSController final : public CameraController
+class FPSController final : public CameraControllerInput
 {
 public:
-  Common::Matrix44 GetView() override
+  Common::Matrix44 GetView() const override
   {
     return Common::Matrix44::FromQuaternion(m_rotate_quat) *
            Common::Matrix44::Translate(m_position);
@@ -118,6 +126,7 @@ public:
 
   void Reset() override
   {
+    CameraControllerInput::Reset();
     m_position = Common::Vec3{};
     m_rotation = Common::Vec3{};
     m_rotate_quat = Common::Quaternion::Identity();
@@ -125,6 +134,7 @@ public:
 
   void DoState(PointerWrap& p) override
   {
+    CameraControllerInput::DoState(p);
     p.Do(m_rotation);
     p.Do(m_rotate_quat);
     p.Do(m_position);
@@ -136,10 +146,10 @@ private:
   Common::Vec3 m_position = Common::Vec3{};
 };
 
-class OrbitalController final : public CameraController
+class OrbitalController final : public CameraControllerInput
 {
 public:
-  Common::Matrix44 GetView() override
+  Common::Matrix44 GetView() const override
   {
     return Common::Matrix44::Translate(Common::Vec3{0, 0, -m_distance}) *
            Common::Matrix44::FromQuaternion(m_rotate_quat);
@@ -152,7 +162,7 @@ public:
   void MoveForward(float amt) override
   {
     m_distance += -1 * amt;
-    m_distance = std::clamp(m_distance, 0.0f, m_distance);
+    m_distance = std::max(m_distance, MIN_DISTANCE);
   }
 
   void Rotate(const Common::Vec3& amt) override
@@ -174,142 +184,123 @@ public:
 
   void Reset() override
   {
+    CameraControllerInput::Reset();
     m_rotation = Common::Vec3{};
     m_rotate_quat = Common::Quaternion::Identity();
-    m_distance = 0;
+    m_distance = MIN_DISTANCE;
   }
 
   void DoState(PointerWrap& p) override
   {
+    CameraControllerInput::DoState(p);
     p.Do(m_rotation);
     p.Do(m_rotate_quat);
     p.Do(m_distance);
   }
 
 private:
-  float m_distance = 0;
+  static constexpr float MIN_DISTANCE = 0.0f;
+  float m_distance = MIN_DISTANCE;
   Common::Vec3 m_rotation = Common::Vec3{};
   Common::Quaternion m_rotate_quat = Common::Quaternion::Identity();
 };
 }  // namespace
 
-FreeLookCamera::FreeLookCamera()
+Common::Vec2 CameraControllerInput::GetFieldOfViewMultiplier() const
 {
-  SetControlType(FreeLook::ControlType::SixAxis);
-}
-
-void FreeLookCamera::SetControlType(FreeLook::ControlType type)
-{
-  if (m_current_type && *m_current_type == type)
-  {
-    return;
-  }
-
-  if (type == FreeLook::ControlType::SixAxis)
-  {
-    m_camera_controller = std::make_unique<SixAxisController>();
-  }
-  else if (type == FreeLook::ControlType::Orbital)
-  {
-    m_camera_controller = std::make_unique<OrbitalController>();
-  }
-  else if (type == FreeLook::ControlType::FPS)
-  {
-    m_camera_controller = std::make_unique<FPSController>();
-  }
-
-  m_current_type = type;
+  return Common::Vec2{m_fov_x_multiplier, m_fov_y_multiplier};
 }
 
-Common::Matrix44 FreeLookCamera::GetView()
+void CameraControllerInput::DoState(PointerWrap& p)
 {
-  return m_camera_controller->GetView();
+  p.Do(m_speed);
+  p.Do(m_fov_x_multiplier);
+  p.Do(m_fov_y_multiplier);
 }
 
-Common::Vec2 FreeLookCamera::GetFieldOfView() const
+void CameraControllerInput::IncreaseFovX(float fov)
 {
-  return Common::Vec2{m_fov_x, m_fov_y};
+  m_fov_x_multiplier += fov;
+  m_fov_x_multiplier = std::max(m_fov_x_multiplier, MIN_FOV_MULTIPLIER);
 }
 
-void FreeLookCamera::MoveVertical(float amt)
+void CameraControllerInput::IncreaseFovY(float fov)
 {
-  m_camera_controller->MoveVertical(amt);
-  m_dirty = true;
+  m_fov_y_multiplier += fov;
+  m_fov_y_multiplier = std::max(m_fov_y_multiplier, MIN_FOV_MULTIPLIER);
 }
 
-void FreeLookCamera::MoveHorizontal(float amt)
+float CameraControllerInput::GetFovStepSize() const
 {
-  m_camera_controller->MoveHorizontal(amt);
-  m_dirty = true;
+  return 1.5f;
 }
 
-void FreeLookCamera::MoveForward(float amt)
+void CameraControllerInput::Reset()
 {
-  m_camera_controller->MoveForward(amt);
+  m_fov_x_multiplier = DEFAULT_FOV_MULTIPLIER;
+  m_fov_y_multiplier = DEFAULT_FOV_MULTIPLIER;
   m_dirty = true;
 }
 
-void FreeLookCamera::Rotate(const Common::Vec3& amt)
+void CameraControllerInput::ModifySpeed(float amt)
 {
-  m_camera_controller->Rotate(amt);
-  m_dirty = true;
+  m_speed += amt;
+  m_speed = std::max(m_speed, 0.0f);
 }
 
-void FreeLookCamera::Rotate(const Common::Quaternion& amt)
+void CameraControllerInput::ResetSpeed()
 {
-  m_camera_controller->Rotate(amt);
-  m_dirty = true;
+  m_speed = DEFAULT_SPEED;
 }
 
-void FreeLookCamera::IncreaseFovX(float fov)
+float CameraControllerInput::GetSpeed() const
 {
-  m_fov_x += fov;
-  m_fov_x = std::clamp(m_fov_x, m_min_fov_multiplier, m_fov_x);
+  return m_speed;
 }
 
-void FreeLookCamera::IncreaseFovY(float fov)
+FreeLookCamera::FreeLookCamera()
 {
-  m_fov_y += fov;
-  m_fov_y = std::clamp(m_fov_y, m_min_fov_multiplier, m_fov_y);
+  SetControlType(FreeLook::ControlType::SixAxis);
 }
 
-float FreeLookCamera::GetFovStepSize() const
+void FreeLookCamera::SetControlType(FreeLook::ControlType type)
 {
-  return 1.5f;
-}
+  if (m_current_type && *m_current_type == type)
+  {
+    return;
+  }
 
-void FreeLookCamera::Reset()
-{
-  m_camera_controller->Reset();
-  m_fov_x = 1.0f;
-  m_fov_y = 1.0f;
-  m_dirty = true;
-}
+  if (type == FreeLook::ControlType::SixAxis)
+  {
+    m_camera_controller = std::make_unique<SixAxisController>();
+  }
+  else if (type == FreeLook::ControlType::Orbital)
+  {
+    m_camera_controller = std::make_unique<OrbitalController>();
+  }
+  else if (type == FreeLook::ControlType::FPS)
+  {
+    m_camera_controller = std::make_unique<FPSController>();
+  }
 
-void FreeLookCamera::ModifySpeed(float amt)
-{
-  m_speed += amt;
-  m_speed = std::clamp(m_speed, 0.0f, m_speed);
+  m_current_type = type;
 }
 
-void FreeLookCamera::ResetSpeed()
+Common::Matrix44 FreeLookCamera::GetView() const
 {
-  m_speed = 60.0f;
+  return m_camera_controller->GetView();
 }
 
-float FreeLookCamera::GetSpeed() const
+Common::Vec2 FreeLookCamera::GetFieldOfViewMultiplier() const
 {
-  return m_speed;
+  return m_camera_controller->GetFieldOfViewMultiplier();
 }
 
 void FreeLookCamera::DoState(PointerWrap& p)
 {
   if (p.mode == PointerWrap::MODE_WRITE || p.mode == PointerWrap::MODE_MEASURE)
   {
-    p.Do(m_speed);
     p.Do(m_current_type);
-    p.Do(m_fov_x);
-    p.Do(m_fov_y);
     if (m_camera_controller)
     {
       m_camera_controller->DoState(p);
@@ -318,10 +309,7 @@ void FreeLookCamera::DoState(PointerWrap& p)
   else
   {
     const auto old_type = m_current_type;
-    p.Do(m_speed);
     p.Do(m_current_type);
-    p.Do(m_fov_x);
-    p.Do(m_fov_y);
     if (old_type == m_current_type)
     {
       m_camera_controller->DoState(p);
@@ -340,17 +328,12 @@ void FreeLookCamera::DoState(PointerWrap& p)
   }
 }
 
-bool FreeLookCamera::IsDirty() const
-{
-  return m_dirty;
-}
-
-void FreeLookCamera::SetClean()
+bool FreeLookCamera::IsActive() const
 {
-  m_dirty = false;
+  return FreeLook::GetActiveConfig().enabled;
 }
 
-bool FreeLookCamera::IsActive() const
+CameraController* FreeLookCamera::GetController() const
 {
-  return FreeLook::GetActiveConfig().enabled;
+  return m_camera_controller.get();
 }