What SyncWorldWidgets needs from the host's camera to place world-anchored widget trees on the screen-space overlay: the combined view-projection, the viewport it maps into and where the camera is (for distance scale/fad
One resolved world-space UI widget quad for the host to draw as a real in-scene quad through SceneRenderer::SubmitWorldWidgetQuad. WorldMatrix maps a unit quad (centered on the origin, XY plane) to world space — already
Runtime owner of the live game-UI overlays. Scans a World for ArcUIComponents, hosts code-driven Push/Pop screens next to them, instantiates each visible one from its .ui asset, composites them (ZOrder-sorted) into a sin
Renders an Arc widget tree into an offscreen engine texture so the scene renderer can draw it as a real in-world quad (nameplates, ping markers). It reuses Arc's own CArcUIRenderer against the bridge-adopted device — it
Binds a .ui widget-tree asset to an entity. A game host that drives a CArcUIScreenStack (SyncFromWorld each tick, overlay mounted into its Arc root) instantiates each visible component's asset into a live Arc widget tree
Binds a .ui widget tree to an entity's position in the world — the WidgetComponent analog: nameplates over players, ping markers, interaction prompts. The host drives it through CArcUIScreenStack::SyncWorldWidgets, which
Pure keyframe math shared by the runtime player and the designer's scrub preview: per-key easing (the curve eases INTO each key from the previous one), clamped outside the key range, tolerant of unsorted or empty tracks.
A track with its property and every key's easing resolved, keys sorted by time: what a playing animation evaluates each frame. The authored form names both as strings, and evaluating it looked the easing name up for ever
Writes one animation's pose at a given time onto a built widget tree: host-level properties (opacity/translation/scale) go through the anim host wrapped around each target, colour goes to the named widget itself.
How PlayAnimation starts a timeline. Loop/Reverse default to the authored flags; OnFinished fires once when a non-looping run reaches its end pose (after the pose is applied, outside the per-screen animation loop).
One running timeline on a mounted screen. Owns a copy of the authored animation so a hot-reload that evicts the asset cache can never leave the player pointing at freed data.
How a child sits inside an auto-layout parent (box, overlay, grid) on one axis. Default is not an alignment — it means the node never had one written, so the parent keeps the layout it had before these fields existed.
A canvas slot resolved to its UMG-equivalent form: fractional anchors, the four per-side offsets, the alignment pivot and the size-to-content flags. Authored nodes carry the shorthand (anchor preset + position + size); t
One property → gameplay/Visual Script binding on a widget. Property is the widget field driven every frame (e.g. "percent", "text"); Source is a gameplay property path or a Visual Script expression (e.g. "Health / MaxHea
One variable a widget asset exposes to whoever embeds it. The asset names the variable, the node inside its own tree the value lands on and which property of that node it drives; a parent that references the asset with a
One widget event → host action wiring. Event names the widget delegate ("clicked", "changed", "committed"); Action is an opaque string the host's event sink dispatches — a C++ handler name today, a Visual Script function
One key on an animation track. Value carries scalar properties; Color is read instead when the owning track animates "color". Easing names the curve used to reach THIS key from the previous one ("linear", "cubic_out", "b
One animated property on one named widget. Property is one of "opacity", "translation_x", "translation_y", "scale", "rotation" (applied through the render host wrapping the target widget) or "color" (applied to the widge
A named timeline on a screen: any number of tracks evaluated together. AutoPlay starts it whenever the screen mounts (or hot-reloads in); Loop wraps instead of finishing.
A single node in the serialized Arc widget tree: which Arc widget class to build, its canvas anchoring/placement, its widget-specific properties, its data bindings and its children. Value type — the whole tree is a plain
Resolves .ui binding sources against live gameplay state. Two source forms are understood: - numeric literals ("0.75") — constant values, mostly for authoring tests; - reflection property paths ("Entity.Component.Propert
"A modal screen takes the input mode to UIOnly and gives it back when it pops" — documented behaviour that only half existed. It lived on MGameEngine::PushUIScreen, so a screen pushed through MUIStatics (which is how Vis
A game-UI theme: the named colours, fonts and metrics a .ui resolves its tokens against. Serialized as MDF under the engine's existing .theme extension, so it browses, cooks and validates like every other text asset. A s
Pure geometry for the world-space UI widget quad — the part that decides where a nameplate sits in the scene, how large its offscreen texture should be at the current distance, whether it needs re-rendering this frame an
One resolved binding value the host supplies for a data-bound property. A binding source resolves to a number, a string, or both; Valid is false when the host has no value for that source (the authored default is left in
What a gamepad/keyboard direction does from a focused widget (UE's EUINavigation rules). Escape is the default: a spatial search across the whole screen, keeping focus at an edge. Stop refuses to move that way even when
The four direction rules of one widget, resolved through the node tree: a node's own nav_up / nav_down / nav_left / nav_right props override its parent's, so a menu panel sets "wrap" once and every button inside inherits
Turns a serialized .ui tree into a live Arc widget tree. The widget class name on each node keys a small construction table; named nodes are collected so a game can resolve them for script binding after instantiate.
using FArcUIBindingResolver = std::function<FArcUIBindingValue(const std::string& source)>
Host contract for data binding: given a binding source (a gameplay property path or Visual Script expression authored in the editor), return its current value. The screen stack passes this into Build so bound widgets pick up host state at instantiation, then re-resolves it every Tick to keep them live.
Host contract for widget events: the factory wires each authored Events { On { event, action } } entry on a node to the widget's matching delegate; firing calls the sink with the widget's name, the event name and the authored action string. The host decides what an action means — the game logs/dispatches to C++ handlers today, and a visual-script-backed sink that invokes a graph function by name attaches through the same signature later.
Host contract for decoding an image asset ("Content/UI/panel.png") into straight RGBA8 pixels. Injected by the host because image decoding lives in a higher tier (Game/AssetSystem); the factory owns the GPU upload + cache.
using FArcUIAssetProvider = std::function<const FArcUIAsset*(const std::string& path)>
Host contract for resolving a referenced widget asset ("Content/UI/Card.ui") when a UserWidget node embeds one. The host owns the cache and the lifetime; the returned asset must outlive the Build call. Returning null makes the node build as a placeholder rather than failing the whole screen.
What a VideoPlayer widget needs from a clip, and nothing about how the clip is decoded. ArcUI sits below Game, where FMediaPlayer and the .media asset live, so the host injects a source factory the same way it injects th
Free functions
Signature
Description
using FArcUIMediaSourceFactory = std::function<std::unique_ptr<IArcUIMediaSource>()>
The lobby screen's logic with no widgets in it: which view to show, what the footer may do, the status line, and the browser's ordering. The screen rebuilds only when Poll says the state it draws from changed, so a roste
What the lobby screen reads and drives. ArcUI sits below the networking session in nothing it may include, so the host that owns both — the game player — implements this over FNetSession and the platform's lobby list and
The two device families a rebind screen shows side by side. A row keeps one column per family so a player can see, and change, the keyboard and the pad binding of the same action without switching pages.
One action of one context, as the screen draws it. The data structs below carry std::string / std::vector members, so they are deliberately NOT dllexported: exporting one makes MSVC demand a DLL interface for every stand
A pair of actions that read the same physical source. The engine never refuses a conflicting bind — whether an overlap is intentional is a design call — so the screen reports it and lets the player decide.
Backs the in-game rebinding screen: enumerates every action the action system currently carries, captures a new source while in the listening state, reports conflicts, and writes through the player tier (<project>/Saved/
The six screens a player expects to find in a pause menu. Anything the editor exposes that is not one of these is a developer knob and stays in Project Settings.
Where the value actually lives. Cvar rows go through IConsoleManager the way the editor's pages do; GlobalConfig rows are the handful of knobs the engine reads out of the config directly (the audio bus volumes); Host row
The data structs below carry std::string / std::vector members, so they are deliberately NOT dllexported: exporting one makes MSVC demand a DLL interface for every standard container inside it (C4251) while adding nothin
One row of the settings screen. Labels, defaults and descriptions are copied from the editor's Project Settings pages rather than reinvented, so the two screens never disagree about what a knob does.
What a game hands FGameUserSettings::RegisterRow to put a row on the player's settings screen: an id, a label, a type, a default, where the value goes (a console variable or a callback), when it is available and what the
What the device and the active graphics API can do, flattened away from RHI so the model is constructible with no device at all. Probe fills it from the live backend; a test fills it by hand.
UE5's GameUserSettings, in the shape this engine already has: cvars for the renderer knobs, GlobalConfig for the audio buses, and a per-user MDF file under <project>/Saved/Config that keeps the player's choices out of th
The input-remapping surface for a game that builds its own controls screen in Visual Scripting or ArcUI instead of using the stock rebind screen: list every action with its keyboard and gamepad binding, start listening f
Transparent single-child wrapper the widget factory inserts around every node an animation targets. Layout-transparent always: it reports the child's desired size and hands the child a rect of its full allotted size. Ani
A UMG-style canvas: children are placed by anchor + offset + explicit size within this widget's allotted rect. Arc has no canvas panel, so the ArcUI runtime carries its own — the one widget the .ui factory needs that the
The co-op front door: a server browser with Host and Direct Connect while the player is in no session, the crew's ready-up lobby between runs, and a call-back card while the crew is out. It reads and drives an IArcLobbyS
The in-game control-rebinding screen: one tab per input context, one row per action, a key cap per device family. Clicking a cap puts it into the listening state; the host then feeds the next raw key, button or axis to t
The player-facing settings screen: a category rail on the left, the rows of the selected category on the right, and Apply / Revert / Reset along the bottom. It reads FGameUserSettings, which reads the same cvars the edit
Hosts world-anchored widget trees on the screen-space overlay: each child is placed at the projected screen position of the entity it belongs to, scaled by distance and faded out past its draw distance. This is the proje
UMG's MediaPlayer + Image pairing in one node: binds a .media asset, owns the playback controls Visual Script reaches through MUIStatics, and shows the decoded frame through a hosted AImage so the picture takes the same