LevelStreamingSubsystem.h

이 파일의 문서화 페이지로 가기

// Fill out your copyright notice in the Description page of Project Settings.
 
#pragma once
 
#include "Containers/Ticker.h"
#include "CoreMinimal.h"
#include "Data/Bundle/DataBundleRegistry.h"
#include "Data/Level/LevelStreamingData.h"
#include "Level/ELevelStreamingEnums.h"
#include "Level/Effect/LevelStreamingEffect.h"
#include "Level/LevelStreamingStateMachine.h"
#include "Level/Stage/StageFlowDefinition.h"
#include "LevelStreamingSubsystem.generated.h"
 
class AUStageFlowDefinition;
class IStreamingEventListenerInterface;
class ULevelPlayerPlacer;
class ULevelStreaming;
class ULevelStreamingData;
class ULevelStreamingEffect;
class UStageDictionary;
class UWorld;
 
struct FLevelStreamingContext;
struct FLevelStreamingStateMachine;
struct FStreamableHandle;
 
DECLARE_MULTICAST_DELEGATE(FOnLevelStreamingDataMapReady);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnLevelLoadCompleted);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnLevelLoadedInMemory, ULevelStreamingData*, StreamingData);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnPlacePlayerTheWorld, ULevelPlayerPlacer*, Placer, UWorld*, World);
 
 
UCLASS()
class CK_UE_API ULevelStreamingSubsystem : public UGameInstanceSubsystem, public FTickableGameObject
{
    GENERATED_BODY()
 
public:
    virtual void Initialize(FSubsystemCollectionBase& Collection) override;
    virtual void Deinitialize() override;
    virtual void Tick(float DeltaTime) override;
    virtual bool IsTickable() const override;
    
public:
    void PlacePlayerInLevel();
    AUStageFlowDefinition* GetCurrentFlowDefinition() const;
 
public:
    UFUNCTION(BlueprintCallable, Category = "Level|Streaming")
    void RequestLevelLoad(ULevelStreamingData* ReqLevelLoadPipelineData);
 
    UFUNCTION()
    void OnLevelLoaded();
 
    UFUNCTION()
    void OnLevelShown();
 
    UFUNCTION()
    void OnLevelHidden();
 
public:
    // true: Persistent 레벨에서 시작되어 스트리밍 sublevel이 존재함.
    // false: sublevel 자체로 직접 PIE 진입 — 스트리밍 파이프라인 비대상.
    FORCEINLINE bool IsLaunchedFromPersistentLevel() const
    {
        return GetWorld() && !GetWorld()->GetStreamingLevels().IsEmpty();
    }
 
    FORCEINLINE const UStageDictionary* GetStageDictionary() const
    {
        return CachedStageDictionary.Get();
    }
 
    FORCEINLINE virtual TStatId GetStatId() const override
    {
        RETURN_QUICK_DECLARE_CYCLE_STAT(ULevelStreamingSubsystem, STATGROUP_Tickables);
    }
 
    FORCEINLINE bool IsLevelLoadRequested() const
    {
        return StreamingStateMachine.IsBusy();
    }
 
    FORCEINLINE bool IsInitialStageInitialized() const
    {
        return InitialStageBootstrap.IsInitializedForCurrentWorld();
    }
 
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;
 
public:
    UPROPERTY(BlueprintAssignable, Category = "Level|Streaming")
    FOnLevelLoadCompleted OnLevelLoadCompleted;
 
    UPROPERTY(BlueprintAssignable, Category = "Level|Streaming")
    FOnLevelLoadedInMemory OnLevelLoadedInMemory;
 
    UPROPERTY(BlueprintAssignable, Category = "Level|Streaming")
    FOnPlacePlayerTheWorld OnPlacePlayerTheWorld;
    
private:
    struct FLevelStreamingUtility
    {
        static ULevelStreaming* FindVisible(const UWorld* World);
        static ULevelStreaming* FindByName(const UWorld* World, FName LevelName);
        static void PrepareLevelForLoad(ULevelStreaming* StreamingLevel, bool bShouldBeLoaded);
        static ULevelStreaming* ResolveTargetLevel(UObject* WorldContextObject, FName LevelName, bool& bOutAlreadyLoaded, bool& bOutSuccess);
    };
 
    struct FInitialStageBootstrapper
    {
        void Initialize(ULevelStreamingSubsystem* InOwner);
        void Reset();
        void TryInitializeCurrentStage();
        bool IsInitializedForCurrentWorld() const;
 
    private:
        ULevelStreamingData* ResolveCurrentStageDataFromWorld() const;
        bool OnWaitForPlayTick(float DeltaTime);
 
    private:
        TWeakObjectPtr<UWorld> InitializedWorld;
        TWeakObjectPtr<ULevelStreamingSubsystem> Owner;
        FTSTicker::FDelegateHandle InitTickerHandle;
    };
 
private:
    UPROPERTY(Transient)
    TObjectPtr<UStageDictionary> CachedStageDictionary;
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<ULevelStreamingEffect>> AllRegisteredEffects;
 
    UPROPERTY(Transient)
    TObjectPtr<ULevelStreamingData> LevelStreamingData;
 
    UPROPERTY(Transient)
    TObjectPtr<ULevelPlayerPlacer> ActivePlayerPlacer;
 
    UPROPERTY(Transient)
    TWeakObjectPtr<ULevelStreaming> LevelToLoad;
 
    UPROPERTY(Transient)
    TWeakObjectPtr<ULevelStreaming> LevelToUnload;
 
    UPROPERTY(Transient)
    TObjectPtr<UDataBundleRegistry> BundleRegistry;
 
    FEffectChainExecutor ChainExecutor;
    FInitialStageBootstrapper InitialStageBootstrap;
    FLevelStreamingStateMachine StreamingStateMachine;
 
    // 타이틀에서 프리로드한 Niagara 에셋의 로드 핸들. 세션 동안 로드 상태를 유지한다.
    TSharedPtr<FStreamableHandle> NiagaraPreloadHandle;
 
private:
    friend struct FLevelStreamingStateMachine;
};