ULevelStreamingSubsystem 클래스 참조

#include <LevelStreamingSubsystem.h>

ULevelStreamingSubsystem에 대한 상속 다이어그램 :

ULevelStreamingSubsystem에 대한 협력 다이어그램:

Public 멤버 함수
	ULevelStreamingSubsystem ()
virtual void	Initialize (FSubsystemCollectionBase &Collection) override
void	RequestLevelLoad (ULevelStreamingData *ReqLevelLoadPipelineData)
FORCEINLINE bool	IsAvailable () const

Public 속성
bool	bDebugMode = true
int32	StreamingWindowSize = 3
FOnLevelLoadCompleted	OnLevelLoadCompleted
FOnLevelLoadedInMemory	OnLevelLoadedInMemory
FOnPlacePlayerTheWorld	OnPlacePlayerTheWorld

Protected 멤버 함수
virtual void	Tick (float DeltaTime) override
virtual bool	IsTickable () const override
FString	HandleLevelLoading (ULevelStreamingData *ReqLevelLoadPipelineData, ULevelStreaming *TargetLevel)
bool	InvalidateLevelLoadRequest (const ULevelStreamingData *ReqLevelLoadPipelineData, ULevelStreaming *&PreviousLevelStreaming) const
virtual TStatId	GetStatId () const override

Private 멤버 함수
void	FinalizeLevelLoadProcess (ELevelStreamingPhase Phase)
void	StartChain (ELevelStreamingPhase Phase)
void	OnLevelLoaded ()
void	OnLevelShown ()
void	StartDuringLoadPhase ()
void	EvaluateDuringLoadCompletion ()
void	NotifyLevelLoaded (ULevelRuleData *Rule) const

Private 속성
TArray< TObjectPtr< ULevelStreamingEffect > >	AllRegisteredEffects
TObjectPtr< ULevelStreamingData >	LevelStreamingData
TWeakObjectPtr< ULevelStreaming >	LevelToLoad
TWeakObjectPtr< ULevelStreaming >	LevelToUnload
TObjectPtr< UDataBundleRegistry >	BundleRegistry
FLevelStreamingDeque	LevelStreamingDeque
FEffectChainExecutor	ChainExecutor
bool	bIsLevelLoadRequested = false
bool	bAsyncLoading = false
bool	bLevelLoadDone = false
bool	bDuringLoadChainDone = false
bool	bFakeLoadingDone = false
FTSTicker::FDelegateHandle	FakeLoadingTickerHandle

생성자 & 소멸자 문서화

ULevelStreamingSubsystem()

ULevelStreamingSubsystem::ULevelStreamingSubsystem

(

)

{ }

멤버 함수 문서화

EvaluateDuringLoadCompletion()

void ULevelStreamingSubsystem::EvaluateDuringLoadCompletion ( )

private

{
    if (bDuringLoadChainDone == false || bFakeLoadingDone == false || bLevelLoadDone == false)
    {
        return;
    }
 
    if (LevelToUnload.Get() != nullptr)
    {
        LevelToUnload.Get()->SetShouldBeVisible(false);
        LevelToUnload.Get()->SetShouldBeLoaded(true);
    }
 
    if (LevelToLoad.IsValid() == false)
    {
        return;
    }
 
    ULevelStreaming* LevelToEvict = nullptr;
 
    if (LevelStreamingDeque.Contains(LevelToLoad.Get()))
    {
        // 직전에 방문했던 레벨 → Deque에서 꺼내 재사용 (언로드 없음)
        LevelStreamingDeque.TryExtract(LevelToLoad.Get(), LevelToEvict);
    }
    else if (LevelStreamingDeque.Size() >= StreamingWindowSize)
    {
        // 새 레벨이고 윈도우 초과 → 가장 오래된 레벨 제거 후 언로드
        if (LevelStreamingDeque.TryPopFront(LevelToEvict))
        {
            //꺼두면 GC가 알아서 언로드된 레벨을 회수한다 함.
            LevelToEvict->SetShouldBeLoaded(false);
        }
    }
 
    //아오 이 그지 같은거 Visible 상태가 False에서 True로 바뀔때만 델리게이트 호출해주네 씨바.
    LevelToLoad->OnLevelShown.AddDynamic(this, &ULevelStreamingSubsystem::OnLevelShown);
    LevelToLoad->SetShouldBeVisible(true);
    LevelToLoad->SetShouldBeLoaded(true);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

FinalizeLevelLoadProcess()

void ULevelStreamingSubsystem::FinalizeLevelLoadProcess ( ELevelStreamingPhase  Phase )

private

{
    switch (Phase)
    {
        case ELevelStreamingPhase::PreLoad:
        {
            StartDuringLoadPhase();
            break;
        }
 
        case ELevelStreamingPhase::DuringLoad: //Tick 함수에서 호출될때 걸림.
        {
            bDuringLoadChainDone = true;
            EvaluateDuringLoadCompletion();
 
            ULevelPlayerPlacer* PlayerPlacer = LevelStreamingData->CreatePlayerPlacer(this);
 
            GetWorld()->GetTimerManager().SetTimerForNextTick([this, PlayerPlacer]
            {
                if (LevelToLoad.IsValid() == false)
                {
                    return;
                }
 
                OnPlacePlayerTheWorld.Broadcast(PlayerPlacer, LevelToLoad->GetWorld());
            });
 
            if (PlayerPlacer)
            {
                PlayerPlacer->PlacePlayer(LevelToLoad->GetWorld());
            }
 
            ULevelRuleData* NewRule = LevelStreamingData->LevelRule.Get();
 
            if (BundleRegistry == nullptr)
            {
                NotifyLevelLoaded(NewRule);
                return;
            }
 
            const TArray<FGameplayTag>& BundleTags = LevelStreamingData->UsingBundlesTag;
 
            BundleRegistry->ReleaseUnusedBundles(BundleTags);
 
            if (BundleTags.IsEmpty())
            {
                NotifyLevelLoaded(NewRule);
                return;
            }
 
            BundleRegistry->RequestLoad(BundleTags, [this, NewRule]()
            {
                NotifyLevelLoaded(NewRule);
            });
 
            break;
        }
 
        case ELevelStreamingPhase::PostLoad:
        {
            bIsLevelLoadRequested = false;
            bDuringLoadChainDone = false;
            bFakeLoadingDone = false;
            bLevelLoadDone = false;
            bAsyncLoading = false;
 
            // LevelToUnload가 Deque에 없으면 먼저 삽입 (최초 전환 시 초기 레벨이 추적되지 않는 문제 방지)
            if (LevelToUnload.IsValid() && LevelStreamingDeque.Contains(LevelToUnload.Get()) == false)
            {
                LevelStreamingDeque.PushBack(LevelToUnload.Get());
            }
 
            LevelStreamingDeque.PushBack(LevelToLoad.Get());
            OnLevelLoadCompleted.Broadcast();
 
            LevelToUnload.Reset();
 
            if (bDebugMode)
            {
                LOG_INFO(LogCKLevel, "====================================================================");
            }
 
            break;
        }
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

GetStatId()

virtual TStatId ULevelStreamingSubsystem::GetStatId ( ) const

inlineoverrideprotectedvirtual

    {
        RETURN_QUICK_DECLARE_CYCLE_STAT(ULevelStreamingSubsystem, STATGROUP_Tickables);
    }

HandleLevelLoading()

FString ULevelStreamingSubsystem::HandleLevelLoading ( ULevelStreamingData *  ReqLevelLoadPipelineData, ULevelStreaming *  TargetLevel  )

protected

{
    FString TargetLevelName;
 
    if (TargetLevel && TargetLevel->IsLevelLoaded()) // 이미 로딩된 레벨 재사용.
    {
        TargetLevelName = *TargetLevel->GetWorldAsset().GetAssetName();
        TargetLevel->SetShouldBeVisible(false);
        LevelToLoad = TargetLevel;
        bLevelLoadDone = true;
        LOG_INFO(LogCKLevel, "[HandleLevelLoading] Reuse already loaded: '%s'", *TargetLevelName);
    }
    else if (TargetLevel) //Persistent Level에 등록은 되어있지만 아직 미로드.
    {
        TargetLevelName = *TargetLevel->GetWorldAsset().GetAssetName();
        bAsyncLoading = true;
 
        LevelToLoad = TargetLevel;
        LevelToLoad->SetShouldBeLoaded(true);
        LevelToLoad->SetShouldBeVisible(false);
        LevelToLoad->OnLevelLoaded.AddDynamic(this, &ULevelStreamingSubsystem::OnLevelLoaded);
        LOG_INFO(LogCKLevel, "[HandleLevelLoading] Async load registered level: '%s'", *TargetLevelName);
    }
    else // 등록되지 않은 레벨 → 동적 로딩.
    {
        TargetLevelName = ReqLevelLoadPipelineData->TargetLevel.PrimaryAssetName.ToString();
 
        bool bOutSuccess = false;
        bAsyncLoading = true;
 
        auto StreamingLevel = ULevelStreamingDynamic::LoadLevelInstance(this, TargetLevelName, FVector(), FRotator(), bOutSuccess);
        ensureMsgf(bOutSuccess && StreamingLevel, TEXT("Failed to dynamically load level '%s'"), *TargetLevelName);
 
        LevelToLoad = StreamingLevel;
        LevelToLoad->SetShouldBeVisible(false);
        LevelToLoad->OnLevelLoaded.AddDynamic(this, &ULevelStreamingSubsystem::OnLevelLoaded);
        LOG_INFO(LogCKLevel, "[HandleLevelLoading] Dynamic load: '%s', success=%s", *TargetLevelName, bOutSuccess ? TEXT("true") : TEXT("false"));
    }
 
    return TargetLevelName;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

Initialize()

void ULevelStreamingSubsystem::Initialize ( FSubsystemCollectionBase &  Collection )

overridevirtual

{
    Super::Initialize(Collection);
    BundleRegistry = GetGameInstance()->GetSubsystem<UDataBundleRegistry>();
}

InvalidateLevelLoadRequest()

bool ULevelStreamingSubsystem::InvalidateLevelLoadRequest ( const ULevelStreamingData *  ReqLevelLoadPipelineData, ULevelStreaming *&  PreviousLevelStreaming  ) const

protected

{
    if (ReqLevelLoadPipelineData == nullptr)
    {
        LOG_ERROR(LogCKLevel, "%s is null", NAMEOF(ULevelStreamingData));
        return true;
    }
 
    if (bIsLevelLoadRequested)
    {
        LOG_ERROR(LogCKLevel, "이미 로딩 중입니다.");
        return true;
    }
 
    if (StreamingWindowSize <= 0)
    {
        LOG_ERROR(LogCKLevel, "StreamingWindowSize 값이 잘못되었습니다. ");
        return true;
    }
 
    PreviousLevelStreaming = FLevelStreamingLocator::FindVisible(GetWorld());
 
    if (PreviousLevelStreaming == nullptr)
    {
        LOG_ERROR(LogCKLevel, "스트리밍할 레벨을 찾을 수 없습니다.");
        return true;
    }
 
    return false;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

IsAvailable()

FORCEINLINE bool ULevelStreamingSubsystem::IsAvailable ( ) const

inline

    {
        const UWorld* World = GetGameInstance()->GetWorld();
        return World && World->GetStreamingLevels().Num() > 0;
    }

이 함수를 호출하는 함수들에 대한 그래프입니다.:

IsTickable()

bool ULevelStreamingSubsystem::IsTickable ( ) const

overrideprotectedvirtual

{
    return ChainExecutor.IsActive() && FTickableGameObject::IsTickable();
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

NotifyLevelLoaded()

void ULevelStreamingSubsystem::NotifyLevelLoaded ( ULevelRuleData *  Rule ) const

private

{
    if (Rule == nullptr)
    {
        LOG_WARNING(LogCKLevel, "레벨 룰이 없습니다. ");
    }
    
    FTimerManager& Manager = GetWorld()->GetTimerManager();
 
    Manager.SetTimerForNextTick([this, Rule]()
    {
        this->OnLevelLoadedInMemory.Broadcast(Rule);
    });
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

OnLevelLoaded()

void ULevelStreamingSubsystem::OnLevelLoaded ( )

private

{
    if (LevelToLoad.IsValid())
    {
        LOG_INFO(LogCKLevel, "'%s' is loaded.", *LevelToLoad->GetWorldAsset().GetAssetName());
        LevelToLoad->OnLevelLoaded.RemoveDynamic(this, &ULevelStreamingSubsystem::OnLevelLoaded); //다시 실행하면 에러나니까 여기서 해제함.
    }
 
    bLevelLoadDone = true;
    EvaluateDuringLoadCompletion();
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

OnLevelShown()

void ULevelStreamingSubsystem::OnLevelShown ( )

private

{
    if (LevelToLoad.IsValid())
    {
        LOG_INFO(LogCKLevel, "'%s' is shown.", *LevelToLoad->GetWorldAsset().GetAssetName());
        LevelToLoad->OnLevelShown.RemoveDynamic(this, &ULevelStreamingSubsystem::OnLevelShown);
    }
 
    StartChain(ELevelStreamingPhase::PostLoad);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

RequestLevelLoad()

void ULevelStreamingSubsystem::RequestLevelLoad

(

ULevelStreamingData *

ReqLevelLoadPipelineData

)

{
    ULevelStreaming* PreviousLevelStreaming;
 
    if (InvalidateLevelLoadRequest(ReqLevelLoadPipelineData, PreviousLevelStreaming))
    {
        return;
    }
 
    bIsLevelLoadRequested = true;
    LevelStreamingData = ReqLevelLoadPipelineData;
 
    const FString LevelToUnloadName = PreviousLevelStreaming->GetWorldAsset().GetAssetName();
 
    if (LevelToLoad.IsValid() && LevelToLoad.Get()->GetWorld() != nullptr)
    {
        LevelToUnload = LevelToLoad;
    }
    else
    {
        LevelToUnload = FLevelStreamingLocator::FindByName(GetWorld(), *LevelToUnloadName);
    }
 
    if (LevelToUnload == nullptr)
    {
        LOG_ERROR(LogCKLevel, "스트리밍할 레벨을 찾을 수 없습니다.");
        bIsLevelLoadRequested = false;
        LevelStreamingData = nullptr;
        return;
    }
 
    TArray<ULevelStreamingEffect*> CreatedEffects = ReqLevelLoadPipelineData->CreateEffects(this);
 
    AllRegisteredEffects.Reset();
 
    for (ULevelStreamingEffect* Effect : CreatedEffects)
    {
        AllRegisteredEffects.Add(Effect);
    }
 
    ChainExecutor.SetupEffects(CreatedEffects);
 
    ULevelStreaming* TargetLevel = FLevelStreamingLocator::FindByName(GetWorld(), ReqLevelLoadPipelineData->TargetLevel.PrimaryAssetName);
    LOG_INFO(LogCKLevel, "[RequestLevelLoad] TargetAssetName='%s', FindByName=%s", *ReqLevelLoadPipelineData->TargetLevel.PrimaryAssetName.ToString(), TargetLevel ? TEXT("Found") : TEXT("NotFound"));
 
    FString TargetLevelName = HandleLevelLoading(ReqLevelLoadPipelineData, TargetLevel);
 
    if (bDebugMode)
    {
        LOG_INFO(LogCKLevel, "'%s' --> '%s'", *LevelToUnloadName, *TargetLevelName);
    }
 
    StartChain(ELevelStreamingPhase::PreLoad);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

StartChain()

void ULevelStreamingSubsystem::StartChain ( ELevelStreamingPhase  Phase )

private

{
    auto ContextFactory = [this]()
    {
        return FLevelStreamingContext::CreateContext(LevelToUnload, LevelToLoad, ChainExecutor);
    };
 
    auto OnCompleted = [this](const ELevelStreamingPhase CompletedPhase)
    {
        FinalizeLevelLoadProcess(CompletedPhase);
    };
 
    ChainExecutor.Start(Phase, MoveTemp(ContextFactory), MoveTemp(OnCompleted), bDebugMode);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

StartDuringLoadPhase()

void ULevelStreamingSubsystem::StartDuringLoadPhase ( )

private

{
    StartChain(ELevelStreamingPhase::DuringLoad);
 
    const auto Callback = FTickerDelegate::CreateLambda([this](float)
    {
        bFakeLoadingDone = true;
        EvaluateDuringLoadCompletion();
        return false; //연속적으로 호출할 것인지 여부라, False를 반환하면 한 번만 호출함.
    });
 
    if (LevelStreamingData->FakeLoadingTime < KINDA_SMALL_NUMBER)
    {
        Callback.Execute(0.0f);
    }
    else
    {
        FakeLoadingTickerHandle = FTSTicker::GetCoreTicker().AddTicker(Callback, LevelStreamingData->FakeLoadingTime);
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

Tick()

void ULevelStreamingSubsystem::Tick ( float  DeltaTime )

overrideprotectedvirtual

{
    ChainExecutor.Tick(DeltaTime);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

멤버 데이터 문서화

AllRegisteredEffects

TArray<TObjectPtr<ULevelStreamingEffect> > ULevelStreamingSubsystem::AllRegisteredEffects

private

bAsyncLoading

bool ULevelStreamingSubsystem::bAsyncLoading = false

private

bDebugMode

bool ULevelStreamingSubsystem::bDebugMode = true

bDuringLoadChainDone

bool ULevelStreamingSubsystem::bDuringLoadChainDone = false

private

bFakeLoadingDone

bool ULevelStreamingSubsystem::bFakeLoadingDone = false

private

bIsLevelLoadRequested

bool ULevelStreamingSubsystem::bIsLevelLoadRequested = false

private

bLevelLoadDone

bool ULevelStreamingSubsystem::bLevelLoadDone = false

private

BundleRegistry

TObjectPtr<UDataBundleRegistry> ULevelStreamingSubsystem::BundleRegistry

private

ChainExecutor

FEffectChainExecutor ULevelStreamingSubsystem::ChainExecutor

private

FakeLoadingTickerHandle

FTSTicker::FDelegateHandle ULevelStreamingSubsystem::FakeLoadingTickerHandle

private

LevelStreamingData

TObjectPtr<ULevelStreamingData> ULevelStreamingSubsystem::LevelStreamingData

private

LevelStreamingDeque

FLevelStreamingDeque ULevelStreamingSubsystem::LevelStreamingDeque

private

LevelToLoad

TWeakObjectPtr<ULevelStreaming> ULevelStreamingSubsystem::LevelToLoad

private

LevelToUnload

TWeakObjectPtr<ULevelStreaming> ULevelStreamingSubsystem::LevelToUnload

private

OnLevelLoadCompleted

FOnLevelLoadCompleted ULevelStreamingSubsystem::OnLevelLoadCompleted

OnLevelLoadedInMemory

FOnLevelLoadedInMemory ULevelStreamingSubsystem::OnLevelLoadedInMemory

OnPlacePlayerTheWorld

FOnPlacePlayerTheWorld ULevelStreamingSubsystem::OnPlacePlayerTheWorld

StreamingWindowSize

int32 ULevelStreamingSubsystem::StreamingWindowSize = 3

---

이 클래스에 대한 문서화 페이지는 다음의 파일들로부터 생성되었습니다.:

• Source/CK_UE/Subsystem/GameInstance/LevelStreamingSubsystem.h
• Source/CK_UE/Subsystem/GameInstance/LevelStreamingSubsystem.cpp