486 lines
25 KiB
C#
486 lines
25 KiB
C#
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading.Tasks;
|
|
using AutomationTool.Tasks;
|
|
using EpicGames.BuildGraph;
|
|
using EpicGames.BuildGraph.Expressions;
|
|
using EpicGames.Core;
|
|
using Microsoft.Extensions.Logging;
|
|
using UnrealBuildBase;
|
|
using UnrealBuildTool;
|
|
using static AutomationTool.Tasks.StandardTasks;
|
|
|
|
#nullable enable
|
|
|
|
namespace AutomationTool
|
|
{
|
|
class InstalledBuild : BgGraphBuilder
|
|
{
|
|
static FileSet Workspace { get; } = FileSet.FromDirectory(Unreal.RootDirectory);
|
|
static DirectoryReference RootDir { get; } = new DirectoryReference(CommandUtils.CmdEnv.LocalRoot);
|
|
static DirectoryReference IntermediateDir => DirectoryReference.Combine(RootDir, "Engine", "Intermediate", "Installed");
|
|
static DirectoryReference TempMiscDir => DirectoryReference.Combine(IntermediateDir, "General");
|
|
static DirectoryReference TempCsToolsDir => DirectoryReference.Combine(IntermediateDir, "CsTools");
|
|
static DirectoryReference TempDdcDir => DirectoryReference.Combine(IntermediateDir, "DDC");
|
|
|
|
// static string[] PluginsExceptions =
|
|
// {
|
|
// "Engine/Plugins/Enterprise/DatasmithCADImporter/...",
|
|
// "Engine/Plugins/Enterprise/DatasmithC4DImporter/...",
|
|
// "Engine/Plugins/Enterprise/AxFImporter/...",
|
|
// "Engine/Plugins/Enterprise/MDLImporter/..."
|
|
// };
|
|
|
|
// static string[] WinSignFilter =
|
|
// {
|
|
// "*.exe",
|
|
// "*.dll"
|
|
// };
|
|
|
|
static readonly string[] s_winStripFilter =
|
|
{
|
|
"*.pdb",
|
|
"-/Engine/Binaries/Win64/UnrealEditor*.pdb",
|
|
"-/Engine/Plugins/.../Binaries/Win64/UnrealEditor*.pdb",
|
|
};
|
|
|
|
static List<string> GetDdcProjects(UnrealTargetPlatform platform)
|
|
{
|
|
List<string> projects = new List<string>();
|
|
projects.Add("Templates/TP_AEC_ArchvisBP/TP_AEC_ArchvisBP.uproject");
|
|
projects.Add("Templates/TP_AEC_BlankBP/TP_AEC_BlankBP.uproject");
|
|
projects.Add("Templates/TP_AEC_CollabBP/TP_AEC_CollabBP.uproject");
|
|
projects.Add("Templates/TP_AEC_ProdConfigBP/TP_AEC_ProdConfigBP.uproject");
|
|
projects.Add("Templates/TP_FirstPersonBP/TP_FirstPersonBP.uproject");
|
|
projects.Add("Templates/TP_HandheldARBP/TP_HandheldARBP.uproject");
|
|
projects.Add("Templates/TP_AEC_HandheldARBP/TP_AEC_HandheldARBP.uproject");
|
|
projects.Add("Templates/TP_MFG_HandheldARBP/TP_MFG_HandheldARBP.uproject");
|
|
projects.Add("Templates/TP_MFG_CollabBP/TP_MFG_CollabBP.uproject");
|
|
projects.Add("Templates/TP_MFG_ProdConfigBP/TP_MFG_ProdConfigBP.uproject");
|
|
projects.Add("Templates/TP_PhotoStudioBP/TP_PhotoStudioBP.uproject");
|
|
projects.Add("Templates/TP_PuzzleBP/TP_PuzzleBP.uproject");
|
|
projects.Add("Templates/TP_ThirdPersonBP/TP_ThirdPersonBP.uproject");
|
|
projects.Add("Templates/TP_TopDownBP/TP_TopDownBP.uproject");
|
|
projects.Add("Templates/TP_VehicleAdvBP/TP_VehicleAdvBP.uproject");
|
|
projects.Add("Templates/TP_VirtualRealityBP/TP_VirtualRealityBP.uproject");
|
|
projects.Add("Templates/TP_DMXBP/TP_DMXBP.uproject");
|
|
// Projects.Add("Samples/StarterContent/StarterContent.uproject");
|
|
|
|
if (platform == UnrealTargetPlatform.Win64)
|
|
{
|
|
projects.Add("Templates/TP_InCamVFXBP/TP_InCamVFXBP.uproject");
|
|
}
|
|
return projects;
|
|
}
|
|
|
|
public override BgGraph CreateGraph(BgEnvironment context)
|
|
{
|
|
string rootDir = CommandUtils.CmdEnv.LocalRoot;
|
|
|
|
BgBoolOption hostPlatformOnly = new BgBoolOption("HostPlatformOnly", "A helper option to make an installed build for your host platform only, so that you don't have to disable each platform individually", false);
|
|
BgBoolOption hostPlatformEditorOnly = new BgBoolOption("HostPlatformEditorOnly", "A helper option to make an installed build for your host platform only, so that you don't have to disable each platform individually", false);
|
|
BgBoolOption allPlatforms = new BgBoolOption("AllPlatforms", "Include all target platforms by default", false);
|
|
BgBoolOption compileDatasmithPlugins = new BgBoolOption("CompileDatasmithPlugins", "If Datasmith plugins should be compiled on a separate node.", false);
|
|
|
|
UnrealTargetPlatform currentHostPlatform = HostPlatform.Current.HostEditorPlatform;
|
|
|
|
BgBool defaultWithWin64 = !(hostPlatformEditorOnly | (hostPlatformOnly & (currentHostPlatform != UnrealTargetPlatform.Win64)));
|
|
BgBool defaultWithMac = !(hostPlatformEditorOnly | (hostPlatformOnly & (currentHostPlatform != UnrealTargetPlatform.Mac)));
|
|
BgBool defaultWithLinux = !(hostPlatformEditorOnly | (hostPlatformOnly & (currentHostPlatform != UnrealTargetPlatform.Linux)));
|
|
BgBool defaultWithLinuxArm64 = !(hostPlatformEditorOnly | (hostPlatformOnly & (currentHostPlatform != UnrealTargetPlatform.Linux)));
|
|
BgBool defaultWithPlatform = !(hostPlatformEditorOnly | hostPlatformOnly);
|
|
BgBool defaultWithIos = !((currentHostPlatform != UnrealTargetPlatform.Mac) & !allPlatforms);
|
|
|
|
BgBoolOption withWin64 = new BgBoolOption("WithWin64", "Include the Win64 target platform", defaultWithWin64);
|
|
BgBoolOption withMac = new BgBoolOption("WithMac", "Include the Mac target platform", defaultWithMac);
|
|
BgBoolOption withAndroid = new BgBoolOption("WithAndroid", "Include the Android target platform", defaultWithPlatform);
|
|
BgBoolOption withIos = new BgBoolOption("WithIOS", "Include the iOS target platform", defaultWithIos);
|
|
BgBoolOption withTvos = new BgBoolOption("WithTVOS", "Include the tvOS target platform", defaultWithIos);
|
|
BgBoolOption withLinux = new BgBoolOption("WithLinux", "Include the Linux target platform", defaultWithLinux);
|
|
BgBoolOption withLinuxArm64 = new BgBoolOption("WithLinuxArm64", "Include the Linux AArch64 target platform", defaultWithLinuxArm64);
|
|
|
|
BgBoolOption withClient = new BgBoolOption("WithClient", "Include precompiled client targets", false);
|
|
BgBoolOption withServer = new BgBoolOption("WithServer", "Include precompiled server targets", false);
|
|
BgBoolOption withDdc = new BgBoolOption("WithDDC", "Build a standalone derived-data cache for the engine content and templates", true);
|
|
BgBoolOption hostPlatformDdcOnly = new BgBoolOption("HostPlatformDDCOnly", "Whether to include DDC for the host platform only", true);
|
|
BgBoolOption signExecutables = new BgBoolOption("SignExecutables", "Sign the executables produced where signing is available", false);
|
|
|
|
BgStringOption analyticsTypeOverride = new BgStringOption("AnalyticsTypeOverride", "Identifier for analytic events to send", "");
|
|
BgBool embedSrcSrvInfo = new BgBoolOption("EmbedSrcSrvInfo", "Whether to add Source indexing to Windows game apps so they can be added to a symbol server", false);
|
|
|
|
BgList<BgString> defaultGameConfigurations = BgList<BgString>.Create(nameof(UnrealTargetConfiguration.DebugGame), nameof(UnrealTargetConfiguration.Development), nameof(UnrealTargetConfiguration.Shipping));
|
|
BgList<BgString> gameConfigurationStrings = new BgListOption("GameConfigurations", description: "Which game configurations to include for packaged applications", style: BgListOptionStyle.CheckList, values: defaultGameConfigurations);
|
|
BgList<BgEnum<UnrealTargetConfiguration>> gameConfigurations = gameConfigurationStrings.Select(x => BgEnum<UnrealTargetConfiguration>.Parse(x));
|
|
|
|
BgBoolOption withFullDebugInfo = new BgBoolOption("WithFullDebugInfo", "Generate full debug info for binary editor and packaged application builds", false);
|
|
|
|
BgStringOption builtDirectory = new BgStringOption("BuiltDirectory", "Directory for outputting the built engine", rootDir + "/LocalBuilds/Engine");
|
|
|
|
BgStringOption crashReporterApiurl = new BgStringOption("CrashReporterAPIURL", "The URL to use to talk to the CrashReporterClient API.", "");
|
|
BgStringOption crashReporterApiKey = new BgStringOption("CrashReporterAPIKey", "The API key to use to talk to the CrashReporterClient API.", "");
|
|
BgStringOption buildId = new BgStringOption("BuildId", "The unique build identifier to associate with this installed build", "");
|
|
|
|
BgString crashReporterCompileArgs = "";
|
|
crashReporterCompileArgs = crashReporterCompileArgs.If(crashReporterApiurl != "" & crashReporterApiKey != "", BgString.Format("-define:CRC_TELEMETRY_URL=\"{0}\" -define:CRC_TELEMETRY_KEY_DEV=\"{1}\" -define:CRC_TELEMETRY_KEY_RELEASE=\"{1}\" -OverrideBuildEnvironment", crashReporterApiurl, crashReporterApiKey));
|
|
|
|
List<BgAggregate> aggregates = new List<BgAggregate>();
|
|
|
|
/////// EDITORS ////////////////////////////////////////////////
|
|
|
|
//// Windows ////
|
|
BgAgent editorWin64 = new BgAgent("Editor Win64", "Win64_Licensee");
|
|
|
|
BgNode versionFilesNode = editorWin64
|
|
.AddNode(x => UpdateVersionFilesAsync(x));
|
|
|
|
BgNode<BgFileSet> winEditorNode = editorWin64
|
|
.AddNode(x => CompileUnrealEditorWin64Async(x, crashReporterCompileArgs, embedSrcSrvInfo, compileDatasmithPlugins, withFullDebugInfo, signExecutables))
|
|
.Requires(versionFilesNode);
|
|
|
|
aggregates.Add(new BgAggregate("Win64 Editor", winEditorNode, label: "Editors/Win64"));
|
|
|
|
/////// TARGET PLATFORMS ////////////////////////////////////////////////
|
|
|
|
//// Win64 ////
|
|
|
|
BgAgent targetWin64 = new BgAgent("Target Win64", "Win64_Licensee");
|
|
|
|
BgNode<BgFileSet> winGame = targetWin64
|
|
.AddNode(x => CompileUnrealGameWin64Async(x, gameConfigurations, embedSrcSrvInfo, withFullDebugInfo, signExecutables))
|
|
.Requires(versionFilesNode);
|
|
|
|
aggregates.Add(new BgAggregate("TargetPlatforms_Win64", winGame));
|
|
|
|
/////// TOOLS //////////////////////////////////////////////////////////
|
|
|
|
//// Build Rules ////
|
|
|
|
BgAgent buildRules = new BgAgent("BuildRules", "Win64_Licensee");
|
|
|
|
BgNode rulesAssemblies = buildRules
|
|
.AddNode(x => CompileRulesAssembliesAsync(x));
|
|
|
|
//// Win Tools ////
|
|
|
|
BgAgent toolsGroupWin64 = new BgAgent("Tools Group Win64", "Win64_Licensee");
|
|
|
|
BgNode<BgFileSet> winTools = toolsGroupWin64
|
|
.AddNode(x => BuildToolsWin64Async(x, crashReporterCompileArgs))
|
|
.Requires(versionFilesNode);
|
|
|
|
BgNode<BgFileSet> csTools = toolsGroupWin64
|
|
.AddNode(x => BuildToolsCsAsync(x, signExecutables))
|
|
.Requires(versionFilesNode);
|
|
|
|
/////// DDC //////////////////////////////////////////////////////////
|
|
|
|
BgAgent ddcGroupWin64 = new BgAgent("DDC Group Win64", "Win64_Licensee");
|
|
|
|
BgList<BgString> ddcPlatformsWin64 = BgList<BgString>.Create("WindowsEditor");
|
|
ddcPlatformsWin64 = ddcPlatformsWin64.If(withWin64, x => x.Add("Windows"));
|
|
|
|
BgNode ddcNode = ddcGroupWin64
|
|
.AddNode(x => BuildDdcWin64Async(x, ddcPlatformsWin64, BgList<BgFileSet>.Create(winEditorNode.Output, winTools.Output)))
|
|
.Requires(winEditorNode, winTools);
|
|
|
|
/////// STAGING ///////
|
|
|
|
// Windows
|
|
BgAgent winStageAgent = new BgAgent("Installed Build Group Win64", "Win64_Licensee");
|
|
|
|
BgList<BgFileSet> winInstalledFiles = BgList<BgFileSet>.Empty;
|
|
winInstalledFiles = winInstalledFiles.Add(winEditorNode.Output);
|
|
winInstalledFiles = winInstalledFiles.Add(winTools.Output);
|
|
winInstalledFiles = winInstalledFiles.Add(csTools.Output);
|
|
winInstalledFiles = winInstalledFiles.If(withWin64, x => x.Add(winGame.Output));
|
|
|
|
BgList<BgString> winPlatforms = BgList<BgString>.Empty;
|
|
winPlatforms = winPlatforms.If(withWin64, x => x.Add("Win64"));
|
|
|
|
BgList<BgString> winContentOnlyPlatforms = BgList<BgString>.Empty;
|
|
|
|
BgString winOutputDir = "LocalBuilds/Engine/Windows";
|
|
BgString winFinalizeArgs = BgString.Format("-OutputDir=\"{0}\" -Platforms={1} -ContentOnlyPlatforms={2}", winOutputDir, BgString.Join(";", winPlatforms), BgString.Join(";", winContentOnlyPlatforms));
|
|
|
|
BgNode winInstalledNode = winStageAgent
|
|
.AddNode(x => MakeInstalledBuildWin64Async(x, winInstalledFiles, winFinalizeArgs, winOutputDir))
|
|
.Requires(winInstalledFiles);
|
|
|
|
aggregates.Add(new BgAggregate("HostPlatforms_Win64", winInstalledNode, label: "Builds/Win64"));
|
|
|
|
return new BgGraph(BgList<BgNode>.Empty, aggregates);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update the build version
|
|
/// </summary>
|
|
static async Task UpdateVersionFilesAsync(BgContext state)
|
|
{
|
|
if (state.IsBuildMachine)
|
|
{
|
|
await SetVersionAsync(state.Change, state.Stream.Replace('/', '+'));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Builds the Windows editor
|
|
/// </summary>
|
|
[BgNodeName("Compile UnrealEditor Win64")]
|
|
static async Task<BgFileSet> CompileUnrealEditorWin64Async(BgContext state, BgString crashReporterCompileArgs, BgBool embedSrcSrvInfo, BgBool compileDatasmithPlugins, BgBool withFullDebugInfo, BgBool signExecutables)
|
|
{
|
|
_ = compileDatasmithPlugins;
|
|
|
|
FileSet outputFiles = FileSet.Empty;
|
|
outputFiles += await CompileAsync("UnrealEditor", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.DebugGame, arguments: $"-precompile -allmodules {state.Get(crashReporterCompileArgs)}");
|
|
outputFiles += await CompileAsync("UnrealEditor", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development, arguments: $"-precompile -allmodules {state.Get(crashReporterCompileArgs)}");
|
|
|
|
if (state.Get(embedSrcSrvInfo))
|
|
{
|
|
// Embed source info into the PDB files. Should be done from this machine to ensure that paths are correct.
|
|
Logger.LogInformation("Embedding source file information into PDB files...");
|
|
FileSet sourceFiles = Workspace.Filter("Engine/Source/...;Engine/Plugins/...").Except("Engine/Source/ThirdParty/...").Filter("*.c;*.h;*.cpp;*.hpp;*.inl");
|
|
// State.SrcSrv(BinaryFiles: Full, SourceFiles: SourceFiles);
|
|
_ = sourceFiles;
|
|
}
|
|
|
|
if (!state.Get(withFullDebugInfo))
|
|
{
|
|
FileSet unstrippedFiles = outputFiles.Filter(s_winStripFilter);
|
|
outputFiles += await StripAsync(unstrippedFiles, UnrealTargetPlatform.Win64, baseDir: RootDir, outputDir: TempMiscDir);
|
|
outputFiles -= unstrippedFiles;
|
|
}
|
|
|
|
if (state.Get(signExecutables))
|
|
{
|
|
// FileSet UnsignedFiles = OutputFiles.Filter(WinSignFilter);
|
|
// FileSet FilesToCopy = UnsignedFiles.Except((new HashSet<FileReference>(UnsignedFiles.Where(x => !x.IsUnderDirectory(TempMiscDir)));
|
|
// UnsignedFiles += State.Copy(FilesToCopy.Flatten(TempMiscDir));
|
|
// UnsignedFiles.Sign();
|
|
// OutputFiles -= FilesToCopy;
|
|
// OutputFiles += UnsignedFiles;
|
|
}
|
|
|
|
return outputFiles;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Builds the game target
|
|
/// </summary>
|
|
[BgNodeName("Compile UnrealGame Win64")]
|
|
static async Task<BgFileSet> CompileUnrealGameWin64Async(BgContext state, BgList<BgEnum<UnrealTargetConfiguration>> configurations, BgBool embedSrcSrvInfo, BgBool withFullDebugInfo, BgBool signExecutables)
|
|
{
|
|
_ = embedSrcSrvInfo;
|
|
_ = withFullDebugInfo;
|
|
_ = signExecutables;
|
|
|
|
FileSet files = FileSet.Empty;
|
|
|
|
List<UnrealTargetConfiguration> configurationsValue = state.Get(configurations);
|
|
foreach (UnrealTargetConfiguration configuration in configurationsValue)
|
|
{
|
|
files += await CompileAsync("UnrealGame", UnrealTargetPlatform.Win64, configuration, arguments: "-precompile -allmodules -nolink");
|
|
files += await CompileAsync("UnrealGame", UnrealTargetPlatform.Win64, configuration, arguments: "-precompile", clean: false);
|
|
}
|
|
|
|
return files;
|
|
}
|
|
|
|
static async Task<BgFileSet> CompileRulesAssembliesAsync(BgContext state)
|
|
{
|
|
_ = state;
|
|
|
|
FileReference unrealBuildToolDll = FileReference.Combine(RootDir, "Engine/Binaries/DotNET/UnrealBuildTool/UnrealBuildTool.dll");
|
|
|
|
await SpawnAsync(Unreal.DotnetPath.FullName, arguments: $"\"{unrealBuildToolDll}\" -Mode=QueryTargets");
|
|
|
|
return Workspace.Filter("Engine/Intermediate/Build/BuildRules/...");
|
|
}
|
|
|
|
static async Task<BgFileSet> BuildToolsWin64Async(BgContext state, BgString crashReporterCompileArgs)
|
|
{
|
|
string crashReportClientArgs = state.Get(crashReporterCompileArgs);
|
|
|
|
// State.Tag(Files: "#NotForLicensee Build Tools Win64", With: Files);
|
|
|
|
FileSet files = FileSet.Empty;
|
|
files += await CompileAsync("CrashReportClient", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Shipping, arguments: crashReportClientArgs);
|
|
files += await CompileAsync("CrashReportClientEditor", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Shipping, arguments: crashReportClientArgs);
|
|
files += await CompileAsync("ShaderCompileWorker", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
|
|
files += await CompileAsync("EpicWebHelper", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
|
|
files += await CompileAsync("UnrealInsights", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
|
|
files += await CompileAsync("UnrealFrontend", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
|
|
files += await CompileAsync("UnrealLightmass", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
|
|
files += await CompileAsync("InterchangeWorker", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
|
|
files += await CompileAsync("UnrealPak", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
|
|
files += await CompileAsync("UnrealMultiUserServer", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
|
|
files += await CompileAsync("UnrealRecoverySvc", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
|
|
files += await CompileAsync("LiveCodingConsole", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
|
|
files += await CompileAsync("BootstrapPackagedGame", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Shipping);
|
|
files += await CompileAsync("BuildPatchTool", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Shipping);
|
|
files += await CompileAsync("SwitchboardListener", UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
|
|
files += FileSet.FromFile(RootDir, "Engine/Binaries/Win64/XGEControlWorker.exe");
|
|
files += FileSet.FromFile(RootDir, "Engine/Saved/UnrealBuildTool/BuildConfiguration.Schema.xsd");
|
|
|
|
return files;
|
|
}
|
|
|
|
[BgNodeName("Build Tools CS")]
|
|
static async Task<BgFileSet> BuildToolsCsAsync(BgContext state, BgBool signExecutables)
|
|
{
|
|
FileUtils.ForceDeleteDirectory(TempCsToolsDir);
|
|
|
|
// Copy Source and referenced libraries to a new location with Confidential folders removed
|
|
FileSet uatProjects = Workspace.Filter("Engine/Source/Programs/AutomationTool/....csproj");
|
|
_ = uatProjects;
|
|
|
|
FileSet redistUatSource = Workspace.Filter("Engine/Binaries/DotNET/...;Engine/Binaries/ThirdParty/Newtonsoft/...;Engine/Binaries/ThirdParty/IOS/...;Engine/Binaries/ThirdParty/VisualStudio/...;Engine/Source/Programs/...;Engine/Platforms/*/Source/Programs/...;Engine/Source/Editor/SwarmInterface/...");
|
|
await redistUatSource.CopyToAsync(Unreal.RootDirectory);
|
|
|
|
// Compile all the tools
|
|
CsCompileOutput output = CsCompileOutput.Empty;
|
|
if (HostPlatform.Current.HostEditorPlatform == UnrealTargetPlatform.Win64)
|
|
{
|
|
output += await CsCompileAsync(FileReference.Combine(TempCsToolsDir, "Engine/Source/Programs/UnrealSwarm/SwarmCoordinator/SwarmCoordinator.csproj"), platform: "AnyCPU", configuration: "Development");
|
|
output += await CsCompileAsync(FileReference.Combine(TempCsToolsDir, "Engine/Source/Programs/UnrealSwarm/Agent/Agent.csproj"), platform: "AnyCPU", configuration: "Development");
|
|
output += await CsCompileAsync(FileReference.Combine(TempCsToolsDir, "Engine/Source/Editor/SwarmInterface/DotNET/SwarmInterface.csproj"), platform: "AnyCPU", configuration: "Development");
|
|
output += await CsCompileAsync(FileReference.Combine(TempCsToolsDir, "Engine/Source/Programs/UnrealControls/UnrealControls.csproj"), platform: "AnyCPU", configuration: "Development");
|
|
output += await CsCompileAsync(FileReference.Combine(TempCsToolsDir, "Engine/Source/Programs/IOS/iPhonePackager/iPhonePackager.csproj"), platform: "AnyCPU", configuration: "Development", arguments: "/verbosity:minimal /target:Rebuild");
|
|
output += await CsCompileAsync(FileReference.Combine(TempCsToolsDir, "Engine/Source/Programs/NetworkProfiler/NetworkProfiler/NetworkProfiler.csproj"), platform: "AnyCPU", configuration: "Development");
|
|
}
|
|
|
|
FileSet binaries = output.Binaries + output.References;
|
|
|
|
// Tag AutomationTool and UnrealBuildTool folders recursively as NET Core dependencies are not currently handled by CsCompile
|
|
binaries += FileSet.FromDirectory(TempCsToolsDir).Filter("Engine/Binaries/DotNET/AutomationTool/...");
|
|
binaries += FileSet.FromDirectory(TempCsToolsDir).Filter("Engine/Binaries/DotNET/UnrealBuildTool/...");
|
|
|
|
// Tag AutomationTool Script module build records, so that prebuilt modules may be discovered in the absence of source code
|
|
binaries += FileSet.FromDirectory(TempCsToolsDir).Filter("Engine/Intermediate/ScriptModules/...");
|
|
|
|
if (state.Get(signExecutables))
|
|
{
|
|
// Binaries.Sign();
|
|
}
|
|
|
|
return binaries;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a DDC pack file for the supported platforms
|
|
/// </summary>
|
|
[BgNodeName("Build DDC Win64")]
|
|
static async Task<BgFileSet> BuildDdcWin64Async(BgContext state, BgList<BgString> platforms, BgList<BgFileSet> dependencies)
|
|
{
|
|
// Build up a list of files needed to build DDC
|
|
FileSet toCopy = state.Get(dependencies);
|
|
toCopy += await CsCompileAsync(FileReference.Combine(RootDir, "Engine/Source/Programs/UnrealBuildTool/UnrealBuildTool.csproj"), platform: "AnyCPU", configuration: "Development", enumerateOnly: true).MergeAsync();
|
|
toCopy += await toCopy.Filter("*.target").TagReceiptsAsync(runtimeDependencies: true);
|
|
toCopy += FileSet.FromFile(RootDir, "Engine/Binaries/DotNET/Ionic.Zip.Reduced.dll");
|
|
toCopy += FileSet.FromFile(RootDir, "Engine/Binaries/DotNET/OneSky.dll");
|
|
toCopy += FileSet.FromDirectory(RootDir).Filter("Templates/TemplateResources/...");
|
|
|
|
foreach (DirectoryReference extensionDir in Unreal.GetExtensionDirs(Unreal.EngineDirectory))
|
|
{
|
|
toCopy += FileSet.FromDirectory(extensionDir).Filter("Content/...").Except("....psd;....pdn;....fbx;....po");
|
|
toCopy += FileSet.FromDirectory(extensionDir).Filter("Config/...").Except("....vdf");
|
|
toCopy += FileSet.FromDirectory(extensionDir).Filter("Shaders/...");
|
|
|
|
DirectoryReference extensionPluginsDir = DirectoryReference.Combine(extensionDir, "Plugins");
|
|
toCopy += FileSet.FromDirectory(extensionPluginsDir).Filter("....uplugin;.../Config/...;.../Content/...;.../Resources/...;.../Shaders/...;.../Templates/...").Except(".../TwitchLiveStreaming/...");
|
|
}
|
|
|
|
// Filter out the files not needed to build DDC. Removing confidential folders can affect DDC keys, so we want to be sure that we're making DDC with a build that can use it.
|
|
FileSet filteredCopyList = toCopy.Except(".../Source/...;.../Intermediate/...");
|
|
|
|
Dictionary<FileReference, FileReference> targetFileToSourceFile = new Dictionary<FileReference, FileReference>();
|
|
MapFilesToOutputDir(filteredCopyList, TempDdcDir, targetFileToSourceFile);
|
|
|
|
FileUtils.ForceDeleteDirectoryContents(TempDdcDir);
|
|
await filteredCopyList.CopyToAsync(TempDdcDir);
|
|
|
|
// Run the DDC commandlet
|
|
List<string> arguments = new List<string>();
|
|
arguments.Add($"-TempDir=\"{TempDdcDir}\"");
|
|
arguments.Add($"-FeaturePacks=\"{String.Join(";", GetDdcProjects(UnrealTargetPlatform.Win64))}\"");
|
|
arguments.Add($"-TargetPlatforms={String.Join("+", state.Get(platforms))}");
|
|
arguments.Add($"-HostPlatform=Win64");
|
|
await state.CommandAsync("BuildDerivedDataCache", arguments: String.Join(" ", arguments));
|
|
|
|
// Return a tag for the output file
|
|
return FileSet.FromFile(TempDdcDir, "Engine/DerivedDataCache/Compressed.ddp");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copy all the build artifacts to the output folder
|
|
/// </summary>
|
|
[BgNodeName("Make Installed Build Win64")]
|
|
static async Task<BgFileSet> MakeInstalledBuildWin64Async(BgContext state, BgList<BgFileSet> inputFiles, BgString finalizeArgs, BgString outputDir)
|
|
{
|
|
// Find all the input files, and add any runtime dependencies from the receipts into the list
|
|
FileSet sourceFiles = state.Get(inputFiles);
|
|
sourceFiles += await sourceFiles.Filter("*.target").TagReceiptsAsync(runtimeDependencies: true);
|
|
|
|
// Include any files referenced by dependency lists
|
|
FileSet dependencyListFiles = sourceFiles.Filter(".../DependencyList.txt;.../DependencyList-AllModules.txt");
|
|
foreach (FileReference dependencyListFile in dependencyListFiles)
|
|
{
|
|
string[] lines = await FileReference.ReadAllLinesAsync(dependencyListFile);
|
|
foreach (string line in lines)
|
|
{
|
|
string trimLine = line.Trim();
|
|
if (trimLine.Length > 0)
|
|
{
|
|
sourceFiles += FileSet.FromFile(Unreal.RootDirectory, trimLine);
|
|
}
|
|
}
|
|
}
|
|
sourceFiles -= dependencyListFiles;
|
|
|
|
// Clear the output directory
|
|
DirectoryReference outputDirRef = new DirectoryReference(state.Get(outputDir));
|
|
FileUtils.ForceDeleteDirectoryContents(outputDirRef);
|
|
FileSet installedFiles = await sourceFiles.CopyToAsync(outputDirRef);
|
|
|
|
// Run the finalize command
|
|
await state.CommandAsync("FinalizeInstalledBuild", arguments: state.Get(finalizeArgs));
|
|
|
|
// Get the final list of files
|
|
installedFiles += FileSet.FromFile(outputDirRef, "Engine/Build/InstalledEngine.txt");
|
|
|
|
// Sanitize any receipts in the output directory
|
|
await installedFiles.Filter("*.target").SanitizeReceiptsAsync();
|
|
|
|
return installedFiles;
|
|
}
|
|
|
|
static void MapFilesToOutputDir(IEnumerable<FileReference> sourceFiles, DirectoryReference targetDir, Dictionary<FileReference, FileReference> targetFileToSourceFile)
|
|
{
|
|
foreach (FileReference sourceFile in sourceFiles)
|
|
{
|
|
DirectoryReference baseDir;
|
|
if (sourceFile.IsUnderDirectory(TempCsToolsDir))
|
|
{
|
|
baseDir = TempCsToolsDir;
|
|
}
|
|
else if (sourceFile.IsUnderDirectory(TempMiscDir))
|
|
{
|
|
baseDir = TempMiscDir;
|
|
}
|
|
else if (sourceFile.IsUnderDirectory(TempDdcDir))
|
|
{
|
|
baseDir = TempDdcDir;
|
|
}
|
|
else
|
|
{
|
|
baseDir = Unreal.RootDirectory;
|
|
}
|
|
|
|
FileReference targetFile = FileReference.Combine(targetDir, sourceFile.MakeRelativeTo(baseDir));
|
|
targetFileToSourceFile[targetFile] = sourceFile;
|
|
}
|
|
}
|
|
}
|
|
}
|