Reference

Every documented type in Gantry 1.0.0, generated from the plugin's reflection data and headers. Blueprint-visible types are what you meet in the editor; C++ only types are available to code.

GantryCore

Type	Kind	Summary
`EGantryAPIKind`	Enum	What an API entry names.
`EGantryChannelDirection`	Enum	Who sends on a channel, as the game means it to be used.
`EGantryChannelKind`	Enum	What a channel carries.
`EGantryChannelNetScope`	Enum	Which machines the game fires a channel on.
`EGantryResult`	Enum	Outcome of a Gantry operation that can fail in more than one way.
`EGantryTagMatch`	Enum	How a channel or slot tag matches: that tag only, or that tag and every tag under it.
`EGantryUIExtensionAction`	Enum	What happened to an entry in a slot.
`FGantryAPI`	Class · C++	The game's declared API, at run time: what it offers to its own systems and to side-loaded content, and whether a given type, function or property is part of it.
`FGantryAPIAllowlistEntry`	Struct	Puts something in the API that its code does not mark: an engine type, another plugin's, older code.
`FGantryAPIChannelEntry`	Struct	A declared channel as the manifest records it: the declaration, and who declared it.
`FGantryAPIEntry`	Struct	One thing a game offers in its API: a type, or a function or property of one.
`FGantryChannelDeclaration`	Struct	A channel the game (or content added to it) offers: part of its declared API, the events and hooks other code and content are meant to use.
`FGantryChannelDeclarationHandle`	Struct	A declaration made at run time, for taking it back.
`FGantryChannelRegistry`	Class · C++	Every channel declared for the game: the events and hooks it offers as part of its API.
`FGantryCoreModule`	Class · C++	The GantryCore runtime module: the shared pieces every other Gantry module builds on.
`FGantryHandle`	Struct	A handle to a record a Gantry system keeps for you, which can tell when that record is gone.
`FGantryHookResult`	Struct	What running a hook came to.
`FGantryMessageListenerHandle`	Struct	A registered message or hook listener, for removing it again.
`FGantryMessageRouter`	Class · C++	The C++ message bus behind `UGantryMessageSubsystem`: delivers any struct on gameplay-tag channels to whoever listens, with no reference between sender and listener.
`FGantryMessageRouter::FHookCall`	Struct · C++	One running of a hook, as each hook listener sees it.
`FGantryOnHook`	Delegate	Fired each time the hook runs, with the node (to read and change the payload through) and the channel.
`FGantryOnMessageReceived`	Delegate	Fired for each message heard, with the node (to read the message from) and the channel it was sent on.
`FGantryStatus`	Struct	The outcome of a Gantry operation: a result code plus a message for the log.
`FGantryUIExtensionEntry`	Struct	One entry in a UI extension slot: what was put there, how it ranks, and who it is for.
`FGantryUIExtensionEntryHandle`	Struct	A registered entry, for removing it again.
`FGantryUIExtensionSlotEvent`	Delegate	Fires at a slot for each entry arriving or leaving, with Added or Removed.
`FGantryUIExtensionSlotHandle`	Struct	A registered slot, for removing it again.
`Gantry`	Namespace · C++	Small adapters over engine APIs whose shape differs across the supported engine versions.
`GantryCore`	Namespace · C++	Class selection: choosing the one class in a hierarchy that is allowed to exist.
`GantryCoreTags`	Namespace · C++	Native gameplay tags declared by GantryCore.
`GantrySchema`	Namespace · C++	The shape of a code module's reflected types, as a hash: what cooked content depends on.
`GantryTagRegistry`	Namespace · C++	Tag requirements: declare the gameplay tags a system needs, and have them checked at startup.
`GantryTagRegistry::FTagRequirement`	Struct · C++	One system's dependency on a tag existing.
`UGantryAPILibrary`	Class	Blueprint access to the game's declared API (`FGantryAPI`).
`UGantryAPIManifest`	Class	The game's API manifest: every type, function, property and channel it offers, and the API version.
`UGantryAsyncAction_ListenForHook`	Class	Listen For Hook: a Blueprint node that takes part each time a hook runs, until you cancel it or the object that started it is destroyed.
`UGantryAsyncAction_ListenForMessages`	Class	Listen For Messages: a Blueprint node that hears every message sent on a channel, until you cancel it or the object that started it is destroyed.
`UGantryChannelLibrary`	Class	Blueprint access to the channel registry (`FGantryChannelRegistry`).
`UGantryChannelSet`	Class	A set of channel declarations, as data: list it in Project Settings > Plugins > Gantry Core > Channel Sets and its channels are declared for the whole game, or run it from an experience's Declare Channels stage and they are declared while the experience runs (a game mode or a DLC pack offering channels of its own).
`UGantryCoreSettings`	Class	Settings shared by every Gantry module, under `Project Settings > Plugins > Gantry Core`.
`UGantryMessageSubsystem`	Class	Sends messages on gameplay-tag channels, so one part of the game can tell others that something happened without either side knowing the other.
`UGantryUIExtensionSubsystem`	Class	Named places in your game's UI that other content can fill, without the UI knowing what will arrive: a game mode adds its scoreboard to the HUD, a DLC pack adds a button to the main menu.

GantryCoreEditor

Type	Kind	Summary
`FGantryCoreEditorModule`	Class · C++	The GantryCoreEditor module: the editor menus and icons every Gantry editor module shares.
`FGantryCoreEditorStyle`	Class · C++	The Slate style set for Gantry's editor UI: the icons its toolbar, menu and tab entries use.

GantryGauge

Type	Kind	Summary
`EGantryLoadState`	Enum	Lifecycle state of a load scope, from opening through to the state it closed with.
`FGantryGaugeModule`	Class · C++	Runtime module that records tracked loads for loading screens and the Load Gauge panel.
`FGantryLoadLedger`	Class · C++	The C++ record of every tracked load: which load scopes are open, what they asked for and how far they have got.
`FGantryLoadScopeGuard`	Class · C++	C++ helper that opens a load scope when it is created and closes it when it goes out of scope.
`FGantryLoadScopeInfo`	Struct	A copy of one load scope's state: its name, kind, asset counts, elapsed time and whether it has closed.
`FGantryLoadSnapshot`	Struct	Everything loading at one instant: the open load scopes, the recently closed ones, and how many packages the engine is streaming.
`FGantryOnAssetsLoaded`	Delegate	Signature of the tracked load nodes' output pins: the loaded objects, in request order.
`FGantryOnLoadScopeChanged`	Delegate	Fired when a load scope opens, progresses or closes, with a copy of the scope's state.
`FGantryOnLoadingFinished`	Delegate	Fired when the last user-facing scope closes and the game is no longer waiting on anything.
`FGantryOnLoadingScreenChanged`	Delegate	Fired when whether a loading screen should show changes.
`FGantryRecordedScope`	Struct	One row of a load recording: a load scope with its nesting depth and assets, in the order a loading screen lists them.
`FGantryRuntimeReadings`	Struct	This machine's frame timings in milliseconds, smoothed over about one second, plus how many load scopes are open.
`FGantryTrackedAsset`	Struct	One asset inside a scope, as recorded for per-asset detail.
`GantryGaugeTags`	Namespace · C++	Gameplay tags that name the kinds of load Gantry itself does, so a loading screen can tell them apart from the game's own.
`IGantryLoadingHold`	Interface	Interface for an object that keeps the loading screen up until it is ready, such as a player state still arriving, a pawn still setting up or a fade still running.
`UGantryAssetManager`	Class	Asset manager that records every load as a named, tagged scope in the Gantry load ledger.
`UGantryAsyncAction_LoadTracked`	Class	The Blueprint nodes Load Assets Tracked and Load Primary Assets Tracked: async loads a loading screen can see.
`UGantryGaugeSettings`	Class	Project settings for Gantry's load ledger and streaming instrumentation.
`UGantryLoadingHold`	Class · C++	An object that keeps the loading screen up until it is ready.
`UGantryLoadingLibrary`	Class	Blueprint nodes for tracked loads: read a load scope's progress, and open load scopes of your own so a loading screen can show work that is not an asset load.
`UGantryStreamingSubsystem`	Class	Engine subsystem that tells your game when to show a loading screen and what to put on it.

GantryGaugeEditor

Type	Kind	Summary
`FGantryGaugeEditorModule`	Class · C++	Editor module that adds the Load Gauge panel: a live list of every load scope while the game runs in Play In Editor.
`UGantryGaugeEditorSettings`	Class	Per-user Editor Preferences for Gantry Gauge's end-of-PIE load diagnostics.
`UGantryGaugeEditorSubsystem`	Class	Editor subsystem that checks for unfinished loads when a Play In Editor session ends.

GantryExperience

Type	Kind	Summary
`EGantryCompatibility`	Enum	Whether an experience or plugin, as shipped, can run on this build of the game, and if not, why not.
`EGantryDataPatchKind`	Enum	What a data patch changes.
`EGantryExperienceAvailability`	Enum	Whether an experience can be played on this machine right now, and if not, why not.
`EGantryExperienceState`	Enum	Where a world's experience is in its lifecycle.
`EGantryModCollisionKind`	Enum	What two or more providers contest.
`EGantryModUnitState`	Enum	How far a mod got in mounting.
`EGantryReadyPriority`	Enum	When a Wait For Experience Ready node fires, relative to the other code waiting for the same experience.
`EGantryStageNetExecution`	Enum	Which machines run a stage in a networked game: all of them, only the server, or only the machines with players.
`FGantryContentMetadata`	Struct	Build information and compatibility for one experience or plugin, as shipped: which engine and game version it was cooked for, and which game versions it supports.
`FGantryDataPatch`	Struct	One change a Patch Data action makes while its game feature is active.
`FGantryExperienceEntry`	Struct	A copy of one listed child's name, description and metadata, kept on its parent so a menu can show the child while it is not installed.
`FGantryExperienceInfo`	Struct	Everything a menu needs to show one experience, installed or not: its name, description, whether it can be played here, and where it sits in the experience tree.
`FGantryExperienceModule`	Class · C++	The GantryExperience runtime module: experiences, the experience tree, stages and activation.
`FGantryExperienceNode`	Struct · C++	C++: one experience the experience tree knows about, installed or not.
`FGantryExperienceStageContext`	Struct	Everything a stage is allowed to know about the run it belongs to.
`FGantryExperienceTree`	Class · C++	C++: the experience tree, built: every experience the game knows about and how they relate.
`FGantryExperienceTreeBuildOptions`	Struct · C++	C++: options for building an experience tree with `FGantryExperienceTree::Build`.
`FGantryGameFeatureActionTracker`	Class · C++	Counts the Gantry game feature actions still working, so experience loading can wait for them.
`FGantryInputMappingStageEntry`	Struct	One mapping context the Add Input Mappings stage puts on every local player.
`FGantryModCollision`	Struct	One thing provided by more than one mod, or by a mod and the game, and which one is used.
`FGantryModUnit`	Struct	One mod as Gantry found it: its name, what it depends on, how far it got in mounting, and why it failed.
`FGantryOnExperienceFailed`	Delegate	Fired when an activation fails: the experience (empty when it could not be identified) and a reason fit to show a player.
`FGantryOnExperienceReady`	Delegate	Fired once the experience is fully live, with the definition of the experience that was requested.
`FGantryOnExperienceStageChanged`	Delegate	Fired as each stage starts, with its kind tag and display name, so a loading screen can say what is happening.
`FGantryOnExperienceStateChanged`	Delegate	Fired on every state transition, with the state left and the state entered.
`FGantryOnInitStateReached`	Delegate	Fired when the feature reaches the state.
`FGantryOnModsMounted`	Delegate	Signature of the mod events (On Mods Mounted, On Mods Unmounted, On Mods Changed): no parameters.
`FGantryPluginReferenceCounts`	Class · C++	Counts how many running experiences use each game feature plugin, so a plugin is switched off only when the last one is done with it.
`FGantryReplicatedExperience`	Struct	The experience the server chose, as sent to every client: the requested experience and its whole activation chain.
`FGantryUIExtensionStageEntry`	Struct	One thing the Add UI Extensions stage puts in a slot.
`FGantryVersionRange`	Struct	A range of game versions, oldest and newest included, written as dotted numbers ("1.4.2").
`GantryAssetScanRules`	Namespace · C++	Checks of the project's asset manager scan rules against what Gantry's assets need.
`GantryExperienceTags`	Namespace · C++	Gameplay tags Gantry declares for the kinds of stage in an experience activation, such as Gantry.Experience.Stage.LoadAssets.
`GantryMods`	Namespace · C++	The pure steps of mod mounting, separated so they can be tested without mounting anything.
`GantryMods::FIniSet`	Struct · C++	One key a config file sets (not array additions or removals).
`UGantryAsyncAction_WaitForExperienceReady`	Class	The Blueprint node Wait For Experience Ready: runs On Ready once the world's experience is ready, or straight away if it already is.
`UGantryAsyncAction_WaitForInitState`	Class	Wait For Init State: fires once a feature of an actor has reached a state, or a later one.
`UGantryAutomaticReceivers`	Class	Registers actors of the classes listed in Project Settings > Plugins > Gantry Experience > Automatic Receiver Classes with the Game Framework Component Manager as they appear in a game world (spawned, placed in the level, or arriving with a streamed level), and unregisters them as they go.
`UGantryBaseExperienceDefinition`	Class	Root of the project's experience tree; one per project, named in Gantry Experience settings.
`UGantryExperienceDefinition`	Class	One thing your game can be doing, such as a main menu or a game mode, switched on in stages.
`UGantryExperienceDeveloperSettings`	Class	Your own Gantry settings for testing in the editor, under `Editor Preferences > Plugins > Gantry Experience (Developer)`: saved for you alone and never shipped.
`UGantryExperienceSettings`	Class	Where the project's experience tree is rooted, and which subsystem runs it.
`UGantryExperienceStage`	Class	One step of an experience activation, run in order and awaited.
`UGantryExperienceStage_DeclareChannels`	Class	Declares channels while the experience runs.
`UGantryExperienceStage_GameFeatures`	Class	Loads and activates game feature plugins, reference counted across experience swaps.
`UGantryExperienceStage_InputMappings`	Class	Puts Enhanced Input mapping contexts on every local player while the experience is active.
`UGantryExperienceStage_LoadAssets`	Class	Loads a list of assets with tracked progress, for the loading screen.
`UGantryExperienceStage_LocalPlayers`	Class	Base class for a stage that does something for every local player while its experience is active, including split-screen players who join later.
`UGantryExperienceStage_UIExtensions`	Class	Puts entries in UI extension slots while the experience is active.
`UGantryExperienceStateComponent`	Class	Replicates the server's experience to clients. Added automatically when missing.
`UGantryExperienceSubsystem`	Class	Runs one experience per world: works out its chain, runs its stages, and announces when it is ready.
`UGantryGameFeatureAction`	Class	Game feature action whose activation can finish asynchronously, awaited by experience loading.
`UGantryGameFeatureAction_DataPatches`	Class	Patch Data: a game feature action that changes data while its game feature is active, and puts it back when it deactivates.
`UGantryGameFeatureData`	Class	Game feature data that records the plugin's build information for compatibility checks.
`UGantryGameFeaturesProjectPolicies`	Class	The game feature policy that refuses plugins that do not fit this build: another engine, game or API version, or cooked against another build of the game's code.
`UGantryInitStateComponent`	Class	A component that readies one feature of an actor in steps, through the Game Framework Component Manager's init states, and can be made in Blueprint.
`UGantryInputMappingSubsystem`	Class	Adds and removes Enhanced Input mapping contexts on one local player, counting who holds each one.
`UGantryModPreferences`	Class	The player's mod choices, kept per user (GantryMods.ini under Saved/Config, never the project's config): which mods are turned off.
`UGantryModSubsystem`	Class	Finds the mods players install, checks them, and makes their experiences part of the game.

GantryExperienceEditor

Type	Kind	Summary
`FGantryExperienceEditorModule`	Class · C++	Editor support for experiences: the Gantry entries in the Content Browser's Add menu, their class picker, colours and icons, Tools > Gantry > Validate Experiences (also a commandlet: -run=GantryValidate), Tools > Gantry > Generate API Manifest, and the Gantry page of the Message Log, which opens when an experience fails or a mod is refused.
`UAssetDefinition_GantryBaseExperience`	Class	Content Browser presentation of the base experience.
`UAssetDefinition_GantryExperience`	Class	Content Browser presentation of experiences: the Gantry category and colour.
`UAssetDefinition_GantryGameFeatureData`	Class	Content Browser presentation of Gantry game feature data.
`UGantryAPICommandlet`	Class	Writes the API manifest from the command line:
`UGantryBaseExperienceDefinitionFactory`	Class	Add > Gantry > Base Experience.
`UGantryDataAssetFactory`	Class	Creates a Gantry data asset from the Content Browser's Add > Gantry menu.
`UGantryExperienceDefinitionFactory`	Class	Add > Gantry > Experience.
`UGantryGameFeatureDataFactory`	Class	Add > Gantry > Game Feature Data.
`UGantryValidateCommandlet`	Class	Validates the project's Gantry content from the command line, for builds and CI:

GantrySettings

Type	Kind	Summary
`EGantryConsoleVariablePriority`	Enum	How strongly a console variable written by a setting holds against other sources of the same variable.
`EGantrySettingChangeReason`	Enum	Why a setting's value changed.
`EGantrySettingConditionEffect`	Enum	What a condition does when it holds.
`EGantrySettingNumberFormat`	Enum	How a number setting is written for the player.
`FGantryOnSettingAction`	Delegate	Fired when an action setting is used.
`FGantryOnSettingChanged`	Delegate	Fired when a setting's value changes, with why.
`FGantryOnSettingsPagesChanged`	Delegate	Fired when the registry's pages change (one added or removed).
`FGantryOnVideoConfirmChanged`	Delegate	Fired when a display change starts or stops waiting to be confirmed.
`FGantrySettingEditState`	Struct	Whether a setting can be seen and changed right now, and if not, why not.
`FGantrySettingOption`	Struct	One choice a setting offers.
`FGantrySettingsPageEntry`	Struct	One page in a registry: the page, this player's copies of its settings, and how often it was added.
`FGantrySettingsProviderEntry`	Struct	One settings provider in a registry: the provider, the pages it built, and how often it was added.
`UGantryExperienceStage_SettingsPages`	Class	Gives every local player these settings pages while the experience is active.
`UGantrySetting`	Class	One thing a player can set, such as mouse sensitivity, window mode or a key binding.
`UGantrySettingAction`	Class	A button among the settings, such as "Calibrate brightness" or "Run benchmark".
`UGantrySettingChoice`	Class	One of a list of options, usually drawn as a rotator or a drop-down.
`UGantrySettingCondition`	Class	A rule that hides a setting, disables it, or disables some of its options.
`UGantrySettingCondition_Platform`	Class	Hides or disables a setting on platforms not in a list ("Windows", "Linux", "Mac").
`UGantrySettingCondition_PrimaryPlayer`	Class	Disables a setting for every local player except the first.
`UGantrySettingCondition_WhenSetting`	Class	Hides or disables a setting while another setting has one of the listed values.
`UGantrySettingKeyBinding`	Class	A key the player can rebind: one key slot of one of Enhanced Input's player mappable keys.
`UGantrySettingNumber`	Class	A number between Minimum and Maximum, usually drawn as a slider.
`UGantrySettingToggle`	Class	An on or off setting, usually drawn as a check box.
`UGantrySettingValue`	Class	A setting whose value is stored as text: the base of the number, choice, toggle and key binding shapes.
`UGantrySettingsConfig`	Class	The project's settings for player settings, under `Project Settings > Plugins > Gantry Settings`.
`UGantrySettingsLibrary`	Class	Blueprint access to players' settings, and helpers for settings to read and write their values with.
`UGantrySettingsPage`	Class	A page of player settings, authored as an asset.
`UGantrySettingsProvider`	Class	Builds settings pages for one player in code, instead of authoring them as assets.
`UGantrySettingsRegistry`	Class	One local player's settings: pages, values, changes, saving.
`UGantrySettingsSave`	Class	One player's saved setting values, by setting Id.
`UGantrySettingsSubsystem`	Class	Gives each local player their settings registry as soon as the player exists.

GantryTests

Type	Kind	Summary
`AGantryTestReceiver`	Class	An actor class the automatic receiver tests list.
`FGantryTestMessage`	Struct	A message for the message channel tests.
`FGantryTestMessageChild`	Struct	A child message type: listeners for `FGantryTestMessage` hear it too.
`FGantryTestOtherMessage`	Struct	A message of an unrelated type.
`FGantryTestRow`	Struct	A table row for the data patch tests.
`UGantryTestEventSink`	Class	Records how a dynamic load-scope event reached it: whether at all, and on which thread.
`UGantryTestLoadingHold`	Class	An object that holds the loading screen while bHold is set.
`UGantryTestNetSubsystem`	Class	An experience subsystem that acts as whatever net mode the test world asked for.
`UGantryTestPatchTarget`	Class	An object whose values the data patch tests change.
`UGantryTestSetting_ConsoleChoice`	Class	A console-variable choice declared the way a game would: Read Value and Write Value go to a variable, and Keep In Save remembers it.
`UGantryTestSettingsProvider`	Class	Builds one page per registry in code: a toggle kept in the save, and a number whose value lives in a lambda's storage and which is disabled while the toggle is off.
`UGantryTestStage_Fail`	Class	A stage that fails as soon as it begins.
`UGantryTestStage_Gate`	Class	A stage that stays running until the test opens every gate.
`UGantryTestStage_Hang`	Class	A stage that begins and never finishes, for stall detection.
`UGantryTestStage_Hold`	Class	A stage that models a game feature stage's reference holding without a real plugin.
`UGantryTestStage_RecordWorld`	Class	A stage that records the world it sees while running, then finishes.