Latest Update: May 29, 2018 - Version 1.04
This update adds a Pawn Handling feature that provides full control over Spawn Location and Pawn Type in Streaming Levels, as well as an Actor Pool to keep the active Pawn alive between (and during) Level Transitions.
You can find the full documentation of changes in 1.04 here: Link [^]
The Loading Screen System (LSS) is a framework intended to add dynamic loading screens to your games. It’s incredibly easy to include in your projects and the visuals of your loading screens are entirely yours to design as you see fit.
The LSS uses UE4’s Level Streaming and shows a transition level while your actual levels get loaded in the background. This transition level can be any map you want and can either be static (point a camera on some pretty objects or put a 2D UMG interface up on screen) or fully interactive with a controllable camera or character.
LSS simplifies the whole setup and handling of level streaming down to a couple of nodes, drop the “LSS_Actor” blueprint into your persistent root level and set everything up in its details (loading screen scene, UI overlay, “press key” requirement, autoplay, cinematic mode input handling etc.). Call level transitions from anywhere using just the target level’s name and a readily available node from a globally accessible Blueprint Library. The system will handle the transition and show an interactive loading screen for the duration of the loading.
- Easy to use & Easily extendable
- Create/customise your own loading screens
- Unlimited setup options (2D UI & full 3D scenes)
- Loading screens during level transitions and on start up
- Playable INTERACTIVE loading screens (think Assassin’s Creed)
- MINI GAMES during loading (“Pong” and “Space Invaders” examples included)
- Use different loading screens in a single project
- Fully customizable UMG overlays (e.g. Random Game Hints, example included)
- Support for “Press [Key] To Continue” option
- Advanced features (event handling, latent actions, see documentation)
- 15 well commented tutorial levels included
- Standalone Fade Component included
- VR compatible
- Blueprint Nativization Ready
- Pawn Handling (control spawn location & pawn type)
- Actor Pool (use Player Pawn across levels)
- Loading Progress Indication (Progress Bars)
Mini Games during loading
As the loading screen itself can be any type of level, you can easily set up interactive content to be on screen during the loading of your levels, such as complete minigames.
The project includes two examples, a “Pong” inspired game and the “Space Shooter” example from Unreal’s Content Demos (available in the Epic Launcher). You can add any type of game you like or just create a scene with a character to run and jump around a simplified scene (as seen for example in the Assassin’s Creed series).
Tutorials / Example Maps included
The asset includes 14 tutorial levels with the following setup and usability examples:
- Minimal Setup (Drag&Drop Example)
- Blueprint Only Setup (everything spawned and set up in BP)
- Reference Handling (shows how to access the actor reference)
- Switching between Multiple Loading Screens (use different screens in one project)
- Level Persistence (keep levels in memory after they get closed)
- Advanced Event Handling (access to a wealth of event dispatchers)
- Mini Game in Loading Screen example: Pong
- Mini Game example: “SpaceShooter” from Launcher content
- Main Menu & Pause Menu Example
- User Interface handling
- Advanced: Alternative Loading Order (advanced use case)
- Optional transition via common OpenLevel node (a mix common approach with streaming)
- Loading Progress Plugin integration (Progress Bars)
- Video Playback
- Pawn Handling
Simplest step by step example
- Create an empty level (example name “Root_Map”)
- Drop BP_LSS_Actor into the scene
- Add an existing level (your game scene) to the Levels list of your persistent level (1.)
- Select the BP_LSS_Actor and in its Details add the name of your game scene (3.) Into “List Of Levels”
- Add another level to the Levels list of the root level, this one will act as your loading screen
- In the details of BP_LSS_Actor add the name of your loading scene (5.) as “Loading Screen Level”
- Make sure “Autoplay” is checked In the details of BP_LSS_Actor
Now Play in Editor. The scene should start with a Fade In, then show your loading scene for a short while and finally smoothly Fade to your game scene
To be able to switch between levels:
- Add more levels similar to 3. and 4. above
- Add either a key input in the Level Blueprint of your persistent level (1.) or a box collider in your game scene (as an example)
- On execution of the above (b.) add the node “LSS Open Level” (right click anywhere and start typing “LSS” and you should see functions categorized as “Loading Screen System (Function Library)”)
- As the parameter of “LSS Open Level” enter the name of the level you want to transition to.
Play in Editor, press your input (2.) or enter the collider and the system will smoothly fade into the loading scene and then into the target level (provided as parameter for the “LSS Open Level” node).
This of course is merely the simplest approach, the system offers much more complexity.
**Blueprint Function Library **
All relevant functions to control the Loading Screen System are available in a special Blueprint Function Library (BP_LSS_FunctionLibrary). This is a comprehensive set of methods to interact with the system without ever needing to worry about any references or actual code. It’s meant to be as easy and straightforward as it gets. Just right click anywhere in your blueprints and start typing “LSS” and these functions will show up.
Each function has a tooltip description explaining what it does.
Advanced Event Handling
During the loading process each level triggers a number of events, depending on whether it is loaded / unloaded or shown / hidden. The available Events can be used through bindings to execute custom game logic in specific situations. Usage examples: Show UI, spawn or posses pawns after the level has been loaded, remove UI or save the game before the level closes. The binding itself is very easy, you need the map name and a custom event to connect to.
A list of Available Events:
On Before Level Loaded, On After Level Loaded, On Before Level Shown, On Level Shown, On After Level Shown, On Before Level Hidden, On After Level Hidden, On Before Level Unloaded, On After Level Unloaded
Each of these events can be configured on a per level basis to pause the transition until a special node (“LSS Send Confirmation”) is executed. This allows the system to pause the loading queue when needed to wait for Latent Actions that an individual level migh tneed to conclude (e.g. save game before unloading).
As stated above, in case your game logic requires latent actions (e.g. delays) to be performed during the loading process, you can communicate to the system to keep the loading screen going while your tasks are being executed.
Example: generation of procedural levels, additional level streaming, database communication, etc.
There’s a whole example map dedicated to this topic.
Fade In/Out Controls
The Loading Screen System uses a Fade Component (Blueprints/BPC_ScreenFadeComponent) to make transitions as smooth as possible by fading in and out to black. The fade overlays the screen with a black UMG screen (it could be customized to use any pattern as it uses a simple UMG widget).
Stand-alone usability: you can use the BPC_ScreenFadeComponent on its own independently from the Loading Screen System - just add the Actor Component to any Actor in your scene (e.g. Game Mode)
- Currently the system is available for 4.18+ only (mostly because of several quality of life improvements added to the Engine by Epic, such as DPI scale, which make it hard to go back to an older engine version for me). Support for older engine versions may come at a later date if there is any demand for it - please let me know if you would be interested in a 4.12-4.17 version.
- No multiplayer support in the initial release. Will be added soon, already being working on.
- Tested on PC, but should work on all platforms
- Works with Blueprint Nativization
This thread is primarily intended for helping users with any questions, concerns, or issues they may come across. But all feedback is more than welcome!