FOptimizationThread Class Reference

#include <OptimizationManager.h>

Inheritance diagram for FOptimizationThread:

Public Member Functions
	FOptimizationThread (UWorld *World, class FOptimizationManager *InManager)
virtual uint32	Run () override
virtual void	Exit () override
virtual void	AddReferencedObjects (FReferenceCollector &Collector) override
virtual FString	GetReferencerName () const override
void	RegisterComponent (UOptimizationProxyComponent *Component)
void	UnregisterComponent (const UOptimizationProxyComponent *Component)
void	HandlePostGarbageCollect ()

Protected Attributes
TArray< TObjectPtr< UOptimizationProxyComponent > >	Components
FCriticalSection	Mutex
FCriticalSection	ProxyMutex
TUniquePtr< FRunnableThread >	Thread
FThreadSafeBool	bIsRunning = true
TObjectPtr< UWorld >	GameWorld = nullptr
TObjectPtr< FOptimizationManager >	Manager = nullptr

Private Member Functions
void	RemoveComponentByHandle (int32 Handle)

Static Private Member Functions
static EOptimizationWave	GetOptimizationWave (const APawn *LocalPlayer, const APlayerCameraManager *Camera, IOptimizationProxy *Proxy, bool IsVisible)
static bool	IsInCameraSight (const APlayerCameraManager *Camera, const APawn *LocalPlayer, IOptimizationProxy *Proxy, float InFOV)

Constructor & Destructor Documentation

FOptimizationThread()

FOptimizationThread::FOptimizationThread	(	UWorld *	World,
		class FOptimizationManager *	InManager )

                                                                                       : bIsRunning(true), GameWorld(World), Manager(InManager)
{
    if (IsValid(GameWorld) /*&& GameWorld->GetNetMode() != NM_DedicatedServer*/)
    {
        Thread.Reset(FRunnableThread::Create(this, *FString::Printf(TEXT("NPC_Optimizator_Thread_%s"), *GameWorld->GetName())));
    }
}

Member Function Documentation

AddReferencedObjects()

void FOptimizationThread::AddReferencedObjects ( FReferenceCollector & Collector )

overridevirtual

{
    Collector.AddReferencedObject(GameWorld);
 
    for (auto& it : Components)
    {
        Collector.AddReferencedObject(it);
    }
}

Exit()

void FOptimizationThread::Exit ( )

overridevirtual

{
    Manager = nullptr;
    bIsRunning = false;
}

GetOptimizationWave()

EOptimizationWave FOptimizationThread::GetOptimizationWave ( const APawn * LocalPlayer, const APlayerCameraManager * Camera, IOptimizationProxy * Proxy, bool IsVisible )

staticprivate

{
    if (!IsVisible && !Proxy->IsIgnoreCameraSightOnSmallDistance())
    {
        return EOptimizationWave::Invisible;
    }
 
    float DistToPlayer = 10000.f;
 
    if (LocalPlayer)
    {
        DistToPlayer = FVector::Distance(LocalPlayer->GetActorLocation(), Proxy->GetOwnerActor()->GetActorLocation());
    }
 
    if (Camera && Proxy->GetOptimizationBasedType() == EOptimizationBaseType::PlayerCamera)
    {
        const FVector CameraLocation = Camera->GetCameraLocation();
        DistToPlayer = FVector::Distance(CameraLocation, Proxy->GetOwnerActor()->GetActorLocation());
    }
 
    if (!IsVisible && Proxy->IsIgnoreCameraSightOnSmallDistance() )
    {
        if (DistToPlayer < Proxy->GetDistToWave(EOptimizationWave::FirstWave))
        {
            return EOptimizationWave::NoOptimization;
        }
        else
        {
            return EOptimizationWave::Invisible;
        }
    }
 
    if (DistToPlayer < Proxy->GetDistToWave(EOptimizationWave::FirstWave))
    {
        return EOptimizationWave::NoOptimization;
    }
    else if (DistToPlayer >= Proxy->GetDistToWave(EOptimizationWave::FirstWave) && DistToPlayer < Proxy->GetDistToWave(EOptimizationWave::SecondWave))
    {
        return EOptimizationWave::FirstWave;
    }
    else if (DistToPlayer >= Proxy->GetDistToWave(EOptimizationWave::SecondWave) && DistToPlayer < Proxy->GetDistToWave(EOptimizationWave::ThirdWave))
    {
        return EOptimizationWave::SecondWave;
    }
    else if (DistToPlayer >= Proxy->GetDistToWave(EOptimizationWave::ThirdWave) && DistToPlayer < Proxy->GetMaxVisibleDistance())
    {
        return EOptimizationWave::ThirdWave;
    }
 
    return EOptimizationWave::Invisible;
}

GetReferencerName()

FString FOptimizationThread::GetReferencerName ( ) const

overridevirtual

{
    return TEXT("FOptimizationThread");
}

HandlePostGarbageCollect()

void FOptimizationThread::HandlePostGarbageCollect

(

)

{
    Mutex.Lock();
    {
        bool bRemoved;
        do
        {
            bRemoved = false;
            for (int32 DataIndex = 0; DataIndex < Components.Num(); ++DataIndex)
            {
                if (!IsValid(Components[DataIndex]))
                {
                    RemoveComponentByHandle(DataIndex);
                    bRemoved = true;
                }
            }
        } while (bRemoved);
    }
    Mutex.Unlock();
}

IsInCameraSight()

bool FOptimizationThread::IsInCameraSight ( const APlayerCameraManager * Camera, const APawn * LocalPlayer, IOptimizationProxy * Proxy, float InFOV )

staticprivate

{
    if (IsValid(Camera) && Proxy != nullptr)
    {
        float Distance = 10000.f;
 
        if (Proxy->GetOptimizationBasedType() == EOptimizationBaseType::PlayerCamera)
        {
            const FVector CameraLocation = Camera->GetCameraLocation();
 
            Distance = FVector::Distance(CameraLocation, Proxy->GetOwnerActor()->GetActorLocation());
        }
        else if (Proxy->GetOptimizationBasedType() == EOptimizationBaseType::PlayerPawn && LocalPlayer)
        {
            Distance = FVector::Distance(LocalPlayer->GetActorLocation(), Proxy->GetOwnerActor()->GetActorLocation());
        }
 
        const float CameraDotProd = Camera->GetDotProductTo(Proxy->GetOwnerActor());
        const float CamAngle = 1.f - (InFOV * 0.01f);
 
        if (CameraDotProd < CamAngle || Distance > Proxy->GetMaxVisibleDistance())
        {
            return false;
        }
        
        return true;
    }
 
    return true;
}

RegisterComponent()

void FOptimizationThread::RegisterComponent

(

UOptimizationProxyComponent *

Component

)

{
    Mutex.Lock();
    {
        check(Component);
 
        if (Component->GetOptimizationHandle() == INDEX_NONE)
        {
            Component->SetOptimizationHandle(Components.Num());
 
            Components.Add(Component);
        }
    } 
    Mutex.Unlock();
}

RemoveComponentByHandle()

void FOptimizationThread::RemoveComponentByHandle ( int32 Handle )

private

{
    if (Components.IsValidIndex(Handle))
    {
        if (IsValid(Components[Handle]))
        {
            Components[Handle]->SetOptimizationHandle(INDEX_NONE);
        }
 
        Components.RemoveAtSwap(Handle, 1, false);
 
        const int32 NumRemaining = Components.Num();
        if (NumRemaining > 0 && Handle != NumRemaining)
        {
            if (IsValid(Components[Handle]))
            {
                Components[Handle]->SetOptimizationHandle(Handle);
            }
        }
    }
}

Run()

uint32 FOptimizationThread::Run ( )

overridevirtual

{
    while (bIsRunning)
    {
        SCOPE_CYCLE_COUNTER(STAT_OptimizationThreadTick);
        if(GameWorld == nullptr){return 0;}
        APlayerCameraManager* PlayerCamera = UGameplayStatics::GetPlayerCameraManager(GameWorld, 0);
        APlayerController* PlayerController = UGameplayStatics::GetPlayerController(GameWorld, 0);
        APawn* PlayerPawn = PlayerController ? PlayerController->GetPawn() : nullptr;
 
        SET_DWORD_STAT(STAT_NPC_Count, 0);
        SET_DWORD_STAT(STAT_InvisibleCount, 0);
        SET_DWORD_STAT(STAT_NoOptimizedCount, 0);
        SET_DWORD_STAT(Stat_FirstWaveCount, 0);
        SET_DWORD_STAT(Stat_SecondWaveCount, 0);
        SET_DWORD_STAT(Stat_ThirdWaveCount, 0);
 
        const float FOV = CVarMaxFOV.GetValueOnAnyThread();
 
        // Calculate visible & optimization waves for proxy components
        Mutex.Lock();
        {
            SCOPE_CYCLE_COUNTER(STAT_OptimizationComponentsTick);
 
            const uint32 MaxOptimizedInOneFrame = CVarMaxOptimizationOnOneFrame.GetValueOnAnyThread();
            uint32 OptimizedCount = 0;
 
            for (auto& it : Components)
            {
                if (!IsValid(it))
                    continue;
 
                const EOptimizationWave CurrentWave = it->GetOptimizationWave();
 
                INC_DWORD_STAT(STAT_NPC_Count);
 
                // Stats counters
                {
                    switch (CurrentWave)
                    {
                    case EOptimizationWave::Invisible:
                        INC_DWORD_STAT(STAT_InvisibleCount);
                        break;
                    case EOptimizationWave::NoOptimization:
                        INC_DWORD_STAT(STAT_NoOptimizedCount);
                        break;
                    case EOptimizationWave::FirstWave:
                        INC_DWORD_STAT(Stat_FirstWaveCount);
                        break;
                    case EOptimizationWave::SecondWave:
                        INC_DWORD_STAT(Stat_SecondWaveCount);
                        break;
                    case EOptimizationWave::ThirdWave:
                        INC_DWORD_STAT(Stat_ThirdWaveCount);
                        break;
                    }
                }
 
                if (it->IsNeedToBeOptimized())
                    continue;
 
                if (OptimizedCount >= MaxOptimizedInOneFrame)
                    break;
 
                const bool IsVisible = it->IgnoreCameraSight ? true : IsInCameraSight(PlayerCamera, PlayerPawn, it, FOV);
                const EOptimizationWave NewWave = GetOptimizationWave(PlayerPawn, PlayerCamera, it, IsVisible);
 
                if (CurrentWave != NewWave && !it->IsForceOptimizationWaveEnabled())
                {
                    it->SetOptimizationWave(NewWave);
                    it->SetIsNeedToBeOptimized(true);
 
                    OptimizedCount++;
                }
            }
        }
        Mutex.Unlock();
        
        FPlatformProcess::Sleep(0.01f);
    }
 
    return 0;
}

UnregisterComponent()

void FOptimizationThread::UnregisterComponent

(

const UOptimizationProxyComponent *

Component

)

{
    Mutex.Lock();
    {
        check(Component);
 
        const int32 Handle = Component->GetOptimizationHandle();
        if (Handle != INDEX_NONE)
        {
            RemoveComponentByHandle(Handle);
        }
    }
    Mutex.Unlock();
}

Member Data Documentation

bIsRunning

FThreadSafeBool FOptimizationThread::bIsRunning = true

protected

Components

TArray<TObjectPtr<UOptimizationProxyComponent> > FOptimizationThread::Components

protected

GameWorld

TObjectPtr<UWorld> FOptimizationThread::GameWorld = nullptr

protected

Manager

TObjectPtr<FOptimizationManager> FOptimizationThread::Manager = nullptr

protected

Mutex

FCriticalSection FOptimizationThread::Mutex

mutableprotected

ProxyMutex

FCriticalSection FOptimizationThread::ProxyMutex

mutableprotected

Thread

TUniquePtr<FRunnableThread> FOptimizationThread::Thread

protected

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/NPCOptimizator/Source/NPC_Optimizator/Public/OptimizationManager.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/NPCOptimizator/Source/NPC_Optimizator/Private/OptimizationManager.cpp