/// <summary>
/// Builds BuildPatchTool for the specified platform.
/// </summary>
/// <param name="Command"></param>
/// <param name="InPlatform"></param>
public static void BuildBuildPatchTool(BuildCommand Command, UnrealBuildTool.UnrealTargetPlatform InPlatform)
{
BuildProduct(Command, new UE4Build.BuildTarget()
{
ProjectName = "",
TargetName = "BuildPatchTool",
Platform = InPlatform,
Config = UnrealBuildTool.UnrealTargetConfiguration.Development,
});
}
/// <summary>
/// Builds BuildPatchTool for the specified platform.
/// </summary>
/// <param name="Command"></param>
/// <param name="InPlatform"></param>
public static void BuildBuildPatchTool(BuildCommand Command, UnrealBuildTool.UnrealTargetPlatform InPlatform)
{
BuildProduct(Command, new UE4Build.BuildTarget()
{
UprojectPath = null,
TargetName = "BuildPatchTool",
Platform = InPlatform,
Config = UnrealBuildTool.UnrealTargetConfiguration.Shipping,
});
}
/// <summary>
/// Builds UnrealHeaderTool for the specified platform.
/// </summary>
/// <param name="Command"></param>
/// <param name="InPlatform"></param>
public static void BuildUnrealHeaderTool(BuildCommand Command, UnrealBuildTool.UnrealTargetPlatform InPlatform)
{
BuildProduct(Command, new UE4Build.BuildTarget()
{
UprojectPath = null,
TargetName = "UnrealHeaderTool",
Platform = InPlatform,
Config = UnrealBuildTool.UnrealTargetConfiguration.Development,
});
}
/// <summary>
/// Returns the default path of the editor executable to use for running commandlets.
/// </summary>
/// <param name="BuildRoot">Root directory for the build</param>
/// <param name="HostPlatform">Platform to get the executable for</param>
/// <returns>Path to the editor executable</returns>
public static string GetEditorCommandletExe(string BuildRoot, UnrealBuildTool.UnrealTargetPlatform HostPlatform)
{
if (HostPlatform == UnrealBuildTool.UnrealTargetPlatform.Mac)
{
return(CommandUtils.CombinePaths(BuildRoot, "Engine/Binaries/Mac/UE4Editor.app/Contents/MacOS/UE4Editor"));
}
if (HostPlatform == UnrealBuildTool.UnrealTargetPlatform.Win64)
{
return(CommandUtils.CombinePaths(BuildRoot, "Engine/Binaries/Win64/UE4Editor-Cmd.exe"));
}
if (HostPlatform == UnrealBuildTool.UnrealTargetPlatform.Linux)
{
return(CommandUtils.CombinePaths(BuildRoot, "Engine/Binaries/Linux/UE4Editor"));
}
throw new AutomationException("EditorCommandlet is not supported for platform {0}", HostPlatform);
}
/// <summary>
/// Builds BuildPatchTool for the specified platform.
/// </summary>
/// <param name="Command"></param>
/// <param name="InPlatform"></param>
public static void BuildBuildPatchTool(BuildCommand Command, UnrealBuildTool.UnrealTargetPlatform InPlatform)
{
Log("Building BuildPatchTool");
if (Command == null)
{
Command = new UE4BuildUtilDummyBuildCommand();
}
var UE4Build = new UE4Build(Command);
var Agenda = new UE4Build.BuildAgenda();
Agenda.Targets.Add(new UE4Build.BuildTarget()
{
ProjectName = "",
TargetName = "BuildPatchTool",
Platform = InPlatform,
Config = UnrealBuildTool.UnrealTargetConfiguration.Development,
});
UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
}
/// <summary>
/// Determines if this reference is valid for the given target platform.
/// </summary>
/// <param name="Platform">The platform to check</param>
/// <returns>True if the plugin for this target platform</returns>
public bool IsSupportedTargetPlatform(UnrealTargetPlatform Platform)
{
return(SupportedTargetPlatforms == null || SupportedTargetPlatforms.Count == 0 || SupportedTargetPlatforms.Contains(Platform));
}
/// <summary>
/// Determine if a plugin is enabled for a given project
/// </summary>
/// <param name="Project">The project to check</param>
/// <param name="Plugin">Information about the plugin</param>
/// <param name="Platform">The target platform</param>
/// <param name="Target"></param>
/// <returns>True if the plugin should be enabled for this project</returns>
public static bool IsPluginEnabledForProject(PluginInfo Plugin, ProjectDescriptor Project, UnrealTargetPlatform Platform, TargetType Target)
{
bool bEnabled = Plugin.EnabledByDefault;
if (Project != null && Project.Plugins != null)
{
foreach (PluginReferenceDescriptor PluginReference in Project.Plugins)
{
if (String.Compare(PluginReference.Name, Plugin.Name, true) == 0)
{
bEnabled = PluginReference.IsEnabledForPlatform(Platform) && PluginReference.IsEnabledForTarget(Target);
}
}
}
return(bEnabled);
}
/// <summary>
/// Creates a target rules object for the specified target name.
/// </summary>
/// <param name="TargetName">Name of the target</param>
/// <param name="Platform">Platform being compiled</param>
/// <param name="Configuration">Configuration being compiled</param>
/// <param name="Architecture">Architecture being built</param>
/// <param name="ProjectFile">Path to the project file for this target</param>
/// <param name="bInEditorRecompile">Whether this is an editor recompile, where we need to guess the name of the editor target</param>
/// <param name="TargetFileName">The original source file name of the Target.cs file for this target</param>
/// <returns>The build target rules for the specified target</returns>
public TargetRules CreateTargetRules(string TargetName, UnrealTargetPlatform Platform, UnrealTargetConfiguration Configuration, string Architecture, FileReference ProjectFile, bool bInEditorRecompile, out FileReference TargetFileName)
{
// Make sure the target file is known to us
bool bFoundTargetName = TargetNameToTargetFile.ContainsKey(TargetName);
if (bFoundTargetName == false)
{
if (Parent == null)
{
// throw new BuildException("Couldn't find target rules file for target '{0}' in rules assembly '{1}'.", TargetName, RulesAssembly.FullName);
string ExceptionMessage = "Couldn't find target rules file for target '";
ExceptionMessage += TargetName;
ExceptionMessage += "' in rules assembly '";
ExceptionMessage += CompiledAssembly.FullName;
ExceptionMessage += "'." + Environment.NewLine;
ExceptionMessage += "Location: " + CompiledAssembly.Location + Environment.NewLine;
ExceptionMessage += "Target rules found:" + Environment.NewLine;
foreach (KeyValuePair <string, FileReference> entry in TargetNameToTargetFile)
{
ExceptionMessage += "\t" + entry.Key + " - " + entry.Value + Environment.NewLine;
}
throw new BuildException(ExceptionMessage);
}
else
{
return(Parent.CreateTargetRules(TargetName, Platform, Configuration, Architecture, ProjectFile, bInEditorRecompile, out TargetFileName));
}
}
// Return the target file name to the caller
TargetFileName = TargetNameToTargetFile[TargetName];
// Currently, we expect the user's rules object type name to be the same as the module name + 'Target'
string TargetTypeName = TargetName + "Target";
// The build module must define a type named '<TargetName>Target' that derives from our 'TargetRules' type.
TargetRules RulesObject = CreateTargetRulesInstance(TargetTypeName, new TargetInfo(TargetName, Platform, Configuration, Architecture, ProjectFile));
if (bInEditorRecompile)
{
// Make sure this is an editor module.
if (RulesObject != null)
{
if (RulesObject.Type != TargetType.Editor)
{
// Not the editor... determine the editor project
string TargetSourceFolderString = TargetFileName.FullName;
Int32 SourceFolderIndex = -1;
if (Utils.IsRunningOnMono)
{
TargetSourceFolderString = TargetSourceFolderString.Replace("\\", "/");
SourceFolderIndex = TargetSourceFolderString.LastIndexOf("/Source/", StringComparison.InvariantCultureIgnoreCase);
}
else
{
TargetSourceFolderString = TargetSourceFolderString.Replace("/", "\\");
SourceFolderIndex = TargetSourceFolderString.LastIndexOf("\\Source\\", StringComparison.InvariantCultureIgnoreCase);
}
if (SourceFolderIndex != -1)
{
DirectoryReference TargetSourceFolder = new DirectoryReference(TargetSourceFolderString.Substring(0, SourceFolderIndex + 7));
foreach (KeyValuePair <string, FileReference> CheckEntry in TargetNameToTargetFile)
{
if (CheckEntry.Value.IsUnderDirectory(TargetSourceFolder))
{
if (CheckEntry.Key.Equals(TargetName, StringComparison.InvariantCultureIgnoreCase) == false)
{
// We have found a target in the same source folder that is not the original target found.
// See if it is the editor project
string CheckTargetTypeName = CheckEntry.Key + "Target";
TargetRules CheckRulesObject = CreateTargetRulesInstance(CheckTargetTypeName, new TargetInfo(CheckEntry.Key, Platform, Configuration, Architecture, ProjectFile));
if (CheckRulesObject != null)
{
if (CheckRulesObject.Type == TargetType.Editor)
{
// Found it
// NOTE: This prevents multiple Editor targets from co-existing...
RulesObject = CheckRulesObject;
break;
}
}
}
}
}
}
}
}
}
return(RulesObject);
}
/// <summary>
/// Construct a PluginReferenceDescriptor from a Json object
/// </summary>
/// <param name="RawObject">The Json object containing a plugin reference descriptor</param>
/// <returns>New PluginReferenceDescriptor object</returns>
public static PluginReferenceDescriptor FromJsonObject(JsonObject RawObject)
{
string[] WhitelistPlatformNames;
string[] BlacklistPlatformNames;
string[] SupportedTargetPlatformNames;
PluginReferenceDescriptor Descriptor = new PluginReferenceDescriptor(RawObject.GetStringField("Name"), null, RawObject.GetBoolField("Enabled"));
RawObject.TryGetBoolField("Optional", out Descriptor.bOptional);
RawObject.TryGetStringField("Description", out Descriptor.Description);
RawObject.TryGetStringField("MarketplaceURL", out Descriptor.MarketplaceURL);
RawObject.TryGetStringArrayField("WhitelistPlatforms", out WhitelistPlatformNames);
RawObject.TryGetStringArrayField("BlacklistPlatforms", out BlacklistPlatformNames);
RawObject.TryGetEnumArrayField <UnrealTargetConfiguration>("WhitelistTargetConfigurations", out Descriptor.WhitelistTargetConfigurations);
RawObject.TryGetEnumArrayField <UnrealTargetConfiguration>("BlacklistTargetConfigurations", out Descriptor.BlacklistTargetConfigurations);
RawObject.TryGetEnumArrayField <TargetType>("WhitelistTargets", out Descriptor.WhitelistTargets);
RawObject.TryGetEnumArrayField <TargetType>("BlacklistTargets", out Descriptor.BlacklistTargets);
RawObject.TryGetStringArrayField("SupportedTargetPlatforms", out SupportedTargetPlatformNames);
try
{
// convert string array to UnrealTargetPlatform arrays
if (WhitelistPlatformNames != null)
{
Descriptor.WhitelistPlatforms = WhitelistPlatformNames.Select(x => UnrealTargetPlatform.Parse(x)).ToList();
}
if (BlacklistPlatformNames != null)
{
Descriptor.BlacklistPlatforms = BlacklistPlatformNames.Select(x => UnrealTargetPlatform.Parse(x)).ToList();
}
if (SupportedTargetPlatformNames != null)
{
Descriptor.SupportedTargetPlatforms = SupportedTargetPlatformNames.Select(x => UnrealTargetPlatform.Parse(x)).ToList();
}
}
catch (BuildException Ex)
{
ExceptionUtils.AddContext(Ex, "while parsing PluginReferenceDescriptor {0}", Descriptor.Name);
throw;
}
return(Descriptor);
}
///
/// VisualStudio project generation functions
///
/// <summary>
/// Whether this build platform has native support for VisualStudio
/// </summary>
/// <param name="InPlatform"> The UnrealTargetPlatform being built</param>
/// <param name="InConfiguration"> The UnrealTargetConfiguration being built</param>
/// <param name="ProjectFileFormat"></param>
/// <returns>bool true if native VisualStudio support (or custom VSI) is available</returns>
public override bool HasVisualStudioSupport(UnrealTargetPlatform InPlatform, UnrealTargetConfiguration InConfiguration, VCProjectFileFormat ProjectFileFormat)
{
// iOS is not supported in VisualStudio
return(false);
}
/// <summary>
/// Gets the default architecture for a given platform
/// </summary>
/// <param name="Platform">The platform to get the default architecture for</param>
/// <param name="ProjectFile">Project file to read settings from</param>
/// <returns>The default architecture</returns>
public static string GetDefaultArchitecture(UnrealTargetPlatform Platform, FileReference ProjectFile)
{
return(UEBuildPlatform.GetBuildPlatform(Platform).GetDefaultArchitecture(ProjectFile));
}
/// <summary>
/// Determines whether the given plugin module is part of the current build.
/// </summary>
/// <param name="Platform">The platform being compiled for</param>
/// <param name="Configuration">The target configuration being compiled for</param>
/// <param name="TargetName">Name of the target being built</param>
/// <param name="TargetType">The type of the target being compiled</param>
/// <param name="bBuildDeveloperTools">Whether the configuration includes developer tools (typically UEBuildConfiguration.bBuildDeveloperTools for UBT callers)</param>
/// <param name="bBuildRequiresCookedData">Whether the configuration requires cooked content (typically UEBuildConfiguration.bBuildRequiresCookedData for UBT callers)</param>
public bool IsCompiledInConfiguration(UnrealTargetPlatform Platform, UnrealTargetConfiguration Configuration, string TargetName, TargetType TargetType, bool bBuildDeveloperTools, bool bBuildRequiresCookedData)
{
// Check the platform is whitelisted
if (WhitelistPlatforms != null && WhitelistPlatforms.Length > 0 && !WhitelistPlatforms.Contains(Platform))
{
return(false);
}
// Check the platform is not blacklisted
if (BlacklistPlatforms != null && BlacklistPlatforms.Contains(Platform))
{
return(false);
}
// Check the target is whitelisted
if (WhitelistTargets != null && WhitelistTargets.Length > 0 && !WhitelistTargets.Contains(TargetType))
{
return(false);
}
// Check the target is not blacklisted
if (BlacklistTargets != null && BlacklistTargets.Contains(TargetType))
{
return(false);
}
// Check the target configuration is whitelisted
if (WhitelistTargetConfigurations != null && WhitelistTargetConfigurations.Length > 0 && !WhitelistTargetConfigurations.Contains(Configuration))
{
return(false);
}
// Check the target configuration is not blacklisted
if (BlacklistTargetConfigurations != null && BlacklistTargetConfigurations.Contains(Configuration))
{
return(false);
}
// Special checks just for programs
if (TargetType == TargetType.Program)
{
// Check the program name is whitelisted. Note that this behavior is slightly different to other whitelist/blacklist checks; we will whitelist a module of any type if it's explicitly allowed for this program.
if (WhitelistPrograms != null && WhitelistPrograms.Length > 0)
{
return(WhitelistPrograms.Contains(TargetName));
}
// Check the program name is not blacklisted
if (BlacklistPrograms != null && BlacklistPrograms.Contains(TargetName))
{
return(false);
}
}
// Check the module is compatible with this target.
switch (Type)
{
case ModuleHostType.Runtime:
case ModuleHostType.RuntimeNoCommandlet:
return(TargetType != TargetType.Program);
case ModuleHostType.RuntimeAndProgram:
return(true);
case ModuleHostType.CookedOnly:
return(bBuildRequiresCookedData);
case ModuleHostType.UncookedOnly:
return(!bBuildRequiresCookedData);
case ModuleHostType.Developer:
return(TargetType == TargetType.Editor || TargetType == TargetType.Program);
case ModuleHostType.DeveloperTool:
return(bBuildDeveloperTools);
case ModuleHostType.Editor:
case ModuleHostType.EditorNoCommandlet:
return(TargetType == TargetType.Editor);
case ModuleHostType.EditorAndProgram:
return(TargetType == TargetType.Editor || TargetType == TargetType.Program);
case ModuleHostType.Program:
return(TargetType == TargetType.Program);
case ModuleHostType.ServerOnly:
return(TargetType != TargetType.Program && TargetType != TargetType.Client);
case ModuleHostType.ClientOnly:
return(TargetType != TargetType.Program && TargetType != TargetType.Server);
}
return(false);
}
/// <summary>
/// Returns the standard path to the build receipt for a given target
/// </summary>
/// <param name="BaseDir">Base directory for the target being built; either the project directory or engine directory.</param>
/// <param name="TargetName">The target being built</param>
/// <param name="Platform">The target platform</param>
/// <param name="Configuration">The target configuration</param>
/// <param name="BuildArchitecture">The architecture being built</param>
/// <returns>Path to the receipt for this target</returns>
public static FileReference GetDefaultPath(DirectoryReference BaseDir, string TargetName, UnrealTargetPlatform Platform, UnrealTargetConfiguration Configuration, string BuildArchitecture)
{
// Get the architecture suffix. Platforms have the option of overriding whether to include this string in filenames.
string ArchitectureSuffix = "";
if (UEBuildPlatform.GetBuildPlatform(Platform).RequiresArchitectureSuffix())
{
ArchitectureSuffix = BuildArchitecture;
}
// Build the output filename
if (String.IsNullOrEmpty(ArchitectureSuffix) && Configuration == UnrealTargetConfiguration.Development)
{
return(FileReference.Combine(BaseDir, "Binaries", Platform.ToString(), String.Format("{0}.target", TargetName)));
}
else
{
return(FileReference.Combine(BaseDir, "Binaries", Platform.ToString(), String.Format("{0}-{1}-{2}{3}.target", TargetName, Platform.ToString(), Configuration.ToString(), ArchitectureSuffix)));
}
}
public override bool PrepTargetForDeployment(TargetReceipt Receipt)
{
// Use the project name if possible - InTarget.AppName changes for 'Client'/'Server' builds
string ProjectName = Receipt.ProjectFile != null?Receipt.ProjectFile.GetFileNameWithoutAnyExtensions() : Receipt.Launch.GetFileNameWithoutExtension();
Log.TraceInformation("Prepping {0} for deployment to {1}", ProjectName, Receipt.Platform.ToString());
System.DateTime PrepDeployStartTime = DateTime.UtcNow;
// Note: TargetReceipt.Read now expands path variables internally.
TargetReceipt NewReceipt = null;
FileReference ReceiptFileName = TargetReceipt.GetDefaultPath(Receipt.ProjectDir != null ? Receipt.ProjectDir : UnrealBuildTool.EngineDirectory, Receipt.TargetName, Receipt.Platform, Receipt.Configuration, "Multi");
if (!TargetReceipt.TryRead(ReceiptFileName, UnrealBuildTool.EngineDirectory, out NewReceipt))
{
NewReceipt = new TargetReceipt(Receipt.ProjectFile, Receipt.TargetName, Receipt.TargetType, Receipt.Platform, Receipt.Configuration, Receipt.Version, "Multi");
}
AddWinMDReferencesFromReceipt(Receipt, Receipt.ProjectDir != null ? Receipt.ProjectDir : UnrealBuildTool.EngineDirectory, UnrealBuildTool.EngineDirectory.ParentDirectory.FullName);
//PrepForUATPackageOrDeploy(InTarget.ProjectFile, InAppName, InTarget.ProjectDirectory.FullName, InTarget.OutputPath.FullName, TargetBuildEnvironment.RelativeEnginePath, false, "", false);
List <UnrealTargetConfiguration> TargetConfigs = new List <UnrealTargetConfiguration> {
Receipt.Configuration
};
List <string> ExePaths = new List <string> {
Receipt.Launch.FullName
};
string RelativeEnginePath = UnrealBuildTool.EngineDirectory.MakeRelativeTo(DirectoryReference.GetCurrentDirectory());
WindowsArchitecture Arch = WindowsArchitecture.ARM64;
if (Receipt.Architecture.ToLower() == "x64")
{
Arch = WindowsArchitecture.x64;
}
string SDK = "";
var Results = Receipt.AdditionalProperties.Where(x => x.Name == "SDK");
if (Results.Any())
{
SDK = Results.First().Value;
}
HoloLensExports.InitWindowsSdkToolPath(SDK);
string AbsoluteExeDirectory = Path.GetDirectoryName(ExePaths[0]);
UnrealTargetPlatform Platform = UnrealTargetPlatform.HoloLens;
string IntermediateDirectory = Path.Combine(Receipt.ProjectDir != null ? Receipt.ProjectDir.FullName : UnrealBuildTool.EngineDirectory.FullName, "Intermediate", "Deploy", WindowsExports.GetArchitectureSubpath(Arch));
List <string> UpdatedFiles = new HoloLensManifestGenerator().CreateManifest(Platform, Arch, AbsoluteExeDirectory, IntermediateDirectory, Receipt.ProjectFile, Receipt.ProjectDir != null ? Receipt.ProjectDir.FullName : UnrealBuildTool.EngineDirectory.FullName, TargetConfigs, ExePaths, WinMDReferences);
PrepForUATPackageOrDeploy(Receipt.ProjectFile, ProjectName, Receipt.ProjectDir != null ? Receipt.ProjectDir.FullName : UnrealBuildTool.EngineDirectory.FullName, Arch, TargetConfigs, ExePaths, RelativeEnginePath, false, "", false);
MakePackage(Receipt, NewReceipt, Arch, UpdatedFiles);
CopyDataAndSymbolsBetweenReceipts(Receipt, NewReceipt, Arch);
NewReceipt.Write(ReceiptFileName, UnrealBuildTool.EngineDirectory);
// Log out the time taken to deploy...
double PrepDeployDuration = (DateTime.UtcNow - PrepDeployStartTime).TotalSeconds;
Log.TraceInformation("HoloLens deployment preparation took {0:0.00} seconds", PrepDeployDuration);
return(true);
}
/// <summary>
/// Constructs a ModuleDescriptor from a Json object
/// </summary>
/// <param name="InObject"></param>
/// <returns>The new module descriptor</returns>
public static ModuleDescriptor FromJsonObject(JsonObject InObject)
{
ModuleDescriptor Module = new ModuleDescriptor(InObject.GetStringField("Name"), InObject.GetEnumField <ModuleHostType>("Type"));
ModuleLoadingPhase LoadingPhase;
if (InObject.TryGetEnumField <ModuleLoadingPhase>("LoadingPhase", out LoadingPhase))
{
Module.LoadingPhase = LoadingPhase;
}
try
{
string[] WhitelistPlatforms;
if (InObject.TryGetStringArrayField("WhitelistPlatforms", out WhitelistPlatforms))
{
Module.WhitelistPlatforms = Array.ConvertAll(WhitelistPlatforms, x => UnrealTargetPlatform.Parse(x));
}
string[] BlacklistPlatforms;
if (InObject.TryGetStringArrayField("BlacklistPlatforms", out BlacklistPlatforms))
{
Module.BlacklistPlatforms = Array.ConvertAll(BlacklistPlatforms, x => UnrealTargetPlatform.Parse(x));
}
}
catch (BuildException Ex)
{
ExceptionUtils.AddContext(Ex, "while parsing module descriptor '{0}'", Module.Name);
throw;
}
TargetType[] WhitelistTargets;
if (InObject.TryGetEnumArrayField <TargetType>("WhitelistTargets", out WhitelistTargets))
{
Module.WhitelistTargets = WhitelistTargets;
}
TargetType[] BlacklistTargets;
if (InObject.TryGetEnumArrayField <TargetType>("BlacklistTargets", out BlacklistTargets))
{
Module.BlacklistTargets = BlacklistTargets;
}
UnrealTargetConfiguration[] WhitelistTargetConfigurations;
if (InObject.TryGetEnumArrayField <UnrealTargetConfiguration>("WhitelistTargetConfigurations", out WhitelistTargetConfigurations))
{
Module.WhitelistTargetConfigurations = WhitelistTargetConfigurations;
}
UnrealTargetConfiguration[] BlacklistTargetConfigurations;
if (InObject.TryGetEnumArrayField <UnrealTargetConfiguration>("BlacklistTargetConfigurations", out BlacklistTargetConfigurations))
{
Module.BlacklistTargetConfigurations = BlacklistTargetConfigurations;
}
string[] WhitelistPrograms;
if (InObject.TryGetStringArrayField("WhitelistPrograms", out WhitelistPrograms))
{
Module.WhitelistPrograms = WhitelistPrograms;
}
string[] BlacklistPrograms;
if (InObject.TryGetStringArrayField("BlacklistPrograms", out BlacklistPrograms))
{
Module.BlacklistPrograms = BlacklistPrograms;
}
string[] AdditionalDependencies;
if (InObject.TryGetStringArrayField("AdditionalDependencies", out AdditionalDependencies))
{
Module.AdditionalDependencies = AdditionalDependencies;
}
return(Module);
}
public LinuxPlatform(UnrealTargetPlatform UnrealTarget, CppPlatform InCppPlatform, LinuxPlatformSDK InSDK)
: base(UnrealTarget, InCppPlatform)
{
SDK = InSDK;
}
private static bool IsPathExcludedOnPlatform(string SourceFileRelativeToRoot, UnrealTargetPlatform targetPlatform)
{
switch (targetPlatform)
{
case UnrealTargetPlatform.Linux:
{
return(IsPathExcludedOnLinux(SourceFileRelativeToRoot));
}
case UnrealTargetPlatform.Mac:
{
return(IsPathExcludedOnMac(SourceFileRelativeToRoot));
}
case UnrealTargetPlatform.Win64:
{
return(IsPathExcludedOnWindows(SourceFileRelativeToRoot));
}
default:
{
return(false);
}
}
}
/// <summary>
/// Loads JunkManifest.txt file.
/// </summary>
/// <returns>Junk manifest file contents.</returns>
static private List <string> LoadJunkManifest()
{
string ManifestPath = ".." + Path.DirectorySeparatorChar + "Build" + Path.DirectorySeparatorChar + "JunkManifest.txt";
List <string> JunkManifest = new List <string>();
if (File.Exists(ManifestPath))
{
string MachineName = Environment.MachineName;
using (StreamReader reader = new StreamReader(ManifestPath))
{
string CurrentToRootDir = ".." + Path.DirectorySeparatorChar + "..";
string LineRead;
while ((LineRead = reader.ReadLine()) != null)
{
string JunkEntry = LineRead.Trim();
if (String.IsNullOrEmpty(JunkEntry) == false)
{
string[] Tokens = JunkEntry.Split(":".ToCharArray());
bool bIsValidJunkLine = true;
foreach (string Token in Tokens)
{
if (Token.StartsWith("Machine=", StringComparison.InvariantCultureIgnoreCase) == true)
{
string[] InnerTokens = Token.Split("=".ToCharArray());
// check if the machine name on the line matches the current machine name, if not, we don't apply this junk
if (InnerTokens.Length == 2 && MachineName.StartsWith(InnerTokens[1]) == false)
{
// Not meant for this machine
bIsValidJunkLine = false;
}
}
else if (Token.StartsWith("Platform=", StringComparison.InvariantCultureIgnoreCase) == true)
{
string[] InnerTokens = Token.Split("=".ToCharArray());
// check if the machine name on the line matches the current machine name, if not, we don't apply this junk
if (InnerTokens.Length == 2)
{
UnrealTargetPlatform ParsedPlatform = UEBuildPlatform.ConvertStringToPlatform(InnerTokens[1]);
// if the platform is valid, then we want to keep the files, which means that we don't want to apply the junk line
if (ParsedPlatform != UnrealTargetPlatform.Unknown)
{
if (UEBuildPlatform.GetBuildPlatform(ParsedPlatform, bInAllowFailure: true) != null)
{
// this is a good platform, so don't delete any files!
bIsValidJunkLine = false;
}
}
}
}
}
// All paths within the manifest are UE4 root directory relative.
// UBT's working directory is Engine\Source so add "..\..\" to each of the entires.
if (bIsValidJunkLine)
{
// the entry is always the last element in the token array (after the final :)
string FixedPath = Path.Combine(CurrentToRootDir, Tokens[Tokens.Length - 1]);
FixedPath = FixedPath.Replace('\\', Path.DirectorySeparatorChar);
JunkManifest.Add(FixedPath);
}
}
}
}
}
return(JunkManifest);
}
/// <summary>
/// Determine if a plugin is enabled for a given project
/// </summary>
/// <param name="Project">The project to check</param>
/// <param name="Plugin">Information about the plugin</param>
/// <param name="Platform">The target platform</param>
/// <param name="TargetType"></param>
/// <param name="bBuildDeveloperTools"></param>
/// <param name="bBuildEditor"></param>
/// <param name="bBuildRequiresCookedData"></param>
/// <returns>True if the plugin should be enabled for this project</returns>
public static bool IsPluginDescriptorRequiredForProject(PluginInfo Plugin, ProjectDescriptor Project, UnrealTargetPlatform Platform, TargetType TargetType, bool bBuildDeveloperTools, bool bBuildEditor, bool bBuildRequiresCookedData)
{
// Check if it's referenced by name from the project descriptor. If it is, we'll need the plugin to be included with the project regardless of whether it has
// any platform-specific modules or content, just so the runtime can make the call.
if (Project != null && Project.Plugins != null)
{
foreach (PluginReferenceDescriptor PluginReference in Project.Plugins)
{
if (String.Compare(PluginReference.Name, Plugin.Name, true) == 0)
{
return(PluginReference.IsEnabledForPlatform(Platform) && PluginReference.IsEnabledForTarget(TargetType));
}
}
}
// If the plugin contains content, it should be included for all platforms
if (Plugin.Descriptor.bCanContainContent)
{
return(true);
}
// Check if the plugin has any modules for the given target
foreach (ModuleDescriptor Module in Plugin.Descriptor.Modules)
{
if (Module.IsCompiledInConfiguration(Platform, TargetType, bBuildDeveloperTools, bBuildEditor, bBuildRequiresCookedData))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Determine if a plugin is enabled for a given project
/// </summary>
/// <param name="Project">The project to check. May be null.</param>
/// <param name="Plugin">Information about the plugin</param>
/// <param name="Platform">The target platform</param>
/// <param name="Configuration">The target configuration</param>
/// <param name="TargetType">The type of target being built</param>
/// <returns>True if the plugin should be enabled for this project</returns>
public static bool IsPluginEnabledForTarget(PluginInfo Plugin, ProjectDescriptor Project, UnrealTargetPlatform Platform, UnrealTargetConfiguration Configuration, TargetType TargetType)
{
if (!Plugin.Descriptor.SupportsTargetPlatform(Platform))
{
return(false);
}
bool bAllowEnginePluginsEnabledByDefault = (Project == null ? true : !Project.DisableEnginePluginsByDefault);
bool bEnabled = Plugin.IsEnabledByDefault(bAllowEnginePluginsEnabledByDefault);
if (Project != null && Project.Plugins != null)
{
foreach (PluginReferenceDescriptor PluginReference in Project.Plugins)
{
if (String.Compare(PluginReference.Name, Plugin.Name, true) == 0 && !PluginReference.bOptional)
{
bEnabled = PluginReference.IsEnabledForPlatform(Platform) && PluginReference.IsEnabledForTargetConfiguration(Configuration) && PluginReference.IsEnabledForTarget(TargetType);
}
}
}
return(bEnabled);
}
public LinuxPlatform(UnrealTargetPlatform UnrealTarget, LinuxPlatformSDK InSDK)
: base(UnrealTarget)
{
SDK = InSDK;
}
/// <summary>
/// Check whether the given platform supports XGE
/// </summary>
/// <param name="Platform">Platform to check</param>
/// <returns>True if the platform supports XGE</returns>
public static bool CanUseXGE(UnrealTargetPlatform Platform)
{
return(UEBuildPlatform.IsPlatformAvailable(Platform) && UEBuildPlatform.GetBuildPlatform(Platform).CanUseXGE());
}
/// <summary>
/// Read a receipt from disk.
/// </summary>
/// <param name="Location">Filename to read from</param>
/// <param name="EngineDir">Engine directory for expanded variables</param>
/// <param name="ProjectDir">Project directory for expanded variables</param>
public static TargetReceipt Read(FileReference Location, DirectoryReference EngineDir, DirectoryReference ProjectDir)
{
JsonObject RawObject = JsonObject.Read(Location.FullName);
// Read the initial fields
string TargetName = RawObject.GetStringField("TargetName");
UnrealTargetPlatform Platform = RawObject.GetEnumField <UnrealTargetPlatform>("Platform");
UnrealTargetConfiguration Configuration = RawObject.GetEnumField <UnrealTargetConfiguration>("Configuration");
string BuildId = RawObject.GetStringField("BuildId");
// Try to read the build version
BuildVersion Version;
if (!BuildVersion.TryParse(RawObject.GetObjectField("Version"), out Version))
{
throw new JsonParseException("Invalid 'Version' field");
}
// Create the receipt
TargetReceipt Receipt = new TargetReceipt(TargetName, Platform, Configuration, BuildId, Version);
// Read the build products
JsonObject[] BuildProductObjects;
if (RawObject.TryGetObjectArrayField("BuildProducts", out BuildProductObjects))
{
foreach (JsonObject BuildProductObject in BuildProductObjects)
{
string Path;
BuildProductType Type;
if (BuildProductObject.TryGetStringField("Path", out Path) && BuildProductObject.TryGetEnumField("Type", out Type))
{
FileReference File = ExpandPathVariables(Path, EngineDir, ProjectDir);
string Module;
BuildProductObject.TryGetStringField("Module", out Module);
BuildProduct NewBuildProduct = Receipt.AddBuildProduct(File, Type);
bool IsPrecompiled;
if (BuildProductObject.TryGetBoolField("IsPrecompiled", out IsPrecompiled))
{
NewBuildProduct.IsPrecompiled = IsPrecompiled;
}
}
}
}
// Read the runtime dependencies
JsonObject[] RuntimeDependencyObjects;
if (RawObject.TryGetObjectArrayField("RuntimeDependencies", out RuntimeDependencyObjects))
{
foreach (JsonObject RuntimeDependencyObject in RuntimeDependencyObjects)
{
string Path;
if (RuntimeDependencyObject.TryGetStringField("Path", out Path))
{
FileReference File = ExpandPathVariables(Path, EngineDir, ProjectDir);
StagedFileType Type;
if (!RuntimeDependencyObject.TryGetEnumField("Type", out Type))
{
// Previous format included an optional IgnoreIfMissing flag, which was only used for debug files. We can explicitly reference them as DebugNonUFS files now.
bool bIgnoreIfMissing;
if (RuntimeDependencyObject.TryGetBoolField("IgnoreIfMissing", out bIgnoreIfMissing))
{
bIgnoreIfMissing = false;
}
Type = bIgnoreIfMissing? StagedFileType.DebugNonUFS : StagedFileType.NonUFS;
}
Receipt.RuntimeDependencies.Add(File, Type);
}
}
}
// Read the additional properties
JsonObject[] AdditionalPropertyObjects;
if (RawObject.TryGetObjectArrayField("AdditionalProperties", out AdditionalPropertyObjects))
{
foreach (JsonObject AdditionalPropertyObject in AdditionalPropertyObjects)
{
string Name;
if (AdditionalPropertyObject.TryGetStringField("Name", out Name))
{
string Value;
if (AdditionalPropertyObject.TryGetStringField("Value", out Value))
{
Receipt.AdditionalProperties.Add(new ReceiptProperty(Name, Value));
}
}
}
}
// Read the precompiled dependencies
string[] PrecompiledBuildDependencies;
if (RawObject.TryGetStringArrayField("PrecompiledBuildDependencies", out PrecompiledBuildDependencies))
{
foreach (string PrecompiledBuildDependency in PrecompiledBuildDependencies)
{
FileReference File = ExpandPathVariables(PrecompiledBuildDependency, EngineDir, ProjectDir);
Receipt.PrecompiledBuildDependencies.Add(File);
}
}
// Read the precompiled dependencies
string[] PrecompiledRuntimeDependencies;
if (RawObject.TryGetStringArrayField("PrecompiledRuntimeDependencies", out PrecompiledRuntimeDependencies))
{
foreach (string PrecompiledRuntimeDependency in PrecompiledRuntimeDependencies)
{
FileReference File = ExpandPathVariables(PrecompiledRuntimeDependency, EngineDir, ProjectDir);
Receipt.PrecompiledRuntimeDependencies.Add(File);
}
}
return(Receipt);
}
/// <summary>
/// Checks whether the given platform is available
/// </summary>
/// <param name="Platform">Platform to check</param>
/// <returns>True if the platform is available, false otherwise</returns>
public static bool IsPlatformAvailable(UnrealTargetPlatform Platform)
{
return(UEBuildPlatform.IsPlatformAvailable(Platform));
}
/// <summary>
/// Checks whether the given project has a default build configuration
/// </summary>
/// <param name="ProjectFile">The project file</param>
/// <param name="Platform">Platform to check settings for</param>
/// <returns>True if the project uses the default build configuration</returns>
public static bool HasDefaultBuildConfig(FileReference ProjectFile, UnrealTargetPlatform Platform)
{
UEBuildPlatform BuildPlat = UEBuildPlatform.GetBuildPlatform(Platform, true);
return((BuildPlat == null)? true : BuildPlat.HasDefaultBuildConfig(Platform, ProjectFile.Directory));
}
/// <summary>
/// Return the platform toolset string to write into the project configuration
/// </summary>
/// <param name="InPlatform"> The UnrealTargetPlatform being built</param>
/// <param name="InConfiguration"> The UnrealTargetConfiguration being built</param>
/// <param name="InProjectFileFormat"> The verison of VS</param>
/// <param name="ProjectFileBuilder">String builder for the project file</param>
/// <returns>string The custom configuration section for the project file; Empty string if it doesn't require one</returns>
public override void GetVisualStudioPlatformToolsetString(UnrealTargetPlatform InPlatform, UnrealTargetConfiguration InConfiguration, VCProjectFileFormat InProjectFileFormat, StringBuilder ProjectFileBuilder)
{
ProjectFileBuilder.AppendLine(" <PlatformToolset>" + VCProjectFileGenerator.GetProjectFilePlatformToolsetVersionString(InProjectFileFormat) + "</PlatformToolset>");
}
/// <summary>
/// Determine if a plugin is enabled for a given project
/// </summary>
/// <param name="Project">The project to check. May be null.</param>
/// <param name="Plugin">Information about the plugin</param>
/// <param name="Platform">The target platform</param>
/// <param name="Configuration">The target configuration</param>
/// <param name="TargetType">The type of target being built</param>
/// <param name="bRequiresCookedData">Whether the target requires cooked data</param>
/// <returns>True if the plugin should be enabled for this project</returns>
public static bool IsPluginCompiledForTarget(PluginInfo Plugin, ProjectDescriptor Project, UnrealTargetPlatform Platform, UnrealTargetConfiguration Configuration, TargetType TargetType, bool bRequiresCookedData)
{
bool bCompiledForTarget = false;
if (IsPluginEnabledForTarget(Plugin, Project, Platform, Configuration, TargetType) && Plugin.Descriptor.Modules != null)
{
bool bBuildDeveloperTools = (TargetType == TargetType.Editor || TargetType == TargetType.Program || (Configuration != UnrealTargetConfiguration.Test && Configuration != UnrealTargetConfiguration.Shipping));
foreach (ModuleDescriptor Module in Plugin.Descriptor.Modules)
{
if (Module.IsCompiledInConfiguration(Platform, Configuration, "", TargetType, bBuildDeveloperTools, bRequiresCookedData))
{
bCompiledForTarget = true;
break;
}
}
}
return(bCompiledForTarget);
}
/// <summary>
/// Creates a target rules object for the specified target name.
/// </summary>
/// <param name="TargetName">Name of the target</param>
/// <param name="Platform">The platform that the target is being built for</param>
/// <param name="Configuration">The configuration the target is being built for</param>
/// <param name="Architecture">The architecture the target is being built for</param>
/// <param name="ProjectFile">The project containing the target being built</param>
/// <param name="bInEditorRecompile">Whether this is an editor recompile, where we need to guess the name of the editor target</param>
/// <returns>The build target rules for the specified target</returns>
public TargetRules CreateTargetRules(string TargetName, UnrealTargetPlatform Platform, UnrealTargetConfiguration Configuration, string Architecture, FileReference ProjectFile, bool bInEditorRecompile)
{
FileReference TargetFileName;
return(CreateTargetRules(TargetName, Platform, Configuration, Architecture, ProjectFile, bInEditorRecompile, out TargetFileName));
}
/// <summary>
/// Whether this build platform has native support for VisualStudio
/// </summary>
/// <param name="InPlatform"> The UnrealTargetPlatform being built</param>
/// <param name="InConfiguration"> The UnrealTargetConfiguration being built</param>
/// <param name="ProjectFileFormat"> Which version of VS</param>
/// <returns>bool true if native VisualStudio support (or custom VSI) is available</returns>
public override bool HasVisualStudioSupport(UnrealTargetPlatform InPlatform, UnrealTargetConfiguration InConfiguration, VCProjectFileFormat ProjectFileFormat)
{
// TODO: Returning true from here is resulting in VS erroring out when trying to build a game project for Lumin.
return(false); //IsVSLuminSupportInstalled(ProjectFileFormat);
}
/// <summary>
/// Whether this build platform has native support for VisualStudio
/// </summary>
/// <param name="InPlatform"> The UnrealTargetPlatform being built</param>
/// <param name="InConfiguration"> The UnrealTargetConfiguration being built</param>
/// <returns>bool true if native VisualStudio support (or custom VSI) is available</returns>
public override bool HasVisualStudioSupport(UnrealTargetPlatform InPlatform, UnrealTargetConfiguration InConfiguration)
{
// Debugging, etc. are dependent on the TADP being installed
return(IsNsightInstalled());
}
