FEffectChainExecutor 구조체 참조

레벨 스트리밍 이펙트 체인의 순차 실행을 담당합니다. 더 자세히 ...

#include <EffectChainExecutor.h>

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

Public 타입
using	FContextFactory = TFunction< FLevelStreamingContext()>
	매 틱마다 FLevelStreamingContext를 생성하는 팩토리 타입.
using	FOnChainCompleted = TFunction< void(ELevelStreamingPhase)>
	체인 완료 시 완료된 Phase를 인자로 호출되는 콜백 타입.

Public 멤버 함수
void	SetupEffects (const TArray< ULevelStreamingEffect * > &AllEffects)
	이펙트 목록을 Phase별로 분류해 내부 체인 맵을 구성합니다.
void	ClearEffects ()
	내부 Phase 체인 맵과 현재 실행 체인을 모두 초기화합니다.
void	Start (ELevelStreamingPhase InPhase, FContextFactory InContextFactory, FOnChainCompleted InOnCompleted, bool bInDebugMode=false)
	이펙트 체인 실행을 시작합니다.
void	Tick (float DeltaTime)
	현재 이펙트를 틱합니다. 완료 시 End 이벤트를 호출하고 다음 이펙트로 진행합니다.
bool	IsActive () const
	체인이 현재 실행 중인지 여부를 반환합니다.
ELevelStreamingPhase	GetPhase () const
	현재 Phase를 반환합니다.
int32	GetChainIndex () const
	현재 ChainIndex를 반환합니다.

Private 멤버 함수
void	Process ()
	다음 실행 대상 이펙트를 결정하고 Start 이벤트를 호출하거나 완료 처리합니다.
ELevelStreamingEffectResult	DispatchUpdate (ULevelStreamingEffect *Effect, const FLevelStreamingContext &Context) const
	Phase에 맞는 인터페이스로 Update를 디스패치하고 결과를 반환합니다.
void	DispatchEvent (ULevelStreamingEffect *Effect, ELevelStreamingEffectCallType CallType, const FLevelStreamingContext &Context) const
	Phase에 맞는 인터페이스로 Start 또는 End 이벤트를 디스패치합니다.

Private 속성
TMap< ELevelStreamingPhase, TArray< ULevelStreamingEffect * > >	PhaseChains
	Phase별로 분류된 이펙트 체인 맵. SetupEffects 호출 시 구성됩니다.
TArray< ULevelStreamingEffect * >	Chain
	현재 실행 중인 이펙트 목록. Start 시 PhaseChains에서 복사됩니다.
int32	ChainIndex = 0
	현재 실행 중인 이펙트의 인덱스.
ELevelStreamingPhase	Phase = ELevelStreamingPhase::None
	현재 Phase.
FContextFactory	ContextFactory
	매 틱마다 컨텍스트를 생성하는 팩토리 함수.
FOnChainCompleted	OnCompleted
	체인 완료 시 호출될 콜백.
bool	bActive = false
	체인 실행 중 여부.
bool	bDebugMode = false
	디버그 로그 출력 여부.

상세한 설명

레벨 스트리밍 이펙트 체인의 순차 실행을 담당합니다.

Phase별 이펙트의 Update / Start / End 디스패치, bSkipThisEffect 처리, 완료 시 콜백 호출을 수행합니다. LevelStreamingSubsystem이 값으로 소유하며, 체인 진행 상태를 독립적으로 관리합니다.

멤버 타입정의 문서화

FContextFactory

using FEffectChainExecutor::FContextFactory = TFunction<FLevelStreamingContext()>

매 틱마다 FLevelStreamingContext를 생성하는 팩토리 타입.

FOnChainCompleted

using FEffectChainExecutor::FOnChainCompleted = TFunction<void(ELevelStreamingPhase)>

체인 완료 시 완료된 Phase를 인자로 호출되는 콜백 타입.

멤버 함수 문서화

ClearEffects()

void FEffectChainExecutor::ClearEffects

(

)

내부 Phase 체인 맵과 현재 실행 체인을 모두 초기화합니다.

{
    PhaseChains.Reset();
    Chain.Reset();
}

DispatchEvent()

void FEffectChainExecutor::DispatchEvent ( ULevelStreamingEffect *  Effect, ELevelStreamingEffectCallType  CallType, const FLevelStreamingContext &  Context  ) const

private

Phase에 맞는 인터페이스로 Start 또는 End 이벤트를 디스패치합니다.

매개변수

Effect	대상 이펙트.
CallType	Start 또는 End.
Context	현재 레벨 스트리밍 컨텍스트.

{
    switch (Phase)
    {
        case ELevelStreamingPhase::PreLoad:
        {
            ILevelPreLoad* PreLoad = Cast<ILevelPreLoad>(Effect);
 
            if (PreLoad == nullptr)
            {
                return;
            }
 
            if (CallType == ELevelStreamingEffectCallType::Start)
            {
                PreLoad->OnPreLoadStart(Context);
            }
            else if (CallType == ELevelStreamingEffectCallType::End)
            {
                PreLoad->OnPreLoadEnd(Context);
            }
 
            break;
        }
 
        case ELevelStreamingPhase::DuringLoad:
        {
            ILevelLoading* Loading = Cast<ILevelLoading>(Effect);
 
            if (Loading == nullptr)
            {
                return;
            }
 
            if (CallType == ELevelStreamingEffectCallType::Start)
            {
                Loading->OnLoadingStart(Context);
            }
            else if (CallType == ELevelStreamingEffectCallType::End)
            {
                Loading->OnLoadingEnd(Context);
            }
 
            break;
        }
 
        case ELevelStreamingPhase::PostLoad:
        {
            ILevelPostLoad* PostLoad = Cast<ILevelPostLoad>(Effect);
 
            if (PostLoad == nullptr)
            {
                return;
            }
 
            if (CallType == ELevelStreamingEffectCallType::Start)
            {
                PostLoad->OnPostLoadStart(Context);
            }
            else if (CallType == ELevelStreamingEffectCallType::End)
            {
                PostLoad->OnPostLoadEnd(Context);
            }
 
            break;
        }
    }
}

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

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

DispatchUpdate()

ELevelStreamingEffectResult FEffectChainExecutor::DispatchUpdate ( ULevelStreamingEffect *  Effect, const FLevelStreamingContext &  Context  ) const

private

Phase에 맞는 인터페이스로 Update를 디스패치하고 결과를 반환합니다.

매개변수

Effect	업데이트할 이펙트.
Context	현재 레벨 스트리밍 컨텍스트.

반환값

이펙트 실행 결과.

{
    switch (Phase)
    {
        case ELevelStreamingPhase::PreLoad:
        {
            ILevelPreLoad* PreLoad = Cast<ILevelPreLoad>(Effect);
            return PreLoad->OnPreLoadUpdate(Context);
        }
 
        case ELevelStreamingPhase::DuringLoad:
        {
            ILevelLoading* Loading = Cast<ILevelLoading>(Effect);
            return Loading->OnLoadingUpdate(Context);
        }
 
        case ELevelStreamingPhase::PostLoad:
        {
            ILevelPostLoad* PostLoad = Cast<ILevelPostLoad>(Effect);
            return PostLoad->OnPostLoadUpdate(Context);
        }
    }
 
    return ELevelStreamingEffectResult::Completed;
}

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

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

GetChainIndex()

int32 FEffectChainExecutor::GetChainIndex ( ) const

inline

현재 ChainIndex를 반환합니다.

    {
        return ChainIndex;
    }

GetPhase()

ELevelStreamingPhase FEffectChainExecutor::GetPhase ( ) const

inline

현재 Phase를 반환합니다.

    {
        return Phase;
    }

IsActive()

bool FEffectChainExecutor::IsActive ( ) const

inline

체인이 현재 실행 중인지 여부를 반환합니다.

    {
        return bActive;
    }

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

Process()

void FEffectChainExecutor::Process ( )

private

다음 실행 대상 이펙트를 결정하고 Start 이벤트를 호출하거나 완료 처리합니다.

bSkipThisEffect인 이펙트를 건너뛰고, 유효한 이펙트가 없으면 OnCompleted를 호출합니다.

{
    // bSkipThisEffect인 이펙트 건너뜀
    while (Chain.IsValidIndex(ChainIndex) && Chain[ChainIndex]->bSkipThisEffect)
    {
        ChainIndex++;
    }
 
    if (Chain.IsValidIndex(ChainIndex) == false)
    {
        // 완료 처리 전에 bActive를 먼저 내려 콜백 내부에서 IsActive() 호출 시 false 반환
        bActive = false;
 
        ELevelStreamingPhase CompletedPhase = Phase;
 
        // 완료된 Phase의 모든 이펙트에 OnCompletedEffectsByPhase 알림
        if (TArray<ULevelStreamingEffect*>* PhaseEffects = PhaseChains.Find(CompletedPhase))
        {
            for (ULevelStreamingEffect* Effect : *PhaseEffects)
            {
                if (Effect)
                {
                    Effect->OnCompletedEffectsByPhase(CompletedPhase);
                }
            }
        }
 
        if (OnCompleted)
        {
            OnCompleted(CompletedPhase);
        }
 
        return;
    }
 
    if (bDebugMode)
    {
        LOG_INFO(LogCKLevel, "ChainIndex '%d' Phase '%s'", ChainIndex, *UEnum::GetValueAsString(Phase));
    }
 
    FLevelStreamingContext Context = ContextFactory();
    DispatchEvent(Chain[ChainIndex], ELevelStreamingEffectCallType::Start, Context);
}

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

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

SetupEffects()

void FEffectChainExecutor::SetupEffects

(

const TArray< ULevelStreamingEffect * > &

AllEffects

)

이펙트 목록을 Phase별로 분류해 내부 체인 맵을 구성합니다.

ILevelPreLoad / ILevelLoading / ILevelPostLoad 인터페이스 캐스트로 Phase를 판별합니다. 한 이펙트가 여러 인터페이스를 구현하면 해당 Phase 모두에 등록됩니다.

매개변수

AllEffects

분류할 이펙트 목록.

{
    PhaseChains.Reset();
    
    PhaseChains.FindOrAdd(ELevelStreamingPhase::PreLoad);
    PhaseChains.FindOrAdd(ELevelStreamingPhase::DuringLoad);
    PhaseChains.FindOrAdd(ELevelStreamingPhase::PostLoad);
 
    for (ULevelStreamingEffect* Effect : AllEffects)
    {
        if (Effect == nullptr)
        {
            continue;
        }
 
        if (Cast<ILevelPreLoad>(Effect))
        {
            PhaseChains[ELevelStreamingPhase::PreLoad].Add(Effect);
        }
 
        if (Cast<ILevelLoading>(Effect))
        {
            PhaseChains[ELevelStreamingPhase::DuringLoad].Add(Effect);
        }
 
        if (Cast<ILevelPostLoad>(Effect))
        {
            PhaseChains[ELevelStreamingPhase::PostLoad].Add(Effect);
        }
    }
}

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

Start()

void FEffectChainExecutor::Start	(	ELevelStreamingPhase	InPhase,
		FContextFactory	InContextFactory,
		FOnChainCompleted	InOnCompleted,
		bool	bInDebugMode = false
	)

이펙트 체인 실행을 시작합니다.

이전 체인 상태를 초기화한 뒤 첫 번째 이펙트의 Start 이벤트를 즉시 호출합니다. 실행할 체인은 SetupEffects로 미리 구성되어 있어야 합니다.

매개변수

InPhase	현재 Phase.
InContextFactory	매 틱마다 컨텍스트를 생성하는 팩토리 함수.
InOnCompleted	체인 완료 시 호출될 콜백.
bInDebugMode	디버그 로그 출력 여부.

{
    TArray<ULevelStreamingEffect*>* FoundChain = PhaseChains.Find(InPhase);
    Chain = FoundChain ? *FoundChain : TArray<ULevelStreamingEffect*>();
 
    Phase = InPhase;
    ContextFactory = MoveTemp(InContextFactory);
    OnCompleted = MoveTemp(InOnCompleted);
    bDebugMode = bInDebugMode;
    ChainIndex = 0;
    bActive = true;
 
    Process();
}

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

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

Tick()

void FEffectChainExecutor::Tick

(

float

DeltaTime

)

현재 이펙트를 틱합니다. 완료 시 End 이벤트를 호출하고 다음 이펙트로 진행합니다.

매개변수

DeltaTime

프레임 경과 시간.

{
    if (bActive == false || Chain.IsValidIndex(ChainIndex) == false)
    {
        return;
    }
 
    ULevelStreamingEffect* Effect = Chain[ChainIndex];
    FLevelStreamingContext Context = ContextFactory();
 
    Effect->LastExecutionResult = DispatchUpdate(Effect, Context);
 
    //TODO 만약에 추후 병렬적으로 이펙트를 수행해야될 경우, EffectGroup을 만들어, 한 번에 돌리는 방식으로 개선.
    if (Effect->LastExecutionResult != ELevelStreamingEffectResult::InProgress)
    {
        DispatchEvent(Effect, ELevelStreamingEffectCallType::End, Context);
        ChainIndex++;
        Process();
    }
}

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

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

멤버 데이터 문서화

bActive

bool FEffectChainExecutor::bActive = false

private

체인 실행 중 여부.

bDebugMode

bool FEffectChainExecutor::bDebugMode = false

private

디버그 로그 출력 여부.

Chain

TArray<ULevelStreamingEffect*> FEffectChainExecutor::Chain

private

현재 실행 중인 이펙트 목록. Start 시 PhaseChains에서 복사됩니다.

ChainIndex

int32 FEffectChainExecutor::ChainIndex = 0

private

현재 실행 중인 이펙트의 인덱스.

ContextFactory

FContextFactory FEffectChainExecutor::ContextFactory

private

매 틱마다 컨텍스트를 생성하는 팩토리 함수.

OnCompleted

FOnChainCompleted FEffectChainExecutor::OnCompleted

private

체인 완료 시 호출될 콜백.

Phase

ELevelStreamingPhase FEffectChainExecutor::Phase = ELevelStreamingPhase::None

private

현재 Phase.

PhaseChains

TMap<ELevelStreamingPhase, TArray<ULevelStreamingEffect*> > FEffectChainExecutor::PhaseChains

private

Phase별로 분류된 이펙트 체인 맵. SetupEffects 호출 시 구성됩니다.

---

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

• Source/CK_UE/Level/Effect/EffectChainExecutor.h
• Source/CK_UE/Level/Effect/EffectChainExecutor.cpp