UI themes

The module PulseFoundationUI gives all Pulse widgets, and your own, one shared look. A theme is a data asset that holds colors, text styles, button styles, panel styles, brushes, widget styles, texts, sounds and motion timing. Widgets do not name a style; they name a role (“body text”, “primary button”, “popup panel”), and the theme decides how that role looks. One asset changes the look of every widget that uses it, in every Pulse plugin. Plugins and games add values for their own roles with theme extensions.

At a glance

  1. Project Settings > Pulse > Foundation > UI: set Default Theme (default: /PulseFoundation/UI/DA_PulseTheme_Default).
  2. In the UMG designer, select a widget, add the UI component Pulse Style and pick a Style Role, for example Pulse.UI.Text.Body on a Common Text Block or Pulse.UI.Panel.Popup on a Common Border. The designer shows the result right away.
  3. Make your own look: create a Pulse UI Theme data asset, set Parent Theme to the default theme and override only the roles you want to change.
  4. Change the look at runtime per player: Set Player Theme (or UPulseUIThemeSubsystem::SetTheme), for example a darker variant in a dangerous area. Widgets with Pulse Style components update themselves.

Roles

Roles are gameplay tags. The standard roles are native tags in PulseUITags.h; any other tag works as well, so games and plugins can add their own.

All values of a theme are in its Values (FPulseUIThemeValues), one map per kind:

Kind Map in Values Standard roles
Colors Colors Pulse.UI.Color.Accent, .Background (HUD elements: compass band, hotbar, marker pins), .Surface (panels), .Text, .TextMuted, .Positive, .Negative, .Warning, .Highlight, .Outline, .OnAccent, .Inset, .Backdrop, .BarLag (trailing loss of health bars)
Text styles TextStyles Pulse.UI.Text.Title, .Heading, .Subheading, .Label (small upper case labels), .Body, .Strong (emphasized body text, notification titles), .Small, .Caption, .Button, .Number, .Key (key names), .Overlay (text over the game world, with shadow), .OverlayLarge (damage numbers), .OverlayHeading (boss names), .Subtitle (spoken lines)
Letter case TextTransforms Per text or button role: ToUpper, ToLower or None; the default theme writes labels and buttons in upper case
Button styles ButtonStyles Pulse.UI.Button.Primary, .Secondary, .Danger, .Tab, .ListEntry, .Icon
Panels BorderStyles Pulse.UI.Panel.Window, .Popup, .Tooltip, .Toast, .Backdrop, .Inset, .HUD (containers on the HUD such as the hotbar)
Brushes Brushes Pulse.UI.Brush.Divider, .Focus, .Highlight, .Shadow, .MarkerDot, .MarkerPin, .EdgeArrow, .Glow, .Grain, .KeyCap (key cap behind key names without icon), .CompassBand, .Tick, .ProgressRing (material, scalar Percent), .Vignette, .Crosshair, .SlotActive (frame of the active slot); icons Pulse.UI.Icon.Chevron, .Arrow, .Close, .Check, .Dot, .Diamond, .Info, .Warning
Widget styles ProgressBarStyles, SliderStyles, CheckBoxStyles, ScrollBarStyles Pulse.UI.ProgressBar.Default, Pulse.UI.Slider.Default, Pulse.UI.CheckBox.Default, Pulse.UI.ScrollBar.Default
Texts Texts Labels widgets show, localizable; plugins use Pulse.UI.String.<Plugin>.<Name>
Sounds Sounds Pulse.UI.Sound.Open, .Close, .Notification, .Hint, .Error; each a sound asset or a Pulse Sound event (Sounds)
Aliases Aliases A role that takes the value of another role, for every kind (see below)

Text, button and panel styles are ordinary CommonUI style classes (UCommonTextStyle, UCommonButtonStyle, UCommonBorderStyle).

Themes and inheritance

UPulseUITheme (Primary Asset Type PulseUITheme) looks a role up in this order: the theme itself, its Parent Theme chain, the default theme of the settings, the theme extensions (higher priority first), then nothing (the widget keeps its own look). So a theme only needs the roles it changes. Motion timing is taken from the first theme in the chain with Override Motion set.

Aliases

An alias gives a role the value of another role, for every kind of value: Pulse.UI.Color.Selection -> Pulse.UI.Color.Accent makes the selection follow the accent color. Each theme and extension checks its own value of a role first, then its alias; the role of the alias is looked up again from the first theme. So an alias in a child theme wins over a value of the same role in its parent. Aliases that lead back to a role they passed (a ring) give no value; the log warns once per role and the asset check reports them.

The plugin ships two themes in /PulseFoundation/UI/:

Theme Look
DA_PulseTheme_Default “Pulse HUD Basisstil”: calm, dark, slightly transparent panels (Surface #141921 at 86 %, 1 px outline at 14 % white, soft shadow), three radii (8 panels, 5 buttons and slots, 3 bars), blue accent #5BC4F0, yellow highlight #F4C766; Roboto for text, Roboto Condensed for numbers, labels and keys
DA_PulseTheme_Light Light variant; inherits from the default theme and changes colors, text, button and panel styles

Colors have a meaning in the default theme: blue = active, selection, shield; yellow = goal and attention; green = health and success; red = damage and enemies; orange = warnings. Text over the game world uses the overlay roles with a shadow instead of a panel.

Lookup functions (Blueprint and C++): FindColor, GetColor, FindTextStyle, FindButtonStyle, FindBorderStyle, FindBrush, FindSound, FindText, GetText, FindTextTransform, FindButtonRole (role of a button style), GetMotion; C++ also FindBrushPtr, FindProgressBarStyle, FindSliderStyle, FindCheckBoxStyle, FindScrollBarStyle, FindValue(Role, &FPulseUIThemeValues::Colors) for any kind, VisitThemeChain and GatherValueSources. UPulseUITheme::Resolve(Theme) returns a theme, never null.

Data validation reports parent cycles, entries without role, empty style entries, aliases to the same role and alias rings.

Example: a theme that only changes colors, and a panel that uses style roles, key icons and motion (see Examples):

Theme extensions

A Pulse UI Theme Extension (UPulseUIThemeExtension, data asset) adds values to every theme without being part of one: a plugin gives its own roles (icons, texts, sounds) a look that works with any theme, a game adds roles or aliases for all its themes at once.

  • Values: the same maps as a theme.
  • Priority: order among the extensions, higher first. Themes always come before extensions, so a theme can change every value an extension brings.
  • Every extension of the project is used, wherever it lies (project, plugins, Fab packages): they are found by class in the asset registry and registered as Primary Asset Type PulseUIThemeExtension with the cook rule “always cook”, so nothing has to reference them. Two extensions with the same priority are ordered by asset path.
  • Project Settings > Pulse > Foundation > UI > Disabled Extensions turns single extensions off.
  • The check of an extension warns when another extension with the same priority sets the same role in the same map (which one wins depends on the path) and reports alias rings.
  • Console: Pulse.UI.Extensions lists the extensions in lookup order (Console).

C++: Pulse::UI::GetThemeExtensions(), ForEachThemeExtension, RefreshThemeExtensions (after changing extensions or the settings from code), FilterAndSortThemeExtensions, FindSharedRoles.

The Pulse Style component

UPulseUIStyleComponent (“Pulse Style”) applies roles to the widget it is attached to, in the designer (OnPreConstruct) and at runtime, and again when the player’s theme changes.

Widget StyleRole is looked up in
Common Text Block TextStyles (SetStyle) and the letter case of TextTransforms
Text Block, Rich Text Block TextStyles (font, color and shadow of the style); text blocks also take the letter case
Common Button ButtonStyles
Common Border BorderStyles
Border BorderStyles (background brush), else Brushes
Image Brushes, else Colors
Progress Bar, Slider, Check Box, Scroll Box the matching widget style map
  • ColorRole tints the widget afterwards (text color, image tint, border brush color, progress fill).
  • ThemeOverride makes the widget always use one theme.
  • SetStyleRole, SetColorRole, ApplyStyle change and apply roles at runtime.
  • Validation warns when the default theme has no entry for the role that fits the widget type.
  • Without component: Apply Style Role (UPulseUILibrary) once, or UPulseUIStyleComponent::ApplyRoleToWidget in C++. Pulse::UI::ApplyTextStyleToTextBlock gives a plain text block a CommonUI text style.

Key icons

Prompts, hints and buttons show keys as icons that follow the player’s input device.

  • Pulse Key Cap (UPulseUIKeyCap, palette “Pulse”): shows the key of an InputAction (Enhanced Input) or a fixed Key / GamepadKey, and updates itself when the player switches between keyboard and gamepad (CommonInput). Height sets the size; icons keep their aspect.
  • Pulse Key Decorator (UPulseUIKeyDecorator): add it to the decorator classes of a Rich Text Block and write <key id="E"/>, <key id="Gamepad_FaceButton_Bottom"/> or <key action="/Game/Input/IA_Jump.IA_Jump"/> into the text. HeightScale (default 2.2) sets the icon height relative to the font size.
  • C++: Pulse::UI::ResolveKeyDisplay, GetShortKeyName, MakeKeyCapWidget.

Icons come from CommonInput controller data (UCommonInputBaseControllerData). PulseFoundation ships three sets in /PulseFoundation/UI/Input/, drawn as soft 3D key caps and buttons:

Controller data Icons
CID_Pulse_KeyboardMouse A-Z, 0-9, F1-F12, Esc, Tab, Shift, Ctrl, Alt, Space, Caps, Enter, Backspace, Insert, Delete, Home, End, Page Up/Down, arrows, mouse buttons and wheel
CID_Pulse_Xbox A (green), B (red), X (blue), Y (yellow), LB/RB, LT/RT, View, Menu, sticks, D-pad; picked for XInput devices
CID_Pulse_Gamepad Generic gamepad: face buttons as direction symbols, L1/R1, L2/R2, sticks, Select, Start, D-pad

The key caps look the icon up in this order:

  1. The CommonInput platform settings of the project (Project Settings > Common Input > Platform Input > Windows > Controller Data). Register the Pulse sets there (or your own) to use them in CommonUI widgets too, for example the input action widgets of CommonUI buttons.
  2. Fallback Controller Data of the Pulse UI settings (default: the three Pulse sets). For gamepad keys the set whose hardware mapping matches the player’s last used device wins (Xbox for XInput), then the current gamepad name, then the generic set. So key icons work without any setup.
  3. No icon: the key name on a plain key cap (brush role Pulse.UI.Brush.KeyCap, text role Pulse.UI.Text.Key).

Theme per player

UPulseUIThemeSubsystem (local player) holds the theme of a player: SetTheme (null = default theme), GetTheme (never null), GetOwnTheme, events OnThemeChanged / OnThemeChangedNative. Nothing is replicated or saved. Pulse::UI::GetTheme(Widget) returns the theme of a widget’s owning player, in the designer the default theme. FindText and GetText of the subsystem read the texts of the player’s theme.

UI motion

UPulseUIMotionSubsystem (game instance) animates the render opacity, translation and scale of widgets, so widgets fade, slide and pop without UMG animations. It uses real time (runs while the game is paused) and only ticks while motions run. One motion per widget: a new one replaces the running one.

Preset Motion
FadeIn / FadeOut Opacity only (keeps the render translation, so it works on widgets that place themselves with it)
SlideIn / SlideOut Fade plus slide from or to a side (EPulseUIDirection) by Motion.SlideDistance
PopIn / PopOut Fade plus scale from or to Motion.PopScale
  • Blueprint: Play Pulse UI Motion (async, pins OnFinished and OnInterrupted) or Play Motion (fire and forget), Stop Motion.
  • C++: Pulse::UI::PlayMotion(Widget, Preset, Direction, Speed, OnFinished, Delay); the callback gets true at the end and false when the motion was replaced or stopped.
  • Durations (Fast, Normal, Slow), curves, distances and the stack transition come from FPulseUIMotion of the theme. Apply Stack Transition gives a CommonUI stack or queue the theme’s transition (call it before the container is shown).
  • Project setting Reduce Motion, or the player’s accessibility setting Reduce motion: widgets jump to the end state.

Text size: UPulseUIThemeSubsystem has a text scale per player (Set Text Scale, Get Text Scale; the accessibility setting Text size sets it). Text roles get the font size of their style times the scale, and widgets update like on a theme change.

Other functions

UPulseUILibrary: Get Widget Theme, Get Player Theme, Set Player Theme, Find Theme Text, Get Theme Text (labels a game can rename in its theme), Apply Style Role, Play Theme Sound (2D sound of a sound role, through Pulse::Sound::Play), Apply Stack Transition, Play Motion, Stop Motion.

Where widgets of plugins show (the UI host)

Plugins never talk to the HUD of the game. They hand their widgets to the presenter of the local player (UPulseUIPresenter, the UI host), which decides where they show:

Function Does
Open Widget On Layer (controller, layer, class) Shows a widget on a layer and returns it. A widget of the class that is open on that layer already (also one another widget of the layer covers) comes back as it is: one open widget per class and layer, the same class on two layers gives two widgets. Open Widget is the same on the Menu layer. In C++ a setup function runs on the widget before it is activated (the pause menu sets its type), also for a widget that was open.
Close Layer, Close Widgets, Close Widget, Find Widget, Find Widget On Layer Close the widgets of one layer or of all layers (also covered ones), close one widget (also a covered one, so it does not come back when the widgets above it close; it returns whether the widget was open), find the widget of a class the presenter opened last or on a layer
Is Host Ready, On Host Ready The host can take gameplay widgets (the HUD built its layout); On Host Ready comes again after every map change, which builds a new host. Add gameplay widgets when the host is ready and again after each On Host Ready. Modules listen to On Host Ready of the presenter subsystem, which also comes after the game set another presenter (see below).
Add Gameplay Widget (controller, widget, placement), Remove Gameplay Widget A widget in the gameplay part of the screen (minimap, tracker, status bars): anchor from (0, 0) top left to (1, 1) bottom right, offset towards the middle, size (0 for the desired size); Fill stretches it over the whole screen instead (floating texts, a damage overlay, a build overlay above the hotbar) at its Padding from the edges and ignores anchor, offset and size
Find Gameplay Widget (controller, class) A widget of the class the host shows, also one the layout of the HUD placed itself, so a plugin adds no second minimap
Add Gameplay Hide Request, Remove Gameplay Hide Request, Is Gameplay Hidden Hide the gameplay part while any reason (a gameplay tag such as a cutscene) is left; a request without reason is ignored. A widget the game changes while hidden (to anything but Collapsed) keeps the visibility of the game.
Show Notification (controller, notification), Hide Notification (controller, handle) A short message that goes away by itself (FPulseUINotification: kind Pulse.UI.Notification.Info, Success, Warning, Error, Subtitle (a spoken line, the title is the speaker) or one of a plugin below them, title, message, icon, duration, merge key, priority (waiting notifications with a higher one show first), widget class (the host takes it only when it fits, the Pulse HUD a child of UPulseHUDNotificationWidget), payload). It returns a handle; Hide Notification takes the notification back before it goes by itself (the next line of the same speaker). The handle is valid also when the host only logged or skipped the notification.
Show Progress (controller, request), Update Progress (handle, progress, text), Hide Progress (handle) A progress overlay until it is hidden (loading, waiting for a reconnect; FPulseUIProgressRequest: title, text, progress from 0 to 1 or below 0 while unknown, block input, payload). Call Update Progress and Hide Progress on the presenter that showed it, also when the game set another one in between; an empty text keeps the one it has. A host may close its overlays and notifications when it stops serving the player (the Pulse HUD does): show an overlay that still matters again after On Host Ready.
Show Tooltip (controller, request, anchor, follow mouse, delay), Hide Tooltip A tooltip next to a widget (FPulseUITooltipRequest: title, text, icon, widget class, payload). A tooltip widget of your own derives from UPulseUITooltipWidget and shows the request in On Tooltip Request Set. Hide Tooltip without anchor hides every tooltip the presenter showed; the default gives an anchor its own tooltip back.
Show Modal (controller, request), Close Modal, Close All Modals, Is Modal Open Asks the player: title, message, buttons (FPulseUIModalRequest; Make Message Modal Request and Make Confirm Modal Request, in C++ MakeMessage and MakeConfirm, turn empty button texts into Close, Confirm and Cancel); answers once with the id of the button, the cancel action when the back key or Close Modal ends it. C++ passes a callback, Blueprint listens to On Modal Finished (handle, action). A button has a Role (Primary, Neutral, Cancel, Destructive; Auto: a cancel action is Cancel, the first Auto answer that does not cancel is Primary unless another button is set to Primary). Get Modal Action Role, or Get Action Role of the modal widget, gives the role to show.

The layers are gameplay tags below Pulse.UI.Layer: Game (windows such as inventory and map), Menu (pause menu, save menu, settings), Modal and Overlay (progress, loading). Games add their own.

Which presenter. Every local player has one (UPulseUIPresenterSubsystem, Get Pulse UI Presenter, Pulse::UI::GetPresenter(Controller)):

  1. one the game sets at runtime (Set Presenter, Set Presenter Class),
  2. else Presenter Class of Project Settings > Pulse > Foundation > UI,
  3. else the presenter a plugin with its own UI host registers (the Pulse HUD of PulseGameplay does: Pulse::UI::Presenter::SetDefaultPresenterClass),
  4. else the default, which adds everything to the viewport: layers at the Z order of Layer Z Orders (Game 20, Menu 50, Modal 100, Overlay 150), gameplay widgets below them at their placement (hide requests collapse them), modals with the Modal Class of the settings (a UPulseUIModal: it gets the request in On Request and calls Choose with the id of the button), tooltips as the tooltip of the anchor (shown by the engine while the cursor is over it), notifications and progress overlays only in the log (their handles are valid, hiding them does nothing). It is ready as soon as the player has a controller. Without a Modal Class it shows the built-in Pulse Default Modal (UPulseUIDefaultModal): a dimmed backdrop and a panel with title, message, the content widget of the request and a button per action, styled from the theme (Pulse.UI.Panel.Popup, text roles Heading, Body and Button, colors Backdrop, Surface, Outline, Accent for the primary button, Negative for a destructive one, Inset for the others, Text and On Accent). The primary button gets the focus. A Blueprint child of it can change Max Width, or bring a tree of its own and fill it in On Request.

A game with a UI of its own derives a presenter in Blueprint or C++. It binds to its HUD in On Initialize Presenter (unbinds in On Deinitialize Presenter; On Player Controller Changed comes after a map change) and overrides, in groups:

  • Open Widget On Layer (call Prepare Widget before activating the widget, so the setup of the caller runs, Remember Widget after, so Close Layer, Close Widgets and Find Widget know it, and Apply Layer Input after the activation, so the widget gets the input context of its layer) together with Close Layer, Close Widgets and Close Widget when its widgets close another way,
  • Is Host Ready (call Notify Host Ready when its layout exists; the HUD of the game may call it on the presenter too), Add Gameplay Widget, Remove Gameplay Widget and Find Gameplay Widget,
  • the hide requests (call the parent function, it keeps the reasons of Is Gameplay Hidden),
  • Show Notification and Hide Notification, Show Progress, Update Progress and Hide Progress, Show Tooltip and Hide Tooltip,
  • Present Modal (call Finish Modal with the answer) and Dismiss Modal.

What it leaves alone works like the default, which knows only the widgets it opened or remembered. Some plugins also name a presenter class in their own settings (PresenterClass of the save menus); it wins for the menus of that plugin.

Host ready after a presenter change. On Host Ready of UPulseUIPresenterSubsystem (C++ OnHostReadyNative) forwards the event of the presenter the player has now. After Set Presenter it comes once more when the new host is ready for the controller of the player (unless the host said so itself while it was initialized), after Set Presenter Class when the new presenter is made and ready. The subsystem makes the presenter when the player gets a controller, and that controller change announces it; Set Presenter Class makes the new one right away when the player has a controller. A module still asks Is Host Ready when it starts and listens to the subsystem from then on. While the presenter of before ends (its open modals answer their cancel action), Get Presenter returns none.

When UI modules turn on

The UI modules of the plugins (minimap and world map, status bars, death screen, ping menu) have a setting of the type EPulseUIModuleActivation, default With UI Host:

Value The module is on
With UI Host Only when a UI host is set up: Presenter Class of Project Settings > Pulse > Foundation > UI names one, or the plugin that registered its presenter is in use (the Pulse HUD of PulseGameplay with Enable HUD)
Always Also with the default presenter, which adds everything to the viewport
Never Never

Pulse::UI::Presenter::IsHostConfigured() (Blueprint Is UI Host Configured) answers whether a host is set up; a presenter the game sets at runtime does not count. A plugin with its own host registers next to its class whether it is in use, the class first: registering a class removes the check of before, so the check of an unloaded plugin never applies to another class.

// StartupModule of the plugin (the Pulse HUD registers its setting Enable HUD)
Pulse::UI::Presenter::SetDefaultPresenterClass(UMyHUDPresenter::StaticClass());
Pulse::UI::Presenter::SetDefaultPresenterCheck([]() { return GetDefault<UMyHUDSettings>()->bEnableHUD; });

// ShutdownModule
Pulse::UI::Presenter::SetDefaultPresenterClass(nullptr);
Pulse::UI::Presenter::SetDefaultPresenterCheck(nullptr);

A registered class without a check counts as in use. A module decides with Pulse::UI::Presenter::ShouldActivateModule(Settings->MapUIActivation, Pulse::UI::Presenter::IsHostConfigured()).

Gameplay widgets added by code

A HUD with a layout of its own places the gameplay widgets of the modules itself (a minimap in its corner). For a host without one, such as the default presenter, a module may add its widget by code: a setting of the type FPulseUIGameplayWidgetPlacement with Add By Code (off by default), Widget Class (a child of the class the module looks for, none for that class) and Placement. In C++ the module keeps an FPulseUIGameplayWidgetSlot per widget:

// When the module starts (if Is Host Ready) and on every OnHostReadyNative of UPulseUIPresenterSubsystem
UUserWidget* hotbar = HotbarSlot.Ensure(presenter, controller, UMyHotbarWidget::StaticClass(), Settings->HotbarPlacement);

// Deinitialize of the module: removes only the widget the slot added
HotbarSlot.Remove(presenter, controller);

Ensure does nothing while the host is not ready. It uses the widget of the class the host shows (Find Gameplay Widget); only when there is none and Add By Code is on, it creates the widget for the controller and adds it at the placement (again after the host dropped it for a new layout). Turned off, or when the host shows another widget of the class, it removes the widget it added. A widget of another controller it forgets (the host of the old map took it with it), so a new controller of the local player needs no call. It remembers only the widget it added, weakly, so Remove never takes a widget of the host. Modules that always added their widget (the minimap, the status bars) pass their own switch as Add By Code.

Input contexts

A menu needs the cursor and the input while it is open, the game gets them back when it closes. With Enable Player Input Manager (Project Settings > Pulse > Foundation > UI > Input, off by default, needs a restart) every local player gets a player input manager (UPulsePlayerInputManager, Pulse::UI::GetPlayerInputManager) that sets cursor and input mode from a list of input contexts (FPulseInputContext: cursor Show, Hide or Inherit, input mode Game, UI, Game and UI or Inherit, widget to focus, mouse lock, flush pressed keys, hide the cursor during capture). Don’t set input mode or cursor by hand while it is on.

Function Does
Add Input Context (context, priority) Adds a context and returns its handle (FPulseHandle)
Add Input Context For Widget (widget, context, priority) The same, removed by itself when the widget closes (activatable widgets) or is destructed; without a widget to focus the widget (or its desired focus target) gets the focus
Remove Input Context, Has Input Context, Refresh Input Removes a context (and clears the handle), asks whether it is still active, applies the contexts again after something else changed the input mode

The context with the highest priority wins, with equal priority the newest one. Cursor and input mode come from the first context that does not inherit them, else from Show Mouse Cursor By Default and Default Input Mode of the settings; focus, mouse lock, cursor capture and flush come from the top context. Clear Contexts On Controller Change drops every context after a map change. Make Menu (cursor, UI only, flush) and Make Game And Menu (cursor, game and UI) in C++ give the common contexts. A local player class that implements IPulsePlayerInputManagerOwner decides itself with Should Create Input Manager. The Pulse Debugger shows the contexts top first and the result under “UI”; the timeline logs every change (UI, Input).

The input manager is overridable: a class of your game derived from UPulsePlayerInputManager replaces it, with own rules in ResolveContexts and ApplyContexts (Replacing and switching off subsystems). Pulse::UI::GetPlayerInputManager gives the replacement.

Layer input. The presenter adds a context for the widgets it opens on a layer: Layer Inputs of the presenter (FPulseUILayerInput: add a context, the context, its priority), by default Menu (priority 100) and Modal (priority 1000) with a menu context, the other layers none. Apply Layer Input adds it with Add Input Context For Widget, one while the widget is active (opened again it keeps its context; a stack that covers the widget takes it away, and it comes back when the widget shows again); the default calls it after the activation and for its modals, a host after it pushed the widget (the presenter of the Pulse HUD of PulseGameplay). Without the input manager nothing is added.

Markers

Pings, quest targets, build sites and waypoints are markers. Plugins never put them on a HUD themselves: every local player has a marker register (UPulseUIMarkerSubsystem, Get Pulse UI Markers, Pulse::UI::GetMarkers with a local player, a controller or any object of its world) that keeps them as plain data, and the parts of the UI that show markers read it.

Function Does
Add Marker (data, channels, presentation) Adds a marker and returns its handle (FPulseHandle); without a channel nothing is added and the handle is invalid
Update Marker (handle, data) Replaces the data; the channels stay as they were added
Remove Marker, Remove Markers For Actor, Remove Markers Of Kind Removes one marker (the node of the registry also clears the handle), the markers that track an actor, the markers of a kind and its child kinds
Find Marker, Get Markers (channels, kinds), Get Num Markers (channels) Reads the register; 0 channels and no kinds mean every marker. In C++ also FindMarkerForActor (actor, kind) and GetMarkerRecords
On Marker Changed (OnMarkerChangedNative in C++) Added, Updated or Removed with the record, always after the change

Data (FPulseUIMarkerData): world location or an actor to track (with Remove When Actor Invalid), an offset on the screen, icon, name, color role of the theme, Kind, persistent, distance text, units and a range (Min Distance, Max Distance in the units of the marker, 0 = no limit), screen edge, custom data. In C++ GetLocation, IsActorGone, NeedsDistance, GetMaxDistanceCm and IsInRange (a distance in centimeters), and Pulse::UI::Markers::ToCentimeters, ConvertDistance and FormatDistance for the units (centimeters, meters, kilometers, miles, feet).

Channels (EPulseUIMarkerChannels, a bit mask): Compass 1, Screen 2 (at the projected world location), Map 4 (minimap and world map). A marker is in every channel it was added with; each consumer draws its own.

Kinds are gameplay tags below Pulse.UI.Marker (Pulse.UI.Marker.Generic for markers without a kind of their own). Every plugin declares its kinds itself (a ping plugin Pulse.UI.Marker.Ping). Filters and Remove Markers Of Kind use them, and a HUD can pick a look per kind. Presentation is an instanced struct for the data of one host (the Pulse HUD of PulseGameplay keeps its widget classes there); the register never reads it.

Lifetime. Markers stay while the HUD is built again (the HUD draws the ones that are there). The cleanup of the player’s world (map change, end of play) removes every marker, with one Removed each. A marker of a tracked actor with Remove When Actor Invalid goes when the actor is gone: the register checks every 0.5 s, only while such markers exist.

Without a HUD. The register is always there and holds the data; a map shows its map markers without a HUD. Compass and screen markers need a consumer, the Pulse HUD of PulseGameplay or a HUD of the game that listens to On Marker Changed. Markers are not part of the presenter. The Pulse Debugger shows the markers under “UI”, the timeline logs every change (UI, Marker), and PulseUIMarkersDraw draws them as debug text.

Cheats

Cheat Does
PulseUITheme <name or path> Gives the local player a theme, e.g. PulseUITheme DA_PulseTheme_Light
PulseUIThemeReset Back to the default theme
PulseUIThemeList Lists the theme assets
PulseUIMarker <distance> <channels> Adds a marker of kind Pulse.UI.Marker.Generic in front of the player (distance in cm, 1000 if left out; channels Compass 1, Screen 2, Map 4 as a sum, all if left out)
PulseUIMarkersClear [all] Removes the markers of PulseUIMarker, with all every marker of the register
PulseUIMarkersDraw [seconds] Lists the markers and draws them as debug text in the world (10 s if left out), without a HUD

Content

/PulseFoundation/UI/: the two themes, Styles/ (text styles TS_Pulse_*, button styles BS_Pulse_*, border styles BRS_Pulse_*, light variants in Styles/Light), Fonts/F_PulseRoboto (typefaces Regular, Medium, SemiBold, Bold, Italic of Roboto and CondensedMedium, CondensedBold of Roboto Condensed; both SIL Open Font License 1.1, see License/Roboto.txt and License/RobotoCondensed.txt), Textures/ (white, tintable icons, soft shadow, glow, grain, focus corners, key cap, compass band, marker pin, vignette, crosshair, active slot frame, hit arc), Materials/ (M_PulseUI_RadialProgress: ring with track and center disc, Percent, Thickness, TrackColor, CenterColor, fill = brush tint; M_PulseUI_RadialWipe: clockwise wipe for cooldowns, Percent) and Input/ (key icons and controller data).


PulseFoundation plugin documentation.

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