public override UE4Build.BuildAgenda GetAgenda(GUBP bp) { var Agenda = new UE4Build.BuildAgenda(); Agenda.DotNetSolutions.Add("Engine/Source/Programs/UnrealDocTool/APIDocTool/APIDocTool.sln"); Agenda.DotNetSolutions.Add("Engine/Source/Programs/UnrealDocTool/UnrealDocTool/UnrealDocTool.sln"); return Agenda; }
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); } }
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); }
/// <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); }
// 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; } }
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); }
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 override UE4Build.BuildAgenda GetAgenda(GUBP bp) { var Agenda = new UE4Build.BuildAgenda(); if (HostPlatform == UnrealTargetPlatform.Win64 && !BranchConfig.bForceIncrementalCompile) { Agenda.DotNetProjects.AddRange( new string[] { @"Engine\Source\Programs\DotNETCommon\DotNETUtilities\DotNETUtilities.csproj", @"Engine\Source\Programs\RPCUtility\RPCUtility.csproj", } ); } string AddArgs = "-CopyAppBundleBackToDevice"; Agenda.AddTargets(new string[] { "UnrealHeaderTool" }, HostPlatform, UnrealTargetConfiguration.Development, InAddArgs: AddArgs); if (HostPlatform == UnrealTargetPlatform.Win64) { Agenda.AddTargets(new string[] { "ParallelExecutor" }, HostPlatform, UnrealTargetConfiguration.Development, InAddArgs: AddArgs); } return Agenda; }
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 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 UE4Build.BuildAgenda GetAgenda(GUBP bp) { if (EditorPlatform != UnrealTargetPlatform.IOS && !bp.bOrthogonalizeEditorPlatforms) { return null; } var Agenda = new UE4Build.BuildAgenda(); if (EditorPlatform == UnrealTargetPlatform.IOS) { //@todo, this should be generic platform stuff 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", } ); } if (bp.bOrthogonalizeEditorPlatforms) { Agenda.AddTargets( new string[] { bp.Branch.BaseEngineProject.Properties.Targets[TargetRules.TargetType.Editor].TargetName }, HostPlatform, UnrealTargetConfiguration.Development, InAddArgs: "-nobuilduht -skipactionhistory -onlyplatformspecificfor=" + EditorPlatform.ToString()); foreach (var ProgramTarget in bp.Branch.BaseEngineProject.Properties.Programs) { if (ProgramTarget.Rules.GUBP_AlwaysBuildWithBaseEditor() && ProgramTarget.Rules.SupportsPlatform(HostPlatform) && ProgramTarget.Rules.GUBP_NeedsPlatformSpecificDLLs()) { Agenda.AddTargets(new string[] { ProgramTarget.TargetName }, HostPlatform, UnrealTargetConfiguration.Development, InAddArgs: "-nobuilduht -skipactionhistory -onlyplatformspecificfor=" + EditorPlatform.ToString()); } } } return Agenda; }
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() { 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 UE4Build.BuildAgenda GetAgenda(GUBP bp) { var Agenda = new UE4Build.BuildAgenda(); string AddArgs = "-nobuilduht -skipactionhistory -CopyAppBundleBackToDevice"; foreach (var ProgramTarget in BranchConfig.Branch.BaseEngineProject.Properties.Programs) { bool bInternalOnly; bool SeparateNode; bool CrossCompile; if (ProgramTarget.Rules.GUBP_AlwaysBuildWithTools(HostPlatform, out bInternalOnly, out SeparateNode, out CrossCompile) && ProgramTarget.Rules.SupportsPlatform(HostPlatform) && !bInternalOnly && !SeparateNode && CrossCompile) { foreach (var Config in ProgramTarget.Rules.GUBP_ToolConfigs(HostPlatform)) { Agenda.AddTargets(new string[] { ProgramTarget.TargetName }, UnrealTargetPlatform.Linux, Config, InAddArgs: AddArgs); } } } return Agenda; }
/// <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 UE4Build.BuildAgenda GetAgenda(GUBP bp) { bool bAnyAdded = false; var Agenda = new UE4Build.BuildAgenda(); if (HostPlatform == UnrealTargetPlatform.Win64) { bAnyAdded = true; Agenda.DotNetProjects.AddRange( new string[] { CombinePaths(@"Engine\Source\Programs\NotForLicensees\CrashReportServer\CrashReportCommon\CrashReportCommon.csproj"), CombinePaths(@"Engine\Source\Programs\NotForLicensees\CrashReportServer\CrashReportReceiver\CrashReportReceiver.csproj"), CombinePaths(@"Engine\Source\Programs\NotForLicensees\CrashReportServer\CrashReportProcess\CrashReportProcess.csproj"), CombinePaths(@"Engine\Source\Programs\CrashReporter\RegisterPII\RegisterPII.csproj"), }); Agenda.DotNetSolutions.AddRange( new string[] { CombinePaths(@"Engine\Source\Programs\UnrealDocTool\UnrealDocTool\UnrealDocTool.sln"), } ); Agenda.ExtraDotNetFiles.AddRange( new string[] { "Interop.IWshRuntimeLibrary", "UnrealMarkdown", "CommonUnrealMarkdown", } ); } string AddArgs = "-nobuilduht -skipactionhistory -CopyAppBundleBackToDevice"; foreach (var ProgramTarget in BranchConfig.Branch.BaseEngineProject.Properties.Programs) { bool bInternalOnly; bool SeparateNode; bool CrossCompile; if (ProgramTarget.Rules.GUBP_AlwaysBuildWithTools(HostPlatform, out bInternalOnly, out SeparateNode, out CrossCompile) && ProgramTarget.Rules.SupportsPlatform(HostPlatform) && bInternalOnly && !SeparateNode) { foreach (var Plat in ProgramTarget.Rules.GUBP_ToolPlatforms(HostPlatform)) { foreach (var Config in ProgramTarget.Rules.GUBP_ToolConfigs(HostPlatform)) { Agenda.AddTargets(new string[] { ProgramTarget.TargetName }, Plat, Config, InAddArgs: AddArgs); bAnyAdded = true; } } } } if (bAnyAdded) { return Agenda; } return null; }
public override UE4Build.BuildAgenda GetAgenda(GUBP bp) { var Agenda = new UE4Build.BuildAgenda(); Agenda.DotNetProjects.AddRange( new string[] { @"Engine\Source\Programs\Distill\Distill.csproj", @"Engine\Source\Programs\UnrealControls\UnrealControls.csproj", } ); if (HostPlatform == UnrealTargetPlatform.Mac) { Agenda.DotNetProjects.AddRange( new string[] { // UnrealSwarm @"Engine/Source/Programs/UnrealSwarm/SwarmCoordinatorInterface/SwarmCoordinatorInterface_Mono.csproj", @"Engine/Source/Programs/UnrealSwarm/Agent/Agent_Mono.csproj", @"Engine/Source/Programs/UnrealControls/UnrealControls_Mono.csproj", @"Engine/Source/Programs/UnrealSwarm/SwarmCoordinator/SwarmCoordinator_Mono.csproj", @"Engine/Source/Programs/UnrealSwarm/AgentInterface/AgentInterface_Mono.csproj", // AutomationTool @"Engine/Source/Programs/AutomationTool/AutomationTool_Mono.csproj", } ); } else { 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.ExtraDotNetFiles.AddRange( new string[] { "Interop.IWshRuntimeLibrary", "UnrealMarkdown", "CommonUnrealMarkdown", } ); Agenda.DotNetProjects.AddRange(new string[] { @"Engine\Source\Programs\CrashReporter\RegisterPII\RegisterPII.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", }); } foreach (var ProgramTarget in bp.Branch.BaseEngineProject.Properties.Programs) { if (ProgramTarget.Rules.GUBP_AlwaysBuildWithTools() && ProgramTarget.Rules.SupportsPlatform(HostPlatform)) { Agenda.AddTargets(new string[] { ProgramTarget.TargetName }, HostPlatform, UnrealTargetConfiguration.Development); } } return Agenda; }
public override UE4Build.BuildAgenda GetAgenda(GUBP bp) { var Agenda = new UE4Build.BuildAgenda(); //if (HostPlatform == UnrealTargetPlatform.Mac) { Agenda.DotNetProjects.AddRange( new string[] { @"Engine\Source\Programs\DotNETCommon\DotNETUtilities\DotNETUtilities.csproj", @"Engine\Source\Programs\RPCUtility\RPCUtility.csproj", } ); } string AddArgs = ""; if (bp.bOrthogonalizeEditorPlatforms) { AddArgs = "-skipnonhostplatforms"; } Agenda.AddTargets(new string[] { "UnrealHeaderTool" }, HostPlatform, UnrealTargetConfiguration.Development); Agenda.AddTargets( new string[] { bp.Branch.BaseEngineProject.Properties.Targets[TargetRules.TargetType.Editor].TargetName }, HostPlatform, UnrealTargetConfiguration.Development, InAddArgs: AddArgs); foreach (var ProgramTarget in bp.Branch.BaseEngineProject.Properties.Programs) { if (ProgramTarget.Rules.GUBP_AlwaysBuildWithBaseEditor() && ProgramTarget.Rules.SupportsPlatform(HostPlatform)) { Agenda.AddTargets(new string[] { ProgramTarget.TargetName }, HostPlatform, UnrealTargetConfiguration.Development, InAddArgs: AddArgs); } } return Agenda; }
public override UE4Build.BuildAgenda GetAgenda(GUBP bp) { if (!bp.ActivePlatforms.Contains(TargetPlatform)) { throw new AutomationException("{0} is not a supported platform for {1}", TargetPlatform.ToString(), GetFullName()); } var Agenda = new UE4Build.BuildAgenda(); foreach (var Kind in BranchInfo.MonolithicKinds) { if (GameProj.Properties.Targets.ContainsKey(Kind)) { var Target = GameProj.Properties.Targets[Kind]; var Platforms = Target.Rules.GUBP_GetPlatforms_MonolithicOnly(HostPlatform); if (Platforms.Contains(TargetPlatform) && Target.Rules.SupportsPlatform(TargetPlatform)) { var Configs = Target.Rules.GUBP_GetConfigs_MonolithicOnly(HostPlatform, TargetPlatform); foreach (var Config in Configs) { Agenda.AddTargets(new string[] { Target.TargetName }, TargetPlatform, Config, GameProj.FilePath); } } } } return Agenda; }
public override UE4Build.BuildAgenda GetAgenda(GUBP bp) { var Agenda = new UE4Build.BuildAgenda(); string AddArgs = "-nobuilduht"; Agenda.AddTargets( new string[] { BranchConfig.Branch.BaseEngineProject.Properties.Targets[TargetRules.TargetType.Editor].TargetName }, UnrealTargetPlatform.Linux, UnrealTargetConfiguration.Development, InAddArgs: AddArgs); foreach (var ProgramTarget in BranchConfig.Branch.BaseEngineProject.Properties.Programs) { if (ProgramTarget.Rules.GUBP_AlwaysBuildWithBaseEditor() && ProgramTarget.Rules.SupportsPlatform(UnrealTargetPlatform.Linux)) { Agenda.AddTargets(new string[] { ProgramTarget.TargetName }, UnrealTargetPlatform.Linux, UnrealTargetConfiguration.Development, InAddArgs: AddArgs); } } return Agenda; }
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 UE4Build.BuildAgenda GetAgenda(GUBP bp) { var Agenda = new UE4Build.BuildAgenda(); if (HostPlatform == UnrealTargetPlatform.Win64) { if (!BranchConfig.bForceIncrementalCompile) { Agenda.DotNetProjects.AddRange( new string[] { CombinePaths(@"Engine\Source\Programs\UnrealControls\UnrealControls.csproj"), } ); } Agenda.DotNetSolutions.AddRange( new string[] { CombinePaths(@"Engine\Source\Programs\NetworkProfiler\NetworkProfiler.sln"), } ); if (!BranchConfig.bForceIncrementalCompile) { Agenda.SwarmProject = CombinePaths(@"Engine\Source\Programs\UnrealSwarm\UnrealSwarm.sln"); } bool WithIOS = !BranchConfig.BranchOptions.PlatformsToRemove.Contains(UnrealTargetPlatform.IOS); if ( WithIOS ) { Agenda.IOSDotNetProjects.AddRange( new string[] { CombinePaths(@"Engine\Source\Programs\IOS\iPhonePackager\iPhonePackager.csproj"), CombinePaths(@"Engine\Source\Programs\IOS\DeploymentServer\DeploymentServer.csproj"), CombinePaths(@"Engine\Source\Programs\IOS\MobileDeviceInterface\MobileDeviceInterface.csproj"), CombinePaths(@"Engine\Source\Programs\IOS\DeploymentInterface\DeploymentInterface.csproj"), } ); } bool WithHTML5 = !BranchConfig.BranchOptions.PlatformsToRemove.Contains(UnrealTargetPlatform.HTML5); if (WithHTML5) { Agenda.HTML5DotNetProjects.AddRange( new string[] { CombinePaths(@"Engine\Source\Programs\HTML5\HTML5LaunchHelper\HTML5LaunchHelper.csproj"), } ); } } string AddArgs = "-nobuilduht -skipactionhistory -CopyAppBundleBackToDevice"; foreach (var ProgramTarget in BranchConfig.Branch.BaseEngineProject.Properties.Programs) { bool bInternalOnly; bool SeparateNode; bool CrossCompile; if (ProgramTarget.Rules.GUBP_AlwaysBuildWithTools(HostPlatform, out bInternalOnly, out SeparateNode, out CrossCompile) && ProgramTarget.Rules.SupportsPlatform(HostPlatform) && !bInternalOnly && !SeparateNode) { if (!BranchConfig.BranchOptions.ExcludeNodes.Contains(ProgramTarget.TargetName)) { foreach (var Plat in ProgramTarget.Rules.GUBP_ToolPlatforms(HostPlatform)) { foreach (var Config in ProgramTarget.Rules.GUBP_ToolConfigs(HostPlatform)) { Agenda.AddTargets(new string[] { ProgramTarget.TargetName }, Plat, Config, InAddArgs: AddArgs); } } } } } return Agenda; }
public override UE4Build.BuildAgenda GetAgenda(GUBP bp) { if (!ActivePlatforms.Contains(TargetPlatform)) { throw new AutomationException("{0} is not a supported platform for {1}", TargetPlatform.ToString(), GetFullName()); } var Agenda = new UE4Build.BuildAgenda(); string Args = "-nobuilduht -skipactionhistory -CopyAppBundleBackToDevice"; if(Precompiled) { Args += " -precompile"; // MSVC doesn't provide a way to strip symbols from static libraries - you have to use PDBs, but that causes random OOM // exceptions with the /FS arg because mspdbsrv is 32-bit. Just disable compiler debug info manually for now. if(TargetPlatform == UnrealTargetPlatform.Win32 || TargetPlatform == UnrealTargetPlatform.Win64) { Args += " -nodebuginfo"; } } if (WithXp) { Args += " -winxp"; } foreach (var Kind in BranchInfo.MonolithicKinds) { if (GameProj.Properties.Targets.ContainsKey(Kind)) { var Target = GameProj.Properties.Targets[Kind]; var AllowXp = Target.Rules.GUBP_BuildWindowsXPMonolithics(); if (!WithXp || (AllowXp && WithXp)) { var Platforms = Target.Rules.GUBP_GetPlatforms_MonolithicOnly(HostPlatform); var AdditionalPlatforms = Target.Rules.GUBP_GetBuildOnlyPlatforms_MonolithicOnly(HostPlatform); var AllPlatforms = Platforms.Union(AdditionalPlatforms); if (AllPlatforms.Contains(TargetPlatform) && Target.Rules.SupportsPlatform(TargetPlatform)) { List<UnrealTargetConfiguration> Configs; if(Precompiled) { Configs = Target.Rules.GUBP_GetConfigsForPrecompiledBuilds_MonolithicOnly(HostPlatform, TargetPlatform); } else { Configs = Target.Rules.GUBP_GetConfigs_MonolithicOnly(HostPlatform, TargetPlatform).Except(Target.Rules.GUBP_GetConfigsForPrecompiledBuilds_MonolithicOnly(HostPlatform, TargetPlatform)).ToList(); } foreach (var Config in Configs) { if (GameProj.GameName == BranchConfig.Branch.BaseEngineProject.GameName) { Agenda.AddTargets(new string[] { Target.TargetName }, TargetPlatform, Config, InAddArgs: Args); } else { Agenda.AddTargets(new string[] { Target.TargetName }, TargetPlatform, Config, GameProj.FilePath, InAddArgs: Args); } } } } } } return Agenda; }
public override UE4Build.BuildAgenda GetAgenda(GUBP bp) { var Agenda = new UE4Build.BuildAgenda(); string AddArgs = "-nobuilduht -skipactionhistory -CopyAppBundleBackToDevice"; foreach (var Plat in ProgramTarget.Rules.GUBP_ToolPlatforms(HostPlatform)) { foreach (var Config in ProgramTarget.Rules.GUBP_ToolConfigs(HostPlatform)) { Agenda.AddTargets(new string[] { ProgramTarget.TargetName }, Plat, Config, InAddArgs: AddArgs); } } return Agenda; }
public override UE4Build.BuildAgenda GetAgenda(GUBP bp) { var Agenda = new UE4Build.BuildAgenda(); Agenda.AddTargets( new string[] { GameProj.Properties.Targets[TargetRules.TargetType.Editor].TargetName }, HostPlatform, UnrealTargetConfiguration.Development, GameProj.FilePath, InAddArgs: "-nobuilduht -skipactionhistory -skipnonhostplatforms"); return Agenda; }
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 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 UE4Build.BuildAgenda GetAgenda(GUBP bp) { var Agenda = new UE4Build.BuildAgenda(); string Args = "-nobuilduht -skipactionhistory -skipnonhostplatforms -CopyAppBundleBackToDevice -forceheadergeneration"; if(!BranchConfig.BranchOptions.bNoInstalledEngine) { Args += " -precompile"; } foreach(BranchInfo.BranchUProject GameProj in GameProjects) { Agenda.AddTargets( new string[] { GameProj.Properties.Targets[TargetRules.TargetType.Editor].TargetName }, HostPlatform, UnrealTargetConfiguration.Development, GameProj.FilePath, InAddArgs: Args); } return Agenda; }