ULevelStreamingSubsystem 클래스 참조

#include <LevelStreamingSubsystem.h>

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

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

클래스
struct	FInitialStageBootstrapper
struct	FLevelStreamingUtility

Public 멤버 함수
virtual void	Initialize (FSubsystemCollectionBase &Collection) override
virtual void	Deinitialize () override
virtual void	Tick (float DeltaTime) override
virtual bool	IsTickable () const override
void	PlacePlayerInLevel ()
AUStageFlowDefinition *	GetCurrentFlowDefinition () const
void	RequestLevelLoad (ULevelStreamingData *ReqLevelLoadPipelineData)
void	OnLevelLoaded ()
void	OnLevelShown ()
void	OnLevelHidden ()
FORCEINLINE bool	IsLaunchedFromPersistentLevel () const
FORCEINLINE const UStageDictionary *	GetStageDictionary () const
virtual FORCEINLINE TStatId	GetStatId () const override
FORCEINLINE bool	IsLevelLoadRequested () const
FORCEINLINE bool	IsInitialStageInitialized () const

Public 속성
FOnLevelLoadCompleted	OnLevelLoadCompleted
FOnLevelLoadedInMemory	OnLevelLoadedInMemory
FOnPlacePlayerTheWorld	OnPlacePlayerTheWorld

Private 멤버 함수
AUStageFlowDefinition *	GetPreviousFlowDefinition () const
bool	InvalidateLevelLoadRequest (const ULevelStreamingData *ReqLevelLoadPipelineData, ULevelStreaming *&PreviousLevelStreaming) const
void	HandleLevelLoading (const ULevelStreamingData *ReqLevelStreamingData, ULevelStreaming *TargetLevel)
bool	CacheStreamingDataFromStageDictionary ()
void	EnterPreLoadingState ()
void	EnterDuringLoadState ()
void	EnterAwaitShownState ()
void	EnterIdleState ()
bool	HandleAsyncLoadCompleted ()
void	HandleDuringLoadChainCompleted ()
void	HandleLevelShown ()
void	HandleLevelHidden ()
void	StartChain (ELevelStreamingPhase Phase)
void	NotifyLevelLoaded (ULevelStreamingData *StreamingData) const
void	PreloadNiagaraEffectsAsync (TWeakObjectPtr< ULevelStreamingData > RequestedStreamingData)
void	ReleaseNiagaraEffectsPreload ()
void	ForEachSendStreamingEvent (const ULevel *LoadedLevel, const TFunctionRef< void(IStreamingEventListenerInterface &)> &Callback) const

Private 속성
TObjectPtr< UStageDictionary >	CachedStageDictionary
TArray< TObjectPtr< ULevelStreamingEffect > >	AllRegisteredEffects
TObjectPtr< ULevelStreamingData >	LevelStreamingData
TObjectPtr< ULevelPlayerPlacer >	ActivePlayerPlacer
TWeakObjectPtr< ULevelStreaming >	LevelToLoad
TWeakObjectPtr< ULevelStreaming >	LevelToUnload
TObjectPtr< UDataBundleRegistry >	BundleRegistry
FEffectChainExecutor	ChainExecutor
FInitialStageBootstrapper	InitialStageBootstrap
FLevelStreamingStateMachine	StreamingStateMachine
TSharedPtr< FStreamableHandle >	NiagaraPreloadHandle

Friends
struct	FLevelStreamingStateMachine

멤버 함수 문서화

CacheStreamingDataFromStageDictionary()

bool ULevelStreamingSubsystem::CacheStreamingDataFromStageDictionary ( )

private

{
    CachedStageDictionary = GetEnvironmentAssetByKey<UStageDictionary>("StageDictionary");
 
    if (CachedStageDictionary == nullptr)
    {
        LOG_ERROR(LogCKLevel, "Failed to load StageDictionary from key '%s'.", TEXT("StageDictionary"));
        return false;
    }
 
    return true;
}

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

Deinitialize()

void ULevelStreamingSubsystem::Deinitialize ( )

overridevirtual

{
    if (LevelToLoad.IsValid())
    {
        LevelToLoad->OnLevelLoaded.RemoveDynamic(this, &ULevelStreamingSubsystem::OnLevelLoaded);
        LevelToLoad->OnLevelShown.RemoveDynamic(this, &ULevelStreamingSubsystem::OnLevelShown);
    }
 
    if (LevelToUnload.IsValid())
    {
        LevelToUnload->OnLevelLoaded.RemoveDynamic(this, &ULevelStreamingSubsystem::OnLevelLoaded);
        LevelToUnload->OnLevelShown.RemoveDynamic(this, &ULevelStreamingSubsystem::OnLevelShown);
        LevelToUnload->OnLevelHidden.RemoveDynamic(this, &ULevelStreamingSubsystem::OnLevelHidden);
    }
 
    if (AUStageFlowDefinition* PrevDefinition = GetPreviousFlowDefinition())
    {
        PrevDefinition->OnLevelUnloaded();
    }
 
    if (AUStageFlowDefinition* CurrDefinition = GetCurrentFlowDefinition())
    {
        CurrDefinition->OnLevelUnloaded();
    }
 
    StreamingStateMachine.Reset();
    InitialStageBootstrap.Reset();
 
    ReleaseNiagaraEffectsPreload();
    ActivePlayerPlacer = nullptr;
    LevelStreamingData = nullptr;
    LevelToLoad.Reset();
    LevelToUnload.Reset();
    Super::Deinitialize();
}

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

EnterAwaitShownState()

void ULevelStreamingSubsystem::EnterAwaitShownState ( )

private

{
    if (LevelToUnload.IsValid())
    {
        LevelToUnload->OnLevelHidden.AddUniqueDynamic(this, &ULevelStreamingSubsystem::OnLevelHidden);
        LevelToUnload->SetShouldBeVisible(false);
        LevelToUnload->SetShouldBeLoaded(true);
    }
 
    if (LevelToLoad.IsValid() == false)
    {
        return;
    }
 
    LevelToLoad->OnLevelShown.AddUniqueDynamic(this, &ULevelStreamingSubsystem::OnLevelShown);
    LevelToLoad->SetShouldBeVisible(true);
    LevelToLoad->SetShouldBeLoaded(true);
}

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

EnterDuringLoadState()

void ULevelStreamingSubsystem::EnterDuringLoadState ( )

private

{
    ULevelStreaming* TargetLevel = FLevelStreamingUtility::FindByName(GetWorld(), LevelStreamingData->TargetMap.PrimaryAssetName);
    HandleLevelLoading(LevelStreamingData, TargetLevel);
    StartChain(ELevelStreamingPhase::DuringLoad);
}

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

EnterIdleState()

void ULevelStreamingSubsystem::EnterIdleState ( )

private

{
    if (AUStageFlowDefinition* Definition = GetCurrentFlowDefinition())
    {
        Definition->OnLevelStreamingEnded();
    }
    else
    {
        LOG_WARNING(LogCK, "%s is not initialized.", NAMEOF(AUStageFlowDefinition));
    }
 
    ForEachSendStreamingEvent(LevelToLoad.IsValid() ? LevelToLoad->GetLoadedLevel() : nullptr, [](IStreamingEventListenerInterface& Listener)
    {
        Listener.OnLevelStreamingEnded();
    });
 
    OnLevelLoadCompleted.Broadcast();
    LevelToUnload.Reset();
}

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

EnterPreLoadingState()

void ULevelStreamingSubsystem::EnterPreLoadingState ( )

private

{
    if (AUStageFlowDefinition* Definition = GetCurrentFlowDefinition())
    {
        Definition->OnLevelStreamingStarted();
    }
 
    ForEachSendStreamingEvent(LevelToUnload.IsValid() ? LevelToUnload->GetLoadedLevel() : nullptr, [](IStreamingEventListenerInterface& Listener)
    {
        Listener.OnLevelStreamingStarted();
    });
 
    TArray<ULevelStreamingEffect*> CreatedEffects = LevelStreamingData->CreateEffects(this);
 
    AllRegisteredEffects.Reset();
 
    for (ULevelStreamingEffect* Effect : CreatedEffects)
    {
        AllRegisteredEffects.Add(Effect);
    }
 
    ChainExecutor.SetupEffects(CreatedEffects);
    StartChain(ELevelStreamingPhase::PreLoad);
}

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

ForEachSendStreamingEvent()

void ULevelStreamingSubsystem::ForEachSendStreamingEvent ( const ULevel *  LoadedLevel, const TFunctionRef< void(IStreamingEventListenerInterface &)> &  Callback  ) const

private

{
    if (LoadedLevel == nullptr)
    {
        return;
    }
 
    TArray<USubsystem*> Subsystems;
    const UWorld* World = GetWorld();
 
    if (World)
    {
        Subsystems.Append(World->GetSubsystemArrayCopy<UWorldSubsystem>());
    }
 
    if (const ULocalPlayer* Player = World->GetGameInstance()->GetFirstGamePlayer())
    {
        Subsystems.Append(Player->GetSubsystemArrayCopy<ULocalPlayerSubsystem>());
    }
 
    if (Subsystems.IsEmpty())
    {
        return;
    }
 
    for (USubsystem* Subsystem : Subsystems)
    {
        if (Subsystem && Subsystem->GetClass()->ImplementsInterface(UStreamingEventListenerInterface::StaticClass()))
        {
            Callback(*(Cast<IStreamingEventListenerInterface>(Subsystem)));
        }
    }
}

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

GetCurrentFlowDefinition()

AUStageFlowDefinition * ULevelStreamingSubsystem::GetCurrentFlowDefinition

(

)

const

{
    if (LevelToLoad.IsValid() == false)
    {
        return nullptr;
    }
 
    ALevelScriptActor* LevelActor = LevelToLoad->GetLevelScriptActor();
 
    if (LevelActor == nullptr)
    {
        return nullptr;
    }
    else
    {
        return Cast<AUStageFlowDefinition>(LevelActor);
    }
}

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

GetPreviousFlowDefinition()

AUStageFlowDefinition * ULevelStreamingSubsystem::GetPreviousFlowDefinition ( ) const

private

{
    if (LevelToUnload.IsValid() == false)
    {
        return nullptr;
    }
 
    ALevelScriptActor* LevelActor = LevelToUnload->GetLevelScriptActor();
 
    if (LevelActor == nullptr)
    {
        return nullptr;
    }
    else
    {
        return Cast<AUStageFlowDefinition>(LevelActor);
    }
}

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

GetStageDictionary()

FORCEINLINE const UStageDictionary * ULevelStreamingSubsystem::GetStageDictionary ( ) const

inline

    {
        return CachedStageDictionary.Get();
    }

GetStatId()

virtual FORCEINLINE TStatId ULevelStreamingSubsystem::GetStatId ( ) const

inlineoverridevirtual

    {
        RETURN_QUICK_DECLARE_CYCLE_STAT(ULevelStreamingSubsystem, STATGROUP_Tickables);
    }

HandleAsyncLoadCompleted()

bool ULevelStreamingSubsystem::HandleAsyncLoadCompleted ( )

private

{
    if (LevelToLoad.IsValid() == false)
    {
        LOG_ERROR(LogCKLevel, "Failed to find loaded level streaming.");
        return false;
    }
 
    ULevelStreaming* StreamingLevel = LevelToLoad.Get();
    LOG_INFO(LogCKLevel, "'%s' is loaded.", *StreamingLevel->GetWorldAsset().GetAssetName());
    StreamingLevel->OnLevelLoaded.RemoveDynamic(this, &ULevelStreamingSubsystem::OnLevelLoaded);
 
    ULevel* LoadedLevel = StreamingLevel->GetLoadedLevel();
 
    if (LoadedLevel == nullptr)
    {
        LOG_ERROR(LogCKLevel, "LoadedLevel이 nullptr 입니다.");
        return false;
    }
 
    if (LevelStreamingData == nullptr)
    {
        LOG_ERROR(LogCKLevel, "%s is null.", NAMEOF(ULevelStreamingData));
        return false;
    }
 
    if (AUStageFlowDefinition* PrevDefinition = GetPreviousFlowDefinition())
    {
        PrevDefinition->OnLevelUnloaded();
    }
 
    AUStageFlowDefinition* CurrentFlowDefinition = AUStageFlowDefinition::GetStageFlowDefinition(LoadedLevel, LevelStreamingData);
 
    if (CurrentFlowDefinition)
    {
        CurrentFlowDefinition->OnLevelLoaded(LoadedLevel, LevelStreamingData);
    }
    else
    {
        LOG_ERROR(LogCK, "Failed to create %s.", NAMEOF(AUStageFlowDefinition));
    }
 
    if (LevelToUnload.IsValid())
    {
        ForEachSendStreamingEvent(LevelToUnload->GetLoadedLevel(), [](IStreamingEventListenerInterface& Listener)
        {
            Listener.OnLevelUnloaded();
        });
    }
 
    ForEachSendStreamingEvent(LoadedLevel, [this, LoadedLevel](IStreamingEventListenerInterface& Listener)
    {
        Listener.OnLevelLoaded(LoadedLevel, LevelStreamingData);
    });
 
    return true;
}

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

HandleDuringLoadChainCompleted()

void ULevelStreamingSubsystem::HandleDuringLoadChainCompleted ( )

private

{
    check(BundleRegistry);
 
    const FGameplayTagContainer& BundleTags = LevelStreamingData->UsingBundlesTag;
    TWeakObjectPtr<ULevelStreamingData> RequestedStreamingData = LevelStreamingData;
    BundleRegistry->ReleaseUnusedBundles(BundleTags);
 
    if (BundleTags.IsEmpty())
    {
        NotifyLevelLoaded(RequestedStreamingData.Get());
        StreamingStateMachine.NotifyBundleLoadCompleted();
        return;
    }
 
    BundleRegistry->RequestLoad(BundleTags, [this, RequestedStreamingData](TArray<UDataBundleDefinition*>)
    {
        NotifyLevelLoaded(RequestedStreamingData.Get());
        StreamingStateMachine.NotifyBundleLoadCompleted();
    });
}

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

HandleLevelHidden()

void ULevelStreamingSubsystem::HandleLevelHidden ( )

private

{
    if (LevelToUnload.IsValid())
    {
        LevelToUnload->OnLevelHidden.RemoveDynamic(this, &ULevelStreamingSubsystem::OnLevelHidden);
    }
 
    if (AUStageFlowDefinition* Definition = GetPreviousFlowDefinition())
    {
        Definition->OnLevelUnloaded();
    }
    else
    {
        LOG_WARNING(LogCKLevel, "Failed to get previous %s.", NAMEOF(AUStageFlowDefinition));
    }
 
    if (LevelToUnload.IsValid())
    {
        LevelToUnload->SetShouldBeLoaded(false);
    }
}

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

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

HandleLevelLoading()

void ULevelStreamingSubsystem::HandleLevelLoading ( const ULevelStreamingData *  ReqLevelStreamingData, ULevelStreaming *  TargetLevel  )

private

{
    bool bAlreadyLoaded = false;
    bool bResolved = false;
 
    if (TargetLevel == nullptr)
    {
        TargetLevel = FLevelStreamingUtility::ResolveTargetLevel(this, ReqLevelStreamingData->TargetMap.PrimaryAssetName, bAlreadyLoaded, bResolved);
    }
    else
    {
        bAlreadyLoaded = TargetLevel->IsLevelLoaded();
        bResolved = true;
    }
 
    const FString TargetLevelName = bResolved ? TargetLevel->GetWorldAsset().GetAssetName() : ReqLevelStreamingData->TargetMap.PrimaryAssetName.ToString();
    ensureMsgf(bResolved && TargetLevel, TEXT("Failed to resolve level '%s'"), *TargetLevelName);
 
    if (TargetLevel == nullptr)
    {
        return;
    }
 
    LevelToLoad = TargetLevel;
 
    if (bAlreadyLoaded)
    {
        FLevelStreamingUtility::PrepareLevelForLoad(LevelToLoad.Get(), false);
        LOG_INFO(LogCKLevel, "[HandleLevelLoading] Reuse already loaded: '%s'", *TargetLevelName);
        StreamingStateMachine.NotifyAsyncLoadCompleted();
        return;
    }
 
    FLevelStreamingUtility::PrepareLevelForLoad(LevelToLoad.Get(), true);
    LevelToLoad->OnLevelLoaded.AddUniqueDynamic(this, &ULevelStreamingSubsystem::OnLevelLoaded);
    LOG_INFO(LogCKLevel, "[HandleLevelLoading] Async load prepared: '%s'", *TargetLevelName);
}

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

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

HandleLevelShown()

void ULevelStreamingSubsystem::HandleLevelShown ( )

private

{
    if (LevelToLoad.IsValid())
    {
        LOG_INFO(LogCKLevel, "'%s' is shown.", *LevelToLoad->GetWorldAsset().GetAssetName());
        LevelToLoad->OnLevelShown.RemoveDynamic(this, &ULevelStreamingSubsystem::OnLevelShown);
    }
    else
    {
        LOG_ERROR(LogCKLevel, "Failed to find level to show.");
    }
}

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

Initialize()

void ULevelStreamingSubsystem::Initialize ( FSubsystemCollectionBase &  Collection )

overridevirtual

{
    Super::Initialize(Collection);
 
    BundleRegistry = GetGameInstance()->GetSubsystem<UDataBundleRegistry>();
    InitialStageBootstrap.Initialize(this);
    StreamingStateMachine.Initialize(this);
    CacheStreamingDataFromStageDictionary();
 
    if (BundleRegistry == nullptr)
    {
        LOG_ERROR(LogCKAsset, "%s is null.", NAMEOF(UDataBundleRegistry));
        return;
    }
 
    BundleRegistry->RequestLoad(TAG_BUNDLE_INITIAL, [this](UDataBundleDefinition*)
    {
        CacheStreamingDataFromStageDictionary();
        InitialStageBootstrap.TryInitializeCurrentStage();
    });
 
    LOG_INFO(LogCK, "%s initialized successfully.", NAMEOF(ULevelStreamingSubsystem));
}

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

InvalidateLevelLoadRequest()

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

private

{
    if (ReqLevelLoadPipelineData == nullptr)
    {
        LOG_ERROR(LogCKLevel, "%s is null", NAMEOF(ULevelStreamingData));
        return true;
    }
 
    if (StreamingStateMachine.GetState() != ELevelStreamingFlowState::Idle)
    {
        LOG_ERROR(LogCKLevel, "A level load is already in progress.");
        return true;
    }
 
    PreviousLevelStreaming = FLevelStreamingUtility::FindVisible(GetWorld());
 
    if (PreviousLevelStreaming == nullptr)
    {
        LOG_ERROR(LogCKLevel, "Failed to find currently visible streaming level.");
        return true;
    }
 
    return false;
}

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

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

IsInitialStageInitialized()

FORCEINLINE bool ULevelStreamingSubsystem::IsInitialStageInitialized ( ) const

inline

    {
        return InitialStageBootstrap.IsInitializedForCurrentWorld();
    }

IsLaunchedFromPersistentLevel()

FORCEINLINE bool ULevelStreamingSubsystem::IsLaunchedFromPersistentLevel ( ) const

inline

    {
        return GetWorld() && !GetWorld()->GetStreamingLevels().IsEmpty();
    }

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

IsLevelLoadRequested()

FORCEINLINE bool ULevelStreamingSubsystem::IsLevelLoadRequested ( ) const

inline

    {
        return StreamingStateMachine.IsBusy();
    }

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

IsTickable()

bool ULevelStreamingSubsystem::IsTickable ( ) const

overridevirtual

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

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

NotifyLevelLoaded()

void ULevelStreamingSubsystem::NotifyLevelLoaded ( ULevelStreamingData *  StreamingData ) const

private

{
    if (StreamingData == nullptr)
    {
        LOG_WARNING(LogCKLevel, "Level streaming data is null.");
        return;
    }
 
    FTimerManager& Manager = GetWorld()->GetTimerManager();
 
    Manager.SetTimerForNextTick([this, StreamingData]()
    {
        OnLevelLoadedInMemory.Broadcast(StreamingData);
    });
}

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

OnLevelHidden()

void ULevelStreamingSubsystem::OnLevelHidden

(

)

{
    HandleLevelHidden();
}

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

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

OnLevelLoaded()

void ULevelStreamingSubsystem::OnLevelLoaded

(

)

{
    StreamingStateMachine.NotifyAsyncLoadCompleted();
}

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

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

OnLevelShown()

void ULevelStreamingSubsystem::OnLevelShown

(

)

{
    StreamingStateMachine.NotifyLevelShown();
}

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

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

PlacePlayerInLevel()

void ULevelStreamingSubsystem::PlacePlayerInLevel

(

)

{
    UWorld* World = GetWorld();
 
    if (World == nullptr)
    {
        LOG_ERROR(LogCKLevel, "World is null.");
        return;
    }
 
    ULevel* LoadedLevel = LevelToLoad.IsValid() ? LevelToLoad->GetLoadedLevel() : nullptr;
    const bool bUseCurrentLevel = LoadedLevel == nullptr;
 
    if (LoadedLevel == nullptr)
    {
        LoadedLevel = World->GetCurrentLevel();
    }
 
    if (LevelStreamingData == nullptr)
    {
        LOG_ERROR(LogCKLevel, "%s is null.", NAMEOF(ULevelStreamingData));
        return;
    }
 
    if (LevelStreamingData->PlayerPlacer == nullptr)
    {
        return;
    }
 
    ActivePlayerPlacer = LevelStreamingData->CreatePlayerPlacer(this);
 
    if (ActivePlayerPlacer == nullptr)
    {
        return;
    }
 
    TWeakObjectPtr<ULevelPlayerPlacer> PlacementPlacer = ActivePlayerPlacer;
 
    auto BroadcastPlacement = [this, PlacementPlacer]
    {
        if (LevelToLoad.IsValid() == false || PlacementPlacer.IsValid() == false)
        {
            return;
        }
 
        OnPlacePlayerTheWorld.Broadcast(PlacementPlacer.Get(), LevelToLoad->GetWorld());
    };
 
    GetWorld()->GetTimerManager().SetTimerForNextTick(BroadcastPlacement);
    ActivePlayerPlacer->PlacePlayer(LoadedLevel, LevelStreamingData->TargetMap);
}

PreloadNiagaraEffectsAsync()

void ULevelStreamingSubsystem::PreloadNiagaraEffectsAsync ( TWeakObjectPtr< ULevelStreamingData >  RequestedStreamingData )

private

{
    ULevelStreamingData* StreamingData = RequestedStreamingData.Get();
 
    if (StreamingData == nullptr || StreamingData->LevelRule == nullptr)
    {
        return;
    }
 
    UNiagaraCachingFlowDefinition* NiagaraCachingFlow = StreamingData->LevelRule->GetNiagaraCachingFlowDefinition();
 
    if (NiagaraCachingFlow == nullptr)
    {
        return;
    }
 
    TArray<FSoftObjectPath> PathsToLoad;
    NiagaraCachingFlow->GetCachedSystemPaths(PathsToLoad);
 
    if (PathsToLoad.IsEmpty())
    {
        return;
    }
 
    // 에셋만 비동기 로드해두면, 로드 시점에 PSO precaching이 백그라운드에서 자동으로 셰이더/PSO를 컴파일한다.
    // 핸들을 서브시스템에 보관해 세션 동안 로드 상태를 유지(스테이지 전환 후에도 재사용)한다.
    const int32 RequestedCount = PathsToLoad.Num();
    LOG_INFO(LogCKAsset, "Niagara 프리로드 요청: %d개", RequestedCount);
 
    FStreamableManager& Manager = UAssetManager::Get().GetStreamableManager();
    NiagaraPreloadHandle = Manager.RequestAsyncLoad(PathsToLoad, FStreamableDelegate::CreateWeakLambda(this, [this, RequestedCount]()
    {
        int32 LoadedCount = 0;
 
        if (NiagaraPreloadHandle.IsValid())
        {
            TArray<UObject*> LoadedAssets;
            NiagaraPreloadHandle->GetLoadedAssets(LoadedAssets);
            LoadedCount = LoadedAssets.Num();
        }
 
        LOG_INFO(LogCKAsset, "Niagara 프리로드 완료: %d/%d개 로드됨", LoadedCount, RequestedCount);
    }));
}

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

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

ReleaseNiagaraEffectsPreload()

void ULevelStreamingSubsystem::ReleaseNiagaraEffectsPreload ( )

private

{
    if (NiagaraPreloadHandle.IsValid())
    {
        NiagaraPreloadHandle->ReleaseHandle();
        NiagaraPreloadHandle.Reset();
    }
}

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

RequestLevelLoad()

void ULevelStreamingSubsystem::RequestLevelLoad

(

ULevelStreamingData *

ReqLevelLoadPipelineData

)

{
    ULevelStreaming* PreviousLevelStreaming = nullptr;
 
    if (InvalidateLevelLoadRequest(ReqLevelLoadPipelineData, PreviousLevelStreaming))
    {
        return;
    }
 
    LevelStreamingData = ReqLevelLoadPipelineData;
    LevelToUnload = PreviousLevelStreaming;
    StreamingStateMachine.BeginLoad();
}

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

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

StartChain()

void ULevelStreamingSubsystem::StartChain ( ELevelStreamingPhase  Phase )

private

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

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

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

Tick()

void ULevelStreamingSubsystem::Tick ( float  DeltaTime )

overridevirtual

{
    ChainExecutor.Tick(DeltaTime);
}

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

Friend, 그리고 관련된 함수 문서화

FLevelStreamingStateMachine

friend struct FLevelStreamingStateMachine

friend

멤버 데이터 문서화

ActivePlayerPlacer

TObjectPtr<ULevelPlayerPlacer> ULevelStreamingSubsystem::ActivePlayerPlacer

private

AllRegisteredEffects

TArray<TObjectPtr<ULevelStreamingEffect> > ULevelStreamingSubsystem::AllRegisteredEffects

private

BundleRegistry

TObjectPtr<UDataBundleRegistry> ULevelStreamingSubsystem::BundleRegistry

private

CachedStageDictionary

TObjectPtr<UStageDictionary> ULevelStreamingSubsystem::CachedStageDictionary

private

ChainExecutor

FEffectChainExecutor ULevelStreamingSubsystem::ChainExecutor

private

InitialStageBootstrap

FInitialStageBootstrapper ULevelStreamingSubsystem::InitialStageBootstrap

private

LevelStreamingData

TObjectPtr<ULevelStreamingData> ULevelStreamingSubsystem::LevelStreamingData

private

LevelToLoad

TWeakObjectPtr<ULevelStreaming> ULevelStreamingSubsystem::LevelToLoad

private

LevelToUnload

TWeakObjectPtr<ULevelStreaming> ULevelStreamingSubsystem::LevelToUnload

private

NiagaraPreloadHandle

TSharedPtr<FStreamableHandle> ULevelStreamingSubsystem::NiagaraPreloadHandle

private

OnLevelLoadCompleted

FOnLevelLoadCompleted ULevelStreamingSubsystem::OnLevelLoadCompleted

OnLevelLoadedInMemory

FOnLevelLoadedInMemory ULevelStreamingSubsystem::OnLevelLoadedInMemory

OnPlacePlayerTheWorld

FOnPlacePlayerTheWorld ULevelStreamingSubsystem::OnPlacePlayerTheWorld

StreamingStateMachine

FLevelStreamingStateMachine ULevelStreamingSubsystem::StreamingStateMachine

private

---

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

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