xuanchi/XCEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3968083da747a9bc7122842c12a05e3e40080b60
XCEngine/docs/plan/XCUI_Phase_Status_2026-04-05.md

39 KiB
Raw Blame History

XCUI Phase Status 2026-04-05

Scope

Current execution stays inside the XCUI module and new_editor. Old editor replacement is explicitly out of scope for this phase.

Latest Checkpoint

  • Phase 1 sandbox batch committed and pushed as 67a28bd (Add XCUI new editor sandbox phase 1).
  • Phase 2 common/runtime batch committed and pushed as ade5be3 (Add XCUI runtime screen layer and demo textarea).
  • Phase 3 has now produced a stable mixed batch across common/runtime/editor:
    • schema document definition data is now retained on UIDocumentModel and round-trips through the UI artifact path
    • schema self-definition validation is now stricter around enum/document-only metadata combinations
    • engine runtime coverage was tightened again around UISystem and concrete document-host rendering
    • LayoutLab continues as the editor widget proving ground for tree/list/property-section style controls
    • the demo sandbox and editor bridge APIs were tightened again without touching the old editor replacement scope
    • new_editor now has an explicit two-step window compositor seam through IWindowUICompositor / ImGuiWindowUICompositor, layered on top of IEditorHostCompositor / ImGuiHostCompositor
  • The native-host / hosted-preview publication follow-up is now landed in new_editor:
    • NativeWindowUICompositor is now buildable alongside the legacy ImGui compositor
    • Application now defaults to a native XCUI host path instead of creating the ImGui shell by default
    • the native default path now drives XCUIDemoRuntime and XCUILayoutLabRuntime directly, composes their UIDrawData, and submits one swapchain packet through the native compositor
    • the native compositor now publishes hosted-preview textures as SRV-backed UITextureRegistration / UITextureHandle values instead of relying on ImGui-only descriptor semantics
    • the native shell now begins the hosted-preview queue/registry lifecycle each frame, queues native preview frames, drains them during the native render pass, and consumes published hosted-surface images directly in panel cards with live/warming placeholder states
    • the old ImGui shell path remains present as an explicit compatibility host instead of the default host
    • XCUIInputBridge.h no longer drags imgui.h through the public XCUI input seam
  • The default native text path is now also de-ImGuiized inside new_editor:
    • XCUIStandaloneTextAtlasProvider now builds and owns its atlas through a Windows/GDI raster path instead of using ImGui font-atlas internals
    • the standalone atlas provider now exposes both RGBA32 and Alpha8 views, supports non-nominal size resolution, lazily adds non-prebaked BMP glyphs, and falls back to ? when a glyph cannot be rasterized
  • The default native shell path now also has a cleaner translation-unit seam:
    • legacy ImGui shell chrome / HUD rendering now lives in a dedicated legacy-only Application translation unit instead of keeping direct ImGui::* calls inside the main native host TU
    • Application.cpp no longer directly includes <imgui.h>, even though the compatibility host path is still compiled into new_editor
  • The new_editor build now also has an explicit compatibility-source slice:
    • legacy ImGui shell sources and vendored ImGui backend sources are now grouped into a dedicated compatibility static library instead of being compiled directly as part of the main XCNewEditor source list
  • The main-target header-isolation milestone is now also landed in new_editor:
    • XCNewEditor drops direct ${IMGUI_SOURCE_DIR} / ${IMGUI_SOURCE_DIR}/backends include-directory requirements
    • the generated XCNewEditor.vcxproj no longer advertises imgui-src or editor/src on the default include surface
    • the default native compile path no longer reaches <imgui.h> through editor/src/UI/ImGuiBackendBridge.h or equivalent bridge headers
    • XCNewEditorImGuiCompat remains the explicit compatibility-only consumer of legacy ImGui headers and backend sources
  • The compositor/font compat boundary is now tighter as well:
    • IWindowUICompositor.h and IEditorHostCompositor.h no longer declare CreateImGui* factories on the generic XCUI seam
    • ImGui factory entry points now live only in LegacyImGuiHostInterop.h
    • XCUIEditorFontSetup.h no longer exposes ImFont / ImFontAtlas; the public API is now a current-context font bootstrap helper
    • XCUIStandaloneTextAtlasProvider.h no longer depends on the ImGui-oriented font bootstrap header
  • The generic shell command/state boundary is now narrower as well:
    • XCUIShellChromeState no longer carries the legacy host demo-window toggle or command id on the generic shell-state surface
    • Application.h no longer exposes that legacy demo command through generic ShellCommandIds, ShellCommandBindings, or RegisterShellViewCommands(...)
    • the legacy demo window toggle now lives as a compatibility-only command inside ApplicationLegacyImGui.cpp
    • Application.h now also uses backend-neutral compatibility-host naming for the non-native window-host path, so the generic application header no longer names LegacyImGui in its mode enum or private host-frame method declarations
    • generic Application host-mode/member naming is now also shifting from LegacyImGui toward CompatibilityHost, so the default shell surface does not have to encode ImGui into every host-facing method name
  • Old editor replacement remains deferred; all active execution still stays inside XCUI shared code and new_editor.

Three-Layer Status

1. Common Core

  • UI::DrawData, input event types, focus routing, style/theme resolution are in active use.
  • UIDocumentCompiler is buildable again after repairing the duplicated schema helper regression introduced by overlapping schema work.
  • UIDocumentModel / UIDocumentResource now retain schema definition metadata explicitly, including memory accounting and UISchema accessors.
  • .xcschema round-trip coverage is now present through compile, loader, artifact write, and artifact read paths.
  • Build-system hardening for MSVC/PDB output paths has started in root CMake, engine/CMakeLists.txt, new_editor/CMakeLists.txt, and tests/NewEditor/CMakeLists.txt.
  • Shared engine-side XCUI runtime scaffolding is now present under engine/include/XCEngine/UI/Runtime and engine/src/UI/Runtime.
  • Shared engine-side UIDocumentScreenHost now compiles .xcui / .xctheme screen documents into a runtime-facing document host path instead of leaving all document ownership in new_editor.
  • Shared text-editing primitives now live under engine/include/XCEngine/UI/Text and engine/src/UI/Text, so UTF-8 caret movement, line splitting, and multiline navigation are no longer trapped inside XCUI Demo.
  • Shared text-input controller/state now also lives under engine/include/XCEngine/UI/Text and engine/src/UI/Text, so character insertion, backspace/delete, submit, and multiline key handling no longer need to be reimplemented per host.
  • Shared editor collection primitive classification and metric helpers now also live under engine/include/XCEngine/UI/Widgets and engine/src/UI/Widgets, covering the current ScrollView / TreeView / ListView / PropertySection / FieldRow prototype taxonomy.
  • Shared single-selection state now also lives under engine/include/XCEngine/UI/Widgets and engine/src/UI/Widgets as UISelectionModel, so collection-style widget selection no longer has to stay private to LayoutLab.
  • Shared expansion state now also lives under engine/include/XCEngine/UI/Widgets and engine/src/UI/Widgets as UIExpansionModel, so collapsible tree/property-style widget state no longer has to stay private to LayoutLab.
  • Shared keyboard-navigation state now also lives under engine/include/XCEngine/UI/Widgets and engine/src/UI/Widgets as UIKeyboardNavigationModel, so list/tree/property-style widgets can share current-index, anchor, and home/end/step navigation rules instead of re-rolling them per sandbox.
  • Shared property-edit session state now also lives under engine/include/XCEngine/UI/Widgets and engine/src/UI/Widgets as UIPropertyEditModel, so editor-facing field rows can reuse begin/edit/commit/cancel transaction state instead of baking that directly into sandbox runtimes.
  • Core regression coverage now includes UIContext, layout, style, runtime screen player/system, and real document-host tests through core_ui_tests.

Current gap:

  • Minimal schema self-definition support is landed, including consistency checks for enum/document-only schema metadata, but schema-driven validation for .xcui / .xctheme instances is still not implemented.
  • Shared widget/runtime instantiation is still thin and mostly editor-side.
  • Common widget primitives are still incomplete: shared text-input presentation/composition on top of the new text controller, multi-selection/focus-traversal/virtualized collection state on top of the new editor-primitive helpers, shared scroll/navigation-scope/caret-layout helpers, and promotion of the current native text-atlas path into a shared/cross-platform text subsystem.

2. Runtime/Game Layer

  • The main concrete progress here is that the retained-mode demo runtime now supports a real TextField input path with UTF-8 text entry and backspace handling.
  • The demo runtime has moved past single-line input: multiline TextArea behavior is now covered in the sandbox testbed.
  • Engine-side runtime ownership is no longer zero: UIScreenPlayer, UIDocumentScreenHost, and UISystem now define a shared runtime contract for loading a screen document, ticking it with input, and collecting UI::UIDrawData.
  • UISystem now supports layered screen composition semantics: stacked screen players, top-interactive input routing, and modal layers that block lower screens.
  • UIScreenStackController::ReplaceTop now preserves the previous top screen if the replacement screen fails to load, so runtime menu flows do not silently drop their active layer on bad assets.
  • SceneRuntime now owns a dedicated UISceneRuntimeContext, so game/runtime code has a first-class place to configure viewport/focus, queue UIInputEvents, drive UISystem each Update, and inspect the latest UI frame result.
  • Runtime screen emission now also carries concrete button text in the shared document host path instead of silently dropping button labels.
  • UISystemFrameResult now also preserves viewport rect, submitted input count, frame delta, and focus state, and both UISystem and UISceneRuntimeContext now expose ConsumeLastFrame() so runtime/game hosts can drain the last retained frame packet without copying editor-side concepts into the shared layer.
  • UIScreenPlayer now also exposes ConsumeLastFrame(), so player/system/context all share the same consume-vs-borrow frame ownership semantics in the runtime layer.

Current gap:

  • Runtime UI is now wired into SceneRuntime, but render submission is still limited to producing UIDrawData; there is no game-view/runtime presenter path that automatically draws those frames yet.
  • The runtime widget library is still shallow and missing the editor-grade controls that will later be shared downward.

3. Editor Layer

  • new_editor remains the isolated XCUI sandbox.
  • Native hosted preview is now working end-to-end as RHI offscreen surface -> SRV-backed publication -> hosted surface image present through the native shell path.
  • Hosted preview surface descriptors now stay on XCUI-owned value types (UITextureHandle, UIPoint, UIRect) instead of exposing ImGui texture/UV types through the generic preview contract.
  • Shared UI::UIDrawData image commands now carry explicit uvMin / uvMax source-rect semantics, and the native panel canvas host preserves those UVs when it records hosted surface-image preview commands.
  • XCUI Demo remains the long-lived effect and behavior testbed.
  • XCUI Demo now covers both single-line and multiline text authoring behavior, including click caret placement, delete/backspace, tab indentation, and optional text-area line numbers.
  • XCUI Demo now consumes the shared UITextInputController path for text editing instead of carrying a private key-handling state machine.
  • LayoutLab now includes a ScrollView prototype and a more editor-like three-column authored layout.
  • LayoutLab now also covers editor-facing widget prototypes: TreeView, TreeItem, ListView, ListItem, PropertySection, and FieldRow.
  • LayoutLab now consumes the shared UIEditorCollectionPrimitives helper layer for collection-widget tag classification, clipping flags, and default metric resolution instead of keeping that taxonomy private to the sandbox runtime.
  • LayoutLab now also consumes the shared UISelectionModel for click-selection persistence across collection-style widgets, and the diagnostics panel now exposes both hovered and selected element ids.
  • LayoutLab now also consumes the shared UIExpansionModel for tree expansion and property-section collapse, with reserved property headers, disclosure glyphs, and persisted click-toggle behavior in the sandbox runtime.
  • new_editor now also has an isolated XCUIEditorCommandRouter model with shortcut matching, enable predicates, and direct command invocation semantics covered by dedicated tests, ready for shell-frame integration.
  • XCUI Demo now exports pending per-frame command ids through DrainPendingCommandIds(), so editor-side hosts have a clean seam for observing demo/runtime command traffic without parsing draw data.
  • XCUI Demo and LayoutLab panel canvases are now being pulled behind a dedicated IXCUIPanelCanvasHost seam, so canvas surface presentation, hover/focus fallback state, and overlay draw hooks no longer have to stay hard-coded inside each ImGui panel implementation.
  • The panel-canvas seam now keeps the generic host contract on observable canvas behavior only; backend/capability identity probing has been removed from IXCUIPanelCanvasHost, and the minimal NullXCUIPanelCanvasHost remains the concrete placeholder host for non-ImGui paths.
  • XCUI Demo and LayoutLab panel input now also flows through an explicit IXCUIInputSnapshotSource seam, so panel/runtime code no longer reads ImGuiIO / ImGui::IsKeyPressed / ImGui::IsMouseClicked directly when the shell wants to use an ImGui adapter.
  • new_editor now also has an explicit ImGuiXCUIInputSnapshotSource adapter, keeping ImGui-specific input capture in the host adapter layer instead of inside panel/runtime update code.
  • Panel diagnostics were expanded to clearly separate preview/runtime/input state and native vs legacy paths.
  • The editor bridge layer now has smoke coverage for swapchain after-UI rendering hooks and SRV-backed ImGui texture descriptor registration.
  • Application no longer owns the ImGui backend directly; window presentation now routes through IWindowUICompositor with an ImGuiWindowUICompositor implementation, which currently delegates to IEditorHostCompositor / ImGuiHostCompositor.
  • Hosted preview offscreen surfaces now keep compositor-returned UITextureRegistration / UITextureHandle data inside Application instead of storing ImTextureID directly.
  • The generic hosted-preview presenter contract no longer owns ImGuiTransitionBackend; the ImGui presenter now sits in a separate ImGuiXCUIHostedPreviewPresenter header while the native queue/surface registry remains XCUI-generic.
  • The generic hosted-preview frame contract no longer carries an ImGui draw-list pointer; the legacy ImGui presenter resolves its inline draw target from the active ImGui window context instead of pushing that type through the XCUI contract.
  • The legacy ImGui hosted-preview presenter now also accepts an explicit draw-target binding object, so presenter-side ImGui::GetWindowDrawList() lookup is no longer hard-coded inside the generic presenter path and can stay isolated behind the ImGui adapter layer.
  • Application shell menu toggles and global shortcuts now route through XCUIEditorCommandRouter instead of directly mutating shell booleans from menu callbacks, giving the editor layer a real command-routing seam.
  • LayoutLab runtime now consumes the shared UIKeyboardNavigationModel for abstract list/tree/property navigation actions (previous/next/home/end/collapse/expand), so keyboard collection traversal rules are no longer trapped in sandbox-local state.
  • LayoutLab panel input now also maps concrete arrow/home/end keys into those shared navigation actions, so keyboard traversal is reachable from the sandbox UI instead of staying runtime-only.
  • XCUIDemoRuntime now bridges pointer activation, text-edit commands, and shortcut-triggered commands through a unified command path, and DrainPendingCommandIds() now preserves mixed pointer/text/shortcut ordering.
  • new_editor now also has a pure XCUIShellChromeState model covering panel visibility, hosted-preview mode, and shell-level view toggles without depending on ImGui, Application, or the old editor.
  • XCUIShellChromeState hosted-preview mode naming is now backend-neutral (HostedPresenter / NativeOffscreen) instead of encoding ImGui into the XCUI shell model.
  • The shell chrome view-toggle model no longer carries the legacy host demo window at all on the generic XCUI seam; that command now lives only inside the compatibility-only legacy host implementation.
  • new_editor now also has a concrete NativeWindowUICompositor path and native-focused compositor tests, so the window compositor seam is no longer ImGui-only.
  • Application now also has a native XCUI shell path that:
    • becomes the default new_editor startup path
    • lays out XCUI Demo and Layout Lab as native cards directly in the swapchain window
    • routes shell shortcuts through the same command router without reading ImGui capture state in the default host path
    • drives both sandbox runtimes directly from Win32/XCUI input snapshots instead of routing through ImGui panel hosts
    • composes one native UIDrawData packet and submits it through NativeWindowUICompositor
  • The native shell layout policy now also lives behind XCUINativeShellLayout, so top-bar/footer/workspace geometry, panel split rules, and active-panel transfer on pointer press are no longer hard-coded inline inside Application.cpp.
  • NativeXCUIPanelCanvasHost now backs that direct shell path as an externally driven canvas/session host for native cards instead of assuming an ImGui child-window model, and it now emits native Image draw commands for hosted surface-image previews while preserving per-surface UVs.
  • NativeWindowUICompositor now creates and frees SRV-backed texture registrations for hosted preview surfaces, so native publication no longer depends on ImGui descriptor handles.
  • Application now runs the hosted-preview lifecycle in both legacy and native frame paths, treats published textures as XCUI-owned UITextureHandle state, queues native preview frames from BuildNativeShellDrawData(...), and drains them during native rendering before shell chrome overlays.
  • XCUIInputBridge.h no longer includes imgui.h, so the public XCUI input bridge seam is now host-neutral at the header boundary.
  • XCNewEditor builds successfully to build/new_editor/bin/Debug/XCNewEditor.exe.

Current gap:

  • The default shell host is now native, and the legacy ImGui shell/panel path has been split out of the default executable into the standalone XCNewEditorImGuiCompat compatibility slice.
  • The default native shell path is now split away from direct ImGui::* calls at the main-target header/include level and no longer links the compatibility slice by default.
  • The default native shell now also consumes shared XCUINativeShellLayout and UIEditorPanelChrome helpers for panel split/chrome policy instead of duplicating that card layout logic entirely inside Application.cpp.
  • The native shell currently proves direct runtime composition, but its shell chrome is still a bespoke Application-side layout rather than a fully shared XCUI-authored editor shell document.
  • Editor-specialized widgets are still incomplete at the shared-module level: the authored prototypes exist, but virtualization, multi-selection/focus traversal, toolbar/menu chrome, menu interaction widgets, and icon-atlas widgets are not yet extracted into reusable XCUI modules.
  • The default native text path now uses a standalone Windows/GDI atlas through XCUIStandaloneTextAtlasProvider, but that provider still lives inside new_editor and is not yet promoted into a shared/cross-platform text subsystem.

Validated This Phase

  • new_editor_xcui_demo_panel_tests: 3/3
  • new_editor_xcui_demo_runtime_tests: 12/12
  • new_editor_xcui_input_bridge_tests: 4/4
  • new_editor_imgui_xcui_input_adapter_tests: 2/2
  • new_editor_xcui_layout_lab_runtime_tests: 12/12
  • new_editor_xcui_rhi_command_compiler_tests: 7/7
  • new_editor_xcui_rhi_render_backend_tests: 5/5
  • new_editor_xcui_standalone_text_atlas_provider_tests: 6/6
  • new_editor_xcui_hosted_preview_presenter_tests: 20/20
  • new_editor_legacy_imgui_host_interop_tests: 4/4
  • new_editor_imgui_window_ui_compositor_tests: 7/7
  • new_editor_native_window_ui_compositor_tests: 8/8
  • new_editor_xcui_editor_command_router_tests: 5/5
  • new_editor_application_shell_command_bindings_tests: 11/11
  • new_editor_xcui_shell_chrome_state_tests: 11/11
  • new_editor_xcui_panel_canvas_host_tests: 4/4
  • new_editor_imgui_xcui_panel_canvas_host_tests: 1/1
  • new_editor_native_xcui_panel_canvas_host_tests: 4/4
  • new_editor_xcui_layout_lab_panel_tests: 3/3
  • XCNewEditor Debug target builds successfully
  • XCNewEditor.exe native-default smoke run stayed alive for 5s
  • core_ui_tests: 52 total (50 passed, 2 skipped because KeyCode::Delete currently aliases Backspace)
  • scene_tests: 68/68
  • core_ui_style_tests: 5/5
  • ui_resource_tests: 11/11
  • editor_tests targeted bridge smoke: 3/3

Landed This Phase

  • Demo runtime TextField with UTF-8 text insertion, caret state, and backspace.
  • Demo runtime multiline TextArea path in the sandbox and test coverage for caret movement / multiline input.
  • Common-core UITextEditing extraction now owns UTF-8 offset stepping, codepoint counting, line splitting, and vertical caret motion with dedicated core_ui_tests coverage.
  • Common-core UITextInputController extraction now owns per-field text state, character insertion, enter-submit, and multiline keyboard editing behavior with dedicated core_ui_tests coverage.
  • Common-core UIEditorCollectionPrimitives extraction now owns the editor collection tag taxonomy and default metric resolution used by current LayoutLab widget prototypes, with dedicated core_ui_tests coverage.
  • Common-core UISelectionModel extraction now owns reusable single-selection state for collection-style widgets, with dedicated core_ui_tests coverage.
  • Common-core UIExpansionModel extraction now owns reusable expansion/collapse state for tree/property-style widgets, with dedicated core_ui_tests coverage.
  • Common-core UIKeyboardNavigationModel extraction now owns reusable current-index/anchor navigation state for collection-style widgets, with dedicated core_ui_tests coverage.
  • Common-core UIPropertyEditModel extraction now owns reusable property-field edit session state, including staged values and commit/cancel behavior, with dedicated core_ui_tests coverage.
  • Runtime frame ownership was tightened again:
    • UIScreenPlayer::ConsumeLastFrame() now exposes consume-style packet ownership at the player layer
    • UISystemFrameResult now carries viewport rect, submitted input event count, frame delta, and focus state
    • UISystem::ConsumeLastFrame() moves the retained packet out of the runtime layer
    • UISceneRuntimeContext::ConsumeLastFrame() forwards the same shared runtime seam upward
  • Demo runtime text editing was extended with:
    • click-to-place caret
    • Delete support
    • Tab / Shift+Tab indentation for text areas
    • optional text-area line-number gutter rendering
  • Demo authored resources updated to exercise the input field.
  • LayoutLab ScrollView prototype with clipping and hover rejection outside clipped content.
  • LayoutLab editor-widget prototypes for tree/list/property-style sections with dedicated runtime coverage.
  • LayoutLab click-selection now persists through the shared UISelectionModel, including selected-state diagnostics and reusable visual selection feedback on cards, collection rows, and field rows.
  • LayoutLab tree expansion and property-section collapse now persist through the shared UIExpansionModel, including reserved property headers, disclosure glyphs, and runtime coverage for collapsed/expanded visibility.
  • XCUIDemoRuntime now exposes DrainPendingCommandIds() so hosts can observe emitted runtime commands in order across pointer/text interactions without scraping UI text or draw-command payloads.
  • XCUIDemoRuntime command recording was tightened so pointer activation, text editing, and shortcut-triggered commands now share one bridge path and preserve mixed ordering in DrainPendingCommandIds().
  • Schema document support extended with:
    • retained UISchemaDefinition data on UIDocumentModel
    • artifact schema version bump for UI documents
    • loader/resource accessors and memory accounting
    • schema compile/load/artifact regression coverage
    • schema consistency rules for:
      • allowedValues only on enum
      • documentKind / restrictDocumentKind only on document
      • explicit documentKind required when restrictDocumentKind=true
  • Engine runtime layer added:
    • UIScreenPlayer
    • UIDocumentScreenHost
    • UISceneRuntimeContext
    • UIScreenStackController
    • UISystem
    • layered screen composition and modal blocking semantics
  • Runtime/game integration scaffolding now includes reusable HUD/menu/modal stack helpers on top of UISystem.
  • UIScreenStackController replacement now rolls back safely on failure instead of popping the active top layer first.
  • SceneRuntime now exposes XCUI runtime ownership directly:
    • GetUISystem()
    • GetUIScreenStackController()
    • GetLastUIFrame()
    • SetUIViewportRect(...)
    • SetUIFocused(...)
    • QueueUIInputEvent(...)
    • ClearQueuedUIInputEvents()
    • automatic UISystem ticking during SceneRuntime::Update(...)
  • Runtime document-host draw emission now preserves button labels for shared screen rendering.
  • RHI image path improvements:
    • clipped image UV adjustment
    • mirrored image UV preservation
    • explicit image UV/source-rect submission through UI::UIDrawData
    • external texture binding reuse
    • per-batch scissor application
  • Editor bridge helpers now expose:
    • an afterUiRender swapchain callback hook in D3D12WindowRenderer
    • SRV-view based texture descriptor registration in ImGuiBackendBridge
    • smoke tests for window renderer, ImGui backend bridge, and console sink registration
  • new_editor host presentation now has a first-class compositor seam:
    • IWindowUICompositor
    • ImGuiWindowUICompositor
    • IEditorHostCompositor
    • ImGuiHostCompositor
    • Application frame/present flow routed through the compositor instead of direct m_imguiBackend ownership
  • The window-level XCUI compositor seam now also has a dedicated regression target around ImGuiWindowUICompositor, covering initialization, render-frame ordering, Win32 message forwarding, texture registration forwarding, and shutdown safety.
  • The legacy compatibility seam now also has dedicated regression coverage around LegacyImGuiHostInterop, covering compat factory wiring, ImGui input-capture forwarding, legacy font bootstrap, and the disabled demo-window path.
  • The window compositor and hosted-preview seams gained more edge-case coverage around no-UI render passes, compositor re-initialization/rebinding, partial logical-size fallback, and descriptor reuse for repeated queued-frame keys.
  • new_editor now has a dedicated XCUIEditorCommandRouter test target covering command registration, replacement, enable predicates, accelerator matching, and policy gates around focus/keyboard capture/text input.
  • Application now integrates XCUIEditorCommandRouter into the shell itself:
    • View menu items invoke routed commands instead of directly mutating shell state
    • shell-level shortcuts now flow from XCUIWin32InputSource through XCUIInputBridge into command matching
    • hosted-preview mode toggles still trigger presenter reconfiguration through the routed command bindings
  • new_editor panel canvas ownership is now being split behind IXCUIPanelCanvasHost, with an ImGuiXCUIPanelCanvasHost adapter carrying the legacy path so panel code stops directly owning ImGui::Image / ImGui::InvisibleButton / draw-list preview plumbing.
  • XCUIDemoPanel and XCUILayoutLabPanel no longer create an ImGui hosted-preview presenter or ImGui panel canvas host implicitly; default construction now stays on null/explicitly injected backends until the outer shell binds a concrete host adapter.
  • Application now binds ImGuiXCUIPanelCanvasHost explicitly at the shell composition root, so the current ImGui panel host path is visible as a host-layer decision instead of a panel-layer fallback.
  • XCUIDemoPanel and XCUILayoutLabPanel no longer read ImGui input directly; both now consume an injected IXCUIInputSnapshotSource, and the new ImGuiXCUIInputSnapshotSource keeps the current ImGui-backed input path isolated behind an explicit adapter.
  • new_editor now also has a pure XCUIShellChromeState model with dedicated tests, covering shell panel visibility, hosted-preview mode, and shell view toggles without depending on ImGui or Application.
  • XCUIShellChromeState now also exposes effective hosted-preview state helpers and shell view-toggle command-id helpers, so shell routing code no longer has to manually combine enablement and requested preview mode.
  • XCUIShellChromeState hosted-preview modes were renamed away from LegacyImGui, so XCUI shell state no longer treats ImGui as the generic fallback concept.
  • The panel-canvas seam now has dedicated null/compat/native coverage around stable debug names, passive-session safety, externally driven native snapshots, and compat-host factory creation without relying on explicit backend/capability reporting.
  • The native host follow-up is now present in new_editor:
    • NativeWindowUICompositor provides a swapchain-native XCUI packet present path beside the legacy ImGui compositor
    • Application now defaults to that native host path and directly composes XCUI Demo plus Layout Lab into one native shell frame
    • NativeXCUIPanelCanvasHost now drives externally configured native card sessions for that shell path and records hosted surface-image preview commands with preserved UVs
    • new native compositor/native canvas-host tests now cover the new host seam
  • XCUIInputBridge.h no longer includes imgui.h, so XCUI input translation is no longer coupled to ImGui at the public header boundary.
  • SceneRuntime layered XCUI routing now has dedicated regression coverage for:
    • top-interactive layer input ownership
    • blocking/modal layer suppression of lower layers
    • hidden top-layer pass-through back to visible underlying layers
  • Shared UITextInputController coverage now includes more caret-boundary / modifier branches; the remaining Delete distinction stays blocked on KeyCode::Delete and KeyCode::Backspace still sharing the same enum value.
  • Window compositor texture registration now also flows back into Application as XCUI-owned UITextureRegistration / UITextureHandle data instead of exposing raw ImTextureID there.
  • Hosted preview contracts were tightened again:
    • generic preview surface metadata stays on XCUI-owned value types
    • ImGuiTransitionBackend moved behind ImGuiXCUIHostedPreviewPresenter
    • generic preview frame submission no longer carries an ImGui draw-list pointer
    • the ImGui presenter now resolves inline draw targets through an explicit ImGui-only binding seam
    • panel/runtime callers still preserve the same legacy and native-preview behavior
  • Native hosted-preview publication milestone is now wired through the default shell path:
    • NativeWindowUICompositor publishes hosted preview textures as SRV-backed XCUI registrations and frees them through the compositor seam
    • Application::BeginHostedPreviewFrameLifecycle(...) now resets queue/registry state for both legacy and native frame paths
    • hosted-preview surface readiness now keys on published texture availability instead of ImGui-style descriptor validity
    • BuildNativeShellDrawData(...) now queues native preview frames for XCUI Demo / LayoutLab, while shell cards consume the previously published hosted-surface image with warming/live placeholder text
    • native compositor and shell-command tests now cover the new publication / lifecycle guards
  • LayoutLab now resolves editor collection widget taxonomy and metrics through shared UIEditorCollectionPrimitives helpers instead of duplicating the same tag and metric rules inside the sandbox runtime.
  • LayoutLab runtime now consumes shared keyboard-navigation semantics for list/tree/property traversal, while the remaining panel-level key mapping is tracked as an editor-host integration gap rather than a runtime gap.
  • LayoutLab panel now maps concrete arrow/home/end keys into the shared navigation model, with dedicated panel-level coverage proving that the sandbox UI can actually drive the runtime navigation seam end-to-end.
  • new_editor panel/shell diagnostics improvements for hosted preview state.
  • XCUI asset document loading changed to prefer direct source compilation before ResourceManager fallback for the sandbox path, fixing the LayoutLab crash.
  • UIDocumentCompiler.cpp repaired enough to restore full local builds after the duplicated schema-helper regression.
  • MSVC debug build hardening was tightened again so large parallel engine rebuilds stop tripping over compile-PDB contention.
  • XCUIStandaloneTextAtlasProvider no longer uses ImGui font-atlas/internal baking helpers:
    • atlas ownership now stays inside a standalone provider implementation built on Windows/GDI glyph rasterization
    • default editor atlas prewarms the current supported nominal sizes, exposes both RGBA32 and Alpha8 atlas views, lazily inserts non-prebaked BMP glyphs, and falls back to ? for unrasterizable codepoints
    • standalone atlas coverage now includes reset/rebuild, non-nominal size resolution, lazy glyph insertion/fallback behavior, and smoke use without any ImGui context
  • Legacy shell chrome / HUD rendering is now split out of the main Application.cpp translation unit:
    • the direct ImGui::* shell rendering path now lives in a dedicated legacy-only Application implementation file
    • the main Application.cpp native host path no longer directly includes <imgui.h>, reducing default-path compile-time coupling while the remaining main-target header/include cleanup stays open
  • new_editor build composition is now split into main/native and compatibility slices:
    • the main XCNewEditor target no longer compiles legacy ImGui shell/panel/backend source files directly
    • legacy ImGui shell/panel/backend sources plus vendored ImGui sources now build behind a dedicated compatibility static library that the main executable links
    • the main target no longer carries ImGui include directories or older editor bridge headers on its direct compile surface; those remain confined to the compatibility slice
  • The default XCUI compile seam is now also cleaner:
    • generic compositor headers no longer advertise compat-only CreateImGui* factories
    • compat-only host/window compositor factories now live behind LegacyImGuiHostInterop.*
    • public font bootstrap headers no longer leak ImFont / ImFontAtlas types into generic XCUI consumers

Phase Risks Still Open

  • Schema instance validation is still open beyond .xcschema self-definition and artifact round-trip coverage.
  • ScrollView is still authored/static; no wheel-driven scrolling or virtualization yet.
  • XCNewEditor no longer depends on ImGui at the default-path header/include level and no longer links XCNewEditorImGuiCompat; the legacy shell/panel path now lives only in the standalone compatibility slice.
  • Legacy panel implementations such as XCUIDemoPanel / XCUILayoutLabPanel still render as ImGui windows inside the compatibility slice, so editor-layer behavior is not yet fully carried by XCUI-native shell composition.
  • The default native text path now owns its atlas without ImGui, but the provider is still Windows-only and remains trapped inside new_editor instead of a shared/cross-platform text layer.
  • Hosted-preview compatibility presentation still depends on an ImGui-only inline presenter path when not using the queued native surface path.
  • Editor widget coverage is still prototype-driven inside LayoutLab; it has not yet been promoted into a full reusable shared widget/runtime layer with command routing, virtualization, and property-edit transactions.

Execution-Plan Alignment

  • Against XCUI完整架构设计与执行计划.md, current new_editor progress should be treated as an early Phase 8 foothold rather than full Milestone E completion:
    • landed: NativeWindowUICompositor, native shell packet composition, native hosted-preview publication, XCUI-owned texture registrations, native panel surface-image presentation, standalone native text-atlas ownership inside new_editor, legacy Application TU split, XCNewEditorImGuiCompat, main-target header/include isolation from ImGui, default-executable unlinking from the compatibility slice, compat-only factory/font seam tightening, shared native shell layout helpers, and shared panel-chrome/flat-hierarchy helpers
    • not yet landed: promotion of the native text-atlas path into a shared/cross-platform text subsystem, shared XCUI-authored editor shell chrome, and retirement of legacy ImGui-window panel implementations
  • That means the next de-ImGui push should not keep centering on hosted-preview publication; that milestone is now effectively closed for the default native shell path.
  • The real remaining default-path blockers are:
    • move editor-layer behavior off the legacy ImGui-window panel implementations and into native/XCUI shell composition
    • keep compat-only factories/types from drifting back into generic XCUI seams while the compatibility slice remains linked
    • harden and promote XCUIStandaloneTextAtlasProvider / editor font bootstrap into a shared native text subsystem
    • move native shell chrome out of bespoke Application layout code and into a shared XCUI shell model or authored shell document

Next Phase

  1. Expand runtime/game-layer ownership from the current SceneRuntime UI context into scene-declared HUD/menu bootstrapping, draw submission, and higher-level runtime UI policies.
  2. Promote the current editor-facing widget prototypes out of authored LayoutLab content and into reusable XCUI widget/runtime modules, then continue with toolbar/menu chrome, shell-state adoption, virtualization, and broader focus/multi-selection behavior.
  3. Push the remaining de-ImGui cleanup from build/header isolation into behavior isolation: keep ImGui confined to XCNewEditorImGuiCompat, keep generic XCUI seams free of compat-only factories/types, and keep shrinking the legacy shell boundary.
  4. Promote the current standalone native text/font path out of new_editor, harden its atlas invalidation/caching contract, and keep the remaining font/bootstrap ownership compatibility-only.
  5. Promote the native shell chrome and card layout out of bespoke Application code into a shared XCUI/editor-layer shell model or authored shell document, then retire the remaining ImGui-window panel path.
  6. Continue phased validation, commit, push, and plan refresh after each stable batch.
Reference in New Issue View Git Blame Copy Permalink