Editor Overview

Owns the editor's state and its panels. Its frame runs on Encoder before each render.

• Panel registration via AddPanel<T>(...)
• Scene load/save (LoadScene, SaveToFile)
• Entity spawn/delete via the engine spawn handshake
• Prefab instantiation (SpawnPrefab)
• Undo/redo stack (max 50 commands, merge-capable)
• PIE lifecycle (StartPIE, StopPIE)
• Scene snapshot/restore for play/stop cycles
• The scene view (SceneView): picking, camera controls, the gizmo, prefab drops
• File drag-drop handling

Writing a panel

A panel is GG-UI content in a dock panel. Three rules keep it short and current:

• Watch once, at the top. ui.Watch(Changed) covers everything built inside: tabs, split panes, popups. A panel that shows editor state also watches editor.Changes().
• Change the editor with Do. Handlers run in the UI update, where the editor and the engine aren't theirs to change. editor.Do([](EditorContext& Editor) { editor.SaveScene(); }) runs on Encoder before the next frame and then moves Changes(), so nothing is bumped by hand.
• Find what a handler changes by a stable ID, not an index: tabs close and reorder between the build and the click. The type editors keep their documents as unique_ptrs with an ID and change them through Edit(id, fn), which does nothing if the document has closed.

void Build(UI& ui, EditorContext& editor)
{
    ui.Watch(editor.Changes());
    ui.Button("Editor.Scene.Save", [&editor] { editor.Do([](EditorContext& e) { e.SaveScene(); }); });
}

Transient per-frame state shared across all panels. Lives on the render thread — no synchronization required.

Outliner (

What is in the edit world, as a tree: By Owner (each Construct with the entities its views made, then the entities nothing owns, by archetype) or By Type (every entity, by archetype). A name filter. Its selection is the editor's, both ways: picking rows selects in the viewport (Ctrl and Shift for several), and selecting in the viewport selects and reveals the rows. Double click frames; right click has Frame, Drop to Floor, Duplicate and Delete. A prefab dropped on it is placed. The outline is rebuilt when the world's shape changes, and once a second.

Not yet: parenting and attachments (the engine has none yet); prefab instances; renaming entities (they have no names).

Details (

What is selected. Entities: a property grid over their components (EntityFields), several selected edited together as one undo step, with a field filter. Asset references (mesh, material, skeleton, animation) are picked by name from the loaded assets of their type. An archetype: its components and their tiers. A Construct: its type and ID. While the simulation runs a warning says values change under you.

Not yet: Construct fields; picking an asset that isn't loaded; materials (no material manager, so there is nothing to list); dropping an asset on a field.

Content Browser (

The project's content and src folders as a tree. Content: tiles (sized by a slider) or a list, a search, a type filter, breadcrumbs, Import. Double click opens a level or a prefab; right click renames, deletes, or creates a folder, level, prefab or data asset. Source: the headers in a folder and whether each is a Construct, Entity or Component; double click opens the Construct or Entity editor; right click creates one. An asset is dragged as its AssetID: a prefab onto the viewport (shown where it would land) or the outliner. Folders are read when the panel first shows, after it changes them, and on Refresh.

Not yet: thumbnails; moving assets between folders; tiles for very large folders are all built (no virtualisation).

Engine Stats (

The Brain and the Encoder against their budgets (the fixed step, and the display's refresh); the simulation's health, bound to EngineStats (Sentinel rate, how far behind real time, rollbacks, frame age, GPU frame time from timestamps, UI primitives); the edit world's entities; the GPU (device, driver, Vulkan version, video memory used and budget, from VK_EXT_memory_budget where the driver has it); the engine configuration.

Log (

The logger's recent lines, filtered by level, channel (Engine, Game, UI) and text. Clear hides what is there so far. A command line runs TnxConsole commands. Lines are numbered so a filter change never reuses one.

Node graphs (

The graphs in the Construct and Entity editors: a tick slot's or a TNXFUNC method's, and an entity type's spawn initializer. A NodeGraphCanvas holds a graph's nodes and wires; Build shows it with ui.Graph and makes each gesture one step of the graph's own undo, which Undo and Redo use while focus is in the graph. A right click opens a searchable menu of node kinds (events, flow, properties, maths, logic, vectors, entity, input, variables, values), placed where it was opened. Wires join only pins of matching kinds (exec to exec, a value to the same type, Int into Float, anything to Any); an in pin takes one wire. Copy and paste work across graphs.

Component Generator (

A component's name, storage tier, system group and fields, with the header it makes shown as it is edited. Export writes the header; Register as Script registers it at once as a script component (stored per entity, no SIMD, no rollback) until the header is compiled in. Emits the tier's macro (TNX_TEMPORAL_FIELDS / TNX_VOLATILE_FIELDS / TNX_REGISTER_FIELDS).

Construct, Entity and Prefab editors

A tab per open type or file. Opening one from the Content Browser brings its editor to the front (EditorPanel::AskShown).

• Construct Editor: views and owned members; a graph per tick slot and per TNXFUNC method, parsed from the source by TrinyxParser; node counts.
• Entity Editor: the type's components, picked from the registered ones; its spawn graph.
• Prefab Editor: an entity prefab's values in the same property grid as Details (PrefabFields, over the prefab's JSON; a field it doesn't name is zero, its default), a Construct prefab's named defaults, Save and Revert, and a live preview, framed to fit, to orbit and zoom. Each open prefab has its own undo: while focus is in the panel, Undo and Redo are the prefab's (a command nearest the focus wins), otherwise the scene's. One edit in the grid is one step; typing on in one field is one step; Revert is a step too.
• Prefabs are centred. Save Prefab leaves out the position (PosX/Y/Z, VisPosX/Y/Z): a prefab is placed where it is spawned. Rotation and scale are kept. The preview centres older prefabs that still have one.

Not yet: generating a Construct's or an entity type's header from its graphs. Their parts (values, graphs, preview) are splits inside one panel; they are to become dock panels that follow the tab in front, as the widget designer's are, so every tool's parts can be arranged and saved in layouts.

Widget Designer (

Widget assets (.tnxwidget) edited as their files and shown as they will look (Widgets). Opening one from the Content Browser brings up the UI workspace.

• Widget Designer: a tab per open asset. A HUD is shown on a screen, chosen from presets of common devices or set as a size in pixels and a DPI, and turned round; any other asset in an area of a size you set. The canvas is a document of its own (ui.Document) built from the host's preview library, which holds the asset as it stands in the designer; the running game builds from the saved files only.
• Widget Problems: what loading the asset as it stands reports, and what building it on the canvas reports.
• Saving writes the outline layout (GGWriteWidgetFile), keeping the keys' order and the file's comments, with the editor's safe writes. Each asset has its own undo while focus is in the designer. Unsaved assets are in the exit question, Save All, and autosave, as prefabs are (EditorDocuments).
• Widget Hierarchy: the asset's elements as a tree, with the asset each use uses. Drag rows to reorder and reparent them. A row's menu, or the keys while focus is in the designer: Rename (F2, typed in place, and what names it in animations and triggers follows), Duplicate (Ctrl+D), Copy, Cut, Paste (Ctrl+C, X, V: copies get names of their own, and the text goes to the clipboard too), Delete, Wrap With, Replace With, and Turn Comment into Note.
• Widget Palette: the element types and the widget assets (the engine's, then the project's), searchable. Drag one onto a hierarchy row (before, in, or after it) or onto the canvas (into what is under the pointer, or after it), or click it to add it where the selection is.
• Zoom and pan: the wheel zooms the canvas about the pointer, a middle or right drag pans it; Fit (or F) shows it whole again, and 1:1 shows the asset's units at the editor's. Text is shaped for the size it is drawn at, so it stays sharp zoomed in.
• Selecting on the canvas: what the pointer is over is outlined, and a press selects it, with the hierarchy. The canvas's document tags each node with the element that built it (UIContext::SetTagsElements).
• The edits are GGWidgetFile operations on the file's JSON (UIWidgetFile.h), each one undo step.
• What it is shown on is kept in editor/previews/<asset ID>.json in the project, never in the asset.
• TNX_EDITOR_OPEN=<file>;<file#Element> opens widget assets at start (selecting an element), TNX_DESIGNER_SELFTEST=<a copy of an asset> works the designer's edits, undo, and saving through it and logs each check, and TNX_SCREENSHOT=<file.bmp> writes what the window shows after TNX_SCREENSHOT_FRAME frames (300 by default): for checking it without driving the desktop.

Not yet: Details, Inputs and Contexts (8c), Styles and Cost (8d), Animation (8e), canvas tools (8f).

Debugger (

Network: active channels, dirty entities, state correction and entity delta bytes per dispatch and their ratio, with 120-sample graphs (drawn on a canvas). The last session's numbers stay after it stops. Profiler: the fixed step and the logic frame, with their history against the budget. Render Debug (builds with TNX_DEBUG_RENDERING): the debug draw mode.