USnapshotSubsystem 클래스 참조

#include <SnapshotSubsystem.h>

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

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

Public 멤버 함수
	USnapshotSubsystem ()
virtual void	Deinitialize () override
bool	ProcessCommand (UCommandBase *Command)
void	RecordCommand (UCommandBase *Command)
void	MarkRollbackPoint (FName RollbackPointID)
bool	RollbackTo (FName RollbackPointID)
void	ResetCommands ()
template<typename TCommandType , typename TInitializeCommand >
TCommandType *	ProcessNewCommand (TInitializeCommand InitializeCommand)
FORCEINLINE bool	IsRollingBack () const

정적 Public 멤버 함수
template<typename TCommandType , typename TInitializeCommand >
static TCommandType *	ProcessNewCommand (UObject *WorldContextObject, TInitializeCommand InitializeCommand)

Private 속성
TArray< TObjectPtr< UCommandBase > >	CommandStack
TMap< FName, int32 >	RollbackPointByID
int32	RollbackDepth = 0

생성자 & 소멸자 문서화

USnapshotSubsystem()

USnapshotSubsystem::USnapshotSubsystem

(

)

{
#if WITH_EDITOR
    FCK_ConsoleCommands::RegisterSnapshotCommands(this);
#endif
}

멤버 함수 문서화

Deinitialize()

void USnapshotSubsystem::Deinitialize ( )

overridevirtual

{
    ResetCommands();
    Super::Deinitialize();
}

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

IsRollingBack()

FORCEINLINE bool USnapshotSubsystem::IsRollingBack ( ) const

inline

    {
        return RollbackDepth > 0;
    }

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

MarkRollbackPoint()

void USnapshotSubsystem::MarkRollbackPoint

(

FName

RollbackPointID

)

{
    if (RollbackPointID.IsNone())
    {
        return;
    }
 
    RollbackPointByID.FindOrAdd(RollbackPointID) = CommandStack.Num();
}

ProcessCommand()

bool USnapshotSubsystem::ProcessCommand

(

UCommandBase *

Command

)

{
    if (Command == nullptr)
    {
        return false;
    }
 
    if (Command->Process() == false)
    {
        return false;
    }
 
    RecordCommand(Command);
    return true;
}

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

ProcessNewCommand() [1/2]

template<typename TCommandType , typename TInitializeCommand >

TCommandType * USnapshotSubsystem::ProcessNewCommand

(

TInitializeCommand

InitializeCommand

)

{
    static_assert(TIsDerivedFrom<TCommandType, UCommandBase>::Value, "TCommandType must derive from UCommandBase.");
 
    if (IsRollingBack())
    {
        return nullptr;
    }
 
    TCommandType* Command = NewObject<TCommandType>(this);
 
    if (Command == nullptr)
    {
        return nullptr;
    }
 
    InitializeCommand(Command);
 
    if (ProcessCommand(Command) == false)
    {
        return nullptr;
    }
    else
    {
        return Command;
    }
}

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

ProcessNewCommand() [2/2]

template<typename TCommandType , typename TInitializeCommand >

TCommandType * USnapshotSubsystem::ProcessNewCommand ( UObject *  WorldContextObject, TInitializeCommand  InitializeCommand  )

static

{
    static_assert(TIsDerivedFrom<TCommandType, UCommandBase>::Value, "TCommandType must derive from UCommandBase.");
    
    if (WorldContextObject == nullptr)
    {
        return nullptr;
    }
 
    UGameInstance* GameInstance = Cast<UGameInstance>(WorldContextObject);
 
    if (GameInstance == nullptr)
    {
        UWorld* World = WorldContextObject->GetWorld();
        GameInstance = World ? World->GetGameInstance() : nullptr;
        check(GameInstance);
    }
 
    USnapshotSubsystem* SnapshotSubsystem = GameInstance->GetSubsystem<USnapshotSubsystem>();
 
    if (SnapshotSubsystem == nullptr)
    {
        LOG_ERROR(LogCK, "%s를 가져올 수 없습니다. ", NAMEOF(USnapshotSubsystem));
        return nullptr;
    }
    else
    {
        return SnapshotSubsystem->ProcessNewCommand<TCommandType>(InitializeCommand);
    }
}

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

RecordCommand()

void USnapshotSubsystem::RecordCommand

(

UCommandBase *

Command

)

{
    if (Command == nullptr || IsRollingBack())
    {
        return;
    }
 
    CommandStack.Add(Command);
}

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

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

ResetCommands()

void USnapshotSubsystem::ResetCommands

(

)

{
    CommandStack.Empty();
    RollbackPointByID.Empty();
    RollbackDepth = 0;
}

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

RollbackTo()

bool USnapshotSubsystem::RollbackTo

(

FName

RollbackPointID

)

{
    const int32* FoundIndex = RollbackPointByID.Find(RollbackPointID);
 
    if (FoundIndex == nullptr)
    {
        return false;
    }
 
    const int32 TargetIndex = FMath::Clamp(*FoundIndex, 0, CommandStack.Num());
 
    ++RollbackDepth;
 
    for (int32 Index = CommandStack.Num() - 1; Index >= TargetIndex; --Index)
    {
        UCommandBase* Command = CommandStack[Index];
 
        if (Command)
        {
            Command->Undo();
        }
    }
 
    CommandStack.SetNum(TargetIndex);
 
    for (auto It = RollbackPointByID.CreateIterator(); It; ++It)
    {
        if (It.Value() > TargetIndex)
        {
            It.RemoveCurrent();
        }
    }
 
    --RollbackDepth;
    return true;
}

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

멤버 데이터 문서화

CommandStack

TArray<TObjectPtr<UCommandBase> > USnapshotSubsystem::CommandStack

private

RollbackDepth

int32 USnapshotSubsystem::RollbackDepth = 0

private

RollbackPointByID

TMap<FName, int32> USnapshotSubsystem::RollbackPointByID

private

---

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

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