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>
2021-09-13 17:57:42 -07:00
parent b2963f2bc1
commit db63dcbcd9
26 changed files with 633 additions and 124 deletions
@@ -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
@@ -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
@@ -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
@@ -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