UPoolWorldSubsystem 클래스 참조

#include <PoolWorldSubsystem.h>

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

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

Public 멤버 함수
virtual void	OnWorldBeginPlay (UWorld &InWorld) override
AActor *	GetActorFromPool (TSubclassOf< AActor > ActorClass, FVector Location, FRotator Rotation)
void	ReturnActorToPool (AActor *ActorToReturn)

Private 멤버 함수
AActor *	CreateActorAndSetup (TSubclassOf< AActor > ActorClass, UWorld *World)
AActor *	CreateActorFromPendingWarmup (TSubclassOf< AActor > ActorClass)
void	QueuePoolWarmup (TSubclassOf< AActor > ActorClass, int32 ActorCount)
void	ProcessPendingPoolWarmup ()
void	ScheduleNextPoolWarmup ()

Private 속성
TMap< TSubclassOf< AActor >, FObjectPool >	ObjectPools
TArray< FPendingPoolWarmup >	PendingPoolWarmups
bool	bIsPoolWarmupActive = false

멤버 함수 문서화

CreateActorAndSetup()

AActor * UPoolWorldSubsystem::CreateActorAndSetup ( TSubclassOf< AActor >  ActorClass, UWorld *  World  )

private

{
    FActorSpawnParameters SpawnParams;
    SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn; // 위치 겹쳐도 강제 생성
 
    AActor* SpawnedActor = World->SpawnActor<AActor>(ActorClass, FVector::ZeroVector, FRotator::ZeroRotator, SpawnParams);
 
    if (SpawnedActor == nullptr)
    {
        return nullptr;
    }
 
    const FString FolderPath = FString::Printf(TEXT("ObjectPool/%s"), *ActorClass->GetName());
 
#if WITH_EDITOR
    SpawnedActor->SetFolderPath(FName(*FolderPath));
#endif
 
    if (SpawnedActor->Implements<UObjectPoolingInterface>())
    {
        IObjectPoolingInterface::Execute_OnReturnToPool(SpawnedActor);
    }
 
    SpawnedActor->SetActorHiddenInGame(true);
    SpawnedActor->SetActorEnableCollision(false);
    SpawnedActor->SetActorTickEnabled(false);
    return SpawnedActor;
}

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

CreateActorFromPendingWarmup()

AActor * UPoolWorldSubsystem::CreateActorFromPendingWarmup ( TSubclassOf< AActor >  ActorClass )

private

{
    UWorld* World = GetWorld();
 
    if (ActorClass == nullptr || World == nullptr)
    {
        return nullptr;
    }
 
    for (int32 Index = 0; Index < PendingPoolWarmups.Num(); ++Index)
    {
        FPendingPoolWarmup& PendingWarmup = PendingPoolWarmups[Index];
 
        if (PendingWarmup.ActorClass != ActorClass || PendingWarmup.RemainingCount <= 0)
        {
            continue;
        }
 
        --PendingWarmup.RemainingCount;
 
        if (FMath::Max(PendingWarmup.RemainingCount, 0) == 0)
        {
            PendingPoolWarmups.RemoveAt(Index);
        }
 
        return CreateActorAndSetup(ActorClass, World);
    }
 
    return nullptr;
}

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

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

GetActorFromPool()

AActor * UPoolWorldSubsystem::GetActorFromPool	(	TSubclassOf< AActor >	ActorClass,
		FVector	Location,
		FRotator	Rotation
	)

{
    if (ActorClass == nullptr || GetWorld() == nullptr)
    {
        return nullptr;
    }
 
    FObjectPool* Pool = ObjectPools.Find(ActorClass);
    AActor* SpawnedActor = nullptr;
 
    while (Pool && Pool->InactiveActors.Num() > 0)
    {
        SpawnedActor = Pool->InactiveActors.Pop(EAllowShrinking::No);
 
        if (IsValid(SpawnedActor))
        {
            break;
        }
 
        SpawnedActor = nullptr;
    }
 
    if (SpawnedActor == nullptr)
    {
        SpawnedActor = CreateActorFromPendingWarmup(ActorClass);
    }
 
    if (SpawnedActor == nullptr)
    {
        const UObjectPoolSettings* Settings = GetDefault<UObjectPoolSettings>();
 
        bool bCanExpand = true;
 
        if (Settings && Settings->PoolMaps.Contains(ActorClass))
        {
            bCanExpand = Settings->PoolMaps[ActorClass].bCanExpand;
        }
 
        if (bCanExpand)
        {
            SpawnedActor = CreateActorAndSetup(ActorClass, GetWorld());
        }
        else
        {
            LOG_WARNING(LogCK, "%s 풀 부족으로 더 이상 스폰 불가능", *ActorClass->GetName())
            return nullptr;
        }
    }
 
    if (SpawnedActor == nullptr)
    {
        return nullptr;
    }
 
    SpawnedActor->SetActorLocationAndRotation(Location, Rotation);
    SpawnedActor->SetActorHiddenInGame(false);
    SpawnedActor->SetActorTickEnabled(true);
    SpawnedActor->SetActorEnableCollision(true);
 
 
    if (SpawnedActor->Implements<UObjectPoolingInterface>())
    {
        IObjectPoolingInterface::Execute_OnSpawnFromPool(SpawnedActor);
    }
 
    return SpawnedActor;
}

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

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

OnWorldBeginPlay()

void UPoolWorldSubsystem::OnWorldBeginPlay ( UWorld &  InWorld )

overridevirtual

{
    Super::OnWorldBeginPlay(InWorld);
    const UObjectPoolSettings* Settings = GetDefault<UObjectPoolSettings>();
 
    if (Settings == nullptr)
    {
        return;
    }
 
    for (const auto& Pair : Settings->PoolMaps)
    {
        TSubclassOf<AActor> ActorClass = Pair.Key;
        int32 InitialSize = Pair.Value.InitialPoolSize;
 
        if (ActorClass == nullptr || InitialSize <= 0)
        {
            continue;
        }
 
        ObjectPools.FindOrAdd(ActorClass);
        QueuePoolWarmup(ActorClass, InitialSize);
    }
 
    ScheduleNextPoolWarmup();
}

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

ProcessPendingPoolWarmup()

void UPoolWorldSubsystem::ProcessPendingPoolWarmup ( )

private

{
    bIsPoolWarmupActive = false;
 
    UWorld* World = GetWorld();
 
    if (World == nullptr)
    {
        PendingPoolWarmups.Empty();
        return;
    }
 
    int32 CreatedCount = 0;
    
    const UObjectPoolSettings* Settings = GetDefault<UObjectPoolSettings>();
    
    if (Settings == nullptr)
    {
        LOG_ERROR(LogCK, "%s를 찾지 못했습니다. ", NAMEOF(UObjectPoolSettings));
        PendingPoolWarmups.Empty();
        return;
    } 
 
    while (CreatedCount < Settings->PoolWarmupActorsPerFrame && PendingPoolWarmups.Num() > 0)
    {
        FPendingPoolWarmup& PendingWarmup = PendingPoolWarmups[0];
 
        if (PendingWarmup.ActorClass == nullptr || PendingWarmup.RemainingCount <= 0)
        {
            PendingPoolWarmups.RemoveAt(0);
            continue;
        }
 
        FObjectPool& Pool = ObjectPools.FindOrAdd(PendingWarmup.ActorClass);
 
        if (AActor* NewActor = CreateActorAndSetup(PendingWarmup.ActorClass, World))
        {
            Pool.InactiveActors.Add(NewActor);
        }
 
        --PendingWarmup.RemainingCount;
        ++CreatedCount;
 
        if (FMath::Max(PendingWarmup.RemainingCount, 0) > 0)
        {
            continue;
        }
 
        PendingPoolWarmups.RemoveAt(0);
    }
 
    ScheduleNextPoolWarmup();
}

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

QueuePoolWarmup()

void UPoolWorldSubsystem::QueuePoolWarmup ( TSubclassOf< AActor >  ActorClass, int32  ActorCount  )

private

{
    if (ActorClass == nullptr || ActorCount <= 0)
    {
        return;
    }
 
    FPendingPoolWarmup& PendingWarmup = PendingPoolWarmups.AddDefaulted_GetRef();
    PendingWarmup.ActorClass = ActorClass;
    PendingWarmup.RemainingCount = ActorCount;
}

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

ReturnActorToPool()

void UPoolWorldSubsystem::ReturnActorToPool

(

AActor *

ActorToReturn

)

{
    if (ActorToReturn == nullptr || GetWorld() == nullptr)
    {
        return;
    }
 
    UClass* ActorClass = ActorToReturn->GetClass();
    FObjectPool& Pool = ObjectPools.FindOrAdd(ActorClass);
 
    if (Pool.InactiveActors.Contains(ActorToReturn))
    {
        LOG_WARNING(LogCK, "이미 반환된 액터")
        return;
    }
 
    if (ActorToReturn->Implements<UObjectPoolingInterface>())
    {
        IObjectPoolingInterface::Execute_OnReturnToPool(ActorToReturn);
    }
 
    // 비활성화
    ActorToReturn->SetActorHiddenInGame(true);
    ActorToReturn->SetActorEnableCollision(false);
    ActorToReturn->SetActorTickEnabled(false);
 
    Pool.InactiveActors.Add(ActorToReturn);
}

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

ScheduleNextPoolWarmup()

void UPoolWorldSubsystem::ScheduleNextPoolWarmup ( )

private

{
    if (bIsPoolWarmupActive || PendingPoolWarmups.Num() <= 0)
    {
        return;
    }
 
    const UWorld* World = GetWorld();
 
    if (World == nullptr)
    {
        PendingPoolWarmups.Empty();
        return;
    }
 
    bIsPoolWarmupActive = true;
    TWeakObjectPtr<UPoolWorldSubsystem> WeakThis(this);
 
    if (WeakThis.IsValid() == false)
    {
        return;
    }
 
    auto Lambda = [WeakThis]()
    {
        WeakThis->ProcessPendingPoolWarmup();
    };
 
    World->GetTimerManager().SetTimerForNextTick(Lambda);
}

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

멤버 데이터 문서화

bIsPoolWarmupActive

bool UPoolWorldSubsystem::bIsPoolWarmupActive = false

private

ObjectPools

TMap<TSubclassOf<AActor>, FObjectPool> UPoolWorldSubsystem::ObjectPools

private

PendingPoolWarmups

TArray<FPendingPoolWarmup> UPoolWorldSubsystem::PendingPoolWarmups

private

---

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

• Source/CK_UE/Subsystem/World/PoolWorldSubsystem.h
• Source/CK_UE/Subsystem/World/PoolWorldSubsystem.cpp