App.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "CoreGlobals.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "HAL/PlatformCrt.h"
#include "HAL/PlatformMisc.h"
#include "HAL/PlatformProcess.h"
#include "Misc/Build.h"
#include "Misc/CString.h"
#include "Misc/CommandLine.h"
#include "Misc/CoreMisc.h"
#include "Misc/FrameRate.h"
#include "Misc/Guid.h"
#include "Misc/Optional.h"
#include "Misc/Parse.h"
#include "Misc/QualifiedFrameTime.h"
#include "Misc/Timecode.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
 
#include <atomic>
#include <optional>
 
class FCbObjectId;
 
class FApp
{
public:
 
    static CORE_API FString GetBranchName();
 
    static CORE_API EBuildConfiguration GetBuildConfiguration();
 
    static CORE_API EBuildTargetType GetBuildTargetType();
 
#if UE_BUILD_DEVELOPMENT
    static CORE_API void SetDebugGame(bool bIsDebugGame);
#endif
 
    /*
    * Gets the unique version string for this build. This string is not assumed to have any particular format other being a unique identifier for the build.
    *
    * @return The build version
    */
    static CORE_API const TCHAR* GetBuildVersion();
    
    /* 
     * Gets the URL for a job which created these binaries. 
     * This may not be accessible if you are not part of the organization that created this build. 
     * May be overridden with FCoreDelegates::OnGetBuildURL
     */
    static CORE_API const TCHAR* GetBuildURL();
 
    /* 
     * Gets the URL for the currently running Horde job/step if any. 
     * May be overridden with FCoreDelegates::OnGetExecutingJobURL
     */ 
    static CORE_API const TCHAR* GetExecutingJobURL();
 
    /* Returns whether the binaries were built with debug info */
    static CORE_API bool GetIsWithDebugInfo();
 
    static CORE_API FString GetBuildDate();
 
    static CORE_API FString GetGraphicsRHI();
 
    static CORE_API void SetGraphicsRHI(FString RHIString);
 
 
    static CORE_API int32 GetEngineIsPromotedBuild();
 
    static CORE_API FString GetEpicProductIdentifier();
 
    FORCEINLINE static const TCHAR* GetProjectName()
    {
        return GInternalProjectName;
    }
 
    static FString GetName()
    {
        FString ExecutableName = FPlatformProcess::ExecutableName();
 
        int32 ChopIndex = ExecutableName.Find(TEXT("-"));
 
        if (ExecutableName.FindChar(TCHAR('-'), ChopIndex))
        {
            return ExecutableName.Left(ChopIndex);
        }
 
        if (ExecutableName.FindChar(TCHAR('.'), ChopIndex))
        {
            return ExecutableName.Left(ChopIndex);
        }
 
        return ExecutableName;
    }
 
    FORCEINLINE static bool HasProjectName()
    {
        return (IsProjectNameEmpty() == false) && (FCString::Stricmp(GInternalProjectName, TEXT("None")) != 0);
    }
 
    FORCEINLINE static bool IsGame()
    {
#if WITH_EDITOR
        return !GIsEditor || GIsPlayInEditorWorld || IsRunningGame();
#else
        return true;
#endif
    }
 
    FORCEINLINE static bool IsProjectNameEmpty()
    {
        return (GInternalProjectName[0] == 0);
    }
 
    FORCEINLINE static void SetProjectName(const TCHAR* InProjectName)
    {
        // At the moment Strcpy is not safe as we don't check the buffer size on all platforms, so we use strncpy here.
        FCString::Strncpy(GInternalProjectName, InProjectName, UE_ARRAY_COUNT(GInternalProjectName));
        // And make sure the ProjectName string is null terminated.
        GInternalProjectName[UE_ARRAY_COUNT(GInternalProjectName) - 1] = TEXT('\0');
    }
 
public:
 
    FORCEINLINE static void AuthorizeUser(const FString& UserName)
    {
        SessionUsers.AddUnique(UserName);
    }
 
    FORCEINLINE static void DenyAllUsers()
    {
        SessionUsers.Empty();
    }
 
    FORCEINLINE static void DenyUser(const FString& UserName)
    {
        SessionUsers.Remove(UserName);
    }
 
    static CORE_API FString GetZenStoreProjectId(FStringView SubProject = FStringView());
 
#if PLATFORM_DESKTOP
    static CORE_API FString GetZenStoreProjectIdForProject(FStringView ProjectFilePath, FStringView SubProject = FStringView());
#endif
 
    static CORE_API FGuid GetInstanceId();
 
    static FString GetInstanceName()
    {
        return FString::Printf(TEXT("%s-%i"), FPlatformProcess::ComputerName(), FPlatformProcess::GetCurrentProcessId());
    }
 
    FORCEINLINE static FGuid GetSessionId()
    {
        return SessionId;
    }
 
    static CORE_API const FCbObjectId& GetSessionObjectId();
 
    FORCEINLINE static FString GetSessionName()
    {
        return SessionName;
    }
 
    FORCEINLINE static FString GetSessionOwner()
    {
        return SessionOwner;
    }
 
    static CORE_API void InitializeSession();
 
    FORCEINLINE static bool IsAuthorizedUser(const FString& UserName)
    {
        return ((FPlatformProcess::UserName(false) == UserName) || (SessionOwner == UserName) || SessionUsers.Contains(UserName));
    }
 
    FORCEINLINE static bool IsStandalone()
    {
        return Standalone;
    }
 
    FORCEINLINE static bool IsThisInstance(const FGuid& InInstanceId)
    {
        return (InInstanceId == GetInstanceId());
    };
 
    FORCEINLINE static void SetSessionName(const FString& NewName)
    {
        SessionName = NewName;
    }
 
    FORCEINLINE static void SetSessionOwner(const FString& NewOwner)
    {
        SessionOwner = NewOwner;
    }
 
public:
 
// MSVC 16.4 (1924) has a bug that does not properly handle the local static bool in CanEverRender. This will be fixed in 16.5. Working around by using FORCENOINLINE.
// MSVC 16.6 (1926) fixes the problem so inlning can be enabled again from that point onwards.
#if !UE_SERVER && defined(_MSC_VER) && _MSC_VER >= 1924 && _MSC_VER <= 1925
#define INLINE_CANEVERRENDER FORCENOINLINE
#else
#define INLINE_CANEVERRENDER FORCEINLINE
#endif
 
    INLINE_CANEVERRENDER static bool CanEverRender()
    {
#if UE_SERVER
        return false;
#else
        static bool bHasNullRHIOnCommandline = FParse::Param(FCommandLine::Get(), TEXT("nullrhi"));
        return (!IsRunningCommandlet() || IsAllowCommandletRendering()) && !IsRunningDedicatedServer() && !(USE_NULL_RHI || bHasNullRHIOnCommandline);
#endif // UE_SERVER
    }
 
    INLINE_CANEVERRENDER static bool CanEverRenderOrProduceRenderData()
    {
        return !FPlatformProperties::RequiresCookedData() || FApp::CanEverRender();
    }
 
    INLINE_CANEVERRENDER static bool CanEverRenderAudio()
    {
#if UE_SERVER
        return false;
#else
        static bool bHasNoAudioOnCommandline = FParse::Param(FCommandLine::Get(), TEXT("nosound")) && !FParse::Param(FCommandLine::Get(), TEXT("enablesound"));
        static bool bApplicationTypeDoesNotRenderAudio = FApp::IsBenchmarking() || IsRunningDedicatedServer() || (IsRunningCommandlet() && !IsAllowCommandletAudio());
        return !bApplicationTypeDoesNotRenderAudio && !bHasNoAudioOnCommandline;
#endif // UE_SERVER
    }
 
    INLINE_CANEVERRENDER static bool IsAudioMuted()
    {
        static bool bMuteAudio = FParse::Param(FCommandLine::Get(), TEXT("muteaudio"));
        return bMuteAudio;
    }
 
    static CORE_API bool IsInstalled();
 
    static CORE_API bool IsEngineInstalled();
 
    static CORE_API bool IsUnattended();
 
    static CORE_API bool AllowUnattendedInput();
 
    static CORE_API bool ShouldUseThreadingForPerformance();
 
    static CORE_API bool IsMultithreadServer();
 
    FORCEINLINE static bool IsBenchmarking()
    {
        return bIsBenchmarking;
    }
 
    static void SetBenchmarking(bool bVal)
    {
        bIsBenchmarking = bVal;
    }
 
    FORCEINLINE static double GetFixedDeltaTime()
    {
        return FixedDeltaTime.load(std::memory_order_relaxed);
    }
 
    static void SetFixedDeltaTime(double Seconds)
    {
        FixedDeltaTime.store(Seconds, std::memory_order_relaxed);
    }
 
    static bool UseFixedTimeStep()
    {
#if WITH_FIXED_TIME_STEP_SUPPORT
        return bUseFixedTimeStep;
#else
        return false;
#endif
    }
 
    static void SetUseFixedTimeStep(bool bVal)
    {
        bUseFixedTimeStep = bVal;
    }
 
    FORCEINLINE static double GetCurrentTime()
    {
        return CurrentTime.load(std::memory_order_relaxed);
    }
 
    static void SetCurrentTime(double Seconds)
    {
        CurrentTime.store(Seconds, std::memory_order_relaxed);
    }
 
    FORCEINLINE static double GetLastTime()
    {
        return LastTime.load(std::memory_order_relaxed);
    }
 
    static void UpdateLastTime()
    {
        // Not an atomic operation, but preferred to a compare and swap
        LastTime.store(CurrentTime.load(std::memory_order_relaxed), std::memory_order_relaxed);
    }
 
    FORCEINLINE static double GetDeltaTime()
    {
        return DeltaTime.load(std::memory_order_relaxed);
    }
 
    static void SetDeltaTime(double Seconds)
    {
        DeltaTime.store(Seconds, std::memory_order_relaxed);
    }
 
    FORCEINLINE static double GetIdleTime()
    {
        return IdleTime.load(std::memory_order_relaxed);
    }
 
    static void SetIdleTime(double Seconds)
    {
        IdleTime.store(Seconds, std::memory_order_relaxed);
    }
 
    FORCEINLINE static double GetGameTime()
    {
        return GameTime.load(std::memory_order_relaxed);
    }
 
    static void SetGameTime(double Seconds)
    {
        GameTime.store(Seconds, std::memory_order_relaxed);
    }
 
    FORCEINLINE static double GetIdleTimeOvershoot()
    {
        return IdleTimeOvershoot.load(std::memory_order_relaxed);
    }
 
    static void SetIdleTimeOvershoot(double Seconds)
    {
        IdleTimeOvershoot.store(Seconds, std::memory_order_relaxed);
    }
 
    static CORE_API FTimecode GetTimecode();
 
    static CORE_API FFrameRate GetTimecodeFrameRate();
 
    FORCEINLINE static TOptional<FQualifiedFrameTime> GetCurrentFrameTime()
    {
        return CurrentFrameTime;
    }
 
    UE_DEPRECATED(4.25, "Please use SetQualifiedFrameTime")
    static void SetTimecodeAndFrameRate(FTimecode InTimecode, FFrameRate InTimecodeFrameRate)
    {
        CurrentFrameTime = FQualifiedFrameTime(InTimecode, InTimecodeFrameRate);
    }
 
    static void SetCurrentFrameTime(FQualifiedFrameTime InFrameTime)
    {
        CurrentFrameTime = InFrameTime;
    }
 
    static void InvalidateCurrentFrameTime()
    {
        CurrentFrameTime.Reset();
    }
 
    FORCEINLINE static float GetVolumeMultiplier()
    {
        return VolumeMultiplier;
    }
 
    FORCEINLINE static void SetVolumeMultiplier(float InVolumeMultiplier)
    {
        VolumeMultiplier = InVolumeMultiplier;
    }
 
    static CORE_API float GetUnfocusedVolumeMultiplier();
 
    static CORE_API void SetUnfocusedVolumeMultiplier(float InVolumeMultiplier);
 
    static CORE_API void SetUseVRFocus(bool bInUseVRFocus);
 
    FORCEINLINE static bool UseVRFocus()
    {
        return bUseVRFocus;
    }
    static CORE_API void SetHasVRFocus(bool bInHasVRFocus);
 
    FORCEINLINE static bool HasVRFocus()
    {
        return bHasVRFocus;
    }
    
    static CORE_API void SetHasFocusFunction(bool (*InHasFocusFunction)());
 
    static CORE_API bool HasFocus();
 
    /* If the random seed started with a constant or on time, can be affected by -FIXEDSEED or -BENCHMARK */
    static CORE_API bool bUseFixedSeed;
 
    /* Print all initial startup logging */
    static CORE_API void PrintStartupLogMessages();
 
private:
 
#if UE_BUILD_DEVELOPMENT
    static CORE_API bool bIsDebugGame;
#endif
 
    static CORE_API FGuid SessionId;
 
    static CORE_API FString SessionName;
 
    static CORE_API FString SessionOwner;
 
    static CORE_API FString GraphicsRHI;
 
    static CORE_API TArray<FString> SessionUsers;
 
    static CORE_API bool Standalone;
 
    static CORE_API bool bIsBenchmarking;
 
    static CORE_API bool bUseFixedTimeStep;
 
    static CORE_API std::atomic<double> FixedDeltaTime;
 
    static CORE_API std::atomic<double> CurrentTime;
 
    static CORE_API std::atomic<double> LastTime;
 
    static CORE_API std::atomic<double> DeltaTime;
 
    static CORE_API std::atomic<double> IdleTime;
 
    static CORE_API std::atomic<double> IdleTimeOvershoot;
 
    static CORE_API std::atomic<double> GameTime;
 
    static CORE_API TOptional<FQualifiedFrameTime> CurrentFrameTime;
 
    static CORE_API float VolumeMultiplier;
 
    static CORE_API float UnfocusedVolumeMultiplier;
 
    static CORE_API bool bUseVRFocus;
 
    static CORE_API bool bHasVRFocus;
 
    static CORE_API bool (*HasFocusFunction)();
};
 
 
DECLARE_DELEGATE_RetVal_OneParam(bool, FQueryIsRunningServer, FName);
 
 
CORE_API bool IsServerForOnlineSubsystems(FName WorldContextHandle);
 
CORE_API void SetIsServerForOnlineSubsystemsDelegate(FQueryIsRunningServer NewDelegate);