Build XCEditor workspace viewport compose foundation

new_editor/CMakeLists.txt

@@ -21,6 +21,7 @@ add_library(XCUIEditorLib STATIC
     src/Core/UIEditorShortcutManager.cpp
     src/Core/UIEditorViewportInputBridge.cpp
     src/Core/UIEditorViewportShell.cpp
+    src/Core/UIEditorWorkspaceCompose.cpp
     src/Core/UIEditorWorkspaceLayoutPersistence.cpp
     src/Core/UIEditorWorkspaceController.cpp
     src/Core/UIEditorWorkspaceModel.cpp

new_editor/include/XCEditor/Core/UIEditorPanelRegistry.h

@@ -8,7 +8,8 @@
 namespace XCEngine::UI::Editor {
 
 enum class UIEditorPanelPresentationKind : std::uint8_t {
-    Placeholder = 0
+    Placeholder = 0,
+    ViewportShell
 };
 
 struct UIEditorPanelDescriptor {

new_editor/include/XCEditor/Core/UIEditorWorkspaceCompose.h

@@ -0,0 +1,99 @@
+#pragma once
+
+#include <XCEditor/Core/UIEditorPanelRegistry.h>
+#include <XCEditor/Core/UIEditorViewportShell.h>
+#include <XCEditor/Core/UIEditorWorkspaceSession.h>
+#include <XCEditor/Widgets/UIEditorDockHost.h>
+
+#include <XCEngine/UI/DrawData.h>
+
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace XCEngine::UI::Editor {
+
+struct UIEditorWorkspacePanelPresentationModel {
+    std::string panelId = {};
+    UIEditorPanelPresentationKind kind = UIEditorPanelPresentationKind::Placeholder;
+    UIEditorViewportShellModel viewportShellModel = {};
+};
+
+struct UIEditorWorkspacePanelPresentationState {
+    std::string panelId = {};
+    UIEditorViewportShellState viewportShellState = {};
+};
+
+struct UIEditorWorkspaceComposeState {
+    std::vector<UIEditorWorkspacePanelPresentationState> panelStates = {};
+};
+
+struct UIEditorWorkspaceViewportComposeRequest {
+    std::string panelId = {};
+    ::XCEngine::UI::UIRect bounds = {};
+    UIEditorViewportShellRequest viewportShellRequest = {};
+};
+
+struct UIEditorWorkspaceComposeRequest {
+    Widgets::UIEditorDockHostLayout dockHostLayout = {};
+    std::vector<UIEditorWorkspaceViewportComposeRequest> viewportRequests = {};
+};
+
+struct UIEditorWorkspaceViewportComposeFrame {
+    std::string panelId = {};
+    ::XCEngine::UI::UIRect bounds = {};
+    UIEditorViewportShellModel viewportShellModel = {};
+    UIEditorViewportShellFrame viewportShellFrame = {};
+};
+
+struct UIEditorWorkspaceComposeFrame {
+    Widgets::UIEditorDockHostLayout dockHostLayout = {};
+    std::vector<UIEditorWorkspaceViewportComposeFrame> viewportFrames = {};
+};
+
+const UIEditorWorkspacePanelPresentationModel* FindUIEditorWorkspacePanelPresentationModel(
+    const std::vector<UIEditorWorkspacePanelPresentationModel>& presentations,
+    std::string_view panelId);
+
+const UIEditorWorkspacePanelPresentationState* FindUIEditorWorkspacePanelPresentationState(
+    const UIEditorWorkspaceComposeState& state,
+    std::string_view panelId);
+
+const UIEditorWorkspaceViewportComposeRequest* FindUIEditorWorkspaceViewportPresentationRequest(
+    const UIEditorWorkspaceComposeRequest& request,
+    std::string_view panelId);
+
+const UIEditorWorkspaceViewportComposeFrame* FindUIEditorWorkspaceViewportPresentationFrame(
+    const UIEditorWorkspaceComposeFrame& frame,
+    std::string_view panelId);
+
+UIEditorWorkspaceComposeRequest ResolveUIEditorWorkspaceComposeRequest(
+    const ::XCEngine::UI::UIRect& bounds,
+    const UIEditorPanelRegistry& panelRegistry,
+    const UIEditorWorkspaceModel& workspace,
+    const UIEditorWorkspaceSession& session,
+    const std::vector<UIEditorWorkspacePanelPresentationModel>& presentations,
+    const Widgets::UIEditorDockHostState& dockHostState = {},
+    const Widgets::UIEditorDockHostMetrics& dockHostMetrics = {});
+
+UIEditorWorkspaceComposeFrame UpdateUIEditorWorkspaceCompose(
+    UIEditorWorkspaceComposeState& state,
+    const ::XCEngine::UI::UIRect& bounds,
+    const UIEditorPanelRegistry& panelRegistry,
+    const UIEditorWorkspaceModel& workspace,
+    const UIEditorWorkspaceSession& session,
+    const std::vector<UIEditorWorkspacePanelPresentationModel>& presentations,
+    const std::vector<::XCEngine::UI::UIInputEvent>& inputEvents,
+    const Widgets::UIEditorDockHostState& dockHostState = {},
+    const Widgets::UIEditorDockHostMetrics& dockHostMetrics = {});
+
+std::vector<std::string> CollectUIEditorWorkspaceComposeExternalBodyPanelIds(
+    const UIEditorWorkspaceComposeFrame& frame);
+
+void AppendUIEditorWorkspaceCompose(
+    ::XCEngine::UI::UIDrawList& drawList,
+    const UIEditorWorkspaceComposeFrame& frame,
+    const Widgets::UIEditorDockHostPalette& dockHostPalette = {},
+    const Widgets::UIEditorDockHostMetrics& dockHostMetrics = {});
+
+} // namespace XCEngine::UI::Editor

new_editor/include/XCEditor/Widgets/UIEditorDockHost.h

@@ -117,6 +117,12 @@ struct UIEditorDockHostLayout {
     std::vector<UIEditorDockHostTabStackLayout> tabStacks = {};
 };
 
+// Allows higher-level compose to own panel body presentation while DockHost
+// keeps drawing the surrounding chrome/frame.
+struct UIEditorDockHostForegroundOptions {
+    std::vector<std::string> externalBodyPanelIds = {};
+};
+
 const UIEditorDockHostSplitterLayout* FindUIEditorDockHostSplitterLayout(
     const UIEditorDockHostLayout& layout,
     std::string_view nodeId);
@@ -142,9 +148,16 @@ void AppendUIEditorDockHostBackground(
 void AppendUIEditorDockHostForeground(
     ::XCEngine::UI::UIDrawList& drawList,
     const UIEditorDockHostLayout& layout,
+    const UIEditorDockHostForegroundOptions& options = {},
     const UIEditorDockHostPalette& palette = {},
     const UIEditorDockHostMetrics& metrics = {});
 
+void AppendUIEditorDockHostForeground(
+    ::XCEngine::UI::UIDrawList& drawList,
+    const UIEditorDockHostLayout& layout,
+    const UIEditorDockHostPalette& palette,
+    const UIEditorDockHostMetrics& metrics = {});
+
 void AppendUIEditorDockHost(
     ::XCEngine::UI::UIDrawList& drawList,
     const ::XCEngine::UI::UIRect& bounds,
@@ -152,7 +165,18 @@ void AppendUIEditorDockHost(
     const UIEditorWorkspaceModel& workspace,
     const UIEditorWorkspaceSession& session,
     const UIEditorDockHostState& state = {},
+    const UIEditorDockHostForegroundOptions& foregroundOptions = {},
     const UIEditorDockHostPalette& palette = {},
     const UIEditorDockHostMetrics& metrics = {});
 
+void AppendUIEditorDockHost(
+    ::XCEngine::UI::UIDrawList& drawList,
+    const ::XCEngine::UI::UIRect& bounds,
+    const UIEditorPanelRegistry& panelRegistry,
+    const UIEditorWorkspaceModel& workspace,
+    const UIEditorWorkspaceSession& session,
+    const UIEditorDockHostState& state,
+    const UIEditorDockHostPalette& palette,
+    const UIEditorDockHostMetrics& metrics = {});
+
 } // namespace XCEngine::UI::Editor::Widgets

new_editor/src/Core/UIEditorWorkspaceCompose.cpp

@@ -0,0 +1,301 @@
+#include <XCEditor/Core/UIEditorWorkspaceCompose.h>
+
+#include <algorithm>
+#include <utility>
+
+namespace XCEngine::UI::Editor {
+
+namespace {
+
+using Widgets::AppendUIEditorDockHostBackground;
+using Widgets::AppendUIEditorDockHostForeground;
+using Widgets::AppendUIEditorViewportSlotBackground;
+using Widgets::AppendUIEditorViewportSlotForeground;
+using Widgets::BuildUIEditorDockHostLayout;
+using Widgets::UIEditorDockHostForegroundOptions;
+
+const UIEditorWorkspacePanelPresentationState* FindPanelStateImpl(
+    const UIEditorWorkspaceComposeState& state,
+    std::string_view panelId) {
+    for (const UIEditorWorkspacePanelPresentationState& panelState : state.panelStates) {
+        if (panelState.panelId == panelId) {
+            return &panelState;
+        }
+    }
+
+    return nullptr;
+}
+
+UIEditorWorkspacePanelPresentationState* FindMutablePanelStateImpl(
+    UIEditorWorkspaceComposeState& state,
+    std::string_view panelId) {
+    for (UIEditorWorkspacePanelPresentationState& panelState : state.panelStates) {
+        if (panelState.panelId == panelId) {
+            return &panelState;
+        }
+    }
+
+    return nullptr;
+}
+
+bool SupportsExternalViewportPresentation(
+    const UIEditorPanelRegistry& panelRegistry,
+    const UIEditorWorkspacePanelPresentationModel& presentation) {
+    if (presentation.kind != UIEditorPanelPresentationKind::ViewportShell) {
+        return false;
+    }
+
+    const UIEditorPanelDescriptor* descriptor =
+        FindUIEditorPanelDescriptor(panelRegistry, presentation.panelId);
+    return descriptor != nullptr &&
+        descriptor->presentationKind == UIEditorPanelPresentationKind::ViewportShell;
+}
+
+UIEditorWorkspacePanelPresentationState& EnsurePanelState(
+    UIEditorWorkspaceComposeState& state,
+    std::string_view panelId) {
+    for (UIEditorWorkspacePanelPresentationState& panelState : state.panelStates) {
+        if (panelState.panelId == panelId) {
+            return panelState;
+        }
+    }
+
+    UIEditorWorkspacePanelPresentationState panelState = {};
+    panelState.panelId = std::string(panelId);
+    state.panelStates.push_back(std::move(panelState));
+    return state.panelStates.back();
+}
+
+void ResetHiddenViewportPresentationState(
+    UIEditorWorkspaceComposeState& state,
+    std::string_view panelId) {
+    UIEditorWorkspacePanelPresentationState* panelState =
+        FindMutablePanelStateImpl(state, panelId);
+    if (panelState == nullptr) {
+        return;
+    }
+
+    panelState->viewportShellState = {};
+}
+
+void TrimObsoleteViewportPresentationStates(
+    UIEditorWorkspaceComposeState& state,
+    const UIEditorPanelRegistry& panelRegistry,
+    const std::vector<UIEditorWorkspacePanelPresentationModel>& presentations) {
+    state.panelStates.erase(
+        std::remove_if(
+            state.panelStates.begin(),
+            state.panelStates.end(),
+            [&](const UIEditorWorkspacePanelPresentationState& panelState) {
+                for (const UIEditorWorkspacePanelPresentationModel& presentation : presentations) {
+                    if (presentation.panelId == panelState.panelId &&
+                        SupportsExternalViewportPresentation(panelRegistry, presentation)) {
+                        return false;
+                    }
+                }
+
+                return true;
+            }),
+        state.panelStates.end());
+}
+
+const ::XCEngine::UI::UIRect* FindVisiblePanelBodyRect(
+    const Widgets::UIEditorDockHostLayout& layout,
+    std::string_view panelId) {
+    for (const auto& panel : layout.panels) {
+        if (panel.panelId == panelId) {
+            return &panel.frameLayout.bodyRect;
+        }
+    }
+
+    for (const auto& tabStack : layout.tabStacks) {
+        if (tabStack.selectedPanelId == panelId) {
+            return &tabStack.contentFrameLayout.bodyRect;
+        }
+    }
+
+    return nullptr;
+}
+
+} // namespace
+
+const UIEditorWorkspacePanelPresentationModel* FindUIEditorWorkspacePanelPresentationModel(
+    const std::vector<UIEditorWorkspacePanelPresentationModel>& presentations,
+    std::string_view panelId) {
+    for (const UIEditorWorkspacePanelPresentationModel& presentation : presentations) {
+        if (presentation.panelId == panelId) {
+            return &presentation;
+        }
+    }
+
+    return nullptr;
+}
+
+const UIEditorWorkspacePanelPresentationState* FindUIEditorWorkspacePanelPresentationState(
+    const UIEditorWorkspaceComposeState& state,
+    std::string_view panelId) {
+    return FindPanelStateImpl(state, panelId);
+}
+
+const UIEditorWorkspaceViewportComposeRequest* FindUIEditorWorkspaceViewportPresentationRequest(
+    const UIEditorWorkspaceComposeRequest& request,
+    std::string_view panelId) {
+    for (const UIEditorWorkspaceViewportComposeRequest& viewportRequest : request.viewportRequests) {
+        if (viewportRequest.panelId == panelId) {
+            return &viewportRequest;
+        }
+    }
+
+    return nullptr;
+}
+
+const UIEditorWorkspaceViewportComposeFrame* FindUIEditorWorkspaceViewportPresentationFrame(
+    const UIEditorWorkspaceComposeFrame& frame,
+    std::string_view panelId) {
+    for (const UIEditorWorkspaceViewportComposeFrame& viewportFrame : frame.viewportFrames) {
+        if (viewportFrame.panelId == panelId) {
+            return &viewportFrame;
+        }
+    }
+
+    return nullptr;
+}
+
+UIEditorWorkspaceComposeRequest ResolveUIEditorWorkspaceComposeRequest(
+    const ::XCEngine::UI::UIRect& bounds,
+    const UIEditorPanelRegistry& panelRegistry,
+    const UIEditorWorkspaceModel& workspace,
+    const UIEditorWorkspaceSession& session,
+    const std::vector<UIEditorWorkspacePanelPresentationModel>& presentations,
+    const Widgets::UIEditorDockHostState& dockHostState,
+    const Widgets::UIEditorDockHostMetrics& dockHostMetrics) {
+    UIEditorWorkspaceComposeRequest request = {};
+    request.dockHostLayout = BuildUIEditorDockHostLayout(
+        bounds,
+        panelRegistry,
+        workspace,
+        session,
+        dockHostState,
+        dockHostMetrics);
+
+    for (const UIEditorWorkspacePanelPresentationModel& presentation : presentations) {
+        if (!SupportsExternalViewportPresentation(panelRegistry, presentation)) {
+            continue;
+        }
+
+        const auto* bodyRect = FindVisiblePanelBodyRect(request.dockHostLayout, presentation.panelId);
+        if (bodyRect == nullptr) {
+            continue;
+        }
+
+        UIEditorWorkspaceViewportComposeRequest viewportRequest = {};
+        viewportRequest.panelId = presentation.panelId;
+        viewportRequest.bounds = *bodyRect;
+        viewportRequest.viewportShellRequest = ResolveUIEditorViewportShellRequest(
+            *bodyRect,
+            presentation.viewportShellModel.spec);
+        request.viewportRequests.push_back(std::move(viewportRequest));
+    }
+
+    return request;
+}
+
+UIEditorWorkspaceComposeFrame UpdateUIEditorWorkspaceCompose(
+    UIEditorWorkspaceComposeState& state,
+    const ::XCEngine::UI::UIRect& bounds,
+    const UIEditorPanelRegistry& panelRegistry,
+    const UIEditorWorkspaceModel& workspace,
+    const UIEditorWorkspaceSession& session,
+    const std::vector<UIEditorWorkspacePanelPresentationModel>& presentations,
+    const std::vector<::XCEngine::UI::UIInputEvent>& inputEvents,
+    const Widgets::UIEditorDockHostState& dockHostState,
+    const Widgets::UIEditorDockHostMetrics& dockHostMetrics) {
+    UIEditorWorkspaceComposeFrame frame = {};
+    frame.dockHostLayout = BuildUIEditorDockHostLayout(
+        bounds,
+        panelRegistry,
+        workspace,
+        session,
+        dockHostState,
+        dockHostMetrics);
+    TrimObsoleteViewportPresentationStates(state, panelRegistry, presentations);
+
+    for (const UIEditorWorkspacePanelPresentationModel& presentation : presentations) {
+        if (!SupportsExternalViewportPresentation(panelRegistry, presentation)) {
+            continue;
+        }
+
+        const auto* bodyRect = FindVisiblePanelBodyRect(frame.dockHostLayout, presentation.panelId);
+        if (bodyRect == nullptr) {
+            ResetHiddenViewportPresentationState(state, presentation.panelId);
+            continue;
+        }
+
+        UIEditorWorkspacePanelPresentationState& panelState =
+            EnsurePanelState(state, presentation.panelId);
+
+        UIEditorWorkspaceViewportComposeFrame viewportFrame = {};
+        viewportFrame.panelId = presentation.panelId;
+        viewportFrame.bounds = *bodyRect;
+        viewportFrame.viewportShellModel = presentation.viewportShellModel;
+        viewportFrame.viewportShellFrame = UpdateUIEditorViewportShell(
+            panelState.viewportShellState,
+            *bodyRect,
+            presentation.viewportShellModel,
+            inputEvents);
+        frame.viewportFrames.push_back(std::move(viewportFrame));
+    }
+
+    return frame;
+}
+
+std::vector<std::string> CollectUIEditorWorkspaceComposeExternalBodyPanelIds(
+    const UIEditorWorkspaceComposeFrame& frame) {
+    std::vector<std::string> panelIds = {};
+    panelIds.reserve(frame.viewportFrames.size());
+    for (const UIEditorWorkspaceViewportComposeFrame& viewportFrame : frame.viewportFrames) {
+        panelIds.push_back(viewportFrame.panelId);
+    }
+    return panelIds;
+}
+
+void AppendUIEditorWorkspaceCompose(
+    ::XCEngine::UI::UIDrawList& drawList,
+    const UIEditorWorkspaceComposeFrame& frame,
+    const Widgets::UIEditorDockHostPalette& dockHostPalette,
+    const Widgets::UIEditorDockHostMetrics& dockHostMetrics) {
+    AppendUIEditorDockHostBackground(
+        drawList,
+        frame.dockHostLayout,
+        dockHostPalette,
+        dockHostMetrics);
+
+    for (const UIEditorWorkspaceViewportComposeFrame& viewportFrame : frame.viewportFrames) {
+        AppendUIEditorViewportSlotBackground(
+            drawList,
+            viewportFrame.viewportShellFrame.slotLayout,
+            viewportFrame.viewportShellModel.spec.toolItems,
+            viewportFrame.viewportShellModel.spec.statusSegments,
+            viewportFrame.viewportShellFrame.slotState);
+        AppendUIEditorViewportSlotForeground(
+            drawList,
+            viewportFrame.viewportShellFrame.slotLayout,
+            viewportFrame.viewportShellModel.spec.chrome,
+            viewportFrame.viewportShellModel.frame,
+            viewportFrame.viewportShellModel.spec.toolItems,
+            viewportFrame.viewportShellModel.spec.statusSegments,
+            viewportFrame.viewportShellFrame.slotState);
+    }
+
+    UIEditorDockHostForegroundOptions foregroundOptions = {};
+    foregroundOptions.externalBodyPanelIds =
+        CollectUIEditorWorkspaceComposeExternalBodyPanelIds(frame);
+    AppendUIEditorDockHostForeground(
+        drawList,
+        frame.dockHostLayout,
+        foregroundOptions,
+        dockHostPalette,
+        dockHostMetrics);
+}
+
+} // namespace XCEngine::UI::Editor

new_editor/src/Widgets/UIEditorDockHost.cpp

@@ -51,6 +51,15 @@ bool IsPointInsideRect(
         point.y <= rect.y + rect.height;
 }
 
+bool UsesExternalBodyPresentation(
+    const UIEditorDockHostForegroundOptions& options,
+    std::string_view panelId) {
+    return std::find(
+               options.externalBodyPanelIds.begin(),
+               options.externalBodyPanelIds.end(),
+               panelId) != options.externalBodyPanelIds.end();
+}
+
 bool IsPanelOpenAndVisible(
     const UIEditorWorkspaceSession& session,
     std::string_view panelId) {
@@ -740,6 +749,7 @@ void AppendUIEditorDockHostBackground(
 void AppendUIEditorDockHostForeground(
     UIDrawList& drawList,
     const UIEditorDockHostLayout& layout,
+    const UIEditorDockHostForegroundOptions& options,
     const UIEditorDockHostPalette& palette,
     const UIEditorDockHostMetrics& metrics) {
     for (const UIEditorDockHostPanelLayout& panel : layout.panels) {
@@ -755,6 +765,9 @@ void AppendUIEditorDockHostForeground(
             text,
             palette.panelFramePalette,
             metrics.panelFrameMetrics);
+        if (UsesExternalBodyPresentation(options, panel.panelId)) {
+            continue;
+        }
         AppendPlaceholderText(
             drawList,
             panel.frameLayout.bodyRect,
@@ -801,6 +814,9 @@ void AppendUIEditorDockHostForeground(
             }
         }
 
+        if (UsesExternalBodyPresentation(options, tabStack.selectedPanelId)) {
+            continue;
+        }
         AppendPlaceholderText(
             drawList,
             tabStack.contentFrameLayout.bodyRect,
@@ -812,6 +828,35 @@ void AppendUIEditorDockHostForeground(
     }
 }
 
+void AppendUIEditorDockHostForeground(
+    UIDrawList& drawList,
+    const UIEditorDockHostLayout& layout,
+    const UIEditorDockHostPalette& palette,
+    const UIEditorDockHostMetrics& metrics) {
+    AppendUIEditorDockHostForeground(
+        drawList,
+        layout,
+        UIEditorDockHostForegroundOptions{},
+        palette,
+        metrics);
+}
+
+void AppendUIEditorDockHost(
+    UIDrawList& drawList,
+    const UIRect& bounds,
+    const UIEditorPanelRegistry& panelRegistry,
+    const UIEditorWorkspaceModel& workspace,
+    const UIEditorWorkspaceSession& session,
+    const UIEditorDockHostState& state,
+    const UIEditorDockHostForegroundOptions& foregroundOptions,
+    const UIEditorDockHostPalette& palette,
+    const UIEditorDockHostMetrics& metrics) {
+    const UIEditorDockHostLayout layout =
+        BuildUIEditorDockHostLayout(bounds, panelRegistry, workspace, session, state, metrics);
+    AppendUIEditorDockHostBackground(drawList, layout, palette, metrics);
+    AppendUIEditorDockHostForeground(drawList, layout, foregroundOptions, palette, metrics);
+}
+
 void AppendUIEditorDockHost(
     UIDrawList& drawList,
     const UIRect& bounds,
@@ -821,10 +866,16 @@ void AppendUIEditorDockHost(
     const UIEditorDockHostState& state,
     const UIEditorDockHostPalette& palette,
     const UIEditorDockHostMetrics& metrics) {
-    const UIEditorDockHostLayout layout =
-        BuildUIEditorDockHostLayout(bounds, panelRegistry, workspace, session, state, metrics);
-    AppendUIEditorDockHostBackground(drawList, layout, palette, metrics);
-    AppendUIEditorDockHostForeground(drawList, layout, palette, metrics);
+    AppendUIEditorDockHost(
+        drawList,
+        bounds,
+        panelRegistry,
+        workspace,
+        session,
+        state,
+        UIEditorDockHostForegroundOptions{},
+        palette,
+        metrics);
 }
 
 } // namespace XCEngine::UI::Editor::Widgets