CoreGlobals.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "HAL/PlatformTLS.h"
#include "Logging/LogMacros.h"
#include "Misc/Build.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/OutputDevice.h"
#include "ProfilingDebugging/CpuProfilerTrace.h"
#include "Templates/Atomic.h"
#include "UObject/NameTypes.h"
 
#include <atomic>
 
class Error;
class FChunkedFixedUObjectArray;
class FConfigCacheIni;
class FExec;
class FFixedUObjectArray;
class FOutputDeviceConsole;
class FOutputDeviceRedirector;
class FRunnableThread;
class FText;
class ITransaction;
class UClass;
 
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogHAL, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogSerialization, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogUnrealMath, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogUnrealMatrix, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogContentComparisonCommandlet, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogNetPackageMap, Warning, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogNetSerialization, Warning, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogMemory, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogProfilingDebugging, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogCore, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogOutputDevice, Log, All);
 
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogSHA, Warning, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogStats, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogStreaming, Display, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogInit, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogExit, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogExec, Warning, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogScript, Warning, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogLocalization, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogLongPackageNames, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogProcess, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogLoad, Log, All);
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogVirtualization, Log, All);
 
// Temporary log category, generally you should not check things in that use this
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogTemp, Log, All);
 
// Platform specific logs, set here to make it easier to use them from anywhere
// need another layer of macro to help using a define in a define
#define DECLARE_LOG_CATEGORY_EXTERN_HELPER(A,B,C) DECLARE_LOG_CATEGORY_EXTERN(A,B,C)
#ifdef PLATFORM_GLOBAL_LOG_CATEGORY
    CORE_API DECLARE_LOG_CATEGORY_EXTERN_HELPER(PLATFORM_GLOBAL_LOG_CATEGORY, Log, All);
#endif
#ifdef PLATFORM_GLOBAL_LOG_CATEGORY_ALT
    CORE_API DECLARE_LOG_CATEGORY_EXTERN_HELPER(PLATFORM_GLOBAL_LOG_CATEGORY_ALT, Log, All);
#endif
 
 
CORE_API FOutputDeviceRedirector* GetGlobalLogSingleton();
 
CORE_API void BootTimingPoint(const ANSICHAR *Message);
 
CORE_API void DumpBootTiming();
 
struct FScopedBootTiming
{
    FString Message;
    double StartTime;
    CORE_API FScopedBootTiming(const ANSICHAR *InMessage);
    CORE_API FScopedBootTiming(const ANSICHAR *InMessage, FName Suffix);
    CORE_API ~FScopedBootTiming();
};
 
struct FEngineTrackedActivityScope
{
    CORE_API FEngineTrackedActivityScope(const TCHAR* Fmt, ...);
    CORE_API FEngineTrackedActivityScope(const FString& Str);
    CORE_API ~FEngineTrackedActivityScope();
};
 
 
#define SCOPED_BOOT_TIMING(x) TRACE_CPUPROFILER_EVENT_SCOPE_STR(x); FScopedBootTiming ANONYMOUS_VARIABLE(BootTiming_)(x);
#define UE_SCOPED_ENGINE_ACTIVITY(Fmt, ...) FEngineTrackedActivityScope ANONYMOUS_VARIABLE(EngineActivity_)(Fmt, ## __VA_ARGS__);
 
 
#define GLog GetGlobalLogSingleton()
extern CORE_API FConfigCacheIni* GConfig;
extern CORE_API ITransaction* GUndo;
extern CORE_API FOutputDeviceConsole* GLogConsole;
CORE_API extern class FOutputDeviceError*           GError;
CORE_API extern class FFeedbackContext*             GWarn;
 
 
extern CORE_API TCHAR GErrorHist[16384];
 
// #crashReport: 2014-08-19 Combine into one, refactor.
extern CORE_API TCHAR GErrorExceptionDescription[4096];
 
struct FCoreTexts
{
    const FText& True;
    const FText& False;
    const FText& Yes;
    const FText& No;
    const FText& None;
 
    static CORE_API const FCoreTexts& Get();
 
    static CORE_API void TearDown();
 
    // Non-copyable
    FCoreTexts(const FCoreTexts&) = delete;
    FCoreTexts& operator=(const FCoreTexts&) = delete;
 
    FCoreTexts(const FText& InTrue, const FText& InFalse, const FText& InYes, const FText& InNo, const FText& InNone)
        : True(InTrue), False(InFalse), Yes(InYes), No(InNo), None(InNone)
    {
    }
};
 
#if !defined(DISABLE_LEGACY_CORE_TEXTS) || DISABLE_LEGACY_CORE_TEXTS == 0
UE_DEPRECATED(4.23, "GTrue has been deprecated in favor of FCoreTexts::Get().True.")
extern CORE_API const FText GTrue;
UE_DEPRECATED(4.23, "GFalse has been deprecated in favor of FCoreTexts::Get().False.")
extern CORE_API const FText GFalse;
UE_DEPRECATED(4.23, "GYes has been deprecated in favor of FCoreTexts::Get().Yes.")
extern CORE_API const FText GYes;
UE_DEPRECATED(4.23, "GNo has been deprecated in favor of FCoreTexts::Get().No.")
extern CORE_API const FText GNo;
UE_DEPRECATED(4.23, "GNone has been deprecated in favor of FCoreTexts::Get().None.")
extern CORE_API const FText GNone;
#endif
 
extern CORE_API bool GIsGameAgnosticExe;
 
extern CORE_API bool GForceLoadEditorOnly;
 
extern CORE_API bool GVerifyObjectReferencesOnly;
 
extern CORE_API bool GFastPathUniqueNameGeneration;
 
extern CORE_API bool GAllowActorScriptExecutionInEditor;
 
extern CORE_API bool GCompilingBlueprint;
 
extern CORE_API bool GIsGCingAfterBlueprintCompile;
 
extern CORE_API bool GIsReconstructingBlueprintInstances;
 
extern CORE_API std::atomic<bool> GIsReinstancing;
 
extern CORE_API void(*GFlushStreamingFunc)(void);
 
struct FUELibraryOverrideSettings
{
    bool bIsEmbedded = false;
 
    void* WindowHandle = nullptr;
 
    int32 WindowWidth = 0;
 
    int32 WindowHeight = 0;
};
 
extern CORE_API FUELibraryOverrideSettings GUELibraryOverrideSettings;
 
extern CORE_API bool GIsRunningUnattendedScript;
 
#if WITH_ENGINE
extern CORE_API bool PRIVATE_GIsRunningCommandlet;
extern CORE_API UClass* PRIVATE_GRunningCommandletClass;
 
extern CORE_API bool PRIVATE_GAllowCommandletRendering;
 
extern CORE_API bool PRIVATE_GAllowCommandletAudio;
#endif
 
#if WITH_EDITORONLY_DATA
 
extern CORE_API bool GIsEditor;
extern CORE_API bool GIsImportingT3D;
extern CORE_API bool GIsTransacting;
 
extern CORE_API bool            GIntraFrameDebuggingGameThread;
extern CORE_API bool            GFirstFrameIntraFrameDebugging;
 
#elif USING_CODE_ANALYSIS
 
// Defined as variables during code analysis to prevent lots of '<constant> && <expr>' warnings
extern CORE_API bool GIsEditor;
extern CORE_API bool GIntraFrameDebuggingGameThread;
extern CORE_API bool GFirstFrameIntraFrameDebugging;
 
#else
 
#define GIsEditor                               false
#define GIntraFrameDebuggingGameThread          false
#define GFirstFrameIntraFrameDebugging          false
 
#endif // WITH_EDITORONLY_DATA
 
#if WITH_EDITOR
extern CORE_API bool PRIVATE_GIsRunningCookCommandlet;
extern CORE_API bool PRIVATE_GIsRunningDLCCookCommandlet;
#endif
 
FORCEINLINE bool IsRunningCommandlet()
{
#if WITH_ENGINE
    return PRIVATE_GIsRunningCommandlet;
#else
    return false;
#endif
}
 
FORCEINLINE bool IsRunningCookCommandlet()
{
#if WITH_EDITOR
    return PRIVATE_GIsRunningCookCommandlet;
#else
    return false;
#endif
}
 
FORCEINLINE bool IsRunningDLCCookCommandlet()
{
#if WITH_EDITOR
    return PRIVATE_GIsRunningDLCCookCommandlet;
#else
    return false;
#endif
}
 
FORCEINLINE UClass* GetRunningCommandletClass()
{
#if WITH_ENGINE
    return PRIVATE_GRunningCommandletClass;
#else
    return nullptr;
#endif
}
 
CORE_API FString GetCommandletNameFromCmdline();
 
FORCEINLINE bool IsAllowCommandletRendering()
{
#if WITH_ENGINE
    return PRIVATE_GAllowCommandletRendering;
#else
    return false;
#endif
}
 
FORCEINLINE bool IsAllowCommandletAudio()
{
#if WITH_ENGINE
    return PRIVATE_GAllowCommandletAudio;
#else
    return false;
#endif
}
 
namespace UE
{
CORE_API int32 GetMultiprocessId();
}
 
namespace UE::Private
{
CORE_API void SetMultiprocessId(int32 MultiprocessId);
struct FScopeDisableRunningCookCommandlet
{
    CORE_API FScopeDisableRunningCookCommandlet();
    CORE_API ~FScopeDisableRunningCookCommandlet();
private:
    bool bPrevious = false;
};
}
 
class FIsDuplicatingClassForReinstancing
{
public:
    CORE_API FIsDuplicatingClassForReinstancing& operator= (bool bOther);
    CORE_API operator bool() const;
};
 
extern CORE_API bool GEdSelectionLock;
extern CORE_API bool GIsClient;
extern CORE_API bool GIsServer;
extern CORE_API TSAN_ATOMIC(bool) GIsCriticalError;
extern CORE_API TSAN_ATOMIC(bool) GIsRunning;
extern CORE_API FIsDuplicatingClassForReinstancing GIsDuplicatingClassForReinstancing;
 
extern CORE_API bool GIsBuildMachine;
 
extern CORE_API bool GIsSilent;
 
extern CORE_API bool GIsSlowTask;
extern CORE_API bool GSlowTaskOccurred;
extern CORE_API bool GIsGuarded;
 
#ifndef UE_SET_REQUEST_EXIT_ON_TICK_ONLY
    #define UE_SET_REQUEST_EXIT_ON_TICK_ONLY 0
#endif
 
extern CORE_API bool IsEngineStartupModuleLoadingComplete();
extern CORE_API void SetEngineStartupModuleLoadingComplete();
 
UE_DEPRECATED(4.24, "Please use IsEngineExitRequested()/RequestEngineExit(const FString&)")
extern CORE_API bool GIsRequestingExit;
 
extern CORE_API void BeginExitIfRequested();
 
FORCEINLINE bool IsEngineExitRequested()
{
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    return GIsRequestingExit;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
}
 
// Request that the engine exit as soon as it can safely do so
// The ReasonString is not optional and should be a useful description of why the engine exit is requested
CORE_API void RequestEngineExit(const TCHAR* ReasonString);
CORE_API void RequestEngineExit(const FString& ReasonString);
 
extern CORE_API bool GAreScreenMessagesEnabled;
extern CORE_API bool GScreenMessagesRestoreState;
 
/* Whether we are dumping screen shots */
extern CORE_API int32 GIsDumpingMovie;
extern CORE_API bool GIsHighResScreenshot;
extern CORE_API uint32 GScreenshotResolutionX;
extern CORE_API uint32 GScreenshotResolutionY;
extern CORE_API uint64 GMakeCacheIDIndex;
 
extern CORE_API FString GEngineIni;
 
extern CORE_API FString GEditorLayoutIni;
extern CORE_API FString GEditorKeyBindingsIni;
extern CORE_API FString GEditorSettingsIni;
 
extern CORE_API FString GEditorIni;
extern CORE_API FString GEditorPerProjectIni;
 
extern CORE_API FString GCompatIni;
extern CORE_API FString GLightmassIni;
extern CORE_API FString GScalabilityIni;
extern CORE_API FString GHardwareIni;
extern CORE_API FString GInputIni;
extern CORE_API FString GGameIni;
extern CORE_API FString GGameUserSettingsIni;
extern CORE_API FString GRuntimeOptionsIni;
extern CORE_API FString GInstallBundleIni;
extern CORE_API FString GDeviceProfilesIni;
extern CORE_API FString GGameplayTagsIni;
 
extern CORE_API float GNearClippingPlane;
extern CORE_API float GNearClippingPlane_RenderThread;
 
extern CORE_API bool GExitPurge;
extern CORE_API TCHAR GInternalProjectName[64];
extern CORE_API const TCHAR* GForeignEngineDir;
 
extern CORE_API FExec* GDebugToolExec;
 
extern CORE_API bool(*IsAsyncLoading)();
 
extern CORE_API void (*SuspendAsyncLoading)();
 
extern CORE_API void (*ResumeAsyncLoading)();
 
extern CORE_API bool (*IsAsyncLoadingSuspended)();
 
extern CORE_API bool(*IsAsyncLoadingMultithreaded)();
 
enum class ELoaderType : uint8
{
    NotInitialized,
    LegacyLoader,
    EditorPackageLoader,
    ZenLoader
};
 
CORE_API const TCHAR* LexToString(ELoaderType Type);
 
extern CORE_API ELoaderType(*GetLoaderType)();
 
extern CORE_API void (*SuspendTextureStreamingRenderTasks)();
 
extern CORE_API void (*ResumeTextureStreamingRenderTasks)();
 
namespace UE
{
    CORE_API bool GetIsEditorLoadingPackage();
    CORE_API void SetIsEditorLoadingPackage(bool InValue);
}
 
extern CORE_API bool GIsCookerLoadingPackage;
 
extern CORE_API bool GIsPlayInEditorWorld;
 
namespace UE
{
    CORE_API int32 GetPlayInEditorID();
    CORE_API void  SetPlayInEditorID(int32 InPlayInEditorID);
}
 
UE_DEPRECATED(4.25, "This variable is no longer set. Use !GEditor->GetPlayInEditorSessionInfo()->OriginalRequestParams.HasPlayWorldPlacement() instead.")
extern CORE_API bool GIsPIEUsingPlayerStart;
 
extern CORE_API bool GPlatformNeedsPowerOfTwoTextures;
 
extern CORE_API double GStartTime;
 
extern CORE_API FString GSystemStartTime;
 
extern CORE_API bool GIsInitialLoad;
 
/* Whether we are using the event driven loader */
extern CORE_API bool GEventDrivenLoaderEnabled;
 
extern CORE_API bool GIsRetrievingVTablePtr;
 
extern CORE_API uint64 GFrameCounter;
 
extern CORE_API uint64 GFrameCounterRenderThread;
 
extern CORE_API uint64 GLastGCFrame;
 
extern CORE_API uint64 GInputTime;
 
extern CORE_API uint32 GFrameNumber;
 
extern CORE_API uint32 GFrameNumberRenderThread;
 
UE_DEPRECATED(5.1, "Please use `FPlatformProcess::IsFirstInstance()`")
extern CORE_API bool GIsFirstInstance;
 
extern CORE_API float GHitchThresholdMS;
 
extern CORE_API int32 GSavingCompressionChunkSize;
 
extern CORE_API uint32 GGameThreadId;
 
UE_DEPRECATED(4.26, "Please use `IsInActualRenderingThread()`")
extern CORE_API uint32 GRenderThreadId;
 
extern CORE_API uint32 GSlateLoadingThreadId;
 
extern CORE_API bool GIsGameThreadIdInitialized;
 
extern CORE_API FLazyName GCurrentTraceName;
 
extern CORE_API TSAN_ATOMIC(ELogTimes::Type) GPrintLogTimes;
 
extern CORE_API TSAN_ATOMIC(bool) GPrintLogCategory;
 
extern CORE_API TSAN_ATOMIC(bool) GPrintLogVerbosity;
 
#if USE_HITCH_DETECTION
extern CORE_API TSAN_ATOMIC(bool) GHitchDetected;
#endif
 
extern CORE_API int32 GCycleStatsShouldEmitNamedEvents;
 
extern CORE_API bool GShouldEmitVerboseNamedEvents;
 
extern CORE_API bool GIsDemoMode;
 
//@Package name transition, remove the double checks 
extern CORE_API FLazyName GLongCorePackageName;
//@Package name transition, remove the double checks 
extern CORE_API FLazyName GLongCoreUObjectPackageName;
 
extern CORE_API bool GIsAutomationTesting;
 
extern CORE_API bool GPumpingMessagesOutsideOfMainLoop;
 
extern CORE_API bool GPumpingMessages;
 
extern CORE_API bool GEnableVREditorHacks;
 
#if !UE_BUILD_SHIPPING
 
extern CORE_API bool GIgnoreDebugger;
 
#endif // #if !UE_BUILD_SHIPPING
 
enum class ETaskTag : int32
{
    ENone                       = 0 << 0,
    EStaticInit                 = 1 << 0,
    EGameThread                 = 1 << 1,
    ESlateThread                = 1 << 2,
    EAudioThread UE_DEPRECATED(5.0, "AudioThread was removed and ETaskTag::EAudioThread is not used anymore. Please remove it.") = 1 << 3,
    ERenderingThread            = 1 << 4,
    ERhiThread                  = 1 << 5,
    EAsyncLoadingThread         = 1 << 6,
    EEventThread                = 1 << 7,
 
    ENamedThreadBits            = (EEventThread << 1) - 1,
    EParallelThread             = 1 << 30, //This can be used when multiple threads or jobs are involved (usually a parallel for) It will avoid the check for uniqueness of the named thread tag.
    EWorkerThread               = 1 << 29 | EParallelThread,
    EParallelRenderingThread    = ERenderingThread | EParallelThread,
    EParallelGameThread         = EGameThread | EParallelThread,
    EParallelRhiThread          = ERhiThread | EParallelThread,
    EParallelLoadingThread      = EAsyncLoadingThread | EParallelThread,
};
 
ENUM_CLASS_FLAGS(ETaskTag);
 
 
class FTaskTagScope
{
    friend class FRunnableThread;
    friend class FRenderingThread;
    static thread_local ETaskTag ActiveTaskTag;
    static int32 GetStaticThreadId();
    ETaskTag ParentTag;
    ETaskTag Tag;
    bool TagOnlyIfNone;
 
public:
    static void CORE_API SetTagNone();
 
    static void CORE_API SetTagStaticInit();
 
    static ETaskTag CORE_API SwapTag(ETaskTag Tag);
 
public:
    CORE_API FTaskTagScope(ETaskTag InTag);
    CORE_API ~FTaskTagScope();
 
    static CORE_API ETaskTag GetCurrentTag();
    static CORE_API bool IsCurrentTag(ETaskTag InTag);
    static CORE_API bool IsRunningDuringStaticInit();
};
 
class UE_DEPRECATED(5.6, "Use FTaskTagScope instead which is now always optional by default.") FOptionalTaskTagScope : public FTaskTagScope
{
public:
    FOptionalTaskTagScope(ETaskTag InTag = ETaskTag::ENone) : FTaskTagScope(InTag)
    {
    }
};
 
CORE_API void EnsureRetrievingVTablePtrDuringCtor(const TCHAR* CtorSignature);
 
extern CORE_API bool IsInGameThread();
 
extern CORE_API bool IsInParallelGameThread();
 
extern CORE_API bool IsInParallelLoadingThread();
 
extern CORE_API bool IsInWorkerThread();
 
extern CORE_API bool IsAudioThreadRunning();
 
extern CORE_API bool IsInAudioThread();
 
extern CORE_API bool IsInSlateThread();
 
extern CORE_API bool IsInRenderingThread();
 
extern CORE_API bool IsInParallelRenderingThread();
 
extern CORE_API bool IsInAnyRenderingThread();
 
// Unlike IsInRenderingThread, this will always return false if we are running single threaded. It only returns true if this is actually a separate rendering thread. Mostly useful for checks
extern CORE_API bool IsInActualRenderingThread();
 
extern CORE_API bool (*IsInAsyncLoadingThread)();
 
extern CORE_API bool IsInActualLoadingThread();
 
UE_DEPRECATED(4.26, "Please use `GIsThreadedRendering` or `IsInActualRenderingThread()`")
extern CORE_API FRunnableThread* GRenderingThread;
 
extern CORE_API bool IsRHIThreadRunning();
 
extern CORE_API bool IsInRHIThread();
 
extern CORE_API bool IsInParallelRHIThread();
 
extern CORE_API bool GIsRunningRHIInSeparateThread_InternalUseOnly;
extern CORE_API bool GIsRunningRHIInDedicatedThread_InternalUseOnly;
extern CORE_API bool GIsRunningRHIInTaskThread_InternalUseOnly;
 
#if !UE_BUILD_SHIPPING
CORE_API void NotifyLoadingStateChanged(bool bState, const TCHAR *Message);
struct FScopedLoadingState
{
    FString Message;
    FScopedLoadingState(FString&& InMessage)
        : Message(MoveTemp(InMessage))
    {
        NotifyLoadingStateChanged(true, *Message);
    }
    FScopedLoadingState(const FString& InMessage)
        : Message(InMessage)
    {
        NotifyLoadingStateChanged(true, *Message);
    }
    ~FScopedLoadingState()
    {
        NotifyLoadingStateChanged(false, *Message);
    }
};
#else
FORCEINLINE void NotifyLoadingStateChanged(bool bState, const TCHAR *Message)
{
}
struct FScopedLoadingState
{
    template <typename T>
    FORCEINLINE FScopedLoadingState(T&& InMessage)
    {
    }
};
#endif
 
bool CORE_API GetEmitDrawEvents();
void CORE_API SetEmitDrawEvents(bool EmitDrawEvents);
 
class FChunkedFixedUObjectArray;
 
extern CORE_API FChunkedFixedUObjectArray* GCoreObjectArrayForDebugVisualizers;
 
namespace UE::CoreUObject::Private
{
    struct FStoredObjectPathDebug;
    
    struct FObjectHandlePackageDebugData;
}
namespace UE::Core { struct FVisualizerDebuggingState; }
extern CORE_API UE::CoreUObject::Private::FStoredObjectPathDebug* GCoreComplexObjectPathDebug;
extern CORE_API UE::CoreUObject::Private::FObjectHandlePackageDebugData* GCoreObjectHandlePackageDebug;
extern CORE_API UE::Core::FVisualizerDebuggingState* GCoreDebuggingState;
 
bool CORE_API IsRunningCookOnTheFly();
 
namespace UE {
    bool CORE_API IsUsingZenPakFileStreaming();
}
 
/* Used to wrap around null checks with `this` which should be optimized out when not using -fno-delete-null-pointer-checks.
 * The aim is to give the opportunity to the client code to fix any potential causes of `this` being null and stop relying
 * on undefined behavior.
 */
UE_DEPRECATED(5.6, "IsThisNotNull has been deprecated.")
CORE_API FORCENOINLINE bool IsThisNotNull(const void* This, const ANSICHAR* Function);
 
namespace UE
{
    CORE_API bool IsGCLocked();
}
namespace UE::Private
{
    CORE_API void SetIsGCLockedFunction(bool(*InIsGCLockedFuncPtr)());
}