IConsoleManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/AccessDetection.h"
#include "Misc/AssertionMacros.h"
#include "Templates/UnrealTemplate.h"
#include "Containers/UnrealString.h"
#include "Logging/LogMacros.h"
#include "Delegates/IDelegateInstance.h"
#include "Delegates/Delegate.h"
#include "Features/IModularFeature.h"
#include "Templates/EnableIf.h"
#include "Internationalization/Text.h"
 
#define TRACK_CONSOLE_FIND_COUNT !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
 
#if DO_CHECK && (!UE_BUILD_SHIPPING) && !defined(__clang_analyzer__) // Disable even if checks in shipping are enabled.
    #define cvarCheckCode( Code )       checkCode( Code )
#else
    #define cvarCheckCode(...)
#endif
 
#define SETBY_ERROR ((EConsoleVariableFlags)0x01000000)
 
template <class T> class TConsoleVariableData;
 
enum EConsoleVariableFlags
{
    /* Mask for flags. Use this instead of ~ECVF_SetByMask */
    ECVF_FlagMask = 0x0000ffff,
 
    ECVF_Default = 0x0,
    ECVF_Cheat = 0x1,
    ECVF_ReadOnly = 0x4,
    ECVF_Unregistered = 0x8,
    ECVF_CreatedFromIni = 0x10,
    ECVF_RenderThreadSafe = 0x20,
 
    /* ApplyCVarSettingsGroupFromIni will complain if this wasn't set, should not be combined with ECVF_Cheat and ECVF_ExcludeFromPreview. 
     * They are automatically added as  ECVF_Preview unless ECVF_ExcludeFromPreview is used
     */
    ECVF_Scalability = 0x40,
 
    /* those cvars control other cvars with the flag ECVF_Scalability, names should start with "sg." */
    ECVF_ScalabilityGroup = 0x80,
 
    /* CVars with this flag will be included in the device profile previews. */
    ECVF_Preview = 0x100,
 
    /* Cvars with this flag will modify the Shader Keystring for All Platforms*/
    ECVF_GeneralShaderChange = 0x200,
 
    /* Cvars with this flag will modify the Shader Keystring for Mobile Platforms*/
    ECVF_MobileShaderChange = 0x400,
 
    /* Cvars with this flag will modify the Shader Keystring for Desktop Platforms*/
    ECVF_DesktopShaderChange = 0x800,
 
    /* CVars with this flag will be excluded from the device profile previews. */
    ECVF_ExcludeFromPreview = 0x1000,
 
    ECVF_SaveForNextBoot = 0x2000,
 
    // ------------------------------------------------
 
    /* Set flags */
    ECVF_SetFlagMask =              0x00ff0000,
 
    // Use to set a cvar without calling all cvar sinks. Much faster, but potentially unsafe. Use only if you know the particular cvar/setting does not require a sink call
    ECVF_Set_NoSinkCall_Unsafe =    0x00010000,
    
    // Similar to ECVF_Set_NoSinkCall_Unsafe, but this will do nothing but set the cvar and flags, and push updates to render thread, no sinks, etc
    ECVF_Set_SetOnly_Unsafe =       0x00020000,
 
    // When this is set, this will stomp on existing tagged array type values in place, instead of adding to the end of the array
    ECVF_Set_ReplaceExistingTag =   0x00040000,
 
    // ------------------------------------------------
 
    /* to get some history of where the last value was set by ( useful for track down why a cvar is in a specific state */
    ECVF_SetByMask =                0xff000000,
 
    // The ECVF_SetBy flags are sorted in override order (weak to strong), the value is not serialized. It only affects the override behavior when calling Set()
 
    // Lowest priority (default after console variable creation)
    ECVF_SetByConstructor =         0x00000000,
    // Reserved value for SETBY_ERROR. Please don't use.
    // SETBY_ERROR =                0x01000000 
    // Set by scalability groups from Scalability.ini (lower priority than game settings so it's easier to override partially). THIS IS AN ARRAY TYPE
    ECVF_SetByScalability =         0x02000000,
    // Default priority for engine-level game user settings, platform-specific settings will override this
    ECVF_SetByGameSetting =         0x03000000,
    // Set by project settings UI or specific sections in ini file (higher priority than game setting to allow enforcing some settings for this project)
    ECVF_SetByProjectSetting =      0x04000000,
    // Used by the [ConsoleVariables] section of Engine.ini as well as FSystemSettings
    ECVF_SetBySystemSettingsIni =   0x05000000,
    // Dyanmically loaded/unloaded plugins, used with the History concept to restore cvars on plugin unload. THIS IS AN ARRAY TYPE meaning multiple vales with this SetBy are stored in the history.
    ECVF_SetByPluginLowPriority =   0x06000000,
    // Per device settings using the DeviceProfiles.ini hierarchy (e.g. specific iOS device, higher priority than per project to do device specific settings). THIS IS AN ARRAY TYPE
    ECVF_SetByDeviceProfile =       0x07000000,
    // Dyanmically loaded/unloaded plugins, used with the History concept to restore cvars on plugin unload. THIS IS AN ARRAY TYPE meaning multiple vales with this SetBy are stored in the history.
    ECVF_SetByPluginHighPriority =  0x08000000,
    // User settable game overrides, used for GameUserSettings fields that need to override device specific settings
    ECVF_SetByGameOverride =        0x09000000,
    // Set by local consolevariables.ini, mostly used for testing multiple projects
    ECVF_SetByConsoleVariablesIni = 0x0A000000,
    // Set by hotfix. THIS IS AN ARRAY TYPE meaning multiple vales with this SetBy are stored in the history
    ECVF_SetByHotfix =              0x0B000000,
    // Set for previewing in editor. THIS IS AN ARRAY TYPE meaning multiple vales with this SetBy are stored in the history
    ECVF_SetByPreview =             0x0C000000,
    // Used by some command line parameters, others use the Console priority instead
    ECVF_SetByCommandline =         0x0D000000,
    // Used for high priority temporary debugging or operation modes
    ECVF_SetByCode =                0x0E000000,
    // Highest priority used via editor UI or or game/editor interactive console
    ECVF_SetByConsole =             0x0F000000,
 
 
    // ------------------------------------------------
};
 
 
#define ENUMERATE_SET_BY(op) \
    op(Constructor) \
    op(Scalability) \
    op(GameSetting) \
    op(ProjectSetting) \
    op(SystemSettingsIni) \
    op(PluginLowPriority) \
    op(DeviceProfile) \
    op(PluginHighPriority) \
    op(GameOverride) \
    op(ConsoleVariablesIni) \
    op(Hotfix) \
    op(Preview) \
    op(Commandline) \
    op(Code) \
    op(Console)
 
 
extern CORE_API const TCHAR* GetConsoleVariableSetByName(EConsoleVariableFlags ConsoleVariableFlags);
 
extern CORE_API EConsoleVariableFlags GetConsoleVariableSetByValue(const TCHAR* SetByName);
 
namespace ConsoleVariablePlatformMapping
{
    // Store a mapping from EShaderPlatform (as int) to a Platform that is currently cooking for that ShaderPlatform
    CORE_API void RegisterShaderPlatformToPlatformMapping(int ShaderPlatform, FName PlatformName);
    // Store a mapping from Platform to a DevicveProfile that is currently being used when cooking for that Platform
    CORE_API void RegisterPlatformToDeviceProfileMapping(FName PlatformName, FName DeviceProfileName);
 
    // Receives the mapping previously set with RegisterShaderPlatformToPlatformMapping
    // Returns NAME_None if no mapping exists
    CORE_API FName GetShaderPlatformToPlatformMapping(int ShaderPlatform);
    // Receives the mapping previously set with RegisterPlatformToDeviceProfileMapping
    // Returns NAME_None if no mapping exists
    CORE_API FName GetPlatformToDeviceProfileMapping(FName PlatformName);
}
 
class IConsoleVariable;
 
#if !NO_CVARS
 
DECLARE_DELEGATE_OneParam( FConsoleVariableDelegate, IConsoleVariable* );
 
DECLARE_MULTICAST_DELEGATE_OneParam(FConsoleVariableMulticastDelegate, IConsoleVariable*);
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FConsoleObjectWithNameMulticastDelegate, const TCHAR*, IConsoleObject*);
 
DECLARE_DELEGATE( FConsoleCommandDelegate );
 
DECLARE_DELEGATE_OneParam( FConsoleCommandWithArgsDelegate, const TArray< FString >& );
 
DECLARE_DELEGATE_OneParam( FConsoleCommandWithWorldDelegate, UWorld* );
 
DECLARE_DELEGATE_TwoParams(FConsoleCommandWithWorldAndArgsDelegate, const TArray< FString >&, UWorld*);
 
DECLARE_DELEGATE_TwoParams(FConsoleCommandWithArgsAndOutputDeviceDelegate, const TArray< FString >&, FOutputDevice&);
 
DECLARE_DELEGATE_ThreeParams(FConsoleCommandWithWorldArgsAndOutputDeviceDelegate, const TArray< FString >&, UWorld*, FOutputDevice&);
 
DECLARE_DELEGATE_OneParam( FConsoleCommandWithOutputDeviceDelegate, FOutputDevice& );
 
#else
 
template <typename DerivedType, typename... ParamTypes>
struct FNullConsoleVariableDelegate
{
    template <typename... VarTypes>
    inline static DerivedType CreateStatic(typename TIdentity<void (*)(ParamTypes..., VarTypes...)>::Type, VarTypes...)
    {
        return {};
    }
 
    template<typename FunctorType, typename... VarTypes>
    inline static DerivedType CreateLambda(FunctorType&&, VarTypes...)
    {
        return {};
    }
 
    template<typename UserClass, typename FunctorType, typename... VarTypes>
    inline static DerivedType CreateSPLambda(UserClass*, FunctorType&&, VarTypes...)
    {
        return {};
    }
 
    template<typename UserClass, typename FunctorType, typename... VarTypes>
    inline static DerivedType CreateWeakLambda(UserClass*, FunctorType&&, VarTypes...)
    {
        return {};
    }
 
    template <typename UserClass, typename... VarTypes>
    inline static DerivedType CreateRaw(UserClass*, typename TMemFunPtrType<false, UserClass, void (ParamTypes..., VarTypes...)>::Type, VarTypes...)
    {
        return {};
    }
    template <typename UserClass, typename... VarTypes>
    inline static DerivedType CreateRaw(UserClass*, typename TMemFunPtrType<true, UserClass, void (ParamTypes..., VarTypes...)>::Type, VarTypes...)
    {
        return {};
    }
 
    template <typename UserClass, typename... VarTypes>
    inline static DerivedType CreateSP(const TSharedRef<UserClass>&, typename TMemFunPtrType<false, UserClass, void (ParamTypes..., VarTypes...)>::Type, VarTypes...)
    {
        return {};
    }
    template <typename UserClass, typename... VarTypes>
    inline static DerivedType CreateSP(const TSharedRef<UserClass>&, typename TMemFunPtrType<true, UserClass, void (ParamTypes..., VarTypes...)>::Type, VarTypes...)
    {
        return {};
    }
 
    template <typename UserClass, typename... VarTypes>
    inline static DerivedType CreateSP(UserClass*, typename TMemFunPtrType<false, UserClass, void (ParamTypes..., VarTypes...)>::Type, VarTypes...)
    {
        return {};
    }
    template <typename UserClass, typename... VarTypes>
    inline static DerivedType CreateSP(UserClass*, typename TMemFunPtrType<true, UserClass, void (ParamTypes..., VarTypes...)>::Type, VarTypes...)
    {
        return {};
    }
    
    template <typename UserClass, typename... VarTypes>
    inline static DerivedType CreateThreadSafeSP(const TSharedRef<UserClass, ESPMode::ThreadSafe>&, typename TMemFunPtrType<false, UserClass, void (ParamTypes..., VarTypes...)>::Type, VarTypes...)
    {
        return {};
    }
    template <typename UserClass, typename... VarTypes>
    inline static DerivedType CreateThreadSafeSP(const TSharedRef<UserClass, ESPMode::ThreadSafe>&, typename TMemFunPtrType<true, UserClass, void (ParamTypes..., VarTypes...)>::Type, VarTypes...)
    {
        return {};
    }
 
    template <typename UserClass, typename... VarTypes>
    inline static DerivedType CreateThreadSafeSP(UserClass*, typename TMemFunPtrType<false, UserClass, void (ParamTypes..., VarTypes...)>::Type, VarTypes...)
    {
        return {};
    }
    template <typename UserClass, typename... VarTypes>
    inline static DerivedType CreateThreadSafeSP(UserClass*, typename TMemFunPtrType<true, UserClass, void (ParamTypes..., VarTypes...)>::Type, VarTypes...)
    {
        return {};
    }
 
    template <typename UObjectTemplate, typename... VarTypes>
    inline static DerivedType CreateUFunction(UObjectTemplate*, const FName&, VarTypes...)
    {
        return {};
    }
 
    template <typename UserClass, typename... VarTypes>
    inline static DerivedType CreateUObject(UserClass*, typename TMemFunPtrType<false, UserClass, void (ParamTypes..., VarTypes...)>::Type, VarTypes...)
    {
        return {};
    }
    template <typename UserClass, typename... VarTypes>
    inline static DerivedType CreateUObject(UserClass*, typename TMemFunPtrType<true, UserClass, void (ParamTypes..., VarTypes...)>::Type, VarTypes...)
    {
        return {};
    }
 
    FDelegateHandle GetHandle() const
    {
        return {};
    }
 
    bool ExecuteIfBound(ParamTypes...)
    {
        return false;
    }
};
 
struct FConsoleVariableDelegate                             : FNullConsoleVariableDelegate<FConsoleVariableDelegate, IConsoleVariable*> {};
struct FConsoleCommandDelegate                              : FNullConsoleVariableDelegate<FConsoleCommandDelegate> {};
struct FConsoleCommandWithArgsDelegate                      : FNullConsoleVariableDelegate<FConsoleCommandWithArgsDelegate, const TArray<FString>&> {};
struct FConsoleCommandWithWorldDelegate                     : FNullConsoleVariableDelegate<FConsoleCommandWithWorldDelegate, UWorld*> {};
struct FConsoleCommandWithWorldAndArgsDelegate              : FNullConsoleVariableDelegate<FConsoleCommandWithWorldAndArgsDelegate, const TArray<FString>&, UWorld*> {};
struct FConsoleCommandWithArgsAndOutputDeviceDelegate       : FNullConsoleVariableDelegate<FConsoleCommandWithArgsAndOutputDeviceDelegate, const TArray<FString>&, FOutputDevice&> {};
struct FConsoleCommandWithWorldArgsAndOutputDeviceDelegate  : FNullConsoleVariableDelegate<FConsoleCommandWithWorldArgsAndOutputDeviceDelegate, const TArray<FString>&, UWorld*, FOutputDevice&> {};
struct FConsoleCommandWithOutputDeviceDelegate              : FNullConsoleVariableDelegate<FConsoleCommandWithOutputDeviceDelegate, FOutputDevice&> {};
 
#endif
 
template <class T> class TConsoleVariableData;
 
class IConsoleObject
{
 
public:
 
    IConsoleObject()
#if TRACK_CONSOLE_FIND_COUNT
        : FindCallCount(0)
#endif
    {}
 
    virtual ~IConsoleObject() {}
 
    virtual const TCHAR* GetHelp() const = 0;
    virtual void SetHelp(const TCHAR* Value) = 0;
    virtual EConsoleVariableFlags GetFlags() const = 0;
    virtual void SetFlags(const EConsoleVariableFlags Value) = 0;
    virtual FText GetDetailedHelp() const
    {
        // By default, just return the standard help message :
        return FText::FromString(GetHelp());
    }
 
    // Convenience methods -------------------------------------
 
    void ClearFlags(const EConsoleVariableFlags Value)
    {
        uint32 New = (uint32)GetFlags() & ~(uint32)Value;
    
        SetFlags((EConsoleVariableFlags)New);
    }
    bool TestFlags(const EConsoleVariableFlags Value) const
    {
        return ((uint32)GetFlags() & (uint32)Value) != 0;
    }
 
    bool IsEnabled() const
    {
#if DISABLE_CHEAT_CVARS
        if (TestFlags(ECVF_Cheat))
        {
            return false;
        }
#endif // DISABLE_CHEAT_CVARS
        if (TestFlags(ECVF_Unregistered))
        {
            return false;
        }
        return true;
    }
 
 
    virtual IConsoleObject* GetParentObject() const
    {
        return nullptr;
    }
    
    virtual class IConsoleVariable* AsVariable()
    {
        return 0; 
    }
 
    virtual bool IsVariableBool() const { return false; }
    virtual bool IsVariableInt() const { return false; }
    virtual bool IsVariableFloat() const { return false; }
    virtual bool IsVariableString() const { return false; }
 
    virtual class TConsoleVariableData<bool>* AsVariableBool()
    {
        ensureMsgf(false, TEXT("Attempted to access variable data of a console variable type that doesn't support it.  For example FindTConsoleVariableData* on a FAutoConsoleVariableRef."));
        return 0;
    }
 
    virtual class TConsoleVariableData<int32>* AsVariableInt()
    {
        ensureMsgf(false, TEXT("Attempted to access variable data of a console variable type that doesn't support it.  For example FindTConsoleVariableData* on a FAutoConsoleVariableRef."));
        return 0; 
    }
 
    virtual class TConsoleVariableData<float>* AsVariableFloat()
    {
        ensureMsgf(false, TEXT("Attempted to access variable data of a console variable type that doesn't support it.  For example FindTConsoleVariableData* on a FAutoConsoleVariableRef."));
        return 0; 
    }
 
    virtual class TConsoleVariableData<FString>* AsVariableString()
    {
        ensureMsgf(false, TEXT("Attempted to access variable data of a console variable type that doesn't support it.  For example FindTConsoleVariableData* on a FAutoConsoleVariableRef."));
        return 0;
    }
 
    virtual struct IConsoleCommand* AsCommand()
    {
        return 0; 
    }
 
    virtual bool IsShadowObject() const
    {
        return false;
    }
 
    virtual IConsoleObject* GetShadowedObject() const
    {
        return nullptr;
    }
 
    virtual bool IsDeprecated() const
    {
        return false;
    }
 
private: // -----------------------------------------
 
#if TRACK_CONSOLE_FIND_COUNT
    // no longer pure visual, if that causes problems we can change the interface
    // to track down FindConsoleObject/FindConsoleVariable calls without static
    uint32 FindCallCount;
#endif
 
    virtual void Release() = 0;
 
    friend class FConsoleManager;
};
 
class IConsoleVariable : public IConsoleObject
{
public:
 
    struct FResolvedContext
    {
        EConsoleVariableFlags Flags;
        FName Tag;
    };
 
    struct FSetContext
    {
        FSetContext()
        {
        }
 
        FSetContext(EConsoleVariableFlags InFlags, FName InTag)
            : Flags(InFlags)
            , Tag(InTag)
        {
        }
 
 
        enum class EPriorityMode : uint8
        {
            Set,
            // the following are limited by Max priority if its set
            ReplaceCurrent,
        };
 
        enum class ETagMode : uint8
        {
            // Sets the Tag at the end of the array. Remove the Tag if it already exists.
            Set,
            // Replace the Tag in-place if it already exists. Sets the Tag at the end if it doesn't exist.
            Replace,
            // Replaces the current highest Tag.
            ReplaceCurrent,
        };
 
 
        EConsoleVariableFlags Flags = ECVF_SetByCode;
        EPriorityMode PriorityMode = EPriorityMode::Set;
 
        FName Tag = NAME_None;
        ETagMode TagMode = ETagMode::Set;
 
        EConsoleVariableFlags MaxPriority = ECVF_SetByConsole;
        EConsoleVariableFlags MinPriority = SETBY_ERROR;
    };
 
    virtual FResolvedContext ResolveContext(const FSetContext& Context) = 0;
 
    virtual void Set(const TCHAR* InValue, const FResolvedContext& Context) = 0;
 
    virtual void Unset(EConsoleVariableFlags SetBy, FName Tag = NAME_None) = 0;
 
    virtual bool GetBool() const = 0;
    virtual int32 GetInt() const = 0;
    virtual float GetFloat() const = 0;
    virtual FString GetString() const = 0;
 
    void GetValue(int32& OutIntValue) const
    {
        OutIntValue = GetInt();
    }
    void GetValue(bool& OutBoolValue) const
    {
        OutBoolValue = GetBool();
    }
    void GetValue(float& OutFloatValue) const
    {
        OutFloatValue = GetFloat();
    }
    void GetValue(FString& OutStringValue) const
    {
        OutStringValue = GetString();
    }
 
    virtual void SetOnChangedCallback(const FConsoleVariableDelegate& Callback) = 0;
 
    virtual FConsoleVariableMulticastDelegate& OnChangedDelegate() = 0;
 
    UE_DEPRECATED(5.4, "Use GetDefaultValue() instead")
    virtual IConsoleVariable* GetDefaultValueVariable()
    {
        return nullptr;
    }
 
    virtual FString GetDefaultValue() = 0;
 
#if ALLOW_OTHER_PLATFORM_CONFIG
 
    virtual TSharedPtr<IConsoleVariable> GetPlatformValueVariable(FName PlatformName, const FString& DeviceProfileName=FString()) = 0;
 
    virtual bool HasPlatformValueVariable(FName PlatformName, const FString& DeviceProfileName=FString()) = 0;
 
    virtual void ClearPlatformVariables(FName PlatformName=NAME_None)
    {
    }
    
#endif
 
    virtual void LogHistory(FOutputDevice& Ar) = 0;
    
    virtual SIZE_T GetHistorySize() = 0;
 
    // convenience methods
 
    void Set(const TCHAR* InValue, const FSetContext& Context)
    {
        Set(InValue, this->ResolveContext(Context));
    }
 
    void Set(bool InValue, const FSetContext& Context)
    {
        // NOTE: Bool needs to use 1 and 0 here rather than true/false, as this may be a int32 or something
        // and eventually this code calls, TTypeFromString<T>::FromString which won't handle the true/false,
        // but 1 and 0 will work for whatever.
        // inefficient but no common code path
        Set(InValue ? TEXT("1") : TEXT("0"), Context);
    }
    void Set(int32 InValue, const FSetContext& Context)
    {
        // inefficient but no common code path
        Set(*FString::Printf(TEXT("%d"), InValue), Context);
    }
    void Set(float InValue, const FSetContext& Context)
    {
        // inefficient but no common code path
        Set(*FString::Printf(TEXT("%g"), InValue), Context);
    }
 
 
    template <typename T>
    void Set(T Value, EConsoleVariableFlags Flags = ECVF_SetByCode, FName Tag = NAME_None)
    {
        Set(Value, FSetContext(Flags, Tag));
    }
 
    template <typename T>
    void SetWithCurrentPriority(
        T Value, 
        FName Tag = NAME_None, 
        EConsoleVariableFlags MaxPriority = ECVF_SetByConsole,
        EConsoleVariableFlags MinPriority = SETBY_ERROR)
    {
        checkf(MinPriority <= MaxPriority, TEXT("MinPriority must be <= MaxPriority"))
        FSetContext Context;
        Context.Tag = Tag;
        Context.PriorityMode = FSetContext::EPriorityMode::ReplaceCurrent;
        Context.MinPriority = MinPriority;
        Context.MaxPriority = MaxPriority;
        EConsoleVariableFlags CurFlags = (EConsoleVariableFlags)(GetFlags() & ECVF_SetByMask);
        Context.Flags = CurFlags;
        Set(Value, Context);
    }
 
    template<typename T>
    void ReplaceCurrentPriorityAndTag(
        T InValue, 
        EConsoleVariableFlags MaxPriority = ECVF_SetByConsole,
        EConsoleVariableFlags MinPriority = SETBY_ERROR)
    {
        checkf(MinPriority <= MaxPriority, TEXT("MinPriority must be <= MaxPriority"))
        FSetContext Context;
        Context.TagMode = FSetContext::ETagMode::ReplaceCurrent;
        Context.PriorityMode = FSetContext::EPriorityMode::ReplaceCurrent;
        Context.MinPriority = MinPriority;
        Context.MaxPriority = MaxPriority;
        EConsoleVariableFlags CurFlags = (EConsoleVariableFlags)(GetFlags() & ECVF_SetByMask);
        Context.Flags = CurFlags;
        Set(InValue, Context);
    }
 
 
};
 
struct IConsoleCommand : public IConsoleObject
{
    virtual bool Execute( const TArray< FString >& Args, UWorld* InWorld, class FOutputDevice& OutputDevice ) = 0;
};
 
struct IConsoleThreadPropagation
{
    virtual void OnCVarChange(int32& Dest, int32 NewValue) = 0;
    virtual void OnCVarChange(float& Dest, float NewValue) = 0;
    virtual void OnCVarChange(bool& Dest, bool NewValue) = 0;
    virtual void OnCVarChange(FString& Dest, const FString& NewValue) = 0;
    virtual void OnCVarChange(FName& Dest, const FName& NewValue) = 0;
};
 
DECLARE_DELEGATE_TwoParams( FConsoleObjectVisitor, const TCHAR*, IConsoleObject* );
 
 
class FConsoleVariableSinkHandle
{
public:
    FConsoleVariableSinkHandle()
    {
    }
 
    explicit FConsoleVariableSinkHandle(FDelegateHandle InHandle)
        : Handle(InHandle)
    {
    }
 
    template <typename MulticastDelegateType>
    void RemoveFromDelegate(MulticastDelegateType& MulticastDelegate)
    {
        MulticastDelegate.Remove(Handle);
    }
 
    template <typename DelegateType>
    bool HasSameHandle(const DelegateType& Delegate) const
    {
        return Delegate.GetHandle() == Handle;
    }
 
private:
    FDelegateHandle Handle;
};
 
struct FConsoleSuggestion
{
    FString Name;
    FString Help;
 
    FConsoleSuggestion(FString InName, FString InHelp)
    : Name(InName)
    , Help(InHelp)
    {}
 
    FConsoleSuggestion()
    {}
};
 
class IConsoleCommandExecutor : public IModularFeature
{
public:
    virtual ~IConsoleCommandExecutor() = default;
 
    static FName ModularFeatureName()
    {
        static const FName Name = TEXT("ConsoleCommandExecutor");
        return Name;
    }
 
    virtual FName GetName() const = 0;
 
    virtual FText GetDisplayName() const = 0;
 
    virtual FText GetDescription() const = 0;
 
    virtual FText GetHintText() const = 0;
 
    virtual void GetSuggestedCompletions(const TCHAR* Input, TArray<FConsoleSuggestion>& Out) = 0;
 
    UE_DEPRECATED(5.5, "Use GetSuggestedCompletions instead")
    virtual void GetAutoCompleteSuggestions(const TCHAR* Input, TArray<FString>& Out){};
 
    virtual void GetExecHistory(TArray<FString>& Out) = 0;
 
    virtual bool Exec(const TCHAR* Input) = 0;
 
    virtual bool AllowHotKeyClose() const = 0;
 
    virtual bool AllowMultiLine() const = 0;
 
    virtual struct FInputChord GetHotKey() const = 0;
    virtual struct FInputChord GetIterateExecutorHotKey() const = 0;
};
 
 
struct IConsoleManager
{
    virtual IConsoleVariable* RegisterConsoleVariable(const TCHAR* Name, bool DefaultValue, const TCHAR* Help, uint32 Flags = ECVF_Default) = 0;
    virtual IConsoleVariable* RegisterConsoleVariable(const TCHAR* Name, int32 DefaultValue, const TCHAR* Help, uint32 Flags = ECVF_Default) = 0;
    virtual IConsoleVariable* RegisterConsoleVariable(const TCHAR* Name, float DefaultValue, const TCHAR* Help, uint32 Flags = ECVF_Default) = 0;
    virtual IConsoleVariable* RegisterConsoleVariable(const TCHAR* Name, const TCHAR* DefaultValue, const TCHAR* Help, uint32 Flags = ECVF_Default) = 0;
    virtual IConsoleVariable* RegisterConsoleVariable(const TCHAR* Name, const FString& DefaultValue, const TCHAR* Help, uint32 Flags = ECVF_Default) = 0;
    virtual IConsoleVariable* RegisterConsoleVariableRef(const TCHAR* Name, bool& RefValue, const TCHAR* Help, uint32 Flags = ECVF_Default) = 0;
    virtual IConsoleVariable* RegisterConsoleVariableRef(const TCHAR* Name, int32& RefValue, const TCHAR* Help, uint32 Flags = ECVF_Default) = 0;
    virtual IConsoleVariable* RegisterConsoleVariableRef(const TCHAR* Name, float& RefValue, const TCHAR* Help, uint32 Flags = ECVF_Default) = 0;
    virtual IConsoleVariable* RegisterConsoleVariableRef(const TCHAR* Name, FString& RefValue, const TCHAR* Help, uint32 Flags = ECVF_Default) = 0;
    virtual IConsoleVariable* RegisterConsoleVariableRef(const TCHAR* Name, FName& RefValue, const TCHAR* Help, uint32 Flags = ECVF_Default) = 0;
    virtual IConsoleVariable* RegisterConsoleVariableBitRef(const TCHAR* CVarName, const TCHAR* FlagName, uint32 BitNumber, uint8* Force0MaskPtr, uint8* Force1MaskPtr, const TCHAR* Help, uint32 Flags = ECVF_Default) = 0;
 
    // ----------
 
    virtual void CallAllConsoleVariableSinks() = 0;
 
    virtual FConsoleVariableSinkHandle RegisterConsoleVariableSink_Handle(const FConsoleCommandDelegate& Command) = 0;
 
    virtual void UnregisterConsoleVariableSink_Handle(FConsoleVariableSinkHandle Handle) = 0;
 
    // ----------
 
    virtual IConsoleCommand* RegisterConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandDelegate& Command, uint32 Flags = ECVF_Default) = 0;
 
    virtual IConsoleCommand* RegisterConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithArgsDelegate& Command, uint32 Flags = ECVF_Default) = 0;
 
    virtual IConsoleCommand* RegisterConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithWorldDelegate& Command, uint32 Flags = ECVF_Default) = 0;
 
    virtual IConsoleCommand* RegisterConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithWorldAndArgsDelegate& Command, uint32 Flags = ECVF_Default) = 0;
    
    virtual IConsoleCommand* RegisterConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithArgsAndOutputDeviceDelegate& Command, uint32 Flags = ECVF_Default) = 0;
    
    virtual IConsoleCommand* RegisterConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithWorldArgsAndOutputDeviceDelegate& Command, uint32 Flags = ECVF_Default) = 0;
 
    virtual IConsoleCommand* RegisterConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithOutputDeviceDelegate& Command, uint32 Flags = ECVF_Default) = 0;
 
    virtual IConsoleCommand* RegisterConsoleCommand(const TCHAR* Name, const TCHAR* Help, uint32 Flags = (uint32)ECVF_Default) = 0;
 
    virtual void UnregisterConsoleObject( IConsoleObject* ConsoleObject, bool bKeepState = true) = 0;
 
    virtual void UnregisterConsoleObject(const TCHAR* Name, bool bKeepState = true) = 0;
 
    virtual IConsoleVariable* FindConsoleVariable(const TCHAR* Name, bool bTrackFrequentCalls = true) const = 0;
 
    virtual IConsoleObject* FindConsoleObject(const TCHAR* Name, bool bTrackFrequentCalls = true) const = 0;
 
    virtual FString FindConsoleObjectName(const IConsoleObject* Obj) const = 0;
 
    TConsoleVariableData<bool>* FindTConsoleVariableDataBool(const TCHAR* Name) const
    {
        IConsoleVariable* P = FindConsoleVariable(Name);
 
        return P ? P->AsVariableBool() : 0;
    }
 
    TConsoleVariableData<int32>* FindTConsoleVariableDataInt(const TCHAR* Name) const 
    { 
        IConsoleVariable* P = FindConsoleVariable(Name); 
        
        return P ? P->AsVariableInt() : 0; 
    }
 
    TConsoleVariableData<float>* FindTConsoleVariableDataFloat(const TCHAR* Name) const 
    { 
        IConsoleVariable* P = FindConsoleVariable(Name); 
 
        return P ? P->AsVariableFloat() : 0; 
    }
 
 
    virtual void ForEachConsoleObjectThatStartsWith( const FConsoleObjectVisitor& Visitor, const TCHAR* ThatStartsWith = TEXT("")) const = 0;
 
    virtual void ForEachConsoleObjectThatContains(const FConsoleObjectVisitor& Visitor, const TCHAR* ThatContains) const = 0;
 
    virtual bool ProcessUserConsoleInput(const TCHAR* Input, FOutputDevice& Ar, UWorld* InWorld) = 0;
 
    virtual void AddConsoleHistoryEntry(const TCHAR* Key, const TCHAR* Input) = 0;
    
    virtual void GetConsoleHistory(const TCHAR* Key, TArray<FString>& Out) = 0; 
 
    virtual bool IsNameRegistered(const TCHAR* Name) const = 0;
 
    // currently only for render thread
    // @param InCallback 0 to disable the callbacks
    virtual void RegisterThreadPropagation(uint32 ThreadId = 0, IConsoleThreadPropagation* InCallback = 0) = 0;
 
    inline static IConsoleManager& Get()
    {
        if (!Singleton)
        {
            SetupSingleton();
            check(Singleton != nullptr);
        }
        return *Singleton;
    }
 
#if ALLOW_OTHER_PLATFORM_CONFIG
    static CORE_API bool VisitPlatformCVarsForEmulation(FName PlatformName, const FString& DeviceProfileName, TFunctionRef<void(const FString& CVarName, const FString& CVarValue, EConsoleVariableFlags SetBy)> Visit);
    
    virtual void LoadAllPlatformCVars(FName PlatformName, const FString& DeviceProfileName=FString()) = 0;
    
    virtual void PreviewPlatformCVars(FName PlatformName, const FString& DeviceProfileName, FName PreviewModeTag) = 0;
 
    virtual void StompPlatformCVars(FName PlatformName, const FString& DeviceProfileName, FName Tag, EConsoleVariableFlags SetBy, EConsoleVariableFlags RequiredFlags, EConsoleVariableFlags DisallowedFlags) = 0;
 
    virtual void ClearAllPlatformCVars(FName PlatformName=NAME_None, const FString& DeviceProfileName=FString()) = 0;
 
#endif
 
    virtual void UnsetAllConsoleVariablesWithTag(FName Tag, EConsoleVariableFlags Priority=ECVF_SetByMask) = 0;
 
    virtual void BatchUpdateTag(FName Tag, const TMap<FName, FString>& CVarsAndValues) = 0;
 
    virtual FConsoleVariableMulticastDelegate& OnCVarUnregistered() = 0;
    virtual FConsoleObjectWithNameMulticastDelegate& OnConsoleObjectUnregistered() = 0;
 
protected:
    virtual ~IConsoleManager() { }
 
private:
    static CORE_API IConsoleManager* Singleton;
 
    static CORE_API void SetupSingleton();
};
 
 
template <typename T>
struct TGuardConsoleVariable
{
    T PreviousValue;
    IConsoleVariable* ConsoleVariable;
 
    TGuardConsoleVariable(const TCHAR* ConsoleVariableName, const T& NewValue)
        : TGuardConsoleVariable(IConsoleManager::Get().FindConsoleVariable(ConsoleVariableName), NewValue)
    {
        ensureMsgf(ConsoleVariable, TEXT("TGuardConsoleVariable: Trying to set console variable \"%s\" but it doesn't exist"), ConsoleVariableName);
    }
 
    TGuardConsoleVariable(IConsoleVariable* ConsoleVariable, const T& NewValue)
        : ConsoleVariable(ConsoleVariable)
    {
        if (ConsoleVariable)
        {
            ConsoleVariable->GetValue(PreviousValue);
            ConsoleVariable->Set(NewValue);
        }
    }
 
    TGuardConsoleVariable(const TGuardConsoleVariable&) = delete;
 
    TGuardConsoleVariable(TGuardConsoleVariable&& Right)
        : PreviousValue(::MoveTemp(Right.PreviousValue))
        , ConsoleVariable(Right.ConsoleVariable)
    {
        Right.ConsoleVariable = nullptr;
    }
 
    TGuardConsoleVariable& operator=(const TGuardConsoleVariable&) = delete;
 
    TGuardConsoleVariable& operator=(TGuardConsoleVariable&&) = delete;
 
    ~TGuardConsoleVariable()
    {
        if (ConsoleVariable)
        {
            ConsoleVariable->Set(PreviousValue);
        }
    }
};
 
class FAutoConsoleVariableSink
{
public:
    FAutoConsoleVariableSink(const FConsoleCommandDelegate& InCommand)
        : Command(InCommand)
    {
        Handle = IConsoleManager::Get().RegisterConsoleVariableSink_Handle(Command);
    }
    virtual ~FAutoConsoleVariableSink()
    {
//disabled for now, destruction order makes this not always working     IConsoleManager::Get().UnregisterConsoleVariableSink_Handle(Handle);
    }
 
    const FConsoleCommandDelegate& Command;
    FConsoleVariableSinkHandle Handle;
};
 
 
class FAutoConsoleObject
{
protected:
    FAutoConsoleObject(IConsoleObject* InTarget)
        : Target(InTarget)
    {
        check(Target);
        if (Target->TestFlags(ECVF_GeneralShaderChange))
        {
            AccessGeneralShaderChangeCvars().Add(this);
        }
        else if (Target->TestFlags(ECVF_MobileShaderChange))
        {
            AccessMobileShaderChangeCvars().Add(this);
        }
        else if (Target->TestFlags(ECVF_DesktopShaderChange))
        {
            AccessDesktopShaderChangeCvars().Add(this);
        }
    }
public:
    CORE_API virtual ~FAutoConsoleObject();
 
    static CORE_API TArray<const FAutoConsoleObject*>& AccessGeneralShaderChangeCvars();
    static CORE_API TArray<const FAutoConsoleObject*>& AccessMobileShaderChangeCvars();
    static CORE_API TArray<const FAutoConsoleObject*>& AccessDesktopShaderChangeCvars();
 
    inline IConsoleVariable* AsVariable()
    {
        checkSlow(Target->AsVariable());
        return static_cast<IConsoleVariable*>(Target);
    }
    inline const IConsoleVariable* AsVariable() const
    {
        checkSlow(Target->AsVariable());
        return static_cast<const IConsoleVariable*>(Target);
    }
 
private:
    IConsoleObject* Target;
};
 
#if !NO_CVARS
class FAutoConsoleVariable : private FAutoConsoleObject
{
public:
    CORE_API FAutoConsoleVariable(const TCHAR* Name, bool DefaultValue, const TCHAR* Help, uint32 Flags = ECVF_Default);
    CORE_API FAutoConsoleVariable(const TCHAR* Name, int32 DefaultValue, const TCHAR* Help, uint32 Flags = ECVF_Default);
    CORE_API FAutoConsoleVariable(const TCHAR* Name, float DefaultValue, const TCHAR* Help, uint32 Flags = ECVF_Default);
    CORE_API FAutoConsoleVariable(const TCHAR* Name, const TCHAR* DefaultValue, const TCHAR* Help, uint32 Flags = ECVF_Default);
 
    CORE_API FAutoConsoleVariable(const TCHAR* Name, bool DefaultValue, const TCHAR* Help, const FConsoleVariableDelegate& Callback, uint32 Flags = ECVF_Default);
    
    CORE_API FAutoConsoleVariable(const TCHAR* Name, int32 DefaultValue, const TCHAR* Help, const FConsoleVariableDelegate& Callback, uint32 Flags = ECVF_Default);
 
    CORE_API FAutoConsoleVariable(const TCHAR* Name, float DefaultValue, const TCHAR* Help, const FConsoleVariableDelegate& Callback, uint32 Flags = ECVF_Default);
 
    CORE_API FAutoConsoleVariable(const TCHAR* Name, const TCHAR* DefaultValue, const TCHAR* Help, const FConsoleVariableDelegate& Callback, uint32 Flags = ECVF_Default);
 
    UE_FORCEINLINE_HINT IConsoleVariable& operator*()
    {
        return *AsVariable();
    }
    UE_FORCEINLINE_HINT const IConsoleVariable& operator*() const
    {
        return *AsVariable();
    }
    UE_FORCEINLINE_HINT IConsoleVariable* operator->()
    {
        return AsVariable();
    }
    UE_FORCEINLINE_HINT const IConsoleVariable* operator->() const
    {
        return AsVariable();
    }
};
#else
class FAutoConsoleVariable
{
public:
    FAutoConsoleVariable(const TCHAR* Name, int32 DefaultValue, const TCHAR* Help, uint32 Flags = ECVF_Default)
    {
    }
 
    FAutoConsoleVariable(const TCHAR* Name, float DefaultValue, const TCHAR* Help, uint32 Flags = ECVF_Default)
    {
    }
 
    FAutoConsoleVariable(const TCHAR* Name, const TCHAR* DefaultValue, const TCHAR* Help, uint32 Flags = ECVF_Default)
    {
    }
};
#endif
 
#if !NO_CVARS
class FAutoConsoleVariableRef : private FAutoConsoleObject
{
public:
    CORE_API FAutoConsoleVariableRef(const TCHAR* Name, int32& RefValue, const TCHAR* Help, uint32 Flags = ECVF_Default);
    CORE_API FAutoConsoleVariableRef(const TCHAR* Name, float& RefValue, const TCHAR* Help, uint32 Flags = ECVF_Default);
    CORE_API FAutoConsoleVariableRef(const TCHAR* Name, bool& RefValue, const TCHAR* Help, uint32 Flags = ECVF_Default);
    CORE_API FAutoConsoleVariableRef(const TCHAR* Name, FString& RefValue, const TCHAR* Help, uint32 Flags = ECVF_Default);
 
    CORE_API FAutoConsoleVariableRef(const TCHAR* Name, FName& RefValue, const TCHAR* Help, uint32 Flags = ECVF_Default);
 
    CORE_API FAutoConsoleVariableRef(const TCHAR* Name, int32& RefValue, const TCHAR* Help, const FConsoleVariableDelegate& Callback, uint32 Flags = ECVF_Default);
 
    CORE_API FAutoConsoleVariableRef(const TCHAR* Name, float& RefValue, const TCHAR* Help, const FConsoleVariableDelegate& Callback, uint32 Flags = ECVF_Default);
 
    CORE_API FAutoConsoleVariableRef(const TCHAR* Name, bool& RefValue, const TCHAR* Help, const FConsoleVariableDelegate& Callback, uint32 Flags = ECVF_Default);
 
    CORE_API FAutoConsoleVariableRef(const TCHAR* Name, FString& RefValue, const TCHAR* Help, const FConsoleVariableDelegate& Callback, uint32 Flags = ECVF_Default);
 
    virtual ~FAutoConsoleVariableRef()
    {
    }
    UE_FORCEINLINE_HINT IConsoleVariable& operator*()
    {
        return *AsVariable();
    }
    UE_FORCEINLINE_HINT const IConsoleVariable& operator*() const
    {
        return *AsVariable();
    }
    UE_FORCEINLINE_HINT IConsoleVariable* operator->()
    {
        return AsVariable();
    }
    UE_FORCEINLINE_HINT const IConsoleVariable* operator->() const
    {
        return AsVariable();
    }
};
#else
class FAutoConsoleVariableRef
{
public:
    FAutoConsoleVariableRef(const TCHAR* Name, int32& RefValue, const TCHAR* Help, uint32 Flags = ECVF_Default)
    {
    }
 
    FAutoConsoleVariableRef(const TCHAR* Name, float& RefValue, const TCHAR* Help, uint32 Flags = ECVF_Default)
    {
    }
 
    FAutoConsoleVariableRef(const TCHAR* Name, bool& RefValue, const TCHAR* Help, uint32 Flags = ECVF_Default)
    {
    }
 
    FAutoConsoleVariableRef(const TCHAR* Name, FString& RefValue, const TCHAR* Help, uint32 Flags = ECVF_Default)
    {
    }
 
    FAutoConsoleVariableRef(const TCHAR* Name, int32& RefValue, const TCHAR* Help, const FConsoleVariableDelegate& Callback, uint32 Flags = ECVF_Default)
    {
    }
 
    FAutoConsoleVariableRef(const TCHAR* Name, float& RefValue, const TCHAR* Help, const FConsoleVariableDelegate& Callback, uint32 Flags = ECVF_Default)
    {
    }
    
    FAutoConsoleVariableRef(const TCHAR* Name, bool& RefValue, const TCHAR* Help, const FConsoleVariableDelegate& Callback, uint32 Flags = ECVF_Default)
    {
    }
 
    FAutoConsoleVariableRef(const TCHAR* Name, FString& RefValue, const TCHAR* Help, const FConsoleVariableDelegate& Callback, uint32 Flags = ECVF_Default)
    {
    }
};
#endif // NO_CVARS
 
 
// currently only supports main and render thread
// optimized for read access speed (no virtual function call and no thread handling if using the right functions)
// T: int32, float
template <class T>
class TConsoleVariableData
{
public:
    // constructor
    TConsoleVariableData(const T DefaultValue)
    {
        for(uint32 i = 0; i < UE_ARRAY_COUNT(ShadowedValue); ++i)
        {
            ShadowedValue[i] = DefaultValue;
        }
    }
 
    // faster than GetValueOnAnyThread()
    T GetValueOnGameThread() const
    {
        UE::AccessDetection::ReportAccess(UE::AccessDetection::EType::CVar);
        // compiled out in shipping for performance (we can change in development later), if this get triggered you need to call GetValueOnRenderThread() or GetValueOnAnyThread(), the last one is a bit slower
        cvarCheckCode(ensure(GetShadowIndex() == 0));   // ensure to not block content creators, #if to optimize in shipping
        return ShadowedValue[0];
    }
 
    // faster than GetValueOnAnyThread()
    T GetValueOnRenderThread() const
    {
        UE::AccessDetection::ReportAccess(UE::AccessDetection::EType::CVar);
#if !defined(__clang__) // @todo Mac: figure out how to make this compile
        // compiled out in shipping for performance (we can change in development later), if this get triggered you need to call GetValueOnGameThread() or GetValueOnAnyThread(), the last one is a bit slower
        cvarCheckCode(ensure(IsInParallelRenderingThread()));   // ensure to not block content creators, #if to optimize in shipping
#endif
        return ShadowedValue[1];
    }
 
    // convenient, for better performance consider using GetValueOnGameThread() or GetValueOnRenderThread()
    T GetValueOnAnyThread(bool bForceGameThread = false) const
    {
        UE::AccessDetection::ReportAccess(UE::AccessDetection::EType::CVar);
        return ShadowedValue[GetShadowIndex(bForceGameThread)];
    }
 
private: // ----------------------------------------------------
 
    // [0]:main thread, [1]: render thread, having them both in the same cache line should only hurt on write which happens rarely for cvars
    T ShadowedValue[2];
 
    // @return 0:main thread, 1: render thread, later more
    static uint32 GetShadowIndex(bool bForceGameThread = false)
    {   
        if (bForceGameThread)
        {
            cvarCheckCode(ensure(!IsInActualRenderingThread()));
            return 0;
        }
        return IsInParallelGameThread() || IsInGameThread() ? 0 : 1;
    }
 
    // needed for FConsoleVariable and FConsoleVariableRef2, intentionally not public
    T& GetReferenceOnAnyThread(bool bForceGameThread = false)
    {
        UE::AccessDetection::ReportAccess(UE::AccessDetection::EType::CVar);
        return ShadowedValue[GetShadowIndex(bForceGameThread)];
    }
 
    template<class T2> friend class FConsoleVariable;
    template<class T2> friend class TAutoConsoleVariable;
};
 
#if !NO_CVARS
template <class T>
class TAutoConsoleVariable : public FAutoConsoleObject
{
public:
 
    TAutoConsoleVariable(IConsoleVariable* ExistingObject)
        : FAutoConsoleObject(ExistingObject)
    {
        if constexpr (std::is_same_v<T, bool>)
        {
            Ref = AsVariable()->AsVariableBool();
        }
        else if constexpr (std::is_same_v<T, int32>)
        {
            Ref = AsVariable()->AsVariableInt();
        }
        else if constexpr (std::is_same_v<T, float>)
        {
            Ref = AsVariable()->AsVariableFloat();
        }
        else if constexpr (std::is_same_v<T, FString>)
        {
            Ref = AsVariable()->AsVariableString();
        }
        else
        {
            static_assert(sizeof(T) == 0, "Not supported");
        }
    }
 
    FORCENOINLINE TAutoConsoleVariable(const TCHAR* Name, const T& DefaultValue, const TCHAR* Help, uint32 Flags = ECVF_Default)
        : TAutoConsoleVariable(IConsoleManager::Get().RegisterConsoleVariable(Name, DefaultValue, Help, Flags))
    {
    }
 
    FORCENOINLINE TAutoConsoleVariable(const TCHAR* Name, const T& DefaultValue, const TCHAR* Help, const FConsoleVariableDelegate& Callback, uint32 Flags = ECVF_Default)
        : TAutoConsoleVariable(Name, DefaultValue, Help, Flags)
    {
        AsVariable()->SetOnChangedCallback(Callback);
    }
 
    T GetValueOnGameThread() const
    {
        return Ref->GetValueOnGameThread();
    }
 
    T GetValueOnRenderThread() const
    {
        return Ref->GetValueOnRenderThread();
    }
 
    T GetValueOnAnyThread(bool bForceGameThread = false) const
    {
        return Ref->GetValueOnAnyThread(bForceGameThread);
    }
    
    UE_FORCEINLINE_HINT IConsoleVariable& operator*()
    {
        return *AsVariable();
    }
    UE_FORCEINLINE_HINT const IConsoleVariable& operator*() const
    {
        return *AsVariable();
    }
    UE_FORCEINLINE_HINT IConsoleVariable* operator->()
    {
        return AsVariable();
    }
    UE_FORCEINLINE_HINT const IConsoleVariable* operator->() const
    {
        return AsVariable();
    }
private:
    TConsoleVariableData<T>* Ref;
};
 
#else
template <class T>
class TAutoConsoleVariable : public IConsoleVariable
{
public:
    TAutoConsoleVariable(const TCHAR* Name, const T& DefaultValue, const TCHAR* InHelp, uint32 InFlags = ECVF_Default)
        : Value(DefaultValue), Flags((EConsoleVariableFlags)InFlags)
    {
    }
 
    T GetValueOnGameThread() const
    {
        return Value.GetValueOnGameThread();
    }
 
    T GetValueOnRenderThread() const
    {
        return Value.GetValueOnRenderThread();
    }
 
    T GetValueOnAnyThread(bool bForceGameThread = false) const
    {
        return Value.GetValueOnAnyThread(bForceGameThread);
    }
    
    IConsoleVariable& operator*()
    {
        return *AsVariable();
    }
 
    const IConsoleVariable& operator*() const
    {
        return *AsVariable();
    }
 
    IConsoleVariable* operator->()
    {
        return AsVariable();
    }
 
    const IConsoleVariable* operator->() const
    {
        return AsVariable();
    }
 
    IConsoleVariable*       AsVariable()        { return this; }
    const IConsoleVariable* AsVariable() const  { return this; }
 
    virtual class TConsoleVariableData<int32>*      AsVariableInt()     override { return AsImpl<int32>(); }
    virtual class TConsoleVariableData<float>*      AsVariableFloat()   override { return AsImpl<float>(); }
    virtual class TConsoleVariableData<FString>*    AsVariableString()  override { return AsImpl<FString>(); }
 
    virtual bool        IsVariableInt() const override  { return std::is_same_v<int32, T>; }
    virtual int32       GetInt()        const override  { return GetImpl<int32>(); }
    virtual float       GetFloat()      const override  { return GetImpl<float>(); }
    virtual FString     GetString()     const override  { return GetImpl<FString>(); }
    virtual bool        GetBool()       const override { return GetImpl<bool>(); }
 
    virtual const TCHAR* GetHelp() const override
    {
        return TEXT("NO_CVARS, no help");
    }
 
    virtual FText GetDetailedHelp() const override
    {
        return INVTEXT("NO_CVARS, no help");
    }
 
    virtual void SetHelp(const TCHAR* InHelp) override
    {
        check(false);
    }
 
    virtual void Release() override
    {
        check(false);
    }
 
    virtual void SetOnChangedCallback(const FConsoleVariableDelegate &) override
    {
        check(false);
    }
 
    virtual FConsoleVariableMulticastDelegate& OnChangedDelegate()override
    {
        static FConsoleVariableMulticastDelegate Dummy;
        check(false);
        return Dummy;
    }
 
    virtual EConsoleVariableFlags GetFlags() const override
    {
        return Flags;
    }
 
    virtual void SetFlags(const EConsoleVariableFlags InFlags) override
    {
        Flags = InFlags;
    }
 
    virtual void Set(const TCHAR* InValue, EConsoleVariableFlags SetBy) override
    {
        LexFromString(Value.ShadowedValue[0], InValue);
    }
 
private:
    TConsoleVariableData<T> Value;
    FString Help;
    EConsoleVariableFlags Flags = EConsoleVariableFlags::ECVF_Default;
 
    template<class Y>
    Y GetImpl() const
    {
        if constexpr (std::is_same_v<T, Y>)
        {
            return GetValueOnAnyThread();
        }
        else
        {
            check(false);
            return Y();
        }
    }
 
    template<class Y>
    TConsoleVariableData<T>* AsImpl()
    {
        if constexpr (std::is_same_v<T, Y>)
        {
            return &Value;
        }
        else
        {
            check(false);
            return nullptr;
        }
    }
};
#endif // NO_CVARS
 
#if !NO_CVARS
class FAutoConsoleCommand : private FAutoConsoleObject
{
public:
    CORE_API FAutoConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandDelegate& Command, uint32 Flags = ECVF_Default);
 
    CORE_API FAutoConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithArgsDelegate& Command, uint32 Flags = ECVF_Default);
 
    CORE_API FAutoConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithOutputDeviceDelegate& Command, uint32 Flags = ECVF_Default);
 
    CORE_API FAutoConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithArgsAndOutputDeviceDelegate& Command, uint32 Flags = ECVF_Default);
 
    CORE_API FAutoConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithWorldDelegate& Command, uint32 Flags = ECVF_Default);
 
    CORE_API FAutoConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithWorldArgsAndOutputDeviceDelegate& Command, uint32 Flags = ECVF_Default);
};
#else
class FAutoConsoleCommand
{
public:
    FAutoConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandDelegate& Command, uint32 Flags = ECVF_Default)
    {
    }
 
    FAutoConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithArgsDelegate& Command, uint32 Flags = ECVF_Default)
    {
    }
 
    FAutoConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithOutputDeviceDelegate& Command, uint32 Flags = ECVF_Default)
    {
    }
 
    FAutoConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithArgsAndOutputDeviceDelegate& Command, uint32 Flags = ECVF_Default)
    {
    }
 
    FAutoConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithWorldDelegate& Command, uint32 Flags = ECVF_Default)
    {
    }
 
    FAutoConsoleCommand(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithWorldArgsAndOutputDeviceDelegate& Command, uint32 Flags = ECVF_Default)
    {
    }
};
#endif
 
 
#if !NO_CVARS
class FAutoConsoleCommandWithWorld : private FAutoConsoleObject
{
public:
    FAutoConsoleCommandWithWorld(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithWorldDelegate& Command, uint32 Flags = ECVF_Default)
        : FAutoConsoleObject(IConsoleManager::Get().RegisterConsoleCommand(Name, Help, Command, Flags))
    {
    }
 
    
};
 
class FAutoConsoleCommandWithWorldAndArgs : private FAutoConsoleObject
{
public: 
    FAutoConsoleCommandWithWorldAndArgs(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithWorldAndArgsDelegate& Command, uint32 Flags = ECVF_Default)
        : FAutoConsoleObject(IConsoleManager::Get().RegisterConsoleCommand(Name, Help, Command, Flags))
    {
    }
};
 
class FAutoConsoleCommandWithArgsAndOutputDevice : private FAutoConsoleObject
{
public:
    
    FAutoConsoleCommandWithArgsAndOutputDevice(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithArgsAndOutputDeviceDelegate& Command, uint32 Flags = ECVF_Default)
        : FAutoConsoleObject(IConsoleManager::Get().RegisterConsoleCommand(Name, Help, Command, Flags))
    {
    }
};
 
class FAutoConsoleCommandWithOutputDevice : private FAutoConsoleObject
{
public:
    FAutoConsoleCommandWithOutputDevice(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithOutputDeviceDelegate& Command, uint32 Flags = ECVF_Default)
        : FAutoConsoleObject(IConsoleManager::Get().RegisterConsoleCommand(Name, Help, Command, Flags))
    {
    }
};
 
class FAutoConsoleCommandWithWorldArgsAndOutputDevice : private FAutoConsoleObject
{
public:
    FAutoConsoleCommandWithWorldArgsAndOutputDevice(const TCHAR* Name, const TCHAR* Help, const FConsoleCommandWithWorldArgsAndOutputDeviceDelegate& Command, uint32 Flags = ECVF_Default)
        : FAutoConsoleObject(IConsoleManager::Get().RegisterConsoleCommand(Name, Help, Command, Flags))
    {
    }
};
 
#else
 
class FAutoConsoleCommandWithWorld
{
public:
    template<class... Args> FAutoConsoleCommandWithWorld(const Args&...) {}
};
 
class FAutoConsoleCommandWithWorldAndArgs
{
public:
    template<class... Args> FAutoConsoleCommandWithWorldAndArgs(const Args&...) {}
};
 
class FAutoConsoleCommandWithOutputDevice
{
public:
    template<class... Args> FAutoConsoleCommandWithOutputDevice(const Args&...) {}
};
 
class FAutoConsoleCommandWithWorldArgsAndOutputDevice
{
public:
    template<class... Args> FAutoConsoleCommandWithWorldArgsAndOutputDevice(const Args&...) {}
};
 
#endif
 
 
enum class EShadowCVarBehavior : uint8
{
    // skip all messaging
    NoMessaging,
    // log a warning on first usage
    Warn,
    // log an error on first usage
    Error,
    // throw an ensure on first usage
    Ensure,
    // throw an assertion on first usage
    Assert,
};
 
class FAutoConsoleVariableShadow
{
public:
 
    CORE_API FAutoConsoleVariableShadow(const TCHAR* Name, const TCHAR* CVarToShadow, EShadowCVarBehavior LookupFailureBehavior = EShadowCVarBehavior::Ensure);
};
 
class FAutoConsoleVariableDeprecated
{
public:
    CORE_API FAutoConsoleVariableDeprecated(const TCHAR* Name, const TCHAR* CVarToShadow, const TCHAR* DeprecatedAtVersion, EShadowCVarBehavior UsageBehavior=EShadowCVarBehavior::Ensure, EShadowCVarBehavior LookupFailureBehavior = EShadowCVarBehavior::Ensure, const TCHAR* DeprecationMessage = TEXT(""));
};
 
class FAutoConsoleCommandDeprecated
{
public:
    CORE_API FAutoConsoleCommandDeprecated(const TCHAR* Name, const TCHAR* CVarToShadow, const TCHAR* DeprecatedAtVersion, EShadowCVarBehavior UsageBehavior = EShadowCVarBehavior::Ensure, EShadowCVarBehavior LookupFailureBehavior = EShadowCVarBehavior::Ensure, const TCHAR* DeprecationMessage = TEXT(""));
};
 
 
template<typename T>
class TAutoRangedConsoleVariable : public TAutoConsoleVariable<T>
{
public:
    CORE_API TAutoRangedConsoleVariable(const TCHAR* Name, T DefaultValue, T MinValue, T MaxValue, const TCHAR* Help, uint32 Flags = ECVF_Default, IConsoleVariable* Parent = nullptr);
};
 
 
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogConsoleResponse, Log, All);