/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Mac) || (Target.Platform == UnrealTargetPlatform.Linux))
{
bool bBuildShaderFormats = Target.bForceBuildShaderFormats;
if (!Target.bBuildRequiresCookedData)
{
if (ModuleName == "Engine")
{
if (Target.bBuildDeveloperTools)
{
Rules.DynamicallyLoadedModuleNames.Add("LuminTargetPlatform");
}
}
else if (ModuleName == "TargetPlatform")
{
bBuildShaderFormats = true;
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
}
}
// allow standalone tools to use targetplatform modules, without needing Engine
if (ModuleName == "TargetPlatform")
{
if (Target.bForceBuildTargetPlatforms)
{
Rules.DynamicallyLoadedModuleNames.Add("LuminTargetPlatform");
}
}
}
}
/// <summary>
/// Allow all registered build platforms to modify the newly created module
/// passed in for the given platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public static void PlatformModifyHostModuleRules(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
foreach (KeyValuePair <UnrealTargetPlatform, UEBuildPlatform> PlatformEntry in BuildPlatformDictionary)
{
PlatformEntry.Value.ModifyModuleRulesForOtherPlatform(ModuleName, Rules, Target);
}
}
/// <summary>
/// Modify the rules for a newly created module, in a target that's being built for this platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForActivePlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
bool bBuildShaderFormats = Target.bForceBuildShaderFormats;
if (!Target.bBuildRequiresCookedData)
{
if (ModuleName == "TargetPlatform")
{
bBuildShaderFormats = true;
}
}
// allow standalone tools to use target platform modules, without needing Engine
if (ModuleName == "TargetPlatform")
{
if (Target.bForceBuildTargetPlatforms)
{
Rules.DynamicallyLoadedModuleNames.Add("LinuxTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxNoEditorTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxClientTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxServerTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("AllDesktopTargetPlatform");
}
if (bBuildShaderFormats)
{
Rules.DynamicallyLoadedModuleNames.Add("ShaderFormatOpenGL");
Rules.DynamicallyLoadedModuleNames.Add("VulkanShaderFormat");
}
}
}
/// <summary>
/// Modify the rules for a newly created module, in a target that's being built for this platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForActivePlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
if (!UEBuildConfiguration.bBuildRequiresCookedData)
{
if (ModuleName == "TargetPlatform")
{
bBuildShaderFormats = true;
}
}
// allow standalone tools to use target platform modules, without needing Engine
if (ModuleName == "TargetPlatform")
{
if (UEBuildConfiguration.bForceBuildTargetPlatforms)
{
Rules.DynamicallyLoadedModuleNames.Add("MacTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("MacNoEditorTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("MacClientTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("MacServerTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("AllDesktopTargetPlatform");
}
if (bBuildShaderFormats)
{
// Rules.DynamicallyLoadedModuleNames.Add("ShaderFormatD3D");
Rules.DynamicallyLoadedModuleNames.Add("ShaderFormatOpenGL");
Rules.DynamicallyLoadedModuleNames.Add("MetalShaderFormat");
Rules.DynamicallyLoadedModuleNames.Remove("VulkanRHI");
Rules.DynamicallyLoadedModuleNames.Add("VulkanShaderFormat");
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="InName">Name of the module</param>
/// <param name="InType">Type of the module, for UHT</param>
/// <param name="InModuleDirectory">Base directory for the module</param>
/// <param name="InRules">Rules for this module</param>
/// <param name="InRulesFile">Path to the rules file</param>
/// <param name="InRuntimeDependencies">List of runtime dependencies</param>
public UEBuildModule(string InName, UHTModuleType InType, DirectoryReference InModuleDirectory, ModuleRules InRules, FileReference InRulesFile, List <RuntimeDependency> InRuntimeDependencies)
{
Name = InName;
Type = InType;
ModuleDirectory = InModuleDirectory;
Rules = InRules;
RulesFile = InRulesFile;
ModuleApiDefine = Name.ToUpperInvariant() + "_API";
PublicDefinitions = HashSetFromOptionalEnumerableStringParameter(InRules.PublicDefinitions);
PublicIncludePaths = CreateDirectoryHashSet(InRules.PublicIncludePaths);
PublicSystemIncludePaths = CreateDirectoryHashSet(InRules.PublicSystemIncludePaths);
PublicLibraryPaths = CreateDirectoryHashSet(InRules.PublicLibraryPaths);
PublicAdditionalLibraries = HashSetFromOptionalEnumerableStringParameter(InRules.PublicAdditionalLibraries);
PublicFrameworks = HashSetFromOptionalEnumerableStringParameter(InRules.PublicFrameworks);
PublicWeakFrameworks = HashSetFromOptionalEnumerableStringParameter(InRules.PublicWeakFrameworks);
PublicAdditionalFrameworks = InRules.PublicAdditionalFrameworks == null ? new HashSet <UEBuildFramework>() : new HashSet <UEBuildFramework>(InRules.PublicAdditionalFrameworks);
PublicAdditionalShadowFiles = HashSetFromOptionalEnumerableStringParameter(InRules.PublicAdditionalShadowFiles);
PublicAdditionalBundleResources = InRules.AdditionalBundleResources == null ? new HashSet <UEBuildBundleResource>() : new HashSet <UEBuildBundleResource>(InRules.AdditionalBundleResources);
PublicDelayLoadDLLs = HashSetFromOptionalEnumerableStringParameter(InRules.PublicDelayLoadDLLs);
PrivateIncludePaths = CreateDirectoryHashSet(InRules.PrivateIncludePaths);
RuntimeDependencies = InRuntimeDependencies;
IsRedistributableOverride = InRules.IsRedistributableOverride;
WhitelistRestrictedFolders = new HashSet <DirectoryReference>(InRules.WhitelistRestrictedFolders.Select(x => DirectoryReference.Combine(ModuleDirectory, x)));
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
{
if (!Target.bBuildRequiresCookedData)
{
if (ModuleName == "Engine")
{
if (Target.bBuildDeveloperTools)
{
Rules.DynamicallyLoadedModuleNames.Add("LinuxTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxNoEditorTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxClientTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxServerTargetPlatform");
}
}
}
// allow standalone tools to use targetplatform modules, without needing Engine
if (Target.bForceBuildTargetPlatforms && ModuleName == "TargetPlatform")
{
Rules.DynamicallyLoadedModuleNames.Add("LinuxTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxNoEditorTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxClientTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxServerTargetPlatform");
}
}
}
/// <summary>
/// Modify the rules for a newly created module, in a target that's being built for this platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForActivePlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
bool bBuildShaderFormats = Target.bForceBuildShaderFormats;
if (!Target.bBuildRequiresCookedData)
{
if (ModuleName == "TargetPlatform")
{
bBuildShaderFormats = true;
}
}
// allow standalone tools to use target platform modules, without needing Engine
if (ModuleName == "TargetPlatform")
{
if (Target.bForceBuildTargetPlatforms)
{
Rules.DynamicallyLoadedModuleNames.Add("WindowsTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("WindowsNoEditorTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("WindowsServerTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("WindowsClientTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("AllDesktopTargetPlatform");
}
if (bBuildShaderFormats)
{
Rules.DynamicallyLoadedModuleNames.Add("ShaderFormatD3D");
Rules.DynamicallyLoadedModuleNames.Add("ShaderFormatOpenGL");
Rules.DynamicallyLoadedModuleNames.Remove("VulkanRHI");
Rules.DynamicallyLoadedModuleNames.Add("VulkanShaderFormat");
}
}
if (ModuleName == "D3D11RHI")
{
// To enable platform specific D3D11 RHI Types
Rules.PrivateIncludePaths.Add("Runtime/Windows/D3D11RHI/Private/Windows");
}
if (ModuleName == "D3D12RHI")
{
if (Target.WindowsPlatform.bPixProfilingEnabled && Target.Platform == UnrealTargetPlatform.Win64 && Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test)
{
// Define to indicate profiling enabled (64-bit only)
Rules.Definitions.Add("D3D12_PROFILING_ENABLED=1");
Rules.Definitions.Add("PROFILE");
}
else
{
Rules.Definitions.Add("D3D12_PROFILING_ENABLED=0");
}
// To enable platform specific D3D12 RHI Types
Rules.PrivateIncludePaths.Add("Runtime/Windows/D3D12RHI/Private/Windows");
}
// Delay-load D3D12 so we can use the latest features and still run on downlevel versions of the OS
Rules.PublicDelayLoadDLLs.Add("d3d12.dll");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="Rules">Rules for this module</param>
public UEBuildModule(ModuleRules Rules)
{
this.Rules = Rules;
ModuleApiDefine = Name.ToUpperInvariant() + "_API";
PublicDefinitions = HashSetFromOptionalEnumerableStringParameter(Rules.PublicDefinitions);
PublicIncludePaths = CreateDirectoryHashSet(Rules.PublicIncludePaths);
PublicSystemIncludePaths = CreateDirectoryHashSet(Rules.PublicSystemIncludePaths);
PublicLibraryPaths = CreateDirectoryHashSet(Rules.PublicLibraryPaths);
PublicAdditionalLibraries = HashSetFromOptionalEnumerableStringParameter(Rules.PublicAdditionalLibraries);
PublicFrameworks = HashSetFromOptionalEnumerableStringParameter(Rules.PublicFrameworks);
PublicWeakFrameworks = HashSetFromOptionalEnumerableStringParameter(Rules.PublicWeakFrameworks);
PublicAdditionalFrameworks = Rules.PublicAdditionalFrameworks == null ? new HashSet <UEBuildFramework>() : new HashSet <UEBuildFramework>(Rules.PublicAdditionalFrameworks);
PublicAdditionalShadowFiles = HashSetFromOptionalEnumerableStringParameter(Rules.PublicAdditionalShadowFiles);
PublicAdditionalBundleResources = Rules.AdditionalBundleResources == null ? new HashSet <UEBuildBundleResource>() : new HashSet <UEBuildBundleResource>(Rules.AdditionalBundleResources);
PublicDelayLoadDLLs = HashSetFromOptionalEnumerableStringParameter(Rules.PublicDelayLoadDLLs);
if (Rules.bUsePrecompiled)
{
PrivateIncludePaths = new HashSet <DirectoryReference>();
}
else
{
PrivateIncludePaths = CreateDirectoryHashSet(Rules.PrivateIncludePaths);
}
IsRedistributableOverride = Rules.IsRedistributableOverride;
WhitelistRestrictedFolders = new HashSet <DirectoryReference>(Rules.WhitelistRestrictedFolders.Select(x => DirectoryReference.Combine(ModuleDirectory, x)));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="InName">Name of the module</param>
/// <param name="InType">Type of the module, for UHT</param>
/// <param name="InModuleDirectory">Base directory for the module</param>
/// <param name="InRules">Rules for this module</param>
/// <param name="InRulesFile">Path to the rules file</param>
public UEBuildModule(string InName, UHTModuleType InType, DirectoryReference InModuleDirectory, ModuleRules InRules, FileReference InRulesFile)
{
Name = InName;
Type = InType;
ModuleDirectory = InModuleDirectory;
Rules = InRules;
RulesFile = InRulesFile;
NormalizedModuleIncludePath = Utils.CleanDirectorySeparators(ModuleDirectory.MakeRelativeTo(UnrealBuildTool.EngineSourceDirectory), '/');
ModuleApiDefine = Name.ToUpperInvariant() + "_API";
PublicDefinitions = HashSetFromOptionalEnumerableStringParameter(InRules.Definitions);
PublicIncludePaths = HashSetFromOptionalEnumerableStringParameter(InRules.PublicIncludePaths);
PublicSystemIncludePaths = HashSetFromOptionalEnumerableStringParameter(InRules.PublicSystemIncludePaths);
PublicLibraryPaths = HashSetFromOptionalEnumerableStringParameter(InRules.PublicLibraryPaths);
PublicAdditionalLibraries = HashSetFromOptionalEnumerableStringParameter(InRules.PublicAdditionalLibraries);
PublicFrameworks = HashSetFromOptionalEnumerableStringParameter(InRules.PublicFrameworks);
PublicWeakFrameworks = HashSetFromOptionalEnumerableStringParameter(InRules.PublicWeakFrameworks);
PublicAdditionalFrameworks = InRules.PublicAdditionalFrameworks == null ? new HashSet <UEBuildFramework>() : new HashSet <UEBuildFramework>(InRules.PublicAdditionalFrameworks);
PublicAdditionalShadowFiles = HashSetFromOptionalEnumerableStringParameter(InRules.PublicAdditionalShadowFiles);
PublicAdditionalBundleResources = InRules.AdditionalBundleResources == null ? new HashSet <UEBuildBundleResource>() : new HashSet <UEBuildBundleResource>(InRules.AdditionalBundleResources);
PublicDelayLoadDLLs = HashSetFromOptionalEnumerableStringParameter(InRules.PublicDelayLoadDLLs);
PrivateIncludePaths = HashSetFromOptionalEnumerableStringParameter(InRules.PrivateIncludePaths);
RuntimeDependencies = (InRules.RuntimeDependencies == null) ? new RuntimeDependencyList() : new RuntimeDependencyList(InRules.RuntimeDependencies);
IsRedistributableOverride = InRules.IsRedistributableOverride;
WhitelistRestrictedFolders = new HashSet <DirectoryReference>(InRules.WhitelistRestrictedFolders.Select(x => DirectoryReference.Combine(ModuleDirectory, x)));
}
/// <summary>
/// Modify the rules for a newly created module, in a target that's being built for this platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForActivePlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
if (!UEBuildConfiguration.bBuildRequiresCookedData)
{
if (ModuleName == "TargetPlatform")
{
bBuildShaderFormats = true;
}
}
// allow standalone tools to use target platform modules, without needing Engine
if (ModuleName == "TargetPlatform")
{
if (UEBuildConfiguration.bForceBuildTargetPlatforms)
{
Rules.DynamicallyLoadedModuleNames.Add("MacTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("MacNoEditorTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("MacClientTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("MacServerTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("AllDesktopTargetPlatform");
}
if (bBuildShaderFormats)
{
// Rules.DynamicallyLoadedModuleNames.Add("ShaderFormatD3D");
Rules.DynamicallyLoadedModuleNames.Add("ShaderFormatOpenGL");
Rules.DynamicallyLoadedModuleNames.Add("MetalShaderFormat");
Rules.DynamicallyLoadedModuleNames.Remove("VulkanRHI");
Rules.DynamicallyLoadedModuleNames.Add("VulkanShaderFormat");
}
}
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Mac) || (Target.Platform == UnrealTargetPlatform.Linux))
{
bool bBuildShaderFormats = Target.bForceBuildShaderFormats;
if (!Target.bBuildRequiresCookedData)
{
if (ModuleName == "Engine")
{
if (Target.bBuildDeveloperTools)
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_PVRTCTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ATCTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_DXTTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ETC1TargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ETC1aTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ETC2TargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ASTCTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_MultiTargetPlatform");
}
}
else if (ModuleName == "TargetPlatform")
{
bBuildShaderFormats = true;
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("TextureFormatAndroid"); // ATITC, ETC1 and ETC2
if (Target.bBuildDeveloperTools)
{
//Rules.DynamicallyLoadedModuleNames.Add("AudioFormatADPCM"); //@todo android: android audio
}
}
}
// allow standalone tools to use targetplatform modules, without needing Engine
if (ModuleName == "TargetPlatform")
{
if (Target.bForceBuildTargetPlatforms)
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_PVRTCTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ATCTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_DXTTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ETC1TargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ETC1aTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ETC2TargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ASTCTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_MultiTargetPlatform");
}
if (bBuildShaderFormats)
{
//Rules.DynamicallyLoadedModuleNames.Add("ShaderFormatAndroid"); //@todo android: ShaderFormatAndroid
}
}
}
}
public PrecompileHeaderEnvironment( string InitModuleName, string InitPCHHeaderNameInCode, FileItem InitPrecompiledHeaderIncludeFilename, CPPCLRMode InitCLRMode, ModuleRules.CodeOptimization InitOptimizeCode )
{
ModuleName = InitModuleName;
PCHHeaderNameInCode = InitPCHHeaderNameInCode;
PrecompiledHeaderIncludeFilename = InitPrecompiledHeaderIncludeFilename;
CLRMode = InitCLRMode;
OptimizeCode = InitOptimizeCode;
}
/// <summary>
/// Creates an instance of a module rules descriptor object for the specified module name
/// </summary>
/// <param name="ModuleName">Name of the module</param>
/// <param name="Target">Information about the target associated with this module</param>
/// <param name="ReferenceChain">Chain of references leading to this module</param>
/// <returns>Compiled module rule info</returns>
public ModuleRules CreateModuleRules(string ModuleName, ReadOnlyTargetRules Target, string ReferenceChain)
{
// Currently, we expect the user's rules object type name to be the same as the module name
string ModuleTypeName = ModuleName;
// Make sure the module file is known to us
FileReference ModuleFileName;
if (!ModuleNameToModuleFile.TryGetValue(ModuleName, out ModuleFileName))
{
if (Parent == null)
{
throw new BuildException("Could not find definition for module '{0}' (referenced via {1})", ModuleName, ReferenceChain);
}
else
{
return(Parent.CreateModuleRules(ModuleName, Target, ReferenceChain));
}
}
// The build module must define a type named 'Rules' that derives from our 'ModuleRules' type.
Type RulesObjectType = GetModuleRulesTypeInternal(ModuleName);
if (RulesObjectType == null)
{
throw new BuildException("Expecting to find a type to be declared in a module rules named '{0}' in {1}. This type must derive from the 'ModuleRules' type defined by Unreal Build Tool.", ModuleTypeName, CompiledAssembly.FullName);
}
// Create an instance of the module's rules object
try
{
// Create an uninitialized ModuleRules object and set some defaults.
ModuleRules RulesObject = (ModuleRules)FormatterServices.GetUninitializedObject(RulesObjectType);
RulesObject.Name = ModuleName;
RulesObject.File = ModuleFileName;
RulesObject.Directory = ModuleFileName.Directory;
ModuleFileToPluginInfo.TryGetValue(RulesObject.File, out RulesObject.Plugin);
RulesObject.bTreatAsEngineModule = bContainsEngineModules;
RulesObject.bUseBackwardsCompatibleDefaults = bUseBackwardsCompatibleDefaults && Target.bUseBackwardsCompatibleDefaults;
RulesObject.bPrecompile = (RulesObject.bTreatAsEngineModule || ModuleName.Equals("UE4Game", StringComparison.OrdinalIgnoreCase)) && Target.bPrecompile;
RulesObject.bUsePrecompiled = bReadOnly;
// Call the constructor
ConstructorInfo Constructor = RulesObjectType.GetConstructor(new Type[] { typeof(ReadOnlyTargetRules) });
if (Constructor == null)
{
throw new BuildException("No valid constructor found for {0}.", ModuleName);
}
Constructor.Invoke(RulesObject, new object[] { Target });
return(RulesObject);
}
catch (Exception Ex)
{
Exception MessageEx = (Ex is TargetInvocationException && Ex.InnerException != null)? Ex.InnerException : Ex;
throw new BuildException(Ex, "Unable to instantiate module '{0}': {1}\n(referenced via {2})", ModuleName, MessageEx.ToString(), ReferenceChain);
}
}
/// <summary>
/// Modify the rules for a newly created module, in a target that's being built for this platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForActivePlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
if (ModuleName == "Core")
{
//Rules.PrivateDependencyModuleNames.Add("HoloLensSDK");
}
else if (ModuleName == "Engine")
{
Rules.PrivateDependencyModuleNames.Add("zlib");
Rules.PrivateDependencyModuleNames.Add("UElibPNG");
Rules.PublicDependencyModuleNames.Add("UEOgg");
Rules.PublicDependencyModuleNames.Add("Vorbis");
}
else if (ModuleName == "D3D11RHI")
{
Rules.PublicDefinitions.Add("D3D11_WITH_DWMAPI=0");
Rules.PublicDefinitions.Add("WITH_DX_PERF=0");
}
else if (ModuleName == "D3D12RHI")
{
// To enable platform specific D3D12 RHI Types
Rules.PrivateIncludePaths.Add("Runtime/D3D12RHI/Private/HoloLens");
}
else if (ModuleName == "DX11")
{
// Clear out all the Windows include paths and libraries...
// The HoloLensSDK module handles proper paths and libs for HoloLens.
// However, the D3D11RHI module will include the DX11 module.
Rules.PublicIncludePaths.Clear();
Rules.PublicSystemLibraryPaths.Clear();
Rules.PublicSystemLibraries.Clear();
Rules.PublicAdditionalLibraries.Clear();
Rules.PublicDefinitions.Remove("WITH_D3DX_LIBS=1");
Rules.PublicDefinitions.Add("WITH_D3DX_LIBS=0");
Rules.PublicAdditionalLibraries.Remove("X3DAudio.lib");
Rules.PublicAdditionalLibraries.Remove("XAPOFX.lib");
}
else if (ModuleName == "XAudio2")
{
Rules.PublicDefinitions.Add("XAUDIO_SUPPORTS_XMA2WAVEFORMATEX=0");
Rules.PublicDefinitions.Add("XAUDIO_SUPPORTS_DEVICE_DETAILS=0");
Rules.PublicDefinitions.Add("XAUDIO2_SUPPORTS_MUSIC=0");
Rules.PublicDefinitions.Add("XAUDIO2_SUPPORTS_SENDLIST=1");
Rules.PublicSystemLibraries.Add("XAudio2.lib");
}
else if (ModuleName == "DX11Audio")
{
Rules.PublicAdditionalLibraries.Remove("X3DAudio.lib");
Rules.PublicAdditionalLibraries.Remove("XAPOFX.lib");
}
}
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
base.ModifyModuleRulesForOtherPlatform(ModuleName, Rules, Target);
if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Mac))
{
// allow standalone tools to use targetplatform modules, without needing Engine
if (Target.bForceBuildTargetPlatforms)
{
// @todo tvos: Make the module
// InModule.AddPlatformSpecificDynamicallyLoadedModule("TVOSTargetPlatform");
}
}
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Mac)
{
// allow standalone tools to use targetplatform modules, without needing Engine
if ((!UEBuildConfiguration.bBuildRequiresCookedData &&
ModuleName == "Engine" &&
UEBuildConfiguration.bBuildDeveloperTools) ||
(UEBuildConfiguration.bForceBuildTargetPlatforms && ModuleName == "TargetPlatform"))
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
}
}
}
/// <summary>
/// Modify the rules for a newly created module, in a target that's being built for this platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForActivePlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
if (ModuleName == "Core")
{
Rules.PublicIncludePaths.Add("Runtime/Core/Public/HTML5");
Rules.PublicDependencyModuleNames.Add("zlib");
}
else if (ModuleName == "Engine")
{
Rules.PrivateDependencyModuleNames.Add("zlib");
Rules.PrivateDependencyModuleNames.Add("UElibPNG");
Rules.PublicDependencyModuleNames.Add("UEOgg");
Rules.PublicDependencyModuleNames.Add("Vorbis");
}
}
/// <summary>
/// Modify the rules for a newly created module, in a target that's being built for this platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForActivePlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
if (ModuleName == "Core")
{
Rules.PublicIncludePaths.Add("Runtime/Core/Public/HTML5");
Rules.PublicDependencyModuleNames.Add("zlib");
}
else if (ModuleName == "Engine")
{
Rules.PrivateDependencyModuleNames.Add("zlib");
Rules.PrivateDependencyModuleNames.Add("UElibPNG");
Rules.PublicDependencyModuleNames.Add("UEOgg");
Rules.PublicDependencyModuleNames.Add("Vorbis");
}
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
// don't do any target platform stuff if SDK is not available
if (!UEBuildPlatform.IsPlatformAvailable(Platform))
{
return;
}
if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Mac) || (Target.Platform == UnrealTargetPlatform.Linux))
{
bool bBuildShaderFormats = Target.bForceBuildShaderFormats;
if (!Target.bBuildRequiresCookedData)
{
if (ModuleName == "Engine")
{
if (Target.bBuildDeveloperTools)
{
Rules.DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
}
}
else if (ModuleName == "TargetPlatform")
{
bBuildShaderFormats = true;
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatAndroid"); // ETC2
if (Target.bBuildDeveloperTools)
{
//Rules.DynamicallyLoadedModuleNames.Add("AudioFormatADPCM"); //@todo android: android audio
}
}
}
// allow standalone tools to use targetplatform modules, without needing Engine
if (ModuleName == "TargetPlatform")
{
if (Target.bForceBuildTargetPlatforms)
{
Rules.DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
}
if (bBuildShaderFormats)
{
//Rules.DynamicallyLoadedModuleNames.Add("ShaderFormatAndroid"); //@todo android: ShaderFormatAndroid
}
}
}
}
public UEBuildModuleExternal(
UHTModuleType InType,
string InName,
DirectoryReference InModuleDirectory,
ModuleRules InRules,
FileReference InRulesFile
)
: base(
InType: InType,
InName: InName,
InModuleDirectory: InModuleDirectory,
InRules: InRules,
InRulesFile: InRulesFile
)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="Rules">Rules for this module</param>
public UEBuildModule(ModuleRules Rules)
{
this.Rules = Rules;
ModuleApiDefine = Name.ToUpperInvariant() + "_API";
PublicDefinitions = HashSetFromOptionalEnumerableStringParameter(Rules.PublicDefinitions);
PublicIncludePaths = CreateDirectoryHashSet(Rules.PublicIncludePaths);
PublicSystemIncludePaths = CreateDirectoryHashSet(Rules.PublicSystemIncludePaths);
PublicLibraryPaths = CreateDirectoryHashSet(Rules.PublicLibraryPaths);
PublicAdditionalLibraries = HashSetFromOptionalEnumerableStringParameter(Rules.PublicAdditionalLibraries);
PublicFrameworks = HashSetFromOptionalEnumerableStringParameter(Rules.PublicFrameworks);
PublicWeakFrameworks = HashSetFromOptionalEnumerableStringParameter(Rules.PublicWeakFrameworks);
PublicAdditionalFrameworks = new HashSet <UEBuildFramework>();
if (Rules.PublicAdditionalFrameworks != null)
{
foreach (ModuleRules.Framework FrameworkRules in Rules.PublicAdditionalFrameworks)
{
UEBuildFramework Framework;
if (String.IsNullOrEmpty(FrameworkRules.ZipPath))
{
Framework = new UEBuildFramework(FrameworkRules.Name, FrameworkRules.CopyBundledAssets);
}
else
{
Framework = new UEBuildFramework(FrameworkRules.Name, FileReference.Combine(ModuleDirectory, FrameworkRules.ZipPath), DirectoryReference.Combine(UnrealBuildTool.EngineDirectory, "Intermediate", "UnzippedFrameworks", Name, Path.GetFileNameWithoutExtension(FrameworkRules.ZipPath)), FrameworkRules.CopyBundledAssets);
}
PublicAdditionalFrameworks.Add(Framework);
}
}
PublicAdditionalBundleResources = Rules.AdditionalBundleResources == null ? new HashSet <UEBuildBundleResource>() : new HashSet <UEBuildBundleResource>(Rules.AdditionalBundleResources.Select(x => new UEBuildBundleResource(x)));
PublicDelayLoadDLLs = HashSetFromOptionalEnumerableStringParameter(Rules.PublicDelayLoadDLLs);
if (Rules.bUsePrecompiled)
{
PrivateIncludePaths = new HashSet <DirectoryReference>();
}
else
{
PrivateIncludePaths = CreateDirectoryHashSet(Rules.PrivateIncludePaths);
}
IsRedistributableOverride = Rules.IsRedistributableOverride;
WhitelistRestrictedFolders = new HashSet <DirectoryReference>(Rules.WhitelistRestrictedFolders.Select(x => DirectoryReference.Combine(ModuleDirectory, x)));
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealTargetPlatform.Mac ||
Target.Platform == UnrealTargetPlatform.Linux)
{
// allow standalone tools to use targetplatform modules, without needing Engine
if ((!Target.bBuildRequiresCookedData &&
ModuleName == "Engine" &&
Target.bBuildDeveloperTools) ||
(Target.bForceBuildTargetPlatforms && ModuleName == "TargetPlatform"))
{
Rules.DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
}
}
}
public UEBuildModuleExternal(
UHTModuleType InType,
string InName,
DirectoryReference InModuleDirectory,
ModuleRules InRules,
FileReference InRulesFile,
List <RuntimeDependency> InRuntimeDependencies
)
: base(
InType: InType,
InName: InName,
InModuleDirectory: InModuleDirectory,
InRules: InRules,
InRulesFile: InRulesFile,
InRuntimeDependencies: InRuntimeDependencies
)
{
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Mac))
{
bool bBuildShaderFormats = Target.bForceBuildShaderFormats;
if (!Target.bBuildRequiresCookedData)
{
if (ModuleName == "Engine")
{
if (Target.bBuildDeveloperTools)
{
Rules.DynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("TVOSTargetPlatform");
}
}
else if (ModuleName == "TargetPlatform")
{
bBuildShaderFormats = true;
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatETC2");
if (Target.bBuildDeveloperTools && Target.bCompileAgainstEngine)
{
Rules.DynamicallyLoadedModuleNames.Add("AudioFormatADPCM");
}
}
}
// allow standalone tools to use targetplatform modules, without needing Engine
if (ModuleName == "TargetPlatform")
{
if (Target.bForceBuildTargetPlatforms)
{
Rules.DynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("TVOSTargetPlatform");
}
if (bBuildShaderFormats)
{
Rules.DynamicallyLoadedModuleNames.Add("MetalShaderFormat");
}
}
}
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Mac))
{
bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
if (!UEBuildConfiguration.bBuildRequiresCookedData)
{
if (ModuleName == "Engine")
{
if (UEBuildConfiguration.bBuildDeveloperTools)
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("TVOSTargetPlatform");
}
}
else if (ModuleName == "TargetPlatform")
{
bBuildShaderFormats = true;
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
if (UEBuildConfiguration.bBuildDeveloperTools)
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("AudioFormatADPCM");
}
}
}
// allow standalone tools to use targetplatform modules, without needing Engine
if (ModuleName == "TargetPlatform")
{
if (UEBuildConfiguration.bForceBuildTargetPlatforms)
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("TVOSTargetPlatform");
}
if (bBuildShaderFormats)
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("MetalShaderFormat");
}
}
}
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
if (ProjectFileGenerator.bGenerateProjectFiles)
{
// Use latest SDK for Intellisense purposes
WindowsCompiler CompilerForSdkRestriction = Target.HoloLensPlatform.Compiler != WindowsCompiler.Default ? Target.HoloLensPlatform.Compiler : Target.WindowsPlatform.Compiler;
if (CompilerForSdkRestriction != WindowsCompiler.Default)
{
Version OutWin10SDKVersion;
DirectoryReference OutSdkDir;
if (WindowsExports.TryGetWindowsSdkDir(Target.HoloLensPlatform.Win10SDKVersionString, out OutWin10SDKVersion, out OutSdkDir))
{
Rules.PublicDefinitions.Add(string.Format("WIN10_SDK_VERSION={0}", OutWin10SDKVersion.Build));
}
}
}
}
}
/// <summary>
/// Modify the rules for a newly created module, in a target that's being built for this platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForActivePlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
bool bBuildShaderFormats = Target.bForceBuildShaderFormats;
if (!Target.bBuildRequiresCookedData)
{
if (ModuleName == "TargetPlatform")
{
bBuildShaderFormats = true;
}
}
// allow standalone tools to use target platform modules, without needing Engine
if (ModuleName == "TargetPlatform")
{
if (Target.bForceBuildTargetPlatforms)
{
Rules.DynamicallyLoadedModuleNames.Add("LinuxTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxNoEditorTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxClientTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxServerTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("AllDesktopTargetPlatform");
}
if (bBuildShaderFormats)
{
// Rules.DynamicallyLoadedModuleNames.Add("ShaderFormatD3D");
Rules.DynamicallyLoadedModuleNames.Add("ShaderFormatOpenGL");
Rules.DynamicallyLoadedModuleNames.Add("VulkanShaderFormat");
}
}
else if (ModuleName == "Launch")
{
// this is a hack to influence symbol resolution on Linux that results in global delete being called from within CEF
if (Target.LinkType != TargetLinkType.Monolithic && Target.bCompileCEF3)
{
Rules.AddEngineThirdPartyPrivateStaticDependencies(Target, "CEF3");
}
}
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
// don't do any target platform stuff if SDK is not available
if (!UEBuildPlatform.IsPlatformAvailable(Platform))
{
return;
}
if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
{
if (!Target.bBuildRequiresCookedData)
{
if (ModuleName == "Engine")
{
if (Target.bBuildDeveloperTools)
{
Rules.DynamicallyLoadedModuleNames.Add("LinuxTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxNoEditorTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxAArch64NoEditorTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxClientTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxAArch64ClientTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxServerTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxAArch64ServerTargetPlatform");
}
}
}
// allow standalone tools to use targetplatform modules, without needing Engine
if (Target.bForceBuildTargetPlatforms && ModuleName == "TargetPlatform")
{
Rules.DynamicallyLoadedModuleNames.Add("LinuxTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxNoEditorTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxAArch64NoEditorTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxClientTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxAArch64ClientTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxServerTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("LinuxAArch64ServerTargetPlatform");
}
}
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
// This code has been removed because it causes a full rebuild after generating project files (since response files are overwritten with different defines).
#if false
if (Target.Platform == UnrealTargetPlatform.Win64)
{
if (ProjectFileGenerator.bGenerateProjectFiles)
{
// Use latest SDK for Intellisense purposes
WindowsCompiler CompilerForSdkRestriction = Target.HoloLensPlatform.Compiler != WindowsCompiler.Default ? Target.HoloLensPlatform.Compiler : Target.WindowsPlatform.Compiler;
if (CompilerForSdkRestriction != WindowsCompiler.Default)
{
Version OutWin10SDKVersion;
DirectoryReference OutSdkDir;
if (WindowsExports.TryGetWindowsSdkDir(Target.HoloLensPlatform.Win10SDKVersionString, out OutWin10SDKVersion, out OutSdkDir))
{
Rules.PublicDefinitions.Add(string.Format("WIN10_SDK_VERSION={0}", OutWin10SDKVersion.Build));
}
}
}
}
#endif
}
/// <summary>
/// Modify the rules for a newly created module, in a target that's being built for this platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForActivePlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
}
public UEBuildModuleExternal(ModuleRules Rules, DirectoryReference IntermediateDirectory)
: base(Rules, IntermediateDirectory)
{
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Mac) || (Target.Platform == UnrealTargetPlatform.Linux))
{
bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
if (!UEBuildConfiguration.bBuildRequiresCookedData)
{
if (ModuleName == "Engine")
{
if (UEBuildConfiguration.bBuildDeveloperTools)
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_PVRTCTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ATCTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_DXTTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ETC1TargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ETC2TargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ASTCTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_MultiTargetPlatform");
}
}
else if (ModuleName == "TargetPlatform")
{
bBuildShaderFormats = true;
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("TextureFormatAndroid"); // ATITC, ETC1 and ETC2
if (UEBuildConfiguration.bBuildDeveloperTools)
{
//Rules.DynamicallyLoadedModuleNames.Add("AudioFormatADPCM"); //@todo android: android audio
}
}
}
// allow standalone tools to use targetplatform modules, without needing Engine
if (ModuleName == "TargetPlatform")
{
if (UEBuildConfiguration.bForceBuildTargetPlatforms)
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_PVRTCTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ATCTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_DXTTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ETC1TargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ETC2TargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_ASTCTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("Android_MultiTargetPlatform");
}
if (bBuildShaderFormats)
{
//Rules.DynamicallyLoadedModuleNames.Add("ShaderFormatAndroid"); //@todo android: ShaderFormatAndroid
}
}
}
}
public UEBuildModuleCPPCLR(
UEBuildTarget InTarget,
string InName,
UEBuildModuleType InType,
string InModuleDirectory,
string InGeneratedCodeDirectory,
bool? InIsRedistributableOverride,
IntelliSenseGatherer InIntelliSenseGatherer,
IEnumerable<FileItem> InSourceFiles,
IEnumerable<string> InPublicIncludePaths,
IEnumerable<string> InPublicSystemIncludePaths,
IEnumerable<string> InDefinitions,
IEnumerable<string> InPrivateAssemblyReferences,
IEnumerable<string> InPublicIncludePathModuleNames,
IEnumerable<string> InPublicDependencyModuleNames,
IEnumerable<string> InPublicDelayLoadDLLs,
IEnumerable<string> InPublicAdditionalLibraries,
IEnumerable<string> InPublicFrameworks,
IEnumerable<string> InPublicWeakFrameworks,
IEnumerable<UEBuildFramework> InPublicAdditionalFrameworks,
IEnumerable<string> InPublicAdditionalShadowFiles,
IEnumerable<UEBuildBundleResource> InPublicAdditionalBundleResources,
IEnumerable<string> InPrivateIncludePaths,
IEnumerable<string> InPrivateIncludePathModuleNames,
IEnumerable<string> InPrivateDependencyModuleNames,
IEnumerable<string> InCircularlyReferencedDependentModules,
IEnumerable<string> InDynamicallyLoadedModuleNames,
IEnumerable<string> InPlatformSpecificDynamicallyLoadedModuleNames,
IEnumerable<RuntimeDependency> InRuntimeDependencies,
ModuleRules.CodeOptimization InOptimizeCode,
bool InAllowSharedPCH,
string InSharedPCHHeaderFile,
bool InUseRTTI,
bool InEnableBufferSecurityChecks,
bool InFasterWithoutUnity,
int InMinFilesUsingPrecompiledHeaderOverride,
bool InEnableExceptions,
bool InEnableShadowVariableWarnings,
bool bInBuildSourceFiles,
string InBuildCsFilename,
bool bInUseAVX
)
: base(InTarget,InName,InType,InModuleDirectory,InGeneratedCodeDirectory,InIsRedistributableOverride,InIntelliSenseGatherer,
InSourceFiles,InPublicIncludePaths,InPublicSystemIncludePaths,null,InDefinitions,
InPublicIncludePathModuleNames,InPublicDependencyModuleNames,InPublicDelayLoadDLLs,InPublicAdditionalLibraries,InPublicFrameworks,InPublicWeakFrameworks,InPublicAdditionalFrameworks,InPublicAdditionalShadowFiles,InPublicAdditionalBundleResources,
InPrivateIncludePaths,InPrivateIncludePathModuleNames,InPrivateDependencyModuleNames,
InCircularlyReferencedDependentModules, InDynamicallyLoadedModuleNames, InPlatformSpecificDynamicallyLoadedModuleNames, InRuntimeDependencies, InOptimizeCode,
InAllowSharedPCH, InSharedPCHHeaderFile, InUseRTTI, InEnableBufferSecurityChecks, InFasterWithoutUnity, InMinFilesUsingPrecompiledHeaderOverride, true,
InEnableExceptions, InEnableShadowVariableWarnings, bInBuildSourceFiles, InBuildCsFilename, bInUseAVX)
{
PrivateAssemblyReferences = HashSetFromOptionalEnumerableStringParameter(InPrivateAssemblyReferences);
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Mac)
{
// allow standalone tools to use targetplatform modules, without needing Engine
if ((!UEBuildConfiguration.bBuildRequiresCookedData
&& ModuleName == "Engine"
&& UEBuildConfiguration.bBuildDeveloperTools)
|| (UEBuildConfiguration.bForceBuildTargetPlatforms && ModuleName == "TargetPlatform"))
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
}
}
}
/// <summary>
/// Modify the rules for a newly created module, in a target that's being built for this platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForActivePlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
// may need to put some stuff in here to keep Lumin out of other module .cs files
}
public UEBuildModuleCPP(
UEBuildTarget InTarget,
string InName,
UEBuildModuleType InType,
string InModuleDirectory,
string InGeneratedCodeDirectory,
bool? InIsRedistributableOverride,
IntelliSenseGatherer InIntelliSenseGatherer,
IEnumerable<FileItem> InSourceFiles,
IEnumerable<string> InPublicIncludePaths,
IEnumerable<string> InPublicSystemIncludePaths,
IEnumerable<string> InPublicLibraryPaths,
IEnumerable<string> InDefinitions,
IEnumerable<string> InPublicIncludePathModuleNames,
IEnumerable<string> InPublicDependencyModuleNames,
IEnumerable<string> InPublicDelayLoadDLLs,
IEnumerable<string> InPublicAdditionalLibraries,
IEnumerable<string> InPublicFrameworks,
IEnumerable<string> InPublicWeakFrameworks,
IEnumerable<UEBuildFramework> InPublicAdditionalFrameworks,
IEnumerable<string> InPublicAdditionalShadowFiles,
IEnumerable<UEBuildBundleResource> InPublicAdditionalBundleResources,
IEnumerable<string> InPrivateIncludePaths,
IEnumerable<string> InPrivateIncludePathModuleNames,
IEnumerable<string> InPrivateDependencyModuleNames,
IEnumerable<string> InCircularlyReferencedDependentModules,
IEnumerable<string> InDynamicallyLoadedModuleNames,
IEnumerable<string> InPlatformSpecificDynamicallyLoadedModuleNames,
IEnumerable<RuntimeDependency> InRuntimeDependencies,
ModuleRules.CodeOptimization InOptimizeCode,
bool InAllowSharedPCH,
string InSharedPCHHeaderFile,
bool InUseRTTI,
bool InEnableBufferSecurityChecks,
bool InFasterWithoutUnity,
int InMinFilesUsingPrecompiledHeaderOverride,
bool InBuildLocallyWithSNDBS,
bool InEnableExceptions,
bool InEnableShadowVariableWarnings,
bool bInBuildSourceFiles,
string InBuildCsFilename,
bool bInUseAVX
)
: base(InTarget,
InName,
InType,
InModuleDirectory,
InIsRedistributableOverride,
InDefinitions,
InPublicIncludePaths,
InPublicSystemIncludePaths,
InPublicLibraryPaths,
InPublicAdditionalLibraries,
InPublicFrameworks,
InPublicWeakFrameworks,
InPublicAdditionalFrameworks,
InPublicAdditionalShadowFiles,
InPublicAdditionalBundleResources,
InPublicIncludePathModuleNames,
InPublicDependencyModuleNames,
InPublicDelayLoadDLLs,
InPrivateIncludePaths,
InPrivateIncludePathModuleNames,
InPrivateDependencyModuleNames,
InCircularlyReferencedDependentModules,
InDynamicallyLoadedModuleNames,
InPlatformSpecificDynamicallyLoadedModuleNames,
InRuntimeDependencies,
InBuildCsFilename)
{
GeneratedCodeDirectory = InGeneratedCodeDirectory;
IntelliSenseGatherer = InIntelliSenseGatherer;
CategorizeSourceFiles(InSourceFiles, SourceFilesFound);
if (bInBuildSourceFiles)
{
SourceFilesToBuild.CopyFrom(SourceFilesFound);
}
Definitions = HashSetFromOptionalEnumerableStringParameter(InDefinitions);
foreach (var Def in Definitions)
{
Log.TraceVerbose("Compile Env {0}: {1}", Name, Def);
}
OptimizeCode = InOptimizeCode;
bAllowSharedPCH = InAllowSharedPCH;
SharedPCHHeaderFile = InSharedPCHHeaderFile;
bUseRTTI = InUseRTTI;
bUseAVX = bInUseAVX;
bEnableBufferSecurityChecks = InEnableBufferSecurityChecks;
bFasterWithoutUnity = InFasterWithoutUnity;
MinFilesUsingPrecompiledHeaderOverride = InMinFilesUsingPrecompiledHeaderOverride;
bBuildLocallyWithSNDBS = InBuildLocallyWithSNDBS;
bEnableExceptions = InEnableExceptions;
bEnableShadowVariableWarnings = InEnableShadowVariableWarnings;
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
{
if (!UEBuildConfiguration.bBuildRequiresCookedData)
{
if (ModuleName == "Engine")
{
if (UEBuildConfiguration.bBuildDeveloperTools)
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("LinuxTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("LinuxNoEditorTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("LinuxClientTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("LinuxServerTargetPlatform");
}
}
}
// allow standalone tools to use targetplatform modules, without needing Engine
if (UEBuildConfiguration.bForceBuildTargetPlatforms && ModuleName == "TargetPlatform")
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("LinuxTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("LinuxNoEditorTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("LinuxClientTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("LinuxServerTargetPlatform");
}
}
}
protected virtual UEBuildModule InstantiateModule(
ModuleRules RulesObject,
string ModuleName,
UEBuildModuleType ModuleType,
string ModuleDirectory,
string GeneratedCodeDirectory,
IntelliSenseGatherer IntelliSenseGatherer,
List<FileItem> ModuleSourceFiles,
bool bBuildSourceFiles,
string InBuildCsFile)
{
switch (RulesObject.Type)
{
case ModuleRules.ModuleType.CPlusPlus:
return new UEBuildModuleCPP(
InTarget: this,
InName: ModuleName,
InType: ModuleType,
InModuleDirectory: ModuleDirectory,
InGeneratedCodeDirectory: GeneratedCodeDirectory,
InIsRedistributableOverride: RulesObject.IsRedistributableOverride,
InIntelliSenseGatherer: IntelliSenseGatherer,
InSourceFiles: ModuleSourceFiles,
InPublicSystemIncludePaths: RulesObject.PublicSystemIncludePaths,
InPublicLibraryPaths: RulesObject.PublicLibraryPaths,
InPublicIncludePaths: RulesObject.PublicIncludePaths,
InDefinitions: RulesObject.Definitions,
InPublicIncludePathModuleNames: RulesObject.PublicIncludePathModuleNames,
InPublicDependencyModuleNames: RulesObject.PublicDependencyModuleNames,
InPublicDelayLoadDLLs: RulesObject.PublicDelayLoadDLLs,
InPublicAdditionalLibraries: RulesObject.PublicAdditionalLibraries,
InPublicFrameworks: RulesObject.PublicFrameworks,
InPublicWeakFrameworks: RulesObject.PublicWeakFrameworks,
InPublicAdditionalFrameworks: RulesObject.PublicAdditionalFrameworks,
InPublicAdditionalShadowFiles: RulesObject.PublicAdditionalShadowFiles,
InPublicAdditionalBundleResources: RulesObject.AdditionalBundleResources,
InPrivateIncludePaths: RulesObject.PrivateIncludePaths,
InPrivateIncludePathModuleNames: RulesObject.PrivateIncludePathModuleNames,
InPrivateDependencyModuleNames: RulesObject.PrivateDependencyModuleNames,
InCircularlyReferencedDependentModules: RulesObject.CircularlyReferencedDependentModules,
InDynamicallyLoadedModuleNames: RulesObject.DynamicallyLoadedModuleNames,
InPlatformSpecificDynamicallyLoadedModuleNames: RulesObject.PlatformSpecificDynamicallyLoadedModuleNames,
InRuntimeDependencies: RulesObject.RuntimeDependencies,
InOptimizeCode: RulesObject.OptimizeCode,
InAllowSharedPCH: (RulesObject.PCHUsage == ModuleRules.PCHUsageMode.NoSharedPCHs) ? false : true,
InSharedPCHHeaderFile: RulesObject.SharedPCHHeaderFile,
InUseRTTI: RulesObject.bUseRTTI,
InEnableBufferSecurityChecks: RulesObject.bEnableBufferSecurityChecks,
InFasterWithoutUnity: RulesObject.bFasterWithoutUnity,
InMinFilesUsingPrecompiledHeaderOverride: RulesObject.MinFilesUsingPrecompiledHeaderOverride,
InEnableExceptions: RulesObject.bEnableExceptions,
InEnableShadowVariableWarnings: RulesObject.bEnableShadowVariableWarnings,
bInBuildSourceFiles: bBuildSourceFiles,
InBuildCsFilename: InBuildCsFile
);
case ModuleRules.ModuleType.CPlusPlusCLR:
return new UEBuildModuleCPPCLR(
InTarget: this,
InName: ModuleName,
InType: ModuleType,
InModuleDirectory: ModuleDirectory,
InGeneratedCodeDirectory: GeneratedCodeDirectory,
InIsRedistributableOverride: RulesObject.IsRedistributableOverride,
InIntelliSenseGatherer: IntelliSenseGatherer,
InSourceFiles: ModuleSourceFiles,
InDefinitions: RulesObject.Definitions,
InPublicSystemIncludePaths: RulesObject.PublicSystemIncludePaths,
InPublicIncludePaths: RulesObject.PublicIncludePaths,
InPublicIncludePathModuleNames: RulesObject.PublicIncludePathModuleNames,
InPublicDependencyModuleNames: RulesObject.PublicDependencyModuleNames,
InPublicDelayLoadDLLs: RulesObject.PublicDelayLoadDLLs,
InPublicAdditionalLibraries: RulesObject.PublicAdditionalLibraries,
InPublicFrameworks: RulesObject.PublicFrameworks,
InPublicWeakFrameworks: RulesObject.PublicWeakFrameworks,
InPublicAdditionalFrameworks: RulesObject.PublicAdditionalFrameworks,
InPublicAdditionalShadowFiles: RulesObject.PublicAdditionalShadowFiles,
InPublicAdditionalBundleResources: RulesObject.AdditionalBundleResources,
InPrivateIncludePaths: RulesObject.PrivateIncludePaths,
InPrivateIncludePathModuleNames: RulesObject.PrivateIncludePathModuleNames,
InPrivateDependencyModuleNames: RulesObject.PrivateDependencyModuleNames,
InPrivateAssemblyReferences: RulesObject.PrivateAssemblyReferences,
InCircularlyReferencedDependentModules: RulesObject.CircularlyReferencedDependentModules,
InDynamicallyLoadedModuleNames: RulesObject.DynamicallyLoadedModuleNames,
InPlatformSpecificDynamicallyLoadedModuleNames: RulesObject.PlatformSpecificDynamicallyLoadedModuleNames,
InRuntimeDependencies: RulesObject.RuntimeDependencies,
InOptimizeCode: RulesObject.OptimizeCode,
InAllowSharedPCH: (RulesObject.PCHUsage == ModuleRules.PCHUsageMode.NoSharedPCHs) ? false : true,
InSharedPCHHeaderFile: RulesObject.SharedPCHHeaderFile,
InUseRTTI: RulesObject.bUseRTTI,
InEnableBufferSecurityChecks: RulesObject.bEnableBufferSecurityChecks,
InFasterWithoutUnity: RulesObject.bFasterWithoutUnity,
InMinFilesUsingPrecompiledHeaderOverride: RulesObject.MinFilesUsingPrecompiledHeaderOverride,
InEnableExceptions: RulesObject.bEnableExceptions,
InEnableShadowVariableWarnings: RulesObject.bEnableShadowVariableWarnings,
bInBuildSourceFiles : bBuildSourceFiles,
InBuildCsFilename: InBuildCsFile
);
case ModuleRules.ModuleType.External:
return new UEBuildExternalModule(
InTarget: this,
InName: ModuleName,
InType: ModuleType,
InModuleDirectory: ModuleDirectory,
InIsRedistributableOverride: RulesObject.IsRedistributableOverride,
InPublicDefinitions: RulesObject.Definitions,
InPublicSystemIncludePaths: RulesObject.PublicSystemIncludePaths,
InPublicIncludePaths: RulesObject.PublicIncludePaths,
InPublicLibraryPaths: RulesObject.PublicLibraryPaths,
InPublicAdditionalLibraries: RulesObject.PublicAdditionalLibraries,
InPublicFrameworks: RulesObject.PublicFrameworks,
InPublicWeakFrameworks: RulesObject.PublicWeakFrameworks,
InPublicAdditionalFrameworks: RulesObject.PublicAdditionalFrameworks,
InPublicAdditionalShadowFiles: RulesObject.PublicAdditionalShadowFiles,
InPublicAdditionalBundleResources: RulesObject.AdditionalBundleResources,
InPublicDependencyModuleNames: RulesObject.PublicDependencyModuleNames,
InPublicDelayLoadDLLs: RulesObject.PublicDelayLoadDLLs,
InRuntimeDependencies: RulesObject.RuntimeDependencies,
InBuildCsFilename: InBuildCsFile
);
default:
throw new BuildException("Unrecognized module type specified by 'Rules' object {0}", RulesObject.ToString());
}
}
public UEBuildModuleCPPCLR(
UEBuildTarget InTarget,
string InName,
UEBuildModuleType InType,
string InModuleDirectory,
string InOutputDirectory,
IntelliSenseGatherer InIntelliSenseGatherer,
IEnumerable<FileItem> InSourceFiles,
IEnumerable<string> InPublicIncludePaths,
IEnumerable<string> InPublicSystemIncludePaths,
IEnumerable<string> InDefinitions,
IEnumerable<string> InPrivateAssemblyReferences,
IEnumerable<string> InPublicIncludePathModuleNames,
IEnumerable<string> InPublicDependencyModuleNames,
IEnumerable<string> InPublicDelayLoadDLLs,
IEnumerable<string> InPublicAdditionalLibraries,
IEnumerable<string> InPublicFrameworks,
IEnumerable<string> InPublicAdditionalFrameworks,
IEnumerable<string> InPrivateIncludePaths,
IEnumerable<string> InPrivateIncludePathModuleNames,
IEnumerable<string> InPrivateDependencyModuleNames,
IEnumerable<string> InCircularlyReferencedDependentModules,
IEnumerable<string> InDynamicallyLoadedModuleNames,
IEnumerable<string> InPlatformSpecificDynamicallyLoadedModuleNames,
ModuleRules.CodeOptimization InOptimizeCode,
bool InAllowSharedPCH,
string InSharedPCHHeaderFile,
bool InUseRTTI,
bool InEnableBufferSecurityChecks,
bool InFasterWithoutUnity,
int InMinFilesUsingPrecompiledHeaderOverride,
bool InEnableExceptions,
bool InEnableInlining
)
: base(InTarget,InName,InType,InModuleDirectory,InOutputDirectory,InIntelliSenseGatherer,
InSourceFiles,InPublicIncludePaths,InPublicSystemIncludePaths,InDefinitions,
InPublicIncludePathModuleNames,InPublicDependencyModuleNames,InPublicDelayLoadDLLs,InPublicAdditionalLibraries,InPublicFrameworks,InPublicAdditionalFrameworks,
InPrivateIncludePaths,InPrivateIncludePathModuleNames,InPrivateDependencyModuleNames,
InCircularlyReferencedDependentModules, InDynamicallyLoadedModuleNames, InPlatformSpecificDynamicallyLoadedModuleNames, InOptimizeCode,
InAllowSharedPCH, InSharedPCHHeaderFile, InUseRTTI, InEnableBufferSecurityChecks, InFasterWithoutUnity, InMinFilesUsingPrecompiledHeaderOverride,
InEnableExceptions, InEnableInlining)
{
PrivateAssemblyReferences = ListFromOptionalEnumerableStringParameter(InPrivateAssemblyReferences);
}
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
base.ModifyModuleRulesForOtherPlatform(ModuleName, Rules, Target);
if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Mac))
{
// allow standalone tools to use targetplatform modules, without needing Engine
if (UEBuildConfiguration.bForceBuildTargetPlatforms)
{
// @todo tvos: Make the module
// InModule.AddPlatformSpecificDynamicallyLoadedModule("TVOSTargetPlatform");
}
}
}
/// <summary>
/// Add the standard default include paths to the given modulerules object
/// </summary>
/// <param name="InModuleName">The name of the module</param>
/// <param name="InModuleFilename">The filename to the module rules file (Build.cs)</param>
/// <param name="InModuleFileRelativeToEngineDirectory">The module file relative to the engine directory</param>
/// <param name="IsGameModule">true if it is a game module, false if not</param>
/// <param name="RulesObject">The module rules object itself</param>
public static void AddDefaultIncludePathsToModuleRules(string InModuleName, string InModuleFilename, string InModuleFileRelativeToEngineDirectory, bool IsGameModule, ModuleRules RulesObject)
{
// Grab the absolute path of the Engine/Source folder for use later
string AbsEngineSourceDirectory = Path.Combine(ProjectFileGenerator.RootRelativePath, "Engine/Source");
AbsEngineSourceDirectory = Path.GetFullPath(AbsEngineSourceDirectory);
AbsEngineSourceDirectory = AbsEngineSourceDirectory.Replace("\\", "/");
// Find the module path relative to the Engine/Source folder
string ModuleDirectoryRelativeToEngineSourceDirectory = Utils.MakePathRelativeTo(InModuleFilename, Path.Combine(ProjectFileGenerator.RootRelativePath, "Engine/Source"));
ModuleDirectoryRelativeToEngineSourceDirectory = ModuleDirectoryRelativeToEngineSourceDirectory.Replace("\\", "/");
// Remove the build.cs file from the directory if present
if (ModuleDirectoryRelativeToEngineSourceDirectory.EndsWith("Build.cs", StringComparison.InvariantCultureIgnoreCase))
{
Int32 LastSlashIdx = ModuleDirectoryRelativeToEngineSourceDirectory.LastIndexOf("/");
if (LastSlashIdx != -1)
{
ModuleDirectoryRelativeToEngineSourceDirectory = ModuleDirectoryRelativeToEngineSourceDirectory.Substring(0, LastSlashIdx + 1);
}
}
else
{
throw new BuildException("Invalid module filename '{0}'.", InModuleFilename);
}
// Determine the 'Game/Source' folder
//@todo.Rocket: This currently requires following our standard format for folder layout.
// Also, it assumes the module itself is not named Source...
string GameSourceIncludePath = (IsGameModule == true) ? ModuleDirectoryRelativeToEngineSourceDirectory : "";
if (string.IsNullOrEmpty(GameSourceIncludePath) == false)
{
Int32 SourceIdx = GameSourceIncludePath.IndexOf("/Source/");
if (SourceIdx != -1)
{
GameSourceIncludePath = GameSourceIncludePath.Substring(0, SourceIdx + 8);
RulesObject.PublicIncludePaths.Add(GameSourceIncludePath);
}
}
// Setup the directories for Classes, Public, and Intermediate
string ClassesDirectory = Path.Combine(ModuleDirectoryRelativeToEngineSourceDirectory, "Classes/"); // @todo uht: Deprecate eventually. Or force it to be manually specified...
string PublicDirectory = Path.Combine(ModuleDirectoryRelativeToEngineSourceDirectory, "Public/");
if(!Utils.IsFileUnderDirectory(InModuleFilename, AbsEngineSourceDirectory))
{
// This will be either the format
// ../<Game>/Source/<Module>
// or
// c:/PATH/<Game>/Source/<Module>
string SourceDirName = "Source";
Int32 SourceSlashIdx = ModuleDirectoryRelativeToEngineSourceDirectory.IndexOf(SourceDirName);
string SourceDirectoryPath = null;
if(SourceSlashIdx != -1)
{
try
{
SourceDirectoryPath = Path.GetFullPath(ModuleDirectoryRelativeToEngineSourceDirectory.Substring(0, SourceSlashIdx + SourceDirName.Length));
}
catch(Exception Exc)
{
throw new BuildException(Exc, "Failed to resolve module source directory for private include paths for module {0}.", InModuleName);
}
}
else
{
//@todo. throw a build exception here?
}
// Resolve private include paths against the module source root so they are simpler and don't have to be engine root relative.
if(SourceDirectoryPath != null)
{
List<string> ResolvedPrivatePaths = new List<string>();
foreach(var PrivatePath in RulesObject.PrivateIncludePaths)
{
try
{
if(!Path.IsPathRooted(PrivatePath))
{
ResolvedPrivatePaths.Add(Path.Combine(SourceDirectoryPath, PrivatePath));
}
else
{
ResolvedPrivatePaths.Add(PrivatePath);
}
}
catch(Exception Exc)
{
throw new BuildException(Exc, "Failed to resolve private include path {0}.", PrivatePath);
}
}
RulesObject.PrivateIncludePaths = ResolvedPrivatePaths;
}
}
string IncludePath_Classes = "";
string IncludePath_Public = "";
bool bModulePathIsRooted = Path.IsPathRooted(ModuleDirectoryRelativeToEngineSourceDirectory);
string ClassesFolderName = (bModulePathIsRooted == false) ? Path.Combine(AbsEngineSourceDirectory, ClassesDirectory) : ClassesDirectory;
if (Directory.Exists(ClassesFolderName) == true)
{
IncludePath_Classes = ClassesDirectory;
}
string PublicFolderName = (bModulePathIsRooted == false) ? Path.Combine(AbsEngineSourceDirectory, PublicDirectory) : PublicDirectory;
if (Directory.Exists(PublicFolderName) == true)
{
IncludePath_Public = PublicDirectory;
}
// Add them if they are required...
if (IncludePath_Classes.Length > 0)
{
RulesObject.PublicIncludePaths.Add(IncludePath_Classes);
}
if (IncludePath_Public.Length > 0)
{
RulesObject.PublicIncludePaths.Add(IncludePath_Public);
// Add subdirectories of Public if present
DirectoryInfo PublicInfo = new DirectoryInfo(IncludePath_Public);
DirectoryInfo[] PublicSubDirs = PublicInfo.GetDirectories("*", SearchOption.AllDirectories);
if (PublicSubDirs.Length > 0)
{
foreach (DirectoryInfo SubDir in PublicSubDirs)
{
string PartialDir = SubDir.FullName.Replace(PublicInfo.FullName, "");
string NewDir = IncludePath_Public + PartialDir;
NewDir = Utils.CleanDirectorySeparators(NewDir, '/');
RulesObject.PublicIncludePaths.Add(NewDir);
}
}
}
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public virtual void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
}
/// <summary>
/// Allow all registered build platforms to modify the newly created module
/// passed in for the given platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="">Name The name of the module</param>
/// <param name="Module"> The module rules</param>
/// <param name="Target"> The target being build</param>
/// <param name="Only"> If this is not unknown, then only run that platform</param>
public static void PlatformModifyHostModuleRules(string ModuleName, ModuleRules Rules, TargetInfo Target, UnrealTargetPlatform Only = UnrealTargetPlatform.Unknown)
{
foreach (KeyValuePair<UnrealTargetPlatform, UEBuildPlatform> PlatformEntry in BuildPlatformDictionary)
{
if (Only == UnrealTargetPlatform.Unknown || PlatformEntry.Key == Only)
{
PlatformEntry.Value.ModifyModuleRulesForOtherPlatform(ModuleName, Rules, Target);
}
}
}
public UEBuildModuleCPP(
UEBuildTarget InTarget,
string InName,
UEBuildModuleType InType,
string InModuleDirectory,
string InOutputDirectory,
IntelliSenseGatherer InIntelliSenseGatherer,
IEnumerable<FileItem> InSourceFiles,
IEnumerable<string> InPublicIncludePaths,
IEnumerable<string> InPublicSystemIncludePaths,
IEnumerable<string> InDefinitions,
IEnumerable<string> InPublicIncludePathModuleNames,
IEnumerable<string> InPublicDependencyModuleNames,
IEnumerable<string> InPublicDelayLoadDLLs,
IEnumerable<string> InPublicAdditionalLibraries,
IEnumerable<string> InPublicFrameworks,
IEnumerable<string> InPublicAdditionalFrameworks,
IEnumerable<string> InPrivateIncludePaths,
IEnumerable<string> InPrivateIncludePathModuleNames,
IEnumerable<string> InPrivateDependencyModuleNames,
IEnumerable<string> InCircularlyReferencedDependentModules,
IEnumerable<string> InDynamicallyLoadedModuleNames,
IEnumerable<string> InPlatformSpecificDynamicallyLoadedModuleNames,
ModuleRules.CodeOptimization InOptimizeCode,
bool InAllowSharedPCH,
string InSharedPCHHeaderFile,
bool InUseRTTI,
bool InEnableBufferSecurityChecks,
bool InFasterWithoutUnity,
int InMinFilesUsingPrecompiledHeaderOverride,
bool InEnableExceptions,
bool InEnableInlining
)
: base(InTarget,
InName,
InType,
InModuleDirectory,
InOutputDirectory,
InDefinitions,
InPublicIncludePaths,
InPublicSystemIncludePaths,
null,
InPublicAdditionalLibraries,
InPublicFrameworks,
InPublicAdditionalFrameworks,
null,
InPublicIncludePathModuleNames,
InPublicDependencyModuleNames,
InPublicDelayLoadDLLs,
InPrivateIncludePaths,
InPrivateIncludePathModuleNames,
InPrivateDependencyModuleNames,
InCircularlyReferencedDependentModules,
InDynamicallyLoadedModuleNames,
InPlatformSpecificDynamicallyLoadedModuleNames)
{
IntelliSenseGatherer = InIntelliSenseGatherer;
SourceFiles = new List<FileItem>( InSourceFiles );
Definitions = ListFromOptionalEnumerableStringParameter(InDefinitions);
foreach (var Def in Definitions)
{
Log.TraceVerbose("Compile Env {0}: {1}", Name, Def);
}
OptimizeCode = InOptimizeCode;
bAllowSharedPCH = InAllowSharedPCH;
SharedPCHHeaderFile = InSharedPCHHeaderFile;
bUseRTTI = InUseRTTI;
bEnableBufferSecurityChecks = InEnableBufferSecurityChecks;
bFasterWithoutUnity = InFasterWithoutUnity;
MinFilesUsingPrecompiledHeaderOverride = InMinFilesUsingPrecompiledHeaderOverride;
bEnableExceptions = InEnableExceptions;
bEnableInlining = InEnableInlining;
}
public UEBuildModuleCPP(
string InName,
UHTModuleType InType,
DirectoryReference InModuleDirectory,
DirectoryReference InGeneratedCodeDirectory,
IntelliSenseGatherer InIntelliSenseGatherer,
IEnumerable<FileItem> InSourceFiles,
ModuleRules InRules,
bool bInBuildSourceFiles,
FileReference InRulesFile
)
: base(
InName,
InType,
InModuleDirectory,
InRules,
InRulesFile
)
{
GeneratedCodeDirectory = InGeneratedCodeDirectory;
IntelliSenseGatherer = InIntelliSenseGatherer;
CategorizeSourceFiles(InSourceFiles, SourceFilesFound);
if (bInBuildSourceFiles)
{
SourceFilesToBuild.CopyFrom(SourceFilesFound);
}
Definitions = HashSetFromOptionalEnumerableStringParameter(InRules.Definitions);
foreach (string Def in Definitions)
{
Log.TraceVerbose("Compile Env {0}: {1}", Name, Def);
}
}
/// <summary>
/// Creates an instance of a module rules descriptor object for the specified module name
/// </summary>
/// <param name="ModuleName">Name of the module</param>
/// <param name="Target">Information about the target associated with this module</param>
/// <param name="Rules">Output </param>
/// <returns>Compiled module rule info</returns>
public static bool TryCreateModuleRules( string ModuleName, TargetInfo Target, out ModuleRules Rules )
{
if(GetModuleFilename( ModuleName ) == null)
{
Rules = null;
return false;
}
else
{
Rules = CreateModuleRules( ModuleName, Target );
return true;
}
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Mac))
{
bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
if (!UEBuildConfiguration.bBuildRequiresCookedData)
{
if (ModuleName == "Engine")
{
if (UEBuildConfiguration.bBuildDeveloperTools)
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("TVOSTargetPlatform");
}
}
else if (ModuleName == "TargetPlatform")
{
bBuildShaderFormats = true;
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
Rules.DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
if (UEBuildConfiguration.bBuildDeveloperTools)
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("AudioFormatADPCM");
}
}
}
// allow standalone tools to use targetplatform modules, without needing Engine
if (ModuleName == "TargetPlatform")
{
if (UEBuildConfiguration.bForceBuildTargetPlatforms)
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("TVOSTargetPlatform");
}
if (bBuildShaderFormats)
{
Rules.PlatformSpecificDynamicallyLoadedModuleNames.Add("MetalShaderFormat");
}
}
}
}
/// <summary>
/// Modify the rules for a newly created module, where the target is a different host platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForOtherPlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
}
public UEBuildModuleCPPCLR(
string InName,
UHTModuleType InType,
DirectoryReference InModuleDirectory,
DirectoryReference InGeneratedCodeDirectory,
IntelliSenseGatherer InIntelliSenseGatherer,
IEnumerable<FileItem> InSourceFiles,
ModuleRules InRules,
bool bInBuildSourceFiles,
FileReference InRulesFile
)
: base(InName, InType, InModuleDirectory, InGeneratedCodeDirectory, InIntelliSenseGatherer,
InSourceFiles, InRules,
bInBuildSourceFiles, InRulesFile)
{
PrivateAssemblyReferences = HashSetFromOptionalEnumerableStringParameter(InRules.PrivateAssemblyReferences);
}
public UEBuildModule(
string InName,
UHTModuleType InType,
DirectoryReference InModuleDirectory,
ModuleRules InRules,
FileReference InRulesFile
)
{
Name = InName;
Type = InType;
ModuleDirectory = InModuleDirectory;
Rules = InRules;
RulesFile = InRulesFile;
NormalizedModuleIncludePath = Utils.CleanDirectorySeparators(ModuleDirectory.MakeRelativeTo(UnrealBuildTool.EngineSourceDirectory), '/');
ModuleApiDefine = Name.ToUpperInvariant() + "_API";
PublicDefinitions = HashSetFromOptionalEnumerableStringParameter(InRules.Definitions);
PublicIncludePaths = HashSetFromOptionalEnumerableStringParameter(InRules.PublicIncludePaths);
PublicSystemIncludePaths = HashSetFromOptionalEnumerableStringParameter(InRules.PublicSystemIncludePaths);
PublicLibraryPaths = HashSetFromOptionalEnumerableStringParameter(InRules.PublicLibraryPaths);
PublicAdditionalLibraries = HashSetFromOptionalEnumerableStringParameter(InRules.PublicAdditionalLibraries);
PublicFrameworks = HashSetFromOptionalEnumerableStringParameter(InRules.PublicFrameworks);
PublicWeakFrameworks = HashSetFromOptionalEnumerableStringParameter(InRules.PublicWeakFrameworks);
PublicAdditionalFrameworks = InRules.PublicAdditionalFrameworks == null ? new HashSet<UEBuildFramework>() : new HashSet<UEBuildFramework>(InRules.PublicAdditionalFrameworks);
PublicAdditionalShadowFiles = HashSetFromOptionalEnumerableStringParameter(InRules.PublicAdditionalShadowFiles);
PublicAdditionalBundleResources = InRules.AdditionalBundleResources == null ? new HashSet<UEBuildBundleResource>() : new HashSet<UEBuildBundleResource>(InRules.AdditionalBundleResources);
PublicDelayLoadDLLs = HashSetFromOptionalEnumerableStringParameter(InRules.PublicDelayLoadDLLs);
PrivateIncludePaths = HashSetFromOptionalEnumerableStringParameter(InRules.PrivateIncludePaths);
RuntimeDependencies = (InRules.RuntimeDependencies == null) ? new RuntimeDependencyList() : new RuntimeDependencyList(InRules.RuntimeDependencies);
IsRedistributableOverride = InRules.IsRedistributableOverride;
}
public UEBuildExternalModule(
UHTModuleType InType,
string InName,
DirectoryReference InModuleDirectory,
ModuleRules InRules,
FileReference InRulesFile
)
: base(
InType: InType,
InName: InName,
InModuleDirectory: InModuleDirectory,
InRules: InRules,
InRulesFile: InRulesFile
)
{
}
/// <summary>
/// Modify the rules for a newly created module, in a target that's being built for this platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForActivePlatform(string ModuleName, ModuleRules Rules, ReadOnlyTargetRules Target)
{
}
/// <summary>
/// Modify the rules for a newly created module, in a target that's being built for this platform.
/// This is not required - but allows for hiding details of a particular platform.
/// </summary>
/// <param name="ModuleName">The name of the module</param>
/// <param name="Rules">The module rules</param>
/// <param name="Target">The target being build</param>
public override void ModifyModuleRulesForActivePlatform(string ModuleName, ModuleRules Rules, TargetInfo Target)
{
bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
if (!UEBuildConfiguration.bBuildRequiresCookedData)
{
if (ModuleName == "TargetPlatform")
{
bBuildShaderFormats = true;
}
}
// allow standalone tools to use target platform modules, without needing Engine
if (ModuleName == "TargetPlatform")
{
if (UEBuildConfiguration.bForceBuildTargetPlatforms)
{
Rules.DynamicallyLoadedModuleNames.Add("WindowsTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("WindowsNoEditorTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("WindowsServerTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("WindowsClientTargetPlatform");
Rules.DynamicallyLoadedModuleNames.Add("AllDesktopTargetPlatform");
}
if (bBuildShaderFormats)
{
if (!SupportWindowsXP)
{
Rules.DynamicallyLoadedModuleNames.Add("ShaderFormatD3D");
}
Rules.DynamicallyLoadedModuleNames.Add("ShaderFormatOpenGL");
Rules.DynamicallyLoadedModuleNames.Remove("VulkanRHI");
Rules.DynamicallyLoadedModuleNames.Add("VulkanShaderFormat");
}
}
if (ModuleName == "D3D11RHI")
{
// To enable platform specific D3D11 RHI Types
Rules.PrivateIncludePaths.Add("Runtime/Windows/D3D11RHI/Private/Windows");
}
if (ModuleName == "D3D12RHI")
{
// To enable platform specific D3D12 RHI Types
Rules.PrivateIncludePaths.Add("Runtime/Windows/D3D12RHI/Private/Windows");
}
if (SupportWindowsXP)
{
// Change libcurl path for XP as the default Win32 lib calls functions not supported on the platform
// Remove path must exactly match what is created in libcurl.Build.cs
string LibCurlOriginalLibPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "libcurl/lib/" + ((Target.Platform == UnrealTargetPlatform.Win64) ? "Win64/" : "Win32/") + "VS" + WindowsPlatform.GetVisualStudioCompilerVersionName();
Rules.PublicLibraryPaths.Remove(LibCurlOriginalLibPath);
Rules.PublicLibraryPaths.Add(LibCurlOriginalLibPath + "_xp");
Rules.DynamicallyLoadedModuleNames.Remove("D3D12RHI");
Rules.DynamicallyLoadedModuleNames.Remove("D3D11RHI");
Rules.DynamicallyLoadedModuleNames.Remove("ShaderFormatD3D");
Rules.DynamicallyLoadedModuleNames.Remove("OculusRift");
Rules.DynamicallyLoadedModuleNames.Remove("OculusLibrary");
Rules.DynamicallyLoadedModuleNames.Remove("OculusInput");
Rules.DynamicallyLoadedModuleNames.Remove("OculusAudio");
Rules.DynamicallyLoadedModuleNames.Remove("VulkanRHI");
Rules.PrivateDependencyModuleNames.Remove("DX11");
Rules.PrivateDependencyModuleNames.Remove("DX12");
Rules.PrivateDependencyModuleNames.Remove("D3D12RHI");
Rules.PrivateDependencyModuleNames.Remove("D3D11RHI");
Rules.PrivateDependencyModuleNames.Remove("OpenVR");
// If we're targeting Windows XP, then always delay-load D3D11 as it won't exist on that architecture
if (ModuleName == "DX11")
{
Rules.PublicDelayLoadDLLs.Add("d3d11.dll");
Rules.PublicDelayLoadDLLs.Add("dxgi.dll");
}
}
}
