Refresh rate driven rendering tick logic (#3375)

* Implement sync interval and refresh rate API for RenderViewportWidget

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Measure actual frame timings in the viewport info overlay.

Takes the median of the sum of (frame end - frame begin) to provide more a more representative view of when frames begin and end.

Note: Until VSync is internally supported by the event loop, this will produce nearly identical frame timings as the frame will spend as much time as needed synchronously waiting on a vblank.

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Make frame timing per-pipeline, wire up refresh rate info to ViewportContext

Signed-off-by: nvsickle <nvsickle@amazon.com>

* POC: Frame limit pipeline rendering

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Switch Editor tick to every 0ms to allow better tick accumulation behavior

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Move RPISystemComponent to the tick bus, remove tick accumulation logic

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Add `AddToRenderTickAtInterval` to RenderPipeline API

This allows a pipeline to update at a set cadence, instead of rendering every frame or being directly told when to tick.

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Make ViewportContext enforce a target framerate

-Adds GetFpsLimit/SetFpsLimit for actively limiting FPS
-Calculates a render tick interval based on vsync and the vps limit and updates the current pipeline

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Add r_fps_limit and ed_inactive_viewport_fps_limit cvars

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Quick null check from a crash I bumped into

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Fix off-by-one on FPS calculation (shouldn't include the not-yet-rendered frame)

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Clarify frame time begin initialization

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Fix TrackView export.

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Address some reviewer feedback, revert RPISystem API change, fix CPU profiler.

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Add g_simulation_tick_rate

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Address review feedback, make frame limit updates event driven

Signed-off-by: nvsickle <nvsickle@amazon.com>

* Remove timestamp update from ComponentApplication::Tick

Signed-off-by: nvsickle <nvsickle@amazon.com>

Code/Editor/Core/QtEditorApplication.cpp

@@ -44,7 +44,7 @@ enum
 {
     // in milliseconds
     GameModeIdleFrequency = 0,
-    EditorModeIdleFrequency = 1,
+    EditorModeIdleFrequency = 0,
     InactiveModeFrequency = 10,
     UninitializedFrequency = 9999,
 };

Code/Editor/TrackView/SequenceBatchRenderDialog.cpp

@@ -36,6 +36,9 @@
 #include "CryEdit.h"
 #include "Viewport.h"
 
+// Atom Renderer
+#include <Atom/RPI.Public/RPISystemInterface.h>
+
 AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
 #include <TrackView/ui_SequenceBatchRenderDialog.h>
 AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
@@ -1234,6 +1237,13 @@ void CSequenceBatchRenderDialog::OnKickIdleTimout()
         {
             componentApplication->TickSystem();
         }
+
+        // Directly tick the renderer, as it's no longer part of the system tick
+        if (auto rpiSystem = AZ::RPI::RPISystemInterface::Get())
+        {
+            rpiSystem->SimulationTick();
+            rpiSystem->RenderTick();
+        }
     }
 }
 

Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp

@@ -74,6 +74,8 @@
 #include <AzCore/Module/Environment.h>
 #include <AzCore/std/string/conversions.h>
 
+AZ_CVAR(float, g_simulation_tick_rate, 0, nullptr, AZ::ConsoleFunctorFlags::Null, "The rate at which the game simulation tick loop runs, or 0 for as fast as possible");
+
 static void PrintEntityName(const AZ::ConsoleCommandContainer& arguments)
 {
     if (arguments.empty())
@@ -1392,6 +1394,23 @@ namespace AZ
                 AZ_PROFILE_SCOPE(AzCore, "ComponentApplication::Tick:OnTick");
                 EBUS_EVENT(TickBus, OnTick, m_deltaTime, ScriptTimePoint(now));
             }
+
+            // If tick rate limiting is on, ensure (1 / g_simulation_tick_rate) ms has elapsed since the last frame,
+            // sleeping if there's still time remaining.
+            if (g_simulation_tick_rate > 0.f)
+            {
+                now = AZStd::chrono::system_clock::now();
+
+                // Work in microsecond durations here as that's the native measurement time for time_point
+                constexpr float microsecondsPerSecond = 1000.f * 1000.f;
+                const AZStd::chrono::microseconds timeBudgetPerTick(static_cast<int>(microsecondsPerSecond / g_simulation_tick_rate));
+                AZStd::chrono::microseconds timeUntilNextTick = m_currentTime + timeBudgetPerTick - now;
+
+                if (timeUntilNextTick.count() > 0)
+                {
+                    AZStd::this_thread::sleep_for(timeUntilNextTick);
+                }
+            }
         }
     }
 

Code/Framework/AzCore/AzCore/Component/TickBus.h

@@ -46,6 +46,8 @@ namespace AZ
 
         TICK_PRE_RENDER     = 750,     ///< Suggested tick handler position to update render-related data.
 
+        TICK_RENDER         = 800,     ///< Suggested tick handler position for rendering.
+
         TICK_DEFAULT        = 1000,    ///< Default tick handler position when the handler is constructed.
 
         TICK_UI             = 2000,    ///< Suggested tick handler position for UI components.

Gems/Atom/Bootstrap/Code/Include/Atom/Bootstrap/BootstrapNotificationBus.h

@@ -56,7 +56,8 @@ namespace AZ
 
                 //////////////////////////////////////////////////////////////////////////
 
-                virtual void OnBootstrapSceneReady(AZ::RPI::Scene* bootstrapScene) = 0;
+                virtual void OnBootstrapSceneReady([[maybe_unused]]AZ::RPI::Scene* bootstrapScene){}
+                virtual void OnFrameRateLimitChanged([[maybe_unused]]float fpsLimit){}
             };
             using NotificationBus = AZ::EBus<Notification>;
         } // namespace Bootstrap

Gems/Atom/Bootstrap/Code/Include/Atom/Bootstrap/BootstrapRequestBus.h

@@ -23,6 +23,8 @@ namespace AZ::Render::Bootstrap
 
         virtual AZ::RPI::ScenePtr GetOrCreateAtomSceneFromAzScene(AzFramework::Scene* scene) = 0;
         virtual bool EnsureDefaultRenderPipelineInstalledForScene(AZ::RPI::ScenePtr scene, AZ::RPI::ViewportContextPtr viewportContext) = 0;
+        virtual float GetFrameRateLimit() const = 0;
+        virtual void SetFrameRateLimit(float fpsLimit) = 0;
 
     protected:
         ~Request() = default;

Gems/Atom/Bootstrap/Code/Source/BootstrapSystemComponent.cpp

@@ -41,7 +41,14 @@
 #include <AzCore/Console/IConsole.h>
 #include <BootstrapSystemComponent_Traits_Platform.h>
 
+static void OnFrameRateLimitChanged(const float& fpsLimit)
+{
+    AZ::Render::Bootstrap::RequestBus::Broadcast(
+        &AZ::Render::Bootstrap::RequestBus::Events::SetFrameRateLimit, fpsLimit);
+}
+
 AZ_CVAR(AZ::CVarFixedString, r_default_pipeline_name, AZ_TRAIT_BOOTSTRAPSYSTEMCOMPONENT_PIPELINE_NAME, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "Default Render pipeline name");
+AZ_CVAR(float, r_fps_limit, 0, OnFrameRateLimitChanged, AZ::ConsoleFunctorFlags::Null, "The maximum framerate to render at, or 0 for unlimited");
 
 namespace AZ
 {
@@ -342,6 +349,22 @@ namespace AZ
                 return true;
             }
 
+            float BootstrapSystemComponent::GetFrameRateLimit() const
+            {
+                return r_fps_limit;
+            }
+
+            void BootstrapSystemComponent::SetFrameRateLimit(float fpsLimit)
+            {
+                r_fps_limit = fpsLimit;
+                if (m_viewportContext)
+                {
+                    m_viewportContext->SetFpsLimit(r_fps_limit);
+                }
+                Render::Bootstrap::NotificationBus::Broadcast(
+                    &Render::Bootstrap::NotificationBus::Events::OnFrameRateLimitChanged, fpsLimit);
+            }
+
             void BootstrapSystemComponent::CreateDefaultRenderPipeline()
             {
                 EnsureDefaultRenderPipelineInstalledForScene(m_defaultScene, m_viewportContext);
@@ -381,23 +404,11 @@ namespace AZ
             }
 
             void BootstrapSystemComponent::OnTick([[maybe_unused]] float deltaTime, [[maybe_unused]] ScriptTimePoint time)
-            {
-                // Temp: When running in the launcher without the legacy renderer
-                // we need to call RenderTick on the viewport context each frame.
-                if (m_viewportContext)
-                {
-                    AZ::ApplicationTypeQuery appType;
-                    ComponentApplicationBus::Broadcast(&AZ::ComponentApplicationBus::Events::QueryApplicationType, appType);
-                    if (appType.IsGame())
-                    {
-                        m_viewportContext->RenderTick();
-                    }
-                }
-            }
+            {            }
 
             int BootstrapSystemComponent::GetTickOrder()
             {
-                return TICK_LAST;
+                return TICK_PRE_RENDER;
             }
 
             void BootstrapSystemComponent::OnWindowClosed()

Gems/Atom/Bootstrap/Code/Source/BootstrapSystemComponent.h

@@ -69,6 +69,8 @@ namespace AZ
                 // Render::Bootstrap::RequestBus::Handler overrides ...
                 AZ::RPI::ScenePtr GetOrCreateAtomSceneFromAzScene(AzFramework::Scene* scene) override;
                 bool EnsureDefaultRenderPipelineInstalledForScene(AZ::RPI::ScenePtr scene, AZ::RPI::ViewportContextPtr viewportContext) override;
+                float GetFrameRateLimit() const override;
+                void SetFrameRateLimit(float fpsLimit) override;
 
             protected:
                 // Component overrides ...

Gems/Atom/RHI/Code/Source/RHI/CpuProfilerImpl.cpp

@@ -144,7 +144,7 @@ namespace AZ
             // Try to lock here, the shutdownMutex will only be contested when the CpuProfiler is shutting down.
             if (m_shutdownMutex.try_lock_shared())
             {
-                if (m_enabled)
+                if (m_enabled && ms_threadLocalStorage != nullptr)
                 {
                     ms_threadLocalStorage->RegionStackPopBack();
                 }

Gems/Atom/RPI/Code/Include/Atom/RPI.Public/RenderPipeline.h

@@ -161,19 +161,25 @@ namespace AZ
 
             //! Add this RenderPipeline to RPI system's RenderTick and it will be rendered whenever
             //! the RPI system's RenderTick is called.
-            //! The RenderPipeline is rendered per RenderTick by default unless AddToRenderTickOnce() was called.
+            //! The RenderPipeline is rendered per RenderTick by default.
             void AddToRenderTick();
 
+            //! Add this RenderPipeline to RPI system's RenderTick and it will be rendered every RenderTick
+            //! after the specified interval has elapsed since the last rendered frame.
+            //! @param renderInterval The desired time between rendered frames, in seconds.
+            void AddToRenderTickAtInterval(AZStd::chrono::duration<float> renderInterval);
+
             //! Disable render for this RenderPipeline
             void RemoveFromRenderTick();
 
             ~RenderPipeline();
-                        
+
             enum class RenderMode : uint8_t
             {
-                RenderEveryTick, // Render at each RPI system render tick
-                RenderOnce, // Render once in next RPI system render tick
-                NoRender // Render disabled.
+                RenderEveryTick, //!< Render at each RPI system render tick.
+                RenderAtTargetRate, //!< Render on RPI system render tick after a target refresh rate interval has passed.
+                RenderOnce, //!< Render once in next RPI system render tick.
+                NoRender //!< Render disabled.
             };
 
             //! Get current render mode
@@ -185,6 +191,12 @@ namespace AZ
             //! Get draw filter mask
             RHI::DrawFilterMask GetDrawFilterMask() const;
 
+            using FrameNotificationEvent = AZ::Event<>;
+            //! Notifies a listener when a frame is about to be prepared for render, before SRGs are bound.
+            void ConnectPrepareFrameHandler(FrameNotificationEvent::Handler& handler);
+            //! Notifies a listener when the rendering of a frame has finished
+            void ConnectEndFrameHandler(FrameNotificationEvent::Handler& handler);
+
         private:
             RenderPipeline() = default;
 
@@ -202,8 +214,11 @@ namespace AZ
             void OnAddedToScene(Scene* scene);
             void OnRemovedFromScene(Scene* scene);
 
+            // Called before this pipeline is about to be rendered and before SRGs are bound.
+            void OnPrepareFrame();
+
             // Called when this pipeline is about to be rendered
-            void OnStartFrame(const TickTimeInfo& tick);
+            void OnStartFrame();
 
             // Called when the rendering of current frame is finished.
             void OnFrameEnd();
@@ -228,8 +243,14 @@ namespace AZ
             
             PipelineViewMap m_pipelineViewsByTag;
             
-            /// The system time when the last time this pipeline render was started
-            float m_lastRenderStartTime = 0;
+            // The system time when the last time this pipeline render was started
+            AZStd::chrono::system_clock::time_point m_lastRenderStartTime;
+
+            // The current system time, as of OnPrepareFrame's execution.
+            AZStd::chrono::system_clock::time_point m_lastRenderRequestTime;
+
+            // The target time between renders when m_renderMode is RenderMode::RenderAtTargetRate
+            AZStd::chrono::duration<float> m_targetRefreshRate;
             
             // RenderPipeline's name id, it will be used to identify the render pipeline when it's added to a Scene
             RenderPipelineId m_nameId;
@@ -259,7 +280,11 @@ namespace AZ
             RHI::DrawFilterTag m_drawFilterTag;
             // A mask to filter draw items submitted by passes of this render pipeline.
             // This mask is created from the value of m_drawFilterTag.
-            RHI::DrawFilterMask m_drawFilterMask = 0; 
+            RHI::DrawFilterMask m_drawFilterMask = 0;
+
+            // Events for notification on render state
+            FrameNotificationEvent m_prepareFrameEvent;
+            FrameNotificationEvent m_endFrameEvent;
         };
 
     } // namespace RPI

Gems/Atom/RPI/Code/Include/Atom/RPI.Public/SceneBus.h

@@ -67,6 +67,9 @@ namespace AZ
 
             //! Notifies when the PrepareRender phase is ending
             virtual void OnEndPrepareRender() {}
+
+            //! Notifies when the render tick for a given frame has finished.
+            virtual void OnFrameEnd() {}
         };
 
         using SceneNotificationBus = AZ::EBus<SceneNotification>;

Gems/Atom/RPI/Code/Include/Atom/RPI.Public/ViewportContext.h

@@ -51,9 +51,21 @@ namespace AZ
             //! Sets the root scene associated with this viewport.
             //! This does not provide a default render pipeline, one must be provided to enable rendering.
             void SetRenderScene(ScenePtr scene);
-            //! Runs one simulation and render tick and renders a frame to this viewport's window.
-            //! @note This is likely to be replaced by a tick management system in the RPI.
-            void RenderTick();
+
+            //! Gets the maximum frame rate this viewport context's pipeline can render at, 0 for unlimited.
+            //! The target framerate for the pipeline will be determined by this frame limit and the
+            //! vsync settings for the current window.
+            float GetFpsLimit() const;
+
+            //! Sets the maximum frame rate this viewport context's pipeline can render at, 0 for unlimited.
+            //! The target framerate for the pipeline will be determined by this frame limit and the
+            //! vsync settings for the current window.
+            void SetFpsLimit(float fpsLimit);
+
+            //! Gets the target frame rate for this viewport context.
+            //! This returns the lowest of either the current VSync refresh rate
+            //! or 0 for an unlimited frame rate (if there's no FPS limit and vsync is off).
+            float GetTargetFrameRate() const;
 
             //! Gets the current name of this ViewportContext.
             //! This name is used to tie this ViewportContext to its View stack, and ViewportContexts may be
@@ -74,19 +86,28 @@ namespace AZ
             //! \see AzFramework::WindowRequests::GetDpiScaleFactor
             float GetDpiScalingFactor() const;
 
+            //! Gets the current vsync interval, as a divisor of the current refresh rate.
+            //! A value of 0 indicates that vsync is disabled.
+            uint32_t GetVsyncInterval() const;
+
+            //! Gets the current display refresh rate, in frames per second.
+            uint32_t GetRefreshRate() const;
+
             // SceneNotificationBus interface overrides...
             //! Ensures our default view remains set when our scene's render pipelines are modified.
             void OnRenderPipelineAdded(RenderPipelinePtr pipeline) override;
             //! Ensures our default view remains set when our scene's render pipelines are modified.
             void OnRenderPipelineRemoved(RenderPipeline* pipeline) override;
-            //! OnBeginPrepareRender is forwarded to our RenderTick notification to allow subscribers to do rendering.
-            void OnBeginPrepareRender() override;
 
             // WindowNotificationBus interface overrides...
             //! Used to fire a notification when our window resizes.
             void OnWindowResized(uint32_t width, uint32_t height) override;
             //! Used to fire a notification when our window DPI changes.
             void OnDpiScaleFactorChanged(float dpiScaleFactor) override;
+            //! Used to fire a notification when our vsync interval changes.
+            void OnVsyncIntervalChanged(uint32_t interval) override;
+            //! Used to fire a notification when our refresh rate changes.
+            void OnRefreshRateChanged(uint32_t refreshRate) override;
 
             using SizeChangedEvent = AZ::Event<AzFramework::WindowSize>;
             //! Notifies consumers when the viewport size has changed.
@@ -98,6 +119,12 @@ namespace AZ
             //! Alternatively, connect to ViewportContextNotificationsBus and listen to ViewportContextNotifications::OnViewportDpiScalingChanged.
             void ConnectDpiScalingFactorChangedHandler(ScalarChangedEvent::Handler& handler);
 
+            using UintChangedEvent = AZ::Event<uint32_t>;
+            //! Notifies consumers when the vsync interval has changed.
+            void ConnectVsyncIntervalChangedHandler(UintChangedEvent::Handler& handler);
+            //! Notifies consumers when the refresh rate has changed.
+            void ConnectRefreshRateChangedHandler(UintChangedEvent::Handler& handler);
+
             using MatrixChangedEvent = AZ::Event<const AZ::Matrix4x4&>;
             //! Notifies consumers when the view matrix has changed.
             void ConnectViewMatrixChangedHandler(MatrixChangedEvent::Handler& handler);
@@ -139,15 +166,24 @@ namespace AZ
             void SetDefaultView(ViewPtr view);
             // Ensures our render pipeline's default camera matches ours.
             void UpdatePipelineView();
+            // Ensures our render pipeline refresh rate matches our refresh rate.
+            void UpdatePipelineRefreshRate();
+            // Resets the current pipeline reference and ensures pipeline events are disconnected.
+            void ResetCurrentPipeline();
 
             ScenePtr m_rootScene;
             WindowContextSharedPtr m_windowContext;
             ViewPtr m_defaultView;
             AzFramework::WindowSize m_viewportSize;
             float m_viewportDpiScaleFactor = 1.0f;
+            uint32_t m_vsyncInterval = 1;
+            uint32_t m_refreshRate = 60;
+            float m_fpsLimit = 0.f;
 
             SizeChangedEvent m_sizeChangedEvent;
             ScalarChangedEvent m_dpiScalingFactorChangedEvent;
+            UintChangedEvent m_vsyncIntervalChangedEvent;
+            UintChangedEvent m_refreshRateChangedEvent;
             MatrixChangedEvent m_viewMatrixChangedEvent;
             MatrixChangedEvent::Handler m_onViewMatrixChangedHandler;
             MatrixChangedEvent m_projectionMatrixChangedEvent;
@@ -157,6 +193,9 @@ namespace AZ
             ViewChangedEvent m_defaultViewChangedEvent;
             ViewportIdEvent m_aboutToBeDestroyedEvent;
 
+            AZ::Event<>::Handler m_prepareFrameHandler;
+            AZ::Event<>::Handler m_endFrameHandler;
+
             ViewportContextManager* m_manager;
             RenderPipelinePtr m_currentPipeline;
             Name m_name;

Gems/Atom/RPI/Code/Include/Atom/RPI.Public/ViewportContextBus.h

@@ -110,11 +110,13 @@ namespace AZ
             virtual void OnViewportSizeChanged(AzFramework::WindowSize size){AZ_UNUSED(size);}
             //! Called when the window DPI scaling changes for a given viewport context.
             virtual void OnViewportDpiScalingChanged(float dpiScale){AZ_UNUSED(dpiScale);}
-            //! Called when the active view for a given viewport context name changes.
+            //! Called when the active view changes for a given viewport context.
             virtual void OnViewportDefaultViewChanged(AZ::RPI::ViewPtr view){AZ_UNUSED(view);}
             //! Called when the viewport is to be rendered.
-            //! Add draws to this functions if they only need to be rendered to this viewport. 
-            virtual void OnRenderTick(){};
+            //! Add draws to this function if they only need to be rendered to this viewport. 
+            virtual void OnRenderTick(){}
+            //! Called when the viewport finishes rendering a frame.
+            virtual void OnFrameEnd(){}
 
         protected:
             ~ViewportContextNotifications() = default;

Gems/Atom/RPI/Code/Source/RPI.Private/RPISystemComponent.cpp

@@ -14,6 +14,9 @@
 #include <RPI.Private/RPISystemComponent.h>
 
 #include <Atom/RHI/Factory.h>
+#include <Atom/RPI.Public/ViewportContextBus.h>
+#include <Atom/RPI.Public/ViewportContext.h>
+#include <Atom/RPI.Public/RenderPipeline.h>
 
 #include <AzCore/Asset/AssetManager.h>
 #include <AzCore/IO/IOUtils.h>
@@ -93,20 +96,29 @@ namespace AZ
             }
 
             m_rpiSystem.Initialize(m_rpiDescriptor);
-            AZ::SystemTickBus::Handler::BusConnect();
+            AZ::TickBus::Handler::BusConnect();
         }
 
         void RPISystemComponent::Deactivate()
         {
-            AZ::SystemTickBus::Handler::BusDisconnect();
+            AZ::TickBus::Handler::BusDisconnect();
             m_rpiSystem.Shutdown();
         }
 
-        void RPISystemComponent::OnSystemTick()
+        void RPISystemComponent::OnTick([[maybe_unused]]float deltaTime, [[maybe_unused]]ScriptTimePoint time)
         {
+            if (deltaTime == 0.f)
+            {
+                return;
+            }
+
             m_rpiSystem.SimulationTick();
             m_rpiSystem.RenderTick();
         }
 
+        int RPISystemComponent::GetTickOrder()
+        {
+            return AZ::ComponentTickBus::TICK_RENDER;
+        }
     } // namespace RPI
 } // namespace AZ

Gems/Atom/RPI/Code/Source/RPI.Private/RPISystemComponent.h

@@ -32,7 +32,7 @@ namespace AZ
          */
         class RPISystemComponent final
             : public AZ::Component
-            , public AZ::SystemTickBus::Handler
+            , private AZ::TickBus::Handler
         {
         public:
             AZ_COMPONENT(RPISystemComponent, "{83E301F3-7A0C-4099-B530-9342B91B1BC0}");
@@ -50,8 +50,9 @@ namespace AZ
         private:
             RPISystemComponent(const RPISystemComponent&) = delete;
 
-            // SystemTickBus overrides...
-            void OnSystemTick() override;
+            // TickBus overrides...
+            void OnTick(float deltaTime, ScriptTimePoint time) override;
+            int GetTickOrder() override;
 
             RPISystem m_rpiSystem;
 

Gems/Atom/RPI/Code/Source/RPI.Public/Pass/Pass.cpp

@@ -93,8 +93,11 @@ namespace AZ
 
         void Pass::SetEnabled(bool enabled)
         {
-            m_flags.m_enabled = enabled;
-            OnHierarchyChange();
+            if (m_flags.m_enabled != enabled)
+            {
+                m_flags.m_enabled = enabled;
+                OnHierarchyChange();
+            }
         }
 
         bool Pass::IsEnabled() const

Gems/Atom/RPI/Code/Source/RPI.Public/RenderPipeline.cpp

@@ -301,6 +301,26 @@ namespace AZ
             m_drawFilterMask = 0;
         }
 
+        void RenderPipeline::OnPrepareFrame()
+        {
+            m_lastRenderRequestTime = AZStd::chrono::system_clock::now();
+
+            // If we're attempting to render at a target interval, check to see if we're within
+            // 1ms of that interval, enabling rendering only if we are.
+            if (m_renderMode == RenderMode::RenderAtTargetRate)
+            {
+                constexpr AZStd::chrono::duration<float> updateThresholdMs(0.001f);
+                const bool shouldRender =
+                    m_lastRenderRequestTime - m_lastRenderStartTime + updateThresholdMs >= m_targetRefreshRate;
+                m_rootPass->SetEnabled(shouldRender);
+            }
+
+            if (NeedsRender())
+            {
+                m_prepareFrameEvent.Signal();
+            }
+        }
+
         void RenderPipeline::OnPassModified()
         {
             if (m_needsPassRecreate)
@@ -375,11 +395,11 @@ namespace AZ
             m_scene->RemoveRenderPipeline(m_nameId);
         }
 
-        void RenderPipeline::OnStartFrame(const TickTimeInfo& tick)
+        void RenderPipeline::OnStartFrame()
         {
             AZ_PROFILE_FUNCTION(RPI);
 
-            m_lastRenderStartTime = tick.m_currentGameTime;
+            m_lastRenderStartTime = m_lastRenderRequestTime;
 
             OnPassModified();
 
@@ -407,6 +427,7 @@ namespace AZ
             {
                 RemoveFromRenderTick();
             }
+            m_endFrameEvent.Signal();
         }
 
         void RenderPipeline::CollectPersistentViews(AZStd::map<ViewPtr, RHI::DrawListMask>& outViewMasks) const
@@ -489,6 +510,13 @@ namespace AZ
             m_renderMode = RenderMode::RenderEveryTick;
         }
 
+        void RenderPipeline::AddToRenderTickAtInterval(AZStd::chrono::duration<float> renderInterval)
+        {
+            m_rootPass->SetEnabled(false);
+            m_renderMode = RenderMode::RenderAtTargetRate;
+            m_targetRefreshRate = renderInterval;
+        }
+
         void RenderPipeline::RemoveFromRenderTick()
         {
             m_renderMode = RenderMode::NoRender;
@@ -502,7 +530,7 @@ namespace AZ
         
         bool RenderPipeline::NeedsRender() const
         {
-            return m_renderMode != RenderMode::NoRender;
+            return m_rootPass->IsEnabled();
         }
 
         RHI::DrawFilterTag RenderPipeline::GetDrawFilterTag() const
@@ -515,6 +543,16 @@ namespace AZ
             return m_drawFilterMask;
         }
 
+        void RenderPipeline::ConnectPrepareFrameHandler(FrameNotificationEvent::Handler& handler)
+        {
+            handler.Connect(m_prepareFrameEvent);
+        }
+
+        void RenderPipeline::ConnectEndFrameHandler(FrameNotificationEvent::Handler& handler)
+        {
+            handler.Connect(m_endFrameEvent);
+        }
+
         void RenderPipeline::SetDrawFilterTag(RHI::DrawFilterTag tag)
         {
             m_drawFilterTag = tag;

Gems/Atom/RPI/Code/Source/RPI.Public/Scene.cpp

@@ -420,7 +420,7 @@ namespace AZ
             }
         }
 
-        void Scene::PrepareRender(const TickTimeInfo& tickInfo, RHI::JobPolicy jobPolicy)
+        void Scene::PrepareRender([[maybe_unused]]const TickTimeInfo& tickInfo, RHI::JobPolicy jobPolicy)
         {
             AZ_ATOM_PROFILE_FUNCTION("RPI", "Scene: PrepareRender");
 
@@ -432,20 +432,27 @@ namespace AZ
 
             SceneNotificationBus::Event(GetId(), &SceneNotification::OnBeginPrepareRender);
 
-            // Get active pipelines which need to be rendered and notify them frame started
+            // Get active pipelines which need to be rendered and notify them of an impending frame.
             AZStd::vector<RenderPipelinePtr> activePipelines;
             {
-                AZ_ATOM_PROFILE_TIME_GROUP_REGION("RPI", "Scene: OnStartFrame");
+                AZ_ATOM_PROFILE_TIME_GROUP_REGION("RPI", "Scene: OnPrepareFrame");
                 for (auto& pipeline : m_pipelines)
                 {
+                    pipeline->OnPrepareFrame();
                     if (pipeline->NeedsRender())
                     {
                         activePipelines.push_back(pipeline);
-                        pipeline->OnStartFrame(tickInfo);
                     }
                 }
             }
 
+            // Get active pipelines which need to be rendered and notify them frame started
+            for (const auto& pipeline : activePipelines)
+            {
+                AZ_ATOM_PROFILE_TIME_GROUP_REGION("RPI", "Scene: OnStartFrame");
+                pipeline->OnStartFrame();
+            }
+
             // Return if there is no active render pipeline
             if (activePipelines.empty())
             {
@@ -587,10 +594,12 @@ namespace AZ
         void Scene::OnFrameEnd()
         {
             AZ_ATOM_PROFILE_FUNCTION("RPI", "Scene: OnFrameEnd");
+            bool didRender = false;
             for (auto& pipeline : m_pipelines)
             {
                 if (pipeline->NeedsRender())
                 {
+                    didRender = true;
                     pipeline->OnFrameEnd();
                 }
             }
@@ -598,6 +607,10 @@ namespace AZ
             {
                 fp->OnRenderEnd();
             }
+            if (didRender)
+            {
+                SceneNotificationBus::Event(GetId(), &SceneNotification::OnFrameEnd);
+            }
         }
 
         void Scene::UpdateSrgs()

Gems/Atom/RPI/Code/Source/RPI.Public/View.cpp

@@ -241,7 +241,10 @@ namespace AZ
         {
             AZ_PROFILE_FUNCTION(RPI);
             m_drawListContext.FinalizeLists();
-            SortFinalizedDrawLists();
+            if (m_passesByDrawList)
+            {
+                SortFinalizedDrawLists();
+            }
         }
 
         void View::SortFinalizedDrawLists()

Gems/Atom/RPI/Code/Source/RPI.Public/ViewportContext.cpp

@@ -25,14 +25,13 @@ namespace AZ
             , m_viewportSize(1, 1)
         {
             m_windowContext->Initialize(device, nativeWindow);
-            AzFramework::WindowRequestBus::EventResult(
-                m_viewportSize,
-                nativeWindow,
-                &AzFramework::WindowRequestBus::Events::GetClientAreaSize);
-            AzFramework::WindowRequestBus::EventResult(
-                m_viewportDpiScaleFactor,
-                nativeWindow,
-                &AzFramework::WindowRequestBus::Events::GetDpiScaleFactor);
+            AzFramework::WindowRequestBus::Event(nativeWindow, [this](AzFramework::WindowRequestBus::Events* window)
+            {
+                m_viewportSize = window->GetClientAreaSize();
+                m_viewportDpiScaleFactor = window->GetDpiScaleFactor();
+                m_vsyncInterval = window->GetSyncInterval();
+                m_refreshRate = window->GetDisplayRefreshRate();
+            });
             AzFramework::WindowNotificationBus::Handler::BusConnect(nativeWindow);
             AzFramework::ViewportRequestBus::Handler::BusConnect(id);
 
@@ -46,6 +45,20 @@ namespace AZ
                 m_viewMatrixChangedEvent.Signal(matrix);
             });
 
+            m_prepareFrameHandler = RenderPipeline::FrameNotificationEvent::Handler(
+                [this]()
+                {
+                    ViewportContextNotificationBus::Event(GetName(), &ViewportContextNotificationBus::Events::OnRenderTick);
+                    ViewportContextIdNotificationBus::Event(GetId(), &ViewportContextIdNotificationBus::Events::OnRenderTick);
+                });
+
+            m_endFrameHandler = RenderPipeline::FrameNotificationEvent::Handler(
+                [this]()
+                {
+                    ViewportContextNotificationBus::Event(GetName(), &ViewportContextNotificationBus::Events::OnFrameEnd);
+                    ViewportContextIdNotificationBus::Event(GetId(), &ViewportContextIdNotificationBus::Events::OnFrameEnd);
+                });
+
             SetRenderScene(renderScene);
         }
 
@@ -111,26 +124,38 @@ namespace AZ
                 {
                     SceneNotificationBus::Handler::BusConnect(m_rootScene->GetId());
                 }
-                m_currentPipeline.reset();
+                ResetCurrentPipeline();
                 UpdatePipelineView();
+                UpdatePipelineRefreshRate();
             }
 
             m_sceneChangedEvent.Signal(scene);
         }
 
-        void ViewportContext::RenderTick()
+        float ViewportContext::GetFpsLimit() const
         {
-            // add the current pipeline to next render tick if it's not already added.
-            if (m_currentPipeline && m_currentPipeline->GetRenderMode() != RenderPipeline::RenderMode::RenderOnce)
-            {
-                m_currentPipeline->AddToRenderTickOnce();
-            }
+            return m_fpsLimit;
+        }
+
+        void ViewportContext::SetFpsLimit(float fpsLimit)
+        {
+            m_fpsLimit = fpsLimit;
+            UpdatePipelineRefreshRate();
         }
 
-        void ViewportContext::OnBeginPrepareRender()
+        float ViewportContext::GetTargetFrameRate() const
         {
-            ViewportContextNotificationBus::Event(GetName(), &ViewportContextNotificationBus::Events::OnRenderTick);
-            ViewportContextIdNotificationBus::Event(GetId(), &ViewportContextIdNotificationBus::Events::OnRenderTick);
+            float targetFrameRate = GetFpsLimit();
+            const AZ::u32 vsyncInterval = GetVsyncInterval();
+            if (vsyncInterval != 0)
+            {
+                const float vsyncFrameRate = static_cast<float>(GetRefreshRate()) / static_cast<float>(vsyncInterval);
+                if (targetFrameRate == 0.f || vsyncFrameRate < targetFrameRate)
+                {
+                    targetFrameRate = vsyncFrameRate;
+                }
+            }
+            return targetFrameRate;
         }
 
         AZ::Name ViewportContext::GetName() const
@@ -158,6 +183,16 @@ namespace AZ
             return m_viewportDpiScaleFactor;
         }
 
+        uint32_t ViewportContext::GetVsyncInterval() const
+        {
+            return m_vsyncInterval;
+        }
+
+        uint32_t ViewportContext::GetRefreshRate() const
+        {
+            return m_refreshRate;
+        }
+
         void ViewportContext::ConnectSizeChangedHandler(SizeChangedEvent::Handler& handler)
         {
             handler.Connect(m_sizeChangedEvent);
@@ -168,6 +203,16 @@ namespace AZ
             handler.Connect(m_dpiScalingFactorChangedEvent);
         }
 
+        void ViewportContext::ConnectVsyncIntervalChangedHandler(UintChangedEvent::Handler& handler)
+        {
+            handler.Connect(m_vsyncIntervalChangedEvent);
+        }
+
+        void ViewportContext::ConnectRefreshRateChangedHandler(UintChangedEvent::Handler& handler)
+        {
+            handler.Connect(m_refreshRateChangedEvent);
+        }
+
         void ViewportContext::ConnectViewMatrixChangedHandler(MatrixChangedEvent::Handler& handler)
         {
             handler.Connect(m_viewMatrixChangedEvent);
@@ -263,12 +308,43 @@ namespace AZ
                 m_currentPipelineChangedEvent.Signal(m_currentPipeline);
             }
 
-            if (auto pipeline = GetCurrentPipeline())
+            if (m_currentPipeline)
             {
-                pipeline->SetDefaultView(m_defaultView);
+                if (!m_prepareFrameHandler.IsConnected())
+                {
+                    m_currentPipeline->ConnectPrepareFrameHandler(m_prepareFrameHandler);
+                    m_currentPipeline->ConnectEndFrameHandler(m_endFrameHandler);
+                }
+                m_currentPipeline->SetDefaultView(m_defaultView);
+            }
+        }
+
+        void ViewportContext::UpdatePipelineRefreshRate()
+        {
+            if (!m_currentPipeline)
+            {
+                return;
+            }
+
+            const float refreshRate = GetTargetFrameRate();
+            // If we have a truly unlimited framerate, just render every tick
+            if (refreshRate == 0.f)
+            {
+                m_currentPipeline->AddToRenderTick();
+            }
+            else
+            {
+                m_currentPipeline->AddToRenderTickAtInterval(AZStd::chrono::duration<float>(1.f / refreshRate));
             }
         }
 
+        void ViewportContext::ResetCurrentPipeline()
+        {
+            m_prepareFrameHandler.Disconnect();
+            m_endFrameHandler.Disconnect();
+            m_currentPipeline.reset();
+        }
+
         RenderPipelinePtr ViewportContext::GetCurrentPipeline()
         {
             return m_currentPipeline;
@@ -281,8 +357,9 @@ namespace AZ
             // in the event prioritization is added later
             if (pipeline->GetWindowHandle() == m_windowContext->GetWindowHandle())
             {
-                m_currentPipeline.reset();
+                ResetCurrentPipeline();
                 UpdatePipelineView();
+                UpdatePipelineRefreshRate();
             }
         }
 
@@ -290,8 +367,9 @@ namespace AZ
         {
             if (m_currentPipeline.get() == pipeline)
             {
-                m_currentPipeline.reset();
+                ResetCurrentPipeline();
                 UpdatePipelineView();
+                UpdatePipelineRefreshRate();
             }
         }
 
@@ -305,10 +383,30 @@ namespace AZ
             }
         }
 
+        void ViewportContext::OnRefreshRateChanged(uint32_t refreshRate)
+        {
+            if (m_refreshRate != refreshRate)
+            {
+                m_refreshRate = refreshRate;
+                m_refreshRateChangedEvent.Signal(m_refreshRate);
+                UpdatePipelineRefreshRate();
+            }
+        }
+
         void ViewportContext::OnDpiScaleFactorChanged(float dpiScaleFactor)
         {
             m_viewportDpiScaleFactor = dpiScaleFactor;
             m_dpiScalingFactorChangedEvent.Signal(dpiScaleFactor);
         }
+
+        void ViewportContext::OnVsyncIntervalChanged(uint32_t interval)
+        {
+            if (m_vsyncInterval != interval)
+            {
+                m_vsyncInterval = interval;
+                m_vsyncIntervalChangedEvent.Signal(m_vsyncInterval);
+                UpdatePipelineRefreshRate();
+            }
+        }
     } // namespace RPI
 } // namespace AZ

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

@@ -10,6 +10,7 @@
 
 #include <QWidget>
 #include <QElapsedTimer>
+#include <QPointer>
 #include <Atom/RPI.Public/Base.h>
 #include <AzToolsFramework/Viewport/ViewportMessages.h>
 #include <AzToolsFramework/Input/QtEventToAzInputManager.h>
@@ -21,6 +22,8 @@
 #include <AzFramework/Windowing/WindowBus.h>
 #include <AzCore/Component/TickBus.h>
 #include <Atom/RPI.Public/AuxGeom/AuxGeomFeatureProcessorInterface.h>
+#include <Atom/Bootstrap/BootstrapNotificationBus.h>
+#include <AtomToolsFramework/Viewport/RenderViewportWidgetNotificationBus.h>
 
 namespace AtomToolsFramework
 {
@@ -35,6 +38,8 @@ namespace AtomToolsFramework
         , public AzFramework::WindowRequestBus::Handler
         , protected AzFramework::InputChannelEventListener
         , protected AZ::TickBus::Handler
+        , protected AZ::Render::Bootstrap::NotificationBus::Handler
+        , protected AtomToolsFramework::RenderViewportWidgetNotificationBus::Handler
     {
     public:
         //! Creates a RenderViewportWidget.
@@ -121,6 +126,7 @@ namespace AtomToolsFramework
 
         // AZ::TickBus::Handler ...
         void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
+        int GetTickOrder() override;
 
         // QWidget ...
         void resizeEvent(QResizeEvent *event) override;
@@ -128,9 +134,21 @@ namespace AtomToolsFramework
         void enterEvent(QEvent* event) override;
         void leaveEvent(QEvent* event) override;
         void mouseMoveEvent(QMouseEvent* event) override;
+        void focusInEvent(QFocusEvent* event) override;
+
+        // AZ::Render::Bootstrap::NotificationBus::Handler ...
+        void OnFrameRateLimitChanged(float fpsLimit) override;
+
+        // AtomToolsFramework::RenderViewportWidgetNotificationBus::Handler ...
+        void OnInactiveViewportFrameRateChanged(float fpsLimit) override;
 
     private:
+        AzFramework::NativeWindowHandle GetNativeWindowHandle() const;
+        void UpdateFrameRate();
+
+        void SetScreen(QScreen* screen);
         void SendWindowResizeEvent();
+        void NotifyUpdateRefreshRate();
 
         // The underlying ViewportContext, our entry-point to the Atom RPI.
         AZ::RPI::ViewportContextPtr m_viewportContext;
@@ -153,5 +171,11 @@ namespace AtomToolsFramework
         AZ::ScriptTimePoint m_time;
         // Maps our internal Qt events into AzFramework InputChannels for our ViewportControllerList.
         AzToolsFramework::QtEventToAzInputMapper* m_inputChannelMapper = nullptr;
+        // Stores our current screen, used for tracking the current refresh rate.
+        QScreen* m_screen = nullptr;
+        // Stores the last RenderViewportWidget that has received user focus.
+        // This is used for optional framerate throtting for "inactive" viewports via the
+        // ed_inactive_viewport_fps_limit CVAR.
+        AZ::EnvironmentVariable<RenderViewportWidget*> m_lastFocusedViewport;
     };
 } //namespace AtomToolsFramework

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

@@ -0,0 +1,35 @@
+/*
+ * 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>
+
+namespace AtomToolsFramework
+{
+    //! Provides an interface for providing notifications specific to RenderViewportWidget.
+    //! @note Most behaviors in RenderViewportWidget are handled by its underyling
+    //! ViewportContext, this bus is specifically for functionality exclusive to the
+    //! Qt layer provided by RenderViewportWidget.
+    class RenderViewportWidgetNotifications : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+
+        //! Triggered when the idle frame rate limit for inactive viewports changed.
+        //! Controlled by the ed_inactive_viewport_fps_limit CVAR.
+        //! Active viewports are controlled by the r_fps_limit CVAR.
+        virtual void OnInactiveViewportFrameRateChanged([[maybe_unused]]float fpsLimit){}
+
+    protected:
+        ~RenderViewportWidgetNotifications() = default;
+    };
+
+    using RenderViewportWidgetNotificationBus = AZ::EBus<RenderViewportWidgetNotifications>;
+} // namespace AtomToolsFramework

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

@@ -6,23 +6,42 @@
  *
  */
 
-#include <AtomToolsFramework/Viewport/RenderViewportWidget.h>
+#include <Atom/Bootstrap/BootstrapRequestBus.h>
+#include <Atom/RHI/RHISystemInterface.h>
+#include <Atom/RPI.Public/View.h>
 #include <Atom/RPI.Public/ViewportContext.h>
 #include <Atom/RPI.Public/ViewportContextBus.h>
-#include <Atom/RPI.Public/View.h>
+#include <AtomToolsFramework/Viewport/RenderViewportWidget.h>
+#include <AzCore/Console/Console.h>
+#include <AzCore/Math/MathUtils.h>
 #include <AzFramework/Input/Devices/Mouse/InputDeviceMouse.h>
 #include <AzFramework/Viewport/ViewportControllerList.h>
 #include <AzFramework/Viewport/ViewportScreen.h>
 #include <AzToolsFramework/Viewport/ViewportTypes.h>
-#include <AzCore/Math/MathUtils.h>
-#include <Atom/RHI/RHISystemInterface.h>
-#include <Atom/Bootstrap/BootstrapRequestBus.h>
 
 #include <QApplication>
-#include <QCursor>
 #include <QBoxLayout>
-#include <QWindow>
+#include <QCursor>
 #include <QMouseEvent>
+#include <QScreen>
+#include <QTimer>
+#include <QWindow>
+
+static void OnInactiveViewportFrameRateChanged(const float& fpsLimit)
+{
+    AtomToolsFramework::RenderViewportWidgetNotificationBus::Broadcast(
+        &AtomToolsFramework::RenderViewportWidgetNotificationBus::Events::OnInactiveViewportFrameRateChanged, fpsLimit);
+}
+
+AZ_CVAR(
+    float,
+    ed_inactive_viewport_fps_limit,
+    0,
+    OnInactiveViewportFrameRateChanged,
+    AZ::ConsoleFunctorFlags::Null,
+    "The maximum framerate to render viewports that don't have focus at");
+
+static constexpr const char* LastFocusedViewportVariableName = "AtomToolsFramework::RenderViewportWidget::LastFocusedViewport";
 
 namespace AtomToolsFramework
 {
@@ -30,6 +49,12 @@ namespace AtomToolsFramework
         : QWidget(parent)
         , AzFramework::InputChannelEventListener(AzFramework::InputChannelEventListener::GetPriorityDefault())
     {
+        m_lastFocusedViewport = AZ::Environment::FindVariable<RenderViewportWidget*>(LastFocusedViewportVariableName);
+        if (!m_lastFocusedViewport)
+        {
+            m_lastFocusedViewport = AZ::Environment::CreateVariable<RenderViewportWidget*>(LastFocusedViewportVariableName, nullptr);
+        }
+
         if (shouldInitializeViewportContext)
         {
             InitializeViewportContext();
@@ -38,13 +63,24 @@ namespace AtomToolsFramework
         setUpdatesEnabled(false);
         setFocusPolicy(Qt::FocusPolicy::WheelFocus);
         setMouseTracking(true);
+
+        // Wait a frame for our window handle to be constructed, then wire up our screen change signals.
+        QTimer::singleShot(
+            0,
+            [this]()
+            {
+                QObject::connect(windowHandle(), &QWindow::screenChanged, this, &RenderViewportWidget::SetScreen);
+            });
+        SetScreen(screen());
     }
 
     bool RenderViewportWidget::InitializeViewportContext(AzFramework::ViewportId id)
     {
         if (m_viewportContext != nullptr)
         {
-            AZ_Assert(id == AzFramework::InvalidViewportId || m_viewportContext->GetId() == id, "Attempted to reinitialize RenderViewportWidget with a different ID");
+            AZ_Assert(
+                id == AzFramework::InvalidViewportId || m_viewportContext->GetId() == id,
+                "Attempted to reinitialize RenderViewportWidget with a different ID");
             return true;
         }
 
@@ -59,7 +95,7 @@ namespace AtomToolsFramework
         // Before we do anything else, we must create a ViewportContext which will give us a ViewportId if we didn't manually specify one.
         AZ::RPI::ViewportContextRequestsInterface::CreationParameters params;
         params.device = AZ::RHI::RHISystemInterface::Get()->GetDevice();
-        params.windowHandle = reinterpret_cast<AzFramework::NativeWindowHandle>(winId());
+        params.windowHandle = GetNativeWindowHandle();
         params.id = id;
         AzFramework::WindowRequestBus::Handler::BusConnect(params.windowHandle);
         m_viewportContext = viewportContextManager->CreateViewportContext(AZ::Name(), params);
@@ -80,29 +116,46 @@ namespace AtomToolsFramework
         AzFramework::InputChannelEventListener::Connect();
         AZ::TickBus::Handler::BusConnect();
         AzFramework::WindowRequestBus::Handler::BusConnect(params.windowHandle);
+        AZ::Render::Bootstrap::NotificationBus::Handler::BusConnect();
+        AtomToolsFramework::RenderViewportWidgetNotificationBus::Handler::BusConnect();
 
         m_inputChannelMapper = new AzToolsFramework::QtEventToAzInputMapper(this, id);
 
         // Forward input events to our controller list.
-        QObject::connect(m_inputChannelMapper, &AzToolsFramework::QtEventToAzInputMapper::InputChannelUpdated, this,
+        QObject::connect(
+            m_inputChannelMapper, &AzToolsFramework::QtEventToAzInputMapper::InputChannelUpdated, this,
             [this](const AzFramework::InputChannel* inputChannel, QEvent* event)
-        {
-            AzFramework::NativeWindowHandle windowId = reinterpret_cast<AzFramework::NativeWindowHandle>(winId());
-            if (m_controllerList->HandleInputChannelEvent(AzFramework::ViewportControllerInputEvent{GetId(), windowId, *inputChannel}))
             {
-                // If the controller handled the input event, mark the event as accepted so it doesn't continue to propagate.
-                if (event)
+                const AzFramework::NativeWindowHandle windowId = GetNativeWindowHandle();
+                if (m_controllerList->HandleInputChannelEvent(
+                        AzFramework::ViewportControllerInputEvent{ GetId(), windowId, *inputChannel }))
                 {
-                    event->setAccepted(true);
+                    // If the controller handled the input event, mark the event as accepted so it doesn't continue to propagate.
+                    if (event)
+                    {
+                        event->setAccepted(true);
+                    }
                 }
-            }
-        });
+            });
+
+        // Update our target frame rate. If we're the only viewport, become active.
+        if (m_lastFocusedViewport.Get() == nullptr)
+        {
+            m_lastFocusedViewport.Set(this);
+        }
+        UpdateFrameRate();
+
 
         return true;
     }
 
     RenderViewportWidget::~RenderViewportWidget()
     {
+        if (m_lastFocusedViewport.Get() == this)
+        {
+            m_lastFocusedViewport.Set(nullptr);
+        }
+
         AzFramework::WindowRequestBus::Handler::BusDisconnect();
         AZ::TickBus::Handler::BusDisconnect();
         AzFramework::InputChannelEventListener::Disconnect();
@@ -181,17 +234,22 @@ namespace AtomToolsFramework
 
         bool shouldConsumeEvent = true;
 
-        AzFramework::NativeWindowHandle windowId = reinterpret_cast<AzFramework::NativeWindowHandle>(winId());
-        const bool eventHandled = m_controllerList->HandleInputChannelEvent({GetId(), windowId, inputChannel});
+        const bool eventHandled = m_controllerList->HandleInputChannelEvent({ GetId(), GetNativeWindowHandle(), inputChannel });
 
-        // If our controllers handled the event and it's one we can safely consume (i.e. it's not an Ended event that other viewports might need), consume it.
+        // If our controllers handled the event and it's one we can safely consume (i.e. it's not an Ended event that other viewports might
+        // need), consume it.
         return eventHandled && shouldConsumeEvent;
     }
 
-    void RenderViewportWidget::OnTick([[maybe_unused]]float deltaTime, AZ::ScriptTimePoint time)
+    void RenderViewportWidget::OnTick([[maybe_unused]] float deltaTime, AZ::ScriptTimePoint time)
     {
         m_time = time;
-        m_controllerList->UpdateViewport({GetId(), AzFramework::FloatSeconds(deltaTime), m_time});
+        m_controllerList->UpdateViewport({ GetId(), AzFramework::FloatSeconds(deltaTime), m_time });
+    }
+
+    int RenderViewportWidget::GetTickOrder()
+    {
+        return AZ::ComponentTickBus::TICK_PRE_RENDER;
     }
 
     void RenderViewportWidget::resizeEvent([[maybe_unused]] QResizeEvent* event)
@@ -236,6 +294,75 @@ namespace AtomToolsFramework
         m_mousePosition = event->localPos();
     }
 
+    void RenderViewportWidget::focusInEvent([[maybe_unused]] QFocusEvent* event)
+    {
+        RenderViewportWidget* lastFocusedViewport = m_lastFocusedViewport.Get();
+        if (lastFocusedViewport == this)
+        {
+            return;
+        }
+
+        RenderViewportWidget* previousFocusWidget = lastFocusedViewport;
+        m_lastFocusedViewport.Set(this);
+
+        // Ensure this viewport and whatever viewport last had focus (if any) respect
+        // the active / inactive viewport frame rate settings.
+        UpdateFrameRate();
+        if (previousFocusWidget != nullptr)
+        {
+            previousFocusWidget->UpdateFrameRate();
+        }
+    }
+
+    void RenderViewportWidget::OnFrameRateLimitChanged([[maybe_unused]] float fpsLimit)
+    {
+        UpdateFrameRate();
+    }
+
+    void RenderViewportWidget::OnInactiveViewportFrameRateChanged([[maybe_unused]] float fpsLimit)
+    {
+        UpdateFrameRate();
+    }
+
+    AzFramework::NativeWindowHandle RenderViewportWidget::GetNativeWindowHandle() const
+    {
+        return reinterpret_cast<AzFramework::NativeWindowHandle>(winId());
+    }
+
+    void RenderViewportWidget::UpdateFrameRate()
+    {
+        if (ed_inactive_viewport_fps_limit > 0.f && m_lastFocusedViewport.Get() != this)
+        {
+            m_viewportContext->SetFpsLimit(ed_inactive_viewport_fps_limit);
+        }
+        else
+        {
+            float fpsLimit = 0.f;
+            AZ::Render::Bootstrap::RequestBus::BroadcastResult(fpsLimit, &AZ::Render::Bootstrap::RequestBus::Events::GetFrameRateLimit);
+            m_viewportContext->SetFpsLimit(fpsLimit);
+        }
+    }
+
+    void RenderViewportWidget::SetScreen(QScreen* screen)
+    {
+        if (m_screen != screen)
+        {
+            if (m_screen)
+            {
+                QObject::disconnect(m_screen, &QScreen::refreshRateChanged, this, &RenderViewportWidget::NotifyUpdateRefreshRate);
+            }
+
+            if (screen)
+            {
+                QObject::connect(m_screen, &QScreen::refreshRateChanged, this, &RenderViewportWidget::NotifyUpdateRefreshRate);
+            }
+
+            NotifyUpdateRefreshRate();
+
+            m_screen = screen;
+        }
+    }
+
     void RenderViewportWidget::SendWindowResizeEvent()
     {
         // Scale the size by the DPI of the platform to
@@ -243,11 +370,17 @@ namespace AtomToolsFramework
         const QSize uiWindowSize = size();
         const QSize windowSize = uiWindowSize * devicePixelRatioF();
 
-        const AzFramework::NativeWindowHandle windowId = reinterpret_cast<AzFramework::NativeWindowHandle>(winId());
-        AzFramework::WindowNotificationBus::Event(windowId, &AzFramework::WindowNotifications::OnWindowResized, windowSize.width(), windowSize.height());
+        AzFramework::WindowNotificationBus::Event(
+            GetNativeWindowHandle(), &AzFramework::WindowNotifications::OnWindowResized, windowSize.width(), windowSize.height());
         m_windowResizedEvent = false;
     }
 
+    void RenderViewportWidget::NotifyUpdateRefreshRate()
+    {
+        AzFramework::WindowNotificationBus::Event(
+            GetNativeWindowHandle(), &AzFramework::WindowNotificationBus::Events::OnRefreshRateChanged, GetDisplayRefreshRate());
+    }
+
     AZ::Name RenderViewportWidget::GetCurrentContextName() const
     {
         return m_viewportContext->GetName();
@@ -303,9 +436,7 @@ namespace AtomToolsFramework
 
         // Build camera state from Atom camera transforms
         AzFramework::CameraState cameraState = AzFramework::CreateCameraFromWorldFromViewMatrix(
-            currentView->GetViewToWorldMatrix(),
-            AZ::Vector2{aznumeric_cast<float>(width()), aznumeric_cast<float>(height())}
-        );
+            currentView->GetViewToWorldMatrix(), AZ::Vector2{ aznumeric_cast<float>(width()), aznumeric_cast<float>(height()) });
         AzFramework::SetCameraClippingVolumeFromPerspectiveFovMatrixRH(cameraState, currentView->GetViewToClipMatrix());
 
         // Convert from Z-up
@@ -317,8 +448,7 @@ namespace AtomToolsFramework
 
     AzFramework::ScreenPoint RenderViewportWidget::ViewportWorldToScreen(const AZ::Vector3& worldPosition)
     {
-        if (AZ::RPI::ViewPtr currentView = m_viewportContext->GetDefaultView();
-            currentView == nullptr)
+        if (AZ::RPI::ViewPtr currentView = m_viewportContext->GetDefaultView(); currentView == nullptr)
         {
             return AzFramework::ScreenPoint(0, 0);
         }
@@ -331,12 +461,10 @@ namespace AtomToolsFramework
         const auto& cameraProjection = m_viewportContext->GetCameraProjectionMatrix();
         const auto& cameraView = m_viewportContext->GetCameraViewMatrix();
 
-        const AZ::Vector4 normalizedScreenPosition {
-            screenPosition.m_x * 2.f / width() - 1.0f,
-            (height() - screenPosition.m_y) * 2.f / height() - 1.0f,
-            1.f - depth, // [GFX TODO] [ATOM-1501] Currently we always assume reverse depth
-            1.f
-        };
+        const AZ::Vector4 normalizedScreenPosition{ screenPosition.m_x * 2.f / width() - 1.0f,
+                                                    (height() - screenPosition.m_y) * 2.f / height() - 1.0f,
+                                                    1.f - depth, // [GFX TODO] [ATOM-1501] Currently we always assume reverse depth
+                                                    1.f };
 
         AZ::Matrix4x4 worldFromScreen = cameraProjection * cameraView;
         worldFromScreen.InvertFull();
@@ -365,7 +493,7 @@ namespace AtomToolsFramework
         AZ::Vector3 rayDirection = pos1.value() - pos0.value();
         rayDirection.Normalize();
 
-        return AzToolsFramework::ViewportInteraction::ProjectedViewportRay{rayOrigin, rayDirection};
+        return AzToolsFramework::ViewportInteraction::ProjectedViewportRay{ rayOrigin, rayDirection };
     }
 
     float RenderViewportWidget::DeviceScalingFactor()
@@ -395,12 +523,12 @@ namespace AtomToolsFramework
 
     AzFramework::WindowSize RenderViewportWidget::GetClientAreaSize() const
     {
-        return AzFramework::WindowSize{aznumeric_cast<uint32_t>(width()), aznumeric_cast<uint32_t>(height())};
+        return AzFramework::WindowSize{ aznumeric_cast<uint32_t>(width()), aznumeric_cast<uint32_t>(height()) };
     }
 
     void RenderViewportWidget::ResizeClientArea(AzFramework::WindowSize clientAreaSize)
     {
-        const QSize targetSize = QSize{aznumeric_cast<int>(clientAreaSize.m_width), aznumeric_cast<int>(clientAreaSize.m_height)};
+        const QSize targetSize = QSize{ aznumeric_cast<int>(clientAreaSize.m_width), aznumeric_cast<int>(clientAreaSize.m_height) };
         resize(targetSize);
     }
 
@@ -410,7 +538,7 @@ namespace AtomToolsFramework
         return false;
     }
 
-    void RenderViewportWidget::SetFullScreenState([[maybe_unused]]bool fullScreenState)
+    void RenderViewportWidget::SetFullScreenState([[maybe_unused]] bool fullScreenState)
     {
         // The RenderViewportWidget does not currently support full screen.
     }
@@ -433,11 +561,20 @@ namespace AtomToolsFramework
 
     uint32_t RenderViewportWidget::GetDisplayRefreshRate() const
     {
-        return 60;
+        return static_cast<uint32_t>(screen()->refreshRate());
     }
 
     uint32_t RenderViewportWidget::GetSyncInterval() const
     {
-        return 1;
+        uint32_t interval = 1;
+
+        // Get vsync_interval from AzFramework::NativeWindow, which owns it.
+        // NativeWindow also handles broadcasting OnVsyncIntervalChanged to all
+        // WindowNotificationBus listeners.
+        if (auto console = AZ::Interface<AZ::IConsole>::Get())
+        {
+            console->GetCvarValue<uint32_t>("vsync_interval", interval);
+        }
+        return interval;
     }
-} //namespace AtomToolsFramework
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/atomtoolsframework_files.cmake

@@ -28,6 +28,7 @@ set(FILES
     Include/AtomToolsFramework/Util/MaterialPropertyUtil.h
     Include/AtomToolsFramework/Util/Util.h
     Include/AtomToolsFramework/Viewport/RenderViewportWidget.h
+    Include/AtomToolsFramework/Viewport/RenderViewportWidgetNotificationBus.h
     Include/AtomToolsFramework/Viewport/ModularViewportCameraController.h
     Include/AtomToolsFramework/Viewport/ModularViewportCameraControllerRequestBus.h
     Include/AtomToolsFramework/Window/AtomToolsMainWindow.h

Gems/AtomLyIntegration/AtomViewportDisplayInfo/Code/Source/AtomViewportDisplayInfoSystemComponent.cpp

@@ -183,6 +183,15 @@ namespace AZ::Render
         DrawFramerate();
     }
 
+    void AtomViewportDisplayInfoSystemComponent::OnFrameEnd()
+    {
+        auto currentTime = AZStd::chrono::system_clock::now();
+        if (!m_fpsHistory.empty())
+        {
+            m_fpsHistory.back().m_endFrameTime = currentTime;
+        }
+    }
+
     AtomBridge::ViewportInfoDisplayState AtomViewportDisplayInfoSystemComponent::GetDisplayState() const
     {
         return aznumeric_cast<AtomBridge::ViewportInfoDisplayState>(r_displayInfo.operator int());
@@ -248,11 +257,11 @@ namespace AZ::Render
     void AtomViewportDisplayInfoSystemComponent::UpdateFramerate()
     {
         auto currentTime = AZStd::chrono::system_clock::now();
-        while (!m_fpsHistory.empty() && (currentTime - m_fpsHistory.front()) > m_fpsInterval)
+        while (!m_fpsHistory.empty() && (currentTime - m_fpsHistory.front().m_beginFrameTime) > m_fpsInterval)
         {
             m_fpsHistory.pop_front();
         }
-        m_fpsHistory.push_back(currentTime);
+        m_fpsHistory.push_back(FrameTimingInfo(currentTime));
     }
 
     void AtomViewportDisplayInfoSystemComponent::DrawFramerate()
@@ -261,25 +270,31 @@ namespace AZ::Render
         double minFPS = DBL_MAX;
         double maxFPS = 0;
         AZStd::chrono::duration<double> deltaTime;
+        AZStd::chrono::milliseconds totalFrameMS(0);
         for (const auto& time : m_fpsHistory)
         {
             if (lastTime.has_value())
             {
-                deltaTime = time - lastTime.value();
+                deltaTime = time.m_beginFrameTime - lastTime.value();
                 double fps = AZStd::chrono::seconds(1) / deltaTime;
                 minFPS = AZStd::min(minFPS, fps);
                 maxFPS = AZStd::max(maxFPS, fps);
             }
-            lastTime = time;
+            lastTime = time.m_beginFrameTime;
+
+            if (time.m_endFrameTime.has_value())
+            {
+                totalFrameMS += time.m_endFrameTime.value() - time.m_beginFrameTime;
+            }
         }
 
         double averageFPS = 0;
         double averageFrameMs = 0;
         if (m_fpsHistory.size() > 1)
         {
-            deltaTime = m_fpsHistory.back() - m_fpsHistory.front();
-            averageFPS = AZStd::chrono::seconds(m_fpsHistory.size()) / deltaTime;
-            averageFrameMs = 1000.0f/averageFPS;
+            deltaTime = m_fpsHistory.back().m_beginFrameTime - m_fpsHistory.front().m_beginFrameTime;
+            averageFPS = AZStd::chrono::seconds(m_fpsHistory.size() - 1) / deltaTime;
+            averageFrameMs = aznumeric_cast<double>(totalFrameMS.count()) / (m_fpsHistory.size() - 1);
         }
 
         const double frameIntervalSeconds = m_fpsInterval.count();
@@ -288,7 +303,7 @@ namespace AZ::Render
             AZStd::string::format(
                 "FPS %.1f [%.0f..%.0f], %.1fms/frame, avg over %.1fs",
                 averageFPS,
-                minFPS,
+                minFPS == DBL_MAX ? 0.0 : minFPS,
                 maxFPS,
                 averageFrameMs,
                 frameIntervalSeconds),

Gems/AtomLyIntegration/AtomViewportDisplayInfo/Code/Source/AtomViewportDisplayInfoSystemComponent.h

@@ -45,6 +45,7 @@ namespace AZ
 
             // AZ::RPI::ViewportContextNotificationBus::Handler overrides...
             void OnRenderTick() override;
+            void OnFrameEnd() override;
 
             // AZ::AtomBridge::AtomViewportInfoDisplayRequestBus::Handler overrides...
             AtomBridge::ViewportInfoDisplayState GetDisplayState() const override;
@@ -61,6 +62,8 @@ namespace AZ
             void DrawPassInfo();
             void DrawFramerate();
 
+            void UpdateScene(AZ::RPI::ScenePtr scene);
+
             static constexpr float BaseFontSize = 0.7f;
 
             AZStd::string m_rendererDescription;
@@ -68,7 +71,17 @@ namespace AZ
             AzFramework::FontDrawInterface* m_fontDrawInterface = nullptr;
             float m_lineSpacing;
             AZStd::chrono::duration<double> m_fpsInterval = AZStd::chrono::seconds(1);
-            AZStd::deque<AZStd::chrono::system_clock::time_point> m_fpsHistory;
+            struct FrameTimingInfo
+            {
+                AZStd::chrono::system_clock::time_point m_beginFrameTime;
+                AZStd::optional<AZStd::chrono::system_clock::time_point> m_endFrameTime;
+
+                explicit FrameTimingInfo(AZStd::chrono::system_clock::time_point beginFrameTime)
+                    : m_beginFrameTime(beginFrameTime)
+                {
+                }
+            };
+            AZStd::deque<FrameTimingInfo> m_fpsHistory;
             AZStd::optional<AZStd::chrono::system_clock::time_point> m_lastMemoryUpdate;
             bool m_updateRootPassQuery = true;
         };