Download

Loading Screen System (Level Transitions w/ Progress)

4.19 Added to Supported Engine Versions

Version 1.03 submitted
This Update introduces proper Loading Progress Indicators (Progress Bars).

**Update v1.03 has been released Today!

This version introduces Loading Percentage display (Progress Bars) as well as a couple of quality of life improvements (e.g. a Load List of Levels node and Open All Levels On Autoplay option)**

IMPORTANT: The new Loading Progress functionality requires the installation of a small code plugin,
as this feature is not supported with Blueprint alone. The plugin is available with source and precompiled for Win64.
Note: This plugin is only required for this new feature, the Loading Screen System itself will still work without it.

The documentation has been updated to reflect the changes, below are direct links to the most relevant parts thereof.

  1. Loading Progress (including Plugin Installation guide)
  2. Change Log (including all new blueprint nodes)

Plugin Installation Guide - Loading Progress Feature For The Loading Screen System

Hi there! Would this work for loading screens on map transitions for clients changing maps on dedicated servers?

Good question. I will look into it further, but so far I’m afraid this is not achievable at all.
It would certainly work when all clients travel simultaneously (e.g. start a match from lobby when all players are ready), but not for individual clients joining a session that is already in progress (e.g. enter a persistent game world at any time).

PS: The system is not yet replicated, expect the network update to be available later this month.

Ok thanks for the info!

Tutorial Video: Loading Screen On Startup

More videos to come, next up: Getting Started with Level Transitions

Hi. Am I correct in understanding that if my multiplayer setup consists of multiple root levels, your asset will not function even after you add multiplayer support? The client won’t know which root level the server is using, and switching between root levels (while connecting) wouldn’t allow your asset to function properly?

Hey CodeSpartan,

Multiple root levels aren’t the problem - when the client connects to a server or the server uses ServerTravel at any point, the client(s) will “know which root level the server is using” and follow accordingly.
The limitation however (mentioned here) is, that once the server streams sublevels, any clients connecting *after *that point, will start opening the root level with those streaming levels already active (i.e. at the time the game framework starts for the client and the Loading Screen System gets initialized, the level is already loaded).

While ServerTravel for all clients simultaneously would work, connecting individually to a (root) level that already has sublevels loaded server-side will not allow the asset to work at all for that transition.

The client would need to be able to connect to an empty root level with no streaming levels loaded yet, then handle streaming client-side for the levels already active on the server.
Thus far I haven’t been able to find a way to achieve that without desyncing the client from the server by creating separate, unreplicated level instances.

As it stands, when connecting to already existing worlds (server-side), there doesn’t seem to be any substitute for out-of-the-box TransitionMap / Seamless Travel.

Is there also a way to use this loader with non-seamless map loading (open a map)? Couldn’t find this in the demo videos.

You can also use the common OpenLevel node to transition between maps, though it will require a tiny bit of setup (see FAQ).
You will need to create an empty persistent level, add your actual map as its sublevel (i.e. drag it into the “levels” tab), set up the LSS Actor in the persistent level, and you’re done.
Now, when calling OpenLevel, use the new map’s name as parameter.

The setup is identical to the one in the “Loading Screen On Startup” Video](Tutorial: Loading Screen On Startup | Loading Screen System - UE4 Marketplace - YouTube). Here’s also a written step by step example: Documentation Link [^] ).
Any level set up this way will use the loading screen when opened, be it as first level on launch or through OpenLevel.
The game will load the empty persistent level, then the LSS Actor will handle loading according to its settings.

I am trying to have my Level Load using the Percentage Loading Screen. My level is made of a Persistent Level with sub levels for different areas of the main map. When I try to add my main level to a blank level my sub levels don’t show only the Persistent level and not the sub levels. How do I get my Sub Levels to show when I add my main level to a blank level?

My goal is to use three of your BP_Portal Blueprints as my Main Menu. Each Portal would take You to different Levels like Start Game, Continue, Shooting Gallery etc… I would like my loading screen to play a sequencer animation I made which has its own level. I want to use the “skip with any key button” and load my main game level with the Persistent Map with Sub Levels as in picture.

This is being used in my VR game. So I am guessing the any key should work with motion controllers.

Awesome Plugin by the way. Just trying to get this figured out.

Unreal will only ever honor one step of sublevels, meaning if a sublevel has its own set of sublevels, those will be ignored.
You would want to add the sublevels to the top persistent level as well.

Let’s say, your current setup so far is this (the forum refuses to show me your screenshots, so I’ll be using generic names):

*P_Level00_Map (persistent)

  • S_Level01_Map (sublevel)
  • S_Level02_Map (sublevel)*

If you wanted to move that to a new persistent level, you would have to do it this way:

*P_NewLevel00_Map (persistent, containing BP_LSS_Actor)

  • P_Level00_Map (sublevel)
  • S_Level01_Map (sublevel)
  • S_Level02_Map (sublevel)*

Btw, you can easily load​​ multiple levels simultaneously, using the globally accessible "LSS OpenLevels" node (it takes an Array of Name as parameter - you can plug a “make array” node into it). Though, if you wanted to stream the sublevels depending on player position, you would have to adjust that to the new setup (volume triggers would work fine, but streaming volumes could be limited in some cases as they have to be placed in the persistent level).

If your levels (such as “Shooting Gallery” or “Start Game” etc.) don’t rely on different GameModes, the best way to set up the project would be adding these levels to the same persistent level:

*P_NewLevel00_Map (persistent, containing BP_LSS_Actor)

  • P_Level00_Map (sublevel - I’m assuming this to be the NewGame/Continue one)
  • S_Level01_Map (sublevel)
  • S_Level02_Map (sublevel)
  • S_ShootingGallery_Map (sublevel)
  • S_MainMenu_Map (sublevel with portals)
  • S_LoadingScreen_Map (loading screen level with the sequencer animation)*

In this example you would deactivate "Autoplay" on the LSS Actor (otherwise it would load the first level) and from blueprint (e.g. in BeginPlay of the persistent level), run "LSS OpenLevel" with “S_MainMenu_Map” as parameter to load into the menu on startup (you would substitute this of course with the correct name of your sublevel).

Then, in the portals you would set up transitions to the game level ("LSS OpenLevels" as mentioned earlier, with an array of the game scene and its sublevels) and the Shooting Gallery ("LSS OpenLevel" with “S_ShootingGallery_Map” as parameter). Can’t really speak to the “Continue” mechanic, as this depends on how you save and load your game.

Note that the portal blueprint (which is just a simple example) doesn’t support loading of multiple levels, so you would have to override the overlap event and place your custom nodes there (or I could update it with that option and make it available for download).

— Method with common “OpenLevel” node —

Let’s say you wanted to keep all your levels separate and not in one single persistent level as above. This could look similar to this:

Menu level:

P_Persistent03_Map (persistent, containing BP_LSS_Actor)
*- S_LoadingScreen_Map (loading screen level with the sequencer animation)

  • S_MainMenu_Map (sublevel with portals) *

Shooting Gallery Level:

P_Persistent02_Map (persistent, containing BP_LSS_Actor)
*- S_ShootingGallery_Map (sublevel)

  • S_LoadingScreen_Map (loading screen level with the sequencer animation)*

Game Level:

*P_Persistent01_Map (persistent, containing BP_LSS_Actor)

  • S_LoadingScreen_Map (loading screen level with the sequencer animation)
  • P_Level00_Map (sublevel)
  • S_Level01_Map (sublevel)
  • S_Level02_Map (sublevel)*

In the transition (e.g. portals) you would use the common "OpenLevel" node rather than the custom "LSS OpenLevel" ones (the portals are set up to use both methods).

You would lose the persistence between the levels (e.g. you would have to unload the game level to go into the menu, which wouldn’t be the case with one shared persistent level) and the loading screen level would need to be loaded on each transition, but each of the levels could have its own GameMode.

Add this level as a sublevel of the persistent map and enter the level’s name in the LSS Actor’s details.(“Loading Screen Level”).

To keep in mind: by default the loading screen level is set to be kept in memory (you can uncheck “keep loading screen in memory” if you want to unload the loading screen level after the transition). If kept loaded, in your case you might need to make sure the Sequence is reset to play from start on each loading (else it might continue where it left off when the loading screen was closed).

As far as I am aware, “Any Key” is an all-input thing, it does cover mouse clicks and should work with motion controllers (though I have no way of testing).
If it does not however, you can specify any number of individual inputs available in Unreal here anyway.

In this case you would enable “Input Required To Continue On Finish” and set “Input To Continue On Finish” to “Any Key” or any other input option.

— VR —

In the case of VR in general, you would keep “Use Default UI” unchecked to not show a UMG UI and also select the BPC_ScreenFadeComponent (member of the LSS Actor) and enable “Use Camera Manager (Instead of UMG)”.

— Loading Progress —

To show the progress percentage, you can either bind an event through the “LSS Bind To Loading Progress Update” node (your event would get fired on each change to the progress), or call “LSS Get Current Loading Progress” at any time anywhere (e.g. in tick. It returns the last queried progress result).

With this value (range 0 to 100) you then can drive any effect in your loading screen scene, as is shown in the “LoadingScreen_04_ProgressBars_Map” (it uses both UI and 3d elements to show the percentage).

The default UMG UI of course also has its own progress update event, but I’m assuming this is rather of no use in VR.

Thank you very much. If there is anything I can help you with further, go into more detail on any feature or elaborate on a setup, just let me know.
I hope this write up is not too overwhelming, I’m not great at keeping it short.

Hello, I am having a heck of a time trying to get this to work even at the most basic level, and I feel maybe I’ve missed something. I have a project set up (first person) and currently a handful of maps. I followed your tutorial to a T, but for some reason when it loads in the player is stuck in spectator mode. I’ve also tried using the blueprint method, but for some reason this ONLY works for me if I plop down a 3rd person character from the demo. :\ How can I get it to load into my first person game mode and turn off spectator mode once it loads in?
Edit: I also sent you a DM, so if you answer here, ignore that, or vice versa.

^ Resolved

^ Unresolved

Edit 2: Ok, I think I found a workaround, if I set my player BP to auto-possess ‘Player 0’ it seems to get it working, but this might cause a bit of an issue later. Are there any other fixes for this problem other than forcing player 0 onto that specific pawn?

Also, I am going to be using this system to make loading gates/loading doors. Now, if I have a map that has lets say 3 entrances to it, three ways to come in, how can I set up multiple spawn points? Since the system seems to just grab the first pawn in the level, is there any way to set this up?
Is there any way I can pick which player/pawn the game possesses when loading in with a trigger?
I have the system linked to a few doors in a couple of my maps, it works perfectly, except it always drops me in the same spot.

For example:

Map 1 has 3 doors going in/out.
Door A
Door B
and Door C

My player pawn is infront of Door A

If I walk out of Door B, turn around and re-enter the level through Door B, I am spawned in front of Door A.

For some reason I only got a notification on the Private Message but not here.
This has been already addressed in the PM/email, but I’ll respond here as well in case anybody else might have the same questions.

The issue in regards to the Player Pawn lies within the way Unreal handles spawning or possessing of pawns in general.
The engine will first look at the settings in the GameMode, i.e. what is set as the Default Pawn (e.g. First Person Character) or whether “Start Players As Spectators” is enabled.
This pawn will then be spawned at the PlayerStart, if (and only if) there are no pawns placed in the scene which are set to be possessed by the PlayerController (e.g. set “Auto Possess Player” to “Player 0”).
Next, each time a sublevel gets loaded which contains a pawn set up to be possessed (as above), the Engine will switch to that pawn (abandoning the previous one).

So, with level streaming the order of events we are aiming for would look like this:

  1. Game opens an empty level (the persistent one, which optimally should have no characters in it)
  2. Now the engine will look up in your GameMode what to do next, if there is a default pawn set, the character will get spawned (at PlayerStart or at 0,0,0 if none is present)
    We don’t want to load a pawn at this point as the actual level hasn’t been loaded yet (the pawn might fall into the void).
    To avoid that, enable “Start Players As Spectators” in the GameMode - which will just spawn a light weight floating pawn.
  3. Next the LSS Actor kicks in and loads the Loading Screen Scene - which will have its own pawn, that gets immediately possessed.
  4. In the background the actual game level gets loaded in.
  5. The instant the new level is set to visible, the engine will again look for any characters in the new level that have “Auto Possess Player” enabled

Note 1: if there are none, your camera would be left where the last pawn (from the Loading Screen scene) was located - you wouldn’t be able to move however, as that pawn has been deactivated or unloaded along the scene itself.

Note 2: The engine will not do anything with the GameMode settings at this point, no auto spawning at any PlayerStart, even if there is a new one in the fresh sublevel.

There are many ways you can handle your pawn here, the most simplistic is to place a pawn in each scene, including the Loading Screen scene, and set those to “Auto Possess Player”. That’s how the demo levels in the project handle it.

A different approach would be to use either BeginPlay of the sublevel or events from the LSS to spawn the pawn from blueprint (you could even querry the GameMode settings yourself and spawn the pawn at a PlayerStart if you wanted).

You could also spawn the character once, and using events teleport it around to appear in the newly loaded levels where you would need them (including in the loading screen scene itself if you wanted). For such a persistent pawn you would need:

  1. keep the reference to your current pawn (e.g. as a custom variable in game mode, player state or similar)
  2. hide the pawn (unless you would like to use the same pawn during the loading screen, which you could)
  3. go through the transition
  4. possess/show + teleport the pawn to a location in he newly loaded level

“1.” + “2.” you could bind to OnOpenLoadingScreen (event dispatcher of the LSS Actor) and “4.” to OnLoadingCompleted

Here you have some example code:
Screenshot: Imgur: The magic of the Internet
Pastebin: Begin Object Class=/Script/BlueprintGraph.K2Node_InputKey Name="K2Node_InputKey_ - Pastebin.com (paste into an empty level blueprint)

In this instance it’s placed in the level blueprint of the persistent level, so you could just drag in a reference to the pawn,
but it would work anywhere if the reference was saved globally (GameInstance, GameMode etc.).
The two events bound here in BeginPlay would fire on each transition (achieved in this example on keybindings), until unbound.

Keep in mind, that everything placed in the persistent level will increase the loading time before the loading screen can be shown, this probably wouldn’t be crucial with a single pawn, but it could be easily remedied by spawning the pawn during the first loading and save the reference globally.

Having elaborated on the above, I’ll also add that I am building pawn handling into the Loading Screen System (so that it becomes more of a “Level Transition Suite”).
There will be designated portal actors that can be placed around and be easily configured to init a level transition while also determining where the pawn will be placed in the new level (e.g. at Door A vs. Door B of a hallway, depending on which direction the player is coming from).

The system will be both able to spawn a new character (based on the GameMode settings, even in sublevels) as well as to keep the currently possessed pawn alive throughout transitions. Everything configurable with a few checkboxes.

I purchased this in anticipation of replication just wondered how it was going unless I missed something already?

Hey Smartay,
The Multiplayer update is not quite there yet.
If you want more details or would like access to a beta build, send me an email or PM.

Looking good but MP is needed, when u planning to release it pls ? I would like to buy it but only with MP support. Can i get beta as well pls ?