Move new camera settings to the Settings Registry and connect them to viewport border elements (#1267)

* ensure the new camera respects changing ui values and move camera settings to the settings registry

* factor out creation of modular camera controller

* small updates before posting PR

* updates following review feedback

* updates following review feedback

Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.cpp

@@ -28,19 +28,8 @@ namespace AzFramework
         nullptr,
         AZ::ConsoleFunctorFlags::Null,
         "The default height of the ground plane to do intersection tests against when orbiting");
-    AZ_CVAR(float, ed_cameraSystemBoostMultiplier, 3.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
-    AZ_CVAR(float, ed_cameraSystemTranslateSpeed, 10.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
-    AZ_CVAR(float, ed_cameraSystemOrbitDollyScrollSpeed, 0.02f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
-    AZ_CVAR(float, ed_cameraSystemOrbitDollyCursorSpeed, 0.01f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
-    AZ_CVAR(float, ed_cameraSystemScrollTranslateSpeed, 0.02f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
     AZ_CVAR(float, ed_cameraSystemMinOrbitDistance, 10.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
     AZ_CVAR(float, ed_cameraSystemMaxOrbitDistance, 50.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
-    AZ_CVAR(float, ed_cameraSystemLookSmoothness, 5.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
-    AZ_CVAR(float, ed_cameraSystemTranslateSmoothness, 5.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
-    AZ_CVAR(float, ed_cameraSystemRotateSpeed, 0.005f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
-    AZ_CVAR(float, ed_cameraSystemPanSpeed, 0.01f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
-    AZ_CVAR(bool, ed_cameraSystemPanInvertX, true, nullptr, AZ::ConsoleFunctorFlags::Null, "");
-    AZ_CVAR(bool, ed_cameraSystemPanInvertY, true, nullptr, AZ::ConsoleFunctorFlags::Null, "");
 
     AZ_CVAR(
         AZ::CVarFixedString, ed_cameraSystemTranslateForwardKey, "keyboard_key_alphanumeric_W", nullptr, AZ::ConsoleFunctorFlags::Null, "");
@@ -121,6 +110,13 @@ namespace AzFramework
 
     AZ_CONSOLEFREEFUNC(ReloadCameraKeyBindingsConsole, AZ::ConsoleFunctorFlags::Null, "Reload keybindings for the modern camera system");
 
+    //! return -1.0f if inverted, 1.0f otherwise
+    constexpr static float Invert(const bool invert)
+    {
+        constexpr float Dir[] = { 1.0f, -1.0f };
+        return Dir[aznumeric_cast<int>(invert)];
+    };
+
     // Based on paper by David Eberly - https://www.geometrictools.com/Documentation/EulerAngles.pdf
     AZ::Vector3 EulerAngles(const AZ::Matrix3x3& orientation)
     {
@@ -291,6 +287,20 @@ namespace AzFramework
     RotateCameraInput::RotateCameraInput(const InputChannelId rotateChannelId)
         : m_rotateChannelId(rotateChannelId)
     {
+        m_rotateSpeedFn = []() constexpr
+        {
+            return 0.005f;
+        };
+
+        m_invertPitchFn = []() constexpr
+        {
+            return false;
+        };
+
+        m_invertYawFn = []() constexpr
+        {
+            return false;
+        };
     }
 
     bool RotateCameraInput::HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, [[maybe_unused]] float scrollDelta)
@@ -341,8 +351,9 @@ namespace AzFramework
     {
         Camera nextCamera = targetCamera;
 
-        nextCamera.m_pitch -= float(cursorDelta.m_y) * ed_cameraSystemRotateSpeed;
+        const float rotateSpeed = m_rotateSpeedFn();
-        nextCamera.m_yaw -= float(cursorDelta.m_x) * ed_cameraSystemRotateSpeed;
+        nextCamera.m_pitch -= float(cursorDelta.m_y) * rotateSpeed * Invert(m_invertPitchFn());
+        nextCamera.m_yaw -= float(cursorDelta.m_x) * rotateSpeed * Invert(m_invertYawFn());
 
         const auto clampRotation = [](const float angle)
         {
@@ -360,6 +371,20 @@ namespace AzFramework
         : m_panAxesFn(AZStd::move(panAxesFn))
         , m_panChannelId(panChannelId)
     {
+        m_panSpeedFn = []() constexpr
+        {
+            return 0.01f;
+        };
+
+        m_invertPanXFn = []() constexpr
+        {
+            return true;
+        };
+
+        m_invertPanYFn = []() constexpr
+        {
+            return true;
+        };
     }
 
     bool PanCameraInput::HandleEvents(
@@ -393,17 +418,12 @@ namespace AzFramework
 
         const auto panAxes = m_panAxesFn(nextCamera);
 
-        const auto deltaPanX = float(cursorDelta.m_x) * panAxes.m_horizontalAxis * ed_cameraSystemPanSpeed;
+        const float panSpeed = m_panSpeedFn();
-        const auto deltaPanY = float(cursorDelta.m_y) * panAxes.m_verticalAxis * ed_cameraSystemPanSpeed;
+        const auto deltaPanX = float(cursorDelta.m_x) * panAxes.m_horizontalAxis * panSpeed;
+        const auto deltaPanY = float(cursorDelta.m_y) * panAxes.m_verticalAxis * panSpeed;
 
-        const auto inv = [](const bool invert)
+        nextCamera.m_lookAt += deltaPanX * Invert(m_invertPanXFn());
-        {
+        nextCamera.m_lookAt += deltaPanY * -Invert(m_invertPanYFn());
-            constexpr float Dir[] = { 1.0f, -1.0f };
-            return Dir[aznumeric_cast<int>(invert)];
-        };
-
-        nextCamera.m_lookAt += deltaPanX * inv(ed_cameraSystemPanInvertX);
-        nextCamera.m_lookAt += deltaPanY * -inv(ed_cameraSystemPanInvertY);
 
         return nextCamera;
     }
@@ -446,6 +466,15 @@ namespace AzFramework
     TranslateCameraInput::TranslateCameraInput(TranslationAxesFn translationAxesFn)
         : m_translationAxesFn(AZStd::move(translationAxesFn))
     {
+        m_translateSpeedFn = []() constexpr
+        {
+            return 10.0f;
+        };
+
+        m_boostMultiplierFn = []() constexpr
+        {
+            return 3.0f;
+        };
     }
 
     bool TranslateCameraInput::HandleEvents(
@@ -497,9 +526,9 @@ namespace AzFramework
         const auto axisY = translationBasis.GetBasisY();
         const auto axisZ = translationBasis.GetBasisZ();
 
-        const float speed = [boost = m_boost]()
+        const float speed = [boost = m_boost, &translateSpeedFn = m_translateSpeedFn, &boostMultiplierFn = m_boostMultiplierFn]()
         {
-            return ed_cameraSystemTranslateSpeed * (boost ? ed_cameraSystemBoostMultiplier : 1.0f);
+            return translateSpeedFn() * (boost ? boostMultiplierFn() : 1.0f);
         }();
 
         if ((m_translation & TranslationType::Forward) == TranslationType::Forward)
@@ -632,6 +661,14 @@ namespace AzFramework
         return nextCamera;
     }
 
+    OrbitDollyScrollCameraInput::OrbitDollyScrollCameraInput()
+    {
+        m_scrollSpeedFn = []() constexpr
+        {
+            return 0.03f;
+        };
+    }
+
     bool OrbitDollyScrollCameraInput::HandleEvents(
         const InputEvent& event, [[maybe_unused]] const ScreenVector& cursorDelta, [[maybe_unused]] float scrollDelta)
     {
@@ -650,7 +687,7 @@ namespace AzFramework
         [[maybe_unused]] const float deltaTime)
     {
         Camera nextCamera = targetCamera;
-        nextCamera.m_lookDist = AZ::GetMin(nextCamera.m_lookDist + scrollDelta * ed_cameraSystemOrbitDollyScrollSpeed, 0.0f);
+        nextCamera.m_lookDist = AZ::GetMin(nextCamera.m_lookDist + scrollDelta * m_scrollSpeedFn(), 0.0f);
         EndActivation();
         return nextCamera;
     }
@@ -658,6 +695,10 @@ namespace AzFramework
     OrbitDollyCursorMoveCameraInput::OrbitDollyCursorMoveCameraInput(const InputChannelId dollyChannelId)
         : m_dollyChannelId(dollyChannelId)
     {
+        m_cursorSpeedFn = []() constexpr
+        {
+            return 0.01f;
+        };
     }
 
     bool OrbitDollyCursorMoveCameraInput::HandleEvents(
@@ -688,10 +729,18 @@ namespace AzFramework
         [[maybe_unused]] const float deltaTime)
     {
         Camera nextCamera = targetCamera;
-        nextCamera.m_lookDist = AZ::GetMin(nextCamera.m_lookDist + float(cursorDelta.m_y) * ed_cameraSystemOrbitDollyCursorSpeed, 0.0f);
+        nextCamera.m_lookDist = AZ::GetMin(nextCamera.m_lookDist + float(cursorDelta.m_y) * m_cursorSpeedFn(), 0.0f);
         return nextCamera;
     }
 
+    ScrollTranslationCameraInput::ScrollTranslationCameraInput()
+    {
+        m_scrollSpeedFn = []() constexpr
+        {
+            return 0.02f;
+        };
+    }
+
     bool ScrollTranslationCameraInput::HandleEvents(
         const InputEvent& event, [[maybe_unused]] const ScreenVector& cursorDelta, [[maybe_unused]] float scrollDelta)
     {
@@ -714,14 +763,14 @@ namespace AzFramework
         const auto translation_basis = LookTranslation(nextCamera);
         const auto axisY = translation_basis.GetBasisY();
 
-        nextCamera.m_lookAt += axisY * scrollDelta * ed_cameraSystemScrollTranslateSpeed;
+        nextCamera.m_lookAt += axisY * scrollDelta * m_scrollSpeedFn();
 
         EndActivation();
 
         return nextCamera;
     }
 
-    Camera SmoothCamera(const Camera& currentCamera, const Camera& targetCamera, const float deltaTime)
+    Camera SmoothCamera(const Camera& currentCamera, const Camera& targetCamera, const CameraProps& cameraProps, const float deltaTime)
     {
         const auto clamp_rotation = [](const float angle)
         {
@@ -748,11 +797,11 @@ namespace AzFramework
         Camera camera;
         // note: the math for the lerp smoothing implementation for camera rotation and translation was inspired by this excellent
         // article by Scott Lembcke: https://www.gamasutra.com/blogs/ScottLembcke/20180404/316046/Improved_Lerp_Smoothing.php
-        const float lookRate = AZStd::exp2(ed_cameraSystemLookSmoothness);
+        const float lookRate = AZStd::exp2(cameraProps.m_rotateSmoothnessFn());
         const float lookT = AZStd::exp2(-lookRate * deltaTime);
         camera.m_pitch = AZ::Lerp(targetCamera.m_pitch, currentCamera.m_pitch, lookT);
         camera.m_yaw = AZ::Lerp(targetYaw, currentYaw, lookT);
-        const float moveRate = AZStd::exp2(ed_cameraSystemTranslateSmoothness);
+        const float moveRate = AZStd::exp2(cameraProps.m_translateSmoothnessFn());
         const float moveT = AZStd::exp2(-moveRate * deltaTime);
         camera.m_lookDist = AZ::Lerp(targetCamera.m_lookDist, currentCamera.m_lookDist, moveT);
         camera.m_lookAt = targetCamera.m_lookAt.Lerp(currentCamera.m_lookAt, moveT);

Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.h

@@ -170,7 +170,14 @@ namespace AzFramework
         Activation m_activation = Activation::Idle;
     };
 
-    Camera SmoothCamera(const Camera& currentCamera, const Camera& targetCamera, float deltaTime);
+    //! Properties to use to configure behavior across all types of camera.
+    struct CameraProps
+    {
+        AZStd::function<float()> m_rotateSmoothnessFn; //!< Rotate smoothing value (useful approx range 3-6, higher values give sharper feel).
+        AZStd::function<float()> m_translateSmoothnessFn; //!< Translate smoothing value (useful approx range 3-6, higher values give sharper feel).
+    };
+
+    Camera SmoothCamera(const Camera& currentCamera, const Camera& targetCamera, const CameraProps& cameraProps, float deltaTime);
 
     class Cameras
     {
@@ -225,6 +232,10 @@ namespace AzFramework
         bool HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
         Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
 
+        AZStd::function<float()> m_rotateSpeedFn;
+        AZStd::function<bool()> m_invertPitchFn;
+        AZStd::function<bool()> m_invertYawFn;
+
     private:
         InputChannelId m_rotateChannelId;
         ClickDetector m_clickDetector;
@@ -267,6 +278,10 @@ namespace AzFramework
         bool HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
         Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
 
+        AZStd::function<float()> m_panSpeedFn;
+        AZStd::function<bool()> m_invertPanXFn;
+        AZStd::function<bool()> m_invertPanYFn;
+
     private:
         PanAxesFn m_panAxesFn;
         InputChannelId m_panChannelId;
@@ -310,6 +325,9 @@ namespace AzFramework
         Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
         void ResetImpl() override;
 
+        AZStd::function<float()> m_translateSpeedFn;
+        AZStd::function<float()> m_boostMultiplierFn;
+
     private:
         enum class TranslationType
         {
@@ -375,9 +393,13 @@ namespace AzFramework
     class OrbitDollyScrollCameraInput : public CameraInput
     {
     public:
+        OrbitDollyScrollCameraInput();
+
         // CameraInput overrides ...
         bool HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
         Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
+
+        AZStd::function<float()> m_scrollSpeedFn;
     };
 
     class OrbitDollyCursorMoveCameraInput : public CameraInput
@@ -389,6 +411,8 @@ namespace AzFramework
         bool HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
         Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
 
+        AZStd::function<float()> m_cursorSpeedFn;
+
     private:
         InputChannelId m_dollyChannelId;
     };
@@ -396,9 +420,13 @@ namespace AzFramework
     class ScrollTranslationCameraInput : public CameraInput
     {
     public:
+        ScrollTranslationCameraInput();
+
         // CameraInput overrides ...
         bool HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
         Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
+
+        AZStd::function<float()> m_scrollSpeedFn;
     };
 
     class OrbitCameraInput : public CameraInput

Code/Sandbox/Editor/Core/LevelEditorMenuHandler.cpp

@@ -759,11 +759,6 @@ QMenu* LevelEditorMenuHandler::CreateViewMenu()
 
     viewportViewsMenuWrapper.AddSeparator();
 
-    auto changeMoveSpeedMenu = viewportViewsMenuWrapper.AddMenu(tr("Change Move Speed"));
-    changeMoveSpeedMenu.AddAction(ID_CHANGEMOVESPEED_INCREASE);
-    changeMoveSpeedMenu.AddAction(ID_CHANGEMOVESPEED_DECREASE);
-    changeMoveSpeedMenu.AddAction(ID_CHANGEMOVESPEED_CHANGESTEP);
-
     auto switchCameraMenu = viewportViewsMenuWrapper.AddMenu(tr("Switch Camera"));
     switchCameraMenu.AddAction(ID_SWITCHCAMERA_DEFAULTCAMERA);
     switchCameraMenu.AddAction(ID_SWITCHCAMERA_SEQUENCECAMERA);

Code/Sandbox/Editor/CryEdit.cpp

@@ -441,9 +441,6 @@ void CCryEditApp::RegisterActionHandlers()
     ON_COMMAND(ID_VIEW_CYCLE2DVIEWPORT, OnViewCycle2dviewport)
 #endif
     ON_COMMAND(ID_DISPLAY_GOTOPOSITION, OnDisplayGotoPosition)
-    ON_COMMAND(ID_CHANGEMOVESPEED_INCREASE, OnChangemovespeedIncrease)
-    ON_COMMAND(ID_CHANGEMOVESPEED_DECREASE, OnChangemovespeedDecrease)
-    ON_COMMAND(ID_CHANGEMOVESPEED_CHANGESTEP, OnChangemovespeedChangestep)
     ON_COMMAND(ID_FILE_SAVELEVELRESOURCES, OnFileSavelevelresources)
     ON_COMMAND(ID_CLEAR_REGISTRY, OnClearRegistryData)
     ON_COMMAND(ID_VALIDATELEVEL, OnValidatelevel)
@@ -3706,38 +3703,6 @@ void CCryEditApp::OnDisplayGotoPosition()
     dialog.exec();
 }
 
-//////////////////////////////////////////////////////////////////////////
-void CCryEditApp::OnChangemovespeedIncrease()
-{
-    gSettings.cameraMoveSpeed += m_moveSpeedStep;
-    if (gSettings.cameraMoveSpeed < 0.01f)
-    {
-        gSettings.cameraMoveSpeed = 0.01f;
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-void CCryEditApp::OnChangemovespeedDecrease()
-{
-    gSettings.cameraMoveSpeed -= m_moveSpeedStep;
-    if (gSettings.cameraMoveSpeed < 0.01f)
-    {
-        gSettings.cameraMoveSpeed = 0.01f;
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-void CCryEditApp::OnChangemovespeedChangestep()
-{
-    bool ok = false;
-    int fractionalDigitCount = 5;
-    float step = aznumeric_caster(QInputDialog::getDouble(AzToolsFramework::GetActiveWindow(), QObject::tr("Change Move Increase/Decrease Step"), QStringLiteral(""), m_moveSpeedStep, std::numeric_limits<float>::lowest(), std::numeric_limits<float>::max(), fractionalDigitCount, &ok));
-    if (ok)
-    {
-        m_moveSpeedStep = step;
-    }
-}
-
 //////////////////////////////////////////////////////////////////////////
 void CCryEditApp::OnFileSavelevelresources()
 {

Code/Sandbox/Editor/CryEdit.h

@@ -408,9 +408,6 @@ private:
     void OnToolsScriptHelp();
     void OnViewCycle2dviewport();
     void OnDisplayGotoPosition();
-    void OnChangemovespeedIncrease();
-    void OnChangemovespeedDecrease();
-    void OnChangemovespeedChangestep();
     void OnFileSavelevelresources();
     void OnClearRegistryData();
     void OnValidatelevel();

Code/Sandbox/Editor/EditorPreferencesPageViewportMovement.cpp

@@ -17,7 +17,7 @@
 
 // Editor
 #include "Settings.h"
-
+#include "EditorViewportSettings.h"
 
 void CEditorPreferencesPage_ViewportMovement::Reflect(AZ::SerializeContext& serialize)
 {
@@ -72,20 +72,45 @@ QIcon& CEditorPreferencesPage_ViewportMovement::GetIcon()
 
 void CEditorPreferencesPage_ViewportMovement::OnApply()
 {
-    gSettings.cameraMoveSpeed = m_cameraMovementSettings.m_moveSpeed;
+    if (SandboxEditor::UsingNewCameraSystem())
-    gSettings.cameraRotateSpeed = m_cameraMovementSettings.m_rotateSpeed;
+    {
-    gSettings.cameraFastMoveSpeed = m_cameraMovementSettings.m_fastMoveSpeed;
+        SandboxEditor::SetCameraTranslateSpeed(m_cameraMovementSettings.m_moveSpeed);
-    gSettings.wheelZoomSpeed = m_cameraMovementSettings.m_wheelZoomSpeed;
+        SandboxEditor::SetCameraRotateSpeed(m_cameraMovementSettings.m_rotateSpeed);
-    gSettings.invertYRotation = m_cameraMovementSettings.m_invertYRotation;
+        SandboxEditor::SetCameraBoostMultiplier(m_cameraMovementSettings.m_fastMoveSpeed);
-    gSettings.invertPan = m_cameraMovementSettings.m_invertPan;
+        SandboxEditor::SetCameraScrollSpeed(m_cameraMovementSettings.m_wheelZoomSpeed);
+        SandboxEditor::SetCameraOrbitYawRotationInverted(m_cameraMovementSettings.m_invertYRotation);
+        SandboxEditor::SetCameraPanInvertedX(m_cameraMovementSettings.m_invertPan);
+        SandboxEditor::SetCameraPanInvertedY(m_cameraMovementSettings.m_invertPan);
+    }
+    else
+    {
+        gSettings.cameraMoveSpeed = m_cameraMovementSettings.m_moveSpeed;
+        gSettings.cameraRotateSpeed = m_cameraMovementSettings.m_rotateSpeed;
+        gSettings.cameraFastMoveSpeed = m_cameraMovementSettings.m_fastMoveSpeed;
+        gSettings.wheelZoomSpeed = m_cameraMovementSettings.m_wheelZoomSpeed;
+        gSettings.invertYRotation = m_cameraMovementSettings.m_invertYRotation;
+        gSettings.invertPan = m_cameraMovementSettings.m_invertPan;
+    }
 }
 
 void CEditorPreferencesPage_ViewportMovement::InitializeSettings()
 {
-    m_cameraMovementSettings.m_moveSpeed = gSettings.cameraMoveSpeed;
+    if (SandboxEditor::UsingNewCameraSystem())
-    m_cameraMovementSettings.m_rotateSpeed = gSettings.cameraRotateSpeed;
+    {
-    m_cameraMovementSettings.m_fastMoveSpeed = gSettings.cameraFastMoveSpeed;
+        m_cameraMovementSettings.m_moveSpeed = SandboxEditor::CameraTranslateSpeed();
-    m_cameraMovementSettings.m_wheelZoomSpeed = gSettings.wheelZoomSpeed;
+        m_cameraMovementSettings.m_rotateSpeed = SandboxEditor::CameraRotateSpeed();
-    m_cameraMovementSettings.m_invertYRotation = gSettings.invertYRotation;
+        m_cameraMovementSettings.m_fastMoveSpeed = SandboxEditor::CameraBoostMultiplier();
-    m_cameraMovementSettings.m_invertPan = gSettings.invertPan;
+        m_cameraMovementSettings.m_wheelZoomSpeed = SandboxEditor::CameraScrollSpeed();
+        m_cameraMovementSettings.m_invertYRotation = SandboxEditor::CameraOrbitYawRotationInverted();
+        m_cameraMovementSettings.m_invertPan = SandboxEditor::CameraPanInvertedX() && SandboxEditor::CameraPanInvertedY();
+    }
+    else
+    {
+        m_cameraMovementSettings.m_moveSpeed = gSettings.cameraMoveSpeed;
+        m_cameraMovementSettings.m_rotateSpeed = gSettings.cameraRotateSpeed;
+        m_cameraMovementSettings.m_fastMoveSpeed = gSettings.cameraFastMoveSpeed;
+        m_cameraMovementSettings.m_wheelZoomSpeed = gSettings.wheelZoomSpeed;
+        m_cameraMovementSettings.m_invertYRotation = gSettings.invertYRotation;
+        m_cameraMovementSettings.m_invertPan = gSettings.invertPan;
+    }
 }

Code/Sandbox/Editor/EditorViewportSettings.cpp

@@ -23,94 +23,196 @@ namespace SandboxEditor
     constexpr AZStd::string_view AngleSnappingSetting = "/Amazon/Preferences/Editor/AngleSnapping";
     constexpr AZStd::string_view AngleSizeSetting = "/Amazon/Preferences/Editor/AngleSize";
     constexpr AZStd::string_view ShowGridSetting = "/Amazon/Preferences/Editor/ShowGrid";
+    constexpr AZStd::string_view CameraTranslateSpeedSetting = "/Amazon/Preferences/Editor/Camera/TranslateSpeed";
+    constexpr AZStd::string_view CameraBoostMultiplierSetting = "/Amazon/Preferences/Editor/Camera/BoostMultiplier";
+    constexpr AZStd::string_view CameraRotateSpeedSetting = "/Amazon/Preferences/Editor/Camera/RotateSpeed";
+    constexpr AZStd::string_view CameraScrollSpeedSetting = "/Amazon/Preferences/Editor/Camera/DollyScrollSpeed";
+    constexpr AZStd::string_view CameraDollyMotionSpeedSetting = "/Amazon/Preferences/Editor/Camera/DollyMotionSpeed";
+    constexpr AZStd::string_view CameraOrbitYawRotationInvertedSetting = "/Amazon/Preferences/Editor/Camera/YawRotationInverted";
+    constexpr AZStd::string_view CameraPanInvertedXSetting = "/Amazon/Preferences/Editor/Camera/PanInvertedX";
+    constexpr AZStd::string_view CameraPanInvertedYSetting = "/Amazon/Preferences/Editor/Camera/PanInvertedY";
+    constexpr AZStd::string_view CameraPanSpeedSetting = "/Amazon/Preferences/Editor/Camera/PanSpeed";
+    constexpr AZStd::string_view CameraRotateSmoothnessSetting = "/Amazon/Preferences/Editor/Camera/RotateSmoothness";
+    constexpr AZStd::string_view CameraTranslateSmoothnessSetting = "/Amazon/Preferences/Editor/Camera/TranslateSmoothness";
+
+    template<typename T>
+    void SetRegistry(const AZStd::string_view setting, T&& value)
+    {
+        if (auto* registry = AZ::SettingsRegistry::Get())
+        {
+            registry->Set(setting, AZStd::forward<T>(value));
+        }
+    }
+
+    template<typename T>
+    AZStd::remove_cvref_t<T> GetRegistry(const AZStd::string_view setting, T&& defaultValue)
+    {
+        AZStd::remove_cvref_t<T> value = AZStd::forward<T>(defaultValue);
+        if (auto* registry = AZ::SettingsRegistry::Get())
+        {
+            registry->Get(value, setting);
+        }
+
+        return value;
+    }
 
     bool GridSnappingEnabled()
     {
-        bool enabled = false;
+        return GetRegistry(GridSnappingSetting, false);
-        if (auto* registry = AZ::SettingsRegistry::Get())
-        {
-            registry->Get(enabled, GridSnappingSetting);
-        }
-        return enabled;
-    }
-
-    float GridSnappingSize()
-    {
-        double gridSize = 0.1;
-        if (auto* registry = AZ::SettingsRegistry::Get())
-        {
-            registry->Get(gridSize, GridSizeSetting);
-        }
-        return aznumeric_cast<float>(gridSize);
-    }
-
-    bool AngleSnappingEnabled()
-    {
-        bool enabled = false;
-        if (auto* registry = AZ::SettingsRegistry::Get())
-        {
-            registry->Get(enabled, AngleSnappingSetting);
-        }
-        return enabled;
-    }
-
-    float AngleSnappingSize()
-    {
-        double angleSize = 5.0;
-        if (auto* registry = AZ::SettingsRegistry::Get())
-        {
-            registry->Get(angleSize, AngleSizeSetting);
-        }
-        return aznumeric_cast<float>(angleSize);
-    }
-
-    bool ShowingGrid()
-    {
-        bool enabled = false;
-        if (auto* registry = AZ::SettingsRegistry::Get())
-        {
-            registry->Get(enabled, ShowGridSetting);
-        }
-        return enabled;
     }
 
     void SetGridSnapping(const bool enabled)
     {
-        if (auto* registry = AZ::SettingsRegistry::Get())
+        SetRegistry(GridSnappingSetting, enabled);
-        {
+    }
-            registry->Set(GridSnappingSetting, enabled);
+
-        }
+    float GridSnappingSize()
+    {
+        return aznumeric_cast<float>(GetRegistry(GridSizeSetting, 0.1));
     }
 
     void SetGridSnappingSize(const float size)
     {
-        if (auto* registry = AZ::SettingsRegistry::Get())
+        SetRegistry(GridSizeSetting, size);
-        {
+    }
-            registry->Set(GridSizeSetting, size);
+
-        }
+    bool AngleSnappingEnabled()
+    {
+        return GetRegistry(AngleSnappingSetting, false);
     }
 
     void SetAngleSnapping(const bool enabled)
     {
-        if (auto* registry = AZ::SettingsRegistry::Get())
+        SetRegistry(AngleSnappingSetting, enabled);
-        {
+    }
-            registry->Set(AngleSnappingSetting, enabled);
+
-        }
+    float AngleSnappingSize()
+    {
+        return aznumeric_cast<float>(GetRegistry(AngleSizeSetting, 5.0));
     }
 
     void SetAngleSnappingSize(const float size)
     {
-        if (auto* registry = AZ::SettingsRegistry::Get())
+        SetRegistry(AngleSizeSetting, size);
-        {
+    }
-            registry->Set(AngleSizeSetting, size);
+
-        }
+    bool ShowingGrid()
+    {
+        return GetRegistry(ShowGridSetting, false);
     }
 
     void SetShowingGrid(const bool showing)
     {
-        if (auto* registry = AZ::SettingsRegistry::Get())
+        SetRegistry(ShowGridSetting, showing);
-        {
+    }
-            registry->Set(ShowGridSetting, showing);
+
-        }
+    float CameraTranslateSpeed()
+    {
+        return aznumeric_cast<float>(GetRegistry(CameraTranslateSpeedSetting, 10.0));
+    }
+
+    void SetCameraTranslateSpeed(const float speed)
+    {
+        SetRegistry(CameraTranslateSpeedSetting, speed);
+    }
+
+    float CameraBoostMultiplier()
+    {
+        return aznumeric_cast<float>(GetRegistry(CameraBoostMultiplierSetting, 3.0));
+    }
+
+    void SetCameraBoostMultiplier(const float multiplier)
+    {
+        SetRegistry(CameraBoostMultiplierSetting, multiplier);
+    }
+
+    float CameraRotateSpeed()
+    {
+        return aznumeric_cast<float>(GetRegistry(CameraRotateSpeedSetting, 0.005));
+    }
+
+    void SetCameraRotateSpeed(const float speed)
+    {
+        SetRegistry(CameraRotateSpeedSetting, speed);
+    }
+
+    float CameraScrollSpeed()
+    {
+        return aznumeric_cast<float>(GetRegistry(CameraScrollSpeedSetting, 0.02));
+    }
+
+    void SetCameraScrollSpeed(const float speed)
+    {
+        SetRegistry(CameraScrollSpeedSetting, speed);
+    }
+
+    float CameraDollyMotionSpeed()
+    {
+        return aznumeric_cast<float>(GetRegistry(CameraDollyMotionSpeedSetting, 0.01));
+    }
+
+    void SetCameraDollyMotionSpeed(const float speed)
+    {
+        SetRegistry(CameraDollyMotionSpeedSetting, speed);
+    }
+
+    bool CameraOrbitYawRotationInverted()
+    {
+        return GetRegistry(CameraOrbitYawRotationInvertedSetting, false);
+    }
+
+    void SetCameraOrbitYawRotationInverted(const bool inverted)
+    {
+        SetRegistry(CameraOrbitYawRotationInvertedSetting, inverted);
+    }
+
+    bool CameraPanInvertedX()
+    {
+        return GetRegistry(CameraPanInvertedXSetting, true);
+    }
+
+    void SetCameraPanInvertedX(const bool inverted)
+    {
+        SetRegistry(CameraPanInvertedXSetting, inverted);
+    }
+
+    bool CameraPanInvertedY()
+    {
+        return GetRegistry(CameraPanInvertedYSetting, true);
+    }
+
+    void SetCameraPanInvertedY(const bool inverted)
+    {
+        SetRegistry(CameraPanInvertedYSetting, inverted);
+    }
+
+    float CameraPanSpeed()
+    {
+        return aznumeric_cast<float>(GetRegistry(CameraPanSpeedSetting, 0.01));
+    }
+
+    void SetCameraPanSpeed(float speed)
+    {
+        SetRegistry(CameraPanSpeedSetting, speed);
+    }
+
+    float CameraRotateSmoothness()
+    {
+        return aznumeric_cast<float>(GetRegistry(CameraRotateSmoothnessSetting, 5.0));
+    }
+
+    void SetCameraRotateSmoothness(const float smoothness)
+    {
+        SetRegistry(CameraRotateSmoothnessSetting, smoothness);
+    }
+
+    float CameraTranslateSmoothness()
+    {
+        return aznumeric_cast<float>(GetRegistry(CameraTranslateSmoothnessSetting, 5.0));
+    }
+
+    void SetCameraTranslateSmoothness(const float smoothness)
+    {
+        SetRegistry(CameraTranslateSmoothnessSetting, smoothness);
     }
 } // namespace SandboxEditor

Code/Sandbox/Editor/EditorViewportSettings.h

@@ -17,25 +17,53 @@
 namespace SandboxEditor
 {
     SANDBOX_API bool GridSnappingEnabled();
-
-    SANDBOX_API float GridSnappingSize();
-
-    SANDBOX_API bool AngleSnappingEnabled();
-
-    SANDBOX_API float AngleSnappingSize();
-
-    SANDBOX_API bool ShowingGrid();
-
     SANDBOX_API void SetGridSnapping(bool enabled);
 
+    SANDBOX_API float GridSnappingSize();
     SANDBOX_API void SetGridSnappingSize(float size);
 
+    SANDBOX_API bool AngleSnappingEnabled();
     SANDBOX_API void SetAngleSnapping(bool enabled);
 
+    SANDBOX_API float AngleSnappingSize();
     SANDBOX_API void SetAngleSnappingSize(float size);
 
+    SANDBOX_API bool ShowingGrid();
     SANDBOX_API void SetShowingGrid(bool showing);
 
+    SANDBOX_API float CameraTranslateSpeed();
+    SANDBOX_API void SetCameraTranslateSpeed(float speed);
+
+    SANDBOX_API float CameraBoostMultiplier();
+    SANDBOX_API void SetCameraBoostMultiplier(float multiplier);
+
+    SANDBOX_API float CameraRotateSpeed();
+    SANDBOX_API void SetCameraRotateSpeed(float speed);
+
+    SANDBOX_API float CameraScrollSpeed();
+    SANDBOX_API void SetCameraScrollSpeed(float speed);
+
+    SANDBOX_API float CameraDollyMotionSpeed();
+    SANDBOX_API void SetCameraDollyMotionSpeed(float speed);
+
+    SANDBOX_API bool CameraOrbitYawRotationInverted();
+    SANDBOX_API void SetCameraOrbitYawRotationInverted(bool inverted);
+
+    SANDBOX_API bool CameraPanInvertedX();
+    SANDBOX_API void SetCameraPanInvertedX(bool inverted);
+
+    SANDBOX_API bool CameraPanInvertedY();
+    SANDBOX_API void SetCameraPanInvertedY(bool inverted);
+
+    SANDBOX_API float CameraPanSpeed();
+    SANDBOX_API void SetCameraPanSpeed(float speed);
+
+    SANDBOX_API float CameraRotateSmoothness();
+    SANDBOX_API void SetCameraRotateSmoothness(float smoothness);
+
+    SANDBOX_API float CameraTranslateSmoothness();
+    SANDBOX_API void SetCameraTranslateSmoothness(float smoothness);
+
     //! Return if the new editor camera system is enabled or not.
     //! @note This is implemented in EditorViewportWidget.cpp
     SANDBOX_API bool UsingNewCameraSystem();

Code/Sandbox/Editor/EditorViewportWidget.cpp

@@ -13,7 +13,6 @@
 
 // Description : implementation filefov
 
-
 #include "EditorDefs.h"
 
 #include "EditorViewportWidget.h"
@@ -173,6 +172,7 @@ namespace AZ::ViewportHelpers
         {
             m_renderViewport.OnStopPlayInEditor();
         }
+
     private:
         EditorViewportWidget& m_renderViewport;
     };
@@ -402,7 +402,7 @@ void EditorViewportWidget::InjectFakeMouseMove(int deltaX, int deltaY, Qt::Mouse
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool  EditorViewportWidget::event(QEvent* event)
+bool EditorViewportWidget::event(QEvent* event)
 {
     switch (event->type())
     {
@@ -479,7 +479,6 @@ void EditorViewportWidget::Update()
     }
     m_updatingCameraPosition = false;
 
-
     // Don't wait for changes to update the focused viewport.
     if (CheckRespondToInput())
     {
@@ -1205,6 +1204,166 @@ bool EditorViewportWidget::ShowingWorldSpace()
     return BuildKeyboardModifiers(QGuiApplication::queryKeyboardModifiers()).Shift();
 }
 
+AZStd::shared_ptr<AtomToolsFramework::ModularViewportCameraController> CreateModularViewportCameraController(
+    AzFramework::ViewportId viewportId)
+{
+    AzFramework::ReloadCameraKeyBindings();
+
+    auto controller = AZStd::make_shared<AtomToolsFramework::ModularViewportCameraController>();
+    controller->SetCameraPropsBuilderCallback(
+        [](AzFramework::CameraProps& cameraProps)
+        {
+            cameraProps.m_rotateSmoothnessFn = []
+            {
+                return SandboxEditor::CameraRotateSmoothness();
+            };
+
+            cameraProps.m_translateSmoothnessFn = []
+            {
+                return SandboxEditor::CameraTranslateSmoothness();
+            };
+        });
+
+    controller->SetCameraListBuilderCallback(
+        [viewportId](AzFramework::Cameras& cameras)
+        {
+            auto firstPersonRotateCamera = AZStd::make_shared<AzFramework::RotateCameraInput>(AzFramework::CameraFreeLookButton);
+            firstPersonRotateCamera->m_rotateSpeedFn = []
+            {
+                return SandboxEditor::CameraRotateSpeed();
+            };
+
+            auto firstPersonPanCamera =
+                AZStd::make_shared<AzFramework::PanCameraInput>(AzFramework::CameraFreePanButton, AzFramework::LookPan);
+            firstPersonPanCamera->m_panSpeedFn = []
+            {
+                return SandboxEditor::CameraPanSpeed();
+            };
+            firstPersonPanCamera->m_invertPanXFn = []
+            {
+                return SandboxEditor::CameraPanInvertedX();
+            };
+            firstPersonPanCamera->m_invertPanYFn = []
+            {
+                return SandboxEditor::CameraPanInvertedY();
+            };
+
+            auto firstPersonTranslateCamera = AZStd::make_shared<AzFramework::TranslateCameraInput>(AzFramework::LookTranslation);
+            firstPersonTranslateCamera->m_translateSpeedFn = []
+            {
+                return SandboxEditor::CameraTranslateSpeed();
+            };
+            firstPersonTranslateCamera->m_boostMultiplierFn = []
+            {
+                return SandboxEditor::CameraBoostMultiplier();
+            };
+
+            auto firstPersonWheelCamera = AZStd::make_shared<AzFramework::ScrollTranslationCameraInput>();
+            firstPersonWheelCamera->m_scrollSpeedFn = []
+            {
+                return SandboxEditor::CameraScrollSpeed();
+            };
+
+            auto orbitCamera = AZStd::make_shared<AzFramework::OrbitCameraInput>();
+            orbitCamera->SetLookAtFn(
+                [viewportId](const AZ::Vector3& position, const AZ::Vector3& direction) -> AZStd::optional<AZ::Vector3>
+                {
+                    AZStd::optional<AZ::Vector3> lookAtAfterInterpolation;
+                    AtomToolsFramework::ModularViewportCameraControllerRequestBus::EventResult(
+                        lookAtAfterInterpolation, viewportId,
+                        &AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::LookAtAfterInterpolation);
+
+                    // initially attempt to use the last set look at point after an interpolation has finished
+                    if (lookAtAfterInterpolation.has_value())
+                    {
+                        return *lookAtAfterInterpolation;
+                    }
+
+                    const float RayDistance = 1000.0f;
+                    AzFramework::RenderGeometry::RayRequest ray;
+                    ray.m_startWorldPosition = position;
+                    ray.m_endWorldPosition = position + direction * RayDistance;
+                    ray.m_onlyVisible = true;
+
+                    AzFramework::RenderGeometry::RayResult renderGeometryIntersectionResult;
+                    AzFramework::RenderGeometry::IntersectorBus::EventResult(
+                        renderGeometryIntersectionResult, AzToolsFramework::GetEntityContextId(),
+                        &AzFramework::RenderGeometry::IntersectorBus::Events::RayIntersect, ray);
+
+                    // attempt a ray intersection with any visible mesh and return the intersection position if successful
+                    if (renderGeometryIntersectionResult)
+                    {
+                        return renderGeometryIntersectionResult.m_worldPosition;
+                    }
+
+                    // if there is no selection or no intersection, fallback to default camera orbit behavior (ground plane
+                    // intersection)
+                    return {};
+                });
+
+            auto orbitRotateCamera = AZStd::make_shared<AzFramework::RotateCameraInput>(AzFramework::CameraOrbitLookButton);
+            orbitRotateCamera->m_rotateSpeedFn = []
+            {
+                return SandboxEditor::CameraRotateSpeed();
+            };
+            orbitRotateCamera->m_invertYawFn = []
+            {
+                return SandboxEditor::CameraOrbitYawRotationInverted();
+            };
+
+            auto orbitTranslateCamera = AZStd::make_shared<AzFramework::TranslateCameraInput>(AzFramework::OrbitTranslation);
+            orbitTranslateCamera->m_translateSpeedFn = []
+            {
+                return SandboxEditor::CameraTranslateSpeed();
+            };
+            orbitTranslateCamera->m_boostMultiplierFn = []
+            {
+                return SandboxEditor::CameraBoostMultiplier();
+            };
+
+            auto orbitDollyWheelCamera = AZStd::make_shared<AzFramework::OrbitDollyScrollCameraInput>();
+            orbitDollyWheelCamera->m_scrollSpeedFn = []
+            {
+                return SandboxEditor::CameraScrollSpeed();
+            };
+
+            auto orbitDollyMoveCamera =
+                AZStd::make_shared<AzFramework::OrbitDollyCursorMoveCameraInput>(AzFramework::CameraOrbitDollyButton);
+            orbitDollyMoveCamera->m_cursorSpeedFn = []
+            {
+                return SandboxEditor::CameraDollyMotionSpeed();
+            };
+
+            auto orbitPanCamera = AZStd::make_shared<AzFramework::PanCameraInput>(AzFramework::CameraOrbitPanButton, AzFramework::OrbitPan);
+            orbitPanCamera->m_panSpeedFn = []
+            {
+                return SandboxEditor::CameraPanSpeed();
+            };
+            orbitPanCamera->m_invertPanXFn = []
+            {
+                return SandboxEditor::CameraPanInvertedX();
+            };
+            orbitPanCamera->m_invertPanYFn = []
+            {
+                return SandboxEditor::CameraPanInvertedY();
+            };
+
+            orbitCamera->m_orbitCameras.AddCamera(orbitRotateCamera);
+            orbitCamera->m_orbitCameras.AddCamera(orbitTranslateCamera);
+            orbitCamera->m_orbitCameras.AddCamera(orbitDollyWheelCamera);
+            orbitCamera->m_orbitCameras.AddCamera(orbitDollyMoveCamera);
+            orbitCamera->m_orbitCameras.AddCamera(orbitPanCamera);
+
+            cameras.AddCamera(firstPersonRotateCamera);
+            cameras.AddCamera(firstPersonPanCamera);
+            cameras.AddCamera(firstPersonTranslateCamera);
+            cameras.AddCamera(firstPersonWheelCamera);
+            cameras.AddCamera(orbitCamera);
+        });
+
+    return controller;
+}
+
 void EditorViewportWidget::SetViewportId(int id)
 {
     CViewport::SetViewportId(id);
@@ -1229,77 +1388,7 @@ void EditorViewportWidget::SetViewportId(int id)
 
     if (ed_useNewCameraSystem)
     {
-        AzFramework::ReloadCameraKeyBindings();
+        m_renderViewport->GetControllerList()->Add(CreateModularViewportCameraController(AzFramework::ViewportId(id)));
-
-        auto controller = AZStd::make_shared<AtomToolsFramework::ModularViewportCameraController>();
-        controller->SetCameraListBuilderCallback(
-            [id](AzFramework::Cameras& cameras)
-            {
-                auto firstPersonRotateCamera = AZStd::make_shared<AzFramework::RotateCameraInput>(AzFramework::CameraFreeLookButton);
-                auto firstPersonPanCamera =
-                    AZStd::make_shared<AzFramework::PanCameraInput>(AzFramework::CameraFreePanButton, AzFramework::LookPan);
-                auto firstPersonTranslateCamera = AZStd::make_shared<AzFramework::TranslateCameraInput>(AzFramework::LookTranslation);
-                auto firstPersonWheelCamera = AZStd::make_shared<AzFramework::ScrollTranslationCameraInput>();
-
-                auto orbitCamera = AZStd::make_shared<AzFramework::OrbitCameraInput>();
-                orbitCamera->SetLookAtFn(
-                    [id](const AZ::Vector3& position, const AZ::Vector3& direction) -> AZStd::optional<AZ::Vector3>
-                    {
-                        AZStd::optional<AZ::Vector3> lookAtAfterInterpolation;
-                        AtomToolsFramework::ModularViewportCameraControllerRequestBus::EventResult(
-                            lookAtAfterInterpolation, id,
-                            &AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::LookAtAfterInterpolation);
-
-                        // initially attempt to use the last set look at point after an interpolation has finished
-                        if (lookAtAfterInterpolation.has_value())
-                        {
-                            return *lookAtAfterInterpolation;
-                        }
-
-                        const float RayDistance = 1000.0f;
-                        AzFramework::RenderGeometry::RayRequest ray;
-                        ray.m_startWorldPosition = position;
-                        ray.m_endWorldPosition = position + direction * RayDistance;
-                        ray.m_onlyVisible = true;
-
-                        AzFramework::RenderGeometry::RayResult renderGeometryIntersectionResult;
-                        AzFramework::RenderGeometry::IntersectorBus::EventResult(
-                            renderGeometryIntersectionResult, AzToolsFramework::GetEntityContextId(),
-                            &AzFramework::RenderGeometry::IntersectorBus::Events::RayIntersect, ray);
-
-                        // attempt a ray intersection with any visible mesh and return the intersection position if successful
-                        if (renderGeometryIntersectionResult)
-                        {
-                            return renderGeometryIntersectionResult.m_worldPosition;
-                        }
-
-                        // if there is no selection or no intersection, fallback to default camera orbit behavior (ground plane
-                        // intersection)
-                        return {};
-                    });
-
-                auto orbitRotateCamera = AZStd::make_shared<AzFramework::RotateCameraInput>(AzFramework::CameraOrbitLookButton);
-                auto orbitTranslateCamera = AZStd::make_shared<AzFramework::TranslateCameraInput>(AzFramework::OrbitTranslation);
-                auto orbitDollyWheelCamera = AZStd::make_shared<AzFramework::OrbitDollyScrollCameraInput>();
-                auto orbitDollyMoveCamera =
-                    AZStd::make_shared<AzFramework::OrbitDollyCursorMoveCameraInput>(AzFramework::CameraOrbitDollyButton);
-                auto orbitPanCamera =
-                    AZStd::make_shared<AzFramework::PanCameraInput>(AzFramework::CameraOrbitPanButton, AzFramework::OrbitPan);
-
-                orbitCamera->m_orbitCameras.AddCamera(orbitRotateCamera);
-                orbitCamera->m_orbitCameras.AddCamera(orbitTranslateCamera);
-                orbitCamera->m_orbitCameras.AddCamera(orbitDollyWheelCamera);
-                orbitCamera->m_orbitCameras.AddCamera(orbitDollyMoveCamera);
-                orbitCamera->m_orbitCameras.AddCamera(orbitPanCamera);
-
-                cameras.AddCamera(firstPersonRotateCamera);
-                cameras.AddCamera(firstPersonPanCamera);
-                cameras.AddCamera(firstPersonTranslateCamera);
-                cameras.AddCamera(firstPersonWheelCamera);
-                cameras.AddCamera(orbitCamera);
-            });
-
-        m_renderViewport->GetControllerList()->Add(controller);
     }
     else
     {
@@ -1367,7 +1456,7 @@ namespace AZ::ViewportHelpers
         action->setCheckable(true);
         action->setChecked(*variable);
     }
-}
+} // namespace AZ::ViewportHelpers
 
 //////////////////////////////////////////////////////////////////////////
 void EditorViewportWidget::OnTitleMenu(QMenu* menu)
@@ -1615,7 +1704,6 @@ void EditorViewportWidget::ToggleCameraObject()
     GetIEditor()->GetAnimation()->ForceAnimation();
 }
 
-
 //////////////////////////////////////////////////////////////////////////
 void EditorViewportWidget::SetCamera(const CCamera& camera)
 {
@@ -1623,30 +1711,6 @@ void EditorViewportWidget::SetCamera(const CCamera& camera)
     SetViewTM(m_Camera.GetMatrix());
 }
 
-//////////////////////////////////////////////////////////////////////////
-float EditorViewportWidget::GetCameraMoveSpeed() const
-{
-    return gSettings.cameraMoveSpeed;
-}
-
-//////////////////////////////////////////////////////////////////////////
-float EditorViewportWidget::GetCameraRotateSpeed() const
-{
-    return gSettings.cameraRotateSpeed;
-}
-
-//////////////////////////////////////////////////////////////////////////
-bool EditorViewportWidget::GetCameraInvertYRotation() const
-{
-    return gSettings.invertYRotation;
-}
-
-//////////////////////////////////////////////////////////////////////////
-float EditorViewportWidget::GetCameraInvertPan() const
-{
-    return gSettings.invertPan;
-}
-
 //////////////////////////////////////////////////////////////////////////
 EditorViewportWidget* EditorViewportWidget::GetPrimaryViewport()
 {
@@ -1946,7 +2010,6 @@ void EditorViewportWidget::RenderSelectedRegion()
             Vec3(x1, y2, fMinZ)
         };
 
-
         // Generate vertices
         static AABB boxPrev(AABB::RESET);
         static std::vector<Vec3> verts;
@@ -2508,14 +2571,14 @@ void EditorViewportWidget::SetSequenceCamera()
 }
 
 //////////////////////////////////////////////////////////////////////////
-void  EditorViewportWidget::SetComponentCamera(const AZ::EntityId& entityId)
+void EditorViewportWidget::SetComponentCamera(const AZ::EntityId& entityId)
 {
     ResetToViewSourceType(ViewSourceType::CameraComponent);
     SetViewEntity(entityId);
 }
 
 //////////////////////////////////////////////////////////////////////////
-void  EditorViewportWidget::SetEntityAsCamera(const AZ::EntityId& entityId, bool lockCameraMovement)
+void EditorViewportWidget::SetEntityAsCamera(const AZ::EntityId& entityId, bool lockCameraMovement)
 {
     ResetToViewSourceType(ViewSourceType::AZ_Entity);
     SetViewEntity(entityId, lockCameraMovement);
@@ -2764,18 +2827,18 @@ bool EditorViewportWidget::IsRenderingDisabled() const
 }
 
 //////////////////////////////////////////////////////////////////////////
-QPoint EditorViewportWidget::WidgetToViewport(const QPoint &point) const
+QPoint EditorViewportWidget::WidgetToViewport(const QPoint& point) const
 {
     return point * WidgetToViewportFactor();
 }
 
-QPoint EditorViewportWidget::ViewportToWidget(const QPoint &point) const
+QPoint EditorViewportWidget::ViewportToWidget(const QPoint& point) const
 {
     return point / WidgetToViewportFactor();
 }
 
 //////////////////////////////////////////////////////////////////////////
-QSize EditorViewportWidget::WidgetToViewport(const QSize &size) const
+QSize EditorViewportWidget::WidgetToViewport(const QSize& size) const
 {
     return size * WidgetToViewportFactor();
 }

Code/Sandbox/Editor/EditorViewportWidget.h

@@ -328,11 +328,6 @@ protected:
 
     void SetViewTM(const Matrix34& tm, bool bMoveOnly);
 
-    virtual float GetCameraMoveSpeed() const;
-    virtual float GetCameraRotateSpeed() const;
-    virtual bool  GetCameraInvertYRotation() const;
-    virtual float GetCameraInvertPan() const;
-
     // Called to render stuff.
     virtual void OnRender();
 

Code/Sandbox/Editor/MainWindow.cpp

@@ -842,12 +842,6 @@ void MainWindow::InitActions()
     am->AddAction(ID_SWITCHCAMERA_NEXT, tr("Cycle Camera"))
         .SetShortcut(tr("Ctrl+`"))
         .SetToolTip(tr("Cycle Camera (Ctrl+`)"));
-    am->AddAction(ID_CHANGEMOVESPEED_INCREASE, tr("Increase"))
-        .SetStatusTip(tr("Increase Flycam Movement Speed"));
-    am->AddAction(ID_CHANGEMOVESPEED_DECREASE, tr("Decrease"))
-        .SetStatusTip(tr("Decrease Flycam Movement Speed"));
-    am->AddAction(ID_CHANGEMOVESPEED_CHANGESTEP, tr("Change Step"))
-        .SetStatusTip(tr("Change Flycam Movement Step"));
     am->AddAction(ID_DISPLAY_GOTOPOSITION, tr("Go to Position..."));
     am->AddAction(ID_MODIFY_GOTO_SELECTION, tr("Center on Selection"))
         .SetShortcut(tr("Z"))

Code/Sandbox/Editor/Resource.h

@@ -89,9 +89,6 @@
 #define ID_EXPORT_INDOORS                          32915
 #define ID_VIEW_CYCLE2DVIEWPORT                    32916
 #define ID_SNAPANGLE                               32917
-#define ID_CHANGEMOVESPEED_INCREASE                32928
-#define ID_CHANGEMOVESPEED_DECREASE                32929
-#define ID_CHANGEMOVESPEED_CHANGESTEP              32930
 #define ID_PHYSICS_GETPHYSICSSTATE                 32937
 #define ID_PHYSICS_RESETPHYSICSSTATE               32938
 #define ID_GAME_SYNCPLAYER                         32941

Code/Sandbox/Editor/ViewportTitleDlg.cpp

@@ -170,7 +170,7 @@ void CViewportTitleDlg::SetupCameraDropdownMenu()
     cameraSpeedActionWidget->setDefaultWidget(cameraSpeedContainer);
 
     // Save off the move speed here since setting up the combo box can cause it to update values in the background.
-    float cameraMoveSpeed = gSettings.cameraMoveSpeed;
+    const float cameraMoveSpeed = SandboxEditor::UsingNewCameraSystem() ? SandboxEditor::CameraTranslateSpeed() : gSettings.cameraMoveSpeed;
 
     // Populate the presets in the ComboBox
     for (float presetValue : m_speedPresetValues)
@@ -901,15 +901,24 @@ void CViewportTitleDlg::OnSpeedComboBoxEnter()
 
 void CViewportTitleDlg::OnUpdateMoveSpeedText(const QString& text)
 {
-    gSettings.cameraMoveSpeed = aznumeric_cast<float>(Round(text.toDouble(), m_speedStep));
+    if (SandboxEditor::UsingNewCameraSystem())
+    {
+        SandboxEditor::SetCameraTranslateSpeed(aznumeric_cast<float>(Round(text.toDouble(), m_speedStep)));
+    }
+    else
+    {
+        gSettings.cameraMoveSpeed = aznumeric_cast<float>(Round(text.toDouble(), m_speedStep));
+    }
 }
 
 void CViewportTitleDlg::CheckForCameraSpeedUpdate()
 {
-    if (gSettings.cameraMoveSpeed != m_prevMoveSpeed && !m_cameraSpeed->lineEdit()->hasFocus())
+    if (const float currentCameraMoveSpeed =
+            SandboxEditor::UsingNewCameraSystem() ? SandboxEditor::CameraTranslateSpeed() : gSettings.cameraMoveSpeed;
+        currentCameraMoveSpeed != m_prevMoveSpeed && !m_cameraSpeed->lineEdit()->hasFocus())
     {
-        m_prevMoveSpeed = gSettings.cameraMoveSpeed;
+        m_prevMoveSpeed = currentCameraMoveSpeed;
-        SetSpeedComboBox(gSettings.cameraMoveSpeed);
+        SetSpeedComboBox(currentCameraMoveSpeed);
     }
 }
 

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ModularViewportCameraController.h

@@ -27,14 +27,20 @@ namespace AtomToolsFramework
     {
     public:
         using CameraListBuilder = AZStd::function<void(AzFramework::Cameras&)>;
+        using CameraPropsBuilder = AZStd::function<void(AzFramework::CameraProps&)>;
 
         //! Sets the camera list builder callback used to populate new ModernViewportCameraControllerInstances
         void SetCameraListBuilderCallback(const CameraListBuilder& builder);
+        //! Sets the camera props builder callback used to populate new ModernViewportCameraControllerInstances
+        void SetCameraPropsBuilderCallback(const CameraPropsBuilder& builder);
         //! Sets up a camera list based on this controller's CameraListBuilderCallback
         void SetupCameras(AzFramework::Cameras& cameras);
+        //! Sets up properties shared across all cameras
+        void SetupCameraProperies(AzFramework::CameraProps& cameraProps);
 
     private:
         CameraListBuilder m_cameraListBuilder;
+        CameraPropsBuilder m_cameraPropsBuilder;
     };
 
     class ModernViewportCameraControllerInstance final
@@ -67,6 +73,7 @@ namespace AtomToolsFramework
         AzFramework::Camera m_camera;
         AzFramework::Camera m_targetCamera;
         AzFramework::CameraSystem m_cameraSystem;
+        AzFramework::CameraProps m_cameraProps;
 
         AZ::Transform m_transformStart = AZ::Transform::CreateIdentity();
         AZ::Transform m_transformEnd = AZ::Transform::CreateIdentity();

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ModularViewportCameraController.cpp

@@ -26,7 +26,11 @@
 namespace AtomToolsFramework
 {
     AZ_CVAR(
-        AZ::Color, ed_cameraSystemOrbitPointColor, AZ::Color::CreateFromRgba(255, 255, 255, 255), nullptr, AZ::ConsoleFunctorFlags::Null,
+        AZ::Color,
+        ed_cameraSystemOrbitPointColor,
+        AZ::Color::CreateFromRgba(255, 255, 255, 255),
+        nullptr,
+        AZ::ConsoleFunctorFlags::Null,
         "");
     AZ_CVAR(float, ed_cameraSystemOrbitPointSize, 0.5f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
 
@@ -63,6 +67,11 @@ namespace AtomToolsFramework
         m_cameraListBuilder = builder;
     }
 
+    void ModularViewportCameraController::SetCameraPropsBuilderCallback(const CameraPropsBuilder& builder)
+    {
+        m_cameraPropsBuilder = builder;
+    }
+
     void ModularViewportCameraController::SetupCameras(AzFramework::Cameras& cameras)
     {
         if (m_cameraListBuilder)
@@ -71,11 +80,20 @@ namespace AtomToolsFramework
         }
     }
 
+    void ModularViewportCameraController::SetupCameraProperies(AzFramework::CameraProps& cameraProps)
+    {
+        if (m_cameraPropsBuilder)
+        {
+            m_cameraPropsBuilder(cameraProps);
+        }
+    }
+
     ModernViewportCameraControllerInstance::ModernViewportCameraControllerInstance(
         const AzFramework::ViewportId viewportId, ModularViewportCameraController* controller)
         : MultiViewportControllerInstanceInterface<ModularViewportCameraController>(viewportId, controller)
     {
         controller->SetupCameras(m_cameraSystem.m_cameras);
+        controller->SetupCameraProperies(m_cameraProps);
 
         if (auto viewportContext = RetrieveViewportContext(GetViewportId()))
         {
@@ -138,7 +156,7 @@ namespace AtomToolsFramework
             if (m_cameraMode == CameraMode::Control)
             {
                 m_targetCamera = m_cameraSystem.StepCamera(m_targetCamera, event.m_deltaTime.count());
-                m_camera = AzFramework::SmoothCamera(m_camera, m_targetCamera, event.m_deltaTime.count());
+                m_camera = AzFramework::SmoothCamera(m_camera, m_targetCamera, m_cameraProps, event.m_deltaTime.count());
 
                 // if there has been an interpolation, only clear the look at point if it is no longer
                 // centered in the view (the camera has looked away from it)