Compare revisions

79ebff6a · 79ebff6a · 79ebff6a · 79ebff6a · 79ebff6a · 79ebff6a
--- a/Plugins/AsyncLoadingScreen/README.md
+++ b/Plugins/AsyncLoadingScreen/README.md
+<p align="center">
+    <a href="#">
+        <img src="/Resources/Icon256.png">
+    </a>
+</p>
+
+# Contents
+- [Trailer](#trailer)
+- [About](#about)
+- [How it works](#how-it-works)
+- [Features](#features)
+- [Changelog](#changelog)
+- [Requirements](#requirements)
+- [Installation](#installation)
+    - [Clone from Github](#clone-from-github)
+    - [Download from Marketplace](#download-from-marketplace)
+    - [Setup](#setup)
+- [Architecture](#architecture)
+- [Tutorial](#tutorial)
+    - [1) Create Testing Levels and Blueprints](#1-create-testing-levels-and-blueprints)
+    - [2) Gathering images and movies](#2-gathering-images-and-movies)
+    - [3) Setup Startup Movies](#3-setup-startup-movies)
+    - [4) Configure Default Loading Screen setting](#4-configure-default-loading-screen-setting)        
+        - [4.1) Default Loading Screen - Background setting](#41-default-loading-screen---background-setting)
+        - [4.2) Default Loading Screen - Tip Widget setting](#42-default-loading-screen---tip-widget-setting)
+        - [4.3) Default Loading Screen - Loading Widget setting](#43-default-loading-screen---loading-widget-setting)
+    - [5) Configure Classic Layout setting](#5-configure-classic-layout-setting)
+    - [6) Image Sequence Settings](#6-image-sequence-settings)
+    - [7) Set proper background and tip for each level](#7-set-proper-background-and-tip-for-each-level)
+- [Showcases](#showcases)
+- [Donate](#donate)
+- [License](#license)
+- [Acknowledgment](#acknowledgment)
+
+
+# Trailer
+
+[![Unreal Engine Async Loading Screen Plugin](http://i3.ytimg.com/vi/3rwsNYPUr0I/hqdefault.jpg)](https://youtu.be/3rwsNYPUr0I "Unreal Engine Async Loading Screen Plugin")
+
+# About
+
+Loading screens aren't trivial in general, especially in Unreal Engine. And this makes a lot of UE newcomers are confused at first. Due to User Widget is destroyed at level transition, and level loading runs on the main thread, it blocks any other game activities until it's completed. That's why you need to use Level Streaming for loading screens otherwise your widget blueprint will not work. You have to manually control which object is loaded/unloaded, you can't use different Game Mode, Player Controller for each level, and sometimes there's still occasional freezing.
+
+That said, you may need to change your game logic to fit with Level Streaming mechanic and it requires a lot of works to achieve a simple thing: Add a Loading Screen. To create a custom loading screen without Level Streaming, you have to do it in Unreal C++. However, this is a hard task for artists and designers, even for developers who are not familiar with the Slate framework and engine module code. Async Loading Screen plug-in comes to a savior.
+
+Async Loading Screen allows you to easily configure a Loading Screen System in the project settings, and automatically add a Loading Screen whenever you open a new level. Async Loading Screen also comes with pre-design UI layouts and default icons that make it easy to custom your loading screen in a few minutes (less than 5 minutes I swear).
+
+# How it works
+
+Async Loading Screen uses MoviePlayer to play a movie at level transition, on a different thread than game thread. MoviePlayer is not only playing movie files but also can display a Slate widget on top of the movie. We use this widget for the loading screen.
+
+MoviePlayer is registered to PreLoadMap and PostLoadMapWithWorld delegates so it will be called and shut down automatically by the engine whenever you open a new level.
+
+# Features
+
+- Easy to set up, easy to use.
+- Customizable pre-make responsive layouts.
+- Customizable loading icons.
+- Pre-make default loading icons.
+- Supported animating images sequence.
+- Supported on all major platforms.
+- Easily play movies, audio files.
+- No need for coding.
+- No temporary maps, no level streaming.
+- Automatically handles all level transitions.
+- Integrates seamlessly with an existing project.
+
+# Changelog
+
+### Version 1.5.0 (6/4/2023)
+- Add "PreloadBackgroundImages" option
+- Add Blueprint functions "PreloadBackgroundImages" and "RemovePreloadedBackgroundImages" to load and remove all the background images.
+
+![image](https://user-images.githubusercontent.com/1840964/230429985-6d353486-0389-448c-8e37-d4f9dd3505ae.png)
+![image](https://user-images.githubusercontent.com/1840964/230430019-fb5ab524-7f59-4201-b263-00cbc17672f0.png)
+
+### Version 1.4.0 (25/1/2023)
+- Fixed unintialized errors
+- Add Blueprint function "SetEnableLoadingScreen" to show/hide Loading Screen. Call this function before call the "OpenLevel" node
+
+![ALS-ShowHideLoadingScreen](https://user-images.githubusercontent.com/1840964/214602739-ebcdd994-08a4-4837-96b5-c5596efbdcb1.png)
+
+### Version 1.3.0 (29/08.2021)
+- Supports Unreal Engine 4.27 (Select other branches for other UE versions)
+- Added option for hiding Loading Widget when level loading completes
+![image](https://user-images.githubusercontent.com/1840964/131251300-dbf13ed7-26ae-4965-a119-7b51b29dfe52.png)
+- Moved animating Image Sequence into OnPaint function
+---
+### Version 1.2 (11/01.2021)
+- Added new blueprint library function **Stop Loading Screen**. To use this function, you must enable the **Allow Engine Tick** option. Call this function in **BeginPlay** event to stop the Loading Screen (works with Delay node):
+
+![async-loading-screen-01](https://user-images.githubusercontent.com/1840964/104131830-a3f22300-53ab-11eb-8543-3e8ba6ef2609.png)
+
+- Added **Show Loading Complete Text** option and **Loading Complete Text Settings** section, which show a text when level loading is complete. Note that you need to set **Wait For Manual Stop** = true, and **Minimum Loading Screen Display Time** = -1, this also allows players press any key to stop the Loading Screen by themself.
+
+Show Loading Complete Text Settings:
+![async-loading-screen-02](https://user-images.githubusercontent.com/1840964/104131945-896c7980-53ac-11eb-870a-b7987364f00c.png)
+
+Example:
+![async-loading-screen-03](https://user-images.githubusercontent.com/1840964/104131958-ad2fbf80-53ac-11eb-92a7-8951cbe2061e.png)
+
+---
+
+### Version 1.1 (14/09/2020):
+- Added Shuffle option in the movie setting.
+- Implemented set specific background/tip/movie for each level.
+- Added SetDisplayBackgroundManually, SetDisplayTipTextManually, SetDisplayMovieManually options.
+- Changed TipWidgetVerticalPadding to BorderVerticalOffset in Center Layout settings.
+- Changed WidgetHorizontalPadding to BorderHorizontalOffset in Sidebar Layout settings.
+- Add Async Loading Screen Function Library with 3 Blueprint functions:
+![function-library-01](https://user-images.githubusercontent.com/1840964/93088595-577c2c80-f6c4-11ea-8f23-ec9d065277dc.png)
+
+# Requirements
+
+~~Async Loading Screen plug-in requires Visual Studio and a C++ code project. If your project is blueprint based then you will need to convert it to C++ project otherwise you cannot package your game with code plug-in.~~ It doesn't require c++ project anymore.
+
+# Installation
+
+> :warning: **After installed Async Loading Screen plugin, the "Project/Movies" setting won't work anymore. You need to set up your startup movies in the 'Startup Loading Screen' section of the plugin's setting.**
+
+- ## Clone from Github
+Clone this repository into your project's /Plugins folder, make one if it doesn’t exist, then compile your game in Visual Studio. If your project is blueprint based you’ll need to convert it to a c++ project by adding any c++ class. Supports Engine version from 4.23 and above.
+
+- ## Download from Marketplace
+Download Async Loading Screen from [Marketplace](https://www.unrealengine.com/marketplace/en-US/product/async-loading-screen) and enable the plugin in Plugins.
+
+- ## Setup
+You can disable/enable the plugin in **Edit→Plugins→Project/Loading Screen**. You configure the plug-in settings in project settings **Project Settings/Game/Async Loading Screen**.
+
+![async-loading-screen-screenshot-01](https://user-images.githubusercontent.com/1840964/91760594-d02bb500-ebfd-11ea-85fc-08c5a556a903.png)
+
+# Architecture
+Async Loading Screen has four main components: Background, Loading Widget, Tip Widget, and Layout.
+
+## Background
+The background is a static image, you can add many images as you want, it will be displayed randomly (unless **Set Display Background Manually** option is enabled). Leave it empty if you just want to show a movie instead of a static image.
+
+- Background Setting:
+
+![background-settings](https://user-images.githubusercontent.com/1840964/93088749-8397ad80-f6c4-11ea-9a85-5399efea3ddd.png)
+
+## Tip Widget
+Just some useful texts that will be shown randomly (unless **Set Display Tip Text Manually** option is enabled) for players to have something to look at while waiting for a new level loaded.
+
+- Tip Widget Setting:
+
+![tip-widget-settings](https://user-images.githubusercontent.com/1840964/93089000-df623680-f6c4-11ea-82fb-e2a44f9a524f.png)
+
+## Loading Widget
+This is the most important component of the plug-in, Loading Widget lets players know that the game is still running and not freezing. 
+
+Loading Widget has two parts: Loading Icon and Loading Text. The Loading Text is just a text shown beside the Loading Icon, we mostly care about the Loading Icon. Async Loading Screen supports 3 types of Loading Icon: Throbber, Circular Throbber, and Image Sequence.
+
+- Loading Widget Setting:
+
+![loading-widget-settings](https://user-images.githubusercontent.com/1840964/92412275-7edb7280-f175-11ea-9ef7-c02f183f5c88.png)
+
+### Loading Icon
+
+- Throbber Setting:
+
+![throbber-settings](https://user-images.githubusercontent.com/1840964/92412332-b9dda600-f175-11ea-986c-852cc93cf61c.png)
+
+- Throbber loading icon example:
+
+![throbber-loading-01](https://user-images.githubusercontent.com/1840964/92412429-10e37b00-f176-11ea-999b-bdeab20cf922.gif) ![throbber-loading-02](https://user-images.githubusercontent.com/1840964/92412452-1fca2d80-f176-11ea-838e-a5ccb55ea72d.gif)
+
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+- Circular Throbber Setting:
+
+![circular-throbber-settings](https://user-images.githubusercontent.com/1840964/92413277-8735ac80-f179-11ea-8e16-ab5e08be1595.png)
+
+- Circular Throbber loading icon example:
+
+![circular-throbber-loading-01](https://user-images.githubusercontent.com/1840964/92412600-a2eb8380-f176-11ea-9a6f-ab162490a9e3.gif) ![circular-throbber-loading-02](https://user-images.githubusercontent.com/1840964/92412750-450b6b80-f177-11ea-8af8-9eb68cea0155.gif)
+
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+- Image Sequence Setting:
+
+![image-sequence-settings](https://user-images.githubusercontent.com/1840964/92413824-0e841f80-f17c-11ea-896a-3e16e8291967.png)
+
+- Image Sequence loading icon examples:
+
+![image-sequence-loading-03](https://user-images.githubusercontent.com/1840964/92539810-c98be600-f26c-11ea-832c-770af9438050.gif)
+![image-sequence-loading-01](https://user-images.githubusercontent.com/1840964/92413859-2fe50b80-f17c-11ea-9254-74ebd073a0eb.gif)
+![image-sequence-loading-02](https://user-images.githubusercontent.com/1840964/92413848-26f43a00-f17c-11ea-8f72-c658e3f904a0.gif)
+
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+## Layout
+This is the way Async Loading Screen widgets are arranged on the screen. In version 1.0 Async Loading Screen supports 5 different Layouts: Classic, Center, Letterbox, Sidebar, and Dual Sidebar.
+
+- Layout Settings:
+
+![layout-settings](https://user-images.githubusercontent.com/1840964/92414921-af74d980-f180-11ea-9957-7032f171e843.png)
+
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+- Classic layout example:
+
+![classic-layout-01](https://user-images.githubusercontent.com/1840964/92415877-14cac980-f185-11ea-870a-dc8a7e7d68ea.jpg)
+
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+- Center layout example:
+
+![center-layout-01](https://user-images.githubusercontent.com/1840964/92416035-c833be00-f185-11ea-8d7d-625b4166ca26.jpg)
+
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+- Letterbox layout example:
+
+![letterbox-layout-01](https://user-images.githubusercontent.com/1840964/92416029-c2d67380-f185-11ea-92f9-f7f9021b825f.jpg)
+
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+- Sidebar layout example:
+
+![sidebar-layout-01](https://user-images.githubusercontent.com/1840964/92416031-c4a03700-f185-11ea-9938-b63f1a2971fa.jpg)
+
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+- Dual Sidebar layout example:
+
+![dual-sidebar-layout-01](https://user-images.githubusercontent.com/1840964/92416037-c964eb00-f185-11ea-8ed4-086bb49fc52a.jpg)
+
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+# Tutorial
+In this tutorial, I will use a blank C++ project with UE version 4.25. But you can freely integrate Async Loading Screen plugin into your existing projects without problems. You should install the plugin following [Installation](#installation) steps above.
+
+## 1) Create Testing Levels and Blueprints
+- First, we create two empty levels named **Level_1** and **Level_2** for testing purposes:
+
+![tutorial-02](https://user-images.githubusercontent.com/1840964/92516241-1c4ea900-f23f-11ea-9e32-76b67f2c96a9.png)
+
+- Create BP_GameMode, BP_PlayerController, and an UMG blueprint WBP_OpenLevelButton:
+
+![tutorial-03](https://user-images.githubusercontent.com/1840964/92516572-95e69700-f23f-11ea-9a81-c9e4fb9fa0e4.png)
+
+- In WBP_OpenLevelButton, create a button at the center of the screen:
+
+![tutorial-04](https://user-images.githubusercontent.com/1840964/92516863-fece0f00-f23f-11ea-81f4-6dabd9c05d66.png)
+
+- In WBP_OpenLevelButton graph, add the following nodes in the button's OnClick event:
+
+![tutorial-05](https://user-images.githubusercontent.com/1840964/92517440-dd215780-f240-11ea-855c-0f41e8f66046.png)
+
+- In BP_PlayerController, create that widget and add to the viewport:
+
+![tutorial-06](https://user-images.githubusercontent.com/1840964/92517611-1eb20280-f241-11ea-9bc1-f84521432e41.png)
+
+- Also enable "Show Mouse Cursor" option in BP_PlayerController: 
+
+![tutorial-07](https://user-images.githubusercontent.com/1840964/92517958-cb8c7f80-f241-11ea-83fc-2a74ecdbc4db.png)
+
+- Change default GameMode to our BP_GameMode and BP_PlayerController in "Project/Maps & Modes" setting:
+
+![tutorial-08](https://user-images.githubusercontent.com/1840964/92518004-dfd07c80-f241-11ea-900d-dd89e4163325.png)
+
+- Add two maps to the included list in "Projects/Packaging" setting so you don't have to see annoying warnings when Launch:
+
+![tutorial-09](https://user-images.githubusercontent.com/1840964/92518328-5cfbf180-f242-11ea-9b8b-e7452dff4454.png)
+
+- Note that to see the plugin is actually working, you need to play as Standalone Game or Launch button. Play in Editor will not work due to different level managing of Play in Editor and packaged game:
+
+![tutorial-10](https://user-images.githubusercontent.com/1840964/92521633-c3cfd980-f247-11ea-984b-98f17d604387.png)
+
+If you play Standalone Game or Launch the game you will see a black screen with a white panel shows up very quickly. We'll need a little setting up to make the loading screen looks better.
+
+---
+
+## 2) Gathering images and movies
+You can use your own assets instead but for this tutorial, I'll use Unreal Engine 5 Wallpapers Desktop from this [post](https://forums.unrealengine.com/unreal-engine/announcements-and-releases/1760020-share-your-excitement-for-unreal-engine-5-with-free-wallpapers-gifs-and-more) and UE4 Startup Video Files from this [page](https://www.unrealengine.com/en-US/branding). Here are links download for you:
+- [UE5 Wallpapers - Desktop](https://epicgames.ent.box.com/s/zuorr34ojf3010k71tiv2c79s266v12b/folder/112871747507)
+- [UE4 Startup Video Files](https://epicgames.ent.box.com/s/t94yqy3lxb3mlytmqf5znrr2pobus3fm)
+
+- Create a "Movies" folder in the "Content" folder and copy your movie files into the "Content/Movies" folder (don't import movies into the project just copy the original movie files):
+
+![tutorial-11](https://user-images.githubusercontent.com/1840964/92527405-24afdf80-f251-11ea-97f0-ebe893e27986.png)
+
+- Import your background images into the project:
+
+![tutorial-12](https://user-images.githubusercontent.com/1840964/92527677-96882900-f251-11ea-8cb3-b99c41925337.png)
+
+---
+
+## 3) Setup Startup Movies
+
+Now go to "Game/Async Loading Screen" setting in the Project Settings and open "Startup Loading Screen" section. This Startup Loading Screen only shows once when the player first opens the game so usually, you don't want to show a loading screen here. Instead, you'll want to show a UE4 logo intro movie, your studio logo movie, your sponsor 1 logo movie, your sponsor 2 logo movie, or some weird shit movies, depending on you.
+
+- Uncheck "Auto Complete when Loading Completes" option so we can see the movies play till end
+- Add your movie path without extension in "Movie Paths" array
+
+Here is the Startup Loading Screen setting:
+
+![tutorial-13](https://user-images.githubusercontent.com/1840964/92529902-8eca8380-f255-11ea-92a4-a1c3ed376d62.png)
+
+Click play Standalone Game or Launch button, you will see UE4 logo movie show up here.
+
+---
+
+## 4) Configure Default Loading Screen setting
+
+Open "Default Loading Screen" setting, here we actually set up a loading screen for our game. You can leave most of options default but for testing purpose, we'll change some options.
+
+- Set "Minimum Loading Screen Display Time" value to 10 (I recommend setting it to -1 in packaged games)
+- Set "Layout" to Classic for this tutorial.
+
+Here is Default Loading Screen setting:
+
+![tutorial-14](https://user-images.githubusercontent.com/1840964/92531295-33e65b80-f258-11ea-98d7-489521a93a87.png)
+
+### 4.1) Default Loading Screen - Background setting
+
+Open "Background" setting in the Default Loading Screen section. Add your background images to the Images array. You can leave other options default:
+
+![tutorial-15](https://user-images.githubusercontent.com/1840964/92533170-13b89b80-f25c-11ea-9542-3947df9a0079.png)
+
+### 4.2) Default Loading Screen - Tip Widget setting
+
+Open "Tip Widget" setting in the Default Loading Screen. Add some useful texts, you can change text's appearance like color, font, shadow effect here:
+
+![tutorial-16](https://user-images.githubusercontent.com/1840964/92533302-5b3f2780-f25c-11ea-9975-24f0c09c6e03.png)
+
+### 4.3) Default Loading Screen - Loading Widget setting
+Open "Loading Widget" setting in the Default Loading Screen, here we will custom our loading icon. If you open AsyncLoadingScreen Content folder, you can see there are a lot of default loading images I had made. We'll use those default images in this tutorial.
+
+![tutorial-17](https://user-images.githubusercontent.com/1840964/92533833-81b19280-f25d-11ea-91b5-239bea77ba1a.png)
+
+- Set "Loading Icon Type" to "Throbber"
+- Set "Loading Widget Type" to "Horizontal"
+- Open "Throbber Settings" and select icon-cat-print in "Image" option
+- Set "Space" value to 20
+
+You can leave other options default.
+
+![tutorial-18](https://user-images.githubusercontent.com/1840964/92534376-ce499d80-f25e-11ea-8a13-98ef026b34bf.png)
+
+---
+## 5) Configure Classic Layout setting
+Because we already chose the Classic layout in previous step so we will configure the Classic layout and ignore other layouts. Open "Classic" setting in Layout category and change following options:
+
+- Set "Border Padding" to 20
+- Open "Border Background" option and set Tint color (R:0.1, G:0.1, B:0.1, A:0.8)
+
+You can leave other options default.
+
+![tutorial-19](https://user-images.githubusercontent.com/1840964/92535368-4749f480-f261-11ea-9fe5-76ff2e5dd215.png)
+
+---
+
+Alright! Now you can click play Standalone Game or Launch button to see your loading screen.
+
+![tutorial-20](https://user-images.githubusercontent.com/1840964/92536073-f6d39680-f262-11ea-8c42-8f540aea6217.jpg)
+
+
+## 6) Image Sequence Settings
+Async Loading Screen also supports custom loading icon using Image Sequence. Open "Loading Widget" and change following options:
+
+- Set "Loading Icon Type" to "Image Sequence"
+- Open "Image Sequence Settings" and add all images in folder "Default/Mannequin/RunImages" to Images array
+
+You can leave other options default.
+
+![tutorial-21](https://user-images.githubusercontent.com/1840964/92536598-48c8ec00-f264-11ea-8e35-73b14364e3bb.png)
+
+Click play or Launch button and you'll see the Mannequin is running as a loading icon:
+
+![tutorial-22](https://user-images.githubusercontent.com/1840964/92536933-0eac1a00-f265-11ea-8d62-c173e632b55a.jpg)
+
+---
+## 7) Set proper background and tip for each level:
+In updated version 1.1, Async Loading Screen supports display specific background/tip/movie for each level as you want. In this tutorial we'll show proper background and tip for **Level_1** and **Level_2**:
+
+- Open **Background** setting and enable **Set Display Background Manually**.
+![tutorial-23](https://user-images.githubusercontent.com/1840964/93087118-534f0f80-f6c2-11ea-94e3-4d3c0fc27c55.png)
+
+- Open **Tip Widget** setting, enable **Set Display Tip Text Manually** and add 2 more following texts in **TipText** array:
+![tutorial-24](https://user-images.githubusercontent.com/1840964/93087270-842f4480-f6c2-11ea-9e8f-d79ff58dd35b.png)
+
+- Open **WBP_OpenLevelButton** blueprint, in On Clicked event, set **Background Index=4, Tip Text Index=2** before **Open Level=Level_2** and **Background Index=2, Tip Text Index=1** before **Open Level=Level_1**:
+![tutorial-25](https://user-images.githubusercontent.com/1840964/93087474-ceb0c100-f6c2-11ea-8502-5a5615fd15eb.png)
+
+- Now click play Standalone Game or Launch button, you'll see Async Loading Screen always show Background index 4, TipText index 2 when loading Level_2, and Background index 2, TipText index 1 when loading Level_1.
+
+---
+
+Congratulation! We have finished the tutorial. You should try other layouts and settings to see which is fit for your game.
+
+
+# Showcases
+
+- [Colors:Zero](http://www.colors-zero.com/)
+
+![Colors:Zero](https://user-images.githubusercontent.com/1840964/233838182-2c8cd8fa-dc49-41ed-b536-27a8650fe98a.jpg)
+
+---
+
+- [Elven Warmaiden](https://store.steampowered.com/app/1878000/Elven_Warmaiden/)
+
+![Elven Warmaiden](https://cdn.akamai.steamstatic.com/steam/apps/1878000/header.jpg?t=1644526061)
+
+---
+- [Logic - Keypad](https://store.steampowered.com/app/2265160/Logic__Keypad/)
+
+![logic-keypad](https://user-images.githubusercontent.com/1840964/215274878-c6dd3aa1-6b9c-4f4a-af41-de083943c8ef.jpg)
+
+---
+- [Witchtastic](https://store.steampowered.com/app/1080010/Witchtastic/)
+
+![witchtastic](https://user-images.githubusercontent.com/1840964/198943299-529b153a-322d-4431-bec9-9046147ced43.jpg)
+
+---
+- [Cursed Spire](https://www.youtube.com/watch?v=ZZlxmdRDRMI)
+
+![cursed-spire-async-loading-screen](https://user-images.githubusercontent.com/1840964/93096502-ac24a500-f6ce-11ea-9f6a-613c7a6bb926.gif)
+
+---
+
+- [Pumpkin Jack](https://www.pumpkin-jack.com/)
+
+![pumpkin-jack](https://user-images.githubusercontent.com/1840964/99428459-41475280-2939-11eb-86a5-b27f39b73037.png)
+
+---
+- [Cions of Vega](https://tongucbodur.com/vega)
+
+![cions-of-vega](https://user-images.githubusercontent.com/1840964/120698381-2d300080-c4d9-11eb-96bd-9c0fe71f6813.jpg)
+
+---
+- [BrightSeeker](https://store.steampowered.com/app/1491950/BrightSeeker/)
+
+![BrightSeeker_Scr_(4)](https://user-images.githubusercontent.com/1840964/133012031-f5e91478-5e32-470d-9c8c-df6f13fcf630.png)
+
+---
+If you're using Async Loading Screen plugin in your game and would like to showcase here, shoot me an email about your game's info, including screenshots(gif/png/jpeg/video) of your in-game loading screen.
+
+# Donate
+If Async Loading Screen is useful for you or your team, you can [buy me a coffee](https://www.buymeacoffee.com/truongbui) to support this project.
+
+# License
+Async Loading Screen plug-in is licensed under the [MIT](LICENSE) License.
+
+# Acknowledgment
+
+Async Loading Screen plug-in is inspired from [Loading Screen](https://github.com/ue4plugins/LoadingScreen) plug-in by Nick Darnell.
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/AsyncLoadingScreen.Build.cs
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/AsyncLoadingScreen.Build.cs
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+using UnrealBuildTool;
+
+public class AsyncLoadingScreen : ModuleRules
+{
+	public AsyncLoadingScreen(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+		
+		PublicIncludePaths.AddRange(
+			new string[] {
+				// ... add public include paths required here ...
+			}
+			);
+				
+		
+		PrivateIncludePaths.AddRange(
+			new string[] {
+				// ... add other private include paths required here ...
+			}
+			);
+			
+		
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core"
+				// ... add other public dependencies that you statically link with here ...
+			}
+			);
+			
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"CoreUObject",
+				"Engine",
+				"Slate",
+				"SlateCore",
+				"MoviePlayer",
+				"DeveloperSettings"
+				// ... add private dependencies that you statically link with here ...	
+			}
+			);
+		
+		
+		DynamicallyLoadedModuleNames.AddRange(
+			new string[]
+			{
+				// ... add any modules that your module loads dynamically here ...
+			}
+			);
+	}
+}
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/AsyncLoadingScreen.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/AsyncLoadingScreen.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#include "AsyncLoadingScreen.h"
+#include "MoviePlayer.h"
+#include "LoadingScreenSettings.h"
+#include "SCenterLayout.h"
+#include "SClassicLayout.h"
+#include "SLetterboxLayout.h"
+#include "SSidebarLayout.h"
+#include "SDualSidebarLayout.h"
+#include "Framework/Application/SlateApplication.h"
+#include "AsyncLoadingScreenLibrary.h"
+#include "Engine/Texture2D.h"
+
+#define LOCTEXT_NAMESPACE "FAsyncLoadingScreenModule"
+
+void FAsyncLoadingScreenModule::StartupModule()
+{
+	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
+	if (!IsRunningDedicatedServer() && FSlateApplication::IsInitialized())
+	{
+		const ULoadingScreenSettings* Settings = GetDefault<ULoadingScreenSettings>();
+				
+		if (IsMoviePlayerEnabled())
+		{
+			GetMoviePlayer()->OnPrepareLoadingScreen().AddRaw(this, &FAsyncLoadingScreenModule::PreSetupLoadingScreen);				
+		}		
+		
+		// If PreloadBackgroundImages option is check, load all background images into memory
+		if (Settings->bPreloadBackgroundImages)
+		{
+			LoadBackgroundImages();
+		}
+
+		// Prepare the startup screen, the PreSetupLoadingScreen callback won't be called
+		// if we've already explicitly setup the loading screen
+		bIsStartupLoadingScreen = true;
+		SetupLoadingScreen(Settings->StartupLoadingScreen);
+	}	
+}
+
+void FAsyncLoadingScreenModule::ShutdownModule()
+{
+	// This function may be called during shutdown to clean up your module.  For modules that support dynamic reloading,
+	// we call this function before unloading the module.
+	if (!IsRunningDedicatedServer())
+	{
+		// TODO: Unregister later
+		GetMoviePlayer()->OnPrepareLoadingScreen().RemoveAll(this);
+	}
+}
+
+bool FAsyncLoadingScreenModule::IsGameModule() const
+{
+	return true;
+}
+
+TArray<UTexture2D*> FAsyncLoadingScreenModule::GetBackgroundImages()
+{
+	return bIsStartupLoadingScreen ? StartupBackgroundImages : DefaultBackgroundImages;
+}
+
+void FAsyncLoadingScreenModule::PreSetupLoadingScreen()
+{	
+	UE_LOG(LogTemp, Warning, TEXT("PreSetupLoadingScreen"));
+	const bool bIsEnableLoadingScreen = UAsyncLoadingScreenLibrary::GetIsEnableLoadingScreen();
+	if (bIsEnableLoadingScreen)
+	{
+		const ULoadingScreenSettings* Settings = GetDefault<ULoadingScreenSettings>();
+		bIsStartupLoadingScreen = false;
+		SetupLoadingScreen(Settings->DefaultLoadingScreen);
+	}	
+}
+
+void FAsyncLoadingScreenModule::SetupLoadingScreen(const FALoadingScreenSettings& LoadingScreenSettings)
+{
+	TArray<FString> MoviesList = LoadingScreenSettings.MoviePaths;
+
+	// Shuffle the movies list
+	if (LoadingScreenSettings.bShuffle == true)
+	{
+		ShuffleMovies(MoviesList);
+	}
+		
+	if (LoadingScreenSettings.bSetDisplayMovieIndexManually == true)
+	{
+		MoviesList.Empty();
+
+		// Show specific movie if valid otherwise show original movies list
+		if (LoadingScreenSettings.MoviePaths.IsValidIndex(UAsyncLoadingScreenLibrary::GetDisplayMovieIndex()))
+		{
+			MoviesList.Add(LoadingScreenSettings.MoviePaths[UAsyncLoadingScreenLibrary::GetDisplayMovieIndex()]);
+		}
+		else
+		{
+			MoviesList = LoadingScreenSettings.MoviePaths;
+		}
+	}
+
+	FLoadingScreenAttributes LoadingScreen;
+	LoadingScreen.MinimumLoadingScreenDisplayTime = LoadingScreenSettings.MinimumLoadingScreenDisplayTime;
+	LoadingScreen.bAutoCompleteWhenLoadingCompletes = LoadingScreenSettings.bAutoCompleteWhenLoadingCompletes;
+	LoadingScreen.bMoviesAreSkippable = LoadingScreenSettings.bMoviesAreSkippable;
+	LoadingScreen.bWaitForManualStop = LoadingScreenSettings.bWaitForManualStop;
+	LoadingScreen.bAllowInEarlyStartup = LoadingScreenSettings.bAllowInEarlyStartup;
+	LoadingScreen.bAllowEngineTick = LoadingScreenSettings.bAllowEngineTick;
+	LoadingScreen.MoviePaths = MoviesList;
+	LoadingScreen.PlaybackType = LoadingScreenSettings.PlaybackType;
+
+	if (LoadingScreenSettings.bShowWidgetOverlay)
+	{
+		const ULoadingScreenSettings* Settings = GetDefault<ULoadingScreenSettings>();
+
+		switch (LoadingScreenSettings.Layout)
+		{
+		case EAsyncLoadingScreenLayout::ALSL_Classic:
+			LoadingScreen.WidgetLoadingScreen = SNew(SClassicLayout, LoadingScreenSettings, Settings->Classic);
+			break;
+		case EAsyncLoadingScreenLayout::ALSL_Center:
+			LoadingScreen.WidgetLoadingScreen = SNew(SCenterLayout, LoadingScreenSettings, Settings->Center);
+			break;
+		case EAsyncLoadingScreenLayout::ALSL_Letterbox:
+			LoadingScreen.WidgetLoadingScreen = SNew(SLetterboxLayout, LoadingScreenSettings, Settings->Letterbox);
+			break;
+		case EAsyncLoadingScreenLayout::ALSL_Sidebar:
+			LoadingScreen.WidgetLoadingScreen = SNew(SSidebarLayout, LoadingScreenSettings, Settings->Sidebar);
+			break;
+		case EAsyncLoadingScreenLayout::ALSL_DualSidebar:
+			LoadingScreen.WidgetLoadingScreen = SNew(SDualSidebarLayout, LoadingScreenSettings, Settings->DualSidebar);
+			break;
+		}
+		
+	}
+
+	GetMoviePlayer()->SetupLoadingScreen(LoadingScreen);
+}
+
+void FAsyncLoadingScreenModule::ShuffleMovies(TArray<FString>& MoviesList)
+{
+	if (MoviesList.Num() > 0)
+	{
+		int32 LastIndex = MoviesList.Num() - 1;
+		for (int32 i = 0; i <= LastIndex; ++i)
+		{
+			int32 Index = FMath::RandRange(i, LastIndex);
+			if (i != Index)
+			{
+				MoviesList.Swap(i, Index);
+			}
+		}
+	}
+}
+
+void FAsyncLoadingScreenModule::LoadBackgroundImages()
+{
+	// Empty all background images array
+	RemoveAllBackgroundImages();
+
+	const ULoadingScreenSettings* Settings = GetDefault<ULoadingScreenSettings>();
+	
+	// Preload startup background images
+	for (auto& Image : Settings->StartupLoadingScreen.Background.Images)
+	{
+		UTexture2D* LoadedImage = Cast<UTexture2D>(Image.TryLoad());
+		if (LoadedImage)
+		{
+			StartupBackgroundImages.Add(LoadedImage);
+		}
+	}
+
+	// Preload default background images
+	for (auto& Image : Settings->DefaultLoadingScreen.Background.Images)
+	{
+		UTexture2D* LoadedImage = Cast<UTexture2D> (Image.TryLoad());
+		if (LoadedImage)
+		{
+			DefaultBackgroundImages.Add(LoadedImage);
+		}		
+	}
+}
+
+void FAsyncLoadingScreenModule::RemoveAllBackgroundImages()
+{
+	StartupBackgroundImages.Empty();
+	DefaultBackgroundImages.Empty();
+}
+
+bool FAsyncLoadingScreenModule::IsPreloadBackgroundImagesEnabled()
+{	
+	return GetDefault<ULoadingScreenSettings>()->bPreloadBackgroundImages;
+}
+
+#undef LOCTEXT_NAMESPACE
+	
+IMPLEMENT_MODULE(FAsyncLoadingScreenModule, AsyncLoadingScreen)
\ No newline at end of file
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/AsyncLoadingScreenLibrary.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/AsyncLoadingScreenLibrary.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+
+#include "AsyncLoadingScreenLibrary.h"
+#include "MoviePlayer.h"
+#include "AsyncLoadingScreen.h"
+
+int32 UAsyncLoadingScreenLibrary::DisplayBackgroundIndex = -1;
+int32 UAsyncLoadingScreenLibrary::DisplayTipTextIndex = -1;
+int32 UAsyncLoadingScreenLibrary::DisplayMovieIndex = -1;
+bool  UAsyncLoadingScreenLibrary::bShowLoadingScreen = true;
+
+void UAsyncLoadingScreenLibrary::SetDisplayBackgroundIndex(int32 BackgroundIndex)
+{
+	UAsyncLoadingScreenLibrary::DisplayBackgroundIndex = BackgroundIndex;
+}
+
+void UAsyncLoadingScreenLibrary::SetDisplayTipTextIndex(int32 TipTextIndex)
+{
+	UAsyncLoadingScreenLibrary::DisplayTipTextIndex = TipTextIndex;
+}
+
+void UAsyncLoadingScreenLibrary::SetDisplayMovieIndex(int32 MovieIndex)
+{
+	UAsyncLoadingScreenLibrary::DisplayMovieIndex = MovieIndex;	
+}
+
+void UAsyncLoadingScreenLibrary::SetEnableLoadingScreen(bool bIsEnableLoadingScreen)
+{
+	bShowLoadingScreen = bIsEnableLoadingScreen;
+}
+
+void UAsyncLoadingScreenLibrary::StopLoadingScreen()
+{
+	GetMoviePlayer()->StopMovie();
+}
+
+void UAsyncLoadingScreenLibrary::PreloadBackgroundImages()
+{
+	if (FAsyncLoadingScreenModule::IsAvailable())
+	{
+		FAsyncLoadingScreenModule& LoadingScreenModule = FAsyncLoadingScreenModule::Get();
+		if (LoadingScreenModule.IsPreloadBackgroundImagesEnabled())
+		{
+			LoadingScreenModule.LoadBackgroundImages();
+		}		
+	}
+}
+
+void UAsyncLoadingScreenLibrary::RemovePreloadedBackgroundImages()
+{
+	if (FAsyncLoadingScreenModule::IsAvailable())
+	{
+		FAsyncLoadingScreenModule& LoadingScreenModule = FAsyncLoadingScreenModule::Get();
+		LoadingScreenModule.RemoveAllBackgroundImages();
+	}
+}
+
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/LoadingScreenSettings.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/LoadingScreenSettings.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#include "LoadingScreenSettings.h"
+#include "UObject/ConstructorHelpers.h"
+#include "Engine/Font.h"
+
+#define LOCTEXT_NAMESPACE "AsyncLoadingScreen"
+
+FLoadingWidgetSettings::FLoadingWidgetSettings() : LoadingText(LOCTEXT("Loading", "LOADING")) {}
+//FLoadingCompleteTextSettings::FLoadingCompleteTextSettings() : LoadingCompleteText(LOCTEXT("Loading Complete", "Loading is complete! Press any key to continue...")) {}
+
+
+ULoadingScreenSettings::ULoadingScreenSettings(const FObjectInitializer& Initializer) : Super(Initializer)
+{
+	StartupLoadingScreen.TipWidget.TipWrapAt = 1000.0f;
+	StartupLoadingScreen.bShowWidgetOverlay = false;
+	DefaultLoadingScreen.TipWidget.TipWrapAt = 1000.0f;
+	// Set default font
+	if (!IsRunningDedicatedServer())
+	{
+		static ConstructorHelpers::FObjectFinder<UFont> RobotoFontObj(TEXT("/Engine/EngineFonts/Roboto"));
+		StartupLoadingScreen.TipWidget.Appearance.Font = FSlateFontInfo(RobotoFontObj.Object, 20, FName("Normal"));
+		DefaultLoadingScreen.TipWidget.Appearance.Font = FSlateFontInfo(RobotoFontObj.Object, 20, FName("Normal"));
+		StartupLoadingScreen.LoadingWidget.Appearance.Font = FSlateFontInfo(RobotoFontObj.Object, 32, FName("Bold"));
+		DefaultLoadingScreen.LoadingWidget.Appearance.Font = FSlateFontInfo(RobotoFontObj.Object, 32, FName("Bold"));
+		StartupLoadingScreen.LoadingCompleteTextSettings.Appearance.Font = FSlateFontInfo(RobotoFontObj.Object, 24, FName("Normal"));
+		DefaultLoadingScreen.LoadingCompleteTextSettings.Appearance.Font = FSlateFontInfo(RobotoFontObj.Object, 24, FName("Normal"));
+	}
+}
+
+#undef LOCTEXT_NAMESPACE
+
+
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SBackgroundWidget.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SBackgroundWidget.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#include "SBackgroundWidget.h"
+#include "LoadingScreenSettings.h"
+#include "Slate/DeferredCleanupSlateBrush.h"
+#include "Widgets/Images/SImage.h"
+#include "Widgets/Layout/SBorder.h"
+#include "Engine/Texture2D.h"
+#include "AsyncLoadingScreenLibrary.h"
+#include "AsyncLoadingScreen.h"
+
+void SBackgroundWidget::Construct(const FArguments& InArgs, const FBackgroundSettings& Settings)
+{
+	// If there's an image defined
+	if (Settings.Images.Num() > 0)
+	{
+		int32 ImageIndex = FMath::RandRange(0, Settings.Images.Num() - 1);
+
+		if (Settings.bSetDisplayBackgroundManually == true)
+		{
+			if (Settings.Images.IsValidIndex(UAsyncLoadingScreenLibrary::GetDisplayBackgroundIndex()))
+			{
+				ImageIndex = UAsyncLoadingScreenLibrary::GetDisplayBackgroundIndex();
+			}
+		}		
+		
+		// Load background from settings
+		UTexture2D* LoadingImage = nullptr;
+		const FSoftObjectPath& ImageAsset = Settings.Images[ImageIndex];
+		UObject* ImageObject = ImageAsset.TryLoad();
+		LoadingImage = Cast<UTexture2D>(ImageObject);
+
+		// If IsPreloadBackgroundImagesEnabled is enabled, load from images array
+		FAsyncLoadingScreenModule& LoadingScreenModule = FAsyncLoadingScreenModule::Get();
+		if (LoadingScreenModule.IsPreloadBackgroundImagesEnabled())
+		{
+			TArray<UTexture2D*> BackgroundImages = LoadingScreenModule.GetBackgroundImages();
+			if (!BackgroundImages.IsEmpty() && BackgroundImages.IsValidIndex(ImageIndex))
+			{
+				LoadingImage = BackgroundImages[ImageIndex];
+			}
+		}		
+		
+		if (LoadingImage)
+		{
+			ImageBrush = FDeferredCleanupSlateBrush::CreateBrush(LoadingImage);
+			ChildSlot
+			[
+				SNew(SBorder)
+				.HAlign(HAlign_Fill)
+				.VAlign(VAlign_Fill)
+				.Padding(Settings.Padding)
+				.BorderBackgroundColor(Settings.BackgroundColor)
+				.BorderImage(FCoreStyle::Get().GetBrush("WhiteBrush"))
+				[
+					SNew(SScaleBox)
+					.Stretch(Settings.ImageStretch)
+					[
+						SNew(SImage)						
+						.Image(ImageBrush.IsValid() ? ImageBrush->GetSlateBrush() : nullptr)						
+					]
+				]
+			];			
+		}
+	}
+}
\ No newline at end of file
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SCenterLayout.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SCenterLayout.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#include "SCenterLayout.h"
+#include "LoadingScreenSettings.h"
+#include "Widgets/Layout/SSafeZone.h"
+#include "Widgets/Layout/SDPIScaler.h"
+#include "SHorizontalLoadingWidget.h"
+#include "SVerticalLoadingWidget.h"
+#include "SBackgroundWidget.h"
+#include "STipWidget.h"
+#include "Widgets/SOverlay.h"
+#include "Widgets/Layout/SBorder.h"
+#include "SLoadingCompleteText.h"
+
+
+void SCenterLayout::Construct(const FArguments& InArgs, const FALoadingScreenSettings& Settings, const FCenterLayoutSettings& LayoutSettings)
+{
+	// Root widget and background
+	TSharedRef<SOverlay> Root = SNew(SOverlay)
+		+ SOverlay::Slot()
+		.HAlign(HAlign_Fill)
+		.VAlign(VAlign_Fill)
+		[
+			SNew(SBackgroundWidget, Settings.Background)
+		];
+
+	// Placeholder for loading widget
+	TSharedRef<SWidget> LoadingWidget = SNullWidget::NullWidget;
+	if (Settings.LoadingWidget.LoadingWidgetType == ELoadingWidgetType::LWT_Horizontal)
+	{
+		LoadingWidget = SNew(SHorizontalLoadingWidget, Settings.LoadingWidget);
+	}
+	else
+	{
+		LoadingWidget = SNew(SVerticalLoadingWidget, Settings.LoadingWidget);
+	}
+
+	// Add loading widget at center
+	Root->AddSlot()
+		.HAlign(HAlign_Center)
+		.VAlign(VAlign_Center)
+		[
+			LoadingWidget
+		];
+
+
+	if (LayoutSettings.bIsTipAtBottom)
+	{
+		// Add tip widget at bottom
+		Root->AddSlot()
+			.HAlign(LayoutSettings.BorderHorizontalAlignment)
+			.VAlign(VAlign_Bottom)
+			.Padding(0, 0, 0, LayoutSettings.BorderVerticalOffset)
+			[
+				SNew(SBorder)
+				.HAlign(HAlign_Fill)
+				.VAlign(VAlign_Fill)
+				.BorderImage(&LayoutSettings.BorderBackground)
+				.BorderBackgroundColor(FLinearColor::White)
+				[
+					SNew(SSafeZone)					
+					.HAlign(LayoutSettings.TipAlignment.HorizontalAlignment)
+					.VAlign(LayoutSettings.TipAlignment.VerticalAlignment)
+					.IsTitleSafe(true)
+					.Padding(LayoutSettings.BorderPadding)
+					[
+						SNew(SDPIScaler)
+						.DPIScale(this, &SCenterLayout::GetDPIScale)
+						[					
+							SNew(STipWidget, Settings.TipWidget)
+						]
+					]					
+				]
+			];
+	}
+	else
+	{
+		// Add tip widget at top
+		Root->AddSlot()
+			.HAlign(LayoutSettings.BorderHorizontalAlignment)
+			.VAlign(VAlign_Top)
+			.Padding(0, LayoutSettings.BorderVerticalOffset, 0, 0)
+			[
+				SNew(SBorder)
+				.HAlign(HAlign_Fill)
+				.VAlign(VAlign_Fill)
+				.BorderImage(&LayoutSettings.BorderBackground)
+				.BorderBackgroundColor(FLinearColor::White)
+				[
+					SNew(SSafeZone)					
+					.HAlign(LayoutSettings.TipAlignment.HorizontalAlignment)
+					.VAlign(LayoutSettings.TipAlignment.VerticalAlignment)
+					.IsTitleSafe(true)
+					.Padding(LayoutSettings.BorderPadding)
+					[
+						SNew(SDPIScaler)
+						.DPIScale(this, &SCenterLayout::GetDPIScale)
+						[					
+							SNew(STipWidget, Settings.TipWidget)
+						]						
+					]					
+				]
+			];
+	}
+
+	// Construct loading complete text if enable
+	if (Settings.bShowLoadingCompleteText)
+	{
+		Root->AddSlot()
+			.VAlign(Settings.LoadingCompleteTextSettings.Alignment.VerticalAlignment)
+			.HAlign(Settings.LoadingCompleteTextSettings.Alignment.HorizontalAlignment)
+			.Padding(Settings.LoadingCompleteTextSettings.Padding)
+			[
+				SNew(SLoadingCompleteText, Settings.LoadingCompleteTextSettings)
+			];
+	}
+
+	// Add root to this widget
+	ChildSlot
+	[
+		Root
+	];
+}
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SClassicLayout.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SClassicLayout.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#include "SClassicLayout.h"
+#include "LoadingScreenSettings.h"
+#include "Widgets/Layout/SSafeZone.h"
+#include "Widgets/Layout/SDPIScaler.h"
+#include "Widgets/Layout/SSpacer.h"
+#include "Widgets/SBoxPanel.h"
+#include "SHorizontalLoadingWidget.h"
+#include "SVerticalLoadingWidget.h"
+#include "SBackgroundWidget.h"
+#include "STipWidget.h"
+#include "SLoadingCompleteText.h"
+
+void SClassicLayout::Construct(const FArguments& InArgs, const FALoadingScreenSettings& Settings, const FClassicLayoutSettings& LayoutSettings)
+{
+	// Root widget and background
+	TSharedRef<SOverlay> Root = SNew(SOverlay)
+		+ SOverlay::Slot()
+		.HAlign(HAlign_Fill)
+		.VAlign(VAlign_Fill)
+		[
+			SNew(SBackgroundWidget, Settings.Background)
+		];
+
+	// Placeholder for loading widget
+	TSharedRef<SWidget> LoadingWidget = SNullWidget::NullWidget;
+	if (Settings.LoadingWidget.LoadingWidgetType == ELoadingWidgetType::LWT_Horizontal)
+	{
+		LoadingWidget = SNew(SHorizontalLoadingWidget, Settings.LoadingWidget);
+	}
+	else
+	{
+		LoadingWidget = SNew(SVerticalLoadingWidget, Settings.LoadingWidget);
+	}
+
+	TSharedRef<SHorizontalBox> HorizontalBox = SNew(SHorizontalBox);
+
+	if (LayoutSettings.bIsLoadingWidgetAtLeft)
+	{
+		// Add Loading widget on left first
+		HorizontalBox.Get().AddSlot()
+			.VAlign(VAlign_Center)
+			.HAlign(HAlign_Center)
+			.AutoWidth()
+			[
+				LoadingWidget
+			];
+
+		// Add spacer at midder
+		HorizontalBox.Get().AddSlot()
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.AutoWidth()
+			[
+				SNew(SSpacer)
+				.Size(FVector2D(LayoutSettings.Space, 0.0f))
+			];
+
+			// Tip Text on the right
+		HorizontalBox.Get().AddSlot()
+			.FillWidth(1.0f)
+			.HAlign(LayoutSettings.TipAlignment.HorizontalAlignment)
+			.VAlign(LayoutSettings.TipAlignment.VerticalAlignment)
+			[
+				SNew(STipWidget, Settings.TipWidget)
+			];
+	}
+	else
+	{
+		// Tip Text on the left
+		HorizontalBox.Get().AddSlot()
+			.FillWidth(1.0f)
+			.HAlign(LayoutSettings.TipAlignment.HorizontalAlignment)
+			.VAlign(LayoutSettings.TipAlignment.VerticalAlignment)
+			[
+				// Add tip text
+				SNew(STipWidget, Settings.TipWidget)
+			];
+
+		// Add spacer at midder
+		HorizontalBox.Get().AddSlot()
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.AutoWidth()
+			[
+				SNew(SSpacer)
+				.Size(FVector2D(LayoutSettings.Space, 0.0f))
+			];
+
+		// Add Loading widget on right
+		HorizontalBox.Get().AddSlot()
+			.VAlign(VAlign_Center)
+			.HAlign(HAlign_Center)
+			.AutoWidth()
+			[
+				LoadingWidget
+			];
+	}
+
+
+	EVerticalAlignment VerticalAlignment;
+	// Set vertical alignment for widget
+	if (LayoutSettings.bIsWidgetAtBottom)
+	{
+		VerticalAlignment = EVerticalAlignment::VAlign_Bottom;
+	}
+	else
+	{
+		VerticalAlignment = EVerticalAlignment::VAlign_Top;
+	}
+
+	// Creating loading theme
+	Root->AddSlot()
+	.HAlign(LayoutSettings.BorderHorizontalAlignment)
+	.VAlign(VerticalAlignment)		
+	[
+		SNew(SBorder)
+		.HAlign(HAlign_Fill)
+		.VAlign(VAlign_Fill)
+		.BorderImage(&LayoutSettings.BorderBackground)
+		.BorderBackgroundColor(FLinearColor::White)
+		[
+			SNew(SSafeZone)
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.IsTitleSafe(true)
+			.Padding(LayoutSettings.BorderPadding)
+			[
+				SNew(SDPIScaler)
+				.DPIScale(this, &SClassicLayout::GetDPIScale)
+				[					
+					HorizontalBox
+				]
+			]
+		]
+	];
+
+	// Construct loading complete text if enable
+	if (Settings.bShowLoadingCompleteText)
+	{
+		Root->AddSlot()
+			.VAlign(Settings.LoadingCompleteTextSettings.Alignment.VerticalAlignment)
+			.HAlign(Settings.LoadingCompleteTextSettings.Alignment.HorizontalAlignment)
+			.Padding(Settings.LoadingCompleteTextSettings.Padding)
+			[
+				SNew(SLoadingCompleteText, Settings.LoadingCompleteTextSettings)
+			];
+	}
+
+	// Add root to this widget
+	ChildSlot
+	[
+		Root
+	];
+}
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SDualSidebarLayout.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SDualSidebarLayout.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+
+#include "SDualSidebarLayout.h"
+#include "LoadingScreenSettings.h"
+#include "Widgets/Layout/SSafeZone.h"
+#include "Widgets/Layout/SDPIScaler.h"
+#include "Widgets/Layout/SSpacer.h"
+#include "SHorizontalLoadingWidget.h"
+#include "SVerticalLoadingWidget.h"
+#include "SBackgroundWidget.h"
+#include "STipWidget.h"
+#include "SLoadingCompleteText.h"
+
+void SDualSidebarLayout::Construct(const FArguments& InArgs, const FALoadingScreenSettings& Settings, const FDualSidebarLayoutSettings& LayoutSettings)
+{
+	// Root widget and background
+	TSharedRef<SOverlay> Root = SNew(SOverlay)
+		+ SOverlay::Slot()
+		.HAlign(HAlign_Fill)
+		.VAlign(VAlign_Fill)
+		[
+			SNew(SBackgroundWidget, Settings.Background)
+		];
+
+	// Placeholder for loading widget
+	TSharedRef<SWidget> LoadingWidget = SNullWidget::NullWidget;
+	if (Settings.LoadingWidget.LoadingWidgetType == ELoadingWidgetType::LWT_Horizontal)
+	{
+		LoadingWidget = SNew(SHorizontalLoadingWidget, Settings.LoadingWidget);
+	}
+	else
+	{
+		LoadingWidget = SNew(SVerticalLoadingWidget, Settings.LoadingWidget);
+	}
+
+
+
+	if (LayoutSettings.bIsLoadingWidgetAtRight)
+	{
+		// Add loading widget at right
+		Root.Get().AddSlot()
+		.HAlign(HAlign_Right)
+		.VAlign(LayoutSettings.RightBorderVerticalAlignment)		
+		[
+			SNew(SBorder)
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.BorderImage(&LayoutSettings.RightBorderBackground)
+			.BorderBackgroundColor(FLinearColor::White)
+			[
+				SNew(SSafeZone)
+				.HAlign(HAlign_Fill)
+				.VAlign(LayoutSettings.RightVerticalAlignment)
+				.IsTitleSafe(true)
+				.Padding(LayoutSettings.RightBorderPadding)
+				[
+					SNew(SDPIScaler)
+					.DPIScale(this, &SDualSidebarLayout::GetDPIScale)
+					[
+						LoadingWidget
+					]
+				]
+			]
+		];
+
+		// Add tip widget at left
+		Root.Get().AddSlot()
+		.HAlign(HAlign_Left)
+		.VAlign(LayoutSettings.LeftBorderVerticalAlignment)		
+		[
+			SNew(SBorder)
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.BorderImage(&LayoutSettings.LeftBorderBackground)
+			.BorderBackgroundColor(FLinearColor::White)
+			[
+				SNew(SSafeZone)
+				.HAlign(HAlign_Fill)
+				.VAlign(LayoutSettings.LeftVerticalAlignment)
+				.IsTitleSafe(true)
+				.Padding(LayoutSettings.LeftBorderPadding)
+				[
+					SNew(SDPIScaler)
+					.DPIScale(this, &SDualSidebarLayout::GetDPIScale)
+					[
+						SNew(STipWidget, Settings.TipWidget)
+					]
+				]
+			]
+		];
+	}
+
+	else
+	{
+		// Add Tip widget at right
+		Root.Get().AddSlot()
+		.HAlign(HAlign_Right)
+		.VAlign(LayoutSettings.RightBorderVerticalAlignment)		
+		[
+			SNew(SBorder)
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.BorderImage(&LayoutSettings.RightBorderBackground)
+			.BorderBackgroundColor(FLinearColor::White)
+			[
+				SNew(SSafeZone)
+				.HAlign(HAlign_Fill)
+				.VAlign(LayoutSettings.RightVerticalAlignment)
+				.IsTitleSafe(true)
+				.Padding(LayoutSettings.RightBorderPadding)
+				[
+					SNew(SDPIScaler)
+					.DPIScale(this, &SDualSidebarLayout::GetDPIScale)
+					[
+						SNew(STipWidget, Settings.TipWidget)						
+					]
+				]
+			]
+		];
+
+		// Add Loading widget at left
+		Root.Get().AddSlot()
+		.HAlign(HAlign_Left)
+		.VAlign(LayoutSettings.LeftBorderVerticalAlignment)		
+		[
+			SNew(SBorder)
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.BorderImage(&LayoutSettings.LeftBorderBackground)
+			.BorderBackgroundColor(FLinearColor::White)
+			[
+				SNew(SSafeZone)
+				.HAlign(HAlign_Fill)
+				.VAlign(LayoutSettings.LeftVerticalAlignment)
+				.IsTitleSafe(true)
+				.Padding(LayoutSettings.LeftBorderPadding)
+				[
+					SNew(SDPIScaler)
+					.DPIScale(this, &SDualSidebarLayout::GetDPIScale)
+					[
+						LoadingWidget
+					]
+				]
+			]
+		];
+	}
+
+	// Construct loading complete text if enable
+	if (Settings.bShowLoadingCompleteText)
+	{
+		Root->AddSlot()
+			.VAlign(Settings.LoadingCompleteTextSettings.Alignment.VerticalAlignment)
+			.HAlign(Settings.LoadingCompleteTextSettings.Alignment.HorizontalAlignment)
+			.Padding(Settings.LoadingCompleteTextSettings.Padding)
+			[
+				SNew(SLoadingCompleteText, Settings.LoadingCompleteTextSettings)
+			];
+	}
+
+	// Add root to this widget
+	ChildSlot
+	[
+		Root
+	];
+}
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SHorizontalLoadingWidget.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SHorizontalLoadingWidget.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#include "SHorizontalLoadingWidget.h"
+#include "LoadingScreenSettings.h"
+#include "Widgets/Layout/SSpacer.h"
+#include "Widgets/Images/SImage.h"
+#include "Slate/DeferredCleanupSlateBrush.h"
+#include "Widgets/Text/STextBlock.h"
+#include "Widgets/SBoxPanel.h"
+
+void SHorizontalLoadingWidget::Construct(const FArguments& InArgs, const FLoadingWidgetSettings& Settings)
+{
+	bPlayReverse = Settings.ImageSequenceSettings.bPlayReverse;	
+
+	// Root is a Horizontal Box of course
+	TSharedRef<SHorizontalBox> Root = SNew(SHorizontalBox);		
+	
+	// Construct Loading Icon Widget
+	ConstructLoadingIcon(Settings);
+
+	EVisibility LoadingTextVisibility;
+
+	if (Settings.LoadingText.IsEmpty())
+	{
+		LoadingTextVisibility = EVisibility::Collapsed;
+	}
+	else
+	{
+		LoadingTextVisibility = EVisibility::SelfHitTestInvisible;
+	}
+
+	// If loading text is on the right
+	if (Settings.bLoadingTextRightPosition)
+	{
+		// Add Loading Icon on the left first
+		Root.Get().AddSlot()
+			.HAlign(Settings.LoadingIconAlignment.HorizontalAlignment)
+			.VAlign(Settings.LoadingIconAlignment.VerticalAlignment)
+			.AutoWidth()
+			[
+				LoadingIcon
+			];
+
+		// Add a Spacer in middle
+		Root.Get().AddSlot()
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.AutoWidth()
+			[
+				SNew(SSpacer)
+				.Size(FVector2D(Settings.Space, 0.0f))
+			];
+
+		// Add Loading Text on the right
+		Root.Get().AddSlot()
+			.HAlign(Settings.TextAlignment.HorizontalAlignment)
+			.VAlign(Settings.TextAlignment.VerticalAlignment)
+			.AutoWidth()
+			[
+				SNew(STextBlock)
+				.Visibility(LoadingTextVisibility)
+				.ColorAndOpacity(Settings.Appearance.ColorAndOpacity)
+				.Font(Settings.Appearance.Font)
+				.ShadowOffset(Settings.Appearance.ShadowOffset)
+				.ShadowColorAndOpacity(Settings.Appearance.ShadowColorAndOpacity)
+				.Justification(Settings.Appearance.Justification)
+				.Text(Settings.LoadingText)				
+			];
+	}
+
+	// If loading text is on the left
+	else
+	{
+		// Add Loading Text on the left first
+		Root.Get().AddSlot()
+			.HAlign(Settings.TextAlignment.HorizontalAlignment)
+			.VAlign(Settings.TextAlignment.VerticalAlignment)
+			.AutoWidth()
+			[
+				SNew(STextBlock)
+				.Visibility(LoadingTextVisibility)
+				.ColorAndOpacity(Settings.Appearance.ColorAndOpacity)
+				.Font(Settings.Appearance.Font)
+				.ShadowOffset(Settings.Appearance.ShadowOffset)
+				.ShadowColorAndOpacity(Settings.Appearance.ShadowColorAndOpacity)
+				.Justification(Settings.Appearance.Justification)
+				.Text(Settings.LoadingText)				
+			];
+
+
+		// Add a Spacer in middle
+		Root.Get().AddSlot()
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.AutoWidth()
+			[
+				SNew(SSpacer)
+				.Size(FVector2D(Settings.Space, 0.0f))
+			];
+
+		// Add Loading Icon on the right finally
+		Root.Get().AddSlot()
+			.HAlign(Settings.LoadingIconAlignment.HorizontalAlignment)
+			.VAlign(Settings.LoadingIconAlignment.VerticalAlignment)
+			.AutoWidth()
+			[
+				LoadingIcon
+			];
+	}
+
+	// Add root to this widget
+	ChildSlot
+	[
+		Root
+	];	
+}
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SLetterboxLayout.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SLetterboxLayout.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#include "SLetterboxLayout.h"
+#include "LoadingScreenSettings.h"
+#include "Widgets/Layout/SSafeZone.h"
+#include "Widgets/Layout/SDPIScaler.h"
+#include "SHorizontalLoadingWidget.h"
+#include "SVerticalLoadingWidget.h"
+#include "SBackgroundWidget.h"
+#include "STipWidget.h"
+#include "SLoadingCompleteText.h"
+
+void SLetterboxLayout::Construct(const FArguments& InArgs, const FALoadingScreenSettings& Settings, const FLetterboxLayoutSettings& LayoutSettings)
+{
+	// Root widget and background
+	TSharedRef<SOverlay> Root = SNew(SOverlay)
+		+ SOverlay::Slot()
+		.HAlign(HAlign_Fill)
+		.VAlign(VAlign_Fill)
+		[
+			SNew(SBackgroundWidget, Settings.Background)
+		];
+
+	// Placeholder for loading widget
+	TSharedRef<SWidget> LoadingWidget = SNullWidget::NullWidget;
+	if (Settings.LoadingWidget.LoadingWidgetType == ELoadingWidgetType::LWT_Horizontal)
+	{
+		LoadingWidget = SNew(SHorizontalLoadingWidget, Settings.LoadingWidget);
+	}
+	else
+	{
+		LoadingWidget = SNew(SVerticalLoadingWidget, Settings.LoadingWidget);
+	}
+	
+
+	if (LayoutSettings.bIsLoadingWidgetAtTop)
+	{
+		// Add a border widget at top, then add Loading widget
+		Root->AddSlot()
+			.HAlign(LayoutSettings.TopBorderHorizontalAlignment)
+			.VAlign(VAlign_Top)	
+			[
+				SNew(SBorder)
+				.HAlign(HAlign_Fill)
+				.VAlign(VAlign_Fill)		
+				.BorderImage(&LayoutSettings.TopBorderBackground)
+				.BorderBackgroundColor(FLinearColor::White)
+				[
+					SNew(SSafeZone)
+					.HAlign(LayoutSettings.LoadingWidgetAlignment.HorizontalAlignment)
+					.VAlign(LayoutSettings.LoadingWidgetAlignment.VerticalAlignment)
+					.IsTitleSafe(true)
+					.Padding(LayoutSettings.TopBorderPadding)
+					[
+						SNew(SDPIScaler)
+						.DPIScale(this, &SLetterboxLayout::GetDPIScale)
+						[
+							LoadingWidget
+						]
+					]
+				]
+			];
+
+		// Add a border widget at bottom, then add Tip widget
+		Root->AddSlot()
+			.HAlign(LayoutSettings.BottomBorderHorizontalAlignment)
+			.VAlign(VAlign_Bottom)	
+			[
+				SNew(SBorder)
+				.HAlign(HAlign_Fill)
+				.VAlign(VAlign_Fill)
+				.BorderImage(&LayoutSettings.BottomBorderBackground)
+				.BorderBackgroundColor(FLinearColor::White)
+				[
+					SNew(SSafeZone)
+					.HAlign(LayoutSettings.TipAlignment.HorizontalAlignment)
+					.VAlign(LayoutSettings.TipAlignment.VerticalAlignment)
+					.IsTitleSafe(true)
+					.Padding(LayoutSettings.BottomBorderPadding)
+					[
+						SNew(SDPIScaler)
+						.DPIScale(this, &SLetterboxLayout::GetDPIScale)
+						[
+							SNew(STipWidget, Settings.TipWidget)
+						]						
+					]
+				]
+			];
+	}
+	else
+	{
+		// Add a border widget at top, then add Tip widget
+		Root->AddSlot()
+			.HAlign(LayoutSettings.TopBorderHorizontalAlignment)
+			.VAlign(VAlign_Top)	
+			[
+				SNew(SBorder)
+				.HAlign(HAlign_Fill)
+				.VAlign(VAlign_Fill)
+				.BorderImage(&LayoutSettings.TopBorderBackground)
+				.BorderBackgroundColor(FLinearColor::White)
+				[
+					SNew(SSafeZone)
+					.HAlign(LayoutSettings.TipAlignment.HorizontalAlignment)
+					.VAlign(LayoutSettings.TipAlignment.VerticalAlignment)
+					.IsTitleSafe(true)
+					.Padding(LayoutSettings.TopBorderPadding)
+					[
+						SNew(SDPIScaler)
+						.DPIScale(this, &SLetterboxLayout::GetDPIScale)
+						[					
+							SNew(STipWidget, Settings.TipWidget)
+						]						
+					]
+				]
+			];
+
+		// Add a border widget at bottom, then add Loading widget
+		Root->AddSlot()
+			.HAlign(LayoutSettings.BottomBorderHorizontalAlignment)
+			.VAlign(VAlign_Bottom)	
+			[
+				SNew(SBorder)
+				.HAlign(HAlign_Fill)
+				.VAlign(VAlign_Fill)
+				.BorderImage(&LayoutSettings.BottomBorderBackground)
+				.BorderBackgroundColor(FLinearColor::White)
+				[
+					SNew(SSafeZone)
+					.HAlign(LayoutSettings.LoadingWidgetAlignment.HorizontalAlignment)
+					.VAlign(LayoutSettings.LoadingWidgetAlignment.VerticalAlignment)
+					.IsTitleSafe(true)
+					.Padding(LayoutSettings.BottomBorderPadding)
+					[
+						SNew(SDPIScaler)
+						.DPIScale(this, &SLetterboxLayout::GetDPIScale)
+						[
+							LoadingWidget
+						]						
+					]
+				]
+			];
+	}
+
+	// Construct loading complete text if enable
+	if (Settings.bShowLoadingCompleteText)
+	{
+		Root->AddSlot()
+			.VAlign(Settings.LoadingCompleteTextSettings.Alignment.VerticalAlignment)
+			.HAlign(Settings.LoadingCompleteTextSettings.Alignment.HorizontalAlignment)
+			.Padding(Settings.LoadingCompleteTextSettings.Padding)
+			[
+				SNew(SLoadingCompleteText, Settings.LoadingCompleteTextSettings)
+			];
+	}
+
+	// Add Root to this widget
+	ChildSlot
+		[
+			Root
+		];
+}
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SLoadingCompleteText.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SLoadingCompleteText.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+
+#include "SLoadingCompleteText.h"
+#include "LoadingScreenSettings.h"
+#include "MoviePlayer.h"
+#include "Widgets/Text/STextBlock.h"
+
+void SLoadingCompleteText::Construct(const FArguments& InArgs, const FLoadingCompleteTextSettings& CompleteTextSettings)
+{
+	CompleteTextColor = CompleteTextSettings.Appearance.ColorAndOpacity.GetSpecifiedColor();
+	CompleteTextAnimationSpeed = CompleteTextSettings.AnimationSpeed;
+
+	ChildSlot
+	[
+		SNew(STextBlock)					
+		.Font(CompleteTextSettings.Appearance.Font)
+		.ShadowOffset(CompleteTextSettings.Appearance.ShadowOffset)
+		.ShadowColorAndOpacity(CompleteTextSettings.Appearance.ShadowColorAndOpacity)
+		.Justification(CompleteTextSettings.Appearance.Justification)
+		.Text(CompleteTextSettings.LoadingCompleteText)
+		.ColorAndOpacity(this, &SLoadingCompleteText::GetLoadingCompleteTextColor)
+		.Visibility(this, &SLoadingCompleteText::GetLoadingCompleteTextVisibility)
+	];	
+
+	// Register animated image sequence active timer event
+	if (CompleteTextSettings.bFadeInOutAnim && !bIsActiveTimerRegistered)
+	{
+		bIsActiveTimerRegistered = true;
+		RegisterActiveTimer(0.f, FWidgetActiveTimerDelegate::CreateSP(this, &SLoadingCompleteText::AnimateText));
+	}
+}
+
+EVisibility SLoadingCompleteText::GetLoadingCompleteTextVisibility() const
+{
+	return GetMoviePlayer()->IsLoadingFinished() ? EVisibility::Visible : EVisibility::Hidden;
+}
+
+FSlateColor SLoadingCompleteText::GetLoadingCompleteTextColor() const
+{
+	return CompleteTextColor;
+}
+
+EActiveTimerReturnType SLoadingCompleteText::AnimateText(double InCurrentTime, float InDeltaTime)
+{
+	const float MinAlpha = 0.1f;
+	const float MaxAlpha = 1.0f;
+
+	float TextAlpha = CompleteTextColor.A;
+
+	if (TextAlpha >= MaxAlpha)
+	{
+		bCompleteTextReverseAnim = true;
+	}
+	else if (TextAlpha <= MinAlpha)
+	{
+		bCompleteTextReverseAnim = false;
+	}
+
+	if (!bCompleteTextReverseAnim)
+	{
+		TextAlpha += InDeltaTime * CompleteTextAnimationSpeed;
+	}
+	else
+	{
+		TextAlpha -= InDeltaTime * CompleteTextAnimationSpeed;
+	}
+
+	CompleteTextColor.A = TextAlpha;
+
+	return EActiveTimerReturnType::Continue;
+}
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SLoadingScreenLayout.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SLoadingScreenLayout.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#include "SLoadingScreenLayout.h"
+#include "Engine/UserInterfaceSettings.h"
+
+float SLoadingScreenLayout::PointSizeToSlateUnits(float PointSize)
+{
+	const float SlateFreeTypeHorizontalResolutionDPI = 96.0f;
+	const float FreeTypeNativeDPI = 72.0;
+	const float PixelSize = PointSize * (SlateFreeTypeHorizontalResolutionDPI / FreeTypeNativeDPI);
+	return PixelSize;
+}
+
+float SLoadingScreenLayout::GetDPIScale() const
+{
+	const FVector2D DrawSize = GetTickSpaceGeometry().ToPaintGeometry().GetLocalSize();
+	const FIntPoint Size((int32)DrawSize.X, (int32)DrawSize.Y);
+	
+	return GetDefault<UUserInterfaceSettings>()->GetDPIScaleBasedOnSize(Size);
+}
+
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SLoadingWidget.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SLoadingWidget.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#include "SLoadingWidget.h"
+#include "Widgets/Images/SImage.h"
+#include "Slate/DeferredCleanupSlateBrush.h"
+#include "Widgets/Layout/SSpacer.h"
+#include "Engine/Texture2D.h"
+#include "MoviePlayer.h"
+#include "Widgets/SCompoundWidget.h"
+
+int32 SLoadingWidget::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
+{		
+	TotalDeltaTime += Args.GetDeltaTime();
+
+	if (TotalDeltaTime >= Interval)
+	{
+		if (CleanupBrushList.Num() > 1)
+		{
+			if (bPlayReverse)
+			{
+				ImageIndex--;
+			}
+			else
+			{
+				ImageIndex++;
+			}
+
+			if (ImageIndex >= CleanupBrushList.Num())
+			{
+				ImageIndex = 0;
+			}
+			else if (ImageIndex < 0)
+			{
+				ImageIndex = CleanupBrushList.Num() - 1;
+			}
+
+			StaticCastSharedRef<SImage>(LoadingIcon)->SetImage(CleanupBrushList[ImageIndex].IsValid() ? CleanupBrushList[ImageIndex]->GetSlateBrush() : nullptr);			
+		}
+
+		TotalDeltaTime = 0.0f;
+	}
+	
+
+	return SCompoundWidget::OnPaint(Args, AllottedGeometry, MyCullingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
+}
+
+SThrobber::EAnimation SLoadingWidget::GetThrobberAnimation(const FThrobberSettings& ThrobberSettings) const
+{
+	const int32 AnimationParams = (ThrobberSettings.bAnimateVertically ? SThrobber::Vertical : 0) |
+		(ThrobberSettings.bAnimateHorizontally ? SThrobber::Horizontal : 0) |
+		(ThrobberSettings.bAnimateOpacity ? SThrobber::Opacity : 0);
+
+	return static_cast<SThrobber::EAnimation>(AnimationParams);
+}
+
+void SLoadingWidget::ConstructLoadingIcon(const FLoadingWidgetSettings& Settings)
+{
+	if (Settings.LoadingIconType == ELoadingIconType::LIT_ImageSequence)
+	{
+		// Loading Widget is image sequence
+		if (Settings.ImageSequenceSettings.Images.Num() > 0)
+		{
+			CleanupBrushList.Empty();
+			ImageIndex = 0;
+
+			FVector2D Scale = Settings.ImageSequenceSettings.Scale;
+
+			for (auto Image: Settings.ImageSequenceSettings.Images)
+			{
+				if (Image)
+				{
+					CleanupBrushList.Add(FDeferredCleanupSlateBrush::CreateBrush(Image, FVector2D(Image->GetSurfaceWidth() * Scale.X, Image->GetSurfaceHeight() * Scale.Y)));					
+				}				
+			}
+		
+			// Create Image slate widget
+			LoadingIcon = SNew(SImage)
+				.Image(CleanupBrushList[ImageIndex]->GetSlateBrush());
+
+			// Update play animation interval
+			Interval = Settings.ImageSequenceSettings.Interval;
+		}
+		else
+		{
+			// If there is no image in the array then create a spacer instead
+			LoadingIcon = SNew(SSpacer).Size(FVector2D::ZeroVector);
+		}
+
+	}
+	else if (Settings.LoadingIconType == ELoadingIconType::LIT_CircularThrobber)
+	{
+		// Loading Widget is SCircularThrobber
+		LoadingIcon = SNew(SCircularThrobber)
+			.NumPieces(Settings.CircularThrobberSettings.NumberOfPieces)
+			.Period(Settings.CircularThrobberSettings.Period)
+			.Radius(Settings.CircularThrobberSettings.Radius)
+			.PieceImage(&Settings.CircularThrobberSettings.Image);
+	}
+	else
+	{
+		// Loading Widget is SThrobber
+		LoadingIcon = SNew(SThrobber)
+			.NumPieces(Settings.ThrobberSettings.NumberOfPieces)
+			.Animate(GetThrobberAnimation(Settings.ThrobberSettings))
+			.PieceImage(&Settings.ThrobberSettings.Image);
+	}
+
+	// Set Loading Icon render transform
+	LoadingIcon.Get().SetRenderTransform(FSlateRenderTransform(FScale2D(Settings.TransformScale), Settings.TransformTranslation));
+	LoadingIcon.Get().SetRenderTransformPivot(Settings.TransformPivot);
+
+	// Hide loading widget when level loading is done if bHideLoadingWidgetWhenCompletes is true 
+	if (Settings.bHideLoadingWidgetWhenCompletes)
+	{		
+		SetVisibility(TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateRaw(this, &SLoadingWidget::GetLoadingWidgetVisibility)));
+	}	
+}
+
+EVisibility SLoadingWidget::GetLoadingWidgetVisibility() const
+{
+	return GetMoviePlayer()->IsLoadingFinished() ? EVisibility::Hidden : EVisibility::Visible;
+}
\ No newline at end of file
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SSidebarLayout.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SSidebarLayout.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#include "SSidebarLayout.h"
+#include "LoadingScreenSettings.h"
+#include "Widgets/Layout/SSafeZone.h"
+#include "Widgets/Layout/SDPIScaler.h"
+#include "Widgets/Layout/SSpacer.h"
+#include "SHorizontalLoadingWidget.h"
+#include "SVerticalLoadingWidget.h"
+#include "SBackgroundWidget.h"
+#include "STipWidget.h"
+#include "SLoadingCompleteText.h"
+#include "Widgets/SBoxPanel.h"
+
+void SSidebarLayout::Construct(const FArguments& InArgs, const FALoadingScreenSettings& Settings, const FSidebarLayoutSettings& LayoutSettings)
+{
+	// Root widget and background
+	TSharedRef<SOverlay> Root = SNew(SOverlay)
+		+ SOverlay::Slot()
+		.HAlign(HAlign_Fill)
+		.VAlign(VAlign_Fill)
+		[
+			SNew(SBackgroundWidget, Settings.Background)
+		];
+
+	// Placeholder for loading widget
+	TSharedRef<SWidget> LoadingWidget = SNullWidget::NullWidget;
+	if (Settings.LoadingWidget.LoadingWidgetType == ELoadingWidgetType::LWT_Horizontal)
+	{
+		LoadingWidget = SNew(SHorizontalLoadingWidget, Settings.LoadingWidget);
+	}
+	else
+	{
+		LoadingWidget = SNew(SVerticalLoadingWidget, Settings.LoadingWidget);
+	}
+	
+
+	TSharedRef<SVerticalBox> VerticalBox = SNew(SVerticalBox);
+	if (LayoutSettings.bIsLoadingWidgetAtTop)
+	{
+		// Add loading widget at top
+		VerticalBox.Get().AddSlot()
+			.AutoHeight()
+			.HAlign(LayoutSettings.LoadingWidgetAlignment.HorizontalAlignment)
+			.VAlign(LayoutSettings.LoadingWidgetAlignment.VerticalAlignment)
+			[
+				LoadingWidget
+			];
+		
+		// Add SSpacer at middle
+		VerticalBox.Get().AddSlot()
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.AutoHeight()
+			[
+				SNew(SSpacer)
+				.Size(FVector2D(0.0f, LayoutSettings.Space))
+			];
+
+		// Add tip widget at bottom
+		VerticalBox.Get().AddSlot()
+			.AutoHeight()
+			.HAlign(LayoutSettings.TipAlignment.HorizontalAlignment)
+			.VAlign(LayoutSettings.TipAlignment.VerticalAlignment)
+			[
+				SNew(STipWidget, Settings.TipWidget)
+			];
+	}
+	else
+	{
+		// Add tip widget at top
+		VerticalBox.Get().AddSlot()
+			.AutoHeight()
+			.HAlign(LayoutSettings.TipAlignment.HorizontalAlignment)
+			.VAlign(LayoutSettings.TipAlignment.VerticalAlignment)
+			[
+				SNew(STipWidget, Settings.TipWidget)
+			];
+
+		// Add SSpacer at middle
+		VerticalBox.Get().AddSlot()
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.AutoHeight()
+			[
+				SNew(SSpacer)
+				.Size(FVector2D(0.0f, LayoutSettings.Space))
+			];
+
+		// Add loading widget at bottom
+		VerticalBox.Get().AddSlot()
+			.AutoHeight()
+			.HAlign(LayoutSettings.LoadingWidgetAlignment.HorizontalAlignment)
+			.VAlign(LayoutSettings.LoadingWidgetAlignment.VerticalAlignment)
+			[
+				LoadingWidget
+			];
+	}
+
+
+ 
+	if (LayoutSettings.bIsWidgetAtRight)
+	{
+		// Add widget at right
+		Root.Get().AddSlot()
+		.HAlign(HAlign_Right)
+		.VAlign(LayoutSettings.BorderVerticalAlignment)
+		.Padding(0, 0, LayoutSettings.BorderHorizontalOffset, 0)
+		[
+			SNew(SBorder)
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.BorderImage(&LayoutSettings.BorderBackground)
+			.BorderBackgroundColor(FLinearColor::White)
+			[
+				SNew(SSafeZone)
+				.HAlign(HAlign_Fill)
+				.VAlign(LayoutSettings.VerticalAlignment)
+				.IsTitleSafe(true)
+				.Padding(LayoutSettings.BorderPadding)
+				[
+					SNew(SDPIScaler)
+					.DPIScale(this, &SSidebarLayout::GetDPIScale)
+					[
+						VerticalBox
+					]
+				]
+			]
+		];
+	}
+	else
+	{
+		// Add widget at left
+		Root.Get().AddSlot()
+		.HAlign(HAlign_Left)
+		.VAlign(LayoutSettings.BorderVerticalAlignment)
+		.Padding(LayoutSettings.BorderHorizontalOffset, 0, 0, 0)
+		[
+			SNew(SBorder)
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.BorderImage(&LayoutSettings.BorderBackground)
+			.BorderBackgroundColor(FLinearColor::White)
+			[
+				SNew(SSafeZone)
+				.HAlign(HAlign_Fill)
+				.VAlign(LayoutSettings.VerticalAlignment)
+				.IsTitleSafe(true)
+				.Padding(LayoutSettings.BorderPadding)
+				[
+					SNew(SDPIScaler)
+					.DPIScale(this, &SSidebarLayout::GetDPIScale)
+					[
+						VerticalBox
+					]
+				]
+			]
+		];
+	}
+
+	// Construct loading complete text if enable
+	if (Settings.bShowLoadingCompleteText)
+	{
+		Root->AddSlot()
+			.VAlign(Settings.LoadingCompleteTextSettings.Alignment.VerticalAlignment)
+			.HAlign(Settings.LoadingCompleteTextSettings.Alignment.HorizontalAlignment)
+			.Padding(Settings.LoadingCompleteTextSettings.Padding)
+			[
+				SNew(SLoadingCompleteText, Settings.LoadingCompleteTextSettings)
+			];
+	}
+
+	// Add root to this widget
+	ChildSlot
+	[
+		Root
+	];
+}
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/STipWidget.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/STipWidget.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#include "STipWidget.h"
+#include "LoadingScreenSettings.h"
+#include "Widgets/Text/STextBlock.h"
+#include "AsyncLoadingScreenLibrary.h"
+
+void STipWidget::Construct(const FArguments& InArgs, const FTipSettings& Settings)
+{
+	if (Settings.TipText.Num() > 0)
+	{
+		int32 TipIndex = FMath::RandRange(0, Settings.TipText.Num() - 1);
+		
+		if (Settings.bSetDisplayTipTextManually == true)
+		{			
+			if (Settings.TipText.IsValidIndex(UAsyncLoadingScreenLibrary::GetDisplayTipTextIndex()))
+			{
+				TipIndex = UAsyncLoadingScreenLibrary::GetDisplayTipTextIndex();
+			}
+		}
+
+		ChildSlot
+		[
+			SNew(STextBlock)		
+			.ColorAndOpacity(Settings.Appearance.ColorAndOpacity)
+			.Font(Settings.Appearance.Font)
+			.ShadowOffset(Settings.Appearance.ShadowOffset)
+			.ShadowColorAndOpacity(Settings.Appearance.ShadowColorAndOpacity)
+			.Justification(Settings.Appearance.Justification)
+			.WrapTextAt(Settings.TipWrapAt)
+			.Text(Settings.TipText[TipIndex])			
+		];
+		
+	}
+}
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SVerticalLoadingWidget.cpp
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Private/SVerticalLoadingWidget.cpp
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#include "SVerticalLoadingWidget.h"
+#include "LoadingScreenSettings.h"
+#include "Widgets/Layout/SSpacer.h"
+#include "Widgets/Images/SImage.h"
+#include "Slate/DeferredCleanupSlateBrush.h"
+#include "Widgets/Text/STextBlock.h"
+
+void SVerticalLoadingWidget::Construct(const FArguments& InArgs, const FLoadingWidgetSettings& Settings)
+{
+	bPlayReverse = Settings.ImageSequenceSettings.bPlayReverse;
+
+	// Root is a Vertical Box
+	TSharedRef<SVerticalBox> Root = SNew(SVerticalBox);
+
+	// Construct Loading Icon Widget
+	ConstructLoadingIcon(Settings);
+
+	EVisibility LoadingTextVisibility;
+
+	if (Settings.LoadingText.IsEmpty())
+	{
+		LoadingTextVisibility = EVisibility::Collapsed;
+	}
+	else
+	{
+		LoadingTextVisibility = EVisibility::SelfHitTestInvisible;
+	}
+
+	// If loading text is on the top
+	if (Settings.bLoadingTextTopPosition)
+	{
+		// Add Loading Text on the top first
+		Root.Get().AddSlot()
+			.HAlign(Settings.TextAlignment.HorizontalAlignment)
+			.VAlign(Settings.TextAlignment.VerticalAlignment)
+			.AutoHeight()
+			[
+				SNew(STextBlock)
+				.Visibility(LoadingTextVisibility)
+				.ColorAndOpacity(Settings.Appearance.ColorAndOpacity)
+				.Font(Settings.Appearance.Font)
+				.ShadowOffset(Settings.Appearance.ShadowOffset)
+				.ShadowColorAndOpacity(Settings.Appearance.ShadowColorAndOpacity)
+				.Justification(Settings.Appearance.Justification)
+				.Text(Settings.LoadingText)				
+			];
+
+		// Add a Spacer in middle
+		Root.Get().AddSlot()
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.AutoHeight()
+			[
+				SNew(SSpacer)
+				.Size(FVector2D(0.0f, Settings.Space))
+			];
+
+		// Add Loading Icon at the bottom finally
+		Root.Get().AddSlot()
+			.HAlign(Settings.LoadingIconAlignment.HorizontalAlignment)
+			.VAlign(Settings.LoadingIconAlignment.VerticalAlignment)
+			.AutoHeight()
+			[
+				LoadingIcon
+			];
+	}
+
+	// If loading text is at the bottom
+	else
+	{
+		// Add Loading Icon on the top
+		Root.Get().AddSlot()
+			.HAlign(Settings.LoadingIconAlignment.HorizontalAlignment)
+			.VAlign(Settings.LoadingIconAlignment.VerticalAlignment)
+			.AutoHeight()
+			[
+				LoadingIcon
+			];
+
+		// Add a Spacer in middle
+		Root.Get().AddSlot()
+			.HAlign(HAlign_Fill)
+			.VAlign(VAlign_Fill)
+			.AutoHeight()
+			[
+				SNew(SSpacer)
+				.Size(FVector2D(0.0f, Settings.Space))
+			];
+
+		// Add Loading Text at the bottom
+		Root.Get().AddSlot()
+			.HAlign(Settings.TextAlignment.HorizontalAlignment)
+			.VAlign(Settings.TextAlignment.VerticalAlignment)
+			.AutoHeight()
+			[
+				SNew(STextBlock)
+				.Visibility(LoadingTextVisibility)
+				.ColorAndOpacity(Settings.Appearance.ColorAndOpacity)
+				.Font(Settings.Appearance.Font)
+				.ShadowOffset(Settings.Appearance.ShadowOffset)
+				.ShadowColorAndOpacity(Settings.Appearance.ShadowColorAndOpacity)
+				.Justification(Settings.Appearance.Justification)
+				.Text(Settings.LoadingText)				
+			];
+	}
+
+	// Add root to this widget
+	ChildSlot
+	[
+		Root
+	];
+}
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Public/AsyncLoadingScreen.h
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Public/AsyncLoadingScreen.h
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#pragma once
+
+#include "Modules/ModuleManager.h"
+
+struct FALoadingScreenSettings;
+
+class FAsyncLoadingScreenModule : public IModuleInterface
+{
+public:
+
+	/** IModuleInterface implementation */
+
+	/**
+	 * Called right after the module DLL has been loaded and the module object has been created
+	 */
+	virtual void StartupModule() override;
+	
+	/**
+	 * Called before the module is unloaded, right before the module object is destroyed.
+	 */
+	virtual void ShutdownModule() override;
+
+	/**
+	 * Returns true if this module hosts gameplay code 
+	 * 
+	 * @return True for "gameplay modules", or false for engine code modules, plugins, etc.
+	 */
+	virtual bool IsGameModule() const override;
+
+	/**
+	 * Singleton-like access to this module's interface. This is just for convenience!
+	 * Beware of calling this during the shutdown phase, though.  Your module might have been unloaded already.
+	 *
+	 * @return Returns singleton instance, loading the module on demand if needed
+	 */
+	static inline FAsyncLoadingScreenModule& Get()
+	{
+		return FModuleManager::LoadModuleChecked<FAsyncLoadingScreenModule>("AsyncLoadingScreen");
+	}
+
+	/**
+	 * Checks to see if this module is loaded and ready. It is only valid to call Get() if IsAvailable() returns true.
+	 *
+	 * @return True if the module is loaded and ready to use
+	 */
+	static inline bool IsAvailable()
+	{
+		return FModuleManager::Get().IsModuleLoaded("AsyncLoadingScreen");
+	}
+
+	TArray<UTexture2D*> GetBackgroundImages();
+
+	/**
+	 * Check if "bPreloadBackgroundImages" option is enabled
+	 */
+	bool IsPreloadBackgroundImagesEnabled();
+
+	/**
+	 * Is showing Startup Loading Screen?
+	 */
+	bool IsStartupLoadingScreen() { return bIsStartupLoadingScreen; }
+
+	/**
+	 * Load all background images from settings into array
+	 */
+	void LoadBackgroundImages();
+
+	/**
+	 * Remove all background images from array
+	 */
+	void RemoveAllBackgroundImages();
+
+private:
+	/**
+	 * Loading screen callback, it won't be called if we've already explicitly setup the loading screen
+	 */
+	void PreSetupLoadingScreen();
+
+	/**
+	 * Setup loading screen settings 
+	 */
+	void SetupLoadingScreen(const FALoadingScreenSettings& LoadingScreenSettings);
+
+	/**
+	 * Shuffle the movies list
+	 */
+	void ShuffleMovies(TArray<FString>& MoviesList);
+private:
+	// Startup background images array
+	UPROPERTY()
+	TArray<class UTexture2D*> StartupBackgroundImages;
+	
+	// Default background images array
+	UPROPERTY()
+	TArray<class UTexture2D*> DefaultBackgroundImages;
+
+	bool bIsStartupLoadingScreen = false;
+};
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Public/AsyncLoadingScreenLibrary.h
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Public/AsyncLoadingScreenLibrary.h
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "AsyncLoadingScreenLibrary.generated.h"
+
+/**
+ * Async Loading Screen Function Library
+ */
+UCLASS()
+class ASYNCLOADINGSCREEN_API UAsyncLoadingScreenLibrary : public UBlueprintFunctionLibrary
+{
+	GENERATED_BODY()
+private:
+	static int32 DisplayBackgroundIndex;
+	static int32 DisplayTipTextIndex;
+	static int32 DisplayMovieIndex;	
+	static bool  bShowLoadingScreen;
+public:
+	
+	/**
+	 * Set which background will be displayed on the loading screen by index. The "SetDisplayBackgroundManually" option in Background setting needs to be "true" to use this function.
+	 * 
+	 * @param BackgroundIndex Valid index of the Background in "Images" array in Background setting. If the index is not valid, then it will display random background instead.
+	 **/
+	UFUNCTION(BlueprintCallable, Category = "Async Loading Screen")
+	static void SetDisplayBackgroundIndex(int32 BackgroundIndex);
+
+	/**
+	 * Set which text will be displayed on the loading screen by index. The "SetDisplayTipTextManually" option in Tip Widget setting needs to be "true" to use this function.
+	 *
+	 * @param TipTextIndex Valid index of the text in "TipText" array in Tip Widget setting. If the index is not valid, then it will display random text instead.
+	 **/
+	UFUNCTION(BlueprintCallable, Category = "Async Loading Screen")
+	static void SetDisplayTipTextIndex(int32 TipTextIndex);
+
+	/**
+	 * Set which movie will be displayed on the loading screen by index. The "SetDisplayMovieIndexManually" option needs to be "true" to use this function.
+	 *
+	 * @param MovieIndex Valid index of the movie in "MoviePaths" array.
+	 **/
+	UFUNCTION(BlueprintCallable, Category = "Async Loading Screen")
+	static void SetDisplayMovieIndex(int32 MovieIndex);
+
+
+	/**
+	 * Set enable/disable the loading screen for next levels
+	 *
+	 * @param bIsEnableLoadingScreen Should we enable the loading screen for next level?
+	 **/
+	UFUNCTION(BlueprintCallable, Category = "Async Loading Screen")
+	static void SetEnableLoadingScreen(bool bIsEnableLoadingScreen);
+
+
+	/**
+	 * Get enable/disable the loading screen for next levels
+	 *
+	 **/
+	UFUNCTION(BlueprintPure, Category = "Async Loading Screen")
+	static inline bool GetIsEnableLoadingScreen() { return bShowLoadingScreen; }
+
+	/**
+	 * Stop the loading screen. To use this function, you must enable the "bAllowEngineTick" option.
+	 * Call this function in BeginPlay event to stop the Loading Screen (works with Delay node).
+	 *
+	 **/
+	UFUNCTION(BlueprintCallable, Category = "Async Loading Screen")
+	static void StopLoadingScreen();
+
+	static inline int32 GetDisplayBackgroundIndex() { return DisplayBackgroundIndex; }
+	static inline int32 GetDisplayTipTextIndex() { return DisplayTipTextIndex; }
+	static inline int32 GetDisplayMovieIndex() { return DisplayMovieIndex; }
+
+	/**
+	 * Load all background images into memory
+	 * 
+	 * Only use this function when: 
+	 * "bPreloadBackgroundImages" option is checked, 
+	 * and you called "RemovePreloadedBackgroundImages" before.
+	 * 
+	 * You don't need to use this if you never call
+	 * "RemovePreloadedBackgroundImages" function,
+	 * since the background images are still in the memory
+	 * 
+	 * Note: Call this function before calling "OpenLevel" node.
+	 * 
+	 **/
+	UFUNCTION(BlueprintCallable, Category = "Async Loading Screen")
+	static void PreloadBackgroundImages();
+
+	/**
+	 * Remove all preloaded background images
+	 * 
+	 * Only need to use this function when 
+	 * "bPreloadBackgroundImages" is checked.
+	 * 
+	 * You need to call "PreloadBackgroundImages" 
+	 * to manually load all background images again.
+	 * 
+	 **/
+	UFUNCTION(BlueprintCallable, Category = "Async Loading Screen")
+	static void RemovePreloadedBackgroundImages();
+};
--- a/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Public/LoadingScreenSettings.h
+++ b/Plugins/AsyncLoadingScreen/Source/AsyncLoadingScreen/Public/LoadingScreenSettings.h
+/************************************************************************************
+ *																					*
+ * Copyright (C) 2020 Truong Bui.													*
+ * Website:	https://github.com/truong-bui/AsyncLoadingScreen						*
+ * Licensed under the MIT License. See 'LICENSE' file for full license information. *
+ *																					*
+ ************************************************************************************/
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Engine/DeveloperSettings.h"
+#include "MoviePlayer.h"
+#include "Widgets/Layout/SScaleBox.h"
+#include "Styling/SlateBrush.h"
+#include "Framework/Text/TextLayout.h"
+#include "LoadingScreenSettings.generated.h"
+
+
+/** 
+ * Asynce Loading Screen Layouts
+ */
+UENUM(BlueprintType)
+enum class EAsyncLoadingScreenLayout : uint8
+{
+	/**
+	 * The Classic is a simple, generic layout and fits well with many designs.
+	 * Loading and tip widgets can be at the bottom or top.
+	 */
+	ALSL_Classic UMETA(DisplayName = "Classic"),
+	/** 
+	 * The loading widget is at the center of the screen, tip widget can be at the bottom or top.
+	 * The Center layout is a good choice if your loading icon is the main design.
+	 */
+	ALSL_Center UMETA(DisplayName = "Center"),
+	/**
+	 * The Letterbox layout has two borders on top and bottom of the screen. Loading widget 
+	 * can be on the top and the tip is at the bottom of the screen, or vice versa.
+	 */
+	 ALSL_Letterbox UMETA(DisplayName = "Letterbox"),
+	/**
+	 * The Sidebar layout has a vertical border on the left or right of the screen. The Sidebar 
+	 * is suitable for storytelling, long paragraphs due to the height of the tip widget.
+	 */
+	 ALSL_Sidebar UMETA(DisplayName = "Sidebar"),
+
+	/**
+	 * Similar to Sidebar layout but Dual Sidebar layout has two vertical borders on both left and right of the screen.
+	 * The Dual Sidebar layout is suitable for storytelling, long paragraphs due to the height of the tip widget.
+	 */
+	 ALSL_DualSidebar UMETA(DisplayName = "Dual Sidebar")
+};
+
+/** Loading Icon Type*/
+UENUM(BlueprintType)
+enum class ELoadingIconType : uint8
+{		
+	/** SThrobber widget */
+	LIT_Throbber UMETA(DisplayName = "Throbber"),
+	/** SCircularThrobber widget */
+	LIT_CircularThrobber UMETA(DisplayName = "Circular Throbber"),
+	/** Animated images */
+	LIT_ImageSequence UMETA(DisplayName = "Image Sequence")
+};
+
+/** Loading Widget type */
+UENUM(BlueprintType)
+enum class ELoadingWidgetType : uint8
+{
+	/** Horizontal alignment */
+	LWT_Horizontal UMETA(DisplayName = "Horizontal"),
+	/** Vertical alignment */
+	LWT_Vertical UMETA(DisplayName = "Vertical"),
+};
+
+/** Alignment for widget*/
+USTRUCT(BlueprintType)
+struct FWidgetAlignment
+{
+	GENERATED_BODY()
+	/** The horizontal alignment of the widget.*/
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Alignment Setting")
+	TEnumAsByte<EHorizontalAlignment> HorizontalAlignment = EHorizontalAlignment::HAlign_Center;
+
+	/** The vertical alignment of the widget.*/
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Alignment Setting")
+	TEnumAsByte<EVerticalAlignment> VerticalAlignment = EVerticalAlignment::VAlign_Center;
+};
+
+// Text appearance settings
+USTRUCT(BlueprintType)
+struct FTextAppearance
+{
+	GENERATED_BODY()
+
+	/** Text color and opacity */
+	UPROPERTY(BlueprintReadWrite, Config, EditAnywhere, Category = "Text Appearance")
+	FSlateColor ColorAndOpacity = FSlateColor(FLinearColor::White);
+
+	// The font to render the text with.
+	UPROPERTY(BlueprintReadWrite, Config, EditAnywhere, Category = "Text Appearance")
+	FSlateFontInfo Font;
+
+	/** Drop shadow offset in pixels */
+	UPROPERTY(BlueprintReadWrite, Config, EditAnywhere, Category = "Text Appearance")
+	FVector2D ShadowOffset = FVector2D::ZeroVector;
+
+	/** Shadow color and opacity */
+	UPROPERTY(BlueprintReadWrite, Config, EditAnywhere, Category = "Text Appearance")
+	FLinearColor ShadowColorAndOpacity = FLinearColor::White;
+
+	/** How the text should be aligned with the margin. */
+	UPROPERTY(BlueprintReadWrite, Config, EditAnywhere, Category = "Text Appearance")
+	TEnumAsByte <ETextJustify::Type> Justification = ETextJustify::Left;
+};
+
+USTRUCT(BlueprintType)
+struct FThrobberSettings
+{
+	GENERATED_BODY()
+
+	/** How many pieces there are */
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Appearance, meta = (ClampMin = "1", ClampMax = "25", UIMin = "1", UIMax = "25"))
+	int32 NumberOfPieces = 3;
+
+	/** Should the pieces animate horizontally? */
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Appearance)
+	bool bAnimateHorizontally = true;
+
+	/** Should the pieces animate vertically? */
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Appearance)
+	bool bAnimateVertically = true;
+
+	/** Should the pieces animate their opacity? */
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Appearance)
+	bool bAnimateOpacity = true;
+
+	/** Image to use for each segment of the throbber */
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Appearance)
+	FSlateBrush Image;
+};
+
+USTRUCT(BlueprintType)
+struct FCircularThrobberSettings
+{
+	GENERATED_BODY()
+
+	/** How many pieces there are */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Appearance, meta = (ClampMin = "1", ClampMax = "25", UIMin = "1", UIMax = "25"))
+	int32 NumberOfPieces = 6; 
+
+	/** The amount of time for a full circle (in seconds) */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Appearance, meta = (ClampMin = "0", UIMin = "0"))
+	float Period = 0.75f;
+
+	/** The radius of the circle. If the throbber is a child of Canvas Panel, the 'Size to Content' option must be enabled in order to set Radius. */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Appearance)
+	float Radius = 64.0f;
+
+	/** Image to use for each segment of the throbber */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Appearance)
+	FSlateBrush Image;
+};
+
+USTRUCT(BlueprintType)
+struct FImageSequenceSettings
+{
+	GENERATED_BODY()
+
+	/** An array of images for animating the loading icon.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting", meta = (AllowedClasses = "/Script/Engine.Texture2D"))
+	TArray<UTexture2D*> Images;
+
+	/** Scale of the images.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting")
+	FVector2D Scale = FVector2D(1.0f, 1.0f);
+
+	/**
+	 * Time in second to update the images, the smaller value the faster of the animation. A zero value will update the images every frame.
+	 */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting", meta = (UIMax = 1.00, UIMin = 0.00, ClampMin = "0", ClampMax = "1"))
+	float Interval = 0.05f;
+
+	/** Play the image sequence in reverse.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting")
+	bool bPlayReverse = false;
+};
+
+/**
+ * Background widget for the widget loading screen
+ */
+USTRUCT(BlueprintType)
+struct ASYNCLOADINGSCREEN_API FBackgroundSettings
+{
+	GENERATED_BODY()
+
+	// The images randomly display while in the loading screen on top of the movie 
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Background", meta = (AllowedClasses = "/Script/Engine.Texture2D"))
+	TArray<FSoftObjectPath> Images;
+
+	// The scaling type to apply to images.
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Background")
+	TEnumAsByte<EStretch::Type> ImageStretch = EStretch::ScaleToFit;
+
+	/** The padding area between the border and the image it contains.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Background")
+	FMargin Padding;
+
+	// The border's background color if there is any image defined. If padding = 0 you will not see the border color.
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Background")
+	FLinearColor BackgroundColor = FLinearColor::Black;
+
+	/**
+	 * If true, you will have to manually set which background index you want to display on the loading screen by calling "SetDisplayBackgroundIndex" function
+	 * in your Blueprint before opening a new level. If the index you set is not valid, then it will display random background in the "Images" array.
+	 */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Background")
+	bool bSetDisplayBackgroundManually = false;
+};
+
+/**
+ * Loading widget settings
+ */
+USTRUCT(BlueprintType)
+struct ASYNCLOADINGSCREEN_API FLoadingWidgetSettings
+{
+	GENERATED_BODY()
+
+	FLoadingWidgetSettings();
+
+	/** Loading icon type*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting")
+	ELoadingIconType LoadingIconType = ELoadingIconType::LIT_CircularThrobber;
+	
+	/** Loading Widget type*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting")
+	ELoadingWidgetType LoadingWidgetType = ELoadingWidgetType::LWT_Horizontal;
+
+	/** Render transform translation of the loading icon.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting")
+	FVector2D TransformTranslation = FVector2D(0.0f, 0.0f);
+
+	/** Render transform scale of the loading icon, a negative value will flip the icon.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting")
+	FVector2D TransformScale = FVector2D(1.0f, 1.0f);
+
+	/** Render transform pivot of the loading icon (in normalized local space).*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting")
+	FVector2D TransformPivot = FVector2D(0.5f, 0.5f);
+
+	// Text displayed beside the animated icon
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting")
+	FText LoadingText;
+
+	/** Is Loading Text on the right of the loading icon? Ignore this if you don't choose Loading Widget Type = Horizontal.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting")
+	bool bLoadingTextRightPosition = true;
+
+	/** Is Loading Text on the top of the loading icon? Ignore this if you don't choose Loading Widget Type = Vertical.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting")
+	bool bLoadingTextTopPosition = true;
+
+	// Loading text appearance settings
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Tip Settings")
+	FTextAppearance Appearance;
+
+	/** Throbber settings. Ignore this if you don't choose the 'Throbber' icon type*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting")
+	FThrobberSettings ThrobberSettings;
+
+	/** Circular Throbber settings. Ignore this if you don't choose the 'Circular Throbber' icon type*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting")
+	FCircularThrobberSettings CircularThrobberSettings;
+
+	/** Image Sequence settings. Ignore this if you don't choose the 'Image Sequence' icon type*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Widget Setting")
+	FImageSequenceSettings ImageSequenceSettings;
+
+	/** The alignment of the loading text.*/
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Loading Widget Setting")
+	FWidgetAlignment TextAlignment;
+
+	/** The alignment of the loading icon. */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Loading Widget Setting")
+	FWidgetAlignment LoadingIconAlignment;
+
+	/** Empty space between the loading text and the loading icon */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Loading Widget Setting")
+	float Space = 1.0f;
+
+	/** Hide the loading widget when the level loading is complete*/
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Loading Widget Setting")
+	bool bHideLoadingWidgetWhenCompletes = false;
+};
+
+
+/**
+ * Tips text settings
+ */
+USTRUCT(BlueprintType)
+struct ASYNCLOADINGSCREEN_API FTipSettings
+{
+	GENERATED_BODY()
+
+	// The tip text randomly display in the loading screen.
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Tip Settings", meta = (MultiLine = true))
+	TArray<FText> TipText;
+
+	// Tip text appearance settings
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Tip Settings")
+	FTextAppearance Appearance;
+
+	// The size of the tip before it's wrapped to the next line
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Tip Settings")
+	float TipWrapAt = 0.0f;
+
+	/**
+	 * If true, you will have to manually set which TipText index you want to display on the loading screen by calling "SetDisplayTipTextIndex" function
+	 * in your Blueprint before opening a new level. If the index you set is not valid, then it will display random Tip in the "TipText" array.
+	 */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Background")
+	bool bSetDisplayTipTextManually = false;
+};
+
+/**
+ * The text that displayed when loading is complete. Ignore this if you don't set "bShowLoadingCompletedText" = true
+ */
+USTRUCT(BlueprintType)
+struct ASYNCLOADINGSCREEN_API FLoadingCompleteTextSettings
+{
+	GENERATED_BODY()
+
+//	FLoadingCompleteTextSettings();
+
+	// The text that shows up when level loading is done.
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Complete Text Settings")
+	FText LoadingCompleteText;
+
+	// Text appearance settings
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Complete Text Settings")
+	FTextAppearance Appearance;
+	
+	/** The alignment of the text.*/
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Loading Widget Setting")
+	FWidgetAlignment Alignment;
+
+	/** Text padding. */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Complete Text Settings")
+	FMargin Padding;
+
+	// Animate the text?
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Complete Text Settings")
+	bool bFadeInOutAnim = true;
+
+	/**
+	 * Animation speed
+	 */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Complete Text Settings", meta = (UIMax = 10.00, UIMin = 0.00, ClampMin = "0", ClampMax = "10"))
+	float AnimationSpeed = 1.0f;
+};
+
+/**
+ * Loading Screen Settings
+ */
+USTRUCT(BlueprintType)
+struct ASYNCLOADINGSCREEN_API FALoadingScreenSettings
+{
+	GENERATED_BODY()	
+
+	// The minimum time that a loading screen should be opened for, -1 if there is no minimum time. I recommend set it to -1.
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Movies Settings")
+	float MinimumLoadingScreenDisplayTime = -1;
+	
+	// If true, the loading screen will disappear as soon as loading is done.
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Movies Settings")
+	bool bAutoCompleteWhenLoadingCompletes = true;
+
+	// If true, movies can be skipped by clicking the loading screen as long as loading is done.
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Movies Settings")
+	bool bMoviesAreSkippable = true;
+
+	/** 
+	 * If true, movie playback continue until Stop is called.
+	 * 
+	 * NOTE: If set "Minimum Loading Screen Display Time" = -1, it will allow players to press any key to stop the loading screen.
+	 * If "Minimum Loading Screen Display Time" >= 0, you have to call "StopLoadingScreen" in the BeginPlay event 
+	 * of your GameInstance, GameMode, or PlayerController blueprint to stop the loading screen ("bAllowEngineTick" must be true)
+	 **/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Movies Settings")
+	bool bWaitForManualStop = false;
+
+	/** If true loading screens here cannot have any uobjects of any kind or use any engine features at all. This will start the movies very early as a result on platforms that support it */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Movies Settings")
+	bool bAllowInEarlyStartup = false;
+
+	/** If true, this will call the engine tick while the game thread is stalled waiting for a loading movie to finish. This only works for post-startup load screens and is potentially unsafe */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Movies Settings")
+	bool bAllowEngineTick = false;
+
+	/** Should we just play back, loop, etc.  NOTE: if the playback type is MT_LoopLast, then bAutoCompleteWhenLoadingCompletes will be togged on when the last movie is hit*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Movies Settings")
+	TEnumAsByte<EMoviePlaybackType> PlaybackType = EMoviePlaybackType::MT_Normal;
+
+	/**
+	 * All movie files must be locate at Content/Movies/ directory. Suggested format: MPEG-4 Movie (mp4). Enter file path/name without the extension.
+	 * E.g., if you have a movie name my_movie.mp4 in the 'Content/Movies' folder, then enter my_movie in the input field.
+	 */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Movies Settings")
+	TArray<FString> MoviePaths;
+	
+	/**
+	 * If true, shuffle the movies list before playing.
+	 */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Movies Settings")
+	bool bShuffle = false;
+
+	/**
+	 * If true, the "Shuffle" option will be ignored, and you will have to manually set which Movie index you want to display on the loading screen 
+	 * by calling "SetDisplayMovieIndex" function in your Blueprint before opening a new level.
+	 */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Movies Settings")
+	bool bSetDisplayMovieIndexManually = false;
+
+
+	/** 
+	 * Should we show the loading screen widgets (background/tips/loading widget)? Generally you'll want to set this to false if you just want to show a movie.
+	 */ 
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Screen Settings")
+	bool bShowWidgetOverlay = true;		
+
+	/**
+	 * If true show a text when level loading is completed. Ignore this if you choose "Show Widget Overlay" = false
+	 *
+	 * NOTE: To enable this option properly, you need to set "Wait For Manual Stop" = true, and "Minimum Loading Screen Display Time" = -1.
+	 * This also allows players press any button to stop the Loading Screen.
+	 */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Screen Settings")
+	bool bShowLoadingCompleteText = false;
+
+	/**
+	 * The text that displayed when loading is complete. Ignore this if you set "Show Loading Complete Text" = false.
+	 */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Screen Settings")
+	FLoadingCompleteTextSettings LoadingCompleteTextSettings;
+
+	/** Background widget for the loading screen. Ignore this if you choose "Show Widget Overlay = false" */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Screen Settings")
+	FBackgroundSettings Background;	
+	
+	/** Tip widget for the loading screen. Ignore this if you choose "Show Widget Overlay = false" */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Screen Settings")
+	FTipSettings TipWidget;
+
+	/** Loading widget for the loading screen. Ignore this if you choose "Show Widget Overlay = false" */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Screen Settings")
+	FLoadingWidgetSettings LoadingWidget;
+
+	/**
+	 * Select async loading screen Layout. Ignore this if you choose "Show Widget Overlay = false"
+	 */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Loading Screen Settings")
+	EAsyncLoadingScreenLayout Layout = EAsyncLoadingScreenLayout::ALSL_Classic;
+};
+
+/** Classic Layout settings*/
+USTRUCT(BlueprintType)
+struct FClassicLayoutSettings
+{
+	GENERATED_BODY()
+
+	/** Is the border that contains loading and tip widget located at the bottom or top? */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Classic Layout")
+	bool bIsWidgetAtBottom = true;
+
+	/** Is loading widget on the left of the tip? */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Classic Layout")
+	bool bIsLoadingWidgetAtLeft = true;	
+
+	/** The empty space between loading widget and the tip.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Classic Layout")
+	float Space = 1.0f;
+
+	/** The alignment of the tips. */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Classic Layout")
+	FWidgetAlignment TipAlignment;
+
+	/** The horizontal alignment of the border background.*/
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Center Layout")
+	TEnumAsByte<EHorizontalAlignment> BorderHorizontalAlignment = EHorizontalAlignment::HAlign_Fill;
+
+	/** The padding area between the border and the widget it contains.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Classic Layout")
+	FMargin BorderPadding;
+
+	/** Background appearance settings for the border widget */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Classic Layout")
+	FSlateBrush BorderBackground;	
+};
+
+/** Center Layout settings*/
+USTRUCT(BlueprintType)
+struct FCenterLayoutSettings
+{
+	GENERATED_BODY()
+
+	/** Is tip located at the bottom or top? */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Center Layout")
+	bool bIsTipAtBottom = true;	
+
+	/** The alignment of the tips. */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Center Layout")
+	FWidgetAlignment TipAlignment;
+
+	/** The horizontal alignment of the border.*/
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Center Layout")
+	TEnumAsByte<EHorizontalAlignment> BorderHorizontalAlignment = EHorizontalAlignment::HAlign_Fill;
+
+	/** Offset to bottom or top of the screen depending on the tip located at the bottom or top position.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Center Layout")
+	float BorderVerticalOffset = 0.0f;
+
+	/** The padding area between the border and the tips it contains.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Center Layout")
+	FMargin BorderPadding;
+
+	/** Background appearance settings for tip area */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Center Layout")
+	FSlateBrush BorderBackground;
+};
+
+/** Letterbox Layout settings*/
+USTRUCT(BlueprintType)
+struct FLetterboxLayoutSettings
+{
+	GENERATED_BODY()
+
+	/** Is loading widget located at the bottom or top? */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Letterbox Layout")
+	bool bIsLoadingWidgetAtTop = true;
+
+	/** The alignment of the tips. */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Letterbox Layout")
+	FWidgetAlignment TipAlignment;
+
+	/** The alignment of the loading widget. */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Letterbox Layout")
+	FWidgetAlignment LoadingWidgetAlignment;
+
+	/** The horizontal alignment of the top border.*/
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Letterbox Layout")
+	TEnumAsByte<EHorizontalAlignment> TopBorderHorizontalAlignment = EHorizontalAlignment::HAlign_Fill;
+
+	/** The horizontal alignment of the bottom border.*/
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Letterbox Layout")
+	TEnumAsByte<EHorizontalAlignment> BottomBorderHorizontalAlignment = EHorizontalAlignment::HAlign_Fill;
+
+	/** The top padding area between the border and the widget it contains.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Letterbox Layout")
+	FMargin TopBorderPadding;
+
+	/** The bottom padding area between the border and the widget it contains.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Letterbox Layout")
+	FMargin BottomBorderPadding;
+
+	/** Background appearance settings for top border */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Letterbox Layout")
+	FSlateBrush TopBorderBackground;
+
+	/** Background appearance settings for bottom border */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Letterbox Layout")
+	FSlateBrush BottomBorderBackground;
+};
+
+/** Sidebar Layout settings*/
+USTRUCT(BlueprintType)
+struct FSidebarLayoutSettings
+{
+	GENERATED_BODY()
+
+	/** Is the border that contains loading and tip widgets located at the right or left? */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Sidebar Layout")
+	bool bIsWidgetAtRight = true;
+
+	/** Is loading widget on the top of the tip? */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Sidebar Layout")
+	bool bIsLoadingWidgetAtTop = true;
+
+	/** The empty space between loading widget and the tip.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Sidebar Layout")
+	float Space = 1.0f;	
+
+	/** The vertical alignment of the vertical box that contains loading/tip widgets. */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Sidebar Layout")
+	TEnumAsByte<EVerticalAlignment> VerticalAlignment = EVerticalAlignment::VAlign_Center;
+
+	/** The alignment of the loading widget. */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Sidebar Layout")
+	FWidgetAlignment LoadingWidgetAlignment;
+
+	/** The alignment of the tips. */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Sidebar Layout")
+	FWidgetAlignment TipAlignment;
+
+	/** The vertical alignment of the border background that contains all widgets. */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Sidebar Layout")
+	TEnumAsByte<EVerticalAlignment> BorderVerticalAlignment = EVerticalAlignment::VAlign_Fill;
+
+	/** Offset to left or right of the screen depending on the border that contains loading and tip widgets located at the left or right position.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Sidebar Layout")
+	float BorderHorizontalOffset = 0.0f;
+
+	/** The padding area between the border and the widget it contains.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Sidebar Layout")
+	FMargin BorderPadding;
+
+	/** Background appearance settings for the border widget */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Sidebar Layout")
+	FSlateBrush BorderBackground;
+};
+
+/** Dual Sidebar Layout settings*/
+USTRUCT(BlueprintType)
+struct FDualSidebarLayoutSettings
+{
+	GENERATED_BODY()
+
+	/** Is loading widget on the right or left border? */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Dual Sidebar Layout")
+	bool bIsLoadingWidgetAtRight = true;
+
+	/** The vertical alignment of the left widget. */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Dual Sidebar Layout")
+	TEnumAsByte<EVerticalAlignment> LeftVerticalAlignment = EVerticalAlignment::VAlign_Center;
+
+	/** The vertical alignment of the right widget. */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Dual Sidebar Layout")
+	TEnumAsByte<EVerticalAlignment> RightVerticalAlignment = EVerticalAlignment::VAlign_Center;
+
+	/** The vertical alignment of the left border background that contains all widgets. */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Dual Sidebar Layout")
+	TEnumAsByte<EVerticalAlignment> LeftBorderVerticalAlignment = EVerticalAlignment::VAlign_Fill;
+
+	/** The vertical alignment of the right border background that contains all widgets. */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Dual Sidebar Layout")
+	TEnumAsByte<EVerticalAlignment> RightBorderVerticalAlignment = EVerticalAlignment::VAlign_Fill;
+
+	/** The padding area between the left border and the widget it contains.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Dual Sidebar Layout")
+	FMargin LeftBorderPadding;
+
+	/** The padding area between the right border and the widget it contains.*/
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Dual Sidebar Layout")
+	FMargin RightBorderPadding;
+
+	/** Background appearance settings for the left border widget */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Dual Sidebar Layout")
+	FSlateBrush LeftBorderBackground;
+
+	/** Background appearance settings for the right border widget */
+	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Dual Sidebar Layout")
+	FSlateBrush RightBorderBackground;
+};
+
+/**
+ * Async Loading Screen Settings 
+ */
+UCLASS(Config = "Game", defaultconfig, meta = (DisplayName = "Async Loading Screen"))
+class ASYNCLOADINGSCREEN_API ULoadingScreenSettings : public UDeveloperSettings
+{
+	GENERATED_BODY()
+
+public:
+
+	ULoadingScreenSettings(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
+	
+	/**
+	 * If true, load all background images at the start of the game.
+	 * 
+	 * This is a workaround for the issue when the background image 
+	 * is loaded too late with the wrong image scaling. 
+	 * 
+	 * This issue only happens in the Standalone or Launch mode.
+	 * The packaged game should work fine.
+	 * 
+	 * If you don't encounter this issue when developing, don't enable 
+	 * this option, since it will keep the background images in the 
+	 * memory all the time, therefore consumes memory resources.
+	 * 
+	 * However, you can manually remove all the preloaded background
+	 * images by calling the Blueprint function 
+	 * "RemovePreloadedBackgroundImages"
+	 * 
+	 * You will need to re-load all background images by calling 
+	 * the Blueprint function "PreloadBackgroundImages"
+	 * 
+	 * Note: Call "PreloadBackgroundImages" before the "OpenLevel"
+	 * 
+	 */
+	UPROPERTY(Config, EditAnywhere, Category = "General")
+	bool bPreloadBackgroundImages = false;
+
+	/**
+	 * The startup loading screen when you first open the game. Setup any studio logo movies here.
+	 */
+	UPROPERTY(Config, EditAnywhere, Category = "General")
+	FALoadingScreenSettings StartupLoadingScreen;
+
+	/**
+	 * The default loading screen that shows up whenever you open a new level.
+	 */
+	UPROPERTY(Config, EditAnywhere, Category = "General")
+	FALoadingScreenSettings DefaultLoadingScreen;
+	
+	/**
+	 * Classic Layout settings.
+	 * The Classic is a simple, generic layout and fits well with many designs.
+	 * A border that contains loading and tip widgets can be at the bottom or top.
+	 */
+	UPROPERTY(Config, EditAnywhere, Category = "Layout")
+	FClassicLayoutSettings Classic;
+	
+	/**
+	 * Center Layout settings.
+	 * The loading widget is at the center of the screen, tip widget can be at the bottom or top.
+	 * The Center layout is a good choice if your loading icon is the main design.
+	 */
+	UPROPERTY(Config, EditAnywhere, Category = "Layout")
+	FCenterLayoutSettings Center;
+
+	/**
+	 * Letterbox Layout settings.
+	 * The Letterbox layout has two borders on top and bottom of the screen. Loading widget
+	 * can be on the top and the tip is at the bottom of the screen, or vice versa.
+	 */
+	UPROPERTY(Config, EditAnywhere, Category = "Layout")
+	FLetterboxLayoutSettings Letterbox;
+
+	/**
+	 * Sidebar Layout settings.
+	 * The Sidebar layout has a vertical border on the left or right of the screen. The Sidebar 
+	 * is suitable for storytelling, long paragraphs due to the height of the tip widget.
+	 */
+	UPROPERTY(Config, EditAnywhere, Category = "Layout")
+	FSidebarLayoutSettings Sidebar;
+
+	/**
+	 * Dual Sidebar Layout settings
+	 * Similar to Sidebar layout but Dual Sidebar layout has two vertical borders on both left and right of the screen.
+	 * The Dual Sidebar layout is suitable for storytelling, long paragraphs due to the height of the tip widget.
+	 */
+	UPROPERTY(Config, EditAnywhere, Category = "Layout")
+	FDualSidebarLayoutSettings DualSidebar;
+
+};
No results found