StreamingLevelManager.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "Managers/StreamingLevelManager.h"
#include "VRBaseCharacter.h"
#include "Engine/LevelStreaming.h"
#include "EventSystem/Events/Fade/FadeInEvent.h"
#include "EventSystem/Events/Fade/FadeOutEvent.h"
#include "EventSystem/Events/Story/NewStepLoadedEvent.h"
#include "EventSystem/Events/Story/NewStoryLoadedEvent.h"
#include "EventSystem/Events/StreamingLevels/StreamingLevelsActionFinishedEvent.h"
#include "Kismet/GameplayStatics.h"
 
UStreamingLevelManager::UStreamingLevelManager()
{
    //Bind events
    DEFINE_EVENT_HANDLER(UNewStepLoadedEvent);
    DEFINE_EVENT_HANDLER(UNewStoryLoadedEvent);
}
 
TArray<FName> UStreamingLevelManager::GetLevelsBasedOnStep(FText StepName)
{
    static const FString ContextString(TEXT("StreamingLevels"));
 
    if (LevelStreamingDataTable)
    {
        TArray<FName> RowNames = LevelStreamingDataTable->GetRowNames();
        if (RowNames.Num() == 0)
        {
            UE_LOG(LogTemp, Error, TEXT("LevelStreamingDataTable is empty!"))
            return TArray<FName>();
        }
 
        for (const auto RowName : RowNames)
        {
            FStreamingLevel* FoundLevels = LevelStreamingDataTable->FindRow<FStreamingLevel>(RowName, ContextString);
            if (FoundLevels->StepName.EqualTo(StepName))
            {
                TeleportPlayerToSpecificLocation = FoundLevels->TeleportPlayerToSpecificLocation;
                if (TeleportPlayerToSpecificLocation)
                {
                    PlayerNewTransform = FoundLevels->PlayerNewLocation;
                }
                return FoundLevels->ActiveLevels;
            }
        }
    }
    else
        UE_LOG(LogTemp, Error, TEXT("LevelStreamingDataTable is invalid!"));
 
    return TArray<FName>();
}
 
void UStreamingLevelManager::FilteredArraysToLoadUnload(TArray<FName> levelsToLoad)
{
    //Check levelsToLoad array
    if (levelsToLoad.Num() == 0)
    {
        return;
    }
    //Reset defaults
    LevelsToLoad.Empty();
    LevelsToUnload = LoadedLevels;
 
    for (FName level : levelsToLoad)
    {
        if (LoadedLevels.Contains(level))
        {
            LevelsToUnload.Remove(level);
        }
        else
        {
            LevelsToLoad.Add(level);
        }
    }
}
 
void UStreamingLevelManager::LoadStreamingLevels(TArray<FName> levelsToLoad, bool onlyFadeOut, float FadeTime)
{
    if (levelsToLoad.Num() != 0)
    {
        TimeForFades = FadeTime;
        
        FilteredArraysToLoadUnload(levelsToLoad);
        if (LevelsToUnload.Num() != 0)
        {
            if (AutoFadeInAndOut)
            {
                auto FadeInFinishedEvent = [this]()
                {
                    UnloadStreamingLevels(0);
                };
 
                if (!onlyFadeOut)
                {
                    EventLogService::NewEvent<UFadeInEvent>(nullptr, FadeInFinishedEvent, TimeForFades);
                }
                else
                {
                    EventLogService::NewEvent<UFadeInEvent>(nullptr, FadeInFinishedEvent, 0.0f);
                }
            }
            else
            {
                UnloadStreamingLevels(0);
            }
        }
        else if (LevelsToLoad.Num() != 0)
        {
            if (AutoFadeInAndOut)
            {
                auto FadeInFinishedEvent = [this]()
                {
                    LoadStreamingLevels(0);
                };
 
                if (!onlyFadeOut)
                {
                    EventLogService::NewEvent<UFadeInEvent>(nullptr, FadeInFinishedEvent, TimeForFades);
                }
                else
                {
                    EventLogService::NewEvent<UFadeInEvent>(nullptr, FadeInFinishedEvent, 0.0f);
                }
            }
            else
            {
                LoadStreamingLevels(0);
            }
        }
        LoadedLevels = levelsToLoad;
    }
    else
        UE_LOG(LogTemp, Log, TEXT("Levels to load array is empty!"));
}
 
void UStreamingLevelManager::LoadStreamingLevelsAndTeleportPlayer(TArray<FName> Levels, FTransform PlayerTransform, bool OnlyFadeOut, float FadeTime)
{
    TeleportPlayerToSpecificLocation = true;
    PlayerNewTransform = PlayerTransform;
 
    LoadStreamingLevels(Levels, OnlyFadeOut, FadeTime);
}
 
void UStreamingLevelManager::SetLevelsVisibility(TArray<FName> Levels, bool Visible)
{
    auto SetVisibilityEvent = [this, Visible, Levels]()
    {
        for (FName Level : Levels)
        {
            UGameplayStatics::GetStreamingLevel(GetWorld(), Level)->SetShouldBeVisible(Visible);
        }
    };
    
    if (AutoFadeInAndOut)
    {
        EventLogService::NewEvent<UFadeInEvent>(nullptr, SetVisibilityEvent, TimeForFades);
    }
    else
    {
        SetVisibilityEvent();
    }
}
 
void UStreamingLevelManager::LevelLoaded()
{
    LoadStreamingLevels(++LoadingIndex);
}
 
void UStreamingLevelManager::LevelUnloaded()
{
    UnloadStreamingLevels(++UnloadingIndex);
}
 
void UStreamingLevelManager::UnloadStreamingLevels(int32 IndexToUnload)
{
    UnloadingIndex = IndexToUnload;
    if (IndexToUnload > (LevelsToUnload.Num() - 1))
    {
        if (LevelsToLoad.Num() != 0)
        {
            LoadStreamingLevels(0);
        }
        else
        {
            EventLogService::NewEvent<UStreamingLevelsActionFinishedEvent>();
 
            if (TeleportPlayerToSpecificLocation)
            {
                AVRBaseCharacter* Character = Cast<AVRBaseCharacter>( UGameplayStatics::GetPlayerCharacter(GetWorld(), 0));
 
                if (Character)
                {
                    Character->SetActorLocationAndRotationVR(PlayerNewTransform.GetLocation(), PlayerNewTransform.Rotator());
                }
            }
 
            if (AutoFadeInAndOut)
            {
                EventLogService::NewEvent<UFadeOutEvent>(nullptr, nullptr, TimeForFades);
            }
        }
 
        return;
    }
 
    FLatentActionInfo LatentInfo;
    LatentInfo.CallbackTarget = this;
    LatentInfo.ExecutionFunction = "LevelUnloaded";
    LatentInfo.Linkage = 1;
    LatentInfo.UUID = IndexToUnload;
 
    UGameplayStatics::UnloadStreamLevel(this, LevelsToUnload[IndexToUnload], LatentInfo, false);
}
 
void UStreamingLevelManager::LoadStreamingLevels(int32 IndexToLoad)
{
    LoadingIndex = IndexToLoad;
    if (IndexToLoad > (LevelsToLoad.Num() - 1))
    {
        EventLogService::NewEvent<UStreamingLevelsActionFinishedEvent>();
 
        if (TeleportPlayerToSpecificLocation)
        {
            AVRBaseCharacter* Character = Cast<AVRBaseCharacter>(UGameplayStatics::GetPlayerCharacter(GetWorld(), 0));
 
            if (Character)
            {
                Character->SetActorLocationAndRotationVR(PlayerNewTransform.GetLocation(), PlayerNewTransform.Rotator());
            }
        }
 
        if (AutoFadeInAndOut)
        {
            EventLogService::NewEvent<UFadeOutEvent>(nullptr, nullptr, TimeForFades);
        }
 
        return;
    }
 
    FLatentActionInfo LatentInfo;
    LatentInfo.CallbackTarget = this;
    LatentInfo.ExecutionFunction = "LevelLoaded";
    LatentInfo.Linkage = 1;
    LatentInfo.UUID = IndexToLoad;
    
    UGameplayStatics::LoadStreamLevel(this, LevelsToLoad[IndexToLoad], true, true, LatentInfo);
}
 
void UStreamingLevelManager::HandleEvent_Impl(UNewStepLoadedEvent* Event)
{
    LoadStreamingLevels(GetLevelsBasedOnStep(Event->CurrentStep.StepName));
}
 
void UStreamingLevelManager::HandleEvent_Impl(UNewStoryLoadedEvent* Event)
{
    LoadStreamingLevels(GetLevelsBasedOnStep(Event->CurrentStep.StepName), true);
}