ModuleDescriptor.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "HAL/Platform.h"
#include "HAL/PlatformMisc.h"
#include "Serialization/JsonWriter.h"
#include "UObject/NameTypes.h"
#include "UObject/UnrealNames.h"
 
class FJsonObject;
class FText;
 
enum class EModuleLoadResult;
enum class EModuleUnloadResult;
 
namespace ELoadingPhase
{
    enum Type
    {
        EarliestPossible,
 
        PostConfigInit,
 
        PostSplashScreen,
 
        PreEarlyLoadingScreen,
 
        PreLoadingScreen,
 
        PreDefault,
 
        Default,
 
        PostDefault,
 
        PostEngineInit,
 
        None,
 
        // NOTE: If you add a new value, make sure to update the ToString() method below!
        Max
    };
 
    PROJECTS_API ELoadingPhase::Type FromString( const TCHAR *Text );
 
    PROJECTS_API const TCHAR* ToString( const ELoadingPhase::Type Value );
};
 
namespace EHostType
{
    enum Type : int
    {
        // Loads on all targets, except programs.
        Runtime,
        
        // Loads on all targets, except programs and the editor running commandlets.
        RuntimeNoCommandlet,
        
        // Loads on all targets, including supported programs.
        RuntimeAndProgram,
        
        // Loads only in cooked games.
        CookedOnly,
 
        // Only loads in uncooked games.
        UncookedOnly,
 
        // Deprecated due to ambiguities. Only loads in editor and program targets, but loads in any editor mode (eg. -game, -server).
        // Use UncookedOnly for the same behavior (eg. for editor blueprint nodes needed in uncooked games), or DeveloperTool for modules
        // that can also be loaded in cooked games but should not be shipped (eg. debugging utilities).
        Developer,
 
        // Loads on any targets where bBuildDeveloperTools is enabled.
        DeveloperTool,
 
        // Loads only when the editor is starting up.
        Editor,
        
        // Loads only when the editor is starting up, but not in commandlet mode.
        EditorNoCommandlet,
 
        // Loads only on editor and program targets
        EditorAndProgram,
 
        // Only loads on program targets.
        Program,
        
        // Loads on all targets except dedicated clients.
        ServerOnly,
        
        // Loads on all targets except dedicated servers.
        ClientOnly,
 
        // Loads in editor and client but not in commandlets.
        ClientOnlyNoCommandlet,
        
        //~ NOTE: If you add a new value, make sure to update the ToString() method below!
        Max
    };
 
    PROJECTS_API EHostType::Type FromString( const TCHAR *Text );
 
    PROJECTS_API const TCHAR* ToString( const EHostType::Type Value );
};
 
struct FModuleDescriptor
{
    FName Name;
 
    EHostType::Type Type;
 
    ELoadingPhase::Type LoadingPhase;
 
    TArray<FString> PlatformAllowList;
 
    TArray<FString> PlatformDenyList;
 
    TMap<FString,TArray<FString>> PlatformArchitectureAllowList;
 
    TMap<FString,TArray<FString>> PlatformArchitectureDenyList;
 
    TArray<EBuildTargetType> TargetAllowList;
 
    TArray<EBuildTargetType> TargetDenyList;
 
    TArray<EBuildConfiguration> TargetConfigurationAllowList;
 
    TArray<EBuildConfiguration> TargetConfigurationDenyList;
 
    TArray<FString> ProgramAllowList;
 
    TArray<FString> ProgramDenyList;
 
    TArray<FString> GameTargetAllowList;
 
    TArray<FString> GameTargetDenyList;
    
    TArray<FString> AdditionalDependencies;
 
    bool bHasExplicitPlatforms;
 
 
    PROJECTS_API FModuleDescriptor(const FName InName = NAME_None, EHostType::Type InType = EHostType::Runtime, ELoadingPhase::Type InLoadingPhase = ELoadingPhase::Default);
 
    PROJECTS_API bool Read(const FJsonObject& Object, FText* OutFailReason = nullptr);
 
    PROJECTS_API bool Read(const FJsonObject& Object, FText& OutFailReason);
 
    static PROJECTS_API bool ReadArray(const FJsonObject& Object, const TCHAR* Name, TArray<FModuleDescriptor>& OutModules, FText* OutFailReason = nullptr);
 
    static PROJECTS_API bool ReadArray(const FJsonObject& Object, const TCHAR* Name, TArray<FModuleDescriptor>& OutModules, FText& OutFailReason);
 
    PROJECTS_API void Write(TJsonWriter<>& Writer) const;
 
    PROJECTS_API void UpdateJson(FJsonObject& JsonObject) const;
 
    static PROJECTS_API void WriteArray(TJsonWriter<>& Writer, const TCHAR* ArrayName, const TArray<FModuleDescriptor>& Modules);
 
    static PROJECTS_API void UpdateArray(FJsonObject& JsonObject, const TCHAR* ArrayName, const TArray<FModuleDescriptor>& Modules);
 
    PROJECTS_API bool IsCompiledInConfiguration(const FString& Platform, EBuildConfiguration Configuration, const FString& TargetName, EBuildTargetType TargetType, bool bBuildDeveloperTools, bool bBuildRequiresCookedData, const FString& Architecture = FString()) const;
 
    PROJECTS_API bool IsCompiledInCurrentConfiguration() const;
 
    PROJECTS_API bool IsLoadedInCurrentConfiguration() const;
 
    static PROJECTS_API void LoadModulesForPhase(ELoadingPhase::Type LoadingPhase, const TArray<FModuleDescriptor>& Modules, TMap<FName, EModuleLoadResult>& ModuleLoadErrors);
 
    static PROJECTS_API void UnloadModulesForPhase(ELoadingPhase::Type LoadingPhase, const TArray<FModuleDescriptor>& Modules, TMap<FName, EModuleUnloadResult>& OutErrors, bool bSkipUnload = false, bool bAllowUnloadCode = true);
 
#if !IS_MONOLITHIC
    static PROJECTS_API bool CheckModuleCompatibility(const TArray<FModuleDescriptor>& Modules, TArray<FString>& OutIncompatibleFiles);
#endif
};
 
struct FModuleContextInfo
{
    FString ModuleSourcePath;
 
    FString ModuleName;
 
    EHostType::Type ModuleType;
};