Join our channel

Follow 3DCGHUB on Telegram for new resource drops, migration updates, and community notices.

Join Telegram
Engine Tools

Loading Screen With Load Percentage

Examine how Loading Screen With Load Percentage uses UMG-to-Slate conversion, smooth interpolation, and asynchronous package tracking in Unreal Engine.

Categories: Unreal Engine, Engine ToolsPublished Nov 21, 2026
Resource overview

A functional transition screen requires a bridge between Unreal Engine's visual interface tools and the lower-level systems that operate while maps load. Loading Screen With Load Percentage establishes this connection by converting standard UMG layouts into Slate widgets, binding asynchronous package loading progress directly to user interface elements, and controlling execution flow across world transitions. By managing Slate rendering, mathematical interpolation, and travel parameters through a minimal set of functions, the tool manages level shifts without requiring custom C++ Slate construction from scratch.

Converting UMG to Slate for Screen Display

At the center of the plugin is a mechanism that converts a standard UMG widget into a native Slate widget. Standard UMG widgets operate within the world context of an active level. When that level is torn down during an open or travel command, standard widgets are cleared from the viewport. Slate, operating at a lower layer within the application framework, persists through the transition phase where the engine discards the old world and initializes the new one.

The workflow begins by defining a UMG design containing an indicator bar and percentage text. The plugin takes this layout, converts it into Slate, and presents it directly to the viewport. Because the converted interface exists at the Slate level, it remains visible and animated while the underlying engine destroys the existing world context. The setup also includes explicit ZOrder configuration, ensuring the loading screen layer renders over other viewport layers and graphics buffers during the handover phase.

Tracking the Package Load Percentage and Interpolation

Accurate progress tracking relies on evaluating asynchronous package requests. The system locates the targeted package using its object path and starts asynchronous loading routines. As data streams into memory, the plugin queries the percentage of loaded packages to drive the visual elements.

Raw package loading values often advance in uneven steps as disparate asset batches finish reading from disk. To prevent abrupt jumps in both the progress bar and numerical text readout, the plugin applies FInterpTo Smoothing. This smoothly interpolates the visual values toward the true loaded percentage across frames. For developers who require direct, frame-accurate reporting without mathematical smoothing, the plugin includes a toggle variable labeled "UseF Interp to Movement." Unchecking this setting bypasses the interpolation function entirely, immediately passing raw percentage values to the interface elements.

Percentage values are accessible directly within Blueprints, allowing designers to link the calculated progression to custom events or specialized data readouts. The interface system automatically locates the designated progress bar and text block displaying the % symbol, updating them continuously until the asynchronous operations conclude.

Transition Execution and Level Handovers

Tracking the completion of an asynchronous package load is only one half of a transition pipeline; the engine must also swap the active map cleanly. The plugin implements a structured sequence to manage this handover:

  • Convert and configure the chosen UMG asset into a Slate widget.
  • Detect the associated progress bar and percentage text element.
  • Locate the target package from its Object Path and initiate asynchronous loading.
  • Display the Slate widget on the screen.
  • Fetch the loading percentage of the packages and push updates to the progress bar and text.
  • Evaluate both package completion status and a defined minimum display time threshold before initiating OpenLevel Or ServerTravel.
  • Keep the configured screen active while the new level opens or while network travel concludes.
  • Verify the level transition before removing the Slate widget from view.

Enforcing a minimum display time guarantees that screens do not briefly flash and vanish when loading lightweight test scenes or cached assets. The plugin validates that this elapsed duration has passed alongside asset completion before executing the transition call. Once map initialization finishes, the plugin checks the transition state and hides the Slate widget, preventing visual artifacts such as momentary black frames during map initialization.

Visual Styles, Materials, and Motion States

Visual presentation includes features designed to avoid static loading scenes. The system supports standalone execution outside the editor environment, matching the behavior observed during active play sessions. Visual updates include dedicated background materials and specialized sectoral loading effect materials, expanding visual options beyond simple horizontal bars.

In addition to traditional linear progress bars, the plugin supports circular progress bars driven by Blueprint logic. Interface opacity can be managed using discrete fade-in and fade-out functions. These transitions incorporate configurable interpolation types, giving projects control over the curve and timing with which a screen enters the view or dissolves to reveal the loaded level.

Controlling the Loading Lifecycle and Sublevel Streaming

Modern level design frequently relies on streaming architectures rather than monolithic level files. The plugin provides native support for sublevel loading workflows, adapting beyond the legacy BeginLoadingScreenSimple Function which has been marked as deprecated. This ensures complex persistent map architectures with multiple streaming components can track and display their asset status through the same framework.

For projects built on Unreal Engine 5.5 and later releases, transition logic is expanded through a structured TravelSettings Configuration container. This structure exposes granular network and map parameters directly to transition calls:

  • ServerTravel Toggle: When enabled, the transition routine issues a ServerTravel Command rather than a standard OpenLevel Call, allowing multiplayer hosts to carry connected clients between game worlds.
  • Absolute & Options: The Absolute flag and launch option strings apply uniformly across both OpenLevel And ServerTravel Pathways, preserving URL parameters, game modes, and configuration parameters across level switches.

Engine versions 5.5 and onward also introduce manual lifecycle control over the screen display. By default, the system monitors level initialization and closes the interface automatically. By setting the AutoStopLoadingScreen Variable to false, developers prevent the screen from closing automatically when map streaming completes. The Slate interface remains active until the project explicitly executes the ManuallyStopLoadingScreen Function. This setup allows games to finish post-load processes—such as server synchronization, player pawn instantiation, or shader preparation—behind an uninterrupted interface before revealing the world.

Explore Similar Assets