UnrealEngine.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    UnrealEngine.h: Unreal engine helper definitions.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "RenderCommandFence.h"
#include "GenericPlatform/GenericWindow.h"
#include "Engine/Engine.h"
#include "SceneTypes.h"
 
class FViewportClient;
class UFont;
class ULocalPlayer;
 
extern ENGINE_API int32 GShowMaterialDrawEvents;
extern ENGINE_API int32 GDoAsyncLoadingWhileWaitingForVSync;
 
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogEngine, Log, All);
//
//  FLocalPlayerIterator - Iterates over local players in the game.
//  There are no advantages to using this over GEngine->GetLocalPlayerIterator(GetWorld());
//  
//  Example:
//  for (FLocalPlayerIterator It(GEngine, GetWorld()); It; ++It)
//  {
//          // Do Stuff
//  }   
//
 
 
class FLocalPlayerIterator
{
protected:
    TArray<class ULocalPlayer*>::TConstIterator Iter;
 
    void GetCurrent()
    {       
        // advance iter while not finished iterating, and while current elemnt in NULL
        while( Iter && *Iter == NULL )
            ++Iter;
    }
 
public:
    FLocalPlayerIterator(UEngine* InEngine, class UWorld* InWorld)
        : Iter(InEngine->GetLocalPlayerIterator(InWorld))
    {
        GetCurrent();
    }
 
    void operator++()
    {
        ++Iter;
        GetCurrent();
    }
    ULocalPlayer* operator*() const
    {
        return *Iter;
    }
    ULocalPlayer* operator->() const
    {
        return *Iter;
    }
    explicit operator bool() const
    {
        return (bool)Iter;
    }
};
 
//  PlayerControllerIterators
//  This is the safest, most efficient way to iterate over player controllers.
//
//  Examples:
//
//  for (TPlayerControllerIterator<AQAPlayerController>::LocalOnly It(GetWorld()); It; ++It)
//  {
//      // PC is a locally controlled AQAPlayerController.
//      AQAPlayerController * PC = *It; 
//
//      // This PC will always be locally controlled!
//      check(PC->IsLocalController();
//  }
//
//
//
//
//  for (TPlayerControllerIterator<AQAPlayerController>::ServerAll It(GetWorld()); It; ++It)
//  {
//      // PC is a AQAPlayerController. It may local or remotely controlled.
//      AQAPlayerController * PC = *It; 
//  
//      // This can only be done on the server! 
//      // Only the server has player controllers for everyone!
//      check(GetWorld()->GetNetMode() != NM_Client);
//  }
 
 
 
template< class T, bool LocalOnly > class TBasePlayerControllerIterator
{
public:
    TBasePlayerControllerIterator(class UWorld* InWorld)
        : Iter(InWorld->GetPlayerControllerIterator())
    {
        check(LocalOnly || InWorld->GetNetMode() != NM_Client); // You should only iterate on non local player controllers if you are the server
        AdvanceCurrent();
    }
 
    void operator++()
    {
        Next();
    }
    T* operator*() const
    {
        return Current;
    }
    T* operator->() const
    {
        return Current;
    }
    explicit operator bool() const
    {
        return (Current!=NULL);
    }
 
protected:
 
    FConstPlayerControllerIterator Iter;
    T* Current;
 
    void AdvanceCurrent()
    {
        // Look at current Iter
        Current = Iter ? Cast<T>(*Iter) : nullptr;
 
        // Advance if we have to
        while(Iter && (!Current || (LocalOnly && !Current->IsLocalController())))
        {
            ++Iter;
            Current = Iter ? Cast<T>(*Iter) : nullptr;
        }
    }
 
    void Next()
    {
        // Advance one
        ++Iter;
 
        // Update Current
        AdvanceCurrent();
    }
};
 
template<class T>
struct TPlayerControllerIterator
{
    typedef TBasePlayerControllerIterator<T, true>  LocalOnly;  // Only iterates locally controlled player controllers - can be used on client or server
    typedef TBasePlayerControllerIterator<T, false> ServerAll;  // Iterates all player controllers - local or remote - only can be used on server
};
 
 
/*-----------------------------------------------------------------------------
    Tick/ update stats helper for profiling.
-----------------------------------------------------------------------------*/
 
struct FTickStats
{
    FString ObjectPathName;
    FString ObjectDetailedInfo;
    FName ObjectClassFName;
    int32 GCIndex;
    float TotalTime;
    int32 Count;
    bool bForSummary;
 
    inline bool operator()( const FTickStats& A, const FTickStats& B    ) const
    {
        return (B.TotalTime < A.TotalTime);
    }
};
 
struct FDetailedTickStats
{
    FDetailedTickStats( int32 InNumClassesToReport, float InTimeBetweenLogDumps, float InMinTimeBetweenLogDumps, float InTimesToReport, const TCHAR* InOperationPerformed );
 
    virtual ~FDetailedTickStats();
 
    bool BeginObject( UObject* Object );
 
    void EndObject( UObject* Object, float DeltaTime, bool bForSummary );
 
    void Reset();
 
    void DumpStats();
 
    void OnPreGarbageCollect()
    {
        GCIndex++;
        check(ObjectsInFlight.Num() == 0); // probably not required, but we shouldn't have anything in flight when we GC
    }
 
private:
    TArray<FTickStats> AllStats;
    TMap<const UObject*,int32> ObjectToStatsMap;
    TSet<const UObject*> ObjectsInFlight;
 
    int32 GCIndex;
    bool GCCallBackRegistered;
    int32   NumObjectsToReport;
    float TimeBetweenLogDumps;
    float MinTimeBetweenLogDumps;
    double LastTimeOfLogDump;
    float TimesToReport;
    FString OperationPerformed;
    FDelegateHandle OnPreGarbageCollectDelegateHandle;
};
 
struct FScopedDetailTickStats
{
    FScopedDetailTickStats( FDetailedTickStats& InDetailedTickStats, UObject* ObjectToTrack );
 
    ~FScopedDetailTickStats();
 
 
private:
    FDetailedTickStats& DetailedTickStats;
    UObject* Object;
    uint32 StartCycles;
    bool bShouldTrackObject;
    bool bShouldTrackObjectClass;
};
 
 
DECLARE_DELEGATE_TwoParams( FOnSwitchWorldForPIE, bool, UWorld* );
 
#if WITH_EDITOR
class FScopedConditionalWorldSwitcher
{
public:
    ENGINE_API FScopedConditionalWorldSwitcher( class FViewportClient* InViewportClient );
 
    ENGINE_API FScopedConditionalWorldSwitcher( UWorld* InWorld );
 
    ENGINE_API ~FScopedConditionalWorldSwitcher();
 
    static ENGINE_API FOnSwitchWorldForPIE SwitchWorldForPIEDelegate;
private:
    void ConditionalSwitchWorld( class FViewportClient* InViewportClient, UWorld* InWorld );
 
    FViewportClient* ViewportClient;
 
    UWorld* OldWorld;
};
#else
// does nothing outside of the editor
class FScopedConditionalWorldSwitcher
{
public:
    FScopedConditionalWorldSwitcher( class FViewportClient* InViewportClient ) {}
    FScopedConditionalWorldSwitcher( UWorld* InWorld ) {}
    ~FScopedConditionalWorldSwitcher() {}
};
 
#endif
 
ENGINE_API FString appGetStartupMap(const TCHAR* CommandLine);
 
// Calculate the average frame time by using the stats system.
ENGINE_API void CalculateFPSTimings();
 
 
extern ENGINE_API UFont* GetStatsFont();
 
/*-----------------------------------------------------------------------------
    Frame end sync object implementation.
-----------------------------------------------------------------------------*/
 
namespace FFrameEndSync
{
    UE_DEPRECATED(5.6, "Use FFrameEndSync::Sync defined in RenderingThread.h, which takes an enum.")
    ENGINE_API void Sync(bool bFullSync = false);
};
 
class IEngineLoop
{
public:
 
    virtual int32 Init() = 0;
 
    virtual void Tick() = 0;
 
    virtual void ClearPendingCleanupObjects() = 0;
};
 
struct FCachedSystemScalabilityCVars
{
    bool bInitialized;
    int32 DetailMode;
    int32 CookOutUnusedDetailModeComponents;
    EMaterialQualityLevel::Type MaterialQualityLevel;
    int32 MaxShadowResolution;
    int32 MaxCSMShadowResolution;
    float ViewDistanceScale;
    float ViewDistanceScaleSquared;
    int32 FieldOfViewAffectsHLOD;
    float StaticMeshLODDistanceScale;
    float SkeletalMeshOverlayDistanceScale;
 
    float CalculateFieldOfViewDistanceScale(const float FieldOfView) const
    {
        if (!FMath::IsNearlyEqual(FieldOfViewMaxAngleScale, FieldOfViewMinAngleScale))
        {
            float ClampedFoV = FMath::Clamp(FieldOfView, FieldOfViewMinAngle, FieldOfViewMaxAngle);
            ClampedFoV = (ClampedFoV - FieldOfViewMinAngle) / (FieldOfViewMaxAngle - FieldOfViewMinAngle);
            return FMath::Lerp<float>(FieldOfViewMinAngleScale, FieldOfViewMaxAngleScale, ClampedFoV);
        }
        
        return FieldOfViewMaxAngleScale;
    }
 
    FCachedSystemScalabilityCVars();
 
    bool operator==(const FCachedSystemScalabilityCVars& Other) const;
 
protected:
    // This isn't public as it's only used to detect the change. Use ComputeAnisotropyRT()
    int32 MaxAnisotropy;
 
    // Scaling view distance with active camera field of view
    float FieldOfViewMinAngle;
    float FieldOfViewMinAngleScale;
    float FieldOfViewMaxAngle;
    float FieldOfViewMaxAngleScale;
 
    friend void ScalabilityCVarsSinkCallback();
};
 
ENGINE_API bool AllowHighQualityLightmaps(const FStaticFeatureLevel FeatureLevel);
 
ENGINE_API const FCachedSystemScalabilityCVars& GetCachedScalabilityCVars();
 
struct FSystemResolution
{
    int32 ResX;
    int32 ResY;
    EWindowMode::Type WindowMode;
    bool bForceRefresh;
 
    // Helper function for changing system resolution via the r.setres console command
    // This function will set r.setres, which will trigger a resolution change later on
    // when the console variable sinks are called
    static ENGINE_API void RequestResolutionChange(int32 InResX, int32 InResY, EWindowMode::Type InWindowMode);
 
    FSystemResolution()
        : ResX(0)
        , ResY(0)
        , WindowMode(EWindowMode::Windowed)
        , bForceRefresh(false)
    {
 
    }
 
    void ForceRefresh()
    {
        RequestResolutionChange(ResX, ResY, WindowMode);
        bForceRefresh = true;
    }
};
 
ENGINE_API extern FSystemResolution GSystemResolution;
ENGINE_API extern int32 GUnbuiltHLODCount;
 
#ifndef UE_ENABLE_LOG_STACK_ON_FORCE_GC
#define UE_ENABLE_LOG_STACK_ON_FORCE_GC 0
#endif
#if UE_ENABLE_LOG_STACK_ON_FORCE_GC
ENGINE_API extern bool GLogStackOnForceGC;
#endif
 
// Update the debugging aid GPlayInEditorContextString based on the current world context (does nothing in WITH_EDITOR=0 builds)
ENGINE_API void UpdatePlayInEditorWorldDebugString(const FWorldContext* WorldContext);
 
// Returns the Debug string for a given world (Standalone, Listen Server, Client #, etc)
ENGINE_API FString GetDebugStringForWorld(const UWorld* World);
 
// Used to temporarily override GPlayInEditorID, correctly updating the debug string and other state as necessary
struct FTemporaryPlayInEditorIDOverride
{
public:
    ENGINE_API FTemporaryPlayInEditorIDOverride(int32 NewOverrideID);
    ENGINE_API ~FTemporaryPlayInEditorIDOverride();
 
private:
    int32 PreviousID;
 
    void SetID(int32 NewID);
};