void ExecuteInner()
{
var UE4Build = new UE4Build(this);
var Agenda_Mono = new UE4Build.BuildAgenda();
var Agenda_NonUnity = new UE4Build.BuildAgenda();
{
{
var Win64DevTargets = new string[]
{
"FortniteEditor",
"OrionEditor",
"PlatformerGameEditor",
"QAGameEditor",
"ShooterGameEditor",
"StrategyGameEditor",
"VehicleGameEditor",
};
Agenda_Mono.AddTargets(Win64DevTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development, bForceMonolithic: true);
Agenda_Mono.AddTargets(Win64DevTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Shipping, bForceMonolithic: true);
Agenda_Mono.AddTargets(Win64DevTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development, bForceNonUnity: true);
Agenda_Mono.AddTargets(Win64DevTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Shipping, bForceNonUnity: true);
var Win32Targets = new string[]
{
"FortniteGame",
"FortniteServer",
"OrionGame",
"PlatformerGame",
"QAGame",
"ShooterGame",
"StrategyGame",
"VehicleGame",
};
Agenda_Mono.AddTargets(Win32Targets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Development, bForceMonolithic: true);
Agenda_Mono.AddTargets(Win32Targets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Development, bForceNonUnity: true);
var Win32ShipTargets = new string[]
{
"FortniteGame",
"FortniteServer",
};
Agenda_Mono.AddTargets(Win32ShipTargets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Shipping, bForceMonolithic: true);
Agenda_Mono.AddTargets(Win32ShipTargets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Shipping, bForceNonUnity: true);
}
}
UE4Build.Build(Agenda_Mono, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
UE4Build.Build(Agenda_NonUnity, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
}
void ExecuteInner()
{
var UE4Build = new UE4Build(this);
var Agenda = new UE4Build.BuildAgenda();
{
var Win32Targets = new string[]
{
"FortniteClient",
"FortniteGame",
"FortniteServer",
"OrionServer",
"OrionClient",
"OrionGame",
};
Agenda.AddTargets(Win32Targets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Shipping);
Agenda.AddTargets(Win32Targets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Test);
}
Agenda.DoRetries = false;
Agenda.SpecialTestFlag = true;
UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
}
public override void ExecuteBuild()
{
// Get the plugin filename
string PluginFileName = ParseParamValue("Plugin");
if(PluginFileName == null)
{
throw new AutomationException("Plugin file name was not specified via the -plugin argument");
}
// Read the plugin
PluginDescriptor Plugin = PluginDescriptor.FromFile(PluginFileName);
// Clean the intermediate build directory
string IntermediateBuildDirectory = Path.Combine(Path.GetDirectoryName(PluginFileName), "Intermediate", "Build");
if(CommandUtils.DirectoryExists(IntermediateBuildDirectory))
{
CommandUtils.DeleteDirectory(IntermediateBuildDirectory);
}
// Get any additional arguments from the commandline
string AdditionalArgs = "";
if(ParseParam("Rocket"))
{
AdditionalArgs += " -Rocket";
}
// Build the host platforms
List<string> ReceiptFileNames = new List<string>();
UE4Build.BuildAgenda Agenda = new UE4Build.BuildAgenda();
UnrealTargetPlatform HostPlatform = BuildHostPlatform.Current.Platform;
if(!ParseParam("NoHostPlatform"))
{
AddPluginToAgenda(Agenda, PluginFileName, Plugin, "UE4Editor", TargetRules.TargetType.Editor, HostPlatform, UnrealTargetConfiguration.Development, ReceiptFileNames, AdditionalArgs);
}
// Add the game targets
List<UnrealTargetPlatform> TargetPlatforms = Rocket.RocketBuild.GetTargetPlatforms(this, HostPlatform);
foreach(UnrealTargetPlatform TargetPlatform in TargetPlatforms)
{
if(Rocket.RocketBuild.IsCodeTargetPlatform(HostPlatform, TargetPlatform))
{
AddPluginToAgenda(Agenda, PluginFileName, Plugin, "UE4Game", TargetRules.TargetType.Game, TargetPlatform, UnrealTargetConfiguration.Development, ReceiptFileNames, AdditionalArgs);
AddPluginToAgenda(Agenda, PluginFileName, Plugin, "UE4Game", TargetRules.TargetType.Game, TargetPlatform, UnrealTargetConfiguration.Shipping, ReceiptFileNames, AdditionalArgs);
}
}
// Build it
UE4Build Build = new UE4Build(this);
Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: false);
// Package the plugin to the output folder
string PackageDirectory = ParseParamValue("Package");
if(PackageDirectory != null)
{
List<BuildProduct> BuildProducts = GetBuildProductsFromReceipts(ReceiptFileNames);
PackagePlugin(PluginFileName, BuildProducts, PackageDirectory);
}
}
/// <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");
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);
}
private static void BuildProduct(BuildCommand Command, UE4Build.BuildTarget Target)
{
if (Target == null)
{
throw new AutomationException("Target is required when calling UE4BuildUtils.BuildProduct");
}
LogConsole("Building {0}", Target.TargetName);
if (Command == null)
{
Command = new UE4BuildUtilDummyBuildCommand();
}
var UE4Build = new UE4Build(Command);
var Agenda = new UE4Build.BuildAgenda();
Agenda.Targets.Add(Target);
UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
}
/// <summary>
/// Execute the task.
/// </summary>
/// <param name="Job">Information about the current job</param>
/// <param name="BuildProducts">Set of build products produced by this node.</param>
/// <param name="TagNameToFileSet">Mapping from tag names to the set of files they include</param>
/// <returns>True if the task succeeded</returns>
public override bool Execute(JobContext Job, HashSet<FileReference> BuildProducts, Dictionary<string, HashSet<FileReference>> TagNameToFileSet)
{
// Create the agenda
UE4Build.BuildAgenda Agenda = new UE4Build.BuildAgenda();
Agenda.Targets.AddRange(Targets);
// Build everything
Dictionary<UE4Build.BuildTarget, BuildManifest> TargetToManifest = new Dictionary<UE4Build.BuildTarget,BuildManifest>();
UE4Build Builder = new UE4Build(Job.OwnerCommand);
try
{
bool bCanUseParallelExecutor = (BuildHostPlatform.Current.Platform == UnrealTargetPlatform.Win64); // parallel executor is only available on Windows as of 2016-09-22
Builder.Build(Agenda, InDeleteBuildProducts: null, InUpdateVersionFiles: false, InForceNoXGE: false, InUseParallelExecutor: bCanUseParallelExecutor, InTargetToManifest: TargetToManifest);
}
catch (CommandUtils.CommandFailedException)
{
return false;
}
UE4Build.CheckBuildProducts(Builder.BuildProductFiles);
// Tag all the outputs
foreach(KeyValuePair<UE4Build.BuildTarget, string> TargetTagName in TargetToTagName)
{
BuildManifest Manifest;
if(!TargetToManifest.TryGetValue(TargetTagName.Key, out Manifest))
{
throw new AutomationException("Missing manifest for target {0} {1} {2}", TargetTagName.Key.TargetName, TargetTagName.Key.Platform, TargetTagName.Key.Config);
}
foreach(string TagName in SplitDelimitedList(TargetTagName.Value))
{
HashSet<FileReference> FileSet = FindOrAddTagSet(TagNameToFileSet, TagName);
FileSet.UnionWith(Manifest.BuildProducts.Select(x => new FileReference(x)));
FileSet.UnionWith(Manifest.LibraryBuildProducts.Select(x => new FileReference(x)));
}
}
// Add everything to the list of build products
BuildProducts.UnionWith(Builder.BuildProductFiles.Select(x => new FileReference(x)));
BuildProducts.UnionWith(Builder.LibraryBuildProductFiles.Select(x => new FileReference(x)));
return true;
}
public override void ExecuteBuild()
{
LogConsole("************************* BuildCommonTools");
// Get the list of platform names
string[] PlatformNames = ParseParamValue("platforms", BuildHostPlatform.Current.Platform.ToString()).Split('+');
// Parse the platforms
List<UnrealBuildTool.UnrealTargetPlatform> Platforms = new List<UnrealTargetPlatform>();
foreach(string PlatformName in PlatformNames)
{
UnrealBuildTool.UnrealTargetPlatform Platform;
if(!UnrealBuildTool.UnrealTargetPlatform.TryParse(PlatformName, true, out Platform))
{
throw new AutomationException("Unknown platform specified on command line - '{0}' - valid platforms are {1}", PlatformName, String.Join("/", Enum.GetNames(typeof(UnrealBuildTool.UnrealTargetPlatform))));
}
Platforms.Add(Platform);
}
// Add all the platforms if specified
if(ParseParam("allplatforms"))
{
foreach(UnrealTargetPlatform Platform in Enum.GetValues(typeof(UnrealTargetPlatform)))
{
if(!Platforms.Contains(Platform))
{
Platforms.Add(Platform);
}
}
}
// Get the agenda
List<string> ExtraBuildProducts = new List<string>();
UE4Build.BuildAgenda Agenda = MakeAgenda(Platforms.ToArray(), ExtraBuildProducts);
// Build everything. We don't want to touch version files for GitHub builds -- these are "programmer builds" and won't have a canonical build version
UE4Build Builder = new UE4Build(this);
Builder.Build(Agenda, InDeleteBuildProducts:true, InUpdateVersionFiles: false);
// Add UAT and UBT to the build products
Builder.AddUATFilesToBuildProducts();
Builder.AddUBTFilesToBuildProducts();
// Add all the extra build products
foreach(string ExtraBuildProduct in ExtraBuildProducts)
{
Builder.AddBuildProduct(ExtraBuildProduct);
}
// Make sure all the build products exist
UE4Build.CheckBuildProducts(Builder.BuildProductFiles);
// Write the manifest if needed
string ManifestPath = ParseParamValue("manifest");
if(ManifestPath != null)
{
SortedSet<string> Files = new SortedSet<string>();
foreach(string BuildProductFile in Builder.BuildProductFiles)
{
Files.Add(BuildProductFile);
}
File.WriteAllLines(ManifestPath, Files.ToArray());
}
}
public override void ExecuteBuild()
{
var Build = new UE4Build(this);
var Agenda = new UE4Build.BuildAgenda();
var Platform = UnrealBuildTool.UnrealTargetPlatform.Win64;
var Configuration = UnrealBuildTool.UnrealTargetConfiguration.Development;
var Targets = new List<string>();
foreach (var ObjParam in Params)
{
var Param = (string)ObjParam;
UnrealBuildTool.UnrealTargetPlatform ParsePlatform;
if (Enum.TryParse<UnrealBuildTool.UnrealTargetPlatform>(Param, true, out ParsePlatform))
{
Platform = ParsePlatform;
continue;
}
UnrealBuildTool.UnrealTargetConfiguration ParseConfiguration;
if (Enum.TryParse<UnrealBuildTool.UnrealTargetConfiguration>(Param, true, out ParseConfiguration))
{
Configuration = ParseConfiguration;
continue;
}
if (String.Compare("NoXGE", Param, true) != 0 && String.Compare("Clean", Param, true) != 0)
{
Targets.Add(Param);
}
}
var Clean = ParseParam("Clean");
Agenda.AddTargets(Targets.ToArray(), Platform, Configuration);
Log("UBT Buid");
Log("Targets={0}", String.Join(",", Targets));
Log("Platform={0}", Platform);
Log("Configuration={0}", Configuration);
Log("Clean={0}", Clean);
Build.Build(Agenda, InUpdateVersionFiles: false);
Log("UBT Completed");
}
public override void DoBuild(GUBP bp)
{
BuildProducts = new List<string>();
var UE4Build = new UE4Build(bp);
UE4Build.BuildAgenda Agenda = GetAgenda(bp);
if (Agenda != null)
{
Agenda.DoRetries = false; // these would delete build products
UE4Build.Build(Agenda, InDeleteBuildProducts: DeleteBuildProducts(), InUpdateVersionFiles: false, InForceUnity: true);
PostBuild(bp, UE4Build);
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
foreach (var Product in UE4Build.BuildProductFiles)
{
AddBuildProduct(Product);
}
RemoveOveralppingBuildProducts();
if (bp.bSignBuildProducts)
{
// Sign everything we built
CodeSign.SignMultipleIfEXEOrDLL(bp, BuildProducts);
}
}
else
{
SaveRecordOfSuccessAndAddToBuildProducts("Nothing to actually compile");
}
}
// Broken down steps used to run the process.
#region RebuildLightMaps Process Steps
private void BuildNecessaryTargets()
{
Log("Running Step:- RebuildLightMaps::BuildNecessaryTargets");
UE4Build.BuildAgenda Agenda = new UE4Build.BuildAgenda();
Agenda.AddTarget("UnrealHeaderTool", UnrealBuildTool.UnrealTargetPlatform.Win64, UnrealBuildTool.UnrealTargetConfiguration.Development);
Agenda.AddTarget("ShaderCompileWorker", UnrealBuildTool.UnrealTargetPlatform.Win64, UnrealBuildTool.UnrealTargetConfiguration.Development);
Agenda.AddTarget("UnrealLightmass", UnrealBuildTool.UnrealTargetPlatform.Win64, UnrealBuildTool.UnrealTargetConfiguration.Development);
Agenda.AddTarget(CommandletTargetName, UnrealBuildTool.UnrealTargetPlatform.Win64, UnrealBuildTool.UnrealTargetConfiguration.Development);
try
{
UE4Build Builder = new UE4Build(this);
Builder.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true, InForceNoXGE: false, InChangelistNumberOverride: GetLatestCodeChange());
UE4Build.CheckBuildProducts(Builder.BuildProductFiles);
}
catch (AutomationException Ex)
{
LogError("Rebuild Light Maps has failed.");
throw Ex;
}
}
void ExecuteInner()
{
var UE4Build = new UE4Build(this);
var Agenda = new UE4Build.BuildAgenda();
Agenda.DotNetSolutions.AddRange(
new string[]
{
@"Engine\Source\Programs\UnrealDocTool\UnrealDocTool\UnrealDocTool.sln",
@"Engine\Source\Programs\NetworkProfiler\NetworkProfiler.sln",
}
);
Agenda.DotNetProjects.AddRange(
new string[]
{
@"Engine\Source\Programs\DotNETCommon\DotNETUtilities\DotNETUtilities.csproj",
@"Engine\Source\Programs\NoRedist\CrashReportServer\CrashReportCommon\CrashReportCommon.csproj",
@"Engine\Source\Programs\NoRedist\CrashReportServer\CrashReportReceiver\CrashReportReceiver.csproj",
@"Engine\Source\Programs\NoRedist\CrashReportServer\CrashReportProcess\CrashReportProcess.csproj",
@"Engine\Source\Programs\CrashReporter\RegisterPII\RegisterPII.csproj",
@"Engine\Source\Programs\Distill\Distill.csproj",
}
);
Agenda.ExtraDotNetFiles.AddRange(
new string[]
{
"Interop.IWshRuntimeLibrary",
"UnrealMarkdown",
"CommonUnrealMarkdown",
}
);
{
if (LeanAndMean && !ParseParam("NoXGE"))
{
// this is minimal to test XGE
var ProgramTargets = new string[]
{
"UnrealHeaderTool",
};
Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
var Win64Targets = new string[]
{
"FortniteEditor",
"OrionEditor",
};
Agenda.AddTargets(Win64Targets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
var Win32Targets = new string[]
{
"FortniteGame",
"OrionGame",
};
Agenda.AddTargets(Win32Targets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Development);
}
else if (LeanAndMean)
{
var ProgramTargets = new string[]
{
"ShaderCompileWorker",
"UnrealHeaderTool",
"UnrealLightmass",
};
Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
var Win64DevTargets = new string[]
{
"FortniteEditor",
"QAGameEditor",
};
Agenda.AddTargets(Win64DevTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
}
else
{
var ProgramTargets = new string[]
{
"UnrealFileServer",
"ShaderCompileWorker",
"MinidumpDiagnostics",
"SymbolDebugger",
"UnrealFrontend",
"UnrealHeaderTool",
"BlankProgram",
"UnrealLightmass",
"UnrealPak",
};
Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
var Win64DevTargets = new string[]
{
"FortniteEditor",
"OrionEditor",
"PlatformerGameEditor",
"QAGameEditor",
"ShooterGameEditor",
"StrategyGameEditor",
"VehicleGameEditor",
"ShadowEditor",
"SoulEditor",
};
Agenda.AddTargets(Win64DevTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
var Win32Targets = new string[]
{
"FortniteClient",
"OrionServer",
"ShooterGame",
};
Agenda.AddTargets(Win32Targets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Development);
var Win32ShipTargets = new string[]
{
"OrionGame",
"FortniteServer",
};
Agenda.AddTargets(Win32ShipTargets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Shipping);
var PS4DevTargets = new string[]
{
// could also have "QAGame", "UE4Game",
"FortniteGame",
};
Agenda.AddTargets(PS4DevTargets, UnrealTargetPlatform.PS4, UnrealTargetConfiguration.Development);
var XboxOneDevTargets = new string[]
{
// could also have "FortniteGame", "UE4Game",
"QAGame",
};
Agenda.AddTargets(XboxOneDevTargets, UnrealTargetPlatform.XboxOne, UnrealTargetConfiguration.Development);
var IOSDevTargets = new string[]
{
// could also have "QAGame", "UE4Game", PlatformerGame", "StrategyGame",
"Shadow",
"Soul",
};
Agenda.AddTargets(IOSDevTargets, UnrealTargetPlatform.IOS, UnrealTargetConfiguration.Development);
}
}
Agenda.DoRetries = false;
UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
}
public override void DoTest(GUBP bp)
{
var Build = new UE4Build(bp);
var Agenda = new UE4Build.BuildAgenda();
string AddArgs = "-nobuilduht";
Agenda.AddTargets(
new string[] { BranchConfig.Branch.BaseEngineProject.Properties.Targets[TargetRules.TargetType.Editor].TargetName },
HostPlatform, UnrealTargetConfiguration.Development, InAddArgs: AddArgs);
foreach (var ProgramTarget in BranchConfig.Branch.BaseEngineProject.Properties.Programs)
{
if (ProgramTarget.Rules.GUBP_AlwaysBuildWithBaseEditor() && ProgramTarget.Rules.SupportsPlatform(HostPlatform))
{
Agenda.AddTargets(new string[] { ProgramTarget.TargetName }, HostPlatform, UnrealTargetConfiguration.Development, InAddArgs: AddArgs);
}
}
Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: false);
UE4Build.CheckBuildProducts(Build.BuildProductFiles);
SaveRecordOfSuccessAndAddToBuildProducts();
}
public static void Build(BuildCommand Command, ProjectParams Params, int WorkingCL = -1)
{
Params.ValidateAndLog();
if (!Params.Build)
{
return;
}
Log("********** BUILD COMMAND STARTED **********");
var UE4Build = new UE4Build(Command);
var Agenda = new UE4Build.BuildAgenda();
var CrashReportPlatforms = new HashSet<UnrealTargetPlatform>();
// Setup editor targets
if (Params.HasEditorTargets && !Params.Rocket)
{
// @todo Mac: proper platform detection
UnrealTargetPlatform EditorPlatform = HostPlatform.Current.HostEditorPlatform;
const UnrealTargetConfiguration EditorConfiguration = UnrealTargetConfiguration.Development;
CrashReportPlatforms.Add(EditorPlatform);
Agenda.AddTargets(Params.EditorTargets.ToArray(), EditorPlatform, EditorConfiguration, Params.CodeBasedUprojectPath);
if (Params.EditorTargets.Contains("UnrealHeaderTool") == false)
{
Agenda.AddTargets(new string[] { "UnrealHeaderTool" }, EditorPlatform, EditorConfiguration);
}
if (Params.EditorTargets.Contains("ShaderCompileWorker") == false)
{
Agenda.AddTargets(new string[] { "ShaderCompileWorker" }, EditorPlatform, EditorConfiguration);
}
if (Params.Pak && Params.EditorTargets.Contains("UnrealPak") == false)
{
Agenda.AddTargets(new string[] { "UnrealPak" }, EditorPlatform, EditorConfiguration);
}
if (Params.FileServer && Params.EditorTargets.Contains("UnrealFileServer") == false)
{
Agenda.AddTargets(new string[] { "UnrealFileServer" }, EditorPlatform, EditorConfiguration);
}
}
// Setup cooked targets
if (Params.HasClientCookedTargets)
{
foreach (var BuildConfig in Params.ClientConfigsToBuild)
{
foreach (var ClientPlatform in Params.ClientTargetPlatforms)
{
CrashReportPlatforms.Add(ClientPlatform);
Agenda.AddTargets(Params.ClientCookedTargets.ToArray(), ClientPlatform, BuildConfig, Params.CodeBasedUprojectPath, InAddArgs: " -remoteini=\""+Path.GetDirectoryName(Params.RawProjectPath)+"\"");
}
}
}
if (Params.HasServerCookedTargets)
{
foreach (var BuildConfig in Params.ServerConfigsToBuild)
{
foreach (var ServerPlatform in Params.ServerTargetPlatforms)
{
CrashReportPlatforms.Add(ServerPlatform);
Agenda.AddTargets(Params.ServerCookedTargets.ToArray(), ServerPlatform, BuildConfig, Params.CodeBasedUprojectPath, InAddArgs: " -remoteini=\""+Path.GetDirectoryName(Params.RawProjectPath)+"\"");
}
}
}
if (Params.CrashReporter && !Params.Rocket)
{
var CrashReportClientTarget = new[] { "CrashReportClient" };
foreach (var CrashReportPlatform in CrashReportPlatforms)
{
if (UnrealBuildTool.UnrealBuildTool.PlatformSupportsCrashReporter(CrashReportPlatform))
{
Agenda.AddTargets(CrashReportClientTarget, CrashReportPlatform, UnrealTargetConfiguration.Development);
}
}
}
if (Params.HasProgramTargets && !Params.Rocket)
{
foreach (var BuildConfig in Params.ClientConfigsToBuild)
{
foreach (var ClientPlatform in Params.ClientTargetPlatforms)
{
Agenda.AddTargets(Params.ProgramTargets.ToArray(), ClientPlatform, BuildConfig, Params.CodeBasedUprojectPath);
}
}
}
UE4Build.Build(Agenda, InDeleteBuildProducts: Params.Clean, InUpdateVersionFiles: WorkingCL > 0);
if (WorkingCL > 0) // only move UAT files if we intend to check in some build products
{
UE4Build.AddUATFilesToBuildProducts();
}
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
if (WorkingCL > 0)
{
// Sign everything we built
CodeSign.SignMultipleIfEXEOrDLL(Command, UE4Build.BuildProductFiles);
// Open files for add or edit
UE4Build.AddBuildProductsToChangelist(WorkingCL, UE4Build.BuildProductFiles);
}
Log("********** BUILD COMMAND COMPLETED **********");
}
void ExecuteInner()
{
var UE4Build = new UE4Build(this);
bool IsRunningOnMono = (Type.GetType("Mono.Runtime") != null);
var Agenda = new UE4Build.BuildAgenda();
var Config = ParseParamValue("Config");
if (String.IsNullOrEmpty(Config))
{
Config = "tools";
}
if (Config.ToLower() == "tools")
{
Agenda.DotNetSolutions.AddRange(
new string[]
{
@"Engine\Source\Programs\UnrealDocTool\UnrealDocTool\UnrealDocTool.sln",
@"Engine\Source\Programs\NetworkProfiler\NetworkProfiler.sln",
}
);
Agenda.SwarmProject = @"Engine\Source\Programs\UnrealSwarm\UnrealSwarm.sln";
Agenda.DotNetProjects.AddRange(
new string[]
{
@"Engine\Source\Programs\DotNETCommon\DotNETUtilities\DotNETUtilities.csproj",
@"Engine\Source\Programs\NoRedist\CrashReportServer\CrashReportCommon\CrashReportCommon.csproj",
@"Engine\Source\Programs\NoRedist\CrashReportServer\CrashReportReceiver\CrashReportReceiver.csproj",
@"Engine\Source\Programs\NoRedist\CrashReportServer\CrashReportProcess\CrashReportProcess.csproj",
@"Engine\Source\Programs\CrashReporter\RegisterPII\RegisterPII.csproj",
@"Engine\Source\Programs\Distill\Distill.csproj",
@"Engine\Source\Programs\RPCUtility\RPCUtility.csproj",
@"Engine\Source\Programs\UnrealControls\UnrealControls.csproj",
}
);
Agenda.IOSDotNetProjects.AddRange(
new string[]
{
@"Engine\Source\Programs\IOS\iPhonePackager\iPhonePackager.csproj",
@"Engine\Source\Programs\IOS\MobileDeviceInterface\MobileDeviceInterface.csproj",
@"Engine\Source\Programs\IOS\DeploymentInterface\DeploymentInterface.csproj",
}
);
Agenda.ExtraDotNetFiles.AddRange(
new string[]
{
"Interop.IWshRuntimeLibrary",
"UnrealMarkdown",
"CommonUnrealMarkdown",
}
);
}
//This needs to be a separate target for distributed building because it is required to build anything else.
if (!IsRunningOnMono)
{
var UHTTarget = new string[]
{
"UnrealHeaderTool",
};
Agenda.AddTargets(UHTTarget, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
}
var ProgramTargets = new string[]
{
"UnrealFileServer",
"ShaderCompileWorker",
"MinidumpDiagnostics",
"SymbolDebugger",
"UnrealFrontend",
"UnrealLightmass",
"UnrealPak",
};
var Win64DevTargets = new List<string>
{
"FortniteEditor",
"OrionEditor",
"PlatformerGameEditor",
"QAGameEditor",
"ShooterGameEditor",
"StrategyGameEditor",
"VehicleGameEditor",
"ShadowEditor",
"SoulEditor",
};
var Win32Targets = new List<string>
{
"FortniteGame",
"FortniteServer",
"FortniteClient",
"OrionGame",
"PlatformerGame",
"ShooterGame",
"StrategyGame",
"VehicleGame",
"Shadow",
"Soul",
};
var MacDebugTargets = new List<string>
{
"FortniteGame",
"FortniteEditor",
"ShooterGameEditor",
"ShooterGame",
};
var PS4DevTargets = new List<string>
{
"FortniteGame",
};
var XboxOneDevTargets = new List<string>
{
"QAGame",
};
var IOSDevTargets = new List<string>
{
"QAGame",
"Shadow",
//"PlatformerGame",
//"StrategyGame",
"Soul",
};
var LinuxTargets = new List<string>
{
"FortniteServer",
};
var WinRTDevTargets = new List<string>
{
"QAGame",
};
var HTML5DevTargets = new List<string>
{
"QAGame",
};
var AndroidDevTargets = new List<string>
{
"UE4Game",
"Soul",
};
//Check to see if we should Exclude any projects. We would want to do this for branches that do not have all of the projects
var Excludes = ParseParamValue("Exclude");
if (!String.IsNullOrEmpty(Excludes))
{
List<List<string>> TargetLists = new List<List<string>>
{
Win32Targets,
Win64DevTargets,
PS4DevTargets,
XboxOneDevTargets,
IOSDevTargets,
LinuxTargets,
HTML5DevTargets,
WinRTDevTargets,
MacDebugTargets,
AndroidDevTargets
};
List<string> Samples = new List<string>
{
"PlatformerGame",
"ShooterGame",
"StrategyGame",
"VehicleGame",
"PlatformerGameEditor",
"ShooterGameEditor",
"StrategyGameEditor",
"VehicleGameEditor",
};
List<string> Orion = new List<string>
{
"OrionGame",
"OrionEditor",
};
List<string> Fortnite = new List<string>
{
"FortniteServer",
"FortniteGame",
"FortniteClient",
"FortniteEditor",
};
List<string> Shadow = new List<string>
{
"Shadow",
"ShadowEditor",
};
List<string> Soul = new List<string>
{
"Soul",
"SoulEditor",
};
List<string> Exclude = new List<string>(Excludes.Split('+'));
foreach (List<string> List in TargetLists)
{
if (Exclude.Contains("Samples"))
{
RemoveTargetsFromList(Samples, List);
}
if (Exclude.Contains("Orion"))
{
RemoveTargetsFromList(Orion, List);
}
if (Exclude.Contains("Fortnite"))
{
RemoveTargetsFromList(Fortnite, List);
}
if (Exclude.Contains("Shadow"))
{
RemoveTargetsFromList(Shadow, List);
}
if (Exclude.Contains("Soul"))
{
RemoveTargetsFromList(Soul, List);
}
}
}
// @todo: make this programmatic by looping over the TargetLists (which maybe should be a map from config to list)
string[] Win64Dev = Win64DevTargets.ToArray();
string[] Win32Dev = Win32Targets.ToArray();
string[] PS4Dev = PS4DevTargets.ToArray();
string[] XboxOneDev = XboxOneDevTargets.ToArray();
string[] IOSDev = IOSDevTargets.ToArray();
string[] LinuxDev = LinuxTargets.ToArray();
string[] WinRTDev = WinRTDevTargets.ToArray();
string[] MacDebug = MacDebugTargets.ToArray();
string[] HTML5Dev = HTML5DevTargets.ToArray();
string[] AndroidDev = AndroidDevTargets.ToArray();
switch (Config.ToUpperInvariant())
{
case "TOOLS":
Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
break;
case "EDITORS":
Agenda.AddTargets(Win64Dev, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
break;
case "WIN32DEV":
Agenda.AddTargets(Win32Dev, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Development);
break;
case "PS4DEV":
Agenda.AddTargets(PS4Dev, UnrealTargetPlatform.PS4, UnrealTargetConfiguration.Development);
break;
case "XBOXONEDEV":
Agenda.AddTargets(XboxOneDev, UnrealTargetPlatform.XboxOne, UnrealTargetConfiguration.Development);
break;
case "IOSDEV":
Agenda.AddTargets(IOSDev, UnrealTargetPlatform.IOS, UnrealTargetConfiguration.Development);
break;
case "LINUX":
Agenda.AddTargets(LinuxDev, UnrealTargetPlatform.Linux, UnrealTargetConfiguration.Development);
break;
case "WINRT":
Agenda.AddTargets(WinRTDev, UnrealTargetPlatform.WinRT, UnrealTargetConfiguration.Development);
break;
case "MAC":
Agenda.AddTargets(MacDebug, UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Debug);
break;
case "HTML5":
Agenda.AddTargets(HTML5Dev, UnrealTargetPlatform.HTML5, UnrealTargetConfiguration.Development);
break;
case "ANDROID":
Agenda.AddTargets(AndroidDev, UnrealTargetPlatform.Android, UnrealTargetConfiguration.Development);
break;
}
UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
}
public override void DoTest(GUBP bp)
{
var Build = new UE4Build(bp);
var Agenda = new UE4Build.BuildAgenda();
Agenda.AddTargets(new string[] { "UnrealHeaderTool" }, HostPlatform, UnrealTargetConfiguration.Development);
Agenda.AddTargets(
new string[] { BranchConfig.Branch.BaseEngineProject.Properties.Targets[TargetRules.TargetType.Editor].TargetName },
HostPlatform, UnrealTargetConfiguration.Development, InAddArgs: "-skipnonhostplatforms -shadowvariableerrors");
foreach (var Kind in BranchInfo.MonolithicKinds)
{
if (BranchConfig.Branch.BaseEngineProject.Properties.Targets.ContainsKey(Kind))
{
var Target = BranchConfig.Branch.BaseEngineProject.Properties.Targets[Kind];
Agenda.AddTargets(new string[] { Target.TargetName }, HostPlatform, UnrealTargetConfiguration.Development, InAddArgs: "-shadowvariableerrors");
}
}
Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: false, InForceNonUnity: true, InForceNoXGE: true);
UE4Build.CheckBuildProducts(Build.BuildProductFiles);
SaveRecordOfSuccessAndAddToBuildProducts();
}
public override void ExecuteBuild()
{
// Parse the target list
string[] Targets = ParseParamValues("Target");
if(Targets.Length == 0)
{
throw new AutomationException("No targets specified (eg. -Target=\"UE4Editor Win64 Development\")");
}
// Parse the archive path
string ArchivePath = ParseParamValue("Archive");
if(ArchivePath != null && (!ArchivePath.StartsWith("//") || ArchivePath.Sum(x => (x == '/')? 1 : 0) < 4))
{
throw new AutomationException("Archive path is not a valid depot filename");
}
// Prepare the build agenda
UE4Build.BuildAgenda Agenda = new UE4Build.BuildAgenda();
foreach(string Target in Targets)
{
string[] Tokens = Target.Split(new char[]{ ' ' }, StringSplitOptions.RemoveEmptyEntries);
UnrealTargetPlatform Platform;
UnrealTargetConfiguration Configuration;
if(Tokens.Length < 3 || !Enum.TryParse(Tokens[1], true, out Platform) || !Enum.TryParse(Tokens[2], true, out Configuration))
{
throw new AutomationException("Invalid target '{0}' - expected <TargetName> <Platform> <Configuration>");
}
Agenda.AddTarget(Tokens[0], Platform, Configuration, InAddArgs: String.Join(" ", Tokens.Skip(3)));
}
// Build everything
UE4Build Builder = new UE4Build(this);
Builder.Build(Agenda, InUpdateVersionFiles: ArchivePath != null);
// Include the build products for UAT and UBT if required
if(ParseParam("WithUAT"))
{
Builder.AddUATFilesToBuildProducts();
}
if(ParseParam("WithUBT"))
{
Builder.AddUBTFilesToBuildProducts();
}
// Archive the build products
if(ArchivePath != null)
{
// Create an output folder
string OutputFolder = Path.Combine(CommandUtils.CmdEnv.LocalRoot, "ArchiveForUGS");
Directory.CreateDirectory(OutputFolder);
// Create a temp folder for storing stripped PDB files
string SymbolsFolder = Path.Combine(OutputFolder, "Symbols");
Directory.CreateDirectory(SymbolsFolder);
// Get the Windows toolchain
UEToolChain WindowsToolChain = UEBuildPlatform.GetBuildPlatform(UnrealTargetPlatform.Win64).CreateContext(null).CreateToolChain(CPPTargetPlatform.Win64);
// Figure out all the files for the archive
Ionic.Zip.ZipFile Zip = new Ionic.Zip.ZipFile();
Zip.UseZip64WhenSaving = Ionic.Zip.Zip64Option.Always;
foreach(string BuildProduct in Builder.BuildProductFiles)
{
if(!File.Exists(BuildProduct))
{
throw new AutomationException("Missing build product: {0}", BuildProduct);
}
if(BuildProduct.EndsWith(".pdb", StringComparison.InvariantCultureIgnoreCase))
{
string StrippedFileName = CommandUtils.MakeRerootedFilePath(BuildProduct, CommandUtils.CmdEnv.LocalRoot, SymbolsFolder);
Directory.CreateDirectory(Path.GetDirectoryName(StrippedFileName));
WindowsToolChain.StripSymbols(BuildProduct, StrippedFileName);
Zip.AddFile(StrippedFileName, Path.GetDirectoryName(CommandUtils.StripBaseDirectory(StrippedFileName, SymbolsFolder)));
}
else
{
Zip.AddFile(BuildProduct, Path.GetDirectoryName(CommandUtils.StripBaseDirectory(BuildProduct, CommandUtils.CmdEnv.LocalRoot)));
}
}
// Create the zip file
string ZipFileName = Path.Combine(OutputFolder, "Archive.zip");
Console.WriteLine("Writing {0}...", ZipFileName);
Zip.Save(ZipFileName);
// Submit it to Perforce if required
if(CommandUtils.AllowSubmit)
{
// Delete any existing clientspec for submitting
string ClientName = Environment.MachineName + "_BuildForUGS";
// Create a brand new one
P4ClientInfo Client = new P4ClientInfo();
Client.Owner = CommandUtils.P4Env.User;
Client.Host = Environment.MachineName;
Client.Stream = ArchivePath.Substring(0, ArchivePath.IndexOf('/', ArchivePath.IndexOf('/', 2) + 1));
Client.RootPath = Path.Combine(OutputFolder, "Perforce");
Client.Name = ClientName;
Client.Options = P4ClientOption.NoAllWrite | P4ClientOption.NoClobber | P4ClientOption.NoCompress | P4ClientOption.Unlocked | P4ClientOption.NoModTime | P4ClientOption.RmDir;
Client.LineEnd = P4LineEnd.Local;
P4.CreateClient(Client, AllowSpew: false);
// Create a new P4 connection for this workspace
P4Connection SubmitP4 = new P4Connection(Client.Owner, Client.Name, P4Env.P4Port);
SubmitP4.Revert("-k //...");
// Figure out where the zip file has to go in Perforce
P4WhereRecord WhereZipFile = SubmitP4.Where(ArchivePath, false).FirstOrDefault(x => !x.bUnmap && x.Path != null);
if(WhereZipFile == null)
{
throw new AutomationException("Couldn't locate {0} in this workspace");
}
// Get the latest version of it
int NewCL = SubmitP4.CreateChange(Description: String.Format("[CL {0}] Updated binaries", P4Env.Changelist));
SubmitP4.Sync(String.Format("-k \"{0}\"", ArchivePath), AllowSpew:false);
CommandUtils.CopyFile(ZipFileName, WhereZipFile.Path);
SubmitP4.Add(NewCL, String.Format("\"{0}\"", ArchivePath));
SubmitP4.Edit(NewCL, String.Format("\"{0}\"", ArchivePath));
// Submit it
int SubmittedCL;
SubmitP4.Submit(NewCL, out SubmittedCL);
if(SubmittedCL <= 0)
{
throw new AutomationException("Submit failed.");
}
Console.WriteLine("Submitted in changelist {0}", SubmittedCL);
}
}
}
public override void ExecuteBuild()
{
int WorkingCL = -1;
if (P4Enabled && AllowSubmit)
{
string CmdLine = "";
foreach (var Arg in Params)
{
CmdLine += Arg.ToString() + " ";
}
WorkingCL = P4.CreateChange(P4Env.Client, String.Format("MegaXGE build from changelist {0} - Params: {1}", P4Env.Changelist, CmdLine));
}
LogConsole("************************* MegaXGE");
bool Clean = ParseParam("Clean");
string CleanToolLocation = CombinePaths(CmdEnv.LocalRoot, "Engine", "Build", "Batchfiles", "Clean.bat");
bool ShowProgress = ParseParam("Progress");
var UE4Build = new UE4Build(this);
var Agenda = new UE4Build.BuildAgenda();
// we need to always build UHT when we use mega XGE
var ProgramTargets = new string[]
{
"UnrealHeaderTool",
};
Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
if (Clean)
{
LogSetProgress(ShowProgress, "Cleaning previous builds...");
foreach (var CurTarget in ProgramTargets)
{
string Args = String.Format("{0} {1} {2}", CurTarget, UnrealTargetPlatform.Win64.ToString(), UnrealTargetConfiguration.Development.ToString());
RunAndLog(CmdEnv, CleanToolLocation, Args);
}
}
LogConsole("*************************");
for (int Arg = 1; Arg < 100; Arg++)
{
string Parm = String.Format("Target{0}", Arg);
string Target = ParseParamValue(Parm, "");
if (String.IsNullOrEmpty(Target))
{
break;
}
var Parts = Target.Split(' ');
string JustTarget = Parts[0];
if (String.IsNullOrEmpty(JustTarget))
{
throw new AutomationException("BUILD FAILED target option '{0}' not parsed.", Target);
}
var Targets = JustTarget.Split('|');
if (Targets.Length < 1)
{
throw new AutomationException("BUILD FAILED target option '{0}' not parsed.", Target);
}
var Platforms = new List<UnrealTargetPlatform>();
var Configurations = new List<UnrealTargetConfiguration>();
for (int Part = 1; Part < Parts.Length; Part++)
{
if (!String.IsNullOrEmpty(Parts[Part]))
{
var SubParts = Parts[Part].Split('|');
foreach (var SubPart in SubParts)
{
if (UEBuildPlatform.ConvertStringToPlatform(SubPart) != UnrealTargetPlatform.Unknown)
{
Platforms.Add(UEBuildPlatform.ConvertStringToPlatform(SubPart));
}
else
{
switch (SubPart.ToUpperInvariant())
{
case "DEBUG":
Configurations.Add(UnrealTargetConfiguration.Debug);
break;
case "DEBUGGAME":
Configurations.Add(UnrealTargetConfiguration.DebugGame);
break;
case "DEVELOPMENT":
Configurations.Add(UnrealTargetConfiguration.Development);
break;
case "SHIPPING":
Configurations.Add(UnrealTargetConfiguration.Shipping);
break;
case "TEST":
Configurations.Add(UnrealTargetConfiguration.Test);
break;
default:
throw new AutomationException("BUILD FAILED target option {0} not recognized.", SubPart);
}
}
}
}
}
if (Platforms.Count < 1)
{
Platforms.Add(UnrealTargetPlatform.Win64);
}
if (Configurations.Count < 1)
{
Configurations.Add(UnrealTargetConfiguration.Development);
}
foreach (var Platform in Platforms)
{
foreach (var CurTarget in Targets)
{
foreach (var Configuration in Configurations)
{
Agenda.AddTargets(new string[] { CurTarget }, Platform, Configuration);
LogConsole("Target {0} {1} {2}", CurTarget, Platform.ToString(), Configuration.ToString());
if (Clean)
{
string Args = String.Format("{0} {1} {2}", CurTarget, Platform.ToString(), Configuration.ToString());
RunAndLog(CmdEnv, CleanToolLocation, Args);
}
}
}
}
}
LogConsole("*************************");
Agenda.DoRetries = ParseParam("Retry");
UE4Build.Build(Agenda, InUpdateVersionFiles: IsBuildMachine, InUseParallelExecutor: ParseParam("useparallelexecutor"), InShowProgress: ShowProgress);
// if (WorkingCL > 0) // only move UAT files if we intend to check in some build products
// {
// UE4Build.CopyUATFilesAndAddToBuildProducts();
// }
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
if (WorkingCL > 0)
{
// Sign everything we built
CodeSign.SignMultipleIfEXEOrDLL(this, UE4Build.BuildProductFiles);
// Open files for add or edit
UE4Build.AddBuildProductsToChangelist(WorkingCL, UE4Build.BuildProductFiles);
int SubmittedCL;
P4.Submit(WorkingCL, out SubmittedCL, true, true);
}
PrintRunTime();
}
public override void DoBuild(GUBP bp)
{
BuildProducts = new List<string>();
var UE4Build = new UE4Build(bp);
UE4Build.BuildAgenda Agenda = GetAgenda(bp);
if (Agenda != null)
{
bool ReallyDeleteBuildProducts = DeleteBuildProducts() && !GUBP.bForceIncrementalCompile;
Agenda.DoRetries = false; // these would delete build products
bool UseParallelExecutor = bDependentOnCompileTools && (HostPlatform == UnrealTargetPlatform.Win64);
UE4Build.Build(Agenda, InDeleteBuildProducts: ReallyDeleteBuildProducts, InUpdateVersionFiles: false, InForceNoXGE: true, InForceUnity: true, InUseParallelExecutor: UseParallelExecutor);
var StartPostBuild = DateTime.Now.ToString();
PostBuild(bp, UE4Build);
var FinishPostBuild = DateTime.Now.ToString();
PrintCSVFile(String.Format("UAT,PostBuild,{0},{1}", StartPostBuild, FinishPostBuild));
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
foreach (var Product in UE4Build.BuildProductFiles)
{
AddBuildProduct(Product);
}
RemoveOveralppingBuildProducts();
if (bp.bSignBuildProducts)
{
// Sign everything we built
var StartSign = DateTime.Now.ToString();
CodeSign.SignMultipleIfEXEOrDLL(bp, BuildProducts);
var FinishSign = DateTime.Now.ToString();
PrintCSVFile(String.Format("UAT,SignBuildProducts,{0},{1}", StartSign, FinishSign));
}
PostBuildProducts(bp);
}
if (Agenda == null || (BuildProducts.Count == 0 && GUBP.bForceIncrementalCompile))
{
SaveRecordOfSuccessAndAddToBuildProducts("Nothing to actually compile");
}
}
void ExecuteInner(int WorkingCL)
{
var UE4Build = new UE4Build(this);
var Agenda = new UE4Build.BuildAgenda();
Agenda.DotNetSolutions.AddRange(
new string[]
{
//@"Engine\Source\Programs\UnrealDocTool\UnrealDocTool\UnrealDocTool.sln",
//@"Engine\Source\Programs\NetworkProfiler\NetworkProfiler.sln",
}
);
Agenda.DotNetProjects.AddRange(
new string[]
{
//@"Engine\Source\Programs\DotNETCommon\DotNETUtilities\DotNETUtilities.csproj",
//@"Engine\Source\Programs\CrashReporter\CrashReportCommon\CrashReportCommon.csproj",
//@"Engine\Source\Programs\CrashReporter\CrashReportInput\CrashReportInput.csproj",
//@"Engine\Source\Programs\CrashReporter\CrashReportUploader\CrashReportUploader.csproj",
//@"Engine\Source\Programs\CrashReporter\CrashReportReceiver\CrashReportReceiver.csproj",
//@"Engine\Source\Programs\CrashReporter\CrashReportProcess\CrashReportProcess.csproj",
//@"Engine\Source\Programs\CrashReporter\RegisterPII\RegisterPII.csproj",
//@"Engine\Source\Programs\Distill\Distill.csproj",
//@"Engine\Source\Programs\UnSetup\UnSetup.csproj",
}
);
Agenda.ExtraDotNetFiles.AddRange(
new string[]
{
//"Interop.IWshRuntimeLibrary",
//"UnrealMarkdown",
//"CommonUnrealMarkdown",
}
);
{
if (LeanAndMean)
{
var ProgramTargets = new string[]
{
"CrashReportClient",
"ShaderCompileWorker",
"UnrealHeaderTool",
"UnrealLightmass",
};
Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Development);
var MacDevTargets = new string[]
{
"QAGameEditor",
};
Agenda.AddTargets(MacDevTargets, UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Development);
}
else
{
var ProgramTargets = new string[]
{
"BuildPatchTool",
"CrashReportClient",
"UnrealFileServer",
"ShaderCompileWorker",
//"MinidumpDiagnostics",
//"SymbolDebugger",
"UnrealFrontend",
"UnrealHeaderTool",
"UnrealLightmass",
"UnrealPak",
//"UnrealRemoteAgent",
};
Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Development);
var MacDevTargets = new string[]
{
// "FortniteEditor",
// "OrionEditor",
"PlatformerGameEditor",
"QAGameEditor",
"ShooterGameEditor",
"StrategyGameEditor",
// "VehicleGameEditor",
// "FortniteGame",
// "FortniteServer",
// "OrionGame",
"PlatformerGame",
"QAGame",
"ShooterGame",
"StrategyGame",
// "VehicleGame",
};
Agenda.AddTargets(MacDevTargets, UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Development);
}
}
UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
if (P4Enabled)
{
// Sign everything we built
CodeSign.SignMultipleIfEXEOrDLL(this, UE4Build.BuildProductFiles);
// Open files for add or edit
UE4Build.AddBuildProductsToChangelist(WorkingCL, UE4Build.BuildProductFiles);
// Check everything in!
int SubmittedCL;
Submit(WorkingCL, out SubmittedCL, true, true);
// Label it
MakeDownstreamLabel("PromotableMacOnly");
}
}
public static void Build(BuildCommand Command, ProjectParams Params, int WorkingCL = -1, ProjectBuildTargets TargetMask = ProjectBuildTargets.All)
{
Params.ValidateAndLog();
if (!Params.Build)
{
return;
}
Log("********** BUILD COMMAND STARTED **********");
var UE4Build = new UE4Build(Command);
var Agenda = new UE4Build.BuildAgenda();
var CrashReportPlatforms = new HashSet<UnrealTargetPlatform>();
// Setup editor targets
if (Params.HasEditorTargets && !Automation.IsEngineInstalled() && (TargetMask & ProjectBuildTargets.Editor) == ProjectBuildTargets.Editor)
{
// @todo Mac: proper platform detection
UnrealTargetPlatform EditorPlatform = HostPlatform.Current.HostEditorPlatform;
const UnrealTargetConfiguration EditorConfiguration = UnrealTargetConfiguration.Development;
CrashReportPlatforms.Add(EditorPlatform);
Agenda.AddTargets(Params.EditorTargets.ToArray(), EditorPlatform, EditorConfiguration, Params.CodeBasedUprojectPath);
if (Params.EditorTargets.Contains("UnrealHeaderTool") == false)
{
Agenda.AddTargets(new string[] { "UnrealHeaderTool" }, EditorPlatform, EditorConfiguration);
}
if (Params.EditorTargets.Contains("ShaderCompileWorker") == false)
{
Agenda.AddTargets(new string[] { "ShaderCompileWorker" }, EditorPlatform, EditorConfiguration);
}
if (Params.Pak && Params.EditorTargets.Contains("UnrealPak") == false)
{
Agenda.AddTargets(new string[] { "UnrealPak" }, EditorPlatform, EditorConfiguration);
}
if (Params.FileServer && Params.EditorTargets.Contains("UnrealFileServer") == false)
{
Agenda.AddTargets(new string[] { "UnrealFileServer" }, EditorPlatform, EditorConfiguration);
}
}
// Setup cooked targets
if (Params.HasClientCookedTargets && (TargetMask & ProjectBuildTargets.ClientCooked) == ProjectBuildTargets.ClientCooked)
{
List<UnrealTargetPlatform> UniquePlatformTypes = Params.ClientTargetPlatforms.ConvertAll(x => x.Type).Distinct().ToList();
foreach (var BuildConfig in Params.ClientConfigsToBuild)
{
foreach (var ClientPlatformType in UniquePlatformTypes)
{
string ScriptPluginArgs = GetBlueprintPluginPathArgument(Params, true, ClientPlatformType);
CrashReportPlatforms.Add(ClientPlatformType);
Agenda.AddTargets(Params.ClientCookedTargets.ToArray(), ClientPlatformType, BuildConfig, Params.CodeBasedUprojectPath, InAddArgs: ScriptPluginArgs + " -remoteini=\"" + Params.RawProjectPath.Directory.FullName + "\"");
}
}
}
if (Params.HasServerCookedTargets && (TargetMask & ProjectBuildTargets.ServerCooked) == ProjectBuildTargets.ServerCooked)
{
List<UnrealTargetPlatform> UniquePlatformTypes = Params.ServerTargetPlatforms.ConvertAll(x => x.Type).Distinct().ToList();
foreach (var BuildConfig in Params.ServerConfigsToBuild)
{
foreach (var ServerPlatformType in UniquePlatformTypes)
{
string ScriptPluginArgs = GetBlueprintPluginPathArgument(Params, false, ServerPlatformType);
CrashReportPlatforms.Add(ServerPlatformType);
Agenda.AddTargets(Params.ServerCookedTargets.ToArray(), ServerPlatformType, BuildConfig, Params.CodeBasedUprojectPath, InAddArgs: ScriptPluginArgs + " -remoteini=\"" + Params.RawProjectPath.Directory.FullName + "\"");
}
}
}
if (!Params.NoBootstrapExe && !Automation.IsEngineInstalled() && (TargetMask & ProjectBuildTargets.Bootstrap) == ProjectBuildTargets.Bootstrap)
{
UnrealBuildTool.UnrealTargetPlatform[] BootstrapPackagedGamePlatforms = { UnrealBuildTool.UnrealTargetPlatform.Win32, UnrealBuildTool.UnrealTargetPlatform.Win64 };
foreach(UnrealBuildTool.UnrealTargetPlatform BootstrapPackagedGamePlatformType in BootstrapPackagedGamePlatforms)
{
if(Params.ClientTargetPlatforms.Contains(new TargetPlatformDescriptor(BootstrapPackagedGamePlatformType)))
{
Agenda.AddTarget("BootstrapPackagedGame", BootstrapPackagedGamePlatformType, UnrealBuildTool.UnrealTargetConfiguration.Shipping);
}
}
}
if (Params.CrashReporter && !Automation.IsEngineInstalled() && (TargetMask & ProjectBuildTargets.CrashReporter) == ProjectBuildTargets.CrashReporter)
{
foreach (var CrashReportPlatform in CrashReportPlatforms)
{
if (UnrealBuildTool.UnrealBuildTool.PlatformSupportsCrashReporter(CrashReportPlatform))
{
Agenda.AddTarget("CrashReportClient", CrashReportPlatform, UnrealTargetConfiguration.Shipping);
}
}
}
if (Params.HasProgramTargets && (TargetMask & ProjectBuildTargets.Programs) == ProjectBuildTargets.Programs)
{
List<UnrealTargetPlatform> UniquePlatformTypes = Params.ClientTargetPlatforms.ConvertAll(x => x.Type).Distinct().ToList();
foreach (var BuildConfig in Params.ClientConfigsToBuild)
{
foreach (var ClientPlatformType in UniquePlatformTypes)
{
Agenda.AddTargets(Params.ProgramTargets.ToArray(), ClientPlatformType, BuildConfig, Params.CodeBasedUprojectPath);
}
}
}
UE4Build.Build(Agenda, InDeleteBuildProducts: Params.Clean, InUpdateVersionFiles: WorkingCL > 0);
if (WorkingCL > 0) // only move UAT files if we intend to check in some build products
{
UE4Build.AddUATFilesToBuildProducts();
}
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
if (WorkingCL > 0)
{
// Sign everything we built
CodeSign.SignMultipleIfEXEOrDLL(Command, UE4Build.BuildProductFiles);
// Open files for add or edit
UE4Build.AddBuildProductsToChangelist(WorkingCL, UE4Build.BuildProductFiles);
}
Log("********** BUILD COMMAND COMPLETED **********");
}
public override void DoTest(GUBP bp)
{
var Build = new UE4Build(bp);
var Agenda = new UE4Build.BuildAgenda();
Agenda.AddTargets(new string[] { "UnrealHeaderTool" }, HostPlatform, UnrealTargetConfiguration.Development);
Agenda.AddTargets(new string[] { ProgramTarget.TargetName }, HostPlatform, UnrealTargetConfiguration.Development, InAddArgs: "-skipnonhostplatforms");
Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: false, InForceNonUnity: true, InForceNoXGE: true);
UE4Build.CheckBuildProducts(Build.BuildProductFiles);
SaveRecordOfSuccessAndAddToBuildProducts();
}
public override void ExecuteBuild()
{
if (ParseParam("BuildEditor"))
{
UE4Build.BuildAgenda Agenda = new UE4Build.BuildAgenda();
Agenda.AddTarget("UE4Editor", HostPlatform.Current.HostEditorPlatform, UnrealTargetConfiguration.Development);
Agenda.AddTarget("ShaderCompileWorker", HostPlatform.Current.HostEditorPlatform, UnrealTargetConfiguration.Development);
UE4Build Builder = new UE4Build(this);
Builder.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true, InForceNoXGE: true);
}
var EditorExe = CombinePaths(CmdEnv.LocalRoot, @"Engine/Binaries/Win64/UE4Editor-Cmd.exe");
if (P4Enabled)
{
Log("Sync necessary content to head revision");
P4.Sync(P4Env.BuildRootP4 + "/Engine/Config/...");
P4.Sync(P4Env.BuildRootP4 + "/Engine/Content/...");
P4.Sync(P4Env.BuildRootP4 + "/Engine/Source/...");
P4.Sync(P4Env.BuildRootP4 + "/Portal/Config/...");
P4.Sync(P4Env.BuildRootP4 + "/Portal/Content/...");
P4.Sync(P4Env.BuildRootP4 + "/Portal/Source/...");
Log("Localize from label {0}", P4Env.LabelToSync);
}
OneSkyConfigData OneSkyConfig = OneSkyConfigHelper.Find("OneSkyConfig_EpicGames");
var oneSkyService = new OneSkyService(OneSkyConfig.ApiKey, OneSkyConfig.ApiSecret);
// Export Launcher text from OneSky
{
var launcherGroup = GetLauncherGroup(oneSkyService);
var appProject = GetAppProject(oneSkyService);
var appFile = appProject.UploadedFiles.FirstOrDefault(f => f.Filename == "App.po");
//Export
if (appFile != null)
{
ExportFileToDirectory(appFile, new DirectoryInfo(CmdEnv.LocalRoot + "/Portal/Content/Localization/App"), launcherGroup.EnabledCultures);
}
}
// Setup editor arguments for SCC.
string EditorArguments = String.Empty;
if (P4Enabled)
{
EditorArguments = String.Format("-SCCProvider={0} -P4Port={1} -P4User={2} -P4Client={3} -P4Passwd={4}", "Perforce", P4Env.P4Port, P4Env.User, P4Env.Client, P4.GetAuthenticationToken());
}
else
{
EditorArguments = String.Format("-SCCProvider={0}", "None");
}
// Setup commandlet arguments for SCC.
string CommandletSCCArguments = String.Empty;
if (P4Enabled) { CommandletSCCArguments += (string.IsNullOrEmpty(CommandletSCCArguments) ? "" : " ") + "-EnableSCC"; }
if (!AllowSubmit) { CommandletSCCArguments += (string.IsNullOrEmpty(CommandletSCCArguments) ? "" : " ") + "-DisableSCCSubmit"; }
// Setup commandlet arguments with configurations.
var CommandletArgumentSets = new string[]
{
String.Format("-config={0}", @"../Portal/Config/Localization/App.ini") + (string.IsNullOrEmpty(CommandletSCCArguments) ? "" : " " + CommandletSCCArguments)
};
// Execute commandlet for each set of arguments.
foreach (var CommandletArguments in CommandletArgumentSets)
{
Log("Localization for {0} {1}", EditorArguments, CommandletArguments);
Log("Running UE4Editor to generate Localization data");
string Arguments = String.Format("-run=GatherText {0} {1}", EditorArguments, CommandletArguments);
var RunResult = Run(EditorExe, Arguments);
if (RunResult.ExitCode != 0)
{
throw new AutomationException("Error while executing localization commandlet '{0}'", Arguments);
}
}
// Upload Launcher text to OneSky
UploadDirectoryToProject(GetAppProject(oneSkyService), new DirectoryInfo(CmdEnv.LocalRoot + "/Portal/Content/Localization/App"), "*.po");
}
public override void DoTest(GUBP bp)
{
var Build = new UE4Build(bp);
var Agenda = new UE4Build.BuildAgenda();
Agenda.AddTargets(new string[] { BranchConfig.Branch.BaseEngineProject.Properties.Targets[TargetRules.TargetType.Game].TargetName }, UnrealTargetPlatform.IOS, UnrealTargetConfiguration.Development);
Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: false);
UE4Build.CheckBuildProducts(Build.BuildProductFiles);
SaveRecordOfSuccessAndAddToBuildProducts();
}
public override void ExecuteBuild()
{
Log("************************* BuildUAT");
int WorkingCL = -1;
if (P4Enabled)
{
WorkingCL = CreateChange(P4Env.Client, String.Format("UATOnly build built from changelist {0}", P4Env.Changelist));
Log("Build from {0} Working in {1}", P4Env.Changelist, WorkingCL);
}
ExecuteInner(WorkingCL);
var UE4Build = new UE4Build(this);
var Agenda = new UE4Build.BuildAgenda();
Agenda.DotNetProjects.AddRange(
new string[]
{
@"Engine\Source\Programs\DotNETCommon\DotNETUtilities\DotNETUtilities.csproj",
}
);
UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
UE4Build.AddUATFilesToBuildProducts();
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
if (P4Enabled)
{
// Sign everything we built
CodeSign.SignMultipleIfEXEOrDLL(this, UE4Build.BuildProductFiles);
// Open files for add or edit
UE4Build.AddBuildProductsToChangelist(WorkingCL, UE4Build.BuildProductFiles);
// Check everything in!
int SubmittedCL;
Submit(WorkingCL, out SubmittedCL, true, true);
// Reset engine versions to 0 if required
if (ParseParam("ZeroVersions"))
{
Execute<ZeroEngineVersions>(this);
}
}
PrintRunTime();
}
public override void DoBuild(GUBP bp)
{
BuildProducts = new List<string>();
var UE4Build = new UE4Build(bp);
UE4Build.BuildAgenda Agenda = GetAgenda(bp);
if (Agenda != null)
{
bool ReallyDeleteBuildProducts = DeleteBuildProducts() && !BranchConfig.bForceIncrementalCompile;
Agenda.DoRetries = false; // these would delete build products
bool UseParallelExecutor = bDependentOnCompileTools && (HostPlatform == UnrealTargetPlatform.Win64);
UE4Build.Build(Agenda, InDeleteBuildProducts: ReallyDeleteBuildProducts, InUpdateVersionFiles: false, InForceNoXGE: true, InForceUnity: true, InUseParallelExecutor: UseParallelExecutor);
using(TelemetryStopwatch PostBuildStopwatch = new TelemetryStopwatch("PostBuild"))
{
PostBuild(bp, UE4Build);
}
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
foreach (var Product in UE4Build.BuildProductFiles)
{
AddBuildProduct(Product);
}
RemoveOveralppingBuildProducts();
PostBuildProducts(bp);
}
if (Agenda == null || (BuildProducts.Count == 0 && BranchConfig.bForceIncrementalCompile))
{
SaveRecordOfSuccessAndAddToBuildProducts("Nothing to actually compile");
}
}
void ExecuteInner(int WorkingCL)
{
var UE4Build = new UE4Build(this);
var Agenda = new UE4Build.BuildAgenda();
var Config = ParseParamValue("Config");
if (String.IsNullOrEmpty(Config) || Config.ToLower() == "editors")
{
Agenda.DotNetSolutions.AddRange(
new string[]
{
@"Engine\Source\Programs\UnrealDocTool\UnrealDocTool\UnrealDocTool.sln",
@"Engine\Source\Programs\NetworkProfiler\NetworkProfiler.sln",
}
);
Agenda.SwarmProject = @"Engine\Source\Programs\UnrealSwarm\UnrealSwarm.sln";
Agenda.DotNetProjects.AddRange(
new string[]
{
@"Engine\Source\Programs\DotNETCommon\DotNETUtilities\DotNETUtilities.csproj",
@"Engine\Source\Programs\NoRedist\CrashReportServer\CrashReportCommon\CrashReportCommon.csproj",
@"Engine\Source\Programs\NoRedist\CrashReportServer\CrashReportReceiver\CrashReportReceiver.csproj",
@"Engine\Source\Programs\NoRedist\CrashReportServer\CrashReportProcess\CrashReportProcess.csproj",
@"Engine\Source\Programs\CrashReporter\RegisterPII\RegisterPII.csproj",
@"Engine\Source\Programs\Distill\Distill.csproj",
@"Engine\Source\Programs\RPCUtility\RPCUtility.csproj",
@"Engine\Source\Programs\UnrealControls\UnrealControls.csproj",
}
);
Agenda.IOSDotNetProjects.AddRange(
new string[]
{
@"Engine\Source\Programs\IOS\iPhonePackager\iPhonePackager.csproj",
@"Engine\Source\Programs\IOS\MobileDeviceInterface\MobileDeviceInterface.csproj",
@"Engine\Source\Programs\IOS\DeploymentInterface\DeploymentInterface.csproj",
}
);
Agenda.ExtraDotNetFiles.AddRange(
new string[]
{
"Interop.IWshRuntimeLibrary",
"UnrealMarkdown",
"CommonUnrealMarkdown",
}
);
}
{
if (LeanAndMean && UseXGE)
{
// this is minimal to test XGE
var ProgramTargets = new string[]
{
"UnrealHeaderTool",
};
Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
var Win64Targets = new string[]
{
"FortniteEditor",
"OrionEditor",
};
Agenda.AddTargets(Win64Targets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
var Win32Targets = new string[]
{
"FortniteGame",
"OrionGame",
};
Agenda.AddTargets(Win32Targets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Development);
}
else if (LeanAndMean)
{
var ProgramTargets = new string[]
{
"ShaderCompileWorker",
"UnrealHeaderTool",
"UnrealLightmass",
};
Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
var Win64DevTargets = new string[]
{
"FortniteEditor",
"QAGameEditor",
};
Agenda.AddTargets(Win64DevTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
}
else
{
//This needs to be a separate target for distributed building because it is required to build anything else.
var UHTTarget = new string[]
{
"UnrealHeaderTool",
};
Agenda.AddTargets(UHTTarget, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
var ProgramTargets = new string[]
{
"UnrealFileServer",
"ShaderCompileWorker",
"MinidumpDiagnostics",
"SymbolDebugger",
"UnrealFrontend",
"UnrealLightmass",
"UnrealPak",
"CrashReportClient",
};
var MacProgramTargets = new string[]
{
"UnrealFileServer",
"ShaderCompileWorker",
"UnrealFrontend",
"UnrealHeaderTool",
"UnrealLightmass",
"UnrealPak",
"CrashReportClient",
};
var Win64DevTargets = new List<string>
{
"FortniteEditor",
"OrionEditor",
"PlatformerGameEditor",
"QAGameEditor",
"ShooterGameEditor",
"StrategyGameEditor",
"VehicleGameEditor",
"ShadowEditor",
"SoulEditor",
"StrategyVREditor",
};
var Win32Targets = new List<string>
{
"FortniteGame",
"FortniteClient",
"FortniteServer",
"OrionGame",
"PlatformerGame",
"QAGame",
"ShooterGame",
"StrategyGame",
"VehicleGame",
"Shadow",
"Soul",
"StrategyVR",
};
var Win32ShipTargets = new List<string>
{
"FortniteGame",
"FortniteClient",
"FortniteServer",
};
var PS4DevTargets = new List<string>
{
"QAGame",
"UE4Game",
"FortniteGame",
};
var XboxOneDevTargets = new List<string>
{
"QAGame",
"UE4Game",
"FortniteGame",
};
var IOSDevTargets = new List<string>
{
"QAGame",
"UE4Game",
"Shadow",
"PlatformerGame",
"StrategyGame",
"Soul",
};
var MacDevTargets = new List<string>
{
"QAGameEditor",
};
var AndroidDevTargets = new List<string>
{
"UE4Game",
"Soul",
};
//Check to see if we should Exclude any projects. We would want to do this for branches that do not have all of the projects
var Excludes = ParseParamValue("Exclude");
if (!String.IsNullOrEmpty(Excludes))
{
List<List<string>> TargetLists = new List<List<string>>
{
Win32Targets,
Win64DevTargets,
Win32ShipTargets,
PS4DevTargets,
XboxOneDevTargets,
IOSDevTargets,
MacDevTargets,
AndroidDevTargets,
};
List<string> Samples = new List<string>
{
"PlatformerGame",
"ShooterGame",
"StrategyGame",
"VehicleGame",
"PlatformerGameEditor",
"ShooterGameEditor",
"StrategyGameEditor",
"VehicleGameEditor",
};
List<string> Orion = new List<string>
{
"OrionGame",
"OrionEditor",
};
List<string> Fortnite = new List<string>
{
"FortniteServer",
"FortniteClient",
"FortniteGame",
"FortniteEditor",
};
List<string> Shadow = new List<string>
{
"Shadow",
"ShadowEditor",
};
List<string> Soul = new List<string>
{
"Soul",
"SoulEditor",
};
List<string> StrategyVR = new List<string>
{
"StrategyVR",
"StrategyVREditor",
};
List<string> Exclude = new List<string>(Excludes.Split('+'));
foreach (List<string> List in TargetLists)
{
if (Exclude.Contains("Samples"))
{
RemoveTargetsFromList(Samples, List);
}
if (Exclude.Contains("Orion"))
{
RemoveTargetsFromList(Orion, List);
}
if (Exclude.Contains("Fortnite"))
{
RemoveTargetsFromList(Fortnite, List);
}
if (Exclude.Contains("Shadow"))
{
RemoveTargetsFromList(Shadow, List);
}
if (Exclude.Contains("Soul"))
{
RemoveTargetsFromList(Soul, List);
}
if (Exclude.Contains("StrategyVR"))
{
RemoveTargetsFromList(StrategyVR, List);
}
}
}
// @todo: make this programmatic by looping over the TargetLists (which maybe should be a map from config to list)
string[] Win64Dev = Win64DevTargets.ToArray();
string[] Win32Dev = Win32Targets.ToArray();
string[] Win32Ship = Win32ShipTargets.ToArray();
string[] PS4Dev = PS4DevTargets.ToArray();
string[] XboxOneDev = XboxOneDevTargets.ToArray();
string[] IOSDev = IOSDevTargets.ToArray();
string[] MacDev = MacDevTargets.ToArray();
string[] AndroidDev = AndroidDevTargets.ToArray();
if (!String.IsNullOrEmpty(Config))
{
switch (Config.ToUpperInvariant())
{
case "EDITORS":
Agenda.AddTargets(Win64Dev, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
break;
case "WIN32DEV":
Agenda.AddTargets(Win32Dev, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Development);
break;
case "WIN32SHIP":
Agenda.AddTargets(Win32Ship, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Shipping);
break;
case "PS4DEV":
Agenda.AddTargets(PS4Dev, UnrealTargetPlatform.PS4, UnrealTargetConfiguration.Development);
break;
case "XBOXONEDEV":
Agenda.AddTargets(XboxOneDev, UnrealTargetPlatform.XboxOne, UnrealTargetConfiguration.Development);
break;
case "IOSDEV":
Agenda.AddTargets(IOSDev, UnrealTargetPlatform.IOS, UnrealTargetConfiguration.Development);
break;
case "MACDEV":
Agenda.AddTargets(MacDev, UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Development);
Agenda.AddTargets(MacProgramTargets, UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Development);
break;
case "ANDROIDDEV":
Agenda.AddTargets(AndroidDev, UnrealTargetPlatform.Android, UnrealTargetConfiguration.Development);
break;
}
}
else
{
Agenda.AddTargets(Win64Dev, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
Agenda.AddTargets(Win32Dev, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Development);
Agenda.AddTargets(Win32Ship, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Shipping);
Agenda.AddTargets(PS4Dev, UnrealTargetPlatform.PS4, UnrealTargetConfiguration.Development);
Agenda.AddTargets(XboxOneDev, UnrealTargetPlatform.XboxOne, UnrealTargetConfiguration.Development);
Agenda.AddTargets(IOSDev, UnrealTargetPlatform.IOS, UnrealTargetConfiguration.Development);
}
}
}
UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
if (String.IsNullOrEmpty(Config) || Config.ToLower() == "editors")
{
UE4Build.AddUATFilesToBuildProducts();
}
UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
if (P4Enabled)
{
// Sign everything we built
CodeSign.SignMultipleIfEXEOrDLL(this, UE4Build.BuildProductFiles);
// Open files for add or edit
UE4Build.AddBuildProductsToChangelist(WorkingCL, UE4Build.BuildProductFiles);
// Check everything in!
int SubmittedCL;
Submit(WorkingCL, out SubmittedCL, true, true);
// Label it
if (String.IsNullOrEmpty(Config))
{
MakeDownstreamLabel("Promotable");
}
else if (Config.ToLower() == "editors")
{
MakeDownstreamLabel("Promotable-Partial-" + Config);
}
else
{
MakeDownstreamLabel("Partial-Promotable-" + Config, UE4Build.BuildProductFiles);
}
}
}
public override void ExecuteBuild()
{
// get the project
var UProjectFileName = ParseParamValue("Project");
if (UProjectFileName == null)
{
throw new AutomationException("Project was not specified via the -project argument.");
}
// Get the list of targets
var TargetList = ParseParamList("Target");
if (TargetList == null)
{
throw new AutomationException("Target was not specified via the -target argument.");
}
// get the list of platforms
var PlatformList = ParseParamList("TargetPlatforms", "Win64");
List<UnrealTargetPlatform> TargetPlatforms = new List<UnrealTargetPlatform>();
foreach(string Platform in PlatformList)
{
TargetPlatforms.Add((UnrealTargetPlatform)Enum.Parse(typeof(UnrealTargetPlatform), Platform, true));
}
// get the list configurations
var ConfigList = ParseParamList("Config", "Development");
List<UnrealTargetConfiguration> ConfigsToBuild = new List<UnrealTargetConfiguration>();
foreach(string Config in ConfigList)
{
ConfigsToBuild.Add((UnrealTargetConfiguration)Enum.Parse(typeof(UnrealTargetConfiguration), Config, true));
}
// parse any extra parameters
bool bClean = ParseParam("Clean");
int WorkingCL = ParseParamInt("P4Change");
FileReference UProjectFileReference = new FileReference( UProjectFileName);
// add the targets to the agenda
// verify the targets and add them to the agenda
var Properties = ProjectUtils.GetProjectProperties(UProjectFileReference);
UE4Build.BuildAgenda Agenda = new UE4Build.BuildAgenda();
foreach (string Target in TargetList)
{
SingleTargetProperties TargetData;
if (!Properties.Targets.TryGetValue((TargetRules.TargetType)Enum.Parse(typeof(TargetRules.TargetType), Target), out TargetData))
{
throw new AutomationException("Project does not support specified target: {0}", Target);
}
foreach (UnrealTargetPlatform TargetPlatform in TargetPlatforms)
{
if (TargetData.Rules.SupportsPlatform(TargetPlatform))
{
List<UnrealTargetConfiguration> SupportedConfigurations = new List<UnrealTargetConfiguration>();
TargetData.Rules.GetSupportedConfigurations(ref SupportedConfigurations, true);
foreach (UnrealTargetConfiguration TargetConfig in ConfigsToBuild)
{
if (SupportedConfigurations.Contains(TargetConfig))
{
Agenda.AddTarget(TargetData.TargetName, TargetPlatform, TargetConfig, UProjectFileReference);
}
else
{
Log("{0} doesn't support the {1} configuration. It will not be built.", TargetData.TargetName, TargetConfig);
}
}
}
else
{
Log("{0} doesn't support the {1} platform. It will not be built.", TargetData.TargetName, TargetPlatform);
}
}
}
// build it
UE4Build Build = new UE4Build(this);
Build.Build(Agenda, InDeleteBuildProducts: bClean, InUpdateVersionFiles: WorkingCL > 0);
if (WorkingCL > 0) // only move UAT files if we intend to check in some build products
{
Build.AddUATFilesToBuildProducts();
}
UE4Build.CheckBuildProducts(Build.BuildProductFiles);
if (WorkingCL > 0)
{
// Sign everything we built
CodeSign.SignMultipleIfEXEOrDLL(this, Build.BuildProductFiles);
// Open files for add or edit
UE4Build.AddBuildProductsToChangelist(WorkingCL, Build.BuildProductFiles);
}
}
public override void ExecuteBuild()
{
var StartTime = DateTime.UtcNow;
var Files = CommandUtils.FindFiles("*.*", true, @"P:\Builds\Fortnite\CloudDir\Chunks\");
var Duration = (DateTime.UtcNow - StartTime).TotalSeconds;
Log("Found {0} files in {1}s with C#", Files.Length, Duration);
UE4Build Build = new UE4Build(this);
var Agenda = new UE4Build.BuildAgenda();
UnrealTargetPlatform EditorPlatform = HostPlatform.Current.HostEditorPlatform;
const UnrealTargetConfiguration EditorConfiguration = UnrealTargetConfiguration.Development;
Agenda.AddTargets(new string[] { "BlankProgram" }, EditorPlatform, EditorConfiguration);
Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: false);
var Exe = CombinePaths(CmdEnv.LocalRoot, @"Engine/Binaries/Win64/", "BlankProgram.exe");
RunAndLog(CmdEnv, Exe, "");
}
