diff --git 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 @@ class SixAxisController final : public CameraController
     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,13 +126,15 @@ class FPSController final : public CameraController
 
   void Reset() override
   {
+    CameraControllerInput::Reset();
     m_position = Common::Vec3{};
     m_rotation = Common::Vec3{};
     m_rotate_quat = Common::Quaternion::Identity();
   }
 
   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 @@ class FPSController final : public CameraController
   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 @@ class OrbitalController final : public CameraController
   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 @@ class OrbitalController final : public CameraController
 
   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();
 }
diff --git a/Source/Core/VideoCommon/FreeLookCamera.h b/Source/Core/VideoCommon/FreeLookCamera.h
@@ -23,7 +23,28 @@ class CameraController
   CameraController(CameraController&&) = delete;
   CameraController& operator=(CameraController&&) = delete;
 
-  virtual Common::Matrix44 GetView() = 0;
+  virtual Common::Matrix44 GetView() const = 0;
+  virtual Common::Vec2 GetFieldOfViewMultiplier() const = 0;
+
+  virtual void DoState(PointerWrap& p) = 0;
+
+  virtual bool IsDirty() const = 0;
+  virtual void SetClean() = 0;
+
+  virtual bool SupportsInput() const = 0;
+};
+
+class CameraControllerInput : public CameraController
+{
+public:
+  Common::Vec2 GetFieldOfViewMultiplier() const final override;
+
+  void DoState(PointerWrap& p) override;
+
+  bool IsDirty() const final override { return m_dirty; }
+  void SetClean() final override { m_dirty = false; }
+
+  bool SupportsInput() const final override { return true; }
 
   virtual void MoveVertical(float amt) = 0;
   virtual void MoveHorizontal(float amt) = 0;
@@ -35,50 +56,42 @@ class CameraController
 
   virtual void Reset() = 0;
 
-  virtual void DoState(PointerWrap& p) = 0;
+  void IncreaseFovX(float fov);
+  void IncreaseFovY(float fov);
+  float GetFovStepSize() const;
+
+  void ModifySpeed(float multiplier);
+  void ResetSpeed();
+  float GetSpeed() const;
+
+private:
+  static constexpr float MIN_FOV_MULTIPLIER = 0.025f;
+  static constexpr float DEFAULT_SPEED = 60.0f;
+  static constexpr float DEFAULT_FOV_MULTIPLIER = 1.0f;
+
+  float m_fov_x_multiplier = DEFAULT_FOV_MULTIPLIER;
+  float m_fov_y_multiplier = DEFAULT_FOV_MULTIPLIER;
+  float m_speed = DEFAULT_SPEED;
+  bool m_dirty = false;
 };
 
 class FreeLookCamera
 {
 public:
   FreeLookCamera();
   void SetControlType(FreeLook::ControlType type);
-  Common::Matrix44 GetView();
-  Common::Vec2 GetFieldOfView() const;
-
-  void MoveVertical(float amt);
-  void MoveHorizontal(float amt);
-  void MoveForward(float amt);
-
-  void Rotate(const Common::Vec3& amt);
-  void Rotate(const Common::Quaternion& amt);
-
-  void IncreaseFovX(float fov);
-  void IncreaseFovY(float fov);
-  float GetFovStepSize() const;
-
-  void Reset();
+  Common::Matrix44 GetView() const;
+  Common::Vec2 GetFieldOfViewMultiplier() const;
 
   void DoState(PointerWrap& p);
 
-  bool IsDirty() const;
-  void SetClean();
-
-  void ModifySpeed(float multiplier);
-  void ResetSpeed();
-  float GetSpeed() const;
-
   bool IsActive() const;
 
+  CameraController* GetController() const;
+
 private:
-  bool m_dirty = false;
-  float m_fov_x = 1.0f;
-  float m_fov_y = 1.0f;
   std::optional<FreeLook::ControlType> m_current_type;
   std::unique_ptr<CameraController> m_camera_controller;
-
-  float m_min_fov_multiplier = 0.025f;
-  float m_speed = 60.0f;
 };
 
 extern FreeLookCamera g_freelook_camera;
diff --git a/Source/Core/VideoCommon/VertexShaderManager.cpp b/Source/Core/VideoCommon/VertexShaderManager.cpp
@@ -356,7 +356,7 @@ void VertexShaderManager::SetConstants()
     }
   }
 
-  if (bProjectionChanged || g_freelook_camera.IsDirty())
+  if (bProjectionChanged || g_freelook_camera.GetController()->IsDirty())
   {
     bProjectionChanged = false;
 
@@ -366,16 +366,21 @@ void VertexShaderManager::SetConstants()
     {
     case ProjectionType::Perspective:
     {
-      const Common::Vec2 fov =
-          g_freelook_camera.IsActive() ? g_freelook_camera.GetFieldOfView() : Common::Vec2{1, 1};
-      g_fProjectionMatrix[0] = rawProjection[0] * g_ActiveConfig.fAspectRatioHackW * fov.x;
+      const Common::Vec2 fov_multiplier = g_freelook_camera.IsActive() ?
+                                              g_freelook_camera.GetFieldOfViewMultiplier() :
+                                              Common::Vec2{1, 1};
+      g_fProjectionMatrix[0] =
+          rawProjection[0] * g_ActiveConfig.fAspectRatioHackW * fov_multiplier.x;
       g_fProjectionMatrix[1] = 0.0f;
-      g_fProjectionMatrix[2] = rawProjection[1] * g_ActiveConfig.fAspectRatioHackW * fov.x;
+      g_fProjectionMatrix[2] =
+          rawProjection[1] * g_ActiveConfig.fAspectRatioHackW * fov_multiplier.x;
       g_fProjectionMatrix[3] = 0.0f;
 
       g_fProjectionMatrix[4] = 0.0f;
-      g_fProjectionMatrix[5] = rawProjection[2] * g_ActiveConfig.fAspectRatioHackH * fov.y;
-      g_fProjectionMatrix[6] = rawProjection[3] * g_ActiveConfig.fAspectRatioHackH * fov.y;
+      g_fProjectionMatrix[5] =
+          rawProjection[2] * g_ActiveConfig.fAspectRatioHackH * fov_multiplier.y;
+      g_fProjectionMatrix[6] =
+          rawProjection[3] * g_ActiveConfig.fAspectRatioHackH * fov_multiplier.y;
       g_fProjectionMatrix[7] = 0.0f;
 
       g_fProjectionMatrix[8] = 0.0f;
@@ -435,7 +440,7 @@ void VertexShaderManager::SetConstants()
 
     memcpy(constants.projection.data(), corrected_matrix.data.data(), 4 * sizeof(float4));
 
-    g_freelook_camera.SetClean();
+    g_freelook_camera.GetController()->SetClean();
 
     dirty = true;
   }