Level translation when streaming not working

Development World Creation
, ,
1

This question explains & answer how to stream in a level at a location. As described, I set the LevelTransform on the StreamingLevel before requesting it to be loaded. However, despite the transform being correct, the level is still based around the origin.

Digging in to it I see that when we come to UWorld::AddToWorld, the bAlreadyMovedActors flag has been set to true so the transform is never applied. Further looking reveals it gets set to true in this bit of code:

UWorld* PIELevelWorld = UWorld::DuplicateWorldForPIE(NonPrefixedLevelName, PersistentWorld);
if (PIELevelWorld)
{
	PIELevelWorld->PersistentLevel->bAlreadyMovedActors = true; // As we have duplicated the world, the actors will already have been transformed
	check(PendingUnloadLevel == NULL);
	SetLoadedLevel(PIELevelWorld->PersistentLevel);

	// Broadcast level loaded event to blueprints
	OnLevelLoaded.Broadcast();

	return true;
}

This is inside ULevelStreaming::RequestLevel. I’m not really sure what the comment means, but the level is definitely the new level being streamed in (why it is called the PersistentLevel I’m not sure, it isn’t the persistent level - just a duplication of the persistent world…).

Also, the fact that it is talking about PIE (PlayInEditor) makes me worry this is going to be an editor only issue…

How do I correctly apply the transform to the level?

Update

Commenting out the setting of bAlreadyMovedActors in the above sample does “resolve” the issue, so it is at least related to that.

2

Yeah, it’s a known issue, basically setting level transform in the blueprints does not work in PIE. Editor assumes that loaded sub-levels are already been transformed, so he does not need to apply transformation again when duplicating sub-levels for PIE session. We will look into fixing it, as a workaround you can PIE as standalone game, in this case blueprint transformations will work, because game will actually load sub-levels instead of duplicating them from editor world.

3

Ah ok, what down sides are there to commenting out the bAlreadyMovedActors in the above sample? Didn’t see any issues but obviously didn’t test exhaustively. Would rather not use the standalone if possible…

4

It will not work correctly when you have transform applied in the Editor. In Levels details tab you can set sub-level transform. But if you don’t use editor transforms then ignoring bAlreadyMovedActors will work fine.

5

Holp this can help you: https://youtu.be/hLIs0Bou7mU

6

This is still an issue in 4.21. I think i would like to also ignore bAlreadyMovedActors but would hate to have to fork the engine just for this. Any plans to address this issue?

7

Why can’t we have this exposed as a boolean option in editor for each sub-level and if we tick it off (to enable dynamic transforms) then the editor transform box becomes disabled to show that it is being ignored…

8

can it be that this problem is still not resolved in 5.2? At least I still have it. Any known fixes yet?

9

After a morning of struggling with this, I think I have a solution.

I make the solution in C++, this is the code:

void ACorridorActor::LoadLevel(const FName LevelName, const FTransform& LevelTransform)
{
	auto CurrentLevel = UGameplayStatics::GetStreamingLevel(GetWorld(), LevelName);

	if (CurrentLevel && !CurrentLevel->IsLevelLoaded())
	{
		LoadedLevelTransform = LevelTransform;
		LoadedLevelName = LevelName;
		
		FLatentActionInfo LatentInfo;
		LatentInfo.Linkage = 0;
		LatentInfo.UUID = 1;
		LatentInfo.CallbackTarget = this;
		LatentInfo.ExecutionFunction = "CallbackOnLevelLoaded";
		UGameplayStatics::LoadStreamLevel(this, LevelName, false, false, LatentInfo);
	}
	else if (CurrentLevel == nullptr)
	{
		UE_LOG(LogTemp, Error, TEXT("ERROR: Could not load level %s, level not found!"), *LevelName.ToString());
	}
}

void ACorridorActor::CallbackOnLevelLoaded()
{
	auto CurrentLevel = UGameplayStatics::GetStreamingLevel(GetWorld(), LoadedLevelName);

	if (CurrentLevel)
	{
#if WITH_EDITOR
		FLevelUtils::SetEditorTransform(CurrentLevel, LoadedLevelTransform);
#endif
		CurrentLevel->LevelTransform = LoadedLevelTransform;
		CurrentLevel->SetShouldBeVisible(true);

		OnLevelLoaded.Broadcast();
	}
}

void ACorridorActor::UnloadLevel(FName LevelName)
{
	const auto CurrentLevel = UGameplayStatics::GetStreamingLevel(GetWorld(), LevelName);

	if (CurrentLevel && CurrentLevel->IsLevelLoaded())
	{
		FLatentActionInfo LatentInfo;
		LatentInfo.Linkage = 0;
		LatentInfo.UUID = 0;
		LatentInfo.CallbackTarget = this;
		LatentInfo.ExecutionFunction = "CallbackOnLevelUnloaded";
		UGameplayStatics::UnloadStreamLevel(this, LevelName, LatentInfo, false);
	}
}

void ACorridorActor::CallbackOnLevelUnloaded()
{
#if WITH_EDITOR
	auto CurrentLevel = UGameplayStatics::GetStreamingLevel(GetWorld(), LoadedLevelName);

	if (CurrentLevel && !CurrentLevel->IsLevelLoaded())
	{
		// To avoid warnings in the editor, should be moved to Identity at this point. 
		FLevelUtils::SetEditorTransform(CurrentLevel, FTransform());
	}
#endif
	
	OnLevelUnloaded.Broadcast();
}

Tested inside and outside the editor.

Hope this helps someone.

1 Like
10

Just use Load Level Instance by Name. It takes a Location parameter (and rotation) and you can load the same level more than once. It works in PIE and standalone/packaged.

11

This works great!! It’s really nice to be able to set the level transform without having to run in standalone mode.

12

Taking it a step further I created a couple of AsyncActions of these so they can be global BP Nodes. Hope this helps!

This works in PIE and Standalone Game run from Editor.

image
image898Ă—299 32 KB

LoadStreamLevelAsyncAction.h

#pragma once

#include "Kismet/BlueprintAsyncActionBase.h"
#include "LoadStreamLevelAsyncAction.generated.h"

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnLoadStreamLevel_OutputPin, ULevelStreaming*, level);

UCLASS()
class YOURGAME_API ULoadStreamLevelAsyncAction : public UBlueprintAsyncActionBase
{
    GENERATED_BODY()

    UPROPERTY()
    ULevelStreaming* Level;
    
    UPROPERTY()
    FTransform Transform;
    
public:
    virtual void Activate() override;

    UPROPERTY(BlueprintAssignable)
    FOnLoadStreamLevel_OutputPin OnCompleted;

private:

    UFUNCTION()
    void LatentActionCallback();

public:
    UFUNCTION(BlueprintCallable, meta = (BlueprintInternalUseOnly = "true", WorldContext = "worldContextObject", AllowedClasses = "World", DisplayName = "Load Stream Level"), Category = "Trifecta|Level|Stream")
    static ULoadStreamLevelAsyncAction* LoadStreamLevel(UObject* worldContextObject, const TSoftObjectPtr<UWorld>& _level, const FTransform& _transform);
};

LoadStreamLevelAsyncAction.cpp

#include "Level/LoadStreamLevelAsyncAction.h"
#include "LevelUtils.h"
#include "Engine/LevelStreaming.h"
#include "Engine/World.h"
#include "Kismet/GameplayStatics.h"
#include "Misc/PackageName.h"

void ULoadStreamLevelAsyncAction::Activate()
{
    if (Level && !Level->IsLevelLoaded())
    {
        FLatentActionInfo latentActionInfo;
        latentActionInfo.CallbackTarget = this;
        latentActionInfo.ExecutionFunction = FName("LatentActionCallback");
        latentActionInfo.UUID = 0;
        latentActionInfo.Linkage = 0;
        
        UGameplayStatics::LoadStreamLevel(this, Level->PackageNameToLoad, false, false, latentActionInfo);
    }
    else if (Level == nullptr)
    {
        UE_LOG(LogTemp, Error, TEXT("ERROR: Could not load level %s, level not found!"), *Level->PackageNameToLoad.ToString());
    }    
}

void ULoadStreamLevelAsyncAction::LatentActionCallback()
{
    if (Level)
    {
#if WITH_EDITOR
        if (GIsEditor) // Also don't run when Standalone Game from the editor  
            FLevelUtils::SetEditorTransform(Level, Transform);
#endif

        Level->LevelTransform = Transform;
        Level->SetShouldBeVisible(true);

        OnCompleted.Broadcast(Level);
    }    
}

ULoadStreamLevelAsyncAction* ULoadStreamLevelAsyncAction::LoadStreamLevel(UObject* worldContextObject, const TSoftObjectPtr<UWorld>& level, const FTransform& transform)
{
    ULoadStreamLevelAsyncAction* asyncAction = NewObject<ULoadStreamLevelAsyncAction>(worldContextObject);
    
    asyncAction->Level = UGameplayStatics::GetStreamingLevel(worldContextObject->GetWorld(), FName(*FPackageName::ObjectPathToPackageName(level.ToString())));
    asyncAction->Transform = transform;

    return asyncAction;
}

UnloadStreamLevelAsyncAction.h

#pragma once

#include "Kismet/BlueprintAsyncActionBase.h"
#include "UnloadStreamLevelAsyncAction.generated.h"

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnUnloadStreamLevel_OutputPin, ULevelStreaming*, level);

UCLASS()
class YOURGAME_API UUnloadStreamLevelAsyncAction : public UBlueprintAsyncActionBase
{
    GENERATED_BODY()

    UPROPERTY()
    ULevelStreaming* Level;
    
public:
    virtual void Activate() override;

    UPROPERTY(BlueprintAssignable)
    FOnUnloadStreamLevel_OutputPin OnCompleted;

private:

    UFUNCTION()
    void LatentActionCallback();

public:
    UFUNCTION(BlueprintCallable, meta = (BlueprintInternalUseOnly = "true", WorldContext = "worldContextObject", AllowedClasses = "World", DisplayName = "Unload Stream Level"), Category = "Trifecta|Level|Stream")
    static UUnloadStreamLevelAsyncAction* UnloadStreamLevel(UObject* worldContextObject, const TSoftObjectPtr<UWorld>& _level);
};

UnloadStreamLevelAsyncAction.cpp

#include "Level/UnloadStreamLevelAsyncAction.h"
#include "LevelUtils.h"
#include "Engine/LevelStreaming.h"
#include "Engine/World.h"
#include "Kismet/GameplayStatics.h"
#include "Misc/PackageName.h"

void UUnloadStreamLevelAsyncAction::Activate()
{
    if (Level && !Level->IsLevelLoaded())
    {
        FLatentActionInfo latentActionInfo;
        latentActionInfo.CallbackTarget = this;
        latentActionInfo.ExecutionFunction = FName("LatentActionCallback");
        latentActionInfo.UUID = 0;
        latentActionInfo.Linkage = 0;
        
        UGameplayStatics::UnloadStreamLevel(this, Level->PackageNameToLoad, latentActionInfo, false);
    }
    else if (Level == nullptr)
    {
        UE_LOG(LogTemp, Error, TEXT("ERROR: Could not load level %s, level not found!"), *Level->PackageNameToLoad.ToString());
    }    
}

void UUnloadStreamLevelAsyncAction::LatentActionCallback()
{
#if WITH_EDITOR
    if (Level && !Level->IsLevelLoaded())
    {
        // To avoid warnings in the editor, should be moved to Identity at this point. 
        FLevelUtils::SetEditorTransform(Level, FTransform());
    }
#endif

    OnCompleted.Broadcast(Level);
}

UUnloadStreamLevelAsyncAction* UUnloadStreamLevelAsyncAction::UnloadStreamLevel(UObject* worldContextObject, const TSoftObjectPtr<UWorld>& level)
{
    UUnloadStreamLevelAsyncAction* asyncAction = NewObject<UUnloadStreamLevelAsyncAction>(worldContextObject);
    
    asyncAction->Level = UGameplayStatics::GetStreamingLevel(worldContextObject->GetWorld(), FName(*FPackageName::ObjectPathToPackageName(level.ToString())));

    return asyncAction;
}