¶ LoadSensePro - Professional Loading Screen System
¶ Overview
LoadSensePro is a production-ready loading screen system for Unreal Engine 5 that provides async UMG rendering, multiplayer synchronization, group travel system, and comprehensive Blueprint integration.
Current Version: 1.2.1
¶ 🚀 Key Features
¶ Core Loading System
- Async UMG Rendering - True async loading screen rendering with
UAsyncLoadingScreenRenderer - Map Loading with Screens -
LoadMapWithScreen()andLoadMapByDataAsset()for seamless transitions - Standalone Loading Screens - For long-running operations without level transitions
- Manual Progress Updates - Full control over loading progress and status
- True Async Rendering -
bUseTrueAsyncRenderingsetting for non-blocking UI
¶ Multiplayer Features (Optional)
- Client Synchronization -
RegisterSyncActor()andIsMultiplayerSyncEnabled() - Group Travel System - Advanced player coordination with
UGroupTravelSystem - Connection Quality Monitoring - Track player readiness and sync status
- Cross-platform Support - Works on all platforms with optional OnlineSubsystem
¶ Developer Tools
- Blueprint Integration - Full Blueprint support with
BlueprintCallablefunctions - Comprehensive Events - Rich delegate system for loading state changes
- Debug Support - Client sync status and error handling
- Configuration - Flexible settings via
ULoadingScreenDataAsset
¶ 🔧 Installation & Setup
¶ Requirements
- Unreal Engine 5.3.0 or higher
- No required dependencies (single-player mode)
- Optional: OnlineSubsystemUtils for multiplayer features
¶ Installation Steps
- Download the LoadSensePro plugin for your UE5 version
- Extract to your project’s
Pluginsfolder - Enable the plugin in Project Settings > Plugins
- Restart the Unreal Editor
¶ Basic Setup
// In your GameMode or GameInstance
#include "System/LoadingScreenSubsystem"
// Get the subsystem
ULoadingScreenSubsystem* LoadingSubsystem = GetGameInstance()->GetSubsystem<ULoadingScreenSubsystem>();
// Configure minimum loading time
LoadingSubsystem->SetMinimumLoadingTime(2.0f);
¶ 📚 Quick Start Guide
¶ Basic Map Loading
// Load a map with a loading screen widget class
LoadingSubsystem->LoadMapWithScreen(TEXT("NextLevel"), MyLoadingWidgetClass);
// Load a map using a data asset
ULoadingScreenDataAsset* LoadScreenData = LoadObject<ULoadingScreenDataAsset>(nullptr, TEXT("/Game/LoadingScreens/MyLoadScreen.MyLoadScreen"));
LoadingSubsystem->LoadMapByDataAsset(LoadScreenData);
¶ Standalone Loading Screens
// Show loading screen without level transition (for long operations)
LoadingSubsystem->ShowStandaloneLoadingScreenByDataAsset(LoadScreenAsset);
// Update progress manually
LoadingSubsystem->UpdateStandaloneProgress(0.5f, TEXT("Processing assets..."));
// Update status text without changing progress
LoadingSubsystem->SetStandaloneStatus(TEXT("Finalizing setup..."));
// Hide when done
LoadingSubsystem->HideStandaloneLoadingScreen();
¶ Check Loading Status
// Check if loading screen is active
if (LoadingSubsystem->IsLoadingScreenActive())
{
ELoadingScreenState CurrentState = LoadingSubsystem->GetCurrentState();
// Handle current state (Inactive, Loading, WaitingForLevel, etc.)
}
// Check if standalone mode is active
if (LoadingSubsystem->IsStandaloneLoadingScreenActive())
{
// Update progress for standalone loading
}
¶ 🎯 Advanced Features
¶ Multiplayer Synchronization
// Check if multiplayer sync is available
if (LoadingSubsystem->IsMultiplayerSyncEnabled())
{
// Register actors that need to participate in loading synchronization
LoadingSubsystem->RegisterSyncActor(MyGameMode);
LoadingSubsystem->RegisterSyncActor(MyCustomSyncActor);
// Get current client sync status
TArray<FClientSyncStatus> ClientStatuses = LoadingSubsystem->GetClientSyncStatus();
for (const FClientSyncStatus& Status : ClientStatuses)
{
UE_LOG(LogTemp, Log, TEXT("Client %s: Ready=%s"),
*Status.ClientId, Status.bIsReady ? TEXT("Yes") : TEXT("No"));
}
// Force client synchronization with timeout override
LoadingSubsystem->ForceClientSync(10.0f); // 10 second timeout
// Check if all clients are ready
if (LoadingSubsystem->AreAllClientsReady())
{
UE_LOG(LogTemp, Log, TEXT("All clients are ready for loading!"));
}
}
¶ Group Travel System
// Method 1: Using the simplified interface through LoadingScreenSubsystem
APlayerController* LeaderPC = GetFirstLocalPlayerController();
ULoadingScreenDataAsset* GroupLoadScreen = LoadObject<ULoadingScreenDataAsset>(nullptr, TEXT("/Game/LoadingScreens/GroupLoadScreen.GroupLoadScreen"));
// Initialize group travel with parameters
bool bSuccess = LoadingSubsystem->InitializeGroupTravel(LeaderPC, TEXT("BossLevel"), GroupLoadScreen, 4, 2);
// Quick start (even more simplified)
LoadingSubsystem->QuickStartGroupTravel(TEXT("NextLevel"), GroupLoadScreen);
// Method 2: Using the Group Travel System directly
UGroupTravelSystem* GroupTravel = LoadingSubsystem->GetGroupTravelSystem();
// Create detailed configuration
FGroupTravelConfig Config;
Config.TargetMapName = TEXT("BossLevel");
Config.GroupLoadingScreen = GroupLoadScreen;
Config.MaxGroupSize = 8;
Config.MinGroupSize = 2;
Config.ConfirmationTimeout = 30.0f;
Config.ReadyTimeout = 60.0f;
Config.bRequireAllMembers = true;
Config.bAllowLateJoiners = false;
// Initialize group travel
if (GroupTravel->InitializeGroupTravel(LeaderPC, Config))
{
// Add players to group
GroupTravel->AddPlayerToGroup(Player2Controller, true); // Requires confirmation
GroupTravel->AddPlayerToGroup(Player3Controller, false); // Auto-confirm
// Start the travel process (players must confirm first)
GroupTravel->StartGroupTravel();
// Or force start immediately
// GroupTravel->ForceStartGroupTravel();
}
¶ Event System
// In your class constructor or BeginPlay
ULoadingScreenSubsystem* LoadingSubsystem = GetGameInstance()->GetSubsystem<ULoadingScreenSubsystem>();
// Bind to loading screen events
LoadingSubsystem->OnLoadingScreenStateChanged.AddDynamic(this, &AMyGameMode::OnLoadingScreenStateChanged);
LoadingSubsystem->OnMapLoadingComplete.AddDynamic(this, &AMyGameMode::OnMapLoadingComplete);
LoadingSubsystem->OnMapLoadingProgress.AddDynamic(this, &AMyGameMode::OnMapLoadingProgress);
// Bind to multiplayer events
LoadingSubsystem->OnClientSyncStatusChanged.AddDynamic(this, &AMyGameMode::OnClientSyncStatusChanged);
LoadingSubsystem->OnAllClientsReady.AddDynamic(this, &AMyGameMode::OnAllClientsReady);
// Bind to group travel events
UGroupTravelSystem* GroupTravel = LoadingSubsystem->GetGroupTravelSystem();
GroupTravel->OnGroupTravelStateChanged.AddDynamic(this, &AMyGameMode::OnGroupTravelStateChanged);
GroupTravel->OnGroupMemberJoined.AddDynamic(this, &AMyGameMode::OnGroupMemberJoined);
¶ 🔍 Complete API Reference
¶ ULoadingScreenSubsystem
¶ Core Loading Methods
void LoadMapWithScreen(const FString& MapName, TSubclassOf<UUserWidget> LoadingWidgetClass)- Load a map with specified loading widget
void LoadMapByDataAsset(ULoadingScreenDataAsset* LoadingScreenData)- Load a map using a LoadingScreenDataAsset configuration
void ShowStandaloneLoadingScreen(TSubclassOf<UUserWidget> LoadingWidgetClass)- Show loading screen without level transition
void ShowStandaloneLoadingScreenByDataAsset(ULoadingScreenDataAsset* LoadingScreenData)- Show standalone loading screen using data asset
void HideStandaloneLoadingScreen()- Hide standalone loading screen
void ForceStopLoadingScreen()- Emergency cleanup to stop any active loading screen
¶ Standalone Loading Control
void UpdateStandaloneProgress(float Progress, const FString& StatusText = TEXT("Processing..."))- Update progress (0.0 to 1.0) and status text for standalone loading
void SetStandaloneStatus(const FString& StatusText, float Progress = -1.0f)- Update status text, optionally progress (-1.0 keeps current progress)
bool IsStandaloneLoadingScreenActive() const- Check if standalone loading screen is currently active
¶ Status & State Management
bool IsLoadingScreenActive() const- Check if loading screen is currently active
ELoadingScreenState GetCurrentState() const- Get current loading state: Inactive, Loading, WaitingForLevel, WaitingForClients, Finishing
void SetMinimumLoadingTime(float MinTime)- Set minimum time loading screen must be displayed
¶ Multiplayer Synchronization
void RegisterSyncActor(AActor* SyncActor)- Register actor that needs to participate in loading synchronization
void UnregisterSyncActor(AActor* SyncActor)- Unregister a sync actor
bool AreAllClientsReady() const- Check if all clients are ready for transition
void ForceClientSync(float TimeoutOverride = -1.0f)- Force client synchronization with optional timeout override
TArray<FClientSyncStatus> GetClientSyncStatus() const- Get current client sync status array
bool IsMultiplayerSyncEnabled() const- Check if multiplayer sync is enabled for current session
void SetClientReady(const FString& ClientId, bool bReady)- Set a client as ready (server-side)
int32 GetRequiredClientCount() const- Get total number of clients that need to be ready
¶ Group Travel System Integration
UGroupTravelSystem* GetGroupTravelSystem() const- Get the group travel system instance
bool InitializeGroupTravel(APlayerController* GroupLeader, const FString& MapName, ULoadingScreenDataAsset* GroupLoadingScreen = nullptr, int32 MaxGroupSize = 4, int32 MinGroupSize = 1)- Initialize group travel with simplified parameters
void QuickStartGroupTravel(const FString& MapName, ULoadingScreenDataAsset* GroupLoadingScreen = nullptr)- Quick start group travel with default settings
¶ Events (Delegates)
FOnLoadingScreenStateChanged OnLoadingScreenStateChanged- Called when loading screen state changes (bool bIsVisible)
FOnMapLoadingComplete OnMapLoadingComplete- Called when map loading completes (FString MapName)
FOnMapLoadingProgress OnMapLoadingProgress- Called during loading progress updates (float Progress, FString StatusMessage)
FOnStandaloneStatusChanged OnStandaloneStatusChanged- Called for standalone loading status updates (FString StatusText, float Progress)
FOnClientSyncStatusChanged OnClientSyncStatusChanged- Called when client sync status changes (FString ClientId, bool bIsReady)
FOnAllClientsReady OnAllClientsReady- Called when all clients are ready (float TotalSyncTime)
FOnClientSyncTimeout OnClientSyncTimeout- Called when client sync times out (FString ClientId, float TimeoutDuration)
¶ UGroupTravelSystem
¶ Group Management
bool InitializeGroupTravel(APlayerController* GroupLeader, const FGroupTravelConfig& TravelConfig)- Initialize a new group for travel with full configuration
bool AddPlayerToGroup(APlayerController* PlayerController, bool bRequireConfirmation = true)- Add a player to the travel group
bool RemovePlayerFromGroup(APlayerController* PlayerController)- Remove a player from the travel group
void InvitePlayersToGroup(const TArray<APlayerController*>& PlayerControllers, const FString& InvitationMessage = TEXT(""))- Invite multiple players to join the group
¶ Travel Coordination
bool StartGroupTravel()- Start the group travel process (confirmation phase)
bool ConfirmPlayerParticipation(APlayerController* PlayerController)- Confirm participation for a specific player
bool SetPlayerReady(APlayerController* PlayerController)- Set player as ready for travel
bool ForceStartGroupTravel()- Force start group travel (skip confirmations/ready checks)
void CancelGroupTravel(const FString& CancellationReason = TEXT("Travel cancelled"))- Cancel the current group travel
¶ Status & Information
EGroupTravelState GetGroupTravelState() const- Get current group travel state: Inactive, FormingGroup, WaitingForConfirm, PreparingTravel, TravelInProgress, SynchronizingArrival
TArray<FGroupMemberInfo> GetGroupMembers() const- Get all group members and their status
FGroupMemberInfo GetGroupLeader() const- Get group leader information
bool AreAllMembersConfirmed() const- Check if all group members have confirmed participation
bool AreAllMembersReady() const- Check if all group members are ready for travel
int32 GetGroupSize() const- Get current group size (number of players)
bool IsGroupTravelActive() const- Check if group travel is active
¶ Events (Delegates)
FOnGroupTravelStateChanged OnGroupTravelStateChanged- Called when group travel state changes (EGroupTravelState NewState, EGroupTravelState PreviousState)
FOnGroupMemberJoined OnGroupMemberJoined- Called when a member joins the group (FGroupMemberInfo MemberInfo)
FOnGroupMemberLeft OnGroupMemberLeft- Called when a member leaves the group (FGroupMemberInfo MemberInfo)
FOnGroupMemberConfirmed OnGroupMemberConfirmed- Called when a member confirms participation (FGroupMemberInfo MemberInfo)
FOnGroupMemberReady OnGroupMemberReady- Called when a member becomes ready (FGroupMemberInfo MemberInfo)
FOnGroupTravelStarted OnGroupTravelStarted- Called when group travel starts (FString TargetMap)
FOnGroupTravelCompleted OnGroupTravelCompleted- Called when group travel completes (FString TargetMap, float TotalTravelTime)
FOnGroupTravelFailed OnGroupTravelFailed- Called when group travel fails (FString ErrorReason, TArray FailedMembers)
¶ 🎨 Data Structures
¶ ELoadingScreenState
enum class ELoadingScreenState : uint8
{
Inactive, // No loading screen active
Loading, // Loading screen is showing
WaitingForLevel, // Waiting for level to load
WaitingForClients, // Waiting for multiplayer clients
Finishing // Loading completion phase
};
¶ EGroupTravelState
enum class EGroupTravelState : uint8
{
Inactive, // No group travel in progress
FormingGroup, // Forming group for travel
WaitingForConfirm, // Waiting for all group members to confirm
PreparingTravel, // Group confirmed, preparing to travel
TravelInProgress, // Travel in progress with loading screens
SynchronizingArrival // Synchronizing arrival on destination
};
¶ FClientSyncStatus
struct FClientSyncStatus
{
FString ClientId; // Unique client identifier
bool bIsReady = false; // Whether client is ready
float LastUpdateTime = 0.0f; // Last update timestamp
FString PlayerName; // Player display name
};
¶ FGroupMemberInfo
struct FGroupMemberInfo
{
FString PlayerId; // Player's unique identifier
FString PlayerName; // Player's display name
bool bHasConfirmed = false; // Whether player has confirmed travel
bool bIsReady = false; // Whether player is ready for travel
float ConnectionQuality = 1.0f; // Player's connection quality
float LastUpdateTime = 0.0f; // Last update time
};
¶ FGroupTravelConfig
struct FGroupTravelConfig
{
FString TargetMapName; // Target map for group travel
ULoadingScreenDataAsset* GroupLoadingScreen; // Loading screen data for group travel
int32 MaxGroupSize = 8; // Maximum group size
int32 MinGroupSize = 2; // Minimum group size to proceed
float ConfirmationTimeout = 30.0f; // Time to wait for confirmations
float ReadyTimeout = 60.0f; // Time to wait for all members to be ready
bool bRequireAllMembers = true; // Whether to wait for all members or proceed with majority
bool bAllowLateJoiners = false; // Allow members to join during travel preparation
};
¶ 🎯 Configuration Options
¶ LoadingScreenSubsystem Properties (Configurable in Editor)
¶ Default Settings
DefaultLoadingScreenDataAsset- Default loading screen data assetMinimumLoadingTime- Minimum time loading screen is shown (default: 2.0f)LevelCheckInterval- How often to check if level is loaded (default: 0.1f)GracePeriodAfterLoad- Extra time after level load before hiding (default: 0.5f)bPreloadImages- Whether to preload loading screen images (default: true)bUseAsyncLoading- Use async loading system (default: true)bUseTrueAsyncRendering- Use true async rendering (default: true)
¶ Multiplayer Settings
ClientSyncTimeout- Timeout for client synchronization (default: 30.0f)bRequireAllClientsReady- Require all clients to be ready (default: true)MinimumPlayersRequired- Minimum players for multiplayer sync (default: 1)ClientSyncCheckInterval- How often to check client sync (default: 0.5f)bEnableMultiplayerSync- Enable multiplayer synchronization (default: true)
¶ LoadingScreenDataAsset Properties
¶ Display Configuration
- Background Images: Array of background textures
- Tip Images: Array of tip/promotional images
- Tips Array: Text tips to display during loading
- Tip Display Time: Duration each tip is shown
- Background Music: Music track to play during loading
¶ Animation Settings
- Fade In Duration: Screen fade-in animation time
- Fade Out Duration: Screen fade-out animation time
- Loading Animation: Optional loading spinner/animation widget
- Animation Speed: Animation playback speed multiplier
¶ Timing & Behavior
- Minimum Display Time: Minimum time loading screen is shown
- Maximum Display Time: Maximum time before auto-hide
- Auto Hide: Whether to automatically hide when loading completes
- Show Progress: Whether to show loading progress
- Show Tips: Whether to cycle through tips
¶ 🔧 Platform Support
¶ Supported Platforms
- Win64 - Full support including multiplayer features
- Linux - Full support including multiplayer features
- Mac - Full support including multiplayer features
- Android - Single-player support, optional multiplayer with OnlineSubsystem
- iOS - Single-player support, optional multiplayer with OnlineSubsystem
¶ Platform-Specific Configuration
¶ Mobile Platforms (Android/iOS)
- OnlineSubsystemUtils is optional by default to reduce binary size
- Core loading screen features work without any networking dependencies
- Multiplayer features available when OnlineSubsystem is enabled in project settings
- Optimized for mobile performance and memory constraints
¶ Desktop Platforms (Win64/Linux/Mac)
- Full feature set available including all multiplayer capabilities
- OnlineSubsystemUtils enabled by default for complete functionality
- Enhanced debug and development tools available
¶ 🐛 Troubleshooting
¶ Common Issues & Solutions
¶ Build Errors
Problem: “Could not find definition for module” or build fails when adding LoadSensePro
Solution: Ensure OnlineSubsystemUtils is set as optional/disabled in the plugin configuration for single-player projects. LoadSensePro now has optional networking dependencies.
¶ Loading Screen Not Appearing
Problem: LoadMapWithScreen or LoadMapByDataAsset doesn’t show loading screen
Solutions:
- Check that
MinimumLoadingTimeis set appropriately (default: 2.0f) - Ensure the loading widget class or data asset is valid
- Verify that
bUseAsyncLoadingandbUseTrueAsyncRenderingare enabled - Check console logs for any error messages
¶ Standalone Loading Issues
Problem: Standalone loading screen doesn’t update progress
Solutions:
- Use
IsStandaloneLoadingScreenActive()to verify standalone mode is active - Call
UpdateStandaloneProgress()with values between 0.0 and 1.0 - Use
SetStandaloneStatus()for status-only updates - Remember to call
HideStandaloneLoadingScreen()when finished
¶ Multiplayer Sync Problems
Problem: Players not synchronizing properly or IsMultiplayerSyncEnabled() returns false
Solutions:
- Verify OnlineSubsystemUtils is enabled in project settings for multiplayer
- Check that
bEnableMultiplayerSyncis enabled in subsystem settings - Ensure all clients are connected and have valid PlayerStates
- Use
GetClientSyncStatus()to debug individual client states - Call
ForceClientSync()with appropriate timeout if needed
¶ Group Travel Issues
Problem: Group travel initialization fails or players don’t join
Solutions:
- Verify
FGroupTravelConfighas valid settings (check MinGroupSize <= MaxGroupSize) - Ensure GroupLeader is a valid PlayerController with PlayerState
- Check that
ValidateGroupConfiguration()returns true - Use
GetGroupTravelState()to debug current state - Verify all added players pass
ValidatePlayerForGroup()checks
¶ Debug Tools & Commands
¶ Console Commands
// In game console or during development
showlog // Show console output
stat game // Show game performance stats
¶ Code Debugging
// Enable detailed logging
ULoadingScreenSubsystem* LoadingSubsystem = GetGameInstance()->GetSubsystem<ULoadingScreenSubsystem>();
// Check current state
ELoadingScreenState State = LoadingSubsystem->GetCurrentState();
UE_LOG(LogTemp, Log, TEXT("Current loading state: %d"), (int32)State);
// Check multiplayer sync
bool bMultiplayerEnabled = LoadingSubsystem->IsMultiplayerSyncEnabled();
TArray<FClientSyncStatus> ClientStatuses = LoadingSubsystem->GetClientSyncStatus();
UE_LOG(LogTemp, Log, TEXT("Multiplayer enabled: %s, Clients: %d"),
bMultiplayerEnabled ? TEXT("Yes") : TEXT("No"), ClientStatuses.Num());
// Check group travel
UGroupTravelSystem* GroupTravel = LoadingSubsystem->GetGroupTravelSystem();
EGroupTravelState TravelState = GroupTravel->GetGroupTravelState();
TArray<FGroupMemberInfo> Members = GroupTravel->GetGroupMembers();
UE_LOG(LogTemp, Log, TEXT("Group travel state: %d, Members: %d"),
(int32)TravelState, Members.Num());
¶ 📈 Performance Considerations
¶ Best Practices
- Use Async Loading: Keep
bUseAsyncLoadingandbUseTrueAsyncRenderingenabled for smooth performance - Optimize Images: Use compressed textures for loading screen backgrounds
- Set Appropriate Timeouts: Configure
ClientSyncTimeoutandMinimumLoadingTimebased on your content - Monitor Performance: Use the loading state events to track actual loading times
- Test on Target Platforms: Verify performance across all supported platforms
¶ Memory Management
- Loading screen assets are automatically cleaned up when loading completes
- Standalone loading screens use dedicated resource management
- Group travel system properly manages member lists and timers
- Async loading handles large asset collections efficiently
¶ Network Optimization
- Use
ClientSyncCheckIntervalto balance responsiveness with network traffic - Configure
ConfirmationTimeoutandReadyTimeoutbased on your game’s loading times - Consider connection quality when setting
MinimumPlayersRequired - Use
bRequireAllMemberssetting appropriately for your game design
¶ 🆕 Version 1.1.7 Updates
¶ Major Improvements
- Optional OnlineSubsystemUtils: Now truly optional, enabling single-player projects to use LoadSensePro without networking dependencies
- Enhanced Build Compatibility: Fixed demo project build issues and improved platform support
- Conditional Networking: All multiplayer features gracefully degrade when OnlineSubsystem is unavailable
- Improved Error Handling: Better fallback mechanisms and clearer error messages
¶ Technical Changes
- LoadSensePro.Build.cs: Conditional OnlineSubsystemUtils dependency
- LoadSensePro.uplugin: Optional plugin dependency configuration
- Source code: WITH_ONLINESUBSYSTEM guards for all networking functionality
- Cross-platform compatibility improvements for mobile development
¶ 🤝 Support & Community
¶ Getting Help
- Discord Community: Join our Discord server for real-time support
- Documentation: Visit LoadSensePro Wiki for comprehensive guides
- Issues: Report bugs and feature requests through appropriate channels
¶ Development Resources
- Complete API reference with all function signatures and parameters
- Example projects and code samples
- Performance optimization guides
- Platform-specific configuration examples
This documentation is based on LoadSensePro v1.1.7 source code and includes only validated, existing functionality. For the latest updates and community support, visit our Discord server.