VisualScripting

VisualScripting module API reference: 21 headers · 81 types · 801 symbols.

Generated from visualscripting.json · Nov 5, 2026Version 1.0.0
Build name
MowoEngine.VisualScripting
Source
Engine/Source/Runtime/VisualScripting/Public
Category
Runtime
Contents
21 headers · 81 types · 801 symbols

VisualScripting/ScriptVariableMeta.h

KindTypeSummary
structFScriptVariableMeta

VisualScripting/VisualScriptAsync.h

KindTypeSummary
structVisualScriptAsyncEventOne exec-pin fire from an async action. pin indexes the node's exec-output list (execList). outputs are packed onto the node's data-out for this fire. A terminal fire ends the action and resumes the graph past the no
classVisualScriptAsyncActionBase class for an in-flight async action. Start() runs once with the resolved node inputs; Tick() runs each frame and pushes any fired events. Return true while still active, false to retire (a terminal event also retire
structVisualScriptAsyncPinOne output exec pin of an async action, for the editor.
structVisualScriptAsyncDescEditor-facing metadata for a registered action: palette label, argument pins, and the output exec pins (index = VisualScriptAsyncEvent::pin).
enumEVisualScriptAsyncPollHow one poll of a provider-backed latent action came out.
classVisualScriptAssetLoadProviderAsset-load provider for the AsyncLoadAsset action. Visual Scripting sits far below the asset system, so the node owns only the latent plumbing: the module that wires the asset manager installs one of these and the node p
classVisualScriptAIMoveProviderNavigation provider for the AIMoveTo action, installed by the AI/navigation plugin. Same contract: no provider means OnFailed rather than a pawn that pretends it arrived.
classVisualScriptGameplayWaitProviderGameplay state behind WaitInputAction, WaitOverlap and WaitAttributeChange. Input, trigger volumes and the ability system all live above Visual Scripting, so the Game module installs one of these; the actions own only th
classVisualScriptAsyncRegistryProcess-wide registry of async-action factories. Visual Script registers the built-in actions on first use; gameplay can Register() real implementations (asset load, AI move-to) over the shipped stubs by reusing the same

VisualScripting/VisualScriptClass.h

KindTypeSummary
structVisualScriptEventGraphOne named event graph (e.g. event "BeginPlay" → the graph to run).
structVisualScriptVariableA class member variable — per-instance state the graphs read/write through GetVar/SetVar nodes (the Visual Script analog of a Blueprint variable). type picks the VisualScriptValue storage; defaultValue seeds it when
structVisualScriptFunctionParamA custom function — a named, callable sub-graph with typed parameters and an optional return (the Visual Script analog of a Blueprint function). A CallGraphFunction node invokes it by name; GetParam nodes read its argume
structVisualScriptFunction
structVisualScriptDispatcherAn event dispatcher — a multicast delegate. A Broadcast node fires every bound handler (a custom function by name), passing the broadcast arguments as the handler's parameters. The Visual Script analog of a Blueprint Eve
structVisualScriptMacroPinA macro boundary pin — one entry on a macro's input or output side. An exec pin is a flow tunnel; a data pin carries a typed value. The macro instance node mirrors these onto its own pins, and expansion inlines the macro
structVisualScriptMacroA macro — a reusable subgraph with N named exec/data inputs and outputs, INLINED at compile time (the VM never sees a MacroInstance). The Visual Script analog of a Blueprint macro. The body graph's entry is a MacroInput
structVisualScriptComponentSlotA named component slot — the class-description form of "this actor carries component X with these defaults". Slots apply to the backing ECS entity at OnConstruct; a child class (or later an instance) redeclaring a slot w
structVisualScriptClass

VisualScripting/VisualScriptClassIndex.h

KindTypeSummary
classFVisualScriptClassIndex
structFVisualScriptClassIndex::FEntry
structFVisualScriptClassIndex::FScanThe result of reconciling the files on disk against a saved index.

VisualScripting/VisualScriptClassRegistry.h

KindTypeSummary
classVisualScriptClassRegistry
structVisualScriptClassRegistry::FNativeHostThe gameplay layer's native-parent hosting. A class whose native parent has no backing class of its own (a game's AFirstPersonCharacter, any MActorComponent) spawns as an instance of THAT parent with a host component car

VisualScripting/VisualScriptClassValidator.h

VisualScripting/VisualScriptDebugger.h

VisualScripting/VisualScriptDispatcherRegistry.h

VisualScripting/VisualScriptExpression.h

VisualScripting/VisualScriptGraph.h

KindTypeSummary
enumVisualScriptNodeKind
enumVisualScriptPureOpPure data operation for a VisualScriptNodeKind::Pure node. Operand type (int vs float) is inferred from the inputs; logic ops coerce to bool. Two inputs except Neg/Not/Abs/Sqrt/Sin/Cos/Floor/Ceil/Round/Sign/ToString (one
enumVisualScriptTimelineTrackType
enumVisualScriptCurveInterpPer-key interpolation to the NEXT key (Constant holds, Linear lerps, Cubic is a Catmull-Rom spline through the neighbours).
structVisualScriptCurveKey
classVisualScriptCurveSampler for a sorted keyframe list — a class of statics (no free functions), exported so the editor can preview the same evaluation the VM runs.
structVisualScriptTimelineTrack
structVisualScriptTimeline
structVisualScriptPinRefReference to an upstream node's output pin. node < 0 means "not linked" (the input uses its constant instead). pin 0 = a CallFunction's return.
structVisualScriptInputA CallFunction input pin: a literal constant, or a link to an upstream node's output. The VM keeps a per-node output store; a linked input reads from outputs[link.node].
structVisualScriptNode
structVisualScriptGraph

Free functions

SignatureDescription
constexpr int kVisualScriptSchemaVersion = 10Bumped when the on-disk graph schema gains a field. Loaders accept anything <= this; missing fields fall back to their defaults, so an older .vscript always reads. v1 = original; v2 = object refs, macros, multi-exec-in pins; v3 = multi-track Timeline tracks/keys + async-action nodes; v4 = persisted node canvas positions + comment extents; v5 = authority nodes (HasAuthority / SwitchHasAuthority) — an older build maps the unknown kind strings to CallFunction, so the Newer warning is the only thing standing between such a graph and silent misbehavior; v6 = replicated class variables + component-slot placement (transform and attach parent) + the ClassRef node. An older build drops the first two silently — the class still loads and runs, it just stops replicating and puts every slot back on the actor's own entity — and maps the unknown ClassRef kind onto CallFunction, which is why the Newer warning matters; v7 = per-variable Instance Editable and Expose on Spawn. An older build drops both silently: instance-editable degrades to "no inspector row", which is cosmetic, but expose-on-spawn does not — the spawn node keeps the extra input pins the author wired and the old VM refuses the call on arity, so the spawn stops happening rather than happening with default values; v8 = per-variable RepNotify function name. An older build drops it silently and the variable keeps replicating with no hook — the client state still converges, only the reaction to it goes missing, so the Newer warning is advisory rather than load-bearing here; v9 = the MakeText node and its ns/key/src properties. An older build maps the unknown kind onto CallFunction, so the node stops producing a string at all — a label goes blank rather than going untranslated, which is why the Newer warning matters again here; v10 = NativeDefault blocks, the property values a class sets on its native parent. An older build drops them and the parent keeps its C++ values, so a class tuned in the editor plays differently without erroring.

VisualScripting/VisualScriptGraphDiff.h

VisualScripting/VisualScriptGraphSerializer.h

KindTypeSummary
classVisualScriptGraphSerializer

VisualScripting/VisualScriptMacroExpander.h

KindTypeSummary
classVisualScriptMacroExpander

VisualScripting/VisualScriptNodeCatalog.h

VisualScripting/VisualScriptReferenceFinder.h

VisualScripting/VisualScriptRpc.h

KindTypeSummary
classFVisualScriptRpcCodec

VisualScripting/VisualScriptSpawnParams.h

KindTypeSummary
classFVisualScriptSpawnScopeThe exposed values of one spawn, armed for the duration of the spawn call on the calling thread. The gameplay layer's spawn path consumes them at the one moment that works — after the fresh instance has its class bound (
classFVisualScriptSpawnParams

VisualScripting/VisualScriptTextView.h

KindTypeSummary
structVisualScriptTextLineOne listed line. node is -1 for section headers, terminators and blanks.
structVisualScriptTextDocument
classVisualScriptTextView

VisualScripting/VisualScriptVM.h

KindTypeSummary
enumEVisualScriptNetModeNetwork role of a graph run. Standalone (the default) is "no session": every RPC-flagged call executes locally, UE-style. Authority is the server/host (or a client-local actor that was never replicated — it is its own au
enumEVisualScriptRpcRouteWhat the routeRpc hook did with a call it was handed. Sent = the call left on the wire and must NOT run locally; RunLocal = the resolved destination is this machine (e.g. a Client RPC whose owning client is the listen ho
classFVisualScriptSlotCacheOne instance's resolution of graph nodes to entries in its variable store: by node index, the GetVar / SetVar / container-mutator variable, latch state or Timeline state the node reads and writes, null until the node fir
classFVisualScriptFrameOne call's parameters and locals, laid out by slot: the values in one vector, the names pointing at the function's own declarations. A call used to build an unordered_map — a node allocation and a string copy per local a
structVisualScriptContextExecution context for a graph run: the call target + its class (for call-by-reflection), an optional per-instance variable store that GetVar/SetVar nodes read and write, and (for custom functions) the VisualScriptClass w
structVisualScriptDebugHookDebugger hook — the runtime half of the Visual Script DAP. When installed, the VM calls onNode before dispatching every exec node (breakpoint check / single-step); returning false ABORTS the run (debugger stop). ctx.vars
structVisualScriptExecItemOne item on the VM's explicit exec stack. Capturing execution in data (rather than the C++ call stack) is what lets a Delay suspend and resume the graph.
enumVisualScriptExecItem::Kind
structVisualScriptContinuationA suspended graph run — saved when a Delay or Timeline fires. Holds the remaining exec stack + the node outputs computed so far (so data links across the wait still resolve). graph must stay alive (event graphs live in
enumVisualScriptContinuation::Kind
classVisualScriptVM

VisualScripting/VisualScriptValue.h

KindTypeSummary
enumVisualScriptContainerContainer shape of a pin. type keeps describing the ELEMENT type, so an array of ints is { type = Int, container = Array } — the pin colouring and the reflected-call marshalling both keep working off type alone.
enumVisualScriptObjRefHow an Object CONSTANT resolves to a live actor. A hard pointer can never persist (the object doesn't exist at load time), so a serialized object pin carries a symbolic reference resolved against the world when the graph
classFVisualScriptStructBoxA struct value known only by name (FTransform, any copyable MSTRUCT): an owned, constructed instance, deep-copied with the value. It is what lets a Custom pin hand a thunk a pointer to exactly the C++ type it casts to.
classFVisualScriptHeapRefThe owning handle of a value's out-of-line part. Copies SHARE the block and the first mutable access through a shared handle clones it, so copying a string or container value — every pin read, variable read and argument
structFVisualScriptObjectSlotAn object pin's live handle. It shares the scalar slot: an object value never carries a number.
structVisualScriptValue32 bytes on a 64-bit build: the tags, one 16-byte slot shared by every scalar, the quaternion and the object handle, and one pointer to the copy-on-write block holding strings, containers and struct instances. It used to
structFVisualScriptValueHeap

Free functions

SignatureDescription
inline FVisualScriptHeapRef::FVisualScriptHeapRef(const FVisualScriptHeapRef& other) noexcept : m_heap(other.m_heap)
inline FVisualScriptHeapRef& FVisualScriptHeapRef::operator=(const FVisualScriptHeapRef& other) noexcept
inline FVisualScriptHeapRef& FVisualScriptHeapRef::operator=(FVisualScriptHeapRef&& other) noexcept
inline FVisualScriptHeapRef::~FVisualScriptHeapRef()
inline void FVisualScriptHeapRef::Release() noexcept
inline FVisualScriptValueHeap& FVisualScriptHeapRef::Mutable()
inline const std::string& VisualScriptValue::Str() const
inline std::string& VisualScriptValue::MutableStr()
inline const std::vector<VisualScriptValue>& VisualScriptValue::Items() const
inline std::vector<VisualScriptValue>& VisualScriptValue::MutableItems()
inline const std::vector<VisualScriptValue>& VisualScriptValue::Keys() const
inline std::vector<VisualScriptValue>& VisualScriptValue::MutableKeys()
inline const FVisualScriptStructBox& VisualScriptValue::Struct() const
inline FVisualScriptStructBox& VisualScriptValue::MutableStruct()
inline VisualScriptValue VisualScriptValue::MakeString(const std::string& s)
inline VisualScriptValue VisualScriptValue::MakeStruct(const FMStructOps* ops)
inline VisualScriptValue VisualScriptValue::MakeObjectRef(VisualScriptObjRef kind, const std::string& ref)
inline void* VisualScriptValue::Storage()

VisualScripting/VisualScriptVarSync.h

KindTypeSummary
classFVisualScriptVarSync

Page feedback

Was this page helpful?