Editor mode, complete

From "usable" to "feels like a real editor"

The day before, the editor could select objects, drag gizmos and save for the first time, taking the first "hands-on" step; but at that point it was more a usable prototype than a mature tool you'd happily spend all day working in. This day's work fills "usable" out into "pleasant": what makes a professional editor feel natural is countless seemingly-trivial yet indispensable things — whether panels arrange to your habits, whether the transform tools are complete, whether a value change shows feedback at once, how fast you can find an object, whether a mistake can be undone. Filling all of these in at once equips the editor with "the full basics a professional tool should have." This isn't piling on features but polishing a tool to the point of "no awkwardness on first use" — and it's exactly that lack of awkwardness that decides whether a creator will use it for the long haul.

Dockable panels: arrange the interface your way, reset in one click

This day wired a dockable panel system into the editor, with a unified panel manager to govern it. What it can do: every panel — scene tree, property inspector, material, timeline, material graph and so on — can be dragged with the mouse to any region to rearrange, can stack several panels into one tab group (drag together to group, click a tab to switch), can pop a panel out into its own floating window to view alone, and if you mess the layout up you can reset to default in one click. Why does this matter? Because different people and different tasks need entirely different layouts: tuning materials you want the material panel enlarged, animating you want the timeline filling the bottom. One hardcoded fixed layout can only ever serve one kind of person; dockable panels hand the decision of "what the interface looks like" back to the user. The same day debuted three new panels — material, timeline and material graph — joined with the existing inspector and scene tree into this system, and the editor's "skeleton" took shape from here.

The full transform toolset: move, rotate, scale

The day before, the only gizmo you could drag was "move"; this day "rotate" and "scale" were filled in, with a set of shortcuts matching industry-standard convention to switch quickly between the three modes — so anyone who has used any professional 3D tool knows how to use it almost without learning. The three transforms are the most basic actions for placing anything: move a crate to the wall (move), set it at an angle (rotate), double its size as an obstacle (scale) — none dispensable. The engine was also made to render an object's rotation correctly, ensuring the pose you see in the viewport exactly matches the data. On top of that, "one-key fly-to-selection" was added — press a key or double-click and the camera smoothly flies over to frame the selected thing in the center, so in a big scene you no longer struggle to find the viewpoint by hand. Completing this most basic toolset and making it intuitive is the dividing line where an editor turns from a "demo" into a "production tool."

See it at once: the inspector refreshes live as you drag

This day also wired up the most crucial feedback loop in editing: the property inspector refreshes live with your dragging in the viewport. That is, as you drag an object with a gizmo, the numbers for position, rotation and scale in the right-hand inspector jump in sync, so you can drag while seeing the exact current values; conversely, this loop also guarantees that when you type a precise value in the panel, the viewport object changes with it at once. This "bidirectional, instant" consistency is the soul of every professional editor — it eliminates the uncertainty of "just how much did that drag change," letting coarse adjustment (dragging gizmos) and fine adjustment (typing values) seamlessly connect. The same day brought a history panel and a capabilities panel: the history panel lets you see and undo each operation you performed, and the capabilities panel surfaces the currently available operations in one place. With live feedback and an undoable history, editing finally becomes "confident and bold" — mistakes can be undone, changes can be seen.

Engine: see a mesh's topology type at a glance

A very practical engine addition this day: a mesh's "topology type" was made into a debug view that can be drawn directly in the viewport, with all five basic geometry topologies (points, line segments, continuous polylines, triangle faces, continuous triangle strips) visibly annotated. What does this mean? A 3D model is, at bottom, a pile of points and the connections between them, and "topology" describes "how those points are connected" — isolated points, individual line segments, or assembled triangle faces. When a model displays wrong, the problem is often a wrong topology type, but you used to only guess at the code or data. Now you can draw it directly in the viewport and look, making it far more intuitive to locate broken geometry. This capability mainly serves debugging and asset inspection, and it's on the same line as the editor — the editor lets you place and adjust, while this debug view lets you see what's really happening underneath when something goes wrong. Making "invisible internal state" visible is a hallmark of a tool maturing.

Games and content tools: aligning to the editor line

As the editor reached completion, its surroundings converged in the same direction. On the games side, the sample shooter's "playable experience" was written into a proper document, and another shooter sample got "scene-file seeding" — pre-saving its scene as that document-driven scene file so it runs the same disk-scene mechanism as the editor; the artifacts left from earlier editor-testing were also cleaned up to keep the seed scene clean. On the content-tools side, the skill workbench's sidebar workflow was streamlined, and the sidebar header styles across plugins were unified at once so they look like different modules of one product; the narrative tool also kept advancing, adding validation of key nodes and a character timeline. Individually small, these together ensure one thing: when the editor's main line reached completion, the game samples and creation tools around it weren't each going their own way but were pulled together onto the same mechanism and the same visual language.

What this day means

From blueprint to completion, the editor took just three days: set direction, run it through, fill it in. The period drawn this day means Studio formally has a feature-complete, awkwardness-free visual editor — no longer an auxiliary demo beside the AI but a second creative main line on equal footing with conversation. What's worth savoring is the rhythm of these three days: not leaving a pile of half-finished pieces to rush a schedule, but honestly filling in a professional tool's basics one by one until "every implementable feature landed." Whether a tool is ultimately pleasant to use is never decided by how many dazzling big features it has, but by whether these unglamorous basics were earnestly completed. With the editor line wrapped, human and AI finally stand before the same canvas: the AI paints with code and conversation, you revise with mouse and gizmo, two brushes on one image.