Integrate XCUI runtime context into SceneRuntime

engine/CMakeLists.txt

@@ -525,9 +525,11 @@ add_library(XCEngine STATIC
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/UI/Runtime/UIScreenTypes.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/UI/Runtime/UIScreenDocumentHost.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/UI/Runtime/UIScreenPlayer.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/UI/Runtime/UISceneRuntimeContext.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/UI/Runtime/UISystem.h
     ${CMAKE_CURRENT_SOURCE_DIR}/src/UI/Runtime/UIScreenDocumentHost.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/UI/Runtime/UIScreenPlayer.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/UI/Runtime/UISceneRuntimeContext.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/UI/Runtime/UIScreenStackController.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/UI/Runtime/UISystem.cpp
 

engine/include/XCEngine/Scene/SceneRuntime.h

@@ -1,12 +1,37 @@
 #pragma once
 
 #include <XCEngine/Scene/Scene.h>
+#include <XCEngine/UI/Types.h>
+
+#include <memory>
+
+namespace XCEngine {
+namespace UI {
+namespace Runtime {
+
+class UISceneRuntimeContext;
+class UISystem;
+class UIScreenStackController;
+struct UISystemFrameResult;
+
+} // namespace Runtime
+} // namespace UI
+} // namespace XCEngine
 
 namespace XCEngine {
 namespace Components {
 
 class SceneRuntime {
 public:
+    SceneRuntime();
+    ~SceneRuntime();
+
+    SceneRuntime(SceneRuntime&& other) noexcept;
+    SceneRuntime& operator=(SceneRuntime&& other) noexcept;
+
+    SceneRuntime(const SceneRuntime&) = delete;
+    SceneRuntime& operator=(const SceneRuntime&) = delete;
+
     void Start(Scene* scene);
     void Stop();
 
@@ -14,10 +39,19 @@ public:
     void Update(float deltaTime);
     void LateUpdate(float deltaTime);
 
+    UI::Runtime::UISystem& GetUISystem();
+    UI::Runtime::UIScreenStackController& GetUIScreenStackController();
+    const UI::Runtime::UISystemFrameResult& GetLastUIFrame() const;
+    void SetUIViewportRect(const UI::UIRect& viewportRect);
+    void SetUIFocused(bool focused);
+    void QueueUIInputEvent(const UI::UIInputEvent& event);
+    void ClearQueuedUIInputEvents();
+
     bool IsRunning() const { return m_running; }
     Scene* GetScene() const { return m_scene; }
 
 private:
+    std::unique_ptr<UI::Runtime::UISceneRuntimeContext> m_uiRuntime;
     Scene* m_scene = nullptr;
     bool m_running = false;
 };

engine/include/XCEngine/UI/Runtime/UISceneRuntimeContext.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <XCEngine/UI/Runtime/UIScreenDocumentHost.h>
+#include <XCEngine/UI/Runtime/UIScreenStackController.h>
+#include <XCEngine/UI/Runtime/UISystem.h>
+
+namespace XCEngine {
+namespace UI {
+namespace Runtime {
+
+class UISceneRuntimeContext {
+public:
+    UISceneRuntimeContext();
+
+    UISystem& GetSystem();
+    const UISystem& GetSystem() const;
+
+    UIScreenStackController& GetStackController();
+    const UIScreenStackController& GetStackController() const;
+
+    const UISystemFrameResult& GetLastFrame() const;
+
+    void Reset();
+    void SetViewportRect(const UIRect& viewportRect);
+    void SetFocused(bool focused);
+    void QueueInputEvent(const UIInputEvent& event);
+    void ClearQueuedInputEvents();
+    void Update(double deltaTimeSeconds);
+
+private:
+    UIDocumentScreenHost m_documentHost = {};
+    UISystem m_system;
+    UIScreenStackController m_stackController;
+    UIScreenFrameInput m_pendingFrameInput = {};
+    std::uint64_t m_nextFrameIndex = 1u;
+};
+
+} // namespace Runtime
+} // namespace UI
+} // namespace XCEngine

engine/src/Scene/SceneRuntime.cpp

@@ -1,10 +1,21 @@
 #include "Scene/SceneRuntime.h"
 
 #include "Scripting/ScriptEngine.h"
+#include <XCEngine/UI/Runtime/UISceneRuntimeContext.h>
 
 namespace XCEngine {
 namespace Components {
 
+SceneRuntime::SceneRuntime()
+    : m_uiRuntime(std::make_unique<UI::Runtime::UISceneRuntimeContext>()) {
+}
+
+SceneRuntime::~SceneRuntime() = default;
+
+SceneRuntime::SceneRuntime(SceneRuntime&& other) noexcept = default;
+
+SceneRuntime& SceneRuntime::operator=(SceneRuntime&& other) noexcept = default;
+
 void SceneRuntime::Start(Scene* scene) {
     if (m_running && m_scene == scene) {
         return;
@@ -18,16 +29,19 @@ void SceneRuntime::Start(Scene* scene) {
 
     m_scene = scene;
     m_running = true;
+    m_uiRuntime->Reset();
     Scripting::ScriptEngine::Get().OnRuntimeStart(scene);
 }
 
 void SceneRuntime::Stop() {
     if (!m_running) {
+        m_uiRuntime->Reset();
         m_scene = nullptr;
         return;
     }
 
     Scripting::ScriptEngine::Get().OnRuntimeStop();
+    m_uiRuntime->Reset();
     m_running = false;
     m_scene = nullptr;
 }
@@ -49,6 +63,7 @@ void SceneRuntime::Update(float deltaTime) {
 
     Scripting::ScriptEngine::Get().OnUpdate(deltaTime);
     m_scene->Update(deltaTime);
+    m_uiRuntime->Update(deltaTime);
 }
 
 void SceneRuntime::LateUpdate(float deltaTime) {
@@ -60,5 +75,33 @@ void SceneRuntime::LateUpdate(float deltaTime) {
     m_scene->LateUpdate(deltaTime);
 }
 
+UI::Runtime::UISystem& SceneRuntime::GetUISystem() {
+    return m_uiRuntime->GetSystem();
+}
+
+UI::Runtime::UIScreenStackController& SceneRuntime::GetUIScreenStackController() {
+    return m_uiRuntime->GetStackController();
+}
+
+const UI::Runtime::UISystemFrameResult& SceneRuntime::GetLastUIFrame() const {
+    return m_uiRuntime->GetLastFrame();
+}
+
+void SceneRuntime::SetUIViewportRect(const UI::UIRect& viewportRect) {
+    m_uiRuntime->SetViewportRect(viewportRect);
+}
+
+void SceneRuntime::SetUIFocused(bool focused) {
+    m_uiRuntime->SetFocused(focused);
+}
+
+void SceneRuntime::QueueUIInputEvent(const UI::UIInputEvent& event) {
+    m_uiRuntime->QueueInputEvent(event);
+}
+
+void SceneRuntime::ClearQueuedUIInputEvents() {
+    m_uiRuntime->ClearQueuedInputEvents();
+}
+
 } // namespace Components
 } // namespace XCEngine

engine/src/UI/Runtime/UISceneRuntimeContext.cpp

@@ -0,0 +1,64 @@
+#include <XCEngine/UI/Runtime/UISceneRuntimeContext.h>
+
+namespace XCEngine {
+namespace UI {
+namespace Runtime {
+
+UISceneRuntimeContext::UISceneRuntimeContext()
+    : m_system(m_documentHost)
+    , m_stackController(m_system) {
+}
+
+UISystem& UISceneRuntimeContext::GetSystem() {
+    return m_system;
+}
+
+const UISystem& UISceneRuntimeContext::GetSystem() const {
+    return m_system;
+}
+
+UIScreenStackController& UISceneRuntimeContext::GetStackController() {
+    return m_stackController;
+}
+
+const UIScreenStackController& UISceneRuntimeContext::GetStackController() const {
+    return m_stackController;
+}
+
+const UISystemFrameResult& UISceneRuntimeContext::GetLastFrame() const {
+    return m_system.GetLastFrame();
+}
+
+void UISceneRuntimeContext::Reset() {
+    m_stackController.Clear();
+    m_system.DestroyAllPlayers();
+    m_pendingFrameInput = {};
+    m_nextFrameIndex = 1u;
+}
+
+void UISceneRuntimeContext::SetViewportRect(const UIRect& viewportRect) {
+    m_pendingFrameInput.viewportRect = viewportRect;
+}
+
+void UISceneRuntimeContext::SetFocused(bool focused) {
+    m_pendingFrameInput.focused = focused;
+}
+
+void UISceneRuntimeContext::QueueInputEvent(const UIInputEvent& event) {
+    m_pendingFrameInput.events.push_back(event);
+}
+
+void UISceneRuntimeContext::ClearQueuedInputEvents() {
+    m_pendingFrameInput.events.clear();
+}
+
+void UISceneRuntimeContext::Update(double deltaTimeSeconds) {
+    m_pendingFrameInput.deltaTimeSeconds = deltaTimeSeconds;
+    m_pendingFrameInput.frameIndex = m_nextFrameIndex++;
+    m_system.Update(m_pendingFrameInput);
+    m_pendingFrameInput.events.clear();
+}
+
+} // namespace Runtime
+} // namespace UI
+} // namespace XCEngine