UUIManagementSubsystem 클래스 참조

#include <UIManagementSubsystem.h>

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

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

Public 멤버 함수
	UUIManagementSubsystem ()
virtual void	Initialize (FSubsystemCollectionBase &Collection) override
virtual void	Deinitialize () override
virtual void	OnLevelLoaded (ULevel *NewLevel, const ULevelStreamingData *LevelStreamingData) override
virtual void	OnLevelUnloaded () override
virtual void	OnLevelStreamingStarted () override
virtual void	OnLevelStreamingEnded () override
UUserWidgetBase *	PushWidget (const FUIContext &Context, AActor *OwningActor, UUILayer *&OutLayer)
UUserWidgetBase *	PushPlayerWidget (const FUIContext &Context, UUILayer *&OutLayer)
UUserWidgetBase *	PushWidgetInstance (UUserWidgetBase *Widget, int32 ZOrder, UUILayer *&OutLayer)
void	PushWidgetDirect (UUserWidgetBase *Widget, int32 ZOrder, UUILayer *&OutLayer)
bool	PopWidget (UUserWidgetBase *Widget)
void	PopWidgetFromLayer (UUserWidgetBase *Widget, UUILayer *Layer)
void	PopAllWidgetsInLayer (UPARAM(meta=(Categories="UI.Layer")) FGameplayTag LayerTag)
void	PopAllLayer (bool WithPrimaryWidgets=false)
UUILayer *	GetLayer (UPARAM(meta=(Categories="UI.Layer")) FGameplayTag LayerTag) const
UUserWidgetBase *	FindFirstWidgetByArgs (UPARAM(meta=(Categories="UI.Layer")) FGameplayTag LayerTag, const TSubclassOf< UUserWidget > ClassType) const
UUILayer *	GetTopLayer () const
UUILayer *	GetRootLayer () const
UUILayer *	CreateLayer (UPARAM(meta=(Categories="UI.Layer")) FGameplayTag LayerTag, TSubclassOf< UUILayer > LayerClass=nullptr)
void	RemoveLayer (UPARAM(meta=(Categories="UI.Layer")) FGameplayTag LayerTag)
void	ShowLayer (UPARAM(meta=(Categories="UI.Layer")) FGameplayTag LayerTag)
void	HideLayer (UPARAM(meta=(Categories="UI.Layer")) FGameplayTag LayerTag)
void	ClearAllLayers ()
int32	GetWidgetCountInLayer (UPARAM(meta=(Categories="UI.Layer")) const FGameplayTagContainer &UILayerTags)

Private 멤버 함수
UUserWidgetBase *	PushWidgetToLayer (UUserWidgetBase *Widget, FGameplayTag LayerTag, int32 ZOrder, UUILayer *&OutLayer, bool bActivateOnPush=true, bool bCanIncludeInSnapshot=false)
UUILayer *	GetOrCreateLayer (FGameplayTag LayerTag)
void	UpdateInputMode ()
void	ApplyLayerTimeScale (float LayerTimeScale)
float	GetActiveLayerTimeScale () const
void	HandleTimeScaleRaised (float NewTimeScale)

Private 속성
TArray< TObjectPtr< UUILayer > >	LayerStack

생성자 & 소멸자 문서화

UUIManagementSubsystem()

UUIManagementSubsystem::UUIManagementSubsystem

(

)

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

멤버 함수 문서화

ApplyLayerTimeScale()

void UUIManagementSubsystem::ApplyLayerTimeScale ( float  LayerTimeScale )

private

{
    UTimeManagementSubsystem* TimeSubsystem = GetWorld() ? GetWorld()->GetSubsystem<UTimeManagementSubsystem>() : nullptr;
 
    if (TimeSubsystem == nullptr)
    {
        return;
    }
 
    // 시간이 풀렸을 때 아직 떠 있는 레이어의 요구를 다시 주장해야 한다.
    // 이 서브시스템은 GameInstance 수명이라 월드가 바뀌면 구독이 끊긴다. 매번 확인해 다시 붙는다.
    if (TimeSubsystem->GetOnTimeScaleRaised().IsBoundToObject(this) == false)
    {
        TimeSubsystem->GetOnTimeScaleRaised().AddUObject(this, &UUIManagementSubsystem::HandleTimeScaleRaised);
    }
 
    // 배율을 요구하지 않는 레이어로 바뀌었으면 자기가 멈춰둔 시간을 직접 되돌린다.
    if (FMath::IsNearlyEqual(LayerTimeScale, 1.0f))
    {
        TimeSubsystem->ResetTimeScale();
        return;
    }
 
    TimeSubsystem->ApplyTimeScale(LayerTimeScale);
}

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

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

ClearAllLayers()

void UUIManagementSubsystem::ClearAllLayers

(

)

{
    if (LayerStack.IsEmpty())
    {
        UpdateInputMode();
        return;
    }
 
    TArray<TObjectPtr<UUILayer>> LayersToClear = LayerStack;
    LayerStack.Empty();
 
    for (UUILayer* Layer : LayersToClear)
    {
        if (Layer)
        {
            Layer->OnPoppedFromLayerStack();
            Layer->ClearWidget();
        }
    }
 
    UpdateInputMode();
}

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

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

CreateLayer()

UUILayer * UUIManagementSubsystem::CreateLayer	(	UPARAM(meta=(Categories="UI.Layer")) FGameplayTag	LayerTag,
		TSubclassOf< UUILayer >	LayerClass = nullptr
	)

{
    if (LayerTag.IsValid() == false)
    {
        return nullptr;
    }
 
    if (UUILayer* Existing = GetLayer(LayerTag))
    {
        return Existing;
    }
 
    UClass* ClassToUse;
 
    if (LayerClass)
    {
        ClassToUse = LayerClass.Get();
    }
    else
    {
        ClassToUse = UUILayer::StaticClass();
    }
 
    const int32 Priority = UUILayerSettings::Get()->GetLayerPriority(LayerTag);
 
    UUILayer* NewLayer = NewObject<UUILayer>(this, ClassToUse);
    NewLayer->InitLayer(LayerTag, Priority, this);
 
    // 우선순위 오름차순 정렬 삽입
    int32 InsertIndex = 0;
 
    for (int32 i = 0; i < LayerStack.Num(); ++i)
    {
        if (LayerStack[i]->GetPriority() > Priority)
        {
            break;
        }
 
        InsertIndex = i + 1;
    }
 
    LayerStack.Insert(NewLayer, InsertIndex);
    NewLayer->OnPushedToLayerStack();
    return NewLayer;
}

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

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

Deinitialize()

void UUIManagementSubsystem::Deinitialize ( )

overridevirtual

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

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

FindFirstWidgetByArgs()

UUserWidgetBase * UUIManagementSubsystem::FindFirstWidgetByArgs	(	UPARAM(meta=(Categories="UI.Layer")) FGameplayTag	LayerTag,
		const TSubclassOf< UUserWidget >	ClassType
	)		const

{
    // TSubclassOf 는 UUserWidgetBase 파생이 아닌 UClass 를 받아도 컴파일되지만, 역참조할 때마다 nullptr 을 돌려준다.
    // 여기서 걸러두지 않으면 아래 IsA 가 전부 false 가 되고 실패 로그가 널 포인터를 역참조한다.
    const UClass* TargetClass = ClassType.Get();
 
    if (TargetClass == nullptr)
    {
        LOG_ERROR(LogCK, "%s 가 비었거나 %s 파생 클래스가 아닙니다. ", NAMEOF_VAR(ClassType), NAMEOF(UUserWidgetBase));
        return nullptr;
    }
 
    const UUILayer* UILayer = GetLayer(LayerTag);
 
    if (UILayer == nullptr)
    {
        LOG_ERROR(LogCK, "%s를 찾을 수 없습니다. ", NAMEOF(UUILayer));
        return nullptr;
    }
 
    TArray<UUserWidgetBase*> UserWidgetBases = UILayer->GetWidgets();
 
    if (UserWidgetBases.IsEmpty())
    {
        LOG_ERROR(LogCK, "%s가 비어있습니다. ", NAMEOF_VAR(UserWidgetBases));
        return nullptr;
    }
 
    auto MatchPredicate = [TargetClass](const UUserWidgetBase* Widget)
    {
        return IsValid(Widget) && Widget->IsA(TargetClass);
    };
 
    UUserWidgetBase** Result = UserWidgetBases.FindByPredicate(MatchPredicate);
 
    if (Result == nullptr || *Result == nullptr)
    {
        LOG_WARNING(LogCK, "%s 타입의 위젯을 찾지 못했습니다. ", *TargetClass->GetName());
        return nullptr;
    }
 
    return (*Result);
}

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

GetActiveLayerTimeScale()

float UUIManagementSubsystem::GetActiveLayerTimeScale ( ) const

private

{
    // UpdateInputMode 의 레이어 판단 규칙과 동일해야 한다.
    const UUILayerSettings* Settings = UUILayerSettings::Get();
    const FUILayerConfig* ActiveConfig = nullptr;
    const UUILayer* TopLayer = GetTopLayer();
 
    if (TopLayer && TopLayer->IsVisible() && TopLayer->WidgetCount() > 0)
    {
        ActiveConfig = Settings->LayerConfigs.Find(TopLayer->GetTag());
    }
 
    return ActiveConfig ? ActiveConfig->TimeScale : Settings->DefaultConfig.TimeScale;
}

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

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

GetLayer()

UUILayer * UUIManagementSubsystem::GetLayer

(

UPARAM(meta=(Categories="UI.Layer")) FGameplayTag

LayerTag

)

const

{
    TObjectPtr<UUILayer> const* Found = LayerStack.FindByPredicate([&LayerTag](const UUILayer* Layer)
    {
        return Layer && Layer->GetTag() == LayerTag;
    });
 
    if (Found == nullptr)
    {
        return nullptr;
    }
    else
    {
        return Found->Get();
    }
}

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

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

GetOrCreateLayer()

UUILayer * UUIManagementSubsystem::GetOrCreateLayer ( FGameplayTag  LayerTag )

private

{
    if (UUILayer* Existing = GetLayer(LayerTag))
    {
        return Existing;
    }
    else
    {
        return CreateLayer(LayerTag);
    }
}

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

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

GetRootLayer()

UUILayer * UUIManagementSubsystem::GetRootLayer

(

)

const

{
    if (LayerStack.Num() > 0)
    {
        return LayerStack[0];
    }
    else
    {
        return nullptr;
    }
}

GetTopLayer()

UUILayer * UUIManagementSubsystem::GetTopLayer

(

)

const

{
    if (LayerStack.Num() > 0)
    {
        return LayerStack.Last();
    }
    else
    {
        return nullptr;
    }
}

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

GetWidgetCountInLayer()

int32 UUIManagementSubsystem::GetWidgetCountInLayer

(

UPARAM(meta=(Categories="UI.Layer")) const FGameplayTagContainer &

UILayerTags

)

{
    TArray<FGameplayTag> TagArray = UILayerTags.GetGameplayTagArray();
 
    if (TagArray.IsEmpty())
    {
        return 0;
    }
 
    int32 Sum = 0;
 
    for (const FGameplayTag& Tag : TagArray)
    {
        if (Tag.IsValid() == false)
        {
            continue;
        }
 
        if (const UUILayer* Layer = GetLayer(Tag))
        {
            Sum += Layer->WidgetCount();
        }
    }
 
    return Sum;
}

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

HandleTimeScaleRaised()

void UUIManagementSubsystem::HandleTimeScaleRaised ( float  NewTimeScale )

private

{
    const float LayerTimeScale = GetActiveLayerTimeScale();
 
    // 레이어가 여전히 느린 시간을 요구하면 다시 주장한다.
    if (LayerTimeScale >= NewTimeScale)
    {
        return;
    }
 
    if (UTimeManagementSubsystem* TimeSubsystem = GetWorld() ? GetWorld()->GetSubsystem<UTimeManagementSubsystem>() : nullptr)
    {
        TimeSubsystem->ApplyTimeScale(LayerTimeScale);
    }
}

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

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

HideLayer()

void UUIManagementSubsystem::HideLayer

(

UPARAM(meta=(Categories="UI.Layer")) FGameplayTag

LayerTag

)

{
    if (UUILayer* Layer = GetLayer(LayerTag))
    {
        Layer->HideLayer();
    }
    else
    {
        LOG_WARNING(LogCK, "%s 태그 레이어가 설정되어 있시 않습니다. ", *LayerTag.ToString());
    }
}

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

Initialize()

void UUIManagementSubsystem::Initialize ( FSubsystemCollectionBase &  Collection )

overridevirtual

{
    Super::Initialize(Collection);
}

OnLevelLoaded()

virtual void UUIManagementSubsystem::OnLevelLoaded ( ULevel *  NewLevel, const ULevelStreamingData *  LevelStreamingData  )

inlineoverridevirtual

IStreamingEventListenerInterface를 구현.

{ }

OnLevelStreamingEnded()

virtual void UUIManagementSubsystem::OnLevelStreamingEnded ( )

inlineoverridevirtual

IStreamingEventListenerInterface를 구현.

{ }

OnLevelStreamingStarted()

virtual void UUIManagementSubsystem::OnLevelStreamingStarted ( )

inlineoverridevirtual

IStreamingEventListenerInterface를 구현.

{ }

OnLevelUnloaded()

void UUIManagementSubsystem::OnLevelUnloaded ( )

overridevirtual

IStreamingEventListenerInterface를 구현.

{
    PopAllLayer(false);
}

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

PopAllLayer()

void UUIManagementSubsystem::PopAllLayer

(

bool

WithPrimaryWidgets = false

)

{
    TArray<FGameplayTag> LayersToRemove;
 
    for (UUILayer* Layer : LayerStack)
    {
        if (Layer == nullptr)
        {
            continue;
        }
 
        if (WithPrimaryWidgets == false)
        {
            bool bHasPrimaryWidget = false;
 
            for (const UUserWidgetBase* Widget : Layer->GetWidgets())
            {
                if (IsValid(Widget) && Widget->IsPrimary())
                {
                    bHasPrimaryWidget = true;
                    break;
                }
            }
 
            if (bHasPrimaryWidget)
            {
                continue;
            }
        }
 
        LayersToRemove.Add(Layer->GetTag());
    }
 
    for (const FGameplayTag& Tag : LayersToRemove)
    {
        RemoveLayer(Tag);
    }
}

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

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

PopAllWidgetsInLayer()

void UUIManagementSubsystem::PopAllWidgetsInLayer

(

UPARAM(meta=(Categories="UI.Layer")) FGameplayTag

LayerTag

)

{
    if (LayerTag == FGameplayTag::EmptyTag)
    {
        LOG_WARNING(LogCK, "요청받은 레이어 태그가 '%s' 입니다. ", *FGameplayTag::EmptyTag.ToString());
        return;
    }
 
    UUILayer* Layer = GetLayer(LayerTag);
 
    if (Layer == nullptr)
    {
        LOG_WARNING(LogCK, "%s를 찾지 못했습니다. ", *LayerTag.ToString());
        return;
    }
 
    Algo::NullSafeForEach(Layer->GetWidgets(), [this](UUserWidgetBase* Widget)
    {
        PopWidget(Widget);
    });
}

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

PopWidget()

bool UUIManagementSubsystem::PopWidget

(

UUserWidgetBase *

Widget

)

{
    if (IsValid(Widget) == false)
    {
        LOG_ERROR(LogCK, "'%s'이 존재하지 않습니다. ", NAMEOF(UUserWidgetBase));
        return false;
    }
 
    LOG_INFO(LogCK, "제거할 대상 위젯: %s", *Widget->GetName());
 
    //제거할 위젯이 현재 비활성화 중인 상황이거나, 이미 비활성화됐다면 추가로 이행할 작업이 없음. 
    if (Widget->GetWidgetState() == EWidgetState::Disappearing || Widget->GetWidgetState() == EWidgetState::Disappeared)
    {
        return false;
    }
    else
    {
        LOG_INFO(LogCK, "[%s] 제거 위젯", *Widget->GetName());
        Widget->Deactivate();
        return true;
    }
}

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

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

PopWidgetFromLayer()

void UUIManagementSubsystem::PopWidgetFromLayer	(	UUserWidgetBase *	Widget,
		UUILayer *	Layer
	)

{
    if (IsValid(Widget) == false)
    {
        LOG_ERROR(LogCK, "%s가 유효하지 않습니다. ", NAMEOF(UUserWidgetBase));
        return;
    }
 
    if (IsValid(Layer) == false)
    {
        LOG_ERROR(LogCK, "%s가 유효하지 않습니다. ", NAMEOF(UUILayer));
        return;
    }
 
    Layer->RemoveWidget(Widget);
    Widget->OnPoppedFromLayer();
 
    if (Layer->WidgetCount() == 0)
    {
        RemoveLayer(Layer->GetTag());
    }
    else
    {
        UpdateInputMode();
    }
 
    Widget->RemoveFromParent();
}

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

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

PushPlayerWidget()

UUserWidgetBase * UUIManagementSubsystem::PushPlayerWidget	(	const FUIContext &	Context,
		UUILayer *&	OutLayer
	)

{
    APlayerController* PlayerController = GetWorld()->GetFirstPlayerController();
    check(PlayerController);
 
    if (UUserWidgetBase* CreatedWidget = PushWidget(Context, PlayerController, OutLayer))
    {
        return CreatedWidget;
    }
 
    LOG_ERROR(LogCK, "Widget 생성 및 UI Layer 에 쌓는데 실패했습니다. ");
    return nullptr;
}

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

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

PushWidget()

UUserWidgetBase * UUIManagementSubsystem::PushWidget	(	const FUIContext &	Context,
		AActor *	OwningActor,
		UUILayer *&	OutLayer
	)

{
    if (Context.IsValid() == false)
    {
        LOG_ERROR(LogCK, "Context가 잘못되었습니다. ");
        return nullptr;
    }
 
    UWorld* World = GetGameInstance()->GetWorld();
 
    if (World == nullptr)
    {
        LOG_ERROR(LogCK, "World를 가져올 수 없습니다. ");
        return nullptr;
    }
 
    APlayerController* PC = World->GetFirstPlayerController();
 
    if (PC == nullptr)
    {
        LOG_ERROR(LogCK, "PC를 가져올 수 없습니다. ");
        return nullptr;
    }
 
    UUserWidgetBase* Widget = CreateWidget<UUserWidgetBase>(PC, Context.WidgetClass);
 
    if (Widget == nullptr)
    {
        LOG_ERROR(LogCK, "위젯을 생성 할 수 없습니다. ");
        return nullptr;
    }
 
    LOG_INFO(LogCK, "%s이 Layer Stack에 추가되었습니다. ", *Widget->GetName());
 
    Widget->SetPrimary(Context.Primary);
 
    if (IsValid(OwningActor))
    {
        Widget->SetAbilitySystemComponent(OwningActor);
    }
    else
    {
        LOG_ERROR(LogCK, "`OwningActor` 가 유효하지 않습니다. ");
        return nullptr;
    }
 
    return PushWidgetToLayer(Widget, Context.LayerTag, Context.ZOrder, OutLayer, Context.bActivateOnPush, Context.bCanIncludeInSnapshot);
}

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

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

PushWidgetDirect()

void UUIManagementSubsystem::PushWidgetDirect	(	UUserWidgetBase *	Widget,
		int32	ZOrder,
		UUILayer *&	OutLayer
	)

{
    if (IsValid(Widget) == false)
    {
        LOG_ERROR(LogCK, "유효하지 않은 Widget 인스턴스입니다. ");
        return;
    }
 
    const FGameplayTag LayerTag = Widget->GetLayerTag();
 
    if (LayerTag.IsValid() == false)
    {
        LOG_ERROR(LogCK, "%s의 LayerTag가 설정되지 않았습니다. ", *Widget->GetName());
        return;
    }
 
    LOG_INFO(LogCK, "%s이 Layer Stack에 추가되었습니다. ", *Widget->GetName());
    PushWidgetToLayer(Widget, LayerTag, ZOrder, OutLayer);
}

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

PushWidgetInstance()

UUserWidgetBase * UUIManagementSubsystem::PushWidgetInstance	(	UUserWidgetBase *	Widget,
		int32	ZOrder,
		UUILayer *&	OutLayer
	)

{
    if (IsValid(Widget) == false)
    {
        LOG_ERROR(LogCK, "유효하지 않은 Widget 인스턴스입니다. ");
        return nullptr;
    }
 
    const FGameplayTag LayerTag = Widget->GetLayerTag();
 
    if (LayerTag.IsValid() == false)
    {
        LOG_ERROR(LogCK, "%s의 LayerTag가 설정되지 않았습니다. ", *Widget->GetName());
        return nullptr;
    }
 
    return PushWidgetToLayer(Widget, LayerTag, ZOrder, OutLayer);
}

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

PushWidgetToLayer()

UUserWidgetBase * UUIManagementSubsystem::PushWidgetToLayer ( UUserWidgetBase *  Widget, FGameplayTag  LayerTag, int32  ZOrder, UUILayer *&  OutLayer, bool  bActivateOnPush = true, bool  bCanIncludeInSnapshot = false  )

private

{
    UUILayer* Layer = GetOrCreateLayer(LayerTag);
 
    if (Layer == nullptr)
    {
        LOG_ERROR(LogCK, "%s 태그의 위젯을 가져오는데 실패했습ㄴ디ㅏ. ", *LayerTag.ToString())
        return nullptr;
    }
 
    OutLayer = Layer;
 
    Widget->SetLayerTag(LayerTag);
    Widget->AddToViewport(ZOrder);
    Layer->PushWidget(Widget);
 
    if (bCanIncludeInSnapshot)
    {
        USnapshotSubsystem::ProcessNewCommand<UWidgetPushCommand>(this, [this, Widget](UWidgetPushCommand* Command)
        {
            Command->Initialize(this, Widget);
        });
    }
 
    if (bActivateOnPush)
    {
        if (Layer->IsVisible())
        {
            Widget->Activate();
        }
        else
        {
            Widget->SetVisibility(ESlateVisibility::Collapsed);
        }
    }
 
    Widget->OnPushedToLayer();
    UpdateInputMode();
    return Widget;
}

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

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

RemoveLayer()

void UUIManagementSubsystem::RemoveLayer

(

UPARAM(meta=(Categories="UI.Layer")) FGameplayTag

LayerTag

)

{
    int32 Index = LayerStack.IndexOfByPredicate([&LayerTag](const UUILayer* Layer)
    {
        return Layer && Layer->GetTag() == LayerTag;
    });
 
    if (Index == INDEX_NONE)
    {
        LOG_WARNING(LogCK, "%s 레이어가 존재하지 않습니다. ", *LayerTag.ToString());
        return;
    }
 
    UUILayer* Layer = LayerStack[Index];
    Layer->OnPoppedFromLayerStack();
    Layer->ClearWidget();
    LayerStack.RemoveAt(Index);
    UpdateInputMode();
}

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

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

ShowLayer()

void UUIManagementSubsystem::ShowLayer

(

UPARAM(meta=(Categories="UI.Layer")) FGameplayTag

LayerTag

)

{
    if (UUILayer* Layer = GetLayer(LayerTag))
    {
        Layer->ShowLayer();
    }
    else
    {
        LOG_WARNING(LogCK, "%s 태그 레이어가 설정되어 있시 않습니다. ", *LayerTag.ToString());
    }
}

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

UpdateInputMode()

void UUIManagementSubsystem::UpdateInputMode ( )

private

{
    APlayerController* PC = GetGameInstance()->GetWorld()->GetFirstPlayerController();
 
    if (PC == nullptr)
    {
        return;
    }
 
    // 최상위 우선순위 레이어의 설정으로 입력 모드 판단
    const UUILayerSettings* Settings = UUILayerSettings::Get();
    const FUILayerConfig* ActiveConfig = nullptr;
    const UUILayer* TopLayer = GetTopLayer();
 
    if (TopLayer)
    {
        LOG_INFO(LogCK, "[Top Layer]: %s", *TopLayer->GetTag().ToString());
 
        if (TopLayer->IsVisible() && TopLayer->WidgetCount() > 0)
        {
            ActiveConfig = Settings->LayerConfigs.Find(TopLayer->GetTag());
        }
    }
 
    const FUILayerConfig& ConfigToApply = ActiveConfig ? *ActiveConfig : Settings->DefaultConfig;
 
    PC->bShowMouseCursor = ConfigToApply.bShowMouseCursor;
    ApplyLayerTimeScale(ConfigToApply.TimeScale);
 
    if (PC->GetLocalPlayer())
    {
        if (UPlayerManagementSubsystem* PlayerManagement = PC->GetLocalPlayer()->GetSubsystem<UPlayerManagementSubsystem>())
        {
            PlayerManagement->ApplyUILayerInputBlockOptions(ConfigToApply.bBlockPlayerMovement, ConfigToApply.bBlockPlayerInput);
        }
        else
        {
            LOG_WARNING(LogCK, "%s를 찾지 못해 UI 플레이어 입력 차단 옵션을 적용하지 못했습니다.", NAMEOF(UPlayerManagementSubsystem));
        }
    }
 
    if (PC->bShowMouseCursor)
    {
        FInputModeGameAndUI InputMode;
        InputMode.SetLockMouseToViewportBehavior(ConfigToApply.MouseLockMode);
        InputMode.SetHideCursorDuringCapture(false);
        PC->SetInputMode(InputMode);
    }
    else
    {
        PC->SetInputMode(FInputModeGameOnly());
    }
}

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

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

멤버 데이터 문서화

LayerStack

TArray<TObjectPtr<UUILayer> > UUIManagementSubsystem::LayerStack

private

---

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

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