XCEngine/docs/plan/XCUI_Phase_Status_2026-04-05.md

# 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
  - 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 current editor-host checkpoint additionally hardens the XCUI demo text-editing path and the temporary ImGui host bridge:
  - multiline demo text areas now support pointer caret placement, line-number gutters, and tab indent/unindent behavior
  - the ImGui bridge now accepts existing shader-resource views and the window renderer exposes an after-UI callback seam
- 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`.
- The temporary ImGui bridge can now register an existing shader-resource view directly instead of forcing the caller to recreate a texture SRV from scratch.
- 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, 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: multiline text editing, tree/list virtualization, property-grid composition, and native image/source-rect level APIs.

### 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.
- Runtime screen emission now also carries concrete button text in the shared document host path instead of silently dropping button labels.

Current gap:

- No production game-loop integration has been wired yet from scene/runtime systems into `UISystem`.
- 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 working as `RHI offscreen surface -> ImGui shell texture embed`.
- `XCUI Demo` remains the long-lived effect and behavior testbed.
- `XCUI Demo` now covers both single-line and multiline text authoring behavior, including pointer caret placement, line-number gutters, delete/backspace symmetry, and tab indent/unindent in text areas.
- `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`.
- Panel diagnostics were expanded to clearly separate preview/runtime/input state and native vs legacy paths.
- `XCNewEditor` builds successfully to `build/new_editor/bin/Debug/XCNewEditor.exe`.
- `new_editor` host plumbing now has a narrower swapchain seam via a window-renderer post-ImGui callback, which is the first practical hook for a future window-level compositor split.

Current gap:

- The shell is still ImGui-hosted.
- Editor-specialized widgets are still incomplete at the shared-module level: the authored prototypes exist, but virtualization, selection models, command routing, property editing models, toolbar/menu chrome, and icon-atlas widgets are not yet extracted into reusable XCUI modules.

## Validated This Phase

- `new_editor_xcui_demo_runtime_tests`: `7/7`
- `new_editor_xcui_layout_lab_runtime_tests`: `6/6`
- `new_editor_xcui_rhi_command_compiler_tests`: `6/6`
- `new_editor_xcui_rhi_render_backend_tests`: `5/5`
- `XCNewEditor` Debug target builds successfully
- `core_ui_tests`: `14/14`
- `core_ui_style_tests`: `5/5`
- `ui_resource_tests`: `7/7`
- `editor_tests` targeted XCUI/editor host API smoke cases: `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.
- Demo runtime text editing extended with:
  - pointer-based caret placement for text inputs
  - multiline text-area line-number gutters
  - tab indent / shift-tab unindent
  - delete handling symmetry with backspace
- 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.
- 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
- Engine runtime layer added:
  - `UIScreenPlayer`
  - `UIDocumentScreenHost`
  - `UISystem`
  - layered screen composition and modal blocking semantics
- 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
  - external texture binding reuse
  - per-batch scissor application
- `new_editor` panel/shell diagnostics improvements for hosted preview state.
- ImGui host bridge improvements:
  - existing shader-resource view registration overload
  - swapchain render callback seam after ImGui submission
  - editor-side API smoke coverage for bridge and window renderer accessors
- 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.

## 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.
- `Image` widgets still do not have source-rect/atlas-subregion level API in the high-level draw command model.
- Editor shell still depends on ImGui as host chrome.
- Editor widget coverage is still prototype-driven inside `LayoutLab`; it has not yet been promoted into a reusable shared widget/runtime layer.

## Next Phase

1. Expand schema rules just one level further inside `UIDocumentCompiler.cpp`:
   - `allowedValues` only for `Enum`
   - `documentKind` / `restrictDocumentKind` only for `Document`
   - `restrictDocumentKind=true` requires explicit `documentKind`
2. Expand runtime/game-layer ownership from the current document host + layered `UISystem` into reusable menu/HUD stack patterns and engine runtime integration.
3. Promote the current editor-facing widget prototypes out of authored `LayoutLab` content and into reusable XCUI widget/runtime modules, then continue with toolbar/menu and more native shell-owned chrome.
4. Start the window-level compositor split in `new_editor` so the editor shell can run through `ImGuiHostCompositor` first and then grow a native XCUI compositor path on the same seam.
5. Continue phased validation, commit, push, and plan refresh after each stable batch.