HUD system
The PulseHUD module gives every local player a CommonUI based HUD: stacks for menus and screens, pooled modals with results, a compass with markers, notifications (toasts) and input contexts through the player input manager of PulseFoundationUI. World markers, tooltips, a highlight frame, progress overlays, subtitles, tutorial hints and context menus are described on Markers, tooltips and overlays.
Primary building blocks:
| Class | Role |
|---|---|
UPulseHUDSubsystem | Local player subsystem. Creates the HUD and is the entry point for everything below. |
UPulseHUDLayout | Base class of the HUD widget. |
UPulseHUDStackContainer | A stack of activatable widgets, identified by a gameplay tag. |
UPulseHUDModalBase / UPulseHUDModal | Modals (title, message, content, buttons). |
UPulseHUDCompassBase / UPulseHUDCompassMarker | Compass bar and its markers. |
UPulseHUDNotificationArea / UPulseHUDNotificationWidget | Notifications (also subtitles and hints). |
UPulseHUDWorldMarkerLayer, UPulseHUDTooltipLayer, UPulseHUDHighlightLayer, UPulseHUDProgressWidget | See Markers, tooltips and overlays. |
UPulsePlayerInputManager (PulseFoundationUI) | Cursor and input mode from a prioritized list of input contexts (see “Input contexts”). |
UPulseHUDLibrary | Blueprint functions that take a player controller. |
UPulseHUDSettings | Project Settings > Pulse > Gameplay > HUD. |
Setup
- Project Settings > Pulse > Gameplay > HUD: enable
bEnableHUDand setHUDLayoutClass(default:/PulseGameplay/HUD/W_DefaultHUDWidget). - The layout widget derives from
UPulseHUDLayoutand contains at least a stack container namedPulse.HUD.Stack.Main. For modals it needs a stackPulse.HUD.Stack.Modal, for notifications aUPulseHUDNotificationArea, for the compass a panel namedCompassSlot. - Optional: enable
bEnablePlayerInputManager(Project Settings > Pulse > Foundation > UI) so menus and modals (and the dialog bridge) set cursor and input mode. - Optional: add the layers of Markers, tooltips and overlays that the game uses (the default layout has all of them).
- Optional: give the HUD your look with a UI theme (see “Look and theme” below).
Look and theme
All default widgets take their look from the UI theme of PulseFoundation (module PulseFoundationUI, see the UI themes documentation): panels, text, buttons, progress bars, sliders and icons are Pulse Style roles, so one theme asset (Project Settings > Pulse > Foundation > UI > Default Theme) restyles the whole HUD and the settings menu, also at runtime per player (Set Player Theme, cheat PulseUITheme).
What the HUD adds on top:
- Buttons: modal actions use the theme roles
Pulse.UI.Button.Primary(confirm) and.Secondary(cancel, neutral) unlessStyle.ConfirmButtonStyle/CancelButtonStyle/NeutralButtonStyleare set.UPulseHUDTextButton::StyleRolegives any text button a theme role that follows theme changes; its text block takes the text style of the button’s state (bApplyStyleTextStyle). - Motion: stacks take the theme’s stack transition (
bUseThemeTransitionon the stack container). Widgets without own UMG animation play the theme’s motions: notifications slide in and out (ShowMotion,HideMotion,MotionDirection,bUseThemeMotion), modals pop in (bPlayOpenMotion), tooltips, context menus and world markers fade in, the progress bar fills smoothly (FillSpeed). - Colors and icons:
UPulseHUDSettings::NotificationTypeColorRoles(notification type → color role) tints the optionalAccentBar, the icon and the roundIconBackgroundof notifications;NotificationTypeIconsgives notifications without own icon the icon of their type. PulseHUD defines the typesPulse.Notification.Success(positive, check),.Reward(highlight, diamond),.Item(accent, info),.Warningand.Error.FPulseUIMarkerData::ColorRolecolors marker dots and tints icons; compass markers without icon show the theme’s diamond icon. - Crosshair: the layout’s optional
Crosshairwidget (defaultW_DefaultCrosshair, a dot with a dark ring in the middle of the screen, insideGameplayRootso it hides with menus).UPulseHUDSubsystem::SetCrosshairVisible(e.g. only while aiming),bShowCrosshairByDefaultin the settings and the player setting Crosshair must all allow it. - Menus: while the main stack shows a menu the gameplay HUD is hidden (
bHideGameplayHUDWhileMenuOpen, hide reasonPulse.HUD.HideReason.Menu), so compass and notifications never lie on top of it. - Designer previews: notifications (
PreviewNotification), tooltips (PreviewData), world markers (PreviewData,bPreviewOnEdge), progress (PreviewRequest) and modals (PreviewTitle,PreviewActions) show sample content. - Showcase: the cheat
PulseHUDShowcaseshows the HUD scene of the default look: three notifications (success, reward, item), a hint with a key cap and a highlight on the compass, a subtitle and three colored markers;PulseHUDShowcase 1adds a progress overlay and a tooltip. Combat bars, hotbar and interaction prompt come from their cheats (PulseCombatShowcase, the inventory cheats,PulseInteractSpawnTest).
The default look is the “Pulse HUD Basisstil” of the default theme: a compass band at the top (640 x 46, 160° visible, ticks every 5°, directions in Roboto Condensed), boss bar below it, notifications top right, hints left, player vitals bottom left, hotbar bottom center, interaction prompt next to the crosshair and subtitles above the hotbar.
HUD lifecycle
UPulseHUDSubsystem exists per local player (not on dedicated servers). Whenever the player controller of the local player changes (first spawn, map travel, seamless travel with a new controller) it:
- removes the old layout and cancels open modals (they report
Cancel), - creates the layout with
CreateWidget(PlayerController, HUDLayoutClass)and adds it withAddToPlayerScreen(HUDZOrder), - creates the compass (
Style.CompassClass) and lets the layout place it (AddCompass, default: intoCompassSlot), - calls
On HUD Initializedon the layout and broadcastsOnHUDCreated.
Because the layout is always owned by the current controller, GetOwningPlayer() in HUD widgets is never stale.
The default classes of the style are loaded asynchronously when the subsystem starts, so the first modal does not hitch.
Hiding the HUD
AddHUDHideRequest(Reason) / RemoveHUDHideRequest(Reason) hide the gameplay part of the HUD until no reason is left. The layout decides what that means (OnHUDHiddenChanged); by default it collapses the optional widget GameplayRoot (or CompassSlot). Stacks with menus and modals stay visible.
Stacks
A UPulseHUDStackContainer wraps a UCommonActivatableWidgetContainerBase (stack or queue). UPulseHUDDynamicStackContainer creates the container from a class.
- Stacks register themselves with the HUD subsystem of their owning player when they are constructed and unregister on destruct. They can be anywhere: in the layout, in nested widgets or in a menu pushed later.
- The modal stack (
Pulse.HUD.Stack.Modal) must use aUCommonActivatableWidgetQueue; one modal is shown at a time, the others wait. - API (also on the subsystem by stack tag):
PushWidget(class, pooled by CommonUI),PushWidgetInstance,RemoveWidget,PopWidget,ClearStack,GetActiveWidget,GetNumWidgets,IsEmpty. - C++:
PushWidget<T>(Class, [](T& Widget) { ... })configures the widget before it is activated. - Blueprint: Push Widget To Stack Async loads a soft class, optionally blocks UI input while loading, and has
BeforePush(configure) andAfterPushpins. - Events:
OnWidgetPushedEvent,OnWidgetDeactivatedEvent,OnDisplayedWidgetChangedEvent.
UI host of the Pulse plugins
The Pulse HUD is the UI host of every Pulse plugin: its presenter UPulseHUDPresenter registers itself in Pulse Foundation when the module starts, so every local player gets it unless Project Settings > Pulse > Foundation > UI > Presenter Class names another (see “Where widgets of plugins show” in the UI docs of Pulse Foundation). It registers bEnableHUD as the check of the host too: with the HUD on, the UI modules of the Pulse plugins (map, status, death screen, pings) start with their default Activation (With UI Host); with the HUD off and no Presenter Class they stay off as before. Nothing to set up.
- Layers go onto HUD stacks (Layer Stacks): Game and Menu onto
Pulse.HUD.Stack.Main, Modal ontoPulse.HUD.Stack.Modal, Overlay ontoPulse.HUD.Stack.Overlay; a layer without an entry onto Main. - Gameplay widgets go into the gameplay part of the layout (
AddGameplayWidgetofUPulseHUDLayoutwith the placement of the request), so they hide with the HUD; Fill stretches a widget over the whole gameplay part at the Padding of the placement (canvas anchors 0..1 with the padding as offsets, an overlay slot that fills with the padding). A layout without aGameplayRootpanel takes none: the request fails with a warning, the widget does not go to the viewport. The host is ready when the HUD built its layout (OnHUDCreated); On Host Ready of the presenter comes then, again after every map change. - Widgets of a layer stay one per class and layer while they are in their stack, also covered by another widget; opened again they come back as they are. Close Layer and Close Widgets take them out of the stack, covered ones first; Close Widget takes one out, also a covered one.
- Hide requests of the plugins hide the HUD of the local player (
AddHUDHideRequest, also when the plugin passes a controller of before a seamless travel; the reasons are shared with Add HUD Hide Request of the game, the presenter removes only its own and takes them all back when it is replaced), tooltips show in the tooltip layer (a widget class that is noUPulseHUDTooltipWidgetgets the default tooltip of the layer). - Notifications of the plugins are notifications of the HUD in the area of their kind: Notification Areas of the settings maps a kind (
Pulse.UI.Notification.*) to an area (Pulse.HUD.Notification.*); a kind without an entry uses the entry of its parent tag, none the default area. The plugins name only the kind, the HUD decides where it shows. The kindsSuccess,WarningandErrorbecome the success, warning and error kinds of the HUD,Infohas no kind, kinds of plugins stay.Subtitlegoes toPush Subtitle(the title is the speaker; nothing shows while the player turned subtitles off). Priority and payload go along; a widget class goes along only when it is aUPulseHUDNotificationWidget, else the area shows its own. Hide Notification dismisses it before its time (notifications merged by their key share one notification of the HUD, hiding one hides them). - Progress overlays (Show Progress, Update Progress, Hide Progress) are progress overlays of the HUD (
PushProgresswith the progress class of the style, not cancellable). - When the presenter is replaced (Set Presenter, Set Presenter Class) it closes its progress overlays and notifications; a plugin shows an overlay that still matters again on the next presenter (On Host Ready).
- Modals of the plugins are modals of the HUD: Primary and Destructive buttons get the confirm style, Cancel the cancel style, the rest the neutral one; the back key and a modal closed from outside answer the cancel action of the request (
CancelActionIdof the HUD request), none when the request has no cancel action (a button with the role Cancel is not one). - Without a HUD or layout for the player (a dedicated server, a game without the Pulse HUD) it falls back to the viewport.
Modals
A modal is described by an FPulseHUDModalRequest and shown with UPulseHUDSubsystem::PushModal (or UPulseHUDLibrary::PushModal, or the async node Show Modal And Wait).
| Request field | Meaning |
|---|---|
ModalClass | Modal widget. Empty = Style.ModalClass. |
Title, Message | Texts. Hidden when empty. |
Content / ContentClass | Optional content widget (instance, or class from the content pool). |
Actions | Buttons (FPulseHUDModalAction: Id, Label, Role, bClosesModal, optional button class, style, input action). |
Payload | Any struct (FInstancedStruct) for the modal or its content (GetPayload). |
StyleClass, ContainerClass | Frame and backdrop. Empty = modal default / style default. |
bAllowCancel | Whether the back action closes the modal (it triggers the action of CancelActionId, otherwise result Cancel). |
CancelActionId | Id of the action the back action triggers (MakeConfirm sets the cancel button). None, or an id no action has: the modal closes with the result Cancel. The role of a button does not count. |
bManageInput, InputContext, InputPriority | Input context while the modal is open (default: cursor, UI only). |
Helpers: MakeConfirmModalRequest(Title, Message, ConfirmText, CancelText) and MakeMessageModalRequest(Title, Message, CloseText).
Results
Every modal closes with a result (FName): the Id of the action that closed it, or Cancel (Pulse::HUD::Modal::Result_Cancel) if it was cancelled or closed otherwise. Confirm is Pulse::HUD::Modal::Result_Confirm.
OnModalClosed(Modal, Result)(native and dynamic) on the modal.OnActionTriggered(Modal, ActionId)onUPulseHUDModalfor actions that don’t close it.- Show Modal And Wait: pins
OnClosed,OnConfirmed,OnCancelled,OnFailed. Wait For Modal Closed waits for a modal that is already open. - C++:
PushModal(Request, [](UPulseHUDModalBase* Modal, FName Result) { ... }).
Bindings on a modal are cleared when it goes back to the pool, so bind per push.
Buttons with text
UPulseHUDTextButton is a common button that shows ButtonText in the optional text block ButtonTextBlock (also in the designer). Modal action buttons (UPulseHUDModalActionButton) and the buttons of the settings menu derive from it; use it for own menu buttons.
Modal classes
UPulseHUDModalBase: activatable widget with an optional style frame (UPulseHUDModalStyle), close animation (CloseAnimation, orCloseDelay), payload, content and result. OverrideAddContent/RemoveContentto place content.UPulseHUDModal: optional bound widgetsTitleText,MessageText(text or rich text),ContentSlot(panel),ActionList(UDynamicEntryBoxwithUPulseHUDModalActionButtonentries). Parts without data are collapsed. The confirm action gets the focus.PreviewTitle,PreviewMessageandPreviewActionsshow a preview in the designer.UPulseHUDModalActionButton: CommonUI button with the label inButtonTextBlock.SetupActionsets text, style (Style.ConfirmButtonStyle/CancelButtonStyle/NeutralButtonStyleor the action’s style) and the triggering input action.UPulseHUDModalContainer: backdrop the modal is shown in (one per modal, pooled by the queue).UPulseHUDModalContent/IPulseHUDModalContentInterface: optional for content widgets (OnModalContentSet,OnModalOpened,OnModalClosed).
Pooling
Modal widgets and content widgets created from a class come from pools of the HUD subsystem. A modal goes back to the pool after its close animation (OnModalCleanup); its style instance stays with the modal and is reused while the style class is the same. Nothing has to be released by hand.
Compass
The compass is created with the HUD if Style.CompassClass is set and the layout places it.
- The compass shows the markers of the marker registry of PulseFoundation (
UPulseUIMarkerSubsystem) with the channelCompass; add them withAddMarker(Data, Channels)of the registry (see World markers). They keep their handle (FPulseHandle) and survive a rebuilt HUD. - Markers are described by
FPulseUIMarkerDataof PulseFoundationUI (old namesFPulseHUDMarkerDataandFPulseHUDCompassMarkerDataare redirected):WorldLocationorActorToTrack(weak),Kind,Icon,Name,ColorRole,bPersistent,bShowDistance,DistanceUnits,MinDistance,MaxDistance,bRemoveWhenActorInvalid,CustomData(FInstancedStruct). - Compass only, without the registry:
AddMarker/UpdateMarker/RemoveMarker/RemoveMarkersForActorofUPulseHUDCompassBase(GetCompass()of the subsystem).SetCompassVisible(bVisible)on the subsystem. - The compass marker class comes from the presentation of the marker, its kind in the HUD style or the style default (see World markers).
- Markers whose tracked actor is destroyed are removed automatically (
bRemoveWhenActorInvalid); the compass then removes the marker from the registry too. - Performance: marker widgets don’t tick (
DisableNativeTick). The compass updates all markers in its tick with one location/rotation lookup; the distance text only changes when the shown number changes. - Marker widget:
MarkerContainer(required, the part that moves), optionalMarkerIcon,MarkerNameText,MarkerDistanceText, animationsAddMarkerAnim/RemoveMarkerAnim. Overridable:K2_CalcMarkerPosition,K2_ShouldBeVisibleOnCompass,OnMarkerDataChanged. - Compass widget:
CompassBarImage(material withOffset/Orientationparameters),CompassMarkersOverlay,ShowCompassAnim/HideCompassAnim,bHideByDefault.
Notifications
UPulseHUDSubsystem::PushNotification(FPulseHUDNotification) shows a toast in a UPulseHUDNotificationArea of the layout.
| Field | Meaning |
|---|---|
Type | Free tag for the widget (e.g. achievement, quest). |
Area | Area tag. Empty = Pulse.HUD.Notification.Default. |
Title, Message, Icon | Content. |
Speaker | Speaker of a subtitle (SpeakerText of the widget). |
Duration | Seconds (real time). 0 = DefaultNotificationDuration. |
Priority | Waiting notifications with a higher priority come first. |
DedupeKey | Notifications with the same key are merged: the count goes up and a visible one starts its time again. |
WidgetClass | Optional widget class. Empty = entry class of the area. |
Payload | Any struct for custom widgets. |
- At most
MaxVisibleNotificationsper area are visible (area overrideMaxVisibleOverride), at mostMaxQueuedNotificationswait; above that the oldest one with the lowest priority is dropped. - Notifications pushed before the area exists (e.g. while the HUD is created) wait in the subsystem.
- Time runs while the area ticks, so notifications wait while the HUD is hidden.
- The queue logic is
FPulseHUDNotificationQueue(no widgets, covered by thePulseHUD.Notificationsspecs). UPulseHUDNotificationArea: boundEntryBox(UDynamicEntryBox),AreaTag.UPulseHUDNotificationWidget: optionalTitleText,MessageText(text block or rich text block, e.g. with key caps),IconImage,IconBackground(tinted with the type color atIconBackgroundOpacity),AccentBar,CountText(CountFormat),SpeakerText, animationsShowAnim/HideAnim,Dismiss().bTintIconWithTypeColortints the icon.- Subtitles (
PushSubtitle) and tutorial hints (ShowHint) are notifications in their own areas, see Markers, tooltips and overlays.
Notification rules
A rule (FPulseHUDNotificationRule) shows a toast for messages of the Pulse Foundation message bus without code: “when this happens, show that”. Notification Rules in the HUD settings (Project Settings > Pulse > Gameplay) hold the rules of the project; Add Notification Rule / Remove Notification Rule (UPulseHUDNotificationRuleSubsystem, per local player) change them while playing.
| Field | Meaning |
|---|---|
Id | Name of the rule; a rule with the same id replaces an earlier one (added rules replace rules of the settings). |
bEnabled | Off: the rule shows nothing. |
Trigger | Channel, match and conditions of the messages (message triggers). The condition Message Value compares a value of the message (Payload.Result is Success). Server Only is off: rules listen on every machine. Messages that only catch up (a join, a load) show nothing unless Include Catch Up is on. |
Audience | Player: the player of the message (a message without a player shows for every local player). Everyone. |
Type, Area, Duration, Priority, WidgetClass | As in FPulseHUDNotification. |
Title, Message | Texts with placeholders: {Payload.<name>}, {Source.<name>}, {Target.<name>}, {Instigator.<name>}, {Player.<name>}, {Amount}; names walk through structs and objects ({Source.Child.DisplayName}). |
IconPath, Icon | An object reference of the message (Source.Icon), else the fixed icon. |
DedupeKey | Key with placeholders (Achievement.{Payload.Achievement}); empty never merges. |
The payload of the message becomes the payload of the notification, so a custom widget can read it. RulesQuietAfterJoinSeconds (default 3) keeps the rules quiet after the player controller changed, because a joining client receives the state of the game (running quests, unlocked achievements) as messages.
Ready-made rules for other Pulse plugins. The Set Up step “Show toasts for the other Pulse plugins” of the Pulse window offers the rules of the plugins in the project and adds them to the settings, where their texts can be changed:
| Id | Channel | Shows |
|---|---|---|
Quest.Started | Pulse.Message.Quest.Started (not loaded from a save game) | “Quest started”, the quest name |
Quest.Succeeded / Quest.Failed | Pulse.Message.Quest.Finished, Result Success / Failure | “Quest completed” / “Quest failed” (types Success / Error) |
Quest.ObjectiveFinished (off) | Pulse.Message.Quest.ObjectiveFinished, bSucceeded | “Objective done”, the objective text |
Achievement.Unlocked | Pulse.Message.Achievement.Unlocked | Name, description and icon of the achievement (type Reward), merged per achievement |
They replace the former bridges PulseQuestHUDBridge and PulseAchievementHUDBridge: PulseGameplay does not depend on PulseQuest or PulseAchievement, the rules are data. Other plugins and games add their own rules the same way (a harvest, a level up, a door that opens).
Player settings
The HUD registers four options in the PulseFoundation player settings (UPulseHUDPlayerSettings, tab Interface, section HUD), so every settings menu shows them, for example the PulseGameplay settings screen:
| Setting | Id | Default | Effect |
|---|---|---|---|
| Compass | Pulse.Setting.HUD.ShowCompass | On | Shows the compass. SetCompassVisible of the game still applies: the compass is shown when both allow it. |
| Crosshair | Pulse.Setting.HUD.ShowCrosshair | On | Shows the crosshair. SetCrosshairVisible of the game still applies. |
| Notification duration | Pulse.Setting.HUD.NotificationDuration | 100 % | Factor (50 % to 300 %) for how long notifications stay, also for those that use DefaultNotificationDuration. |
| Subtitles | Pulse.Setting.HUD.Subtitles | On | Shows subtitles (PushSubtitle). |
| Subtitle size | Pulse.Setting.HUD.SubtitleSize | 100 % | Size of subtitles (80 % to 200 %): the user specified scale of the scale box SizeScale of the subtitle widget. |
| Subtitle background | Pulse.Setting.HUD.SubtitleBackground | 100 % | Opacity of the panel BackgroundPanel behind subtitles (0 % hides it). |
| Subtitle speaker | Pulse.Setting.HUD.SubtitleSpeaker | On | Shows who speaks above the subtitle. |
The HUD subsystem applies them when the HUD is created and whenever the player changes them. Turn bRegisterPlayerSettings off when the game has its own HUD options; read them in code with UPulseSettingsSubsystem::GetPlayerSettings<UPulseHUDPlayerSettings>(LocalPlayer).
Input contexts
Input contexts and the player input manager are part of PulseFoundation (module PulseFoundationUI): the types FPulseInputContext, EPulseInputMode and EPulseShowMouseCursorMode, the local player subsystem UPulsePlayerInputManager with Pulse::UI::GetPlayerInputManager, the interface IPulsePlayerInputManagerOwner and the settings bEnablePlayerInputManager, bClearContextsOnControllerChange, bShowMouseCursorByDefault and DefaultInputMode (Project Settings > Pulse > Foundation > UI). How contexts are sorted and resolved is in the UI themes documentation of Pulse Foundation (section “Where widgets of plugins show (the UI host)”).
What the HUD does with them while the manager is enabled:
- Modals (
bManageInput,InputContext,InputPriority), the radial menu and progress overlays add their context withAddInputContextForWidget, so it goes away when the widget deactivates or is destructed. - The settings screen, the world map, the death screen and the frontend menus add a menu context the same way.
- The HUD presenter (
UPulseHUDPresenter) adds the input context of the layer (LayerInputsof the presenter: Menu and Modal show the cursor and give the input to the UI) after it pushed a widget to its stack or found it there already: one while the widget is active, again when a covered widget shows again. Turn an entry off for widgets that manage their own input. UPulseHUDLibrary::GetPlayerInputManageris the Blueprint node for a player controller; C++ callsPulse::UI::GetPlayerInputManager.- Don’t change input mode or cursor by hand while the manager is enabled.
Debugging
With PulseFoundation’s debug tools (Tools > Debug > Pulse Debugger, gameplay debugger category Pulse):
UPulseHUDSubsystemis a snapshot provider (categoryHUD): layout class, owner, hide reasons, compass, every stack with its number of widgets and the active widget, open and waiting modals, notification areas and notifications waiting for their area.- The input manager of Pulse Foundation has a snapshot (category
UI) and an input history on the Timeline page of its own: the resolved cursor, input mode and focus and every input context top first (see the UI docs of Pulse Foundation). - Modal requests and closes and pushed notifications are timeline events as well (
Modal,Notification).
Cheats (console, development builds; they act on the HUD of the local player that types them):
| Cheat | Does |
|---|---|
PulseHUDToast <text> | Shows a notification in the default area. |
PulseHUDModal <title> | Opens a confirm modal and prints its result when it closes. |
PulseHUDToggle | Hides the HUD (hide reason Pulse.HUD.HideReason.Cheat) or shows it again. |
PulseHUDShowcase [1] | Shows three notifications, a hint, a subtitle and markers of the marker registry at once (theme check); 1 adds a progress overlay and a tooltip. |
Cheats for progress, subtitles, hints, context menus and tooltips: see Markers, tooltips and overlays. Test markers come from the marker registry of PulseFoundation (PulseUIMarker, PulseUIMarkersClear).
PulseDebugDump HUD (PulseFoundation) prints the HUD snapshots to the log.
Replacing and switching off subsystems
Some subsystems of PulseGameplay can be replaced by a class of your game or switched off in Project Settings > Pulse > Foundation > Subsystems > Disabled Subsystems. How both work: Replacing and switching off subsystems of Pulse Foundation.
| Subsystem | Module | Kind | What for |
|---|---|---|---|
UPulseHUDSubsystem | PulseHUD | Overridable, switchable | Below. |
UPulseHUDNotificationRuleSubsystem | PulseHUD | Switchable | Notifications of your own instead of the notification rules; also goes off with the HUD. |
UPulseFrontendSubsystem | PulseFrontend | Overridable, switchable | An own flow from boot to the menu (Frontend). |
UPulseFrontendPlayerSubsystem | PulseFrontend | Switchable | A pause menu of your own; also goes off with the frontend. |
UPulseCombatHUDSubsystem | PulseCombatHUD | Switchable | A combat HUD of your own (Combat HUD). |
UPulseInteractUISubsystem | PulseInteractUI | Switchable | An interaction prompt of your own (Interaction system). |
UPulseInventoryUISubsystem | PulseInventoryUI | Switchable | A hotbar of your own (Inventory UI). |
UPulseMapUISubsystem | PulseMapUI | Switchable | Map widgets of your own; the map data (UPulseMapSubsystem) stays (Map). |
UPulseRespawnUISubsystem | PulseRespawnUI | Switchable | A death screen of your own; respawning stays (Death and respawn). |
UPulseStatusHUDSubsystem | PulseStatusHUD | Switchable | Status bars of your own (Status effects and attribute bars). |
Every caller of these handles their absence: the Blueprint nodes and Get functions give None, the cheats say so. The other subsystems of PulseGameplay stay on, because other parts build on them (inventory, combat, interaction, map data, respawn rules); their rules are exchangeable through settings, strategies or data instead.
The HUD. Switched off by the list (or Enable HUD off), the HUD takes along the notification rules (UPulseHUDNotificationRuleSubsystem, they show through the HUD) and stops being the UI host of the Pulse plugins: the modules with With UI Host start only when the UI settings of Pulse Foundation name a Presenter Class. The HUD tab of the settings menu stays until Register Player Settings is off.
To replace the HUD, derive from UPulseHUDSubsystem in C++ (a module loaded in the phase Default or earlier) and override RebuildHUD, which creates the layout for each new player controller; the base removes the layout of before with DestroyHUD first. Everything else (stacks, modals, notifications, markers) keeps working on the layout your class creates. UPulseHUDSubsystem::Get and the Blueprint getter of the subsystem give your class.
UCLASS()
class UMyHUDSubsystem : public UPulseHUDSubsystem
{
GENERATED_BODY()
protected:
virtual void RebuildHUD(APlayerController* InPlayerController) override
{
Super::RebuildHUD(InPlayerController);
// Your own widgets next to the layout of the settings
if (GetHUDLayout())
AddMyWidgets(InPlayerController);
}
void AddMyWidgets(APlayerController* InPlayerController);
};
Specs: PulseHUD.Subsystems, PulseFrontend.Subsystems, PulseCombatHUD.Subsystems, PulseInteractUI.Subsystems, PulseInventoryUI.Subsystems, PulseMap.UI.Subsystems, PulseRespawn.UI.Subsystems, PulseStatusHUD.Subsystems.
Integrations (bridge plugins)
| Bridge | What it adds |
|---|---|
PulseDialogHUDBridge | Opens the PulseDialog widget on a layer of the UI host while a dialog runs, sets input (cursor while choosing), hides the HUD during cutscenes, shows the bark lines of an add-on such as Pulse Dialog Barks as subtitles. |
PulseSkillHUDBridge | Notifications when the local player levels up, gets skill points, unlocks a skill or raises its rank (none from loading or the first replication after joining), and the skill menu of PulseSkill on the Menu layer of the UI host, opened and closed with an input action (key K by default). |
Each bridge has its own settings page under Project Settings > Pulse and a README. Toasts for quests and achievements are notification rules, no bridge.
Settings reference (UPulseHUDSettings)
| Setting | Meaning |
|---|---|
bEnableHUD, HUDLayoutClass, HUDZOrder | HUD subsystem and layout. |
bRegisterPlayerSettings | Adds the HUD options to the player settings (see “Player settings”). |
Style (FPulseHUDStyle) | Default modal, modal style, container, action button and button styles per role, compass and marker class, world marker, marker classes per marker kind (MarkerPresentationsByKind), tooltip, progress and context menu classes. |
MaxVisibleNotifications, MaxQueuedNotifications, DefaultNotificationDuration, NotificationTypeColorRoles, NotificationTypeIcons | Notifications. |
NotificationAreas | Area per kind of the notifications of the UI host (Pulse.UI.Notification.* to Pulse.HUD.Notification.*, parent tags count, empty: the default area). |
NotificationRules, RulesQuietAfterJoinSeconds | Notification rules. |
bHideGameplayHUDWhileMenuOpen | Hides the gameplay HUD while the main stack shows a menu. |
bShowCrosshairByDefault | Whether the crosshair is shown when the HUD is created. |
bShowCompassByDefault | Whether the compass is shown when the HUD is created. |
Defaults point at plugin content under /PulseGameplay/HUD/....