ModuleManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "HAL/CriticalSection.h"
#include "HAL/PlatformCrt.h"
#include "HAL/PreprocessorHelpers.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Build.h"
#include "Misc/CoreMisc.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/Optional.h"
#include "Modules/Boilerplate/ModuleBoilerplate.h"
#include "Modules/ModuleInterface.h"
#include "Serialization/Archive.h"
#include "Templates/Atomic.h"
#include "Templates/SharedPointer.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
 
class FArchive;
class FModuleManager;
class FOutputDevice;
class UClass;
class UWorld;
 
#if WITH_HOT_RELOAD
    UE_DEPRECATED(5.0, "GIsHotReload has been deprecated, use IsReloadActive to test to see if a reload is in progress.")
    extern CORE_API bool GIsHotReload;
#endif
 
#if WITH_ENGINE
    extern CORE_API TMap<UClass*, UClass*>& GetClassesToReinstanceForHotReload(); 
#endif
 
 
enum class EModuleLoadResult
{
    Success,
 
    FileNotFound,
 
    FileIncompatible,
 
    CouldNotBeLoadedByOS,
 
    FailedToInitialize,
 
    NotLoadedByGameThread
};
 
CORE_API const TCHAR* LexToString(EModuleLoadResult LoadResult);
 
enum class EModuleUnloadResult
{
    Success,
 
    UnloadNotSupported
};
 
enum class EModuleChangeReason
{
    ModuleLoaded,
 
    /* A module has been unloaded and should no longer be used. */
    ModuleUnloaded,
 
    PluginDirectoryChanged
};
 
 
enum class ECheckModuleCompatibilityFlags
{
    None = 0x00,
 
    // Display the loading of an up-to-date module
    DisplayUpToDateModules = 0x01
};
 
ENUM_CLASS_FLAGS(ECheckModuleCompatibilityFlags)
 
 
enum class ELoadModuleFlags
{
    None = 0x0,
 
    // Print to the log any failure information
    LogFailures = 1 << 0,
};
 
ENUM_CLASS_FLAGS(ELoadModuleFlags)
 
 
 
struct FModuleStatus
{
    FModuleStatus()
        : bIsLoaded(false)
        , bIsGameModule(false)
    { }
 
    FString Name;
 
    FString FilePath;
 
    bool bIsLoaded;
 
    bool bIsGameModule;
};
 
struct FModuleDiskInfo
{
    FName Name;
 
    FString FilePath;
};
 
namespace UE::Core::Private
{
    TOptional<FModuleManager>& GetModuleManagerSingleton();
}
 
class FModuleManager
    : private FSelfRegisteringExec
{
public:
 
    CORE_API ~FModuleManager();
 
 
    static CORE_API FModuleManager& Get( );
 
    static CORE_API void TearDown();
 
 
    CORE_API void AbandonModule( const FName InModuleName );
 
    CORE_API void AddModule( const FName InModuleName );
 
#if !IS_MONOLITHIC
    CORE_API void RefreshModuleFilenameFromManifest(const FName InModuleName);
#endif  // !IS_MONOLITHIC
 
    CORE_API IModuleInterface* GetModule( const FName InModuleName );
 
    CORE_API bool IsModuleSafeToUse( const FName InModuleName ) const;
 
    CORE_API bool IsModuleLoaded( const FName InModuleName ) const;
 
    CORE_API IModuleInterface* LoadModule( const FName InModuleName, ELoadModuleFlags InLoadModuleFlags = ELoadModuleFlags::None );
 
    CORE_API IModuleInterface& LoadModuleChecked( const FName InModuleName );
 
    CORE_API bool LoadModuleWithCallback( const FName InModuleName, FOutputDevice &Ar );
 
    CORE_API IModuleInterface* LoadModuleWithFailureReason( const FName InModuleName, EModuleLoadResult& OutFailureReason, ELoadModuleFlags InLoadModuleFlags = ELoadModuleFlags::None);
 
    CORE_API bool QueryModule( const FName InModuleName, FModuleStatus& OutModuleStatus ) const;
 
    CORE_API void QueryModules( TArray<FModuleStatus>& OutModuleStatuses ) const;
 
    CORE_API bool UnloadModule( const FName InModuleName, bool bIsShutdown = false, bool bAllowUnloadCode = true );
 
    CORE_API void UnloadOrAbandonModuleWithCallback( const FName InModuleName, FOutputDevice &Ar);
 
    CORE_API void AbandonModuleWithCallback( const FName InModuleName );
 
    CORE_API void AddExtraBinarySearchPaths();
 
    template<typename TModuleInterface>
    static TModuleInterface& GetModuleChecked( const FName ModuleName )
    {
        FModuleManager& ModuleManager = FModuleManager::Get();
 
        checkf(ModuleManager.IsModuleLoaded(ModuleName), TEXT("Tried to get module interface for unloaded module: '%s'"), *(ModuleName.ToString()));
        return static_cast<TModuleInterface&>(*ModuleManager.GetModule(ModuleName));
    }
 
private:
    static CORE_API IModuleInterface* GetModulePtr_Internal(FName ModuleName);
 
    IModuleInterface* GetOrLoadModule(const FName InModuleName, EModuleLoadResult& OutFailureReason, ELoadModuleFlags InLoadModuleFlags = ELoadModuleFlags::None);
 
public:
 
    template<typename TModuleInterface>
    static UE_FORCEINLINE_HINT TModuleInterface* GetModulePtr( const FName ModuleName )
    {
        return static_cast<TModuleInterface*>(GetModulePtr_Internal(ModuleName));
    }
 
    template<typename TModuleInterface>
    static TModuleInterface& LoadModuleChecked( const FName InModuleName)
    {
        IModuleInterface& ModuleInterface = FModuleManager::Get().LoadModuleChecked(InModuleName);
        return static_cast<TModuleInterface&>(ModuleInterface);
    }
 
    template<typename TModuleInterface>
    static TModuleInterface* LoadModulePtr( const FName InModuleName)
    {
        return static_cast<TModuleInterface*>(FModuleManager::Get().LoadModule(InModuleName));
    }
 
    CORE_API void FindModules(const TCHAR* WildcardWithoutExtension, TArray<FName>& OutModules) const;
    CORE_API void FindModules(const TCHAR* WildcardWithoutExtension, TArray<FModuleDiskInfo>& OutModules) const;
 
    CORE_API bool ModuleExists(const TCHAR* ModuleName, FString* OutModuleFilePath = nullptr) const;
 
    CORE_API int32 GetModuleCount( ) const;
 
    CORE_API void UnloadModulesAtShutdown( );
 
 
    DECLARE_DELEGATE_RetVal( IModuleInterface*, FInitializeStaticallyLinkedModule )
 
    
    typedef IModuleInterface *FInitializeStaticallyLinkedModuleRaw();
 
    static CORE_API void RegisterStaticallyLinkedModule( const FLazyName InModuleName, FInitializeStaticallyLinkedModuleRaw* InInitializer );
 
    CORE_API void StartProcessingNewlyLoadedObjects();
 
    CORE_API void AddBinariesDirectory(const TCHAR *InDirectory, bool bIsGameDirectory);
 
    CORE_API void LoadModuleBinaryOnly(FName ModuleName);
 
    CORE_API void SetGameBinariesDirectory(const TCHAR* InDirectory);
 
    CORE_API FString GetGameBinariesDirectory() const;
 
#if !IS_MONOLITHIC
    CORE_API bool IsModuleUpToDate( const FName InModuleName ) const;
#endif
 
    CORE_API bool DoesLoadedModuleHaveUObjects( const FName ModuleName ) const;
 
    static CORE_API const TCHAR* GetUBTConfiguration( );
 
#if !IS_MONOLITHIC
    CORE_API FString GetModuleFilename(FName ModuleName) const;
 
    CORE_API void SetModuleFilename(FName ModuleName, const FString& Filename);
 
    CORE_API bool HasAnyOverridenModuleFilename() const;
 
    CORE_API void SaveCurrentStateForBootstrap(const TCHAR* Filename);
#endif
 
    using FModulesChangedEvent UE_DEPRECATED(5.5, "The FModulesChangedEvent typedef has been deprecated - use TTSMulticastDelegateRegistration<void(FName, EModuleChangeReason)> instead.") = TTSMulticastDelegate<void(FName ModuleName, EModuleChangeReason ChangeReason)>;
    TTSMulticastDelegateRegistration<void(FName ModuleName, EModuleChangeReason ChangeReason)>& OnModulesChanged( )
    {
        return ModulesChangedEvent;
    }
 
    using ProcessLoadedObjectsEvent UE_DEPRECATED(5.5, "The ProcessLoadedObjectsEvent typedef has been deprecated - use TMulticastDelegateRegistration<void(FName, bool)> instead.") = TMulticastDelegate<void(FName, bool)>;
    TMulticastDelegateRegistration<void(FName, bool)>& OnProcessLoadedObjectsCallback()
    {
        return ProcessLoadedObjectsCallback;
    }
 
    TMulticastDelegateRegistration<void(TConstArrayView<FName>)>& OnModulesUnloaded()
    {
        return OnModulesUnloadCallback;
    }
 
    TDelegateRegistration<bool(TConstArrayView<FName>)>& OnCheckLiveObjectsInModulesCallback()
    {
        return CheckLiveObjectsInModulesCallback;
    }
 
    DECLARE_DELEGATE_RetVal_OneParam(bool, FIsPackageLoadedCallback, FName);
    FIsPackageLoadedCallback& IsPackageLoadedCallback()
    {
        return IsPackageLoaded;
    }
 
protected:
    // FSelfRegisteringExec interface.
    CORE_API virtual bool Exec_Dev( UWorld* Inworld, const TCHAR* Cmd, FOutputDevice& Ar ) override;
 
private:
    friend TOptional<FModuleManager>& UE::Core::Private::GetModuleManagerSingleton();
    struct FPrivateToken { explicit FPrivateToken() = default; };
 
public:
    CORE_API FModuleManager(FPrivateToken);
    FModuleManager(const FModuleManager&) = delete;
    FModuleManager& operator=(const FModuleManager&) = delete;
 
private:
    class FModuleInfo
    {
    public:
 
        FString OriginalFilename;
 
        FString Filename;
 
        void* Handle;
 
        TUniquePtr<IModuleInterface> Module;
 
        bool bWasUnloadedAtShutdown;
 
        TAtomic<bool> bIsReady;
 
        int32 LoadOrder;
 
        static int32 CurrentLoadOrder;
 
    public:
 
        FModuleInfo()
            : Handle(nullptr)
            , bWasUnloadedAtShutdown(false)
            , bIsReady(false)
            , LoadOrder(CurrentLoadOrder++)
        { }
 
        ~FModuleInfo()
        {
        }
    };
 
    typedef TSharedPtr<FModuleInfo, ESPMode::ThreadSafe> ModuleInfoPtr;
    typedef TSharedRef<FModuleInfo, ESPMode::ThreadSafe> ModuleInfoRef;
 
    typedef TMap<FName, ModuleInfoRef> FModuleMap;
 
public:
    CORE_API void MakeUniqueModuleFilename( const FName InModuleName, FString& UniqueSuffix, FString& UniqueModuleFileName ) const;
 
    CORE_API void AddModuleToModulesList(const FName InModuleName, FModuleManager::ModuleInfoRef& ModuleInfo);
 
    CORE_API void ResetModulePathsCache();
 
#if UE_MERGED_MODULES && !UE_BUILD_SHIPPING
 
    void LogMergedLibraryUsage();
 
    void LoadAllModulesInMergedLibrary(FStringView LibraryName);
 
    void UnloadAllModulesInMergedLibrary(FStringView LibraryName);
 
#endif // UE_MERGED_MODULES && !UE_BUILD_SHIPPING
 
    CORE_API void OnObjectCleanup();
 
    friend FArchive& operator<<( FArchive& Ar, FModuleManager& ModuleManager );
private:
    static CORE_API void WarnIfItWasntSafeToLoadHere(const FName InModuleName);
 
    CORE_API ModuleInfoPtr FindModule(FName InModuleName);
    CORE_API ModuleInfoRef FindModuleChecked(FName InModuleName);
 
    UE_FORCEINLINE_HINT TSharedPtr<const FModuleInfo, ESPMode::ThreadSafe> FindModule(FName InModuleName) const
    {
        return const_cast<FModuleManager*>(this)->FindModule(InModuleName);
    }
 
    UE_FORCEINLINE_HINT TSharedRef<const FModuleInfo, ESPMode::ThreadSafe> FindModuleChecked(FName InModuleName) const
    {
        return const_cast<FModuleManager*>(this)->FindModuleChecked(InModuleName);
    }
 
#if !IS_MONOLITHIC
    CORE_API void FindModulePaths(const TCHAR *NamePattern, TMap<FName, FString> &OutModulePaths) const;
 
    CORE_API void FindModulePathsInDirectory(const FString &DirectoryName, bool bIsGameDirectory, TMap<FName, FString> &OutModulePaths) const;
 
    CORE_API void SerializeStateForBootstrap_Impl(FArchive& Ar);
 
    CORE_API void RefreshModuleFilenameFromManifestImpl(const FName InModuleName, FModuleInfo& ModuleInfo);
 
    void* InternalLoadLibrary(FName ModuleName, const FString& ModuleFileToLoad);
 
    void InternalFreeLibrary(FName ModuleName, void* Handle);
 
#if UE_MERGED_MODULES
 
    TArray<FName> GetLoadedModulesForLibrary(const FString& LibraryFilename) const;
 
    TArray<FName> GetLoadedLibrariesForSharedLibrary(const FString& LibraryFilename) const;
 
    TArray<FName> GetAllSharedLibrariesForLibrary(const FString& LibraryFilename) const;
 
#endif // UE_MERGED_MODULES
 
 
#endif
 
    CORE_API void ProcessPendingStaticallyLinkedModuleInitializers() const;
 
private:
    FModuleMap Modules;
 
    mutable TArray<TPair<FLazyName, FInitializeStaticallyLinkedModule>, TInlineAllocator<16>> PendingStaticallyLinkedModuleInitializers;
 
    mutable TMap<FName, FInitializeStaticallyLinkedModule> StaticallyLinkedModuleInitializers;
 
    bool bCanProcessNewlyLoadedObjects;
 
    bool bExtraBinarySearchPathsAdded;
 
    bool bIsLoadingDynamicLibrary;
 
    mutable TMap<FName, FString> ModulePathsCache;
 
    TTSMulticastDelegate<void(FName ModuleName, EModuleChangeReason ChangeReason)> ModulesChangedEvent;
    
    TMulticastDelegate<void(FName, bool)> ProcessLoadedObjectsCallback;
 
    TMulticastDelegate<void(TConstArrayView<FName>)> OnModulesUnloadCallback;
 
    TDelegate<bool(TConstArrayView<FName>)> CheckLiveObjectsInModulesCallback;
 
    FIsPackageLoadedCallback IsPackageLoaded;
 
    mutable TArray<FString> EngineBinariesDirectories;
    mutable TArray<FString> PendingEngineBinariesDirectories;
 
    mutable TArray<FString> GameBinariesDirectories;
    mutable TArray<FString> PendingGameBinariesDirectories;
 
    mutable TOptional<FString> BuildId;
 
    mutable FCriticalSection ModulesCriticalSection;
 
#if UE_MERGED_MODULES
 
    TMap<FString, void*> LibraryHandles;
 
    TMap<FString, TArray<FName>> DelayUnloadLibraries;
 
    mutable TMap<FString, TArray<FString>> LibraryDependencies;
 
#endif // UE_MERGED_MODULES
};
 
template< class ModuleClass >
class FStaticallyLinkedModuleRegistrant
{
public:
 
    FStaticallyLinkedModuleRegistrant( FLazyName InModuleName )
    {
        FModuleManager::RegisterStaticallyLinkedModule(
            InModuleName,           // Module name
            &InitializeModule );    // Initializer
    }
    
    static IModuleInterface* InitializeModule( )
    {
        return new ModuleClass();
    }
};
 
typedef IModuleInterface* ( *FInitializeModuleFunctionPtr )( void );
 
 
class FModuleInitializerEntry
{
public:
    CORE_API FModuleInitializerEntry(const TCHAR* InName, FInitializeModuleFunctionPtr InFunction, const TCHAR* InName2 = nullptr);
    CORE_API ~FModuleInitializerEntry();
 
    static FInitializeModuleFunctionPtr FindModule(const TCHAR* Name);
 
private:
    FModuleInitializerEntry* Prev;
    FModuleInitializerEntry* Next;
    const TCHAR* Name;
    const TCHAR* Name2;
    FInitializeModuleFunctionPtr Function;
};
 
 
class FDefaultModuleImpl
    : public IModuleInterface
{ };
 
 
class FDefaultGameModuleImpl
    : public FDefaultModuleImpl
{
    virtual bool IsGameModule() const override
    {
        return true;
    }
};
 
namespace UE::Core::Private
{
    constexpr bool ModuleNameEquals(const char* Lhs, const char* Rhs)
    {
        for (;;)
        {
            if (*Lhs != *Rhs)
            {
                return false;
            }
 
            if (*Lhs == '\0')
            {
                return true;
            }
 
            ++Lhs;
            ++Rhs;
        }
    }
}
#if IS_MONOLITHIC || UE_MERGED_MODULES
 
    // If we're linking monolithically we assume all modules are linked in with the main binary.
    #define IMPLEMENT_MODULE( ModuleImplClass, ModuleName ) \
 \
        static FStaticallyLinkedModuleRegistrant< ModuleImplClass > ModuleRegistrant##ModuleName( TEXT(#ModuleName) ); \
        /* Forced reference to this function is added by the linker to check that each module uses IMPLEMENT_MODULE */ \
        extern "C" void IMPLEMENT_MODULE_##ModuleName() { UE_STATIC_ASSERT_WARN(UE::Core::Private::ModuleNameEquals(#ModuleName, UE_MODULE_NAME ), "Module name mismatch (" #ModuleName " != " UE_MODULE_NAME "). Please ensure module name passed to IMPLEMENT_MODULE is " UE_MODULE_NAME " to avoid runtime errors in monolithic builds."); } \
        PER_MODULE_BOILERPLATE_ANYLINK(ModuleImplClass, ModuleName)
 
#else
 
    #define IMPLEMENT_MODULE( ModuleImplClass, ModuleName ) \
        \
         \
        /* InitializeModule function, called by module manager after this module's DLL has been loaded */ \
         \
        /* @return  Returns an instance of this module */ \
         \
        static IModuleInterface* Initialize##ModuleName##Module() \
        { \
            return new ModuleImplClass(); \
        } \
        static FModuleInitializerEntry ModuleName##InitializerEntry(TEXT(#ModuleName), Initialize##ModuleName##Module, TEXT(UE_MODULE_NAME)); \
        /* Forced reference to this function is added by the linker to check that each module uses IMPLEMENT_MODULE */ \
        extern "C" void IMPLEMENT_MODULE_##ModuleName() { UE_STATIC_ASSERT_WARN(UE::Core::Private::ModuleNameEquals(#ModuleName, UE_MODULE_NAME ), "Module name mismatch (" #ModuleName " != " UE_MODULE_NAME "). Please ensure module name passed to IMPLEMENT_MODULE is " UE_MODULE_NAME " to avoid runtime errors in monolithic builds."); } \
        PER_MODULE_BOILERPLATE_ANYLINK(ModuleImplClass, ModuleName)
 
#endif //IS_MONOLITHIC
 
 
#define IMPLEMENT_GAME_MODULE( ModuleImplClass, ModuleName ) \
    IMPLEMENT_MODULE( ModuleImplClass, ModuleName )
 
 
#if PLATFORM_DESKTOP
    #ifdef UE_ENGINE_DIRECTORY
        #define IMPLEMENT_FOREIGN_ENGINE_DIR() const TCHAR *GForeignEngineDir = TEXT( UE_ENGINE_DIRECTORY );
    #else
        #define IMPLEMENT_FOREIGN_ENGINE_DIR() const TCHAR *GForeignEngineDir = nullptr;
    #endif
#else
    #define IMPLEMENT_FOREIGN_ENGINE_DIR() 
#endif
 
#define UE_LIST_ARGUMENT(...) __VA_ARGS__
 
#define UE_REGISTER_SIGNING_KEY(ExponentValue, ModulusValue) \
    struct FSigningKeyRegistration \
    { \
        FSigningKeyRegistration() \
        { \
            extern CORE_API void RegisterSigningKeyCallback(void (*)(TArray<uint8>&, TArray<uint8>&)); \
            RegisterSigningKeyCallback(&Callback); \
        } \
        static void Callback(TArray<uint8>& OutExponent, TArray<uint8>& OutModulus) \
        { \
            const uint8 Exponent[] = { ExponentValue }; \
            const uint8 Modulus[] = { ModulusValue }; \
            OutExponent.SetNum(UE_ARRAY_COUNT(Exponent)); \
            OutModulus.SetNum(UE_ARRAY_COUNT(Modulus)); \
            for(int ByteIdx = 0; ByteIdx < UE_ARRAY_COUNT(Exponent); ByteIdx++) \
            { \
                OutExponent[ByteIdx] = Exponent[ByteIdx]; \
            } \
            for(int ByteIdx = 0; ByteIdx < UE_ARRAY_COUNT(Modulus); ByteIdx++) \
            { \
                OutModulus[ByteIdx] = Modulus[ByteIdx]; \
            } \
        } \
    } GSigningKeyRegistration;
 
#define UE_REGISTER_ENCRYPTION_KEY(...) \
    struct FEncryptionKeyRegistration \
    { \
        FEncryptionKeyRegistration() \
        { \
            extern CORE_API void RegisterEncryptionKeyCallback(void (*)(unsigned char OutKey[32])); \
            RegisterEncryptionKeyCallback(&Callback); \
        } \
        static void Callback(unsigned char OutKey[32]) \
        { \
            const unsigned char Key[32] = { __VA_ARGS__ }; \
            for(int ByteIdx = 0; ByteIdx < 32; ByteIdx++) \
            { \
                OutKey[ByteIdx] = Key[ByteIdx]; \
            } \
        } \
    } GEncryptionKeyRegistration;
 
#define IMPLEMENT_TARGET_NAME_REGISTRATION() \
    struct FTargetNameRegistration \
    { \
        FTargetNameRegistration() \
        { \
            FPlatformMisc::SetUBTTargetName(TEXT(PREPROCESSOR_TO_STRING(UE_TARGET_NAME))); \
        } \
    } GTargetNameRegistration;
 
#if IS_PROGRAM
 
    #if IS_MONOLITHIC
        #define IMPLEMENT_APPLICATION( ModuleName, GameName ) \
            /* For monolithic builds, we must statically define the game's name string (See Core.h) */ \
            TCHAR GInternalProjectName[64] = TEXT( GameName ); \
            IMPLEMENT_FOREIGN_ENGINE_DIR() \
            IMPLEMENT_SIGNING_KEY_REGISTRATION() \
            IMPLEMENT_ENCRYPTION_KEY_REGISTRATION() \
            IMPLEMENT_GAME_MODULE(FDefaultGameModuleImpl, ModuleName) \
            PER_MODULE_BOILERPLATE \
            FEngineLoop GEngineLoop;
 
    #else       
 
        #define IMPLEMENT_APPLICATION( ModuleName, GameName ) \
            /* For non-monolithic programs, we must set the game's name string before main starts (See Core.h) */ \
            struct FAutoSet##ModuleName \
            { \
                FAutoSet##ModuleName() \
                { \
                    FCString::Strncpy(GInternalProjectName, TEXT( GameName ), UE_ARRAY_COUNT(GInternalProjectName)); \
                } \
            } AutoSet##ModuleName; \
            PER_MODULE_BOILERPLATE_ANYLINK(FDefaultGameModuleImpl, ModuleName) \
            FEngineLoop GEngineLoop;
    #endif
 
#else
 
#if IS_MONOLITHIC
    #if PLATFORM_DESKTOP
 
        #define IMPLEMENT_PRIMARY_GAME_MODULE( ModuleImplClass, ModuleName, DEPRECATED_GameName ) \
            /* For monolithic builds, we must statically define the game's name string (See Core.h) */ \
            TCHAR GInternalProjectName[64] = TEXT( PREPROCESSOR_TO_STRING(UE_PROJECT_NAME) ); \
            /* Implement the GIsGameAgnosticExe variable (See Core.h). */ \
            bool GIsGameAgnosticExe = false; \
            IMPLEMENT_FOREIGN_ENGINE_DIR() \
            IMPLEMENT_SIGNING_KEY_REGISTRATION() \
            IMPLEMENT_ENCRYPTION_KEY_REGISTRATION() \
            IMPLEMENT_TARGET_NAME_REGISTRATION() \
            IMPLEMENT_GAME_MODULE( ModuleImplClass, ModuleName ) \
            PER_MODULE_BOILERPLATE
 
    #else   //PLATFORM_DESKTOP
 
        #define IMPLEMENT_PRIMARY_GAME_MODULE( ModuleImplClass, ModuleName, DEPRECATED_GameName ) \
            /* For monolithic builds, we must statically define the game's name string (See Core.h) */ \
            TCHAR GInternalProjectName[64] = TEXT( PREPROCESSOR_TO_STRING(UE_PROJECT_NAME) ); \
            PER_MODULE_BOILERPLATE \
            IMPLEMENT_FOREIGN_ENGINE_DIR() \
            IMPLEMENT_SIGNING_KEY_REGISTRATION() \
            IMPLEMENT_ENCRYPTION_KEY_REGISTRATION() \
            IMPLEMENT_TARGET_NAME_REGISTRATION() \
            IMPLEMENT_GAME_MODULE( ModuleImplClass, ModuleName ) \
            /* Implement the GIsGameAgnosticExe variable (See Core.h). */ \
            bool GIsGameAgnosticExe = false;
 
    #endif  //PLATFORM_DESKTOP
 
#else   //IS_MONOLITHIC
 
    #define IMPLEMENT_PRIMARY_GAME_MODULE( ModuleImplClass, ModuleName, GameName ) \
        /* Nothing special to do for modular builds.  The game name will be set via the command-line */ \
        IMPLEMENT_SIGNING_KEY_REGISTRATION() \
        IMPLEMENT_ENCRYPTION_KEY_REGISTRATION() \
        IMPLEMENT_TARGET_NAME_REGISTRATION() \
        IMPLEMENT_GAME_MODULE( ModuleImplClass, ModuleName )
#endif  //IS_MONOLITHIC
 
#endif
 
enum class EActiveReloadType
{
    None,
    Reinstancing,
#if WITH_HOT_RELOAD
    HotReload,
#endif
#if WITH_LIVE_CODING
    LiveCoding,
#endif
};
 
class IReload;
 
#if WITH_RELOAD
CORE_API EActiveReloadType GetActiveReloadType();
CORE_API IReload* GetActiveReloadInterface();
 
CORE_API bool IsReloadActive();
 
CORE_API void BeginReload(EActiveReloadType ActiveReloadType, IReload& Interface);
 
CORE_API void EndReload();
#else
inline EActiveReloadType GetActiveReloadType() { return EActiveReloadType::None; }
 
inline bool IsReloadActive() { return false; }
 
inline IReload* GetActiveReloadInterface() { return nullptr; }
#endif