Merge branch 'development' into cmake/warn_virtual

Signed-off-by: Esteban Papp <81431996+amznestebanpapp@users.noreply.github.com>
2021-09-09 11:50:40 -07:00
parent d836503814 9976ee2b8e
commit 9f6d4125b8
248 changed files with 9491 additions and 10706 deletions
@@ -18,6 +18,7 @@
 #include <AzCore/std/functional.h>
 #include <AzCore/std/parallel/thread.h>
 #include <AzCore/std/string/string.h>
+#include <AzCore/PlatformIncl.h>

 #include <AzFramework/CommandLine/CommandLine.h>

@@ -14,6 +14,7 @@
 #include <AzCore/Math/Vector2.h>
 #include <AzCore/Math/Vector3.h>
 #include <AzCore/Math/Vector4.h>
+#include <AzCore/Math/Matrix3x4.h>
 #include <AzCore/Math/Color.h>
 #include <AzCore/Math/Transform.h>
 #include <AzCore/Component/ComponentBus.h>
@@ -100,6 +101,8 @@ namespace AzFramework
        virtual AZ::u32 SetState(AZ::u32 state) { (void)state; return 0; }
        virtual void PushMatrix(const AZ::Transform& tm) { (void)tm; }
        virtual void PopMatrix() {}
+        virtual void PushPremultipliedMatrix(const AZ::Matrix3x4& matrix) { (void)matrix; }
+        virtual AZ::Matrix3x4 PopPremultipliedMatrix() { return AZ::Matrix3x4::CreateIdentity(); }

    protected:
        virtual ~DebugDisplayRequests() = default;
@@ -281,7 +281,7 @@ namespace AzFramework
        AZ_PROFILE_FUNCTION(AzCore);
            
        auto data = AZStd::get_if<FileRequest::ReadData>(&request->GetCommand());
-        AZ_Assert(data, "Request doing reading in the RemoteStorageDrive didn't contain read data.")
+        AZ_Assert(data, "Request doing reading in the RemoteStorageDrive didn't contain read data.");

        HandleType file = InvalidHandle;

@@ -83,7 +83,7 @@ namespace AzFramework::ProjectManager
        return ProjectPathCheckResult::ProjectManagerLaunchFailed;
    }

-    bool LaunchProjectManager(const AZStd::string& commandLineArgs)
+    bool LaunchProjectManager([[maybe_unused]]const AZStd::string& commandLineArgs)
    {
        bool launchSuccess = false;
 #if (AZ_TRAIT_AZFRAMEWORK_USE_PROJECT_MANAGER)
@@ -588,6 +588,12 @@ namespace AzFramework
                    // pass through the camera's position and look vector for use in the lookAt function
                    if (const auto lookAt = lookAtFn(targetCamera.Translation(), targetCamera.Rotation().GetBasisY()))
                    {
+                        // default to internal look at behavior if the look at point matches the camera translation
+                        if (targetCamera.m_lookAt.IsClose(*lookAt))
+                        {
+                            return false;
+                        }
+
                        auto transform = AZ::Transform::CreateLookAt(targetCamera.m_lookAt, *lookAt);
                        nextCamera.m_lookDist = -lookAt->GetDistance(targetCamera.m_lookAt);
                        UpdateCameraFromTransform(nextCamera, transform);
@@ -45,6 +45,7 @@ namespace AzFramework
    protected:
        ~BoundsRequests() = default;
    };
+
    using BoundsRequestBus = AZ::EBus<BoundsRequests>;

    //! Returns a union of all local Aabbs provided by components implementing the BoundsRequestBus.
@@ -57,6 +57,7 @@ namespace AzFramework

    uint32_t NativeWindowImpl_Android::GetDisplayRefreshRate() const
    {
+        // [GFX TODO][GHI - 2678]
        // Using 60 for now until proper support is added
        return 60;
    }
@@ -55,6 +55,29 @@ namespace AzFramework

    using LinuxXcbConnectionManagerBus = AZ::EBus<LinuxXcbConnectionManager, LinuxXcbConnectionManagerBusTraits>;
    using LinuxXcbConnectionManagerInterface = AZ::Interface<LinuxXcbConnectionManager>;
+    
+    class LinuxXcbEventHandler
+    {
+    public:
+        AZ_RTTI(LinuxXcbEventHandler, "{3F756E14-8D74-42FD-843C-4863307710DB}");
+
+        virtual ~LinuxXcbEventHandler() = default;
+
+        virtual void HandleXcbEvent(xcb_generic_event_t* event) = 0;
+    };
+
+    class LinuxXcbEventHandlerBusTraits
+        : public AZ::EBusTraits
+    {
+        public:
+            //////////////////////////////////////////////////////////////////////////
+            // EBusTraits overrides
+            static constexpr AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+            static constexpr AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+            //////////////////////////////////////////////////////////////////////////
+    };
+
+    using LinuxXcbEventHandlerBus = AZ::EBus<LinuxXcbEventHandler, LinuxXcbEventHandlerBusTraits>;

 #endif // PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
 } // namespace AzFramework
@@ -6,101 +6,28 @@
 *
 */

-#include <AzFramework/API/ApplicationAPI_Platform.h>
 #include <AzFramework/Application/Application.h>

+#include "Application_Linux_xcb.h"
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 namespace AzFramework
 {
-#if PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
-    class LinuxXcbConnectionManagerImpl
-        : public LinuxXcbConnectionManagerBus::Handler
-    {
-    public:
-        LinuxXcbConnectionManagerImpl()
-        {
-            m_xcbConnection = xcb_connect(nullptr, nullptr);
-            AZ_Error("ApplicationLinux", m_xcbConnection != nullptr, "Unable to connect to X11 Server.");
-            LinuxXcbConnectionManagerBus::Handler::BusConnect();
-        }
-
-        ~LinuxXcbConnectionManagerImpl() override
-        {
-            LinuxXcbConnectionManagerBus::Handler::BusDisconnect();
-            xcb_disconnect(m_xcbConnection);   
-        }
-        xcb_connection_t* GetXcbConnection() const override
-        {
-            return m_xcbConnection;
-        }
-    private:
-        xcb_connection_t*   m_xcbConnection = nullptr;
-    };
-#endif // PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////
-    class ApplicationLinux
-        : public Application::Implementation
-        , public LinuxLifecycleEvents::Bus::Handler
-    {
-    public:
-        ////////////////////////////////////////////////////////////////////////////////////////////
-        AZ_CLASS_ALLOCATOR(ApplicationLinux, AZ::SystemAllocator, 0);
-        ApplicationLinux();
-        ~ApplicationLinux() override;
-
-        ////////////////////////////////////////////////////////////////////////////////////////////
-        // Application::Implementation
-        void PumpSystemEventLoopOnce() override;
-        void PumpSystemEventLoopUntilEmpty() override;
-    private:
-
-#if PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
-        AZStd::unique_ptr<LinuxXcbConnectionManager>    m_xcbConnectionManager;
-#endif // PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
-
-    };
-
    ////////////////////////////////////////////////////////////////////////////////////////////////
    Application::Implementation* Application::Implementation::Create()
    {
-        return aznew ApplicationLinux();
-    }
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////
-    ApplicationLinux::ApplicationLinux()
-    {
-        LinuxLifecycleEvents::Bus::Handler::BusConnect();
-
 #if PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
-        m_xcbConnectionManager = AZStd::make_unique<LinuxXcbConnectionManagerImpl>();
-        if (LinuxXcbConnectionManagerInterface::Get() == nullptr)
-        {
-            LinuxXcbConnectionManagerInterface::Register(m_xcbConnectionManager.get());
-        }
+        return aznew ApplicationLinux_xcb();
+#elif PAL_TRAIT_LINUX_WINDOW_MANAGER_WAYLAND
+        #error "Linux Window Manager Wayland not supported."
+        return nullptr;
+#elif PAL_TRAIT_LINUX_WINDOW_MANAGER_XLIB
+        #error "Linux Window Manager XLIB not supported."
+        return nullptr;
+#else
+        #error "Linux Window Manager not recognized."
+        return nullptr;
 #endif // PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
    }

-    ////////////////////////////////////////////////////////////////////////////////////////////////
-    ApplicationLinux::~ApplicationLinux()
-    {
-#if PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
-        if (LinuxXcbConnectionManagerInterface::Get() == m_xcbConnectionManager.get())
-        {
-            LinuxXcbConnectionManagerInterface::Unregister(m_xcbConnectionManager.get());
-        }
-        m_xcbConnectionManager.reset();
-#endif // PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB        
-        LinuxLifecycleEvents::Bus::Handler::BusDisconnect();
-    }
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////
-    void ApplicationLinux::PumpSystemEventLoopOnce()
-    {
-    }
-
-    ////////////////////////////////////////////////////////////////////////////////////////////////
-    void ApplicationLinux::PumpSystemEventLoopUntilEmpty()
-    {
-    }
 } // namespace AzFramework
@@ -0,0 +1,94 @@
+/*
+ * 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 <AzFramework/API/ApplicationAPI_Platform.h>
+#include <AzFramework/Application/Application.h>
+#include "Application_Linux_xcb.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+namespace AzFramework
+{
+#if PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    class LinuxXcbConnectionManagerImpl
+        : public LinuxXcbConnectionManagerBus::Handler
+    {
+    public:
+        LinuxXcbConnectionManagerImpl()
+        {
+            m_xcbConnection = xcb_connect(nullptr, nullptr);
+            AZ_Error("ApplicationLinux", m_xcbConnection != nullptr, "Unable to connect to X11 Server.");
+            LinuxXcbConnectionManagerBus::Handler::BusConnect();
+        }
+
+        ~LinuxXcbConnectionManagerImpl()
+        {
+            LinuxXcbConnectionManagerBus::Handler::BusDisconnect();
+            xcb_disconnect(m_xcbConnection);   
+        }
+
+        xcb_connection_t* GetXcbConnection() const override
+        {
+            return m_xcbConnection;
+        }
+
+    private:
+        xcb_connection_t*   m_xcbConnection = nullptr;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    ApplicationLinux_xcb::ApplicationLinux_xcb()
+    {
+        LinuxLifecycleEvents::Bus::Handler::BusConnect();
+        m_xcbConnectionManager = AZStd::make_unique<LinuxXcbConnectionManagerImpl>();
+        if (LinuxXcbConnectionManagerInterface::Get() == nullptr)
+        {
+            LinuxXcbConnectionManagerInterface::Register(m_xcbConnectionManager.get());
+        }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    ApplicationLinux_xcb::~ApplicationLinux_xcb()
+    {
+        if (LinuxXcbConnectionManagerInterface::Get() == m_xcbConnectionManager.get())
+        {
+            LinuxXcbConnectionManagerInterface::Unregister(m_xcbConnectionManager.get());
+        }
+        m_xcbConnectionManager.reset();
+        LinuxLifecycleEvents::Bus::Handler::BusDisconnect();
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    void ApplicationLinux_xcb::PumpSystemEventLoopOnce()
+    {
+        if (xcb_connection_t* xcbConnection = m_xcbConnectionManager->GetXcbConnection())
+        {
+            if (xcb_generic_event_t* event = xcb_poll_for_event(xcbConnection))
+            {
+                LinuxXcbEventHandlerBus::Broadcast(&LinuxXcbEventHandlerBus::Events::HandleXcbEvent, event);
+                free(event);
+            }
+        }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    void ApplicationLinux_xcb::PumpSystemEventLoopUntilEmpty()
+    {
+        if (xcb_connection_t* xcbConnection = m_xcbConnectionManager->GetXcbConnection())
+        {
+            while (xcb_generic_event_t* event = xcb_poll_for_event(xcbConnection))
+            {
+                LinuxXcbEventHandlerBus::Broadcast(&LinuxXcbEventHandlerBus::Events::HandleXcbEvent, event);
+                free(event);
+            }
+        }
+    }
+
+#endif // PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB        
+
+} // namespace AzFramework
@@ -0,0 +1,40 @@
+/*
+ * 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 <AzFramework/API/ApplicationAPI_Platform.h>
+#include <AzFramework/Application/Application.h>
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+namespace AzFramework
+{
+
+#if PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    class ApplicationLinux_xcb
+        : public Application::Implementation
+        , public LinuxLifecycleEvents::Bus::Handler
+    {
+    public:
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        AZ_CLASS_ALLOCATOR(ApplicationLinux_xcb, AZ::SystemAllocator, 0);
+        ApplicationLinux_xcb();
+        ~ApplicationLinux_xcb() override;
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        // Application::Implementation
+        void PumpSystemEventLoopOnce() override;
+        void PumpSystemEventLoopUntilEmpty() override;
+
+    private:
+        AZStd::unique_ptr<LinuxXcbConnectionManager>    m_xcbConnectionManager;
+    };
+
+#endif // PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
+
+} // namespace AzFramework
@@ -6,48 +6,24 @@
 *
 */

-#include <AzFramework/Windowing/NativeWindow.h>
+#include "NativeWindow_Linux_xcb.h"

 namespace AzFramework
 {
-    class NativeWindowImpl_Linux final
-        : public NativeWindow::Implementation
-    {
-    public:
-        AZ_CLASS_ALLOCATOR(NativeWindowImpl_Linux, AZ::SystemAllocator, 0);
-        NativeWindowImpl_Linux() = default;
-        ~NativeWindowImpl_Linux() override = default;
-
-        // NativeWindow::Implementation overrides...
-        void InitWindow(const AZStd::string& title,
-                        const WindowGeometry& geometry,
-                        const WindowStyleMasks& styleMasks) override;
-        NativeWindowHandle GetWindowHandle() const override;
-        uint32_t GetDisplayRefreshRate() const override;
-    };
-
    NativeWindow::Implementation* NativeWindow::Implementation::Create()
    {
-        return aznew NativeWindowImpl_Linux();
-    }
-
-    void NativeWindowImpl_Linux::InitWindow([[maybe_unused]]const AZStd::string& title,
-                                            const WindowGeometry& geometry,
-                                            [[maybe_unused]]const WindowStyleMasks& styleMasks)
-    {
-        m_width = geometry.m_width;
-        m_height = geometry.m_height;
-    }
-
-    NativeWindowHandle NativeWindowImpl_Linux::GetWindowHandle() const
-    {
-        AZ_Assert(false, "NativeWindow not implemented for Linux");
+#if PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
+        return aznew NativeWindowImpl_Linux_xcb();
+#elif PAL_TRAIT_LINUX_WINDOW_MANAGER_WAYLAND
+        #error "Linux Window Manager Wayland not supported."
        return nullptr;
+#elif PAL_TRAIT_LINUX_WINDOW_MANAGER_XLIB
+        #error "Linux Window Manager XLIB not supported."
+        return nullptr;
+#else
+        #error "Linux Window Manager not recognized."
+        return nullptr;
+#endif // PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
    }

-    uint32_t NativeWindowImpl_Linux::GetDisplayRefreshRate() const
-    {
-        //Using 60 for now until proper support is added
-        return 60;
-    }
 } // namespace AzFramework
@@ -0,0 +1,244 @@
+/*
+ * 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 <AzFramework/API/ApplicationAPI_Platform.h>
+#include <AzFramework/Application/Application.h>
+#include <AzFramework/Windowing/NativeWindow.h>
+#include <xcb/xcb.h>
+
+#include "NativeWindow_Linux_xcb.h"
+
+namespace AzFramework
+{
+#if PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
+
+    [[maybe_unused]] const char LinuxXcbErrorWindow[] = "NativeWindow_Linux_xcb";
+    static constexpr uint8_t s_XcbFormatDataSize = 32;              // Format indicator for xcb for client messages
+    static constexpr uint16_t s_DefaultXcbWindowBorderWidth = 4;    // The default border with in pixels if a border was specified
+    static constexpr uint8_t s_XcbResponseTypeMask = 0x7f;          // Mask to extract the specific event type from an xcb event
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    NativeWindowImpl_Linux_xcb::NativeWindowImpl_Linux_xcb() 
+        : NativeWindow::Implementation()
+    {
+        if (auto xcbConnectionManager = AzFramework::LinuxXcbConnectionManagerInterface::Get();
+            xcbConnectionManager != nullptr)
+        {
+            m_xcbConnection = xcbConnectionManager->GetXcbConnection();
+        }
+        AZ_Error(LinuxXcbErrorWindow, m_xcbConnection != nullptr, "Unable to get XCB Connection");
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    NativeWindowImpl_Linux_xcb::~NativeWindowImpl_Linux_xcb()
+    {
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    void NativeWindowImpl_Linux_xcb::InitWindow(const AZStd::string& title,
+                                                const WindowGeometry& geometry,
+                                                const WindowStyleMasks& styleMasks)
+    {
+        // Get the parent window 
+        const xcb_setup_t* xcbSetup = xcb_get_setup(m_xcbConnection);
+        xcb_screen_t* xcbRootScreen = xcb_setup_roots_iterator(xcbSetup).data;
+        xcb_window_t xcbParentWindow = xcbRootScreen->root;
+
+        // Create an XCB window from the connection
+        m_xcbWindow = xcb_generate_id(m_xcbConnection);
+
+        uint16_t borderWidth = 0;
+        const uint32_t mask = styleMasks.m_platformAgnosticStyleMask;
+        if ((mask & WindowStyleMasks::WINDOW_STYLE_BORDERED) ||
+            (mask & WindowStyleMasks::WINDOW_STYLE_RESIZEABLE))
+        {
+            borderWidth = s_DefaultXcbWindowBorderWidth;
+        }
+
+        uint32_t eventMask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
+        
+        uint32_t valueList[] = { xcbRootScreen->black_pixel, 
+                                 XCB_EVENT_MASK_STRUCTURE_NOTIFY };
+
+        xcb_void_cookie_t xcbCheckResult;
+
+        xcbCheckResult = xcb_create_window_checked(m_xcbConnection,
+                                                     XCB_COPY_FROM_PARENT,
+                                                     m_xcbWindow,
+                                                     xcbParentWindow,
+                                                     aznumeric_cast<int16_t>(geometry.m_posX),
+                                                     aznumeric_cast<int16_t>(geometry.m_posY),
+                                                     aznumeric_cast<int16_t>(geometry.m_width),
+                                                     aznumeric_cast<int16_t>(geometry.m_height),
+                                                     borderWidth,
+                                                     XCB_WINDOW_CLASS_INPUT_OUTPUT,
+                                                     xcbRootScreen->root_visual,
+                                                     eventMask,
+                                                     valueList);
+
+        AZ_Assert(ValidateXcbResult(xcbCheckResult), "Failed to create xcb window.");
+
+        SetWindowTitle(title);
+
+        // Setup the window close event 
+        const static char* wmProtocolString = "WM_PROTOCOLS";
+        
+        xcb_intern_atom_cookie_t cookieProtocol = xcb_intern_atom(m_xcbConnection, 1, strlen(wmProtocolString), wmProtocolString);
+        xcb_intern_atom_reply_t* replyProtocol = xcb_intern_atom_reply(m_xcbConnection, cookieProtocol, nullptr);
+        AZ_Error(LinuxXcbErrorWindow, replyProtocol != nullptr, "Unable to query xcb '%s' atom", wmProtocolString);
+        m_xcbAtomProtocols = replyProtocol->atom;
+
+        const static char* wmDeleteWindowString = "WM_DELETE_WINDOW";
+        xcb_intern_atom_cookie_t cookieDeleteWindow = xcb_intern_atom(m_xcbConnection, 0, strlen(wmDeleteWindowString), wmDeleteWindowString);
+        xcb_intern_atom_reply_t* replyDeleteWindow = xcb_intern_atom_reply(m_xcbConnection, cookieDeleteWindow, nullptr);
+        AZ_Error(LinuxXcbErrorWindow, replyDeleteWindow != nullptr, "Unable to query xcb '%s' atom", wmDeleteWindowString);
+        m_xcbAtomDeleteWindow = replyDeleteWindow->atom;
+
+        xcbCheckResult = xcb_change_property_checked(m_xcbConnection, 
+                                                       XCB_PROP_MODE_REPLACE, 
+                                                       m_xcbWindow, 
+                                                       m_xcbAtomProtocols, 
+                                                       XCB_ATOM_ATOM, 
+                                                       s_XcbFormatDataSize, 
+                                                       1,
+                                                       &m_xcbAtomDeleteWindow);
+                                                    
+        AZ_Assert(ValidateXcbResult(xcbCheckResult), "Failed to change the xcb atom property for WM_CLOSE event");
+
+        m_width = geometry.m_width;
+        m_height = geometry.m_height;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    void NativeWindowImpl_Linux_xcb::Activate()
+    {
+        LinuxXcbEventHandlerBus::Handler::BusConnect();
+
+        if (!m_activated) // nothing to do if window was already activated
+        {
+            m_activated = true;
+
+            xcb_map_window(m_xcbConnection, m_xcbWindow);
+            xcb_flush(m_xcbConnection);
+        }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    void NativeWindowImpl_Linux_xcb::Deactivate()
+    {
+        if (m_activated) // nothing to do if window was already deactivated
+        {
+            m_activated = false;
+
+            WindowNotificationBus::Event(reinterpret_cast<NativeWindowHandle>(m_xcbWindow), &WindowNotificationBus::Events::OnWindowClosed);
+
+            xcb_unmap_window(m_xcbConnection, m_xcbWindow);
+            xcb_flush(m_xcbConnection);
+        }
+        LinuxXcbEventHandlerBus::Handler::BusDisconnect();
+    }    
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    NativeWindowHandle NativeWindowImpl_Linux_xcb::GetWindowHandle() const
+    {
+        return reinterpret_cast<NativeWindowHandle>(m_xcbWindow);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    void NativeWindowImpl_Linux_xcb::SetWindowTitle(const AZStd::string& title)
+    {
+        xcb_void_cookie_t xcbCheckResult;
+        xcbCheckResult = xcb_change_property(m_xcbConnection,
+                                               XCB_PROP_MODE_REPLACE,
+                                               m_xcbWindow,
+                                               XCB_ATOM_WM_NAME,
+                                               XCB_ATOM_STRING,
+                                               8,
+                                               static_cast<uint32_t>(title.size()),
+                                               title.c_str());
+        AZ_Assert(ValidateXcbResult(xcbCheckResult), "Failed to set window title.");
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    void NativeWindowImpl_Linux_xcb::ResizeClientArea(WindowSize clientAreaSize)
+    {
+        const uint32_t values[] = { clientAreaSize.m_width, clientAreaSize.m_height };
+
+        xcb_configure_window(m_xcbConnection, m_xcbWindow, XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);
+        
+        m_width = clientAreaSize.m_width;
+        m_height = clientAreaSize.m_height;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    uint32_t NativeWindowImpl_Linux_xcb::GetDisplayRefreshRate() const
+    {
+        // [GFX TODO][GHI - 2678]
+        // Using 60 for now until proper support is added
+        return 60;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    bool NativeWindowImpl_Linux_xcb::ValidateXcbResult(xcb_void_cookie_t cookie)
+    {
+        bool result = true;
+        if (xcb_generic_error_t* error = xcb_request_check(m_xcbConnection, cookie))
+        {
+            AZ_TracePrintf("Error","Error code %d", error->error_code);
+            result = false;
+        }
+        return result;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    void NativeWindowImpl_Linux_xcb::HandleXcbEvent(xcb_generic_event_t* event)
+    {
+        switch (event->response_type & s_XcbResponseTypeMask)
+        {
+            case XCB_CONFIGURE_NOTIFY:
+            {
+                xcb_configure_notify_event_t* cne = reinterpret_cast<xcb_configure_notify_event_t*>(event);
+                WindowSizeChanged(aznumeric_cast<uint32_t>(cne->width), 
+                                  aznumeric_cast<uint32_t>(cne->height));
+
+                break;
+            }
+            case XCB_CLIENT_MESSAGE:
+            {
+                xcb_client_message_event_t* cme = reinterpret_cast<xcb_client_message_event_t*>(event);
+                if ((cme->type == m_xcbAtomProtocols) && 
+                    (cme->format == s_XcbFormatDataSize) &&
+                    (cme->data.data32[0] == m_xcbAtomDeleteWindow))
+                {
+                    Deactivate();
+
+                    ApplicationRequests::Bus::Broadcast(&ApplicationRequests::ExitMainLoop);
+                }
+                break;
+            }
+        }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    void NativeWindowImpl_Linux_xcb::WindowSizeChanged(const uint32_t width, const uint32_t height)
+    {
+        if (m_width != width || m_height != height)
+        {
+            m_width = width;
+            m_height = height;
+
+            if (m_activated)
+            {
+                WindowNotificationBus::Event(reinterpret_cast<NativeWindowHandle>(m_xcbWindow), &WindowNotificationBus::Events::OnWindowResized, width, height);
+            }
+        }
+    }
+    
+#endif // PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
+
+} // namespace AzFramework
@@ -0,0 +1,53 @@
+/*
+ * 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 <AzFramework/API/ApplicationAPI_Platform.h>
+#include <AzFramework/Application/Application.h>
+#include <AzFramework/Windowing/NativeWindow.h>
+#include <xcb/xcb.h>
+
+namespace AzFramework
+{
+#if PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
+    class NativeWindowImpl_Linux_xcb final
+        : public NativeWindow::Implementation
+        , public LinuxXcbEventHandlerBus::Handler
+    {
+    public:
+        AZ_CLASS_ALLOCATOR(NativeWindowImpl_Linux_xcb, AZ::SystemAllocator, 0);
+        NativeWindowImpl_Linux_xcb();
+        ~NativeWindowImpl_Linux_xcb() override;
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        // NativeWindow::Implementation
+        void InitWindow(const AZStd::string& title,
+                        const WindowGeometry& geometry,
+                        const WindowStyleMasks& styleMasks) override;
+        void Activate() override;
+        void Deactivate() override;
+        NativeWindowHandle GetWindowHandle() const override;
+        void SetWindowTitle(const AZStd::string& title) override;
+        void ResizeClientArea(WindowSize clientAreaSize) override;
+        uint32_t GetDisplayRefreshRate() const override;        
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        // LinuxXcbEventHandlerBus::Handler
+        void HandleXcbEvent(xcb_generic_event_t* event) override;
+
+    private:
+        bool ValidateXcbResult(xcb_void_cookie_t cookie);
+        void WindowSizeChanged(const uint32_t width, const uint32_t height);
+
+        xcb_connection_t*   m_xcbConnection = nullptr;
+        xcb_window_t        m_xcbWindow = 0;
+        xcb_atom_t          m_xcbAtomProtocols;
+        xcb_atom_t          m_xcbAtomDeleteWindow;
+    };
+#endif // PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
+
+} // namespace AzFramework
@@ -12,6 +12,8 @@ set(FILES
    AzFramework/API/ApplicationAPI_Platform.h
    AzFramework/API/ApplicationAPI_Linux.h
    AzFramework/Application/Application_Linux.cpp
+    AzFramework/Application/Application_Linux_xcb.h
+    AzFramework/Application/Application_Linux_xcb.cpp
    AzFramework/Asset/AssetSystemComponentHelper_Linux.cpp
    AzFramework/Process/ProcessWatcher_Linux.cpp
    AzFramework/Process/ProcessCommon.h
@@ -20,6 +22,8 @@ set(FILES
    ../Common/Unimplemented/AzFramework/StreamingInstall/StreamingInstall_Unimplemented.cpp
    ../Common/Default/AzFramework/TargetManagement/TargetManagementComponent_Default.cpp
    AzFramework/Windowing/NativeWindow_Linux.cpp
+    AzFramework/Windowing/NativeWindow_Linux_xcb.h
+    AzFramework/Windowing/NativeWindow_Linux_xcb.cpp
    ../Common/Unimplemented/AzFramework/Input/Devices/Gamepad/InputDeviceGamepad_Unimplemented.cpp
    ../Common/Unimplemented/AzFramework/Input/Devices/Keyboard/InputDeviceKeyboard_Unimplemented.cpp
    ../Common/Unimplemented/AzFramework/Input/Devices/Motion/InputDeviceMotion_Unimplemented.cpp
@@ -6,6 +6,7 @@
 *
 */

+#include <AZTestShared/Math/MathTestHelpers.h>
 #include <AzCore/UnitTest/TestTypes.h>
 #include <AzCore/std/smart_ptr/make_shared.h>
 #include <AzFramework/Input/Devices/Keyboard/InputDeviceKeyboard.h>
@@ -47,18 +48,17 @@ namespace UnitTest
            m_firstPersonTranslateCamera =
                AZStd::make_shared<AzFramework::TranslateCameraInput>(AzFramework::LookTranslation, m_translateCameraInputChannelIds);

-            auto orbitCamera =
-                AZStd::make_shared<AzFramework::OrbitCameraInput>(AzFramework::InputChannelId("keyboard_key_modifier_alt_l"));
+            m_orbitCamera = AZStd::make_shared<AzFramework::OrbitCameraInput>(m_orbitChannelId);
            auto orbitRotateCamera = AZStd::make_shared<AzFramework::RotateCameraInput>(AzFramework::InputDeviceMouse::Button::Left);
            auto orbitTranslateCamera =
                AZStd::make_shared<AzFramework::TranslateCameraInput>(AzFramework::OrbitTranslation, m_translateCameraInputChannelIds);

-            orbitCamera->m_orbitCameras.AddCamera(orbitRotateCamera);
-            orbitCamera->m_orbitCameras.AddCamera(orbitTranslateCamera);
+            m_orbitCamera->m_orbitCameras.AddCamera(orbitRotateCamera);
+            m_orbitCamera->m_orbitCameras.AddCamera(orbitTranslateCamera);

            m_cameraSystem->m_cameras.AddCamera(m_firstPersonRotateCamera);
            m_cameraSystem->m_cameras.AddCamera(m_firstPersonTranslateCamera);
-            m_cameraSystem->m_cameras.AddCamera(orbitCamera);
+            m_cameraSystem->m_cameras.AddCamera(m_orbitCamera);

            // these tests rely on using motion delta, not cursor positions (default is true)
            AzFramework::ed_cameraSystemUseCursor = false;
@@ -68,6 +68,7 @@ namespace UnitTest
        {
            AzFramework::ed_cameraSystemUseCursor = true;

+            m_orbitCamera.reset();
            m_firstPersonRotateCamera.reset();
            m_firstPersonTranslateCamera.reset();

@@ -77,12 +78,14 @@ namespace UnitTest
            AllocatorsTestFixture::TearDown();
        }

+        AzFramework::InputChannelId m_orbitChannelId = AzFramework::InputChannelId("keyboard_key_modifier_alt_l");
        AzFramework::TranslateCameraInputChannelIds m_translateCameraInputChannelIds;
        AZStd::shared_ptr<AzFramework::RotateCameraInput> m_firstPersonRotateCamera;
        AZStd::shared_ptr<AzFramework::TranslateCameraInput> m_firstPersonTranslateCamera;
+        AZStd::shared_ptr<AzFramework::OrbitCameraInput> m_orbitCamera;
    };

-    TEST_F(CameraInputFixture, Begin_and_end_OrbitCameraInput_consumes_correct_events)
+    TEST_F(CameraInputFixture, BeginAndEndOrbitCameraInputConsumesCorrectEvents)
    {
        // begin orbit camera
        const bool consumed1 = HandleEventAndUpdate(AzFramework::DiscreteInputEvent{ AzFramework::InputDeviceKeyboard::Key::ModifierAltL,
@@ -102,7 +105,7 @@ namespace UnitTest
        EXPECT_THAT(allConsumed, ElementsAre(true, false, true, false));
    }

-    TEST_F(CameraInputFixture, Begin_CameraInput_notifies_ActivationBeganFn_for_TranslateCameraInput)
+    TEST_F(CameraInputFixture, BeginCameraInputNotifiesActivationBeganFnForTranslateCameraInput)
    {
        bool activationBegan = false;
        m_firstPersonTranslateCamera->SetActivationBeganFn(
@@ -111,13 +114,13 @@ namespace UnitTest
                activationBegan = true;
            });

-        HandleEventAndUpdate(
-            AzFramework::DiscreteInputEvent{ m_translateCameraInputChannelIds.m_forwardChannelId, AzFramework::InputChannel::State::Began });
+        HandleEventAndUpdate(AzFramework::DiscreteInputEvent{ m_translateCameraInputChannelIds.m_forwardChannelId,
+                                                              AzFramework::InputChannel::State::Began });

        EXPECT_TRUE(activationBegan);
    }

-    TEST_F(CameraInputFixture, Begin_CameraInput_notifies_ActivationBeganFn_after_delta_for_RotateCameraInput)
+    TEST_F(CameraInputFixture, BeginCameraInputNotifiesActivationBeganFnAfterDeltaForRotateCameraInput)
    {
        bool activationBegan = false;
        m_firstPersonRotateCamera->SetActivationBeganFn(
@@ -133,7 +136,7 @@ namespace UnitTest
        EXPECT_TRUE(activationBegan);
    }

-    TEST_F(CameraInputFixture, Begin_CameraInput_does_not_notify_ActivationBeganFn_with_no_delta_for_RotateCameraInput)
+    TEST_F(CameraInputFixture, BeginCameraInputDoesNotNotifyActivationBeganFnWithNoDeltaForRotateCameraInput)
    {
        bool activationBegan = false;
        m_firstPersonRotateCamera->SetActivationBeganFn(
@@ -148,7 +151,7 @@ namespace UnitTest
        EXPECT_FALSE(activationBegan);
    }

-    TEST_F(CameraInputFixture, End_CameraInput_notifies_ActivationEndFn_after_delta_for_RotateCameraInput)
+    TEST_F(CameraInputFixture, EndCameraInputNotifiesActivationEndFnAfterDeltaForRotateCameraInput)
    {
        bool activationEnded = false;
        m_firstPersonRotateCamera->SetActivationEndedFn(
@@ -166,7 +169,7 @@ namespace UnitTest
        EXPECT_TRUE(activationEnded);
    }

-    TEST_F(CameraInputFixture, End_CameraInput_does_not_notify_ActivationBeganFn_or_ActivationBeganFn_with_no_delta_for_RotateCameraInput)
+    TEST_F(CameraInputFixture, EndCameraInputDoesNotNotifyActivationBeganFnOrActivationBeganFnWithNoDeltaForRotateCameraInput)
    {
        bool activationBegan = false;
        m_firstPersonRotateCamera->SetActivationBeganFn(
@@ -191,7 +194,7 @@ namespace UnitTest
        EXPECT_FALSE(activationEnded);
    }

-    TEST_F(CameraInputFixture, End_CameraInput_notifies_ActivationBeganFn_or_ActivationEndFn_with_TranslateCamera)
+    TEST_F(CameraInputFixture, End_CameraInputNotifiesActivationBeganFnOrActivationEndFnWithTranslateCamera)
    {
        bool activationBegan = false;
        m_firstPersonTranslateCamera->SetActivationBeganFn(
@@ -207,16 +210,16 @@ namespace UnitTest
                activationEnded = true;
            });

-        HandleEventAndUpdate(
-            AzFramework::DiscreteInputEvent{ m_translateCameraInputChannelIds.m_forwardChannelId, AzFramework::InputChannel::State::Began });
-        HandleEventAndUpdate(
-            AzFramework::DiscreteInputEvent{ m_translateCameraInputChannelIds.m_forwardChannelId, AzFramework::InputChannel::State::Ended });
+        HandleEventAndUpdate(AzFramework::DiscreteInputEvent{ m_translateCameraInputChannelIds.m_forwardChannelId,
+                                                              AzFramework::InputChannel::State::Began });
+        HandleEventAndUpdate(AzFramework::DiscreteInputEvent{ m_translateCameraInputChannelIds.m_forwardChannelId,
+                                                              AzFramework::InputChannel::State::Ended });

        EXPECT_TRUE(activationBegan);
        EXPECT_TRUE(activationEnded);
    }

-    TEST_F(CameraInputFixture, End_activation_called_for_CameraInput_if_active_when_cameras_are_cleared)
+    TEST_F(CameraInputFixture, EndActivationCalledForCameraInputIfActiveWhenCamerasAreCleared)
    {
        bool activationEnded = false;
        m_firstPersonTranslateCamera->SetActivationEndedFn(
@@ -225,11 +228,37 @@ namespace UnitTest
                activationEnded = true;
            });

-        HandleEventAndUpdate(
-            AzFramework::DiscreteInputEvent{ m_translateCameraInputChannelIds.m_forwardChannelId, AzFramework::InputChannel::State::Began });
+        HandleEventAndUpdate(AzFramework::DiscreteInputEvent{ m_translateCameraInputChannelIds.m_forwardChannelId,
+                                                              AzFramework::InputChannel::State::Began });

        m_cameraSystem->m_cameras.Clear();

        EXPECT_TRUE(activationEnded);
    }
+
+    TEST_F(CameraInputFixture, OrbitCameraInputHandlesLookAtPointAndSelfAtSamePositionWhenOrbiting)
+    {
+        // create pathological lookAtFn that just returns the same position as the camera
+        m_orbitCamera->SetLookAtFn(
+            [](const AZ::Vector3& position, [[maybe_unused]] const AZ::Vector3& direction)
+            {
+                return position;
+            });
+
+        AzFramework::UpdateCameraFromTransform(
+            m_targetCamera,
+            AZ::Transform::CreateFromQuaternionAndTranslation(
+                AZ::Quaternion::CreateFromEulerAnglesDegrees(AZ::Vector3(0.0f, 0.0f, 90.0f)), AZ::Vector3(10.0f, 10.0f, 10.0f)));
+
+        m_camera = m_targetCamera;
+
+        HandleEventAndUpdate(AzFramework::DiscreteInputEvent{ m_orbitChannelId, AzFramework::InputChannel::State::Began });
+
+        // verify the camera yaw has not changed and the look at point
+        // does not match that of the camera translation
+        using ::testing::Eq;
+        using ::testing::Not;
+        EXPECT_THAT(m_camera.m_yaw, Eq(AZ::DegToRad(90.0f)));
+        EXPECT_THAT(m_camera.m_lookAt, Not(IsClose(m_camera.Translation())));
+    }
 } // namespace UnitTest