UE's struct spelling inside a value: (Name="Jump",Type=Button,Keys=("A","B")). Fields split at top-level commas — parentheses nest, quotes hide commas — and keep their quotes until Unquote, so a reader can tell the text
[/Script/<Module>.<Class>] onto a reflected object. The section names the class without its M/A prefix the way UE drops U/A ("/Script/Mowo.HealthComponent" for MHealthComponent); the module part is not checked, since a
Process-level identity and the app's view of the frame clock. The time accessors are the UE-shaped names over FTime; everything reads the same storage, so FApp::GetCurrentFrame() and FTime::GetFrameNumber() can never dis
One allowlisted player switch and the code that reads it. The reader is part of the entry on purpose: a switch on the support page that nothing consumes is a promise the game silently breaks (--resx, --lang and `--no
Whole-file reads and writes on the native file system (not the VFS): logs, manifests and editor side files. Binary mode, so text comes back byte for byte, CRLF included. Game assets load through the VFS instead.
What a file is to the project. Asset/Level/BuiltData live under Content/; the Source* kinds are what an import reads; Cooked/Runtime/Sidecar are machine files nobody authors; LegacyPackage is the generic .masset/.mdf a p
One row. Aliases are other current spellings of the same format (.jpeg); Legacy are spellings an older engine wrote, read and migrated but never written. Both are space-separated, dot included, lowercase. PackageClasses
How far outside code may reach a cvar. The console, the command line and the config all write through strings; code writes through Set(). A flag only ever narrows the string paths, never code.
Who set a cvar's current value, lowest priority first (UE's ECVF_SetBy*). A write from a lower source than the one holding the value is refused, so an options-menu or scalability change can no longer undo a command-line
The int/float/bool instantiations live in Core.dll — GetValueAsString/SetFromString are specialised in IConsoleManager.cpp, so consumers must NOT instantiate their own copies (they'd miss those two methods and fail to link). The specialisations must be DECLARED before the extern template instantiations below — clang rejects a specialisation that first appears after an instantiation context (MSVC is lax here). CORE_API on each specialisation: MSVC does not fold explicitly specialised members into the extern-template's dllimport/dllexport the way clang's default visibility does — without the attribute every consumer DLL fails to link these six symbols.
CLDR plural categories (cardinal and ordinal). Which ones a language uses is CLDR's: English One/Other, Russian One/Few/Many, Arabic all six, Welsh Zero/One/Two/Few/Many/Other, and so on — see PluralCategory for the list
What a resolve does when neither the active nor the fallback locale carries the key. Warn writes one line per distinct key to stderr; Silent is the shipping default because a shipped game must not pay for, or leak, a tra
One argument of the FText-grade format below: its display text, the number behind it when it has one (what plural and ordinal choose by), and a name for {name} patterns.
The semantic shape of an MPROPERTY field, resolved once by MowoHeaderTool from the field's spelling. Consumers switch on this instead of re-parsing cxxType — four hand-maintained spelling whitelists had already drifted a
What the kind alone cannot say about an MPROPERTY field: whether its BYTES are its whole value, and — for a std::vector field — how to walk and resize it without naming the element type. Both answers come from the C++ co
The MPROPERTY specifiers a consumer acts on, as the header tool parsed them. RuntimeOnly is the one with teeth: the actor serializer never writes such a field, so state play computes cannot leak into an authored level.
FMPropertyInfo — one MPROPERTY field of an MCLASS type, as emitted by MowoHeaderTool into the .refl.cpp. Core sits below Reflection in the dep DAG and can't use TypeDescriptor, so the generator resolves the semantic kind
Core-side mirror of the Reflection module's FunctionInfo — Core sits BELOW Reflection in the dep DAG and can't include it. Thunk ABI: void Thunk(void* instance, void** args, void* ret) (instance + per-arg pointers in, re
MClass — the reflection descriptor for an MObject-derived type. One static instance per MCLASS type lives in the codegen-emitted .refl.cpp; MClassRegistry maps typeid → MClass. Aggregate — codegen brace-initialises every
Free functions
Signature
Description
template<typename T> MObject* ConstructMObject()
Codegen factory target — resolves to nullptr-returning for abstract / non-default-constructible types at compile time, so the emitter never needs to know constructibility.
Base for every engine-scope subsystem. Lifetime = engine lifetime. Header-only (every member is inline/defaulted) — no CORE_API on purpose: with the macro, subclasses in other DLLs dllimport the defaulted ctor/dtor that
Base for every world-scope subsystem. Lifetime = world lifetime (spawned with MWorld::Init, destroyed with ~MWorld). Header-only — no CORE_API for the same reason as above.
Where a zone or a lock was declared. Tracy keeps the pointer for the whole run and reads the fields in place, so it is always a static, laid out like Tracy's own source location.
Ref<T> — intrusive smart pointer for RefCounted objects. Like std::shared_ptr but the count lives in the object, so there is no separate control block.
Outlives the object it describes: WeakRef points here, not at the object, so releasing the last strong ref cannot leave a weak ref holding freed memory. owner is nulled by ~RefCounted under lock; the block itself is
static_assert(sizeof(FSoftObjectPath) == sizeof(std::string), "FSoftObjectPath must be exactly its path: AssetRef consumers address the field as a std::string")
UE's TObjectPtr: behaves like a plain T* in every read, but every STORE shades the new referent through the incremental GC's write barrier — a mid-mark assignment can no longer hide a white object behind an already-black
Owning handle that adds its referent to FMObjectArray's root set, so the GC can't sweep it out from under us. Use when a non-MObject holder needs to keep an MObject alive without being its Outer; an MObject reached throu
Soft asset reference — stores a stable path, lazy-loads the asset through FSoftAssetResolver on LoadSynchronous() and caches a strong Ref<T>. Use in components / properties that reference an asset that may not be loaded
Free functions
Signature
Description
static_assert(sizeof(TObjectPtr<MObject>) == sizeof(MObject*), "TObjectPtr must stay pointer-sized: reflection offsets and the GC trace treat it as an edge, not a container")
Header-only (every member inline) — no export macro. A dllimport-marked class with inline members makes Debug builds call through __imp_ stubs nobody exports.