Skip to content
This documentation describes SGC Loading Screen 2.5.0, which is coming to FAB soon. The version on FAB now is 1.0.0.

What's new

Intermediate versions between 1.0.0 and the latest released version were not published separately on FAB.

  • Style presets Classic, Minimal and Cinematic. Pick one when you create an SGC Loading Screen Widget from the Content Browser; on the startup screen settings page, Apply Preset changes only the appearance (animation, text styles, progress bar and placements) and is written to disk by Save.
  • Startup screen: Progress Fill Color and Progress Width settings.
  • Rich text in tips. SGC Loading Tip: Use Rich Text (off by default) and Rich Text Styles — named text styles for markup such as Press <Key>E</>. Text styles only: no images, links or decorators. An unknown style stays visible as plain text and logs one warning.
  • Fill by Names… in the context menu of an SGC Loading Content Set: finds T_Loading_<Map> and T_Loading_<Map>_<N> textures in a folder, previews them, and adds the backgrounds of one chosen map to the set (with Undo; the asset is not saved for you). Ambiguous names are chosen by hand.
  • What’s New window in the editor: links to the documentation and the video overview and the changes of this version. Shown on every editor start until Don’t show again is checked; a new version of the plugin shows it again. Reopen it from Help → SGC Loading Screen: What’s New.
  • Documentation website https://sgc-docs.github.io/loading-screen/ (English and Russian, search, quick start, guides and a reference generated from the code) replaces the PDF files. The Documentation link of the plugin and of the What’s New window opens it.
  • Events and state of the screen. Get Loading Screen Events returns an object with On Shown (Context), On Dismiss Started (Completion) and On Finished (Completion); Get Loading State (Unavailable, Idle, Pending, Visible, FadingOut); the async node Wait For Loading Screen Shown (On Shown, On Not Shown with the outcome). Outcomes: Ready, Cancelled, Timed Out, Show Failed.
  • Max Visible Secs (0 = off): closes the screen with the Timed Out outcome that many seconds after it first became visible, so a forgotten Dismiss no longer holds the screen forever.
  • Interactive screen. The widgets of the screen receive input and focus while the rest of the game input of its viewport stays blocked; focus returns after the screen closes.
  • Continue On Input (off by default) and the node Set Loading Screen Continue On Input: after 100 % the screen waits for a key, a mouse click, a gamepad button or a touch (“Press any key to continue”). Works in every mode, for a single player.
  • Wait For All Players Ready on a dedicated server: waits for the result of the server session of the current generation.
  • Content sets. The Data Asset SGC Loading Content Set (tips, String Tables, backgrounds, maps, Add To Common / Replace Common, Priority), the setting Content Sets and the C++ registration API SGCLoadingContent::RegisterSource / UnregisterSource. The content is chosen by the destination map; tips can come from a String Table. The sets are cooked automatically.
  • Game Feature Action “Add Loading Content” in the optional module SGCLoadingScreenGameFeatures (setting Enable Game Feature Actions, needs the GameFeatures plugin and a restart).
  • Module SGCLoadingScreenSlate: the Slate views and the shared settings of the startup and the game screen.
  • Reduce Motion: the project setting and the player’s choice (nodes Set / Get Loading Screen Reduce Motion, saved in GameUserSettings.ini).
  • Startup screen: Animation Style, Animation Color, Animation Size, Show Progress (off) and Progress Placement.
  • Add / Remove / Clear Loading Tips and Backgrounds change only their own source: an identical item from a content set stays while another source holds it.
  • Block Input While Visible blocks the game input, not the widgets of the screen. During a blocking map load (MoviePlayer) the game input is always absorbed.
  • The startup screen draws the same views as the game screen: the nine animation styles instead of the engine throbber (Show Throbber keeps its name), the shared status element, an optional progress bar.
  • New factory look of the startup screen: status 16 (was 14), tip 20 in white (was 16, gray), text shadow. Saved values do not change.
  • FSGCLoadingTextStyle moved to the module SGCLoadingScreenSlate: a redirect is in Config/DefaultSGCLoadingScreen.ini, the old header includes the new one, the ini keys are the same.
  • The tooltips of Push / Dismiss Loading Screen and of Loading Screen Mode no longer mention hiding nodes.
  • The Blueprint node filter in the editor that hid Push / Dismiss Loading Screen by the screen mode: both nodes are always shown.
  • SGC Loading Progress element: an honest progress bar with an optional percentage. The value comes from the engine load phases, the game holds and the duration history of the map; 100 % means the screen can close. Works during a blocking map load (MoviePlayer).
  • Get Loading Progress node: the displayed progress from 0 to 1 (0 without a screen).
  • Duration history per map in GameUserSettings.ini (section SGCLoadingScreen.LoadHistory). Only successful loads are written.
  • Closing chord of SGC Loading Animation: Finish Style — Ring (default), Check, None; it plays in the first 0.3 s of the fade-out.
  • Zoom during the fade-out and the Dismiss Zoom Scale setting (1.04; 1 turns it off).
  • Status line Preparing graphics for your GPU (N) when the PSO phase has more than 100 PSOs (the startup screen too).
  • Metrics overlay: a Holds: line (tag, owner, age). A hold longer than 30 s adds a warning to the log.
  • Startup settings page: a notice about unsaved changes, a notification after Save, the Reload Saved button.
  • Blueprint Set nodes for the 43 properties of SGC Loading Animation, Background, Tip and Load Status, and for the properties of SGC Loading Progress and Finish Style.
  • TestKit: the SGCTest.Progress command.
  • Closing order: loading completes → world rendering resumes → wait for a fresh texture streaming count (up to Auto Dismiss Max Texture Streaming Wait Secs, now in every mode) → progress runs out to 100 % → fade-out. Before, world rendering resumed only when the fade-out began.
  • A new game hold or a travel during the fade-out brings the screen back in every mode (before, only in the automatic show modes); engine counters do not. Work that appears after 100 % starts a new progress count.
  • The factory layout and the built-in screen have a progress bar under the status. Existing Widget Blueprints do not change: add the element by hand (see RELEASE_NOTES.md).
  • The fade-out and the zoom apply to the plugin’s container around your widget, not to the widget itself.
  • Waiting Status Text is now WaitingStatusText_DEPRECATED and hidden from Project Settings. The ini key is the same; the value still goes to the deprecated Level Load Status event. Use Idle Text of the SGC Load Status element instead.
  • Slides during a blocking map load: the screen is handed to MoviePlayer only with its first slide ready. Only the current and the next slide stay in memory; when the next one is not ready in time, the current slide starts a new round (the zoom reverses, no transition or text animation) and changes normally as soon as the next one arrives.
  • Layout of the built-in screen and of the factory: Tip and Load Status share one vertical column, so a multi-line status no longer covers the tip.
  • After the Load Status Max PSO Wait Secs limit the status line says that PSOs compile in the background (PSO compiling in background: N), so the screen no longer looks like it is still waiting.
  • Wait For All Players: a client that joins or finishes loading after the timeout gets the timeout event in the widget (before, only the Timed Out result of the Wait For All Players Ready node). With no screen at that moment, the first screen on this map gets it; a travel or reconnect clears it.
  • Wait For All Players: the server took the timeout without the 1 s minimum that the client and the node applied; all three now use one value.
  • Tooltips of Wait For All Players, Load Status Complete Delay Secs, Load Status Max PSO Wait Secs and of the SGC Loading Screen Widget class no longer rely on the deprecated Level Load Status event; Waiting Status Text says that it applies only to that event.
  • SGC Loading Animation, SGC Loading Background, SGC Loading Tip and SGC Load Status: the C++ properties are private, use the Get/Set functions (GetFont, SetFont, …). Names, default values and Details are unchanged; in Blueprint the properties stay read-only and the Get nodes keep working.
  • Project Settings: warning icons next to Fast PSO Precompile While Visible, Load Status Max PSO Wait Secs (when above 0), Wait For All Players and the startup screen switch; the tooltip says what to restart or where to test.
  • C++: FOnSGCStartupLoadingScreenSettingsChanged is deprecated, use FSGCStartupLoadingScreenSettingsChangedDelegate. USGCLoadingScreenSettings::bManualLoadingScreen is now bManualLoadingScreen_DEPRECATED (the ini key is the same and is still migrated to the mode).
  • Existing Widget Blueprints keep their layout. To get the new one, add a Vertical Box at the bottom of the screen’s content overlay, put Tip and Load Status into it and give Tip a bottom padding.
  • Internal cleanup, no change in behavior: comments, includes and module dependencies, Transient fields, names, dead code, one shared StreamableManager, the Arc animation without per-frame arrays.
  • A hold set during the fade-out brings the screen back in the auto-show modes (before, the screen closed).
  • Dismiss and Push from the screen widget’s Construct or from an On Holds Changed handler no longer break the state: a screen request has an identity, and an old continuation does not act on a new request.
  • A failed map load closes only its own load: the “Loading level” hold does not hang; a load of another Game Instance does not affect the screen.
  • The Loading Screen Widget class fails to load or cannot be created: the built-in screen and one error in the log (before, no screen appeared).
  • The deferred callback of the widget class load is cancelled together with the load.
  • Screen handed to MoviePlayer during a map load: Blueprint ticks return only after the loading thread has stopped; holds set by game code during the load update the screen after it is returned.
  • Fast PSO Precompile with several Game Instances: the mode returns when the last screen is closed.
  • Wait For All Players: server change (the counters are tied to the connection); the server timeout runs on real time (independent of pause and time dilation); the server tells “all ready” from “timeout”; the initial PIE world.
  • Startup screen: several Movie Streamers (the first one that initializes successfully is chosen, registering another does not change the playing one), cleanup after a failed initialization, a fallback windowed fullscreen mode when the window resize guard fails.
  • The PSO count for the startup screen and for the status during a map load is read on the render thread and published atomically; the shader count from other threads covers only local tasks.
  • Slide backgrounds: an image that is not ready is never shown (the “show after 3 seconds” bypass is removed); an image that is not ready within 10 s is skipped until the next round; preparing the first frame has one shared time budget.
  • Watch PSO Precompile: the ticker is removed before On Finished; the node survives being finished from its own events.
  • Holds: one tag, one owner. Only the object that set a hold can update or release it; a call from another object is rejected with a warning that names both objects. The hold of a destroyed owner stops counting at once.
  • Work on demand: a static manual-dismiss screen after the load is complete does not tick; slide content works only while its elements are drawn (a hidden stored widget no longer keeps the background loading); the players wait server and the Wait For All Players Ready node run on events, without a per-frame ticker; the overlay in memory-only mode runs on a timer.
  • Wait For All Players Ready reads the timeout once, at the start of the wait.
  • Log: screen state transitions (Verbose) with the reason, the map and the request number; SGC.LoadingScreen.Why shows the load phase and the request number.
  • C++: FSGCLoadWorkSnapshot::CaptureThreadSafe is renamed to CaptureFromAnyThread; FSGCPSOStatus and FSGCPSOStatusSubscription are added (Core module).
  • Internal cleanup, no change in behavior: one state for the startup movie, the SGC Loading Screen Widget is created through the engine’s Widget Blueprint factory, internal headers moved to Private, automated tests for holds, status lines and the auto-dismiss decision.
  • README: which C++ API is stable.
  • The screen keeps moving during a blocking map load: MoviePlayer draws it on the loading thread, so the animation, slides and tips go on while your UMG stays still. Setting Keep Elements Alive During Map Load (on by default). Games, Standalone and packaged builds; not in the editor or PIE.
  • Compile warning for a loading screen with property bindings, a Blueprint OnPaint, list views or a Retainer Box: such a screen stays still during map loads.
  • Warning icon next to Keep Elements Alive During Map Load in Project Settings: the effect is not visible in the editor or PIE.
  • SGC.LoadingScreen.SimulateMapLoadSecs console variable (development builds): makes every map load longer to preview the screen on a long load.
  • Startup screen: the counts stayed the same for the whole engine start.
  • SGC Loading Background: a one-frame jump of the image when slides of different aspect ratios change.
  • SGC Loading Background: in Standalone (editor builds) images of the first round could be squeezed and blurry. A slide now waits until its texture is compiled and fully streamed in, and keeps it at full quality while shown.
  • The screen is complete on its first frame: the first slide and its image are ready before it is drawn, so the background is never empty or see-through.
  • Status lines show the map load from its very start, end with animated dots, and the package, shader and PSO counts stay live during the load (SGC Load Status and the startup screen).
  • SGC Loading Background and SGC Loading Tip update in Slate Tick.
  • Slides: SGC Loading Background and SGC Loading Tip change together on one clock. A slide stays for the longest interval of the elements and for the time needed to read its text (Reading Speed).
  • Shuffled order without repeats: every tip and background is shown once per round, a new order each round, no repeat at the round change; the round continues after a game restart.
  • SGC Loading Background struct: image (soft reference) and an optional text of its own.
  • Remove Loading Tips, Remove Loading Backgrounds.
  • Slow zoom of the background (Zoom Amount): in and out by turns, drifting along a new diagonal each time.
  • Tip change with a fade and a small shift.
  • Add Loading Backgrounds takes SGC Loading Background entries; images load asynchronously and only while the screen shows them, then unload. An entry that fails to load is removed with a warning.
  • A tip or background already in the list is not added twice, so the widget’s Construct can add the same list again.
  • SGC Loading Animation continues smoothly after a frozen frame.
  • Holds: the screen stays while any hold exists. Set / Release Loading Screen Hold with a Gameplay Tag reason (LoadingScreen.Hold.*), progress and status text; Is Loading Screen Held, Get Loading Screen Holds; C++ FSGCScopedLoadingHold.
  • A hold is released by itself when its owner is destroyed.
  • Built-in screen when no widget is set: works right after enabling the plugin.
  • New SGC Loading Screen Widget comes with a ready layout (background, safe zone, tip, status, animation).
  • Warning icon in Project Settings next to the modes that need Push / Dismiss.
  • SGC.LoadingScreen.Why console command; reminder in development builds when the screen waits for Dismiss.
  • SGC Load Status: lines of game holds with progress (Show Game Holds, Show Progress).
  • PSO precompile for your game: Watch PSO Precompile (On Started, On Progress, On Finished) and Get PSO Precompile Status.
  • README with a quick start.
  • The loading screen subsystem is split into small systems; the same status lines everywhere (screen, SGC Load Status, startup screen).
  • SGC Load Status updates only when the holds change.
  • Startup screen closes when engine initialization is done (plus Hold Screen Additional Secs).
  • Wait For All Players: a player is ready when its own screen has no hold left (game holds included, PSOs excluded); the timeout reaches every player by a reliable RPC before the timeout travel; the server works only when something changes.
  • Level Load Status widget event (still fired, with the same data as SGC Load Status).
  • Show Retry Interval Secs setting (unused since 1.1.0).
  • Manual Show / Auto Dismiss: Push without a following load kept the screen forever.
  • Automatic: a new load during the dismiss fade closed the screen before the load finished.
  • Wait For All Players Ready could fire with the previous map’s state after seamless travel.
  • Wait For Loading Screen Dismissed never fired on a dedicated server.
  • Startup screen read engine counters from the Slate loading thread.
  • Session-wide loading tips and backgrounds: Add / Clear Loading Tips, Add / Clear Loading Backgrounds.
  • SGC Loading Tip widget: random tip, timed change with fade.
  • SGC Loading Background widget: random background, timed cross-fade.
  • SGC Loading Animation widget: 9 procedural styles, no assets needed.
  • Set Custom Text 1/2/3, Set Custom Image (still work).
  • The new widgets pause while the engine loads a map.
  • Wait For All Players: after ServerTravel the screen closes for all players at once.
  • Wait timeout, On Wait For Players Timeout event, optional Timeout Travel Map.
  • Wait For All Players Ready node for manual modes.
  • “Waiting for players: N of M” line in Level Load Status and SGC Load Status.
  • SGC Load Status widget: self-updating load status lines for any UMG widget.
  • Loading Screen Mode: Auto Show / Manual Dismiss, Automatic, Manual, Manual Show / Auto Dismiss.
  • Automatic show on seamless travel, client travel and server connection.
  • Automatic dismiss when loading completes, with optional texture streaming wait.
  • Load Status Max PSO Wait Secs and Fast PSO Precompile While Visible.
  • Widget class preload at Game Instance start.
  • Localizable status texts with Russian translation.
  • Verbose load work log for diagnostics.
  • Engine version 5.8.0.
  • The screen appears on the first possible frame.
  • The screen and metrics overlay attach only to their own Game Instance viewport.
  • Push / Dismiss nodes are hidden from the menu when the mode does not need them.
  • Block Input While Visible: in PIE blocks only the game viewport; the console works in non-shipping builds.
  • Metrics overlay FPS is an exact average over the update interval.
  • Show Retry Interval Secs (unused).
  • Manual Loading Screen, migrated to Loading Screen Mode.
  • The world flashed before the screen appeared.
  • Wait For Loading Screen Dismissed did not fire when the screen failed to show.
  • Level Load Status reported completion twice after Push during the dismiss fade.
  • The startup screen could stay up forever.
  • Crash on window resize during the startup screen (Windows).
  • Startup screen elements were cut off in windows larger than 1080p.
  • Block Input While Visible blocked the whole editor in PIE.
  • Automatic dismiss could close the screen before a server travel.
  • Russian tooltips were missing for multi-line descriptions.
  • Shadow Blur label renamed to Shadow Opacity (ini key unchanged).
  • Initial tracked version.