Merge branch 'development' of https://github.com/o3de/o3de into jckand/LCGradOptimizations

.gitignore

@@ -5,6 +5,7 @@ __pycache__
 AssetProcessorTemp/**
 [Bb]uild/**
 [Oo]ut/**
+CMakeUserPresets.json
 [Cc]ache/
 /install/
 Editor/EditorEventLog.xml

AutomatedTesting/Gem/PythonTests/atom_renderer/test_Atom_GPUTests.py

@@ -181,3 +181,39 @@ class TestPerformanceBenchmarkSuite(object):
 
         aggregator = BenchmarkDataAggregator(workspace, logger, 'periodic')
         aggregator.upload_metrics(rhi)
+
+
+@pytest.mark.parametrize("project", ["AutomatedTesting"])
+@pytest.mark.parametrize("launcher_platform", ['windows_generic'])
+@pytest.mark.system
+class TestMaterialEditor(object):
+
+    @pytest.mark.parametrize("cfg_args", ["-rhi=dx12", "-rhi=Vulkan"])
+    @pytest.mark.parametrize("exe_file_name", ["MaterialEditor"])
+    def test_MaterialEditorLaunch_AllRHIOptionsSucceed(
+            self, request, workspace, project, launcher_platform, generic_launcher, exe_file_name, cfg_args):
+        """
+        Tests each valid RHI option (Null RHI excluded) can be launched with the MaterialEditor.
+        Checks for the "Finished loading viewport configurtions." success message post lounch.
+        """
+        expected_lines = ["Finished loading viewport configurtions."]
+        unexpected_lines = [
+            # "Trace::Assert",
+            # "Trace::Error",
+            "Traceback (most recent call last):",
+        ]
+
+        hydra.launch_and_validate_results(
+            request,
+            TEST_DIRECTORY,
+            generic_launcher,
+            editor_script="",
+            run_python="--runpython",
+            timeout=30,
+            expected_lines=expected_lines,
+            unexpected_lines=unexpected_lines,
+            halt_on_unexpected=False,
+            null_renderer=False,
+            cfg_args=[cfg_args],
+            log_file_name="MaterialEditor.log"
+        )

AutomatedTesting/Gem/PythonTests/atom_renderer/test_Atom_MainSuite.py

@@ -303,5 +303,6 @@ class TestMaterialEditorBasicTests(object):
             expected_lines=expected_lines,
             unexpected_lines=unexpected_lines,
             halt_on_unexpected=True,
+            null_renderer=True,
             log_file_name="MaterialEditor.log",
         )

Code/Editor/AnimationContext.cpp

@@ -628,7 +628,7 @@ void CAnimationContext::GoToFrameCmd(IConsoleCmdArgs* pArgs)
     float targetFrame = (float)atof(pArgs->GetArg(1));
     if (pSeq->GetTimeRange().start > targetFrame || targetFrame > pSeq->GetTimeRange().end)
     {
-        gEnv->pLog->LogError("GoToFrame: requested time %f is outside the range of sequence %s (%f, %f)", targetFrame, pSeq->GetName(), pSeq->GetTimeRange().start, pSeq->GetTimeRange().end);
+        gEnv->pLog->LogError("GoToFrame: requested time %f is outside the range of sequence %s (%f, %f)", targetFrame, pSeq->GetName().c_str(), pSeq->GetTimeRange().start, pSeq->GetTimeRange().end);
         return;
     }
     GetIEditor()->GetAnimation()->m_currTime = targetFrame;

Code/Editor/AzAssetBrowser/AzAssetBrowserRequestHandler.cpp

@@ -327,7 +327,7 @@ void AzAssetBrowserRequestHandler::AddContextMenuActions(QWidget* caller, QMenu*
         if (!vetoOpenerFound)
         {
             // if we found no valid openers and no veto openers then just allow it to be opened with the operating system itself.
-            menu->addAction(QObject::tr("Open with associated application..."), [this, fullFilePath]()
+            menu->addAction(QObject::tr("Open with associated application..."), [fullFilePath]()
             {
                 OpenWithOS(fullFilePath);
             });

Code/Editor/Controls/ColorGradientCtrl.h

@@ -130,7 +130,6 @@ private:
 private:
     ISplineInterpolator* m_pSpline;
 
-    bool m_bAutoDelete;
     bool m_bNoZoom;
 
     QRect m_rcClipRect;

Code/Editor/Controls/ConsoleSCB.cpp

@@ -298,7 +298,6 @@ Lines CConsoleSCB::s_pendingLines;
 CConsoleSCB::CConsoleSCB(QWidget* parent)
     : QWidget(parent)
     , ui(new Ui::Console())
-    , m_richEditTextLength(0)
     , m_backgroundTheme(gSettings.consoleBackgroundColorTheme)
 {
     m_lines = s_pendingLines;

Code/Editor/Controls/ConsoleSCB.h

@@ -191,7 +191,6 @@ private:
     void OnEditorNotifyEvent(EEditorNotifyEvent event) override;
 
     QScopedPointer<Ui::Console> ui;
-    int m_richEditTextLength;
 
     Lines m_lines;
     static Lines s_pendingLines;

Code/Editor/Controls/ImageHistogramCtrl.cpp

@@ -30,12 +30,6 @@ namespace ImageHistogram
     const QColor    kGreenSectionColor = QColor(220, 255, 220);
     const QColor    kBlueSectionColor = QColor(220, 220, 255);
     const QColor    kSplitSeparatorColor = QColor(100, 100, 0);
-    const QColor    kButtonBackColor = QColor(20, 20, 20);
-    const QColor    kBtnLightColor(200, 200, 200);
-    const QColor    kBtnShadowColor(50, 50, 50);
-    const int       kButtonWidth = 40;
-    const QColor    kButtonTextColor(255, 255, 0);
-    const int       kTextLeftSpacing = 4;
     const int       kTextFontSize = 70;
     const char*     kTextFontFace = "Arial";
     const QColor    kTextColor(255, 255, 255);

Code/Editor/Controls/SplineCtrl.cpp

@@ -123,8 +123,6 @@ void CSplineCtrl::paintEvent(QPaintEvent* event)
 {
     QPainter painter(this);
 
-    QRect rcClient = rect();
-
     if (m_pSpline)
     {
         m_bSelectedKeys.resize(m_pSpline->GetKeyCount());

Code/Editor/Controls/SplineCtrlEx.cpp

@@ -819,8 +819,6 @@ void SplineWidget::DrawSpline(QPainter* painter, SSplineInfo& splineInfo, float
 {
     const QPen pOldPen = painter->pen();
 
-    const QRect rcClip = painter->clipBoundingRect().intersected(m_rcSpline).toRect();
-
     //////////////////////////////////////////////////////////////////////////
     ISplineInterpolator* pSpline = splineInfo.pSpline;
     ISplineInterpolator* pDetailSpline = splineInfo.pDetailSpline;

Code/Editor/Controls/TimelineCtrl.cpp

@@ -18,11 +18,6 @@
 #include "ScopedVariableSetter.h"
 #include "GridUtils.h"
 
-
-static const QColor timeMarkerCol = QColor(255, 0, 255);
-static const QColor textCol = QColor(0, 0, 0);
-static const QColor ltgrayCol = QColor(110, 110, 110);
-
 QColor InterpolateColor(const QColor& c1, const QColor& c2, float fraction)
 {
     const int r = static_cast<int>(static_cast<float>(c2.red() - c1.red()) * fraction + c1.red());

Code/Editor/Controls/TimelineCtrl.h

@@ -136,7 +136,6 @@ protected:
     void DrawFrameTicks(QPainter* dc);
 
 private:
-    bool m_bAutoDelete;
     QRect m_rcClient;
     QRect m_rcTimeline;
     float m_fTimeMarker;

Code/Editor/Controls/WndGridHelper.h

@@ -14,6 +14,7 @@
 #include <QPoint>
 #include <QRect>
 #include "Cry_Vector2.h"
+#include <AzCore/Casting/numeric_cast.h>
 
 //////////////////////////////////////////////////////////////////////////
 class CWndGridHelper
@@ -81,8 +82,6 @@ public:
             newzoom.y = 0.01f;
         }
 
-        Vec2 prevz = zoom;
-
         // Zoom to mouse position.
         float ofsx = origin.x;
         float ofsy = origin.y;

Code/Editor/Core/LevelEditorMenuHandler.cpp

@@ -41,8 +41,6 @@ using namespace AZ;
 using namespace AzToolsFramework;
 
 static const char* const s_LUAEditorName = "Lua Editor";
-static const char* const s_shortTimeInterval = "debug";
-static const char* const s_assetImporterMetricsIdentifier = "AssetImporter";
 
 // top level menu ids
 static const char* const s_fileMenuId = "FileMenu";
@@ -50,7 +48,6 @@ static const char* const s_editMenuId = "EditMenu";
 static const char* const s_gameMenuId = "GameMenu";
 static const char* const s_toolMenuId = "ToolMenu";
 static const char* const s_viewMenuId = "ViewMenu";
-static const char* const s_awsMenuId = "AwsMenu";
 static const char* const s_helpMenuId = "HelpMenu";
 
 static bool CompareLayoutNames(const QString& name1, const QString& name2)
@@ -157,13 +154,11 @@ namespace
     }
 }
 
-LevelEditorMenuHandler::LevelEditorMenuHandler(
-    MainWindow* mainWindow, QtViewPaneManager* const viewPaneManager, QSettings& settings)
+LevelEditorMenuHandler::LevelEditorMenuHandler(MainWindow* mainWindow, QtViewPaneManager* const viewPaneManager)
     : QObject(mainWindow)
     , m_mainWindow(mainWindow)
     , m_viewPaneManager(viewPaneManager)
     , m_actionManager(mainWindow->GetActionManager())
-    , m_settings(settings)
 {
 #if defined(AZ_PLATFORM_MAC)
     // Hide the non-native toolbar, then setNativeMenuBar to ensure it is always visible on macOS.

Code/Editor/Core/LevelEditorMenuHandler.h

@@ -33,7 +33,7 @@ class LevelEditorMenuHandler
 {
     Q_OBJECT
 public:
-    LevelEditorMenuHandler(MainWindow* mainWindow, QtViewPaneManager* const viewPaneManager, QSettings& settings);
+    LevelEditorMenuHandler(MainWindow* mainWindow, QtViewPaneManager* const viewPaneManager);
     ~LevelEditorMenuHandler();
 
     void Initialize();
@@ -106,7 +106,6 @@ private:
     ActionManager::MenuWrapper m_toolsMenu;
 
     QMenu* m_mostRecentLevelsMenu = nullptr;
-    QMenu* m_mostRecentProjectsMenu = nullptr;
     QMenu* m_editmenu = nullptr;
 
     ActionManager::MenuWrapper m_viewPanesMenu;
@@ -117,7 +116,6 @@ private:
     int m_viewPaneVersion = 0;
 
     QList<QMenu*> m_topLevelMenus;
-    QSettings& m_settings;
 };
 
 #endif // LEVELEDITORMENUHANDLER_H

Code/Editor/Core/QtEditorApplication.cpp

@@ -425,7 +425,7 @@ namespace Editor
                 AZStd::array<BYTE, sizeof(RAWINPUT)> rawInputBytesArray;
                 LPBYTE rawInputBytes = rawInputBytesArray.data();
 
-                const UINT bytesCopied = GetRawInputData((HRAWINPUT)msg->lParam, RID_INPUT, rawInputBytes, &rawInputSize, rawInputHeaderSize);
+                [[maybe_unused]] const UINT bytesCopied = GetRawInputData((HRAWINPUT)msg->lParam, RID_INPUT, rawInputBytes, &rawInputSize, rawInputHeaderSize);
                 CRY_ASSERT(bytesCopied == rawInputSize);
 
                 RAWINPUT* rawInput = (RAWINPUT*)rawInputBytes;

Code/Editor/CryEdit.cpp

@@ -78,7 +78,6 @@ AZ_POP_DISABLE_WARNING
 
 // CryCommon
 #include <CryCommon/ITimer.h>
-#include <CryCommon/IPhysics.h>
 #include <CryCommon/ILevelSystem.h>
 
 // Editor

Code/Editor/CryEditDoc.cpp

@@ -342,7 +342,7 @@ void CCryEditDoc::Load(TDocMultiArchive& arrXmlAr, const QString& szFilename)
     // Register this level and its content hash as version
     GetIEditor()->GetSettingsManager()->AddToolVersion(fileName, levelHash);
     GetIEditor()->GetSettingsManager()->RegisterEvent(loadEvent);
-    LOADING_TIME_PROFILE_SECTION(gEnv->pSystem);
+
     CAutoDocNotReady autoDocNotReady;
 
     HEAP_CHECK
@@ -1018,14 +1018,6 @@ bool CCryEditDoc::AfterSaveDocument([[maybe_unused]] const QString& lpszPathName
     return bSaved;
 }
 
-
-static void GetUserSettingsFile(const QString& levelFolder, QString& userSettings)
-{
-    const char* pUserName = GetISystem()->GetUserName();
-    QString fileName = QStringLiteral("%1_usersettings.editor_xml").arg(pUserName);
-    userSettings = Path::Make(levelFolder, fileName);
-}
-
 static bool TryRenameFile(const QString& oldPath, const QString& newPath, int retryAttempts=10)
 {
     QFile(newPath).setPermissions(QFile::ReadOther | QFile::WriteOther);

Code/Editor/CryEditPy.cpp

@@ -97,11 +97,6 @@ namespace
         }
     }
 
-    const char* PyGetGameFolder()
-    {
-        return Path::GetEditingGameDataFolder().c_str();
-    }
-
     AZStd::string PyGetGameFolderAsString()
     {
         return Path::GetEditingGameDataFolder();

Code/Editor/EditMode/SubObjectSelectionReferenceFrameCalculator.cpp

@@ -1,75 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-// Description : Calculate the reference frame for sub-object selections.
-
-#include "EditorDefs.h"
-
-#include "SubObjectSelectionReferenceFrameCalculator.h"
-
-SubObjectSelectionReferenceFrameCalculator::SubObjectSelectionReferenceFrameCalculator(ESubObjElementType selectionType)
-    :   m_anySelected(false)
-    , pos(0.0f, 0.0f, 0.0f)
-    , normal(0.0f, 0.0f, 0.0f)
-    , nNormals(0)
-    , selectionType(selectionType)
-    , bUseExplicitFrame(false)
-    , bExplicitAnySelected(false)
-{
-}
-
-void SubObjectSelectionReferenceFrameCalculator::SetExplicitFrame(bool bAnySelected, const Matrix34& refFrame)
-{
-    this->m_refFrame = refFrame;
-    this->bUseExplicitFrame = true;
-    this->bExplicitAnySelected = bAnySelected;
-}
-
-bool SubObjectSelectionReferenceFrameCalculator::GetFrame(Matrix34& refFrame)
-{
-    if (this->bUseExplicitFrame)
-    {
-        refFrame = this->m_refFrame;
-        return this->bExplicitAnySelected;
-    }
-    else
-    {
-        refFrame.SetIdentity();
-
-        if (this->nNormals > 0)
-        {
-            this->normal = this->normal / static_cast<float>(this->nNormals);
-            if (!this->normal.IsZero())
-            {
-                this->normal.Normalize();
-            }
-
-            // Average position.
-            this->pos = this->pos / static_cast<float>(this->nNormals);
-            refFrame.SetTranslation(this->pos);
-        }
-
-        if (this->m_anySelected)
-        {
-            if (!this->normal.IsZero())
-            {
-                Vec3 xAxis(1, 0, 0), yAxis(0, 1, 0), zAxis(0, 0, 1);
-                if (this->normal.IsEquivalent(zAxis) || normal.IsEquivalent(-zAxis))
-                {
-                    zAxis = xAxis;
-                }
-                xAxis = this->normal.Cross(zAxis).GetNormalized();
-                yAxis = xAxis.Cross(this->normal).GetNormalized();
-                refFrame.SetFromVectors(xAxis, yAxis, normal, pos);
-            }
-        }
-
-        return m_anySelected;
-    }
-}

Code/Editor/EditMode/SubObjectSelectionReferenceFrameCalculator.h

@@ -1,42 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-// Description : Calculate the reference frame for sub-object selections.
-
-
-#ifndef CRYINCLUDE_EDITOR_EDITMODE_SUBOBJECTSELECTIONREFERENCEFRAMECALCULATOR_H
-#define CRYINCLUDE_EDITOR_EDITMODE_SUBOBJECTSELECTIONREFERENCEFRAMECALCULATOR_H
-#pragma once
-
-
-#include "ISubObjectSelectionReferenceFrameCalculator.h"
-#include "Objects/SubObjSelection.h"
-
-class SubObjectSelectionReferenceFrameCalculator
-    : public ISubObjectSelectionReferenceFrameCalculator
-{
-public:
-    SubObjectSelectionReferenceFrameCalculator(ESubObjElementType selectionType);
-
-    virtual void SetExplicitFrame(bool bAnySelected, const Matrix34& refFrame);
-    bool GetFrame(Matrix34& refFrame);
-
-private:
-    bool m_anySelected;
-    Vec3 pos;
-    Vec3 normal;
-    int nNormals;
-    ESubObjElementType selectionType;
-    std::vector<Vec3> positions;
-    Matrix34 m_refFrame;
-    bool bUseExplicitFrame;
-    bool bExplicitAnySelected;
-};
-
-#endif // CRYINCLUDE_EDITOR_EDITMODE_SUBOBJECTSELECTIONREFERENCEFRAMECALCULATOR_H

Code/Editor/EditorModularViewportCameraComposer.cpp

@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <EditorModularViewportCameraComposer.h>
+
+#include <AtomToolsFramework/Viewport/ModularViewportCameraControllerRequestBus.h>
+#include <AzCore/std/smart_ptr/make_shared.h>
+#include <AzFramework/Render/IntersectorInterface.h>
+#include <AzToolsFramework/Viewport/ViewportMessages.h>
+#include <EditorViewportSettings.h>
+
+namespace SandboxEditor
+{
+    static AzFramework::TranslateCameraInputChannelIds BuildTranslateCameraInputChannelIds()
+    {
+        AzFramework::TranslateCameraInputChannelIds translateCameraInputChannelIds;
+        translateCameraInputChannelIds.m_leftChannelId = SandboxEditor::CameraTranslateLeftChannelId();
+        translateCameraInputChannelIds.m_rightChannelId = SandboxEditor::CameraTranslateRightChannelId();
+        translateCameraInputChannelIds.m_forwardChannelId = SandboxEditor::CameraTranslateForwardChannelId();
+        translateCameraInputChannelIds.m_backwardChannelId = SandboxEditor::CameraTranslateBackwardChannelId();
+        translateCameraInputChannelIds.m_upChannelId = SandboxEditor::CameraTranslateUpChannelId();
+        translateCameraInputChannelIds.m_downChannelId = SandboxEditor::CameraTranslateDownChannelId();
+        translateCameraInputChannelIds.m_boostChannelId = SandboxEditor::CameraTranslateBoostChannelId();
+
+        return translateCameraInputChannelIds;
+    }
+
+    EditorModularViewportCameraComposer::EditorModularViewportCameraComposer(const AzFramework::ViewportId viewportId)
+        : m_viewportId(viewportId)
+    {
+        EditorModularViewportCameraComposerNotificationBus::Handler::BusConnect(viewportId);
+    }
+
+    EditorModularViewportCameraComposer::~EditorModularViewportCameraComposer()
+    {
+        EditorModularViewportCameraComposerNotificationBus::Handler::BusDisconnect();
+    }
+
+    AZStd::shared_ptr<AtomToolsFramework::ModularViewportCameraController> EditorModularViewportCameraComposer::
+        CreateModularViewportCameraController()
+    {
+        SetupCameras();
+
+        auto controller = AZStd::make_shared<AtomToolsFramework::ModularViewportCameraController>();
+
+        controller->SetCameraViewportContextBuilderCallback(
+            [viewportId = m_viewportId](AZStd::unique_ptr<AtomToolsFramework::ModularCameraViewportContext>& cameraViewportContext)
+            {
+                cameraViewportContext = AZStd::make_unique<AtomToolsFramework::ModularCameraViewportContextImpl>(viewportId);
+            });
+
+        controller->SetCameraPriorityBuilderCallback(
+            [](AtomToolsFramework::CameraControllerPriorityFn& cameraControllerPriorityFn)
+            {
+                cameraControllerPriorityFn = AtomToolsFramework::DefaultCameraControllerPriority;
+            });
+
+        controller->SetCameraPropsBuilderCallback(
+            [](AzFramework::CameraProps& cameraProps)
+            {
+                cameraProps.m_rotateSmoothnessFn = []
+                {
+                    return SandboxEditor::CameraRotateSmoothness();
+                };
+
+                cameraProps.m_translateSmoothnessFn = []
+                {
+                    return SandboxEditor::CameraTranslateSmoothness();
+                };
+
+                cameraProps.m_rotateSmoothingEnabledFn = []
+                {
+                    return SandboxEditor::CameraRotateSmoothingEnabled();
+                };
+
+                cameraProps.m_translateSmoothingEnabledFn = []
+                {
+                    return SandboxEditor::CameraTranslateSmoothingEnabled();
+                };
+            });
+
+        controller->SetCameraListBuilderCallback(
+            [this](AzFramework::Cameras& cameras)
+            {
+                cameras.AddCamera(m_firstPersonRotateCamera);
+                cameras.AddCamera(m_firstPersonPanCamera);
+                cameras.AddCamera(m_firstPersonTranslateCamera);
+                cameras.AddCamera(m_firstPersonScrollCamera);
+                cameras.AddCamera(m_orbitCamera);
+            });
+
+        return controller;
+    }
+
+    void EditorModularViewportCameraComposer::SetupCameras()
+    {
+        const auto hideCursor = [viewportId = m_viewportId]
+        {
+            if (SandboxEditor::CameraCaptureCursorForLook())
+            {
+                AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::Event(
+                    viewportId, &AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::Events::BeginCursorCapture);
+            }
+        };
+        const auto showCursor = [viewportId = m_viewportId]
+        {
+            if (SandboxEditor::CameraCaptureCursorForLook())
+            {
+                AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::Event(
+                    viewportId, &AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::Events::EndCursorCapture);
+            }
+        };
+
+        m_firstPersonRotateCamera = AZStd::make_shared<AzFramework::RotateCameraInput>(SandboxEditor::CameraFreeLookChannelId());
+
+        m_firstPersonRotateCamera->m_rotateSpeedFn = []
+        {
+            return SandboxEditor::CameraRotateSpeed();
+        };
+
+        // default behavior is to hide the cursor but this can be disabled (useful for remote desktop)
+        // note: See CaptureCursorLook in the Settings Registry
+        m_firstPersonRotateCamera->SetActivationBeganFn(hideCursor);
+        m_firstPersonRotateCamera->SetActivationEndedFn(showCursor);
+
+        m_firstPersonPanCamera =
+            AZStd::make_shared<AzFramework::PanCameraInput>(SandboxEditor::CameraFreePanChannelId(), AzFramework::LookPan);
+
+        m_firstPersonPanCamera->m_panSpeedFn = []
+        {
+            return SandboxEditor::CameraPanSpeed();
+        };
+
+        m_firstPersonPanCamera->m_invertPanXFn = []
+        {
+            return SandboxEditor::CameraPanInvertedX();
+        };
+
+        m_firstPersonPanCamera->m_invertPanYFn = []
+        {
+            return SandboxEditor::CameraPanInvertedY();
+        };
+
+        const auto translateCameraInputChannelIds = BuildTranslateCameraInputChannelIds();
+
+        m_firstPersonTranslateCamera =
+            AZStd::make_shared<AzFramework::TranslateCameraInput>(AzFramework::LookTranslation, translateCameraInputChannelIds);
+
+        m_firstPersonTranslateCamera->m_translateSpeedFn = []
+        {
+            return SandboxEditor::CameraTranslateSpeed();
+        };
+
+        m_firstPersonTranslateCamera->m_boostMultiplierFn = []
+        {
+            return SandboxEditor::CameraBoostMultiplier();
+        };
+
+        m_firstPersonScrollCamera = AZStd::make_shared<AzFramework::ScrollTranslationCameraInput>();
+
+        m_firstPersonScrollCamera->m_scrollSpeedFn = []
+        {
+            return SandboxEditor::CameraScrollSpeed();
+        };
+
+        m_orbitCamera = AZStd::make_shared<AzFramework::OrbitCameraInput>(SandboxEditor::CameraOrbitChannelId());
+
+        m_orbitCamera->SetLookAtFn(
+            [viewportId = m_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 {};
+            });
+
+        m_orbitRotateCamera = AZStd::make_shared<AzFramework::RotateCameraInput>(SandboxEditor::CameraOrbitLookChannelId());
+
+        m_orbitRotateCamera->m_rotateSpeedFn = []
+        {
+            return SandboxEditor::CameraRotateSpeed();
+        };
+
+        m_orbitRotateCamera->m_invertYawFn = []
+        {
+            return SandboxEditor::CameraOrbitYawRotationInverted();
+        };
+
+        m_orbitTranslateCamera =
+            AZStd::make_shared<AzFramework::TranslateCameraInput>(AzFramework::OrbitTranslation, translateCameraInputChannelIds);
+
+        m_orbitTranslateCamera->m_translateSpeedFn = []
+        {
+            return SandboxEditor::CameraTranslateSpeed();
+        };
+
+        m_orbitTranslateCamera->m_boostMultiplierFn = []
+        {
+            return SandboxEditor::CameraBoostMultiplier();
+        };
+
+        m_orbitDollyScrollCamera = AZStd::make_shared<AzFramework::OrbitDollyScrollCameraInput>();
+
+        m_orbitDollyScrollCamera->m_scrollSpeedFn = []
+        {
+            return SandboxEditor::CameraScrollSpeed();
+        };
+
+        m_orbitDollyMoveCamera =
+            AZStd::make_shared<AzFramework::OrbitDollyCursorMoveCameraInput>(SandboxEditor::CameraOrbitDollyChannelId());
+
+        m_orbitDollyMoveCamera->m_cursorSpeedFn = []
+        {
+            return SandboxEditor::CameraDollyMotionSpeed();
+        };
+
+        m_orbitPanCamera = AZStd::make_shared<AzFramework::PanCameraInput>(SandboxEditor::CameraOrbitPanChannelId(), AzFramework::OrbitPan);
+
+        m_orbitPanCamera->m_panSpeedFn = []
+        {
+            return SandboxEditor::CameraPanSpeed();
+        };
+
+        m_orbitPanCamera->m_invertPanXFn = []
+        {
+            return SandboxEditor::CameraPanInvertedX();
+        };
+
+        m_orbitPanCamera->m_invertPanYFn = []
+        {
+            return SandboxEditor::CameraPanInvertedY();
+        };
+
+        m_orbitCamera->m_orbitCameras.AddCamera(m_orbitRotateCamera);
+        m_orbitCamera->m_orbitCameras.AddCamera(m_orbitTranslateCamera);
+        m_orbitCamera->m_orbitCameras.AddCamera(m_orbitDollyScrollCamera);
+        m_orbitCamera->m_orbitCameras.AddCamera(m_orbitDollyMoveCamera);
+        m_orbitCamera->m_orbitCameras.AddCamera(m_orbitPanCamera);
+    }
+
+    void EditorModularViewportCameraComposer::OnEditorModularViewportCameraComposerSettingsChanged()
+    {
+        const auto translateCameraInputChannelIds = BuildTranslateCameraInputChannelIds();
+        m_firstPersonTranslateCamera->SetTranslateCameraInputChannelIds(translateCameraInputChannelIds);
+        m_orbitTranslateCamera->SetTranslateCameraInputChannelIds(translateCameraInputChannelIds);
+
+        m_firstPersonPanCamera->SetPanInputChannelId(SandboxEditor::CameraFreePanChannelId());
+        m_orbitPanCamera->SetPanInputChannelId(SandboxEditor::CameraOrbitPanChannelId());
+        m_firstPersonRotateCamera->SetRotateInputChannelId(SandboxEditor::CameraFreeLookChannelId());
+        m_orbitRotateCamera->SetRotateInputChannelId(SandboxEditor::CameraOrbitLookChannelId());
+        m_orbitCamera->SetOrbitInputChannelId(SandboxEditor::CameraOrbitChannelId());
+        m_orbitDollyMoveCamera->SetDollyInputChannelId(SandboxEditor::CameraOrbitDollyChannelId());
+    }
+} // namespace SandboxEditor

Code/Editor/EditorModularViewportCameraComposer.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AtomToolsFramework/Viewport/ModularViewportCameraController.h>
+#include <AzFramework/Viewport/CameraInput.h>
+#include <EditorModularViewportCameraComposerBus.h>
+#include <SandboxAPI.h>
+
+namespace SandboxEditor
+{
+    //! Type responsible for building the editor's modular viewport camera controller.
+    class EditorModularViewportCameraComposer : private EditorModularViewportCameraComposerNotificationBus::Handler
+    {
+    public:
+        SANDBOX_API explicit EditorModularViewportCameraComposer(AzFramework::ViewportId viewportId);
+        SANDBOX_API ~EditorModularViewportCameraComposer();
+
+        //! Build a ModularViewportCameraController from the associated camera inputs.
+        SANDBOX_API AZStd::shared_ptr<AtomToolsFramework::ModularViewportCameraController> CreateModularViewportCameraController();
+
+    private:
+        //! Setup all internal camera inputs.
+        void SetupCameras();
+
+        // EditorModularViewportCameraComposerNotificationBus overrides ...
+        void OnEditorModularViewportCameraComposerSettingsChanged() override;
+
+        AZStd::shared_ptr<AzFramework::RotateCameraInput> m_firstPersonRotateCamera;
+        AZStd::shared_ptr<AzFramework::PanCameraInput> m_firstPersonPanCamera;
+        AZStd::shared_ptr<AzFramework::TranslateCameraInput> m_firstPersonTranslateCamera;
+        AZStd::shared_ptr<AzFramework::ScrollTranslationCameraInput> m_firstPersonScrollCamera;
+        AZStd::shared_ptr<AzFramework::OrbitCameraInput> m_orbitCamera;
+        AZStd::shared_ptr<AzFramework::RotateCameraInput> m_orbitRotateCamera;
+        AZStd::shared_ptr<AzFramework::TranslateCameraInput> m_orbitTranslateCamera;
+        AZStd::shared_ptr<AzFramework::OrbitDollyScrollCameraInput> m_orbitDollyScrollCamera;
+        AZStd::shared_ptr<AzFramework::OrbitDollyCursorMoveCameraInput> m_orbitDollyMoveCamera;
+        AZStd::shared_ptr<AzFramework::PanCameraInput> m_orbitPanCamera;
+
+        AzFramework::ViewportId m_viewportId;
+    };
+} // namespace SandboxEditor

Code/Editor/EditorModularViewportCameraComposerBus.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/EBus/EBus.h>
+#include <AzFramework/Viewport/ViewportId.h>
+#include <AzToolsFramework/Viewport/ViewportMessages.h>
+
+namespace SandboxEditor
+{
+    //! Notifications for changes to the editor modular viewport camera controller.
+    class EditorModularViewportCameraComposerNotifications
+    {
+    public:
+        //! Notify any listeners when changes have been made to the modular viewport camera settings.
+        //! @note This is used to update any cached input channels when controls are modified.
+        virtual void OnEditorModularViewportCameraComposerSettingsChanged() = 0;
+
+    protected:
+        ~EditorModularViewportCameraComposerNotifications() = default;
+    };
+
+    using EditorModularViewportCameraComposerNotificationBus =
+        AZ::EBus<EditorModularViewportCameraComposerNotifications, AzToolsFramework::ViewportInteraction::ViewportEBusTraits>;
+} // namespace SandboxEditor

Code/Editor/EditorPreferencesPageViewportMovement.cpp

@@ -5,51 +5,220 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+
 #include "EditorDefs.h"
 
 #include "EditorPreferencesPageViewportMovement.h"
 
+#include <AzCore/std/sort.h>
+#include <AzFramework/Input/Buses/Requests/InputDeviceRequestBus.h>
+#include <AzFramework/Input/Devices/Keyboard/InputDeviceKeyboard.h>
+#include <AzFramework/Input/Devices/Mouse/InputDeviceMouse.h>
 #include <AzQtComponents/Components/StyleManager.h>
+#include <EditorModularViewportCameraComposerBus.h>
 
 // Editor
-#include "Settings.h"
 #include "EditorViewportSettings.h"
+#include "Settings.h"
+
+static AZStd::vector<AZStd::string> GetInputNamesByDevice(const AzFramework::InputDeviceId inputDeviceId)
+{
+    AzFramework::InputDeviceRequests::InputChannelIdSet availableInputChannelIds;
+    AzFramework::InputDeviceRequestBus::Event(
+        inputDeviceId, &AzFramework::InputDeviceRequests::GetInputChannelIds, availableInputChannelIds);
+
+    AZStd::vector<AZStd::string> inputChannelNames;
+    for (const AzFramework::InputChannelId& inputChannelId : availableInputChannelIds)
+    {
+        inputChannelNames.push_back(inputChannelId.GetName());
+    }
+
+    AZStd::sort(inputChannelNames.begin(), inputChannelNames.end());
+
+    return inputChannelNames;
+}
+
+static AZStd::vector<AZStd::string> GetEditorInputNames()
+{
+    // function static to defer having to call GetInputNamesByDevice for every CameraInputSettings member
+    static bool inputNamesGenerated = false;
+    static AZStd::vector<AZStd::string> inputNames;
+
+    if (!inputNamesGenerated)
+    {
+        AZStd::vector<AZStd::string> keyboardInputNames = GetInputNamesByDevice(AzFramework::InputDeviceKeyboard::Id);
+        AZStd::vector<AZStd::string> mouseInputNames = GetInputNamesByDevice(AzFramework::InputDeviceMouse::Id);
+
+        inputNames.insert(inputNames.end(), mouseInputNames.begin(), mouseInputNames.end());
+        inputNames.insert(inputNames.end(), keyboardInputNames.begin(), keyboardInputNames.end());
+
+        inputNamesGenerated = true;
+    }
+
+    return inputNames;
+}
 
 void CEditorPreferencesPage_ViewportMovement::Reflect(AZ::SerializeContext& serialize)
 {
     serialize.Class<CameraMovementSettings>()
-        ->Version(1)
-        ->Field("MoveSpeed", &CameraMovementSettings::m_moveSpeed)
+        ->Version(2)
+        ->Field("TranslateSpeed", &CameraMovementSettings::m_translateSpeed)
         ->Field("RotateSpeed", &CameraMovementSettings::m_rotateSpeed)
-        ->Field("FastMoveSpeed", &CameraMovementSettings::m_fastMoveSpeed)
-        ->Field("WheelZoomSpeed", &CameraMovementSettings::m_wheelZoomSpeed)
-        ->Field("InvertYAxis", &CameraMovementSettings::m_invertYRotation)
-        ->Field("InvertPan", &CameraMovementSettings::m_invertPan);
+        ->Field("BoostMultiplier", &CameraMovementSettings::m_boostMultiplier)
+        ->Field("ScrollSpeed", &CameraMovementSettings::m_scrollSpeed)
+        ->Field("DollySpeed", &CameraMovementSettings::m_dollySpeed)
+        ->Field("PanSpeed", &CameraMovementSettings::m_panSpeed)
+        ->Field("RotateSmoothing", &CameraMovementSettings::m_rotateSmoothing)
+        ->Field("RotateSmoothness", &CameraMovementSettings::m_rotateSmoothness)
+        ->Field("TranslateSmoothing", &CameraMovementSettings::m_translateSmoothing)
+        ->Field("TranslateSmoothness", &CameraMovementSettings::m_translateSmoothness)
+        ->Field("CaptureCursorLook", &CameraMovementSettings::m_captureCursorLook)
+        ->Field("OrbitYawRotationInverted", &CameraMovementSettings::m_orbitYawRotationInverted)
+        ->Field("PanInvertedX", &CameraMovementSettings::m_panInvertedX)
+        ->Field("PanInvertedY", &CameraMovementSettings::m_panInvertedY);
+
+    serialize.Class<CameraInputSettings>()
+        ->Version(1)
+        ->Field("TranslateForward", &CameraInputSettings::m_translateForwardChannelId)
+        ->Field("TranslateBackward", &CameraInputSettings::m_translateBackwardChannelId)
+        ->Field("TranslateLeft", &CameraInputSettings::m_translateLeftChannelId)
+        ->Field("TranslateRight", &CameraInputSettings::m_translateRightChannelId)
+        ->Field("TranslateUp", &CameraInputSettings::m_translateUpChannelId)
+        ->Field("TranslateDown", &CameraInputSettings::m_translateDownChannelId)
+        ->Field("Boost", &CameraInputSettings::m_boostChannelId)
+        ->Field("Orbit", &CameraInputSettings::m_orbitChannelId)
+        ->Field("FreeLook", &CameraInputSettings::m_freeLookChannelId)
+        ->Field("FreePan", &CameraInputSettings::m_freePanChannelId)
+        ->Field("OrbitLook", &CameraInputSettings::m_orbitLookChannelId)
+        ->Field("OrbitDolly", &CameraInputSettings::m_orbitDollyChannelId)
+        ->Field("OrbitPan", &CameraInputSettings::m_orbitPanChannelId);
 
     serialize.Class<CEditorPreferencesPage_ViewportMovement>()
         ->Version(1)
-        ->Field("CameraMovementSettings", &CEditorPreferencesPage_ViewportMovement::m_cameraMovementSettings);
+        ->Field("CameraMovementSettings", &CEditorPreferencesPage_ViewportMovement::m_cameraMovementSettings)
+        ->Field("CameraInputSettings", &CEditorPreferencesPage_ViewportMovement::m_cameraInputSettings);
 
-
-    AZ::EditContext* editContext = serialize.GetEditContext();
-    if (editContext)
+    if (AZ::EditContext* editContext = serialize.GetEditContext())
     {
         editContext->Class<CameraMovementSettings>("Camera Movement Settings", "")
-            ->DataElement(AZ::Edit::UIHandlers::SpinBox, &CameraMovementSettings::m_moveSpeed, "Camera Movement Speed", "Camera Movement Speed")
-            ->DataElement(AZ::Edit::UIHandlers::SpinBox, &CameraMovementSettings::m_rotateSpeed, "Camera Rotation Speed", "Camera Rotation Speed")
-            ->DataElement(AZ::Edit::UIHandlers::SpinBox, &CameraMovementSettings::m_fastMoveSpeed, "Fast Movement Scale", "Fast Movement Scale (holding shift")
-            ->DataElement(AZ::Edit::UIHandlers::SpinBox, &CameraMovementSettings::m_wheelZoomSpeed, "Wheel Zoom Speed", "Wheel Zoom Speed")
-            ->DataElement(AZ::Edit::UIHandlers::CheckBox, &CameraMovementSettings::m_invertYRotation, "Invert Y Axis", "Invert Y Rotation (holding RMB)")
-            ->DataElement(AZ::Edit::UIHandlers::CheckBox, &CameraMovementSettings::m_invertPan, "Invert Pan", "Invert Pan (holding MMB)");
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &CameraMovementSettings::m_translateSpeed, "Camera Movement Speed", "Camera movement speed")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.01f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &CameraMovementSettings::m_rotateSpeed, "Camera Rotation Speed", "Camera rotation speed")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.01f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &CameraMovementSettings::m_boostMultiplier, "Camera Boost Multiplier",
+                "Camera boost multiplier to apply to movement speed")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.01f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &CameraMovementSettings::m_scrollSpeed, "Camera Scroll Speed",
+                "Camera movement speed while using scroll/wheel input")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.01f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &CameraMovementSettings::m_dollySpeed, "Camera Dolly Speed",
+                "Camera movement speed while using mouse motion to move in and out")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.01f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &CameraMovementSettings::m_panSpeed, "Camera Pan Speed",
+                "Camera movement speed while panning using the mouse")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.01f)
+            ->DataElement(
+                AZ::Edit::UIHandlers::CheckBox, &CameraMovementSettings::m_rotateSmoothing, "Camera Rotate Smoothing",
+                "Is camera rotation smoothing enabled or disabled")
+            ->Attribute(AZ::Edit::Attributes::ChangeNotify, AZ::Edit::PropertyRefreshLevels::EntireTree)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &CameraMovementSettings::m_rotateSmoothness, "Camera Rotate Smoothness",
+                "Amount of camera smoothing to apply while rotating the camera")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.01f)
+            ->Attribute(AZ::Edit::Attributes::Visibility, &CameraMovementSettings::RotateSmoothingVisibility)
+            ->DataElement(
+                AZ::Edit::UIHandlers::CheckBox, &CameraMovementSettings::m_translateSmoothing, "Camera Translate Smoothing",
+                "Is camera translation smoothing enabled or disabled")
+            ->Attribute(AZ::Edit::Attributes::ChangeNotify, AZ::Edit::PropertyRefreshLevels::EntireTree)
+            ->DataElement(
+                AZ::Edit::UIHandlers::SpinBox, &CameraMovementSettings::m_translateSmoothness, "Camera Translate Smoothness",
+                "Amount of camera smoothing to apply while translating the camera")
+            ->Attribute(AZ::Edit::Attributes::Min, 0.01f)
+            ->Attribute(AZ::Edit::Attributes::Visibility, &CameraMovementSettings::TranslateSmoothingVisibility)
+            ->DataElement(
+                AZ::Edit::UIHandlers::CheckBox, &CameraMovementSettings::m_orbitYawRotationInverted, "Camera Orbit Yaw Inverted",
+                "Inverted yaw rotation while orbiting")
+            ->DataElement(
+                AZ::Edit::UIHandlers::CheckBox, &CameraMovementSettings::m_panInvertedX, "Invert Pan X",
+                "Invert direction of pan in local X axis")
+            ->DataElement(
+                AZ::Edit::UIHandlers::CheckBox, &CameraMovementSettings::m_panInvertedY, "Invert Pan Y",
+                "Invert direction of pan in local Y axis")
+            ->DataElement(
+                AZ::Edit::UIHandlers::CheckBox, &CameraMovementSettings::m_captureCursorLook, "Camera Capture Look Cursor",
+                "Should the cursor be captured (hidden) while performing free look");
 
-        editContext->Class<CEditorPreferencesPage_ViewportMovement>("Gizmo Movement Preferences", "Gizmo Movement Preferences")
+        editContext->Class<CameraInputSettings>("Camera Input Settings", "")
+            ->DataElement(
+                AZ::Edit::UIHandlers::ComboBox, &CameraInputSettings::m_translateForwardChannelId, "Translate Forward",
+                "Key/button to move the camera forward")
+            ->Attribute(AZ::Edit::Attributes::StringList, &GetEditorInputNames)
+            ->DataElement(
+                AZ::Edit::UIHandlers::ComboBox, &CameraInputSettings::m_translateBackwardChannelId, "Translate Backward",
+                "Key/button to move the camera backward")
+            ->Attribute(AZ::Edit::Attributes::StringList, &GetEditorInputNames)
+            ->DataElement(
+                AZ::Edit::UIHandlers::ComboBox, &CameraInputSettings::m_translateLeftChannelId, "Translate Left",
+                "Key/button to move the camera left")
+            ->Attribute(AZ::Edit::Attributes::StringList, &GetEditorInputNames)
+            ->DataElement(
+                AZ::Edit::UIHandlers::ComboBox, &CameraInputSettings::m_translateRightChannelId, "Translate Right",
+                "Key/button to move the camera right")
+            ->Attribute(AZ::Edit::Attributes::StringList, &GetEditorInputNames)
+            ->DataElement(
+                AZ::Edit::UIHandlers::ComboBox, &CameraInputSettings::m_translateUpChannelId, "Translate Up",
+                "Key/button to move the camera up")
+            ->Attribute(AZ::Edit::Attributes::StringList, &GetEditorInputNames)
+            ->DataElement(
+                AZ::Edit::UIHandlers::ComboBox, &CameraInputSettings::m_translateDownChannelId, "Translate Down",
+                "Key/button to move the camera down")
+            ->Attribute(AZ::Edit::Attributes::StringList, &GetEditorInputNames)
+            ->DataElement(
+                AZ::Edit::UIHandlers::ComboBox, &CameraInputSettings::m_boostChannelId, "Boost",
+                "Key/button to move the camera more quickly")
+            ->Attribute(AZ::Edit::Attributes::StringList, &GetEditorInputNames)
+            ->DataElement(
+                AZ::Edit::UIHandlers::ComboBox, &CameraInputSettings::m_orbitChannelId, "Orbit",
+                "Key/button to begin the camera orbit behavior")
+            ->Attribute(AZ::Edit::Attributes::StringList, &GetEditorInputNames)
+            ->DataElement(
+                AZ::Edit::UIHandlers::ComboBox, &CameraInputSettings::m_freeLookChannelId, "Free Look",
+                "Key/button to begin camera free look")
+            ->Attribute(AZ::Edit::Attributes::StringList, &GetEditorInputNames)
+            ->DataElement(
+                AZ::Edit::UIHandlers::ComboBox, &CameraInputSettings::m_freePanChannelId, "Free Pan", "Key/button to begin camera free pan")
+            ->Attribute(AZ::Edit::Attributes::StringList, &GetEditorInputNames)
+            ->DataElement(
+                AZ::Edit::UIHandlers::ComboBox, &CameraInputSettings::m_orbitLookChannelId, "Orbit Look",
+                "Key/button to begin camera orbit look")
+            ->Attribute(AZ::Edit::Attributes::StringList, &GetEditorInputNames)
+            ->DataElement(
+                AZ::Edit::UIHandlers::ComboBox, &CameraInputSettings::m_orbitDollyChannelId, "Orbit Dolly",
+                "Key/button to begin camera orbit dolly")
+            ->Attribute(AZ::Edit::Attributes::StringList, &GetEditorInputNames)
+            ->DataElement(
+                AZ::Edit::UIHandlers::ComboBox, &CameraInputSettings::m_orbitPanChannelId, "Orbit Pan",
+                "Key/button to begin camera orbit pan")
+            ->Attribute(AZ::Edit::Attributes::StringList, &GetEditorInputNames);
+
+        editContext->Class<CEditorPreferencesPage_ViewportMovement>("Viewport Preferences", "Viewport Preferences")
             ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
             ->Attribute(AZ::Edit::Attributes::Visibility, AZ_CRC("PropertyVisibility_ShowChildrenOnly", 0xef428f20))
-            ->DataElement(AZ::Edit::UIHandlers::Default, &CEditorPreferencesPage_ViewportMovement::m_cameraMovementSettings, "Camera Movement Settings", "Camera Movement Settings");
+            ->DataElement(
+                AZ::Edit::UIHandlers::Default, &CEditorPreferencesPage_ViewportMovement::m_cameraMovementSettings,
+                "Camera Movement Settings", "Camera Movement Settings")
+            ->DataElement(
+                AZ::Edit::UIHandlers::Default, &CEditorPreferencesPage_ViewportMovement::m_cameraInputSettings, "Camera Input Settings",
+                "Camera Input Settings");
     }
 }
 
-
 CEditorPreferencesPage_ViewportMovement::CEditorPreferencesPage_ViewportMovement()
 {
     InitializeSettings();
@@ -68,21 +237,67 @@ QIcon& CEditorPreferencesPage_ViewportMovement::GetIcon()
 
 void CEditorPreferencesPage_ViewportMovement::OnApply()
 {
-    SandboxEditor::SetCameraTranslateSpeed(m_cameraMovementSettings.m_moveSpeed);
+    SandboxEditor::SetCameraTranslateSpeed(m_cameraMovementSettings.m_translateSpeed);
     SandboxEditor::SetCameraRotateSpeed(m_cameraMovementSettings.m_rotateSpeed);
-    SandboxEditor::SetCameraBoostMultiplier(m_cameraMovementSettings.m_fastMoveSpeed);
-    SandboxEditor::SetCameraScrollSpeed(m_cameraMovementSettings.m_wheelZoomSpeed);
-    SandboxEditor::SetCameraOrbitYawRotationInverted(m_cameraMovementSettings.m_invertYRotation);
-    SandboxEditor::SetCameraPanInvertedX(m_cameraMovementSettings.m_invertPan);
-    SandboxEditor::SetCameraPanInvertedY(m_cameraMovementSettings.m_invertPan);
+    SandboxEditor::SetCameraBoostMultiplier(m_cameraMovementSettings.m_boostMultiplier);
+    SandboxEditor::SetCameraScrollSpeed(m_cameraMovementSettings.m_scrollSpeed);
+    SandboxEditor::SetCameraDollyMotionSpeed(m_cameraMovementSettings.m_dollySpeed);
+    SandboxEditor::SetCameraPanSpeed(m_cameraMovementSettings.m_panSpeed);
+    SandboxEditor::SetCameraRotateSmoothness(m_cameraMovementSettings.m_rotateSmoothness);
+    SandboxEditor::SetCameraRotateSmoothingEnabled(m_cameraMovementSettings.m_rotateSmoothing);
+    SandboxEditor::SetCameraTranslateSmoothness(m_cameraMovementSettings.m_translateSmoothness);
+    SandboxEditor::SetCameraTranslateSmoothingEnabled(m_cameraMovementSettings.m_translateSmoothing);
+    SandboxEditor::SetCameraCaptureCursorForLook(m_cameraMovementSettings.m_captureCursorLook);
+    SandboxEditor::SetCameraOrbitYawRotationInverted(m_cameraMovementSettings.m_orbitYawRotationInverted);
+    SandboxEditor::SetCameraPanInvertedX(m_cameraMovementSettings.m_panInvertedX);
+    SandboxEditor::SetCameraPanInvertedY(m_cameraMovementSettings.m_panInvertedY);
+
+    SandboxEditor::SetCameraTranslateForwardChannelId(m_cameraInputSettings.m_translateForwardChannelId);
+    SandboxEditor::SetCameraTranslateBackwardChannelId(m_cameraInputSettings.m_translateBackwardChannelId);
+    SandboxEditor::SetCameraTranslateLeftChannelId(m_cameraInputSettings.m_translateLeftChannelId);
+    SandboxEditor::SetCameraTranslateRightChannelId(m_cameraInputSettings.m_translateRightChannelId);
+    SandboxEditor::SetCameraTranslateUpChannelId(m_cameraInputSettings.m_translateUpChannelId);
+    SandboxEditor::SetCameraTranslateDownChannelId(m_cameraInputSettings.m_translateDownChannelId);
+    SandboxEditor::SetCameraTranslateBoostChannelId(m_cameraInputSettings.m_boostChannelId);
+    SandboxEditor::SetCameraOrbitChannelId(m_cameraInputSettings.m_orbitChannelId);
+    SandboxEditor::SetCameraFreeLookChannelId(m_cameraInputSettings.m_freeLookChannelId);
+    SandboxEditor::SetCameraFreePanChannelId(m_cameraInputSettings.m_freePanChannelId);
+    SandboxEditor::SetCameraOrbitLookChannelId(m_cameraInputSettings.m_orbitLookChannelId);
+    SandboxEditor::SetCameraOrbitDollyChannelId(m_cameraInputSettings.m_orbitDollyChannelId);
+    SandboxEditor::SetCameraOrbitPanChannelId(m_cameraInputSettings.m_orbitPanChannelId);
+
+    SandboxEditor::EditorModularViewportCameraComposerNotificationBus::Broadcast(
+        &SandboxEditor::EditorModularViewportCameraComposerNotificationBus::Events::OnEditorModularViewportCameraComposerSettingsChanged);
 }
 
 void CEditorPreferencesPage_ViewportMovement::InitializeSettings()
 {
-    m_cameraMovementSettings.m_moveSpeed = SandboxEditor::CameraTranslateSpeed();
+    m_cameraMovementSettings.m_translateSpeed = SandboxEditor::CameraTranslateSpeed();
     m_cameraMovementSettings.m_rotateSpeed = SandboxEditor::CameraRotateSpeed();
-    m_cameraMovementSettings.m_fastMoveSpeed = SandboxEditor::CameraBoostMultiplier();
-    m_cameraMovementSettings.m_wheelZoomSpeed = SandboxEditor::CameraScrollSpeed();
-    m_cameraMovementSettings.m_invertYRotation = SandboxEditor::CameraOrbitYawRotationInverted();
-    m_cameraMovementSettings.m_invertPan = SandboxEditor::CameraPanInvertedX() && SandboxEditor::CameraPanInvertedY();
+    m_cameraMovementSettings.m_boostMultiplier = SandboxEditor::CameraBoostMultiplier();
+    m_cameraMovementSettings.m_scrollSpeed = SandboxEditor::CameraScrollSpeed();
+    m_cameraMovementSettings.m_dollySpeed = SandboxEditor::CameraDollyMotionSpeed();
+    m_cameraMovementSettings.m_panSpeed = SandboxEditor::CameraPanSpeed();
+    m_cameraMovementSettings.m_rotateSmoothness = SandboxEditor::CameraRotateSmoothness();
+    m_cameraMovementSettings.m_rotateSmoothing = SandboxEditor::CameraRotateSmoothingEnabled();
+    m_cameraMovementSettings.m_translateSmoothness = SandboxEditor::CameraTranslateSmoothness();
+    m_cameraMovementSettings.m_translateSmoothing = SandboxEditor::CameraTranslateSmoothingEnabled();
+    m_cameraMovementSettings.m_captureCursorLook = SandboxEditor::CameraCaptureCursorForLook();
+    m_cameraMovementSettings.m_orbitYawRotationInverted = SandboxEditor::CameraOrbitYawRotationInverted();
+    m_cameraMovementSettings.m_panInvertedX = SandboxEditor::CameraPanInvertedX();
+    m_cameraMovementSettings.m_panInvertedY = SandboxEditor::CameraPanInvertedY();
+
+    m_cameraInputSettings.m_translateForwardChannelId = SandboxEditor::CameraTranslateForwardChannelId().GetName();
+    m_cameraInputSettings.m_translateBackwardChannelId = SandboxEditor::CameraTranslateBackwardChannelId().GetName();
+    m_cameraInputSettings.m_translateLeftChannelId = SandboxEditor::CameraTranslateLeftChannelId().GetName();
+    m_cameraInputSettings.m_translateRightChannelId = SandboxEditor::CameraTranslateRightChannelId().GetName();
+    m_cameraInputSettings.m_translateUpChannelId = SandboxEditor::CameraTranslateUpChannelId().GetName();
+    m_cameraInputSettings.m_translateDownChannelId = SandboxEditor::CameraTranslateDownChannelId().GetName();
+    m_cameraInputSettings.m_boostChannelId = SandboxEditor::CameraTranslateBoostChannelId().GetName();
+    m_cameraInputSettings.m_orbitChannelId = SandboxEditor::CameraOrbitChannelId().GetName();
+    m_cameraInputSettings.m_freeLookChannelId = SandboxEditor::CameraFreeLookChannelId().GetName();
+    m_cameraInputSettings.m_freePanChannelId = SandboxEditor::CameraFreePanChannelId().GetName();
+    m_cameraInputSettings.m_orbitLookChannelId = SandboxEditor::CameraOrbitLookChannelId().GetName();
+    m_cameraInputSettings.m_orbitDollyChannelId = SandboxEditor::CameraOrbitDollyChannelId().GetName();
+    m_cameraInputSettings.m_orbitPanChannelId = SandboxEditor::CameraOrbitPanChannelId().GetName();
 }

Code/Editor/EditorPreferencesPageViewportMovement.h

@@ -5,17 +5,21 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+
 #pragma once
 
 #include "Include/IPreferencesPage.h"
-#include <AzCore/Serialization/SerializeContext.h>
-#include <AzCore/Serialization/EditContext.h>
 #include <AzCore/RTTI/RTTI.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
 #include <QIcon>
 
+inline AZ::Crc32 EditorPropertyVisibility(const bool enabled)
+{
+    return enabled ? AZ::Edit::PropertyVisibility::Show : AZ::Edit::PropertyVisibility::Hide;
+}
 
-class CEditorPreferencesPage_ViewportMovement
-    : public IPreferencesPage
+class CEditorPreferencesPage_ViewportMovement : public IPreferencesPage
 {
 public:
     AZ_RTTI(CEditorPreferencesPage_ViewportMovement, "{BC593332-7EAF-4171-8A35-1C5DE5B40909}", IPreferencesPage)
@@ -25,12 +29,22 @@ public:
     CEditorPreferencesPage_ViewportMovement();
     virtual ~CEditorPreferencesPage_ViewportMovement() = default;
 
-    virtual const char* GetCategory() override { return "Viewports"; }
+    virtual const char* GetCategory() override
+    {
+        return "Viewports";
+    }
+
     virtual const char* GetTitle();
     virtual QIcon& GetIcon() override;
     virtual void OnApply() override;
-    virtual void OnCancel() override {}
-    virtual bool OnQueryCancel() override { return true; }
+    virtual void OnCancel() override
+    {
+    }
+
+    virtual bool OnQueryCancel() override
+    {
+        return true;
+    }
 
 private:
     void InitializeSettings();
@@ -39,16 +53,53 @@ private:
     {
         AZ_TYPE_INFO(CameraMovementSettings, "{60B8C07E-5F48-4171-A50B-F45558B5CCA1}")
 
-        float m_moveSpeed;
+        float m_translateSpeed;
         float m_rotateSpeed;
-        float m_fastMoveSpeed;
-        float m_wheelZoomSpeed;
-        bool m_invertYRotation;
-        bool m_invertPan;
+        float m_scrollSpeed;
+        float m_dollySpeed;
+        float m_panSpeed;
+        float m_boostMultiplier;
+        float m_rotateSmoothness;
+        bool m_rotateSmoothing;
+        float m_translateSmoothness;
+        bool m_translateSmoothing;
+        bool m_captureCursorLook;
+        bool m_orbitYawRotationInverted;
+        bool m_panInvertedX;
+        bool m_panInvertedY;
+
+        AZ::Crc32 RotateSmoothingVisibility() const
+        {
+            return EditorPropertyVisibility(m_rotateSmoothing);
+        }
+
+        AZ::Crc32 TranslateSmoothingVisibility() const
+        {
+            return EditorPropertyVisibility(m_translateSmoothing);
+        }
+    };
+
+    struct CameraInputSettings
+    {
+        AZ_TYPE_INFO(struct CameraInputSettings, "{A250FAD4-662E-4896-B030-D4ED03679377}")
+
+        AZStd::string m_translateForwardChannelId;
+        AZStd::string m_translateBackwardChannelId;
+        AZStd::string m_translateLeftChannelId;
+        AZStd::string m_translateRightChannelId;
+        AZStd::string m_translateUpChannelId;
+        AZStd::string m_translateDownChannelId;
+        AZStd::string m_boostChannelId;
+        AZStd::string m_orbitChannelId;
+        AZStd::string m_freeLookChannelId;
+        AZStd::string m_freePanChannelId;
+        AZStd::string m_orbitLookChannelId;
+        AZStd::string m_orbitDollyChannelId;
+        AZStd::string m_orbitPanChannelId;
     };
 
     CameraMovementSettings m_cameraMovementSettings;
+    CameraInputSettings m_cameraInputSettings;
+
     QIcon m_icon;
 };
-
-

Code/Editor/EditorViewportSettings.cpp

@@ -63,7 +63,11 @@ namespace SandboxEditor
         AZStd::remove_cvref_t<T> value = AZStd::forward<T>(defaultValue);
         if (const auto* registry = AZ::SettingsRegistry::Get())
         {
-            registry->Get(value, setting);
+            T potentialValue;
+            if (registry->Get(potentialValue, setting))
+            {
+                value = AZStd::move(potentialValue);
+            }
         }
 
         return value;
@@ -363,7 +367,7 @@ namespace SandboxEditor
 
     void SetCameraTranslateBoostChannelId(AZStd::string_view cameraTranslateBoostId)
     {
-        SetRegistry(CameraTranslateDownIdSetting, cameraTranslateBoostId);
+        SetRegistry(CameraTranslateBoostIdSetting, cameraTranslateBoostId);
     }
 
     AzFramework::InputChannelId CameraOrbitChannelId()
@@ -371,7 +375,7 @@ namespace SandboxEditor
         return AzFramework::InputChannelId(GetRegistry(CameraOrbitIdSetting, AZStd::string("keyboard_key_modifier_alt_l")).c_str());
     }
 
-    void SetCameraOrbitChannelChannelId(AZStd::string_view cameraOrbitId)
+    void SetCameraOrbitChannelId(AZStd::string_view cameraOrbitId)
     {
         SetRegistry(CameraOrbitIdSetting, cameraOrbitId);
     }

Code/Editor/EditorViewportSettings.h

@@ -111,7 +111,7 @@ namespace SandboxEditor
     SANDBOX_API void SetCameraTranslateBoostChannelId(AZStd::string_view cameraTranslateBoostId);
 
     SANDBOX_API AzFramework::InputChannelId CameraOrbitChannelId();
-    SANDBOX_API void SetCameraOrbitChannelChannelId(AZStd::string_view cameraOrbitId);
+    SANDBOX_API void SetCameraOrbitChannelId(AZStd::string_view cameraOrbitId);
 
     SANDBOX_API AzFramework::InputChannelId CameraFreeLookChannelId();
     SANDBOX_API void SetCameraFreeLookChannelId(AZStd::string_view cameraFreeLookId);

Code/Editor/EditorViewportWidget.cpp

@@ -50,10 +50,11 @@
 
 // AtomToolsFramework
 #include <AtomToolsFramework/Viewport/RenderViewportWidget.h>
-#include <AtomToolsFramework/Viewport/ModularViewportCameraController.h>
 
 // CryCommon
 #include <CryCommon/HMDBus.h>
+#include <CryCommon/IRenderAuxGeom.h>
+#include <CryCommon/physinterface.h>
 
 // AzFramework
 #include <AzFramework/Render/IntersectorInterface.h>
@@ -739,9 +740,13 @@ void EditorViewportWidget::OnBeginPrepareRender()
     RenderAll();
 
     // Draw 2D helpers.
+#ifdef LYSHINE_ATOM_TODO
     TransformationMatrices backupSceneMatrices;
+#endif
     m_debugDisplay->DepthTestOff();
-    //m_renderer->Set2DMode(m_rcClient.right(), m_rcClient.bottom(), backupSceneMatrices);
+#ifdef LYSHINE_ATOM_TODO
+    m_renderer->Set2DMode(m_rcClient.right(), m_rcClient.bottom(), backupSceneMatrices);
+#endif
     auto prevState = m_debugDisplay->GetState();
     m_debugDisplay->SetState(e_Mode3D | e_AlphaBlended | e_FillModeSolid | e_CullModeBack | e_DepthWriteOn | e_DepthTestOn);
 
@@ -1024,220 +1029,6 @@ bool EditorViewportWidget::ShowingWorldSpace()
     return BuildKeyboardModifiers(QGuiApplication::queryKeyboardModifiers()).Shift();
 }
 
-AZStd::shared_ptr<AtomToolsFramework::ModularViewportCameraController> CreateModularViewportCameraController(
-    const AzFramework::ViewportId viewportId)
-{
-    auto controller = AZStd::make_shared<AtomToolsFramework::ModularViewportCameraController>();
-
-    controller->SetCameraViewportContextBuilderCallback(
-        [viewportId](AZStd::unique_ptr<AtomToolsFramework::ModularCameraViewportContext>& cameraViewportContext)
-        {
-            cameraViewportContext = AZStd::make_unique<AtomToolsFramework::ModularCameraViewportContextImpl>(viewportId);
-        });
-
-    controller->SetCameraPriorityBuilderCallback(
-        [](AtomToolsFramework::CameraControllerPriorityFn& cameraControllerPriorityFn)
-        {
-            cameraControllerPriorityFn = AtomToolsFramework::DefaultCameraControllerPriority;
-        });
-
-    controller->SetCameraPropsBuilderCallback(
-        [](AzFramework::CameraProps& cameraProps)
-        {
-            cameraProps.m_rotateSmoothnessFn = []
-            {
-                return SandboxEditor::CameraRotateSmoothness();
-            };
-
-            cameraProps.m_translateSmoothnessFn = []
-            {
-                return SandboxEditor::CameraTranslateSmoothness();
-            };
-
-            cameraProps.m_rotateSmoothingEnabledFn = []
-            {
-                return SandboxEditor::CameraRotateSmoothingEnabled();
-            };
-
-            cameraProps.m_translateSmoothingEnabledFn = []
-            {
-                return SandboxEditor::CameraTranslateSmoothingEnabled();
-            };
-        });
-
-    controller->SetCameraListBuilderCallback(
-        [viewportId](AzFramework::Cameras& cameras)
-        {
-            const auto hideCursor = [viewportId]
-            {
-                if (SandboxEditor::CameraCaptureCursorForLook())
-                {
-                    AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::Event(
-                        viewportId, &AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::Events::BeginCursorCapture);
-                }
-            };
-            const auto showCursor = [viewportId]
-            {
-                if (SandboxEditor::CameraCaptureCursorForLook())
-                {
-                    AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::Event(
-                        viewportId, &AzToolsFramework::ViewportInteraction::ViewportMouseCursorRequestBus::Events::EndCursorCapture);
-                }
-            };
-
-            auto firstPersonRotateCamera = AZStd::make_shared<AzFramework::RotateCameraInput>(SandboxEditor::CameraFreeLookChannelId());
-            firstPersonRotateCamera->m_rotateSpeedFn = []
-            {
-                return SandboxEditor::CameraRotateSpeed();
-            };
-
-            // default behavior is to hide the cursor but this can be disabled (useful for remote desktop)
-            // note: See CaptureCursorLook in the Settings Registry
-            firstPersonRotateCamera->SetActivationBeganFn(hideCursor);
-            firstPersonRotateCamera->SetActivationEndedFn(showCursor);
-
-            auto firstPersonPanCamera =
-                AZStd::make_shared<AzFramework::PanCameraInput>(SandboxEditor::CameraFreePanChannelId(), AzFramework::LookPan);
-            firstPersonPanCamera->m_panSpeedFn = []
-            {
-                return SandboxEditor::CameraPanSpeed();
-            };
-            firstPersonPanCamera->m_invertPanXFn = []
-            {
-                return SandboxEditor::CameraPanInvertedX();
-            };
-            firstPersonPanCamera->m_invertPanYFn = []
-            {
-                return SandboxEditor::CameraPanInvertedY();
-            };
-
-            AzFramework::TranslateCameraInputChannels translateCameraInputChannels;
-            translateCameraInputChannels.m_leftChannelId = SandboxEditor::CameraTranslateLeftChannelId();
-            translateCameraInputChannels.m_rightChannelId = SandboxEditor::CameraTranslateRightChannelId();
-            translateCameraInputChannels.m_forwardChannelId = SandboxEditor::CameraTranslateForwardChannelId();
-            translateCameraInputChannels.m_backwardChannelId = SandboxEditor::CameraTranslateBackwardChannelId();
-            translateCameraInputChannels.m_upChannelId = SandboxEditor::CameraTranslateUpChannelId();
-            translateCameraInputChannels.m_downChannelId = SandboxEditor::CameraTranslateDownChannelId();
-            translateCameraInputChannels.m_boostChannelId = SandboxEditor::CameraTranslateBoostChannelId();
-
-            auto firstPersonTranslateCamera =
-                AZStd::make_shared<AzFramework::TranslateCameraInput>(AzFramework::LookTranslation, translateCameraInputChannels);
-            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>(SandboxEditor::CameraOrbitChannelId());
-            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>(SandboxEditor::CameraOrbitLookChannelId());
-            orbitRotateCamera->m_rotateSpeedFn = []
-            {
-                return SandboxEditor::CameraRotateSpeed();
-            };
-            orbitRotateCamera->m_invertYawFn = []
-            {
-                return SandboxEditor::CameraOrbitYawRotationInverted();
-            };
-
-            auto orbitTranslateCamera =
-                AZStd::make_shared<AzFramework::TranslateCameraInput>(AzFramework::OrbitTranslation, translateCameraInputChannels);
-            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>(SandboxEditor::CameraOrbitDollyChannelId());
-            orbitDollyMoveCamera->m_cursorSpeedFn = []
-            {
-                return SandboxEditor::CameraDollyMotionSpeed();
-            };
-
-            auto orbitPanCamera = AZStd::make_shared<AzFramework::PanCameraInput>(SandboxEditor::CameraOrbitPanChannelId(), 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);
@@ -1282,8 +1073,9 @@ void EditorViewportWidget::SetViewportId(int id)
 
     m_renderViewport->GetControllerList()->Add(AZStd::make_shared<SandboxEditor::ViewportManipulatorController>());
 
-    m_renderViewport->GetControllerList()->Add(CreateModularViewportCameraController(AzFramework::ViewportId(id)));
-    
+    m_editorModularViewportCameraComposer = AZStd::make_unique<SandboxEditor::EditorModularViewportCameraComposer>(AzFramework::ViewportId(id));
+    m_renderViewport->GetControllerList()->Add(m_editorModularViewportCameraComposer->CreateModularViewportCameraController());
+
     m_renderViewport->SetViewportSettings(&g_EditorViewportSettings);
 
     UpdateScene();
@@ -1643,7 +1435,7 @@ void EditorViewportWidget::SetViewTM(const Matrix34& camMatrix, bool bMoveOnly)
             {
                 // Should be impossible anyways
                 AZ_Assert(false, "Internal logic error - view entity Id and view source type out of sync. Please report this as a bug");
-                return ShouldUpdateObject::No; 
+                return ShouldUpdateObject::No;
             }
 
             // Check that the current view is the same view as the view entity view
@@ -1970,12 +1762,12 @@ Vec3 EditorViewportWidget::ViewToWorld(
 {
     AZ_PROFILE_FUNCTION(Editor);
 
-    AZ_UNUSED(collideWithTerrain)
-    AZ_UNUSED(onlyTerrain)
-    AZ_UNUSED(bTestRenderMesh)
-    AZ_UNUSED(bSkipVegetation)
-    AZ_UNUSED(bSkipVegetation)
-    AZ_UNUSED(collideWithObject)
+    AZ_UNUSED(collideWithTerrain);
+    AZ_UNUSED(onlyTerrain);
+    AZ_UNUSED(bTestRenderMesh);
+    AZ_UNUSED(bSkipVegetation);
+    AZ_UNUSED(bSkipVegetation);
+    AZ_UNUSED(collideWithObject);
 
     auto ray = m_renderViewport->ViewportScreenToWorldRay(AzToolsFramework::ViewportInteraction::ScreenPointFromQPoint(vp));
     if (!ray.has_value())
@@ -1999,82 +1791,15 @@ Vec3 EditorViewportWidget::ViewToWorld(
 //////////////////////////////////////////////////////////////////////////
 Vec3 EditorViewportWidget::ViewToWorldNormal(const QPoint& vp, bool onlyTerrain, bool bTestRenderMesh)
 {
-    AZ_UNUSED(vp)
-    AZ_UNUSED(onlyTerrain)
-    AZ_UNUSED(bTestRenderMesh)
+    AZ_UNUSED(vp);
+    AZ_UNUSED(onlyTerrain);
+    AZ_UNUSED(bTestRenderMesh);
 
     AZ_PROFILE_FUNCTION(Editor);
 
     return Vec3(0, 0, 1);
 }
 
-//////////////////////////////////////////////////////////////////////////
-bool EditorViewportWidget::AdjustObjectPosition(const ray_hit& hit, Vec3& outNormal, Vec3& outPos) const
-{
-    Matrix34A objMat, objMatInv;
-    Matrix33 objRot, objRotInv;
-
-    if (hit.pCollider->GetiForeignData() != PHYS_FOREIGN_ID_STATIC)
-    {
-        return false;
-    }
-
-    IRenderNode* pNode = (IRenderNode*) hit.pCollider->GetForeignData(PHYS_FOREIGN_ID_STATIC);
-    if (!pNode || !pNode->GetEntityStatObj())
-    {
-        return false;
-    }
-
-    IStatObj* pEntObject  = pNode->GetEntityStatObj(hit.partid, 0, &objMat, false);
-    if (!pEntObject || !pEntObject->GetRenderMesh())
-    {
-        return false;
-    }
-
-    objRot = Matrix33(objMat);
-    objRot.NoScale(); // No scale.
-    objRotInv = objRot;
-    objRotInv.Invert();
-
-    float fWorldScale = objMat.GetColumn(0).GetLength(); // GetScale
-    float fWorldScaleInv = 1.0f / fWorldScale;
-
-    // transform decal into object space
-    objMatInv = objMat;
-    objMatInv.Invert();
-
-    // put into normal object space hit direction of projection
-    Vec3 invhitn = -(hit.n);
-    Vec3 vOS_HitDir = objRotInv.TransformVector(invhitn).GetNormalized();
-
-    // put into position object space hit position
-    Vec3 vOS_HitPos = objMatInv.TransformPoint(hit.pt);
-    vOS_HitPos -= vOS_HitDir * RENDER_MESH_TEST_DISTANCE * fWorldScaleInv;
-
-    IRenderMesh* pRM = pEntObject->GetRenderMesh();
-
-    AABB aabbRNode;
-    pRM->GetBBox(aabbRNode.min, aabbRNode.max);
-    Vec3 vOut(0, 0, 0);
-    if (!Intersect::Ray_AABB(Ray(vOS_HitPos, vOS_HitDir), aabbRNode, vOut))
-    {
-        return false;
-    }
-
-    if (!pRM || !pRM->GetVerticesCount())
-    {
-        return false;
-    }
-
-    if (RayRenderMeshIntersection(pRM, vOS_HitPos, vOS_HitDir, outPos, outNormal))
-    {
-        outNormal = objRot.TransformVector(outNormal).GetNormalized();
-        outPos = objMat.TransformPoint(outPos);
-        return true;
-    }
-    return false;
-}
-
 //////////////////////////////////////////////////////////////////////////
 bool EditorViewportWidget::RayRenderMeshIntersection(IRenderMesh* pRenderMesh, const Vec3& vInPos, const Vec3& vInDir, Vec3& vOutPos, Vec3& vOutNormal) const
 {
@@ -2507,7 +2232,7 @@ void EditorViewportWidget::SetViewFromEntityPerspective(const AZ::EntityId& enti
 void EditorViewportWidget::SetViewAndMovementLockFromEntityPerspective(const AZ::EntityId& entityId, [[maybe_unused]] bool lockCameraMovement)
 {
     // This is an editor event, so is only serviced during edit mode, not play game mode
-    // 
+    //
     if (m_playInEditorState != PlayInEditorState::Editor)
     {
         AZ_Warning("EditorViewportWidget", false,

Code/Editor/EditorViewportWidget.h

@@ -19,6 +19,7 @@
 #include "Undo/Undo.h"
 #include "Util/PredefinedAspectRatios.h"
 #include "EditorViewportSettings.h"
+#include "EditorModularViewportCameraComposer.h"
 
 #include <AzCore/Component/EntityId.h>
 #include <AzCore/std/optional.h>
@@ -220,7 +221,6 @@ private:
     // Draw a selected region if it has been selected
     void RenderSelectedRegion();
 
-    bool AdjustObjectPosition(const ray_hit& hit, Vec3& outNormal, Vec3& outPos) const;
     bool RayRenderMeshIntersection(IRenderMesh* pRenderMesh, const Vec3& vInPos, const Vec3& vInDir, Vec3& vOutPos, Vec3& vOutNormal) const;
 
     bool AddCameraMenuItems(QMenu* menu);
@@ -370,6 +370,8 @@ private:
     // This widget holds a reference to the manipulator manage because its responsible for drawing manipulators
     AZStd::shared_ptr<AzToolsFramework::ManipulatorManager> m_manipulatorManager;
 
+    AZStd::unique_ptr<SandboxEditor::EditorModularViewportCameraComposer> m_editorModularViewportCameraComposer;
+
     // Helper for getting EditorEntityNotificationBus events
     AZStd::unique_ptr<AZ::ViewportHelpers::EditorEntityNotifications> m_editorEntityNotifications;
 
@@ -390,7 +392,3 @@ private:
 
     AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
 };
-
-//! Creates a modular camera controller in the configuration used by the editor viewport.
-SANDBOX_API AZStd::shared_ptr<AtomToolsFramework::ModularViewportCameraController> CreateModularViewportCameraController(
-    const AzFramework::ViewportId viewportId);

Code/Editor/Export/ExportManager.cpp

@@ -622,7 +622,7 @@ bool CExportManager::ShowFBXExportDialog()
 
     if (pivotObjectNode && !pivotObjectNode->IsGroupNode())
     {
-        m_pivotEntityObject = static_cast<CEntityObject*>(GetIEditor()->GetObjectManager()->FindObject(pivotObjectNode->GetName()));
+        m_pivotEntityObject = static_cast<CEntityObject*>(GetIEditor()->GetObjectManager()->FindObject(pivotObjectNode->GetName().c_str()));
 
         if (m_pivotEntityObject)
         {
@@ -807,7 +807,7 @@ void CExportManager::FillAnimTimeNode(XmlNodeRef writeNode, CTrackViewAnimNode*
 
     if (numAllTracks > 0)
     {
-        XmlNodeRef objNode = writeNode->createNode(CleanXMLText(pObjectNode->GetName()).toUtf8().data());
+        XmlNodeRef objNode = writeNode->createNode(CleanXMLText(pObjectNode->GetName().c_str()).toUtf8().data());
         writeNode->setAttr("time", m_animTimeExportPrimarySequenceCurrentTime);
 
         for (unsigned int trackID = 0; trackID < numAllTracks; ++trackID)
@@ -818,7 +818,7 @@ void CExportManager::FillAnimTimeNode(XmlNodeRef writeNode, CTrackViewAnimNode*
 
             if (trackType == AnimParamType::Animation || trackType == AnimParamType::Sound)
             {
-                QString childName = CleanXMLText(childTrack->GetName());
+                QString childName = CleanXMLText(childTrack->GetName().c_str());
 
                 if (childName.isEmpty())
                 {
@@ -976,7 +976,7 @@ bool CExportManager::AddObjectsFromSequence(CTrackViewSequence* pSequence, XmlNo
                     else
                     {
                         // In case of exporting animation/sound times data
-                        const QString sequenceName = pSubSequence->GetName();
+                        const QString sequenceName = QString::fromUtf8(pSubSequence->GetName().c_str());
                         XmlNodeRef subSeqNode2 = seqNode->createNode(sequenceName.toUtf8().data());
 
                         if (sequenceName == m_animTimeExportPrimarySequenceName)
@@ -1253,14 +1253,14 @@ void CExportManager::SaveNodeKeysTimeToXML()
         m_soundKeyTimeExport = exportDialog.IsSoundExportChecked();
 
         QString filters = "All files (*.xml)";
-        QString defaultName = QString(pSequence->GetName()) + ".xml";
+        QString defaultName = QString::fromUtf8(pSequence->GetName().c_str()) + ".xml";
 
         QtUtil::QtMFCScopedHWNDCapture cap;
         CAutoDirectoryRestoreFileDialog dlg(QFileDialog::AcceptSave, QFileDialog::AnyFile, "xml", defaultName, filters, {}, {}, cap);
         if (dlg.exec())
         {
-            m_animTimeNode = XmlHelpers::CreateXmlNode(pSequence->GetName());
-            m_animTimeExportPrimarySequenceName = pSequence->GetName();
+            m_animTimeNode = XmlHelpers::CreateXmlNode(pSequence->GetName().c_str());
+            m_animTimeExportPrimarySequenceName = QString::fromUtf8(pSequence->GetName().c_str());
 
             m_data.Clear();
             m_animTimeExportPrimarySequenceCurrentTime = 0.0;

Code/Editor/FBXExporterDialog.cpp

@@ -17,12 +17,6 @@ AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
 #include <ui_FBXExporterDialog.h>
 AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
 
-
-namespace
-{
-    const uint kDefaultFPS = 30u;
-}
-
 CFBXExporterDialog::CFBXExporterDialog(bool bDisplayOnlyFPSSetting, QWidget* pParent)
     : QDialog(pParent)
     , m_ui(new Ui::FBXExporterDialog)

Code/Editor/GameEngine.cpp

@@ -497,8 +497,7 @@ bool CGameEngine::LoadLevel(
     [[maybe_unused]] bool bDeleteAIGraph,
     bool bReleaseResources)
 {
-    LOADING_TIME_PROFILE_SECTION(GetIEditor()->GetSystem());
-    m_bLevelLoaded = false;
+     m_bLevelLoaded = false;
     CLogFile::FormatLine("Loading map '%s' into engine...", m_levelPath.toUtf8().data());
     // Switch the current directory back to the Primary CD folder first.
     // The engine might have trouble to find some files when the current

Code/Editor/GameExporter.h

@@ -102,7 +102,6 @@ private:
     AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
 
     bool m_bAutoExportMode;
-    int m_numExportedMaterials;
 
     static CGameExporter* m_pCurrentExporter;
 };

Code/Editor/IconManager.cpp

@@ -27,19 +27,6 @@
 
 namespace
 {
-    // Object names in this array must correspond to EObject enumeration.
-    const char* g_ObjectNames[eStatObject_COUNT] =
-    {
-        "Objects/Arrow.cgf",
-        "Objects/Axis.cgf",
-        "Objects/Sphere.cgf",
-        "Objects/Anchor.cgf",
-        "Objects/entrypoint.cgf",
-        "Objects/hidepoint.cgf",
-        "Objects/hidepoint_sec.cgf",
-        "Objects/reinforcement_point.cgf",
-    };
-
     const char* g_IconNames[eIcon_COUNT] =
     {
         "Icons/ScaleWarning.png",

Code/Editor/IconManager.h

@@ -15,9 +15,6 @@
 
 #pragma once
 
-struct IStatObj;
-struct IMaterial;
-
 #include "Include/IIconManager.h"   // for IIconManager
 #include "IEditor.h"                // for IDocListener
 

Code/Editor/Include/IEditorMaterial.h

@@ -6,8 +6,6 @@
  *
  */
 #pragma once
-#ifndef CRYINCLUDE_EDITOR_INCLUDE_IEDITORMATERIAL_H
-#define CRYINCLUDE_EDITOR_INCLUDE_IEDITORMATERIAL_H
 
 
 #include "BaseLibraryItem.h"
@@ -20,5 +18,3 @@ struct IEditorMaterial
     virtual _smart_ptr<IMaterial> GetMatInfo(bool bUseExistingEngineMaterial = false) = 0;
     virtual void DisableHighlightForFrame() = 0;
 };
-
-#endif

Code/Editor/Include/ISubObjectSelectionReferenceFrameCalculator.h

@@ -1,24 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-
-// Description : Calculate the reference frame for sub-object selections.
-
-
-#ifndef CRYINCLUDE_EDITOR_INCLUDE_ISUBOBJECTSELECTIONREFERENCEFRAMECALCULATOR_H
-#define CRYINCLUDE_EDITOR_INCLUDE_ISUBOBJECTSELECTIONREFERENCEFRAMECALCULATOR_H
-#pragma once
-
-
-class ISubObjectSelectionReferenceFrameCalculator
-{
-public:
-    virtual void SetExplicitFrame(bool bAnySelected, const Matrix34& refFrame) = 0;
-};
-
-#endif // CRYINCLUDE_EDITOR_INCLUDE_ISUBOBJECTSELECTIONREFERENCEFRAMECALCULATOR_H

Code/Editor/LayoutWnd.cpp

@@ -183,7 +183,6 @@ void CLayoutWnd::MaximizeViewport(int paneId)
 
     QString viewClass = m_viewType[paneId];
 
-    const QRect rc = rect();
     if (!m_bMaximized)
     {
         CLayoutViewPane* pViewPane = GetViewPane(paneId);

Code/Editor/LevelFileDialog.cpp

@@ -32,22 +32,6 @@ static const char lastLoadPathFilename[] = "lastLoadPath.preset";
 // Folder in which levels are stored
 static const char kLevelsFolder[] = "Levels";
 
-// List of folder names that are used to detect a level folder
-static const char* kLevelFolderNames[] =
-{
-    "Layers",
-    "Minimap",
-    "LevelData"
-};
-
-// List of files that are used to detect a level folder
-static const char* kLevelFileNames[] =
-{
-    "level.pak",
-    "filelist.xml",
-    "levelshadercache.pak",
-};
-
 CLevelFileDialog::CLevelFileDialog(bool openDialog, QWidget* parent)
     : QDialog(parent)
     , m_bOpenDialog(openDialog)

Code/Editor/LevelFileDialog.h

@@ -64,7 +64,6 @@ private:
     QString m_fileName;
     QString m_filter;
     const bool m_bOpenDialog;
-    bool m_initialized = false;
     LevelTreeModel* const m_model;
     LevelTreeModelFilter* const m_filterModel;
 };

Code/Editor/Lib/Tests/test_ModularViewportCameraController.cpp

@@ -139,7 +139,8 @@ namespace UnitTest
             m_viewportMouseCursorRequests.Connect(TestViewportId, m_inputChannelMapper.get());
 
             // create editor modular camera
-            auto controller = CreateModularViewportCameraController(TestViewportId);
+            m_editorModularViewportCameraComposer = AZStd::make_unique<SandboxEditor::EditorModularViewportCameraComposer>(TestViewportId);
+            auto controller = m_editorModularViewportCameraComposer->CreateModularViewportCameraController();
 
             // set some overrides for the test
             controller->SetCameraViewportContextBuilderCallback(
@@ -169,6 +170,7 @@ namespace UnitTest
 
         void HaltCollaborators()
         {
+            m_editorModularViewportCameraComposer.reset();
             m_mockWindowRequests.Disconnect();
             m_viewportMouseCursorRequests.Disconnect();
             m_cameraViewportContextView = nullptr;
@@ -212,6 +214,7 @@ namespace UnitTest
         ViewportMouseCursorRequestImpl m_viewportMouseCursorRequests;
         AtomToolsFramework::ModularCameraViewportContext* m_cameraViewportContextView = nullptr;
         AZStd::unique_ptr<AZ::SettingsRegistryInterface> m_settingsRegistry;
+        AZStd::unique_ptr<SandboxEditor::EditorModularViewportCameraComposer> m_editorModularViewportCameraComposer;
     };
 
     const AzFramework::ViewportId ModularViewportCameraControllerFixture::TestViewportId = AzFramework::ViewportId(0);

Code/Editor/LogFile.cpp

@@ -179,19 +179,17 @@ void CLogFile::FormatLineV(const char * format, va_list argList)
 
 void CLogFile::AboutSystem()
 {
-    char szBuffer[MAX_LOGBUFFER_SIZE];
-    wchar_t szBufferW[MAX_LOGBUFFER_SIZE];
 #if defined(AZ_PLATFORM_WINDOWS) || defined(AZ_PLATFORM_LINUX)
     //////////////////////////////////////////////////////////////////////
     // Write the system informations to the log
     //////////////////////////////////////////////////////////////////////
-
-    wchar_t szLanguageBufferW[64];
+    char szBuffer[MAX_LOGBUFFER_SIZE];
     //wchar_t szCPUModel[64];
     MEMORYSTATUS MemoryStatus;
 #endif // defined(AZ_PLATFORM_WINDOWS) || defined(AZ_PLATFORM_LINUX)
 
 #if defined(AZ_PLATFORM_WINDOWS)
+    wchar_t szLanguageBufferW[64];
     DEVMODE DisplayConfig;
     OSVERSIONINFO OSVerInfo;
     OSVerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
@@ -288,7 +286,7 @@ AZ_POP_DISABLE_WARNING
             str += "Version Unknown";
         }
     }
-    azsnprintf(szBuffer, MAX_LOGBUFFER_SIZE, " %d.%d", OSVerInfo.dwMajorVersion, OSVerInfo.dwMinorVersion);
+    azsnprintf(szBuffer, MAX_LOGBUFFER_SIZE, " %ld.%ld", OSVerInfo.dwMajorVersion, OSVerInfo.dwMinorVersion);
     str += szBuffer;
 
     //////////////////////////////////////////////////////////////////////
@@ -296,6 +294,7 @@ AZ_POP_DISABLE_WARNING
     //////////////////////////////////////////////////////////////////////
 
     str += " (";
+    wchar_t szBufferW[MAX_LOGBUFFER_SIZE];
     GetWindowsDirectoryW(szBufferW, sizeof(szBufferW));
     AZStd::to_string(szBuffer, MAX_LOGBUFFER_SIZE, szBufferW);
     str += szBuffer;
@@ -338,7 +337,7 @@ AZ_POP_DISABLE_WARNING
     str += " ";
     azstrdate(szBuffer);
     str += szBuffer;
-    azsnprintf(szBuffer, MAX_LOGBUFFER_SIZE, ", system running for %d minutes", GetTickCount() / 60000);
+    azsnprintf(szBuffer, MAX_LOGBUFFER_SIZE, ", system running for %ld minutes", GetTickCount() / 60000);
     str += szBuffer;
     CryLog("%s", str.toUtf8().data());
 #else
@@ -388,7 +387,7 @@ AZ_POP_DISABLE_WARNING
         L"(Unknown graphics card)", szLanguageBufferW, sizeof(szLanguageBufferW),
         L"system.ini");
     AZStd::to_string(szLanguageBuffer, szLanguageBufferW);
-    azsnprintf(szBuffer, MAX_LOGBUFFER_SIZE, "Current display mode is %dx%dx%d, %s",
+    azsnprintf(szBuffer, MAX_LOGBUFFER_SIZE, "Current display mode is %ldx%ldx%ld, %s",
         DisplayConfig.dmPelsWidth, DisplayConfig.dmPelsHeight,
         DisplayConfig.dmBitsPerPel, szLanguageBuffer.c_str());
     CryLog("%s", szBuffer);

Code/Editor/MainStatusBar.cpp

@@ -15,6 +15,7 @@
 // AzQtComponents
 #include <AzQtComponents/Components/Widgets/CheckBox.h>
 #include <AzQtComponents/Components/Style.h>
+#include <AzQtComponents/Utilities/DesktopUtilities.h>
 
 // Qt
 #include <QMenu>
@@ -209,7 +210,7 @@ MainStatusBar::MainStatusBar(QWidget* parent)
 
     addPermanentWidget(new StatusBarItem(QStringLiteral("connection"), true, this, true), 1);
 
-    addPermanentWidget(new StatusBarItem(QStringLiteral("game_info"), this, true), 1);
+    addPermanentWidget(new GameInfoItem(QStringLiteral("game_info"), this), 1);
 
     addPermanentWidget(new MemoryStatusItem(QStringLiteral("memory"), this), 1);
 }
@@ -221,11 +222,6 @@ void MainStatusBar::Init()
         500
     };                                             //in ms, so 2 FPS
 
-    AZ::IO::FixedMaxPathString projectPath = AZ::Utils::GetProjectPath();
-    QString strGameInfo;
-    strGameInfo = tr("GameFolder: '%1'").arg(projectPath.c_str());
-    SetItem(QStringLiteral("game_info"), strGameInfo, tr("Game Info"), QPixmap());
-
     //ask for updates for items regularly. This is basically what MFC does
     auto timer = new QTimer(this);
     timer->setInterval(statusbarTimerUpdateInterval);
@@ -436,5 +432,29 @@ QString GeneralStatusItem::CurrentText() const
     return StatusBarItem::CurrentText();
 }
 
+GameInfoItem::GameInfoItem(QString name, MainStatusBar* parent)
+    : StatusBarItem(name, parent, true)
+{
+    m_projectPath = QString::fromUtf8(AZ::Utils::GetProjectPath().c_str());
+
+    SetText(QObject::tr("GameFolder: '%1'").arg(m_projectPath));
+    SetToolTip(QObject::tr("Game Info"));
+
+    setContextMenuPolicy(Qt::CustomContextMenu);
+    QObject::connect(this, &QWidget::customContextMenuRequested, this, &GameInfoItem::OnShowContextMenu);
+}
+
+void GameInfoItem::OnShowContextMenu(const QPoint& pos)
+{
+    QMenu contextMenu(this);
+
+    // Context menu action to open the project folder in file browser
+    contextMenu.addAction(AzQtComponents::fileBrowserActionName(), this, [this]() {
+        AzQtComponents::ShowFileOnDesktop(m_projectPath);
+    });
+
+    contextMenu.exec(mapToGlobal(pos));
+}
+
 #include <moc_MainStatusBar.cpp>
 #include <moc_MainStatusBarItems.cpp>

Code/Editor/MainStatusBarItems.h

@@ -71,3 +71,17 @@ public:
 private:
     void updateStatus();
 };
+
+class GameInfoItem
+    : public StatusBarItem
+{
+    Q_OBJECT
+public:
+    GameInfoItem(QString name, MainStatusBar* parent);
+
+private Q_SLOTS:
+    void OnShowContextMenu(const QPoint& pos);
+
+private:
+    QString m_projectPath;
+};

Code/Editor/MainWindow.cpp

@@ -108,12 +108,6 @@ using namespace AzToolsFramework;
 #define LAYOUTS_WILDCARD "*.layout"
 #define DUMMY_LAYOUT_NAME "Dummy_Layout"
 
-static const char* g_openViewPaneEventName = "OpenViewPaneEvent"; //Sent when users open view panes;
-static const char* g_viewPaneAttributeName = "ViewPaneName"; //Name of the current view pane
-static const char* g_openLocationAttributeName = "OpenLocation"; //Indicates where the current view pane is opened from
-
-static const char* g_assetImporterName = "AssetImporter";
-
 class CEditorOpenViewCommand
     : public _i_reference_target_t
 {
@@ -303,7 +297,7 @@ MainWindow::MainWindow(QWidget* parent)
     , m_settings("O3DE", "O3DE")
     , m_toolbarManager(new ToolbarManager(m_actionManager, this))
     , m_assetImporterManager(new AssetImporterManager(this))
-    , m_levelEditorMenuHandler(new LevelEditorMenuHandler(this, m_viewPaneManager, m_settings))
+    , m_levelEditorMenuHandler(new LevelEditorMenuHandler(this, m_viewPaneManager))
     , m_sourceControlNotifHandler(new AzToolsFramework::QtSourceControlNotificationHandler(this))
     , m_viewPaneHost(nullptr)
     , m_autoSaveTimer(nullptr)

Code/Editor/Objects/BaseObject.h

@@ -33,7 +33,6 @@ class CGizmo;
 class CObjectArchive;
 struct SSubObjSelectionModifyContext;
 struct SRayHitInfo;
-class ISubObjectSelectionReferenceFrameCalculator;
 class CPopupMenuItem;
 class QMenu;
 struct IRenderNode;
@@ -571,7 +570,6 @@ public:
     // Return true if object support selecting of this sub object element type.
     virtual bool StartSubObjSelection([[maybe_unused]] int elemType) { return false; };
     virtual void EndSubObjectSelection() {};
-    virtual void CalculateSubObjectSelectionReferenceFrame([[maybe_unused]] ISubObjectSelectionReferenceFrameCalculator* pCalculator) { };
     virtual void ModifySubObjSelection([[maybe_unused]] SSubObjSelectionModifyContext& modCtx) {};
     virtual void AcceptSubObjectModify() {};
 

Code/Editor/Objects/DisplayContext.h

@@ -63,7 +63,6 @@ struct SANDBOX_API DisplayContext
 
     CDisplaySettings* settings;
     IDisplayViewport* view;
-    IRenderer* renderer;
     IRenderAuxGeom* pRenderAuxGeom;
     IIconManager* pIconManager;
     CCamera*    camera;

Code/Editor/Objects/DisplayContextShared.inl

@@ -26,7 +26,6 @@
 DisplayContext::DisplayContext()
 {
     view = 0;
-    renderer = 0;
     flags = 0;
     settings = 0;
     pIconManager = 0;
@@ -1083,7 +1082,10 @@ void DisplayContext::DrawTerrainLine(Vec3 worldPos1, Vec3 worldPos2)
 //////////////////////////////////////////////////////////////////////////
 void DisplayContext::DrawTextLabel(const Vec3& pos, float size, const char* text, const bool bCenter, [[maybe_unused]] int srcOffsetX, [[maybe_unused]] int scrOffsetY)
 {
-    ColorF col(m_color4b.r * (1.0f / 255.0f), m_color4b.g * (1.0f / 255.0f), m_color4b.b * (1.0f / 255.0f), m_color4b.a * (1.0f / 255.0f));
+    AZ_ErrorOnce(nullptr, false, "DisplayContext::DrawTextLabel needs to be removed/ported to use Atom");
+
+#if 0
+      ColorF col(m_color4b.r * (1.0f / 255.0f), m_color4b.g * (1.0f / 255.0f), m_color4b.b * (1.0f / 255.0f), m_color4b.a * (1.0f / 255.0f));
 
     float fCol[4] = { col.r, col.g, col.b, col.a };
     if (flags & DISPLAY_2D)
@@ -1096,13 +1098,28 @@ void DisplayContext::DrawTextLabel(const Vec3& pos, float size, const char* text
     {
         renderer->DrawLabelEx(pos, size, fCol, true, true, text);
     }
+#else
+    AZ_UNUSED(pos);
+    AZ_UNUSED(size);
+    AZ_UNUSED(text);
+    AZ_UNUSED(bCenter);
+#endif
 }
 
 //////////////////////////////////////////////////////////////////////////
 void DisplayContext::Draw2dTextLabel(float x, float y, float size, const char* text, bool bCenter)
 {
+    AZ_ErrorOnce(nullptr, false, "DisplayContext::Draw2dTextLabel needs to be removed/ported to use Atom");
+#if 0
     float col[4] = { m_color4b.r * (1.0f / 255.0f), m_color4b.g * (1.0f / 255.0f), m_color4b.b * (1.0f / 255.0f), m_color4b.a * (1.0f / 255.0f) };
     renderer->Draw2dLabel(x, y, size, col, bCenter, "%s", text);
+#else
+    AZ_UNUSED(x);
+    AZ_UNUSED(y);
+    AZ_UNUSED(size);
+    AZ_UNUSED(text);
+    AZ_UNUSED(bCenter);
+#endif
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -1269,6 +1286,9 @@ void DisplayContext::Flush2D()
     int rcw, rch;
     view->GetDimensions(&rcw, &rch);
 
+    AZ_ErrorOnce(nullptr, false, "DisplayContext::Flush2D needs to be removed/ported to use Atom");
+#if 0
+
     TransformationMatrices backupSceneMatrices;
 
     renderer->Set2DMode(rcw, rch, backupSceneMatrices, 0.0f, 1.0f);
@@ -1310,6 +1330,7 @@ void DisplayContext::Flush2D()
     }
 
     renderer->Unset2DMode(backupSceneMatrices);
+#endif
 
     m_textureLabels.clear();
 }

Code/Editor/Objects/ObjectManager.cpp

@@ -1555,11 +1555,8 @@ void CObjectManager::DeleteSelection()
     // Make sure to unlock selection.
     GetIEditor()->LockSelection(false);
 
-    GUID bID = GUID_NULL;
-
-    int i;
     CSelectionGroup objects;
-    for (i = 0; i < m_currSelection->GetCount(); i++)
+    for (int i = 0; i < m_currSelection->GetCount(); i++)
     {
         // Check condition(s) if object could be deleted
         if (!IsObjectDeletionAllowed(m_currSelection->GetObject(i)))
@@ -2899,17 +2896,6 @@ namespace
         return AZ::Vector3(position.x, position.y, position.z);
     }
 
-    AZ::Vector3 PyGetWorldObjectPosition(const char* pName)
-    {
-        CBaseObject* pObject = GetIEditor()->GetObjectManager()->FindObject(pName);
-        if (!pObject)
-        {
-            throw std::logic_error((QString("\"") + pName + "\" is an invalid object.").toUtf8().data());
-        }
-        Vec3 position = pObject->GetWorldPos();
-        return AZ::Vector3(position.x, position.y, position.z);
-    }
-
     void PySetObjectPosition(const char* pName, float fValueX, float fValueY, float fValueZ)
     {
         CBaseObject* pObject = GetIEditor()->GetObjectManager()->FindObject(pName);

Code/Editor/Objects/SelectionGroup.cpp

@@ -316,8 +316,6 @@ void CSelectionGroup::Rotate(const Ang3& angles, int referenceCoordSys)
     //  return;
 
     // Rotate selection about selection center.
-    Vec3 center = GetCenter();
-
     Matrix34 rotateTM = Matrix34::CreateRotationXYZ(DEG2RAD(angles));
     Rotate(rotateTM, referenceCoordSys);
 }

Code/Editor/Objects/TrackGizmo.cpp

@@ -27,9 +27,11 @@
 //////////////////////////////////////////////////////////////////////////
 #define AXIS_SIZE 0.1f
 
+#if 0
 namespace {
     int s_highlightAxis = 0;
 }
+#endif
 
 //////////////////////////////////////////////////////////////////////////
 CTrackGizmo::CTrackGizmo()
@@ -175,13 +177,15 @@ void CTrackGizmo::DrawAxis(DisplayContext& dc, const Vec3& org)
     y = y * fScreenScale;
     z = z * fScreenScale;
 
+    Vec3 colX(1, 0, 0), colY(0, 1, 0), colZ(0, 0, 1);
+
+    AZ_ErrorOnce(nullptr, false, "CTrackGizmo::DrawAxis needs to be removed/ported to use Atom");
+#if 0
     float col[4] = { 1, 1, 1, 1 };
-    float hcol[4] = { 1, 0, 0, 1 };
     dc.renderer->DrawLabelEx(org + x, 1.2f, col, true, true, "X");
     dc.renderer->DrawLabelEx(org + y, 1.2f, col, true, true, "Y");
     dc.renderer->DrawLabelEx(org + z, 1.2f, col, true, true, "Z");
 
-    Vec3 colX(1, 0, 0), colY(0, 1, 0), colZ(0, 0, 1);
     if (s_highlightAxis)
     {
         float col2[4] = { 1, 0, 0, 1 };
@@ -201,6 +205,7 @@ void CTrackGizmo::DrawAxis(DisplayContext& dc, const Vec3& org)
             dc.renderer->DrawLabelEx(org + z, 1.2f, col2, true, true, "Z");
         }
     }
+#endif
 
     x = x * 0.8f;
     y = y * 0.8f;

Code/Editor/Platform/Mac/main_dummy.cpp

@@ -66,8 +66,8 @@ int main(int argc, char* argv[])
     processLaunchInfo.m_environmentVariables = &envVars;
     processLaunchInfo.m_showWindow = true;
 
-    AzFramework::ProcessWatcher* processWatcher = AzFramework::ProcessWatcher::LaunchProcess(processLaunchInfo, AzFramework::ProcessCommunicationType::COMMUNICATOR_TYPE_NONE);
-    
+    AZStd::unique_ptr<AzFramework::ProcessWatcher> processWatcher(AzFramework::ProcessWatcher::LaunchProcess(processLaunchInfo, AzFramework::ProcessCommunicationType::COMMUNICATOR_TYPE_NONE));
+
     application.Destroy();
 
     return 0;

Code/Editor/Plugin.h

@@ -13,6 +13,7 @@
 #include "Include/IEditorClassFactory.h"
 
 #include "Util/GuidUtil.h"
+#include <map>
 
 //! Derive from this class to decrease the amount of work for creating a new class description
 //! Provides standard reference counter implementation for IUnknown

Code/Editor/Plugins/ComponentEntityEditorPlugin/Objects/ComponentEntityObject.cpp

@@ -40,6 +40,7 @@
 #include <LmbrCentral/Rendering/MaterialOwnerBus.h>
 
 #include <IDisplayViewport.h>
+#include <CryCommon/Cry_GeoIntersect.h>
 #include <MathConversion.h>
 #include <TrackView/TrackViewAnimNode.h>
 #include <ViewManager.h>
@@ -49,11 +50,6 @@
  * Scalars for icon drawing behavior.
  */
 static const int s_kIconSize              = 36;       /// Icon display size (in pixels)
-static const float s_kIconMaxWorldDist    = 200.f;    /// Icons are culled past this range
-static const float s_kIconMinScale        = 0.1f;     /// Minimum scale for icons in the distance
-static const float s_kIconMaxScale        = 1.0f;     /// Maximum scale for icons near the camera
-static const float s_kIconCloseDist       = 3.f;      /// Distance at which icons are at maximum scale
-static const float s_kIconFarDist         = 40.f;     /// Distance at which icons are at minimum scale
 
 CComponentEntityObject::CComponentEntityObject()
     : m_hasIcon(false)

Code/Editor/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.cpp

@@ -528,7 +528,6 @@ void SandboxIntegrationManager::EntityParentChanged(
         oldAncestor = nextParentId;
     } while (oldAncestor.IsValid());
 
-    AZ::EntityId newAncestors = newParentId;
     AZ::EntityId newAncestor = newParentId;
 
     bool isGoingToRootScene = false;
@@ -721,7 +720,7 @@ void SandboxIntegrationManager::PopulateEditorGlobalContextMenu(QMenu* menu, con
         if (selected.size() > 0)
         {
             action = menu->addAction(QObject::tr("Find in Entity Outliner"));
-            QObject::connect(action, &QAction::triggered, [this, selected]
+            QObject::connect(action, &QAction::triggered, [selected]
             {
                 AzToolsFramework::EditorEntityContextNotificationBus::Broadcast(&EditorEntityContextNotification::OnFocusInEntityOutliner, selected);
             });
@@ -842,7 +841,7 @@ void SandboxIntegrationManager::SetupLayerContextMenu(QMenu* menu)
 
             QAction* findLayerAssetAction = menu->addAction(QObject::tr("Find layer in Asset Browser"));
             findLayerAssetAction->setToolTip(QObject::tr("Selects this layer in the Asset Browser"));
-            QObject::connect(findLayerAssetAction, &QAction::triggered, [this, fullFilePath] {
+            QObject::connect(findLayerAssetAction, &QAction::triggered, [fullFilePath] {
                 QtViewPaneManager::instance()->OpenPane(LyViewPane::AssetBrowser);
 
                 AzToolsFramework::AssetBrowser::AssetBrowserViewRequestBus::Broadcast(

Code/Editor/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.h

@@ -280,7 +280,6 @@ private:
 
 private:
     AZ::Vector2 m_contextMenuViewPoint;
-    AZ::Vector3 m_sliceWorldPos;
 
     int m_inObjectPickMode;
     short m_startedUndoRecordingNestingLevel;   // used in OnBegin/EndUndo to ensure we only accept undo's we started recording
@@ -298,8 +297,6 @@ private:
     const AZStd::string m_defaultComponentViewportIconLocation = "Icons/Components/Viewport/Component_Placeholder.svg";
     const AZStd::string m_defaultEntityIconLocation = "Icons/Components/Viewport/Transform.svg";
 
-    bool m_debugDisplayBusImplementationActive = false;
-
     AzToolsFramework::Prefab::PrefabIntegrationManager* m_prefabIntegrationManager = nullptr;
 
     AzToolsFramework::EditorEntityUiInterface* m_editorEntityUiInterface = nullptr;

Code/Editor/Plugins/ComponentEntityEditorPlugin/UI/Outliner/OutlinerListModel.cpp

@@ -1234,8 +1234,6 @@ bool OutlinerListModel::ReparentEntities(const AZ::EntityId& newParentId, const
 QMimeData* OutlinerListModel::mimeData(const QModelIndexList& indexes) const
 {
     AZ_PROFILE_FUNCTION(AzToolsFramework);
-    AZ::TypeId uuid1 = AZ::AzTypeInfo<AZ::Entity>::Uuid();
-    AZ::TypeId uuid2 = AZ::AzTypeInfo<AzToolsFramework::EditorEntityIdContainer>::Uuid();
 
     AzToolsFramework::EditorEntityIdContainer entityIdList;
     for (const QModelIndex& index : indexes)
@@ -1462,13 +1460,11 @@ void OutlinerListModel::OnEntityRuntimeActivationChanged(AZ::EntityId entityId,
     QueueEntityUpdate(entityId);
 }
 
-void OutlinerListModel::OnEntityInfoUpdatedRemoveChildBegin(AZ::EntityId parentId, AZ::EntityId childId)
+void OutlinerListModel::OnEntityInfoUpdatedRemoveChildBegin([[maybe_unused]] AZ::EntityId parentId, [[maybe_unused]] AZ::EntityId childId)
 {
     //add/remove operations trigger selection change signals which assert and break undo/redo operations in progress in inspector etc.
     //so disallow selection updates until change is complete
     emit EnableSelectionUpdates(false);
-    auto parentIndex = GetIndexFromEntity(parentId);
-    auto childIndex = GetIndexFromEntity(childId);
     beginResetModel();
 }
 

Code/Editor/PythonEditorFuncs.cpp

@@ -33,18 +33,6 @@
 
 namespace
 {
-    //////////////////////////////////////////////////////////////////////////
-    const char* PyGetCVar(const char* pName)
-    {
-        ICVar* pCVar = GetIEditor()->GetSystem()->GetIConsole()->GetCVar(pName);
-        if (!pCVar)
-        {
-            Warning("PyGetCVar: Attempt to access non-existent CVar '%s'", pName ? pName : "(null)");
-            throw std::logic_error((QString("\"") + pName + "\" is an invalid cvar.").toUtf8().data());
-        }
-        return pCVar->GetString();
-    }
-
     //////////////////////////////////////////////////////////////////////////
     const char* PyGetCVarAsString(const char* pName)
     {
@@ -212,52 +200,6 @@ namespace
         return GetIEditor()->IsInSimulationMode();
     }
 
-    //////////////////////////////////////////////////////////////////////////
-    QString PyNewObject(const char* typeName, const char* fileName, const char* name, float x, float y, float z)
-    {
-        CBaseObject* object = GetIEditor()->NewObject(typeName, fileName, name, x, y, z);
-        if (object)
-        {
-            return object->GetName();
-        }
-        else
-        {
-            return "";
-        }
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    QString PyNewObjectAtCursor(const char* typeName, const char* fileName, const char* name)
-    {
-        CUndo undo("Create new object");
-
-        Vec3 pos(0, 0, 0);
-
-        QPoint p = QCursor::pos();
-        CViewport* viewport = GetIEditor()->GetViewManager()->GetViewportAtPoint(p);
-        if (viewport)
-        {
-            viewport->ScreenToClient(p);
-            if (GetIEditor()->GetAxisConstrains() != AXIS_TERRAIN)
-            {
-                pos = viewport->MapViewToCP(p);
-            }
-            else
-            {
-                // Snap to terrain.
-                bool hitTerrain;
-                pos = viewport->ViewToWorld(p, &hitTerrain);
-                if (hitTerrain)
-                {
-                    pos.z = GetIEditor()->GetTerrainElevation(pos.x, pos.y) + 1.0f;
-                }
-                pos = viewport->SnapToGrid(pos);
-            }
-        }
-
-        return PyNewObject(typeName, fileName, name, pos.x, pos.y, pos.z);
-    }
-
     //////////////////////////////////////////////////////////////////////////
     void PyRunConsole(const char* text)
     {

Code/Editor/QtViewPaneManager.cpp

@@ -240,14 +240,13 @@ static bool SkipTitleBarOverdraw(QtViewPane* pane)
     return !pane->m_options.isDockable;
 }
 
-DockWidget::DockWidget(QWidget* widget, QtViewPane* pane, QSettings* settings, QMainWindow* parent, AzQtComponents::FancyDocking* advancedDockManager)
+DockWidget::DockWidget(QWidget* widget, QtViewPane* pane, [[maybe_unused]] QSettings* settings, QMainWindow* parent, AzQtComponents::FancyDocking* advancedDockManager)
     : AzQtComponents::StyledDockWidget(pane->m_name, SkipTitleBarOverdraw(pane),
 #if AZ_TRAIT_OS_PLATFORM_APPLE
           pane->m_options.detachedWindow ? nullptr : parent)
 #else
           parent)
 #endif
-    , m_settings(settings)
     , m_mainWindow(parent)
     , m_pane(pane)
     , m_advancedDockManager(advancedDockManager)

Code/Editor/QtViewPaneManager.h

@@ -67,7 +67,6 @@ private:
     void reparentToMainWindowFix();
     QRect ProperGeometry() const;
     QString settingsKey() const;
-    QSettings* const m_settings;
     QMainWindow* const m_mainWindow;
     QtViewPane* const m_pane;
     AzQtComponents::FancyDocking* m_advancedDockManager;

Code/Editor/RenderHelpers/AxisHelperShared.inl

@@ -191,7 +191,6 @@ void CAxisHelper::DrawAxis(const Matrix34& worldTM, const SGizmoParameters& setu
     {
         if (axis)
         {
-            float col[4] = { 1, 0, 0, 1 };
             if (axis == AXIS_X || axis == AXIS_XY || axis == AXIS_XZ || axis == AXIS_XYZ)
             {
                 colX = colSelected;
@@ -436,7 +435,6 @@ void CAxisHelper::DrawAxis(const Matrix34& worldTM, const SGizmoParameters& setu
             {
                 dc.SetColor(QColor(128, 32, 32), 0.4f);
             }
-            Vec3 org = worldTM.GetTranslation();
             dc.DrawBall(Vec3(0.0f),  m_size * kSelectionBallScale);
         }
 

Code/Editor/SettingsManager.cpp

@@ -987,7 +987,7 @@ QString CSettingsManager::GenerateContentHash(XmlNodeRef& node, QString sourceNa
         return sourceName;
     }
 
-    uint32 hash = CCrc32::ComputeLowercase(node->getXML(0));
+    uint32 hash = AZ::Crc32(node->getXML(0));
     hashStr = QString::number(hash);
 
     return hashStr;

Code/Editor/StartupTraceHandler.cpp

@@ -168,7 +168,7 @@ namespace SandboxEditor
 
     void StartupTraceHandler::ShowMessageBox(const QString& message)
     {
-        AZ::SystemTickBus::QueueFunction([this, message]()
+        AZ::SystemTickBus::QueueFunction([message]()
         {
             // Parent to the main window, so that the error dialog doesn't
             // show up as a separate window when alt-tabbing.

Code/Editor/ToolbarManager.cpp

@@ -1217,7 +1217,6 @@ void EditableQToolBar::dropEvent(QDropEvent* ev)
         return;
     }
 
-    const int actionId = action->data().toInt();
     QWidget* beforeWidget = insertPositionForDrop(ev->pos());
     QAction* beforeAction = beforeWidget ? ActionForWidget(beforeWidget) : nullptr;
 

Code/Editor/ToolsConfigPage.cpp

@@ -39,8 +39,6 @@ namespace
     QColor COLOR_FOR_CONSOLE_COMMAND = QColor(0, 0, 255);
     QColor COLOR_FOR_TOGGLE_COMMAND = QColor(128, 0, 255);
     QColor COLOR_FOR_INVALID_COMMAND = QColor(255, 0, 0);
-
-    UINT CONSOLE_CMD_DROP_LIST_HEIGHT           = 300;
 };
 
 class IconListModel

Code/Editor/TopRendererWnd.cpp

@@ -26,27 +26,6 @@
 #define GL_RGBA 0x1908
 #define GL_BGRA 0x80E1
 
-// Used to give each static object type a different color
-static uint32 sVegetationColors[16] =
-{
-    0xFFFF0000,
-    0xFF00FF00,
-    0xFF0000FF,
-    0xFFFFFFFF,
-    0xFFFF00FF,
-    0xFFFFFF00,
-    0xFF00FFFF,
-    0xFF7F00FF,
-    0xFF7FFF7F,
-    0xFFFF7F00,
-    0xFF00FF7F,
-    0xFF7F7F7F,
-    0xFFFF0000,
-    0xFF00FF00,
-    0xFF0000FF,
-    0xFFFFFFFF,
-};
-
 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
 //////////////////////////////////////////////////////////////////////

Code/Editor/TrackView/CommentNodeAnimator.cpp

@@ -13,6 +13,7 @@
 
 // CryCommon
 #include <CryCommon/Maestro/Types/AnimParamType.h>
+#include <CryCommon/IFont.h>
 
 // Editor
 #include "Settings.h"

Code/Editor/TrackView/DirectorNodeAnimator.cpp

@@ -19,10 +19,8 @@
 
 
 ////////////////////////////////////////////////////////////////////////////
-CDirectorNodeAnimator::CDirectorNodeAnimator(CTrackViewAnimNode* pDirectorNode)
-    : m_pDirectorNode(pDirectorNode)
+CDirectorNodeAnimator::CDirectorNodeAnimator([[maybe_unused]] CTrackViewAnimNode* pDirectorNode)
 {
-    assert(m_pDirectorNode != nullptr);
 }
 
 ////////////////////////////////////////////////////////////////////////////
@@ -139,7 +137,6 @@ void CDirectorNodeAnimator::ForEachActiveSequence(const SAnimContext& ac, CTrack
     const bool bHandleOtherKeys, std::function<void(CTrackViewSequence*, const SAnimContext&)> animateFunction,
     std::function<void(CTrackViewSequence*, const SAnimContext&)> resetFunction)
 {
-    const float time = ac.time;
     const unsigned int numKeys = pSequenceTrack->GetKeyCount();
 
     if (bHandleOtherKeys)

Code/Editor/TrackView/DirectorNodeAnimator.h

@@ -34,7 +34,5 @@ private:
     void ForEachActiveSequence(const SAnimContext& ac, CTrackViewTrack* pSequenceTrack,
         const bool bHandleOtherKeys, std::function<void(CTrackViewSequence*, const SAnimContext&)> animateFunction,
         std::function<void(CTrackViewSequence*, const SAnimContext&)> resetFunction);
-
-    CTrackViewAnimNode* m_pDirectorNode;
 };
 #endif // CRYINCLUDE_EDITOR_TRACKVIEW_DIRECTORNODEANIMATOR_H

Code/Editor/TrackView/TVCustomizeTrackColorsDlg.cpp

@@ -106,7 +106,6 @@ namespace
         { AnimParamType::User, "Muted", QColor(255, 224, 224) },
     };
 
-    const int kButtonsIdBase = 0x7fff;
     const int kMaxRows = 20;
     const int kColumnWidth = 300;
     const int kRowHeight = 24;

Code/Editor/TrackView/TVEventsDialog.cpp

@@ -29,12 +29,6 @@ AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
 
 // CTVEventsDialog dialog
 
-namespace
-{
-    const int kCountSubItemIndex = 1;
-    const int kTimeSubItemIndex = 2;
-}
-
 class TVEventsModel
     : public QAbstractTableModel
 {

Code/Editor/TrackView/TVSequenceProps.cpp

@@ -53,7 +53,7 @@ CTVSequenceProps::~CTVSequenceProps()
 // CTVSequenceProps message handlers
 bool CTVSequenceProps::OnInitDialog()
 {
-    ui->NAME->setText(m_pSequence->GetName());
+    ui->NAME->setText(m_pSequence->GetName().c_str());
     int seqFlags = m_pSequence->GetFlags();
 
     ui->ALWAYS_PLAY->setChecked((seqFlags & IAnimSequence::eSeqFlags_PlayOnReset));
@@ -141,7 +141,7 @@ void CTVSequenceProps::UpdateSequenceProps(const QString& name)
         ac->UpdateTimeRange();
     }
 
-    QString seqName = m_pSequence->GetName();
+    QString seqName = QString::fromUtf8(m_pSequence->GetName().c_str());
     if (name != seqName)
     {
         // Rename sequence.

Code/Editor/TrackView/TrackViewAnimNode.cpp

@@ -423,7 +423,7 @@ CTrackViewAnimNode* CTrackViewAnimNode::CreateSubNode(
                 AZStd::string::format(
                     "Failed to add '%s' to sequence '%s', could not find associated entity. "
                     "Please try adding the entity associated with '%s'.",
-                    originalNameStr.constData(), director->GetName(), originalNameStr.constData()));
+                    originalNameStr.constData(), director->GetName().c_str(), originalNameStr.constData()));
 
             return nullptr;
         }
@@ -472,7 +472,7 @@ CTrackViewAnimNode* CTrackViewAnimNode::CreateSubNode(
         {
             GetIEditor()->GetMovieSystem()->LogUserNotificationMsg(
                 AZStd::string::format("'%s' already exists in sequence '%s', skipping...",
-                    originalNameStr.constData(), director2->GetName()));
+                    originalNameStr.constData(), director2->GetName().c_str()));
 
             return nullptr;
         }
@@ -488,7 +488,7 @@ CTrackViewAnimNode* CTrackViewAnimNode::CreateSubNode(
     if (!newAnimNode)
     {
         GetIEditor()->GetMovieSystem()->LogUserNotificationMsg(
-            AZStd::string::format("Failed to add '%s' to sequence '%s'.", nameStr.constData(), director->GetName()));
+            AZStd::string::format("Failed to add '%s' to sequence '%s'.", nameStr.constData(), director->GetName().c_str()));
         return nullptr;
     }
 
@@ -1195,7 +1195,7 @@ CTrackViewAnimNodeBundle CTrackViewAnimNode::GetAnimNodesByName(const char* pNam
 {
     CTrackViewAnimNodeBundle bundle;
 
-    QString nodeName = GetName();
+    QString nodeName = QString::fromUtf8(GetName().c_str());
     if (GetNodeType() == eTVNT_AnimNode && QString::compare(pName, nodeName, Qt::CaseInsensitive) == 0)
     {
         bundle.AppendAnimNode(this);
@@ -1215,10 +1215,9 @@ CTrackViewAnimNodeBundle CTrackViewAnimNode::GetAnimNodesByName(const char* pNam
 }
 
 //////////////////////////////////////////////////////////////////////////
-const char* CTrackViewAnimNode::GetParamName(const CAnimParamType& paramType) const
+AZStd::string CTrackViewAnimNode::GetParamName(const CAnimParamType& paramType) const
 {
-    const char* pName = m_animNode->GetParamName(paramType);
-    return pName ? pName : "";
+    return m_animNode->GetParamName(paramType);
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -1274,7 +1273,7 @@ CTrackViewAnimNodeBundle CTrackViewAnimNode::AddSelectedEntities(const AZStd::ve
             if (existingNode->GetDirector() == GetDirector())
             {
                 GetIEditor()->GetMovieSystem()->LogUserNotificationMsg(AZStd::string::format(
-                    "'%s' was already added to '%s', skipping...", entity->GetName().c_str(), GetDirector()->GetName()));
+                    "'%s' was already added to '%s', skipping...", entity->GetName().c_str(), GetDirector()->GetName().c_str()));
 
                 continue;
             }
@@ -1377,7 +1376,7 @@ void CTrackViewAnimNode::UpdateDynamicParams()
 void CTrackViewAnimNode::CopyKeysToClipboard(XmlNodeRef& xmlNode, const bool bOnlySelectedKeys, const bool bOnlyFromSelectedTracks)
 {
     XmlNodeRef childNode = xmlNode->createNode("Node");
-    childNode->setAttr("name", GetName());
+    childNode->setAttr("name", GetName().c_str());
     childNode->setAttr("type", static_cast<int>(GetType()));
 
     for (auto iter = m_childNodes.begin(); iter != m_childNodes.end(); ++iter)
@@ -1683,7 +1682,7 @@ bool CTrackViewAnimNode::IsValidReparentingTo(CTrackViewAnimNode* pNewParent)
     }
 
     // Check if the new parent already contains a node with this name
-    CTrackViewAnimNodeBundle foundNodes = pNewParent->GetAnimNodesByName(GetName());
+    CTrackViewAnimNodeBundle foundNodes = pNewParent->GetAnimNodesByName(GetName().c_str());
     if (foundNodes.GetCount() > 1 || (foundNodes.GetCount() == 1 && foundNodes.GetNode(0) != this))
     {
         return false;
@@ -1820,7 +1819,6 @@ bool CTrackViewAnimNode::IsDisabled() const
 //////////////////////////////////////////////////////////////////////////
 void CTrackViewAnimNode::SetPos(const Vec3& position)
 {
-    const float time = GetSequence()->GetTime();
     CTrackViewTrack* track = GetTrackForParameter(AnimParamType::Position);
 
     if (track)

Code/Editor/TrackView/TrackViewAnimNode.h

@@ -124,7 +124,7 @@ public:
     virtual void SetAsViewCamera();
 
     // Name setter/getter
-    virtual const char* GetName() const override { return m_animNode->GetName(); }
+    AZStd::string GetName() const override { return m_animNode->GetName(); }
     virtual bool SetName(const char* pName) override;
     virtual bool CanBeRenamed() const override;
 
@@ -187,7 +187,7 @@ public:
     // Param
     unsigned int GetParamCount() const;
     CAnimParamType GetParamType(unsigned int index) const;
-    const char* GetParamName(const CAnimParamType& paramType) const;
+    AZStd::string GetParamName(const CAnimParamType& paramType) const;
     bool IsParamValid(const CAnimParamType& param) const;
     IAnimNode::ESupportedParamFlags GetParamFlags(const CAnimParamType& paramType) const;
     AnimValueType GetParamValueType(const CAnimParamType& paramType) const;

Code/Editor/TrackView/TrackViewDialog.cpp

@@ -77,9 +77,6 @@ inline namespace TrackViewInternal
     const int s_kMinimumFrameSnappingFPS = 1;
     const int s_kMaximumFrameSnappingFPS = 120;
 
-    const int TRACKVIEW_LAYOUT_VERSION = 0x0001; // Bump this up on every substantial pane layout change
-    const int TRACKVIEW_REBAR_VERSION = 0x0002; // Bump this up on every substantial rebar change
-
     CTrackViewSequence* GetSequenceByEntityIdOrName(const CTrackViewSequenceManager* pSequenceManager, const char* entityIdOrName)
     {
         // the "name" string will be an AZ::EntityId in string form if this was called from
@@ -1125,7 +1122,7 @@ void CTrackViewDialog::ReloadSequencesComboBox()
         {
             CTrackViewSequence* sequence = pSequenceManager->GetSequenceByIndex(k);
             QString entityIdString = GetEntityIdAsString(sequence->GetSequenceComponentEntityId());
-            m_sequencesComboBox->addItem(sequence->GetName(), entityIdString);
+            m_sequencesComboBox->addItem(QString::fromUtf8(sequence->GetName().c_str()), entityIdString);
         }
     }
 
@@ -2033,7 +2030,7 @@ void CTrackViewDialog::UpdateTracksToolBar()
                     continue;
                 }
 
-                name = pAnimNode->GetParamName(paramType);
+                name = QString::fromUtf8(pAnimNode->GetParamName(paramType).c_str());
 
                 QString sToolTipText("Add " + name + " Track");
                 QIcon hIcon = m_wndNodesCtrl->GetIconForTrack(pTrack);
@@ -2309,7 +2306,7 @@ void CTrackViewDialog::SaveCurrentSequenceToFBX()
         return;
     }
 
-    QString selectedSequenceFBXStr = QString(sequence->GetName()) + ".fbx";
+    QString selectedSequenceFBXStr = QString::fromUtf8(sequence->GetName().c_str()) + ".fbx";
     CExportManager* pExportManager = static_cast<CExportManager*>(GetIEditor()->GetExportManager());
     const char szFilters[] = "FBX Files (*.fbx)";
 

Code/Editor/TrackView/TrackViewDopeSheetBase.cpp

@@ -199,7 +199,6 @@ void CTrackViewDopeSheetBase::SetTimeRange(float start, float end)
 void CTrackViewDopeSheetBase::SetTimeScale(float timeScale, float fAnchorTime)
 {
     const double fOldOffset = -fAnchorTime * m_timeScale;
-    const double fOldScale = m_timeScale;
 
     timeScale = std::max(timeScale, 0.001f);
     timeScale = std::min(timeScale, 100000.0f);
@@ -1426,8 +1425,6 @@ void CTrackViewDopeSheetBase::OnCaptureChanged()
 //////////////////////////////////////////////////////////////////////////
 bool CTrackViewDopeSheetBase::IsOkToAddKeyHere(const CTrackViewTrack* pTrack, float time) const
 {
-    const float timeEpsilon = 0.05f;
-
     for (unsigned int i = 0; i < pTrack->GetKeyCount(); ++i)
     {
         const CTrackViewKeyConstHandle& keyHandle = pTrack->GetKey(i);
@@ -2152,8 +2149,6 @@ void CTrackViewDopeSheetBase::AcceptUndo()
 {
     if (CUndo::IsRecording())
     {
-        const QPoint mousePos = mapFromGlobal(QCursor::pos());
-
         CTrackViewSequence* sequence = GetIEditor()->GetAnimation()->GetSequence();
 
         if (m_mouseMode == eTVMouseMode_Paste)
@@ -2623,7 +2618,6 @@ void CTrackViewDopeSheetBase::DrawBoolTrack(const Range& timeRange, QPainter* pa
 {
     int x0 = TimeToClient(timeRange.start);
     float t0 = timeRange.start;
-    QRect trackRect;
 
     const QBrush prevBrush = painter->brush();
     painter->setBrush(m_visibilityBrush);
@@ -2752,7 +2746,6 @@ void CTrackViewDopeSheetBase::DrawKeys(CTrackViewTrack* pTrack, QPainter* painte
         }
 
         int x1 = x + kDefaultWidthForDescription;
-        CTrackViewKeyHandle nextKey = keyHandle.GetNextKey();
 
         int nextKeyIndex = i + 1;
 
@@ -3453,7 +3446,7 @@ void CTrackViewDopeSheetBase::DrawNodeTrack(CTrackViewAnimNode* animNode, QPaint
 
     const QRect textRect = trackRect.adjusted(4, 0, -4, 0);
 
-    QString sAnimNodeName = animNode->GetName();
+    QString sAnimNodeName = QString::fromUtf8(animNode->GetName().c_str());
     const bool hasObsoleteTrack = animNode->HasObsoleteTrack();
 
     if (hasObsoleteTrack)

Code/Editor/TrackView/TrackViewNode.cpp

@@ -22,16 +22,12 @@
 ////////////////////////////////////////////////////////////////////////////
 void CTrackViewKeyConstHandle::GetKey(IKey* pKey) const
 {
-    assert(m_bIsValid);
-
     m_pTrack->GetKey(m_keyIndex, pKey);
 }
 
 ////////////////////////////////////////////////////////////////////////////
 float CTrackViewKeyConstHandle::GetTime() const
 {
-    assert(m_bIsValid);
-
     return m_pTrack->GetKeyTime(m_keyIndex);
 }
 
@@ -626,7 +622,7 @@ bool CTrackViewNode::operator<(const CTrackViewNode& otherNode) const
         if (thisTypeOrder == otherTypeOrder)
         {
             // Same node type, sort by name
-            return azstricmp(thisAnimNode.GetName(), otherAnimNode.GetName()) < 0;
+            return thisAnimNode.GetName() < otherAnimNode.GetName();
         }
 
         return thisTypeOrder < otherTypeOrder;
@@ -638,7 +634,7 @@ bool CTrackViewNode::operator<(const CTrackViewNode& otherNode) const
         if (thisTrack.GetParameterType() == otherTrack.GetParameterType())
         {
             // Same parameter type, sort by name
-            return azstricmp(thisTrack.GetName(), otherTrack.GetName()) < 0;
+            return thisTrack.GetName() < otherTrack.GetName();
         }
 
         return thisTrack.GetParameterType() < otherTrack.GetParameterType();

Code/Editor/TrackView/TrackViewNode.h

@@ -22,13 +22,11 @@ class CTrackViewKeyConstHandle
 {
 public:
     CTrackViewKeyConstHandle()
-        : m_bIsValid(false)
-        , m_keyIndex(0)
+        : m_keyIndex(0)
         , m_pTrack(nullptr) {}
 
     CTrackViewKeyConstHandle(const CTrackViewTrack* pTrack, unsigned int keyIndex)
-        : m_bIsValid(true)
-        , m_keyIndex(keyIndex)
+        : m_keyIndex(keyIndex)
         , m_pTrack(pTrack) {}
 
     void GetKey(IKey* pKey) const;
@@ -36,7 +34,6 @@ public:
     const CTrackViewTrack* GetTrack() const { return m_pTrack; }
 
 private:
-    bool m_bIsValid;
     unsigned int m_keyIndex;
     const CTrackViewTrack* m_pTrack;
 };
@@ -159,7 +156,7 @@ public:
     virtual ~CTrackViewNode() {}
 
     // Name
-    virtual const char* GetName() const = 0;
+    virtual AZStd::string GetName() const = 0;
     virtual bool SetName([[maybe_unused]] const char* pName) { return false; };
     virtual bool CanBeRenamed() const { return false; }
 

Code/Editor/TrackView/TrackViewNodes.cpp

@@ -616,7 +616,7 @@ CTrackViewNodesCtrl::CRecord* CTrackViewNodesCtrl::AddAnimNodeRecord(CRecord* pP
 {
     CRecord* pNewRecord = new CRecord(animNode);
 
-    pNewRecord->setText(0, animNode->GetName());
+    pNewRecord->setText(0, QString::fromUtf8(animNode->GetName().c_str()));
     UpdateAnimNodeRecord(pNewRecord, animNode);
     pParentRecord->insertChild(GetInsertPosition(pParentRecord, animNode), pNewRecord);
     FillNodesRec(pNewRecord, animNode);
@@ -629,7 +629,7 @@ CTrackViewNodesCtrl::CRecord* CTrackViewNodesCtrl::AddTrackRecord(CRecord* pPare
 {
     CRecord* pNewTrackRecord = new CRecord(pTrack);
     pNewTrackRecord->setSizeHint(0, QSize(30, 18));
-    pNewTrackRecord->setText(0, pTrack->GetName());
+    pNewTrackRecord->setText(0, QString::fromUtf8(pTrack->GetName().c_str()));
     UpdateTrackRecord(pNewTrackRecord, pTrack);
     pParentRecord->insertChild(GetInsertPosition(pParentRecord, pTrack), pNewTrackRecord);
     FillNodesRec(pNewTrackRecord, pTrack);
@@ -860,7 +860,7 @@ void CTrackViewNodesCtrl::OnFillItems()
         m_nodeToRecordMap.clear();
 
         CRecord* pRootGroupRec = new CRecord(sequence);
-        pRootGroupRec->setText(0, sequence->GetName());
+        pRootGroupRec->setText(0, QString::fromUtf8(sequence->GetName().c_str()));
         QFont f = font();
         f.setBold(true);
         pRootGroupRec->setData(0, Qt::FontRole, f);
@@ -1032,8 +1032,8 @@ void CTrackViewNodesCtrl::OnNMRclick(QPoint point)
                 return;
             }
 
-            QString file = QString(sequence2->GetName()) + QString(".fbx");
-            QString selectedSequenceFBXStr = QString(sequence2->GetName()) + ".fbx";
+            QString file = QString::fromUtf8(sequence2->GetName().c_str()) + QString(".fbx");
+            QString selectedSequenceFBXStr = QString::fromUtf8(sequence2->GetName().c_str()) + ".fbx";
 
             if (numSelectedNodes > 1)
             {
@@ -1041,7 +1041,7 @@ void CTrackViewNodesCtrl::OnNMRclick(QPoint point)
             }
             else
             {
-                file = QString(selectedNodes.GetNode(0)->GetName()) + QString(".fbx");
+                file = QString::fromUtf8(selectedNodes.GetNode(0)->GetName().c_str()) + QString(".fbx");
             }
 
             QString path = QFileDialog::getSaveFileName(this, tr("Export Selected Nodes To FBX File"), QString(), tr("FBX Files (*.fbx)"));
@@ -1338,7 +1338,7 @@ void CTrackViewNodesCtrl::OnNMRclick(QPoint point)
         if (animNode || groupNode)
         {
             CTrackViewAnimNode* animNode2 = static_cast<CTrackViewAnimNode*>(pNode);
-            QString oldName = animNode2->GetName();
+            QString oldName = QString::fromUtf8(animNode2->GetName().c_str());
 
             StringDlg dlg(tr("Rename Node"));
             dlg.SetString(oldName);
@@ -1494,7 +1494,7 @@ void CTrackViewNodesCtrl::OnNMRclick(QPoint point)
         if (animNode)
         {
             QString matName;
-            GetMatNameAndSubMtlIndexFromName(matName, animNode->GetName());
+            GetMatNameAndSubMtlIndexFromName(matName, animNode->GetName().c_str());
             QString newMatName;
             newMatName = tr("%1.[%2]").arg(matName).arg(cmd - eMI_SelectSubmaterialBase + 1);
             CUndo undo("Rename TrackView node");
@@ -1576,7 +1576,7 @@ CTrackViewTrack* CTrackViewNodesCtrl::GetTrackViewTrack(const Export::EntityAnim
     for (unsigned int trackID = 0; trackID < trackBundle.GetCount(); ++trackID)
     {
         CTrackViewTrack* pTrack = trackBundle.GetTrack(trackID);
-        const QString bundleTrackName = pTrack->GetAnimNode()->GetName();
+        const QString bundleTrackName = QString::fromUtf8(pTrack->GetAnimNode()->GetName().c_str());
 
         if (bundleTrackName.compare(nodeName, Qt::CaseInsensitive) != 0)
         {
@@ -2164,7 +2164,7 @@ int CTrackViewNodesCtrl::ShowPopupMenuSingleSelection(SContextMenu& contextMenu,
     if (bOnNode && !pNode->IsGroupNode())
     {
         AddMenuSeperatorConditional(contextMenu.main, bAppended);
-        QString string = QString("%1 Tracks").arg(animNode->GetName());
+        QString string = QString("%1 Tracks").arg(animNode->GetName().c_str());
         contextMenu.main.addAction(string)->setEnabled(false);
 
         bool bAppendedTrackFlag = false;
@@ -2182,7 +2182,7 @@ int CTrackViewNodesCtrl::ShowPopupMenuSingleSelection(SContextMenu& contextMenu,
                     continue;
                 }
 
-                QAction* a = contextMenu.main.addAction(QString("  %1").arg(pTrack2->GetName()));
+                QAction* a = contextMenu.main.addAction(QString("  %1").arg(pTrack2->GetName().c_str()));
                 a->setData(eMI_ShowHideBase + childIndex);
                 a->setCheckable(true);
                 a->setChecked(!pTrack2->IsHidden());
@@ -2348,13 +2348,12 @@ bool CTrackViewNodesCtrl::FillAddTrackMenu(STrackMenuTreeNode& menuAddTrack, con
                 continue;
             }
         }
-        name = animNode->GetParamName(paramType);
-        QStringList splittedName = name.split("/", Qt::SkipEmptyParts);
+        name = QString::fromUtf8(animNode->GetParamName(paramType).c_str());
+        QStringList splitName = name.split("/", Qt::SkipEmptyParts);
 
         STrackMenuTreeNode* pCurrentNode = &menuAddTrack;
-        for (int j = 0; j < splittedName.size() - 1; ++j)
+        for (const QString& segment : splitName)
         {
-            const QString& segment = splittedName[j];
             auto findIter = pCurrentNode->children.find(segment);
             if (findIter != pCurrentNode->children.end())
             {
@@ -2370,10 +2369,10 @@ bool CTrackViewNodesCtrl::FillAddTrackMenu(STrackMenuTreeNode& menuAddTrack, con
 
         // only add tracks to the that STrackMenuTreeNode tree that haven't already been added
         CTrackViewTrackBundle matchedTracks = animNode->GetTracksByParam(paramType);
-        if (matchedTracks.GetCount() == 0)
+        if (matchedTracks.GetCount() == 0 && !splitName.isEmpty())
         {
             STrackMenuTreeNode* pParamNode = new STrackMenuTreeNode;
-            pCurrentNode->children[splittedName.back()] = std::unique_ptr<STrackMenuTreeNode>(pParamNode);
+            pCurrentNode->children[splitName.back()] = std::unique_ptr<STrackMenuTreeNode>(pParamNode);
             pParamNode->paramType = paramType;
 
             bTracksToAdd = true;
@@ -2464,7 +2463,7 @@ void CTrackViewNodesCtrl::FillAutoCompletionListForFilter()
 
         for (unsigned int i = 0; i < animNodeCount; ++i)
         {
-            strings << animNodes.GetNode(i)->GetName();
+            strings << QString::fromUtf8(animNodes.GetNode(i)->GetName().c_str());
         }
     }
     else
@@ -2580,10 +2579,10 @@ void CTrackViewNodesCtrl::Update()
             {
                 const CTrackViewAnimNode* track = static_cast<const CTrackViewAnimNode*>(node);
                 if (track)
-                { 
-                    record->setText(0, track->GetName());
+                {
+                    record->setText(0, QString::fromUtf8(track->GetName().c_str()));
                 }
-            }            
+            }
         }
     }
 }
@@ -2855,7 +2854,7 @@ void CTrackViewNodesCtrl::OnNodeRenamed(CTrackViewNode* pNode, [[maybe_unused]]
     if (!m_bIgnoreNotifications)
     {
         CRecord* pNodeRecord = GetNodeRecord(pNode);
-        pNodeRecord->setText(0, pNode->GetName());
+        pNodeRecord->setText(0, QString::fromUtf8(pNode->GetName().c_str()));
 
         update();
     }

Code/Editor/TrackView/TrackViewNodes.h

@@ -66,7 +66,7 @@ public:
         CRecord(CTrackViewNode* pNode = nullptr);
         CTrackViewNode* GetNode() const { return m_pNode; }
         bool IsGroup() const { return m_pNode->GetChildCount() != 0; }
-        const QString GetName() const { return m_pNode->GetName(); }
+        const QString GetName() const { return QString::fromUtf8(m_pNode->GetName().c_str()); }
 
         // Workaround: CXTPReportRecord::IsVisible is
         // unreliable after the last visible element
@@ -202,7 +202,6 @@ private:
 
     // Drag and drop
     CTrackViewAnimNodeBundle m_draggedNodes;
-    CTrackViewAnimNode* m_pDragTarget;
 
     std::unordered_map<unsigned int, CAnimParamType> m_menuParamTypeMap;
     std::unordered_map<const CTrackViewNode*, CRecord*> m_nodeToRecordMap;

Code/Editor/TrackView/TrackViewPythonFuncs.cpp

@@ -293,8 +293,8 @@ namespace
             CTrackViewTrack* pTrack = pNode->GetTrackForParameter(paramType);
             if (!pTrack || (paramFlags & IAnimNode::eSupportedParamFlags_MultipleTracks))
             {
-                const char* name = pNode->GetParamName(paramType);
-                if (_stricmp(name, paramName) == 0)
+                AZStd::string name = pNode->GetParamName(paramType);
+                if (name == paramName)
                 {
                     CUndo undo("Create track");
                     if (!pNode->CreateTrack(paramType))

Code/Editor/TrackView/TrackViewPythonFuncs.h

@@ -35,7 +35,7 @@ namespace AzToolsFramework
         : public AZ::Component
         , public EditorLayerTrackViewRequestBus::Handler
     {
-    AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
+    AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
     AZ_POP_DISABLE_DLL_EXPORT_BASECLASS_WARNING
     public:
         AZ_COMPONENT(TrackViewComponent, "{3CF943CC-6F10-4B19-88FC-CFB697558FFD}")

Code/Editor/TrackView/TrackViewSequence.cpp

@@ -135,9 +135,7 @@ CTrackViewKeyHandle CTrackViewSequence::FindSingleSelectedKey()
 
 //////////////////////////////////////////////////////////////////////////
 void CTrackViewSequence::OnEntityComponentPropertyChanged(AZ::ComponentId changedComponentId)
-{
-    const AZ::EntityId entityId = *AzToolsFramework::PropertyEditorEntityChangeNotificationBus::GetCurrentBusId();
-   
+{  
     // find the component node for this changeComponentId if it exists
     for (int i = m_pAnimSequence->GetNodeCount(); --i >= 0;)
     {
@@ -894,14 +892,14 @@ bool CTrackViewSequence::SetName(const char* name)
         return false;
     }
 
-    const char* oldName = GetName();
-    if (0 != strcmp(name, oldName))
+    AZStd::string oldName = GetName();
+    if (name != oldName)
     {
         m_pAnimSequence->SetName(name);
         MarkAsModified();
 
         AzToolsFramework::ScopedUndoBatch undoBatch("Rename Sequence");
-        GetSequence()->OnNodeRenamed(this, oldName);
+        GetSequence()->OnNodeRenamed(this, oldName.c_str());
         undoBatch.MarkEntityDirty(m_pAnimSequence->GetSequenceEntityId());
     }
 

Code/Editor/TrackView/TrackViewSequence.h

@@ -102,7 +102,7 @@ public:
     // ITrackViewNode
     virtual ETrackViewNodeType GetNodeType() const override { return eTVNT_Sequence; }
 
-    virtual const char* GetName() const override { return m_pAnimSequence->GetName(); }
+    virtual AZStd::string GetName() const override { return m_pAnimSequence->GetName(); }
     virtual bool SetName(const char* pName) override;
     virtual bool CanBeRenamed() const override { return true; }
 

Code/Editor/TrackView/TrackViewSequenceManager.cpp

@@ -75,7 +75,7 @@ CTrackViewSequence* CTrackViewSequenceManager::GetSequenceByName(QString name) c
     {
         CTrackViewSequence* sequence = (*iter).get();
 
-        if (sequence->GetName() == name)
+        if (QString::fromUtf8(sequence->GetName().c_str()) == name)
         {
             return sequence;
         }
@@ -371,8 +371,8 @@ void CTrackViewSequenceManager::SortSequences()
     std::stable_sort(m_sequences.begin(), m_sequences.end(),
         [](const std::unique_ptr<CTrackViewSequence>& a, const std::unique_ptr<CTrackViewSequence>& b) -> bool
         {
-            QString aName = a.get()->GetName();
-            QString bName = b.get()->GetName();
+            QString aName = QString::fromUtf8(a.get()->GetName().c_str());
+            QString bName = QString::fromUtf8(b.get()->GetName().c_str());
             return aName < bName;
         });
 }

Code/Editor/TrackView/TrackViewSplineCtrl.cpp

@@ -611,7 +611,6 @@ void CTrackViewSplineCtrl::mouseMoveEvent(QMouseEvent* event)
 
     CTrackViewSequenceNotificationContext context(pSequence);
 
-    QPoint cMousePosPrev = m_cMousePos;
     m_cMousePos = point;
 
     if (m_editMode == NothingMode)

Code/Editor/TrackView/TrackViewTrack.cpp

@@ -472,7 +472,7 @@ void CTrackViewTrack::RestoreFromMemento(const CTrackViewTrackMemento& memento)
 }
 
 //////////////////////////////////////////////////////////////////////////
-const char* CTrackViewTrack::GetName() const
+AZStd::string CTrackViewTrack::GetName() const
 {
     CTrackViewNode* pParentNode = GetParentNode();
 
@@ -810,7 +810,7 @@ void CTrackViewTrack::CopyKeysToClipboard(XmlNodeRef& xmlNode, const bool bOnlyS
     }
 
     XmlNodeRef childNode = xmlNode->newChild("Track");
-    childNode->setAttr("name", GetName());
+    childNode->setAttr("name", GetName().c_str());
     GetParameterType().SaveToXml(childNode);
     childNode->setAttr("valueType", static_cast<int>(GetValueType()));
 

Code/Editor/TrackView/TrackViewTrack.h

@@ -80,7 +80,7 @@ public:
     CTrackViewAnimNode* GetAnimNode() const;
 
     // Name getter
-    virtual const char* GetName() const;
+    AZStd::string GetName() const override;
 
     // CTrackViewNode
     virtual ETrackViewNodeType GetNodeType() const override { return eTVNT_Track; }

Code/Editor/TrackView/TrackViewUndo.cpp

@@ -75,7 +75,7 @@ CTrackViewTrack* CUndoComponentEntityTrackObject::FindTrack(CTrackViewSequence*
         CTrackViewTrack* curTrack = allTracks.GetTrack(trackIndex);
         if (curTrack->GetAnimNode() && curTrack->GetAnimNode()->GetComponentId() == m_trackComponentId)
         {
-            if (0 == azstricmp(curTrack->GetName(), m_trackName.c_str()))
+            if (curTrack->GetName() == m_trackName)
             {
                 CTrackViewAnimNode* parentAnimNode = static_cast<CTrackViewAnimNode*>(curTrack->GetAnimNode()->GetParentNode());
                 if (parentAnimNode && parentAnimNode->GetAzEntityId() == m_entityId)

Code/Editor/TrackViewNewSequenceDialog.cpp

@@ -81,7 +81,7 @@ void CTVNewSequenceDialog::OnOK()
     for (unsigned int k = 0; k < GetIEditor()->GetSequenceManager()->GetCount(); ++k)
     {
         CTrackViewSequence* pSequence = GetIEditor()->GetSequenceManager()->GetSequenceByIndex(k);
-        QString fullname = pSequence->GetName();
+        QString fullname = QString::fromUtf8(pSequence->GetName().c_str());
 
         if (fullname.compare(m_sequenceName, Qt::CaseInsensitive) == 0)
         {

Code/Editor/Util/ColorUtils.cpp

@@ -24,7 +24,7 @@ QColor ColorLinearToGamma(ColorF col)
     g = (float)(g <= 0.0031308 ? (12.92 * g) : (1.055 * pow((double)g, 1.0 / 2.4) - 0.055));
     b = (float)(b <= 0.0031308 ? (12.92 * b) : (1.055 * pow((double)b, 1.0 / 2.4) - 0.055));
 
-    return QColor(FtoI(r * 255.0f), FtoI(g * 255.0f), FtoI(b * 255.0f), FtoI(a * 255.0f));
+    return QColor(int(r * 255.0f), int(g * 255.0f), int(b * 255.0f), int(a * 255.0f));
 }
 
 //////////////////////////////////////////////////////////////////////////

Code/Editor/Util/ColumnGroupTreeView.h

@@ -71,7 +71,6 @@ private:
     ColumnGroupHeaderView* m_header;
     ColumnGroupProxyModel* m_groupModel;
     QSet<QString> m_openNodes;
-    bool m_showGroups;
 };
 
 #endif // COLUMNGROUPTREEVIEW_H

Code/Editor/Util/EditorUtils.cpp

@@ -205,7 +205,7 @@ QColor ColorLinearToGamma(ColorF col)
     g = (float)(g <= 0.0031308 ? (12.92 * g) : (1.055 * pow((double)g, 1.0 / 2.4) - 0.055));
     b = (float)(b <= 0.0031308 ? (12.92 * b) : (1.055 * pow((double)b, 1.0 / 2.4) - 0.055));
 
-    return QColor(FtoI(r * 255.0f), FtoI(g * 255.0f), FtoI(b * 255.0f), FtoI(a * 255.0f));
+    return QColor(int(r * 255.0f), int(g * 255.0f), int(b * 255.0f), int(a * 255.0f));
 }
 
 //////////////////////////////////////////////////////////////////////////

Code/Editor/Util/FileUtil.cpp

@@ -1221,15 +1221,14 @@ bool   CFileUtil::CreatePath(const QString& strPath)
     if (!strDriveLetter.isEmpty())
     {
         strCurrentDirectoryPath = strDriveLetter;
-        strCurrentDirectoryPath += "\\";
+        strCurrentDirectoryPath += AZ_CORRECT_FILESYSTEM_SEPARATOR_STRING;
     }
 
-
     nTotalPathQueueElements = cstrDirectoryQueue.size();
     for (nCurrentPathQueue = 0; nCurrentPathQueue < nTotalPathQueueElements; ++nCurrentPathQueue)
     {
         strCurrentDirectoryPath += cstrDirectoryQueue[static_cast<int>(nCurrentPathQueue)];
-        strCurrentDirectoryPath += "\\";
+        strCurrentDirectoryPath += AZ_CORRECT_FILESYSTEM_SEPARATOR_STRING;
         // The value which will go out of this loop is the result of the attempt to create the
         // last directory, only.
 
@@ -2158,7 +2157,6 @@ uint32 CFileUtil::GetAttributes(const char* filename, bool bUseSourceControl /*=
         return SCC_FILE_ATTRIBUTE_READONLY | SCC_FILE_ATTRIBUTE_INPAK;
     }
 
-    
     const char* adjustedFile = file.GetAdjustedFilename();
     if (!AZ::IO::SystemFile::Exists(adjustedFile))
     {

Code/Editor/Util/GuidUtil.h

@@ -48,7 +48,7 @@ inline bool GuidUtil::IsEmpty(REFGUID guid)
 inline const char* GuidUtil::ToString(REFGUID guid)
 {
     static char guidString[64];
-    sprintf_s(guidString, "{%.8X-%.4X-%.4X-%.2X%.2X-%.2X%.2X%.2X%.2X%.2X%.2X}", guid.Data1, guid.Data2, guid.Data3, guid.Data4[0], guid.Data4[1],
+    sprintf_s(guidString, "{%.8" GUID_FORMAT_DATA1 "-%.4X-%.4X-%.2X%.2X-%.2X%.2X%.2X%.2X%.2X%.2X}", guid.Data1, guid.Data2, guid.Data3, guid.Data4[0], guid.Data4[1],
         guid.Data4[2], guid.Data4[3], guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
     return guidString;
 }
@@ -62,7 +62,7 @@ inline GUID GuidUtil::FromString(const char* guidString)
     guid.Data1 = 0;
     guid.Data2 = 0;
     guid.Data3 = 0;
-    azsscanf(guidString, "{%8" SCNx32 "-%4hX-%4hX-%2X%2X-%2X%2X%2X%2X%2X%2X}",
+    azsscanf(guidString, "{%8" GUID_FORMAT_DATA1 "-%4hX-%4hX-%2X%2X-%2X%2X%2X%2X%2X%2X}",
         &guid.Data1, &guid.Data2, &guid.Data3, &d[0], &d[1], &d[2], &d[3], &d[4], &d[5], &d[6], &d[7]);
     guid.Data4[0] = static_cast<unsigned char>(d[0]);
     guid.Data4[1] = static_cast<unsigned char>(d[1]);

Code/Editor/Util/Image.h

@@ -178,7 +178,6 @@ public:
     //////////////////////////////////////////////////////////////////////////
     void GetSubImage(int x1, int y1, int width, int height, TImage<T>& img) const
     {
-        int size = width * height;
         img.Allocate(width, height);
         for (int y = 0; y < height; y++)
         {

Code/Editor/Util/ImageASC.cpp

@@ -99,7 +99,7 @@ bool CImageASC::Load(const QString& fileName, CFloatImage& image)
 
     // Break all of the values in the file apart into tokens.
 
-    char* nextToken = nullptr;
+    [[maybe_unused]] char* nextToken = nullptr;
     token = azstrtok(str, 0, seps, &nextToken);
 
     // ncols = grid width

Code/Editor/Util/ImageGif.cpp

@@ -76,8 +76,6 @@ static int  numused;
 const char* id87 = "GIF87a";
 const char* id89 = "GIF89a";
 
-static int   log2 (int);
-
 /* Fetch the next code from the raster data stream.  The codes can be
  * any length from 3 to 12 bits, packed into 8-bit bytes, so we have to
  * maintain our location in the Raster array as a BIT Offset.  We compute