Core

Core module API reference: 49 headers · 122 types · 1533 symbols.

Generated from core.json · Nov 5, 2026Version 1.0.0
Build name
MowoEngine.Core
Source
Engine/Source/Runtime/Core/Public
Category
Runtime
Contents
49 headers · 122 types · 1533 symbols

Core/Config.h

KindTypeSummary
classConfig
classGlobalConfigEngine-wide settings.

Core/ConfigIni.h

KindTypeSummary
structFConfigIniEntry
structFConfigIniSection
classFConfigIniFile
classFConfigIniStructUE'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
structFConfigLayerDirs
classFConfigHierarchy
classFConfigClassBinder[/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

Core/CultureFormat.h

Core/Delegate.h

KindTypeSummary
classDelegate
classMulticastDelegateMulticastDelegate<Args...> — many subscribers, broadcast in add order.

Free functions

SignatureDescription
template<typename Signature> using Function = std::function<Signature>

Core/FApp.h

KindTypeSummary
classFAppProcess-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

Core/FAssertions.h

KindTypeSummary
classFAssertionsDetail

Core/FColor.h

KindTypeSummary
structFLinearColor
structFColor

Core/FCommandLine.h

KindTypeSummary
classFCommandLine
structFCommandLine::FPlayerArgumentOne 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

Core/FCoreDelegates.h

KindTypeSummary
classFCoreDelegates

Core/FDateTime.h

KindTypeSummary
classFTimespan
classFDateTime

Core/FGCObject.h

KindTypeSummary
classFGCObject

Core/FGameplayTag.h

KindTypeSummary
classFGameplayTag
structhash

Core/FGuid.h

KindTypeSummary
structFGuid
structhash

Core/FMath.h

KindTypeSummary
structFMath

Core/FModuleManager.h

KindTypeSummary
classFModuleManager

Core/FName.h

KindTypeSummary
classFName
structFName::FastLessOrdering by index (process-stable only). Use as the predicate for std::set<FName, FastLess> when you want O(1)-ish ordering.
structhash

Core/FPaths.h

KindTypeSummary
classFPaths

Core/FRandomStream.h

KindTypeSummary
classFRandomStream

Core/FStringFormat.h

KindTypeSummary
classFStringFormat

Core/FStringUtils.h

KindTypeSummary
classFStringUtils

Core/FTime.h

KindTypeSummary
classFTimeThe process-wide frame clock: one real time that never stretches, one game time that does, and the frame number everything else keys off.

Core/FTimerManager.h

KindTypeSummary
structFTimerHandleThe generation counter makes ClearTimer ABA-safe: a handle captured before its slot was cleared and reused cannot clear the new occupant.
classFTimerManager

Core/FileHelper.h

KindTypeSummary
classFFileHelperWhole-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.
structFFileHelper::FDirectoryEntry

Core/FileTypes.h

KindTypeSummary
enumEFileType
enumEFileEncoding
enumEFileCategoryWhat 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
structFFileTypeInfoOne 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
classFFileTypes

Core/GameplayTagContainer.h

Core/Hash.h

KindTypeSummary
classFHash

Core/IConsoleManager.h

KindTypeSummary
enumEConsoleVariableFlagsHow 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.
enumECVarSetByWho 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
classIConsoleManager
classIConsoleVariableGameplay reads through the typed TConsoleVariable<T>; the registry stores this base so editors and config can reach every cvar uniformly.
classTConsoleVariableT is int / float / bool / std::string.
classTConsoleVariableatomic<std::string> doesn't exist, so this one is mutex-guarded.

Free functions

SignatureDescription
inline EConsoleVariableFlags operator|(EConsoleVariableFlags a, EConsoleVariableFlags b)
inline bool HasConsoleVariableFlag(EConsoleVariableFlags flags, EConsoleVariableFlags flag)
template<> std::string TConsoleVariable<int>::GetValueAsString() constThe 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.
template<> bool TConsoleVariable<int>::SetFromString(std::string_view str)
template<> std::string TConsoleVariable<float>::GetValueAsString() const
template<> bool TConsoleVariable<float>::SetFromString(std::string_view str)
template<> std::string TConsoleVariable<bool>::GetValueAsString() const
template<> bool TConsoleVariable<bool>::SetFromString(std::string_view str)
template<typename T> inline TConsoleVariable<T> IConsoleManager::MakeConsoleVar(const char* name, T defaultValue, const char* helpText, EConsoleVariableFlags flags)

Core/Localization.h

KindTypeSummary
enumEPluralCategoryCLDR 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
enumEMissingKeyPolicyWhat 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
structFStringTableEntryOne row of a string table. Source is the authored string the translation was made against — empty for entries registered from code without one.
classFLocalizationManager
classFText
structFText::FFormatArgumentValueOne 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.

Core/MClassRegistry.h

KindTypeSummary
classMClassRegistry

Core/MObject.h

KindTypeSummary
classMObject
enumEMPropertyKindThe 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
structFMPropertyValueOpsWhat 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
classTMPropertyValueOpsEmitted next to each MPROPERTY row. The vector specialisation is what lets a consumer resize and index a std::vector field it cannot name the type of.
classTMPropertyValueOps
classTMPropertyValueOpsstd::vector<bool> is a bit proxy with no element addresses at all, so it gets the plain no-ops rather than array access that cannot exist.
classTMPropertyMapOpsShared by the std::map and std::unordered_map specialisations.
classTMPropertySetOpsShared by the std::set and std::unordered_set specialisations.
classTMPropertyValueOps
classTMPropertyValueOps
classTMPropertyValueOps
classTMPropertyValueOps
structFMPropertyFlagsThe 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.
structFMPropertyInfoFMPropertyInfo — 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
enumFMValueTypeCore-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
structFMParamFlags
structFMFunctionParam
structFMFunctionFlags
structFMFunctionInfo
structFMMetaEntryOne key = value of a class's open metadata: MCLASS(meta=(Key=Value)) and the specifiers without a dedicated field (Config=Game lands as "Config").
structFMClassFlagsWhat MCLASS(...) / MINTERFACE said about a class beyond its members.
classMClassMClass — 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

SignatureDescription
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.

Core/MSubsystem.h

KindTypeSummary
classMEngineSubsystemBase 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
classMWorldSubsystemBase 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.

Core/NewObject.h

KindTypeSummary
classFObjectFactory

Core/Profiler.h

KindTypeSummary
structFProfileSourceLocationWhere 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.
classFProfileZoneOne Tracy zone, open for the object's lifetime.
classFProfileTraceThe rest of what Tracy records: frame marks, plots, messages, memory.
classFProfiledMutexA std::mutex Tracy draws on its lock timeline (who holds it, who waits and for how long). Its layout is the same with Tracy compiled in or out.

Core/ProjectLayout.h

KindTypeSummary
classFProjectLayout

Core/Ref.h

KindTypeSummary
classRefRef<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.
classFRef
structhash

Free functions

SignatureDescription
template<typename T> void swap(Ref<T>& lhs, Ref<T>& rhs) noexcept

Core/RefCounted.h

KindTypeSummary
structFWeakRefControlOutlives 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
structRefCountedStats
classRefCountedBase class for objects managed by Ref<T>.

Core/Scope.h

KindTypeSummary
classFScope

Free functions

SignatureDescription
template<typename T> using Scope = std::unique_ptr<T>
template<typename T> using ScopeArray = std::unique_ptr<T[]>

Core/SoftObjectPath.h

KindTypeSummary
structFSoftObjectPath

Free functions

SignatureDescription
static_assert(sizeof(FSoftObjectPath) == sizeof(std::string), "FSoftObjectPath must be exactly its path: AssetRef consumers address the field as a std::string")

Core/TBitArray.h

KindTypeSummary
classTBitArray

Core/TBitFlags.h

KindTypeSummary
classTBitFlags

Core/TContainers.h

KindTypeSummary
classFContainers

Free functions

SignatureDescription
template<typename T> using TArray = std::vector<T>
template<typename K, typename V> using TMap = std::unordered_map<K, V>
template<typename T> using TSet = std::unordered_set<T>

Core/TLazy.h

KindTypeSummary
classTLazy

Core/TObjectPtr.h

KindTypeSummary
classTObjectPtrUE'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
structhash
classTWeakObjectPtrNon-owning reference to an MObject-derived type that goes nullptr when the referent is destroyed by GC.
classTStrongObjectPtrOwning 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
classTSoftObjectPtrSoft 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

SignatureDescription
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")

Core/TScopedExit.h

KindTypeSummary
classTScopedExit
classFScopeExit
structTag

Free functions

SignatureDescription
template<typename Fn> TScopedExit<std::decay_t<Fn>> operator+(Tag, Fn&& fn)

Core/TSmartPtr.h

KindTypeSummary
classFSmartPtr

Free functions

SignatureDescription
template<typename T, typename Deleter = std::default_delete<T>> using TUniquePtr = std::unique_ptr<T, Deleter>
template<typename T> using TSharedPtr = std::shared_ptr<T>
template<typename T> using TWeakPtr = std::weak_ptr<T>

Core/Timer.h

KindTypeSummary
classTimerHeader-only (every member inline) — no export macro. A dllimport-marked class with inline members makes Debug builds call through __imp_ stubs nobody exports.

Core/UUID.h

KindTypeSummary
classUUID64-bit identifier for entity IDs, asset handles and the like. Not a 128-bit RFC UUID — collision odds are correspondingly worse.
classUUIDGenerator
structhash

Free functions

SignatureDescription
inline UUID UUID::Generate()
inline std::string UUID::ToString() const

Core/WeakRef.h

KindTypeSummary
classWeakRefWeakRef<T> — non-owning reference to a RefCounted object. Does not keep the object alive; Lock() promotes to a Ref when it is still there.
structhash

Free functions

SignatureDescription
template<typename T> WeakRef<T> Ref<T>::CreateWeak() const

Core/TArrayView.h

Free functions

SignatureDescription
template<typename T> using TArrayView = std::span<T>

Page feedback

Was this page helpful?