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

  1. Project Settings > Pulse > Gameplay > HUD: enable bEnableHUD and set HUDLayoutClass (default: /PulseGameplay/HUD/W_DefaultHUDWidget).
  2. The layout widget derives from UPulseHUDLayout and contains at least a stack container named Pulse.HUD.Stack.Main. For modals it needs a stack Pulse.HUD.Stack.Modal, for notifications a UPulseHUDNotificationArea, for the compass a panel named CompassSlot.
  3. Optional: enable bEnablePlayerInputManager (Project Settings > Pulse > Foundation > UI) so menus and modals (and the dialog bridge) set cursor and input mode.
  4. Optional: add the layers of Markers, tooltips and overlays that the game uses (the default layout has all of them).
  5. 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) unless Style.ConfirmButtonStyle / CancelButtonStyle / NeutralButtonStyle are set. UPulseHUDTextButton::StyleRole gives 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 (bUseThemeTransition on 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 optional AccentBar, the icon and the round IconBackground of notifications; NotificationTypeIcons gives notifications without own icon the icon of their type. PulseHUD defines the types Pulse.Notification.Success (positive, check), .Reward (highlight, diamond), .Item (accent, info), .Warning and .Error. FPulseUIMarkerData::ColorRole colors marker dots and tints icons; compass markers without icon show the theme’s diamond icon.
  • Crosshair: the layout’s optional Crosshair widget (default W_DefaultCrosshair, a dot with a dark ring in the middle of the screen, inside GameplayRoot so it hides with menus). UPulseHUDSubsystem::SetCrosshairVisible (e.g. only while aiming), bShowCrosshairByDefault in 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 reason Pulse.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 PulseHUDShowcase shows 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 1 adds 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:

  1. removes the old layout and cancels open modals (they report Cancel),
  2. creates the layout with CreateWidget(PlayerController, HUDLayoutClass) and adds it with AddToPlayerScreen(HUDZOrder),
  3. creates the compass (Style.CompassClass) and lets the layout place it (AddCompass, default: into CompassSlot),
  4. calls On HUD Initialized on the layout and broadcasts OnHUDCreated.

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 a UCommonActivatableWidgetQueue; 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) and AfterPush pins.
  • 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 onto Pulse.HUD.Stack.Modal, Overlay onto Pulse.HUD.Stack.Overlay; a layer without an entry onto Main.
  • Gameplay widgets go into the gameplay part of the layout (AddGameplayWidget of UPulseHUDLayout with 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 a GameplayRoot panel 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 no UPulseHUDTooltipWidget gets 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 kinds Success, Warning and Error become the success, warning and error kinds of the HUD, Info has no kind, kinds of plugins stay. Subtitle goes to Push 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 a UPulseHUDNotificationWidget, 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 (PushProgress with 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 (CancelActionId of 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) on UPulseHUDModal for 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.

  • UPulseHUDModalBase: activatable widget with an optional style frame (UPulseHUDModalStyle), close animation (CloseAnimation, or CloseDelay), payload, content and result. Override AddContent / RemoveContent to place content.
  • UPulseHUDModal: optional bound widgets TitleText, MessageText (text or rich text), ContentSlot (panel), ActionList (UDynamicEntryBox with UPulseHUDModalActionButton entries). Parts without data are collapsed. The confirm action gets the focus. PreviewTitle, PreviewMessage and PreviewActions show a preview in the designer.
  • UPulseHUDModalActionButton: CommonUI button with the label in ButtonTextBlock. SetupAction sets text, style (Style.ConfirmButtonStyle / CancelButtonStyle / NeutralButtonStyle or 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 channel Compass; add them with AddMarker(Data, Channels) of the registry (see World markers). They keep their handle (FPulseHandle) and survive a rebuilt HUD.
  • Markers are described by FPulseUIMarkerData of PulseFoundationUI (old names FPulseHUDMarkerData and FPulseHUDCompassMarkerData are redirected): WorldLocation or ActorToTrack (weak), Kind, Icon, Name, ColorRole, bPersistent, bShowDistance, DistanceUnits, MinDistance, MaxDistance, bRemoveWhenActorInvalid, CustomData (FInstancedStruct).
  • Compass only, without the registry: AddMarker / UpdateMarker / RemoveMarker / RemoveMarkersForActor of UPulseHUDCompassBase (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), optional MarkerIcon, MarkerNameText, MarkerDistanceText, animations AddMarkerAnim / RemoveMarkerAnim. Overridable: K2_CalcMarkerPosition, K2_ShouldBeVisibleOnCompass, OnMarkerDataChanged.
  • Compass widget: CompassBarImage (material with Offset / Orientation parameters), 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 MaxVisibleNotifications per area are visible (area override MaxVisibleOverride), at most MaxQueuedNotifications wait; 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 the PulseHUD.Notifications specs).
  • UPulseHUDNotificationArea: bound EntryBox (UDynamicEntryBox), AreaTag. UPulseHUDNotificationWidget: optional TitleText, MessageText (text block or rich text block, e.g. with key caps), IconImage, IconBackground (tinted with the type color at IconBackgroundOpacity), AccentBar, CountText (CountFormat), SpeakerText, animations ShowAnim / HideAnim, Dismiss(). bTintIconWithTypeColor tints 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 with AddInputContextForWidget, 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 (LayerInputs of 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::GetPlayerInputManager is the Blueprint node for a player controller; C++ calls Pulse::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):

  • UPulseHUDSubsystem is a snapshot provider (category HUD): 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/....


PulseGameplay plugin documentation.

This site uses Just the Docs, a documentation theme for Jekyll.