How to check if a Data Layer has finished loading all actors into a level

Development Programming & Scripting
,
1

I’m using the Data Layer Subsystem to manage multiple data layers in a level. However, I’m having trouble finding how I can query or get a callback when all the actors in a Data Layer are finished loading and are active in the world.

To add context, I have a data layer for a main menu scene, and a data layer for a store scene. The goal here is to allow us to make multiple levels that we can swap in and out as we see fit (by dragging them into the world and assigning them a data layer). When transitioning to the store, we activate the store data layer and set the main menu data layer to loaded. I need to wait for all the actors to finish loading into the world before I can query the camera from the store scene that I want to blend to.

DataLayerSubsystem->SetDataLayerInstanceRuntimeState(MainMenuDataLayerAsset, EDataLayerRuntimeState::Loaded);
DataLayerSubsystem->SetDataLayerInstanceRuntimeState(StoreDataLayerAsset, EDataLayerRuntimeState::Activated);

I’ve tried tying into:

DataLayerSubsystem->OnDataLayerRuntimeStateChanged.AddUniqueDynamic(this, &ThisClass::OnDataLayerRuntimeStateChanged);

but this just broadcasts state changes to the UDataLayerAsset, and not when all the actors have finished loading into the world.

Is anyone able to give me some insights or point me in the right direction?

*NOTE: as a temporary solution I query for the camera actor I’m looking for every 0.25 seconds until I find it.

2

Hey, i am trying to do something similar. Any chance you found a solution or some resources i can go read? Thx.

3

So i came across this issue too, and found a decent solution, which was to hook into the callback for Level Instance loading. This obviously works because our game is primarily loading in Level Instances through World Partition, so may not be applicable for everyone.

First, create a new function like:

void MyClass::OnLevelStreamingStateChanged(UWorld* InWorld, const ULevelStreaming* InStreamingLevel, ULevel* LevelIfLoaded, ELevelStreamingState PreviousState, ELevelStreamingState NewState)

Then, hook into the delegate with

FLevelStreamingDelegates::OnLevelStreamingStateChanged.AddUObject(this, &MyClass::OnLevelStreamingStateChanged);

Then, in your OnLevelStreamingStateChanged function:

void MyClass::OnLevelStreamingStateChanged(UWorld* InWorld, const ULevelStreaming* InStreamingLevel, ULevel* LevelIfLoaded, ELevelStreamingState PreviousState, ELevelStreamingState NewState)
{	
	if(NewState != PreviousState && NewState != ELevelStreamingState::LoadedVisible) return;

	//make sure we are dealing with a Level Instance
	const ULevelStreamingLevelInstance* LevelInstance = (ULevelStreamingLevelInstance*)Cast<ULevelStreamingLevelInstance>(InStreamingLevel);
	if(LevelInstance == nullptr) return;

	if(LevelInstance->GetWorldAssetPackageName().Contains(MyLevelInstanceName))
	{
		//do things here
	}
}

Now we can see when a Level Instance that matches the level we are waiting on has completed loading!

4

We are dealing with the same issue using BPs in 5.3. It seems that a lot of functions for Data Layer management are simply not there and we struggle to understand the usefulness of runtime Data Layer control if it will result in screen freezing and objects appearing suddenly out of nowhere in front of the player.

To get around this issue, the developer needs to (a) know when the Data Layer has finished being Activated and also (b) control the rate of Loading/Activation. If we can’t have (b), then at least we need (a).

Weren’t Data Layers introduced in Unreal 5.0? What can we do to get some functionality out for this? (We are not using Level Instances right now so that method wouldn’t work).

5

We discovered that the answer lies in the Valley of the Ancient demo. You can use the method “IsStreamingCompleted” from the WorldPartitionSubsystem. Had to dig through that big project because finding the answer online did not yield any results. Of course, this solves only the (a) part. Still need to figure out the answer for (b).

1 Like
6

You can wrap “Set data layer runtime state” into a latent function along with WorldPartitionSubsystem->IsStreamingCompleted() to get an async node that returns when all data layers have fully loaded:

Capture

FAsyncCoroutine UGameUtilities::SetDataLayerRuntimeStateAsync(FLatentActionInfo LatentInfo, const UObject* WorldContextObject, const UDataLayerAsset* DataLayerAsset, EDataLayerRuntimeState InState, bool bInIsRecursive)
{
	const UWorld* World = WorldContextObject->GetWorld();

	UWorldPartitionSubsystem* WorldPartitionSubsystem = World->GetSubsystem<UWorldPartitionSubsystem>();
	
	if (!World || !WorldPartitionSubsystem)
		co_return;
	
	if (UDataLayerManager* DataLayerManager = UDataLayerManager::GetDataLayerManager(World))
	{
		if (const UDataLayerInstance* DataLayerInstance = DataLayerManager->GetDataLayerInstanceFromAsset(DataLayerAsset))
		{
			DataLayerManager->SetDataLayerRuntimeState(DataLayerAsset, InState, bInIsRecursive);
		}
		else
		{
			UE_LOG(LogWorldPartition, Warning, TEXT("UDataLayerManager::SetDataLayerRuntimeState unknown Data Layer"));
		}
	}

	bool bStreamingComplete = false;

	while (!bStreamingComplete)
	{
		co_await UE5Coro::Latent::NextTick();
		bStreamingComplete = WorldPartitionSubsystem->IsStreamingCompleted();
	}
	
	co_return;
}

The above code uses the wonderful Unreal coroutines library, if you can’t or don’t want to use coroutines you will have to use one of the default engine async methods

1 Like
7

This coroutine library needs to be part of standard Unreal. Thank you for making me aware of it.

8

Thank you very much for sharing this! I’m very novice when it comes to C++ but have started studying this code to get an understanding of it. When you said that it’s an async node, do you mean that it will load/unload Data Layer assets asynchronously, so that assets are handled in the background off of the main thread?