public UATTestNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, string InTestName, string InUATCommandLine, bool InDependsOnEditor = true, List<UnrealTargetPlatform> InDependsOnCooked = null, bool bInExposeToEC = false, float InECPriority = 0.0f)
: base(InHostPlatform)
{
bExposeToEC = bInExposeToEC;
ECPriority = InECPriority;
GameProj = InGameProj;
TestName = InTestName;
UATCommandLine = InUATCommandLine;
bool bWillCook = InUATCommandLine.IndexOf("-cook") >= 0;
DependsOnEditor = InDependsOnEditor || bWillCook;
if (InDependsOnCooked != null)
{
DependsOnCooked = InDependsOnCooked;
}
else
{
DependsOnCooked = new List<UnrealTargetPlatform>();
}
if (DependsOnEditor)
{
AddDependency(EditorAndToolsNode.StaticGetFullName(HostPlatform));
if (GameProj.GameName != bp.Branch.BaseEngineProject.GameName)
{
if (GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj));
}
}
}
foreach (var Plat in DependsOnCooked)
{
AddDependency(GamePlatformCookedAndCompiledNode.StaticGetFullName(HostPlatform, GameProj, Plat));
if (bWillCook && Plat != HostPlatform && Plat != GUBP.GetAltHostPlatform(HostPlatform))
{
AddDependency(EditorPlatformNode.StaticGetFullName(HostPlatform, Plat));
}
}
if (!bp.bWide)
{
var Options = InGameProj.Options(HostPlatform);
if (Options.bSeparateGamePromotion)
{
AddPseudodependency(GameLabelPromotableNode.StaticGetFullName(GameProj, false));
}
else
{
AddPseudodependency(WaitForTestShared.StaticGetFullName());
}
}
if (InGameProj.GameName == bp.Branch.BaseEngineProject.GameName)
{
ECPriority = ECPriority + 1.0f;
}
if (UATCommandLine.IndexOf("-RunAutomationTests", StringComparison.InvariantCultureIgnoreCase) >= 0)
{
ECPriority = ECPriority - 4.0f;
if (UATCommandLine.IndexOf("-EditorTest", StringComparison.InvariantCultureIgnoreCase) >= 0)
{
ECPriority = ECPriority - 4.0f;
}
}
else if (UATCommandLine.IndexOf("-EditorTest", StringComparison.InvariantCultureIgnoreCase) >= 0)
{
ECPriority = ECPriority + 2.0f;
}
}
public GameLabelPromotableNode(GUBP bp, BranchInfo.BranchUProject InGameProj, bool bInLabelPromoted)
: base(InGameProj.GameName, bInLabelPromoted)
{
GameProj = InGameProj;
}
public GamePlatformMonolithicsNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform)
: base(InHostPlatform)
{
GameProj = InGameProj;
TargetPlatform = InTargetPlatform;
if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
AddPseudodependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj));
AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, TargetPlatform));
}
else
{
AddPseudodependency(RootEditorNode.StaticGetFullName(HostPlatform));
if (TargetPlatform != HostPlatform)
{
AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, HostPlatform));
}
}
if (InGameProj.Options(HostPlatform).bTestWithShared) /// compiling templates is only for testing purposes
{
AddPseudodependency(WaitForTestShared.StaticGetFullName());
}
}
public UATTestNode(GUBPBranchConfig BranchConfig, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, string InTestName, string InUATCommandLine, string InAgentSharingGroup, bool InDependsOnEditor = true, List<UnrealTargetPlatform> InDependsOnCooked = null, float InECPriority = 0.0f)
: base(InHostPlatform)
{
AgentSharingGroup = InAgentSharingGroup;
ECPriority = InECPriority;
GameProj = InGameProj;
TestName = InTestName;
UATCommandLine = InUATCommandLine;
bool bWillCook = InUATCommandLine.IndexOf("-cook") >= 0;
DependsOnEditor = InDependsOnEditor || bWillCook;
if (InDependsOnCooked != null)
{
DependsOnCooked = InDependsOnCooked;
}
else
{
DependsOnCooked = new List<UnrealTargetPlatform>();
}
if (DependsOnEditor)
{
AddDependency(EditorAndToolsNode.StaticGetFullName(HostPlatform));
if (GameProj.GameName != BranchConfig.Branch.BaseEngineProject.GameName)
{
if (GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj));
}
}
}
foreach (var Plat in DependsOnCooked)
{
AddDependency(GamePlatformCookedAndCompiledNode.StaticGetFullName(HostPlatform, GameProj, Plat));
}
AddPseudodependency(WaitForTestShared.StaticGetFullName());
// If the same test fails for the base engine, don't bother trying
if (InGameProj.GameName != BranchConfig.Branch.BaseEngineProject.GameName)
{
if (BranchConfig.HasNode(UATTestNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, TestName)))
{
AddPseudodependency(UATTestNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, InTestName));
}
else
{
bool bFoundACook = false;
foreach (var Plat in DependsOnCooked)
{
var PlatTestName = "CookedGameTest_" + Plat.ToString();
if (BranchConfig.HasNode(UATTestNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, PlatTestName)))
{
AddPseudodependency(UATTestNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, PlatTestName));
bFoundACook = true;
}
}
if (!bFoundACook && BranchConfig.HasNode(UATTestNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, "EditorTest")))
{
AddPseudodependency(UATTestNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, "EditorTest"));
}
}
}
if (InGameProj.GameName == BranchConfig.Branch.BaseEngineProject.GameName)
{
ECPriority = ECPriority + 1.0f;
}
if (UATCommandLine.IndexOf("-RunAutomationTests", StringComparison.InvariantCultureIgnoreCase) >= 0)
{
ECPriority = ECPriority - 4.0f;
if (UATCommandLine.IndexOf("-EditorTest", StringComparison.InvariantCultureIgnoreCase) >= 0)
{
ECPriority = ECPriority - 4.0f;
}
}
else if (UATCommandLine.IndexOf("-EditorTest", StringComparison.InvariantCultureIgnoreCase) >= 0)
{
ECPriority = ECPriority + 2.0f;
}
}
public GameLabelPromotableNode(GUBP.GUBPBranchConfig InBranchConfig, BranchInfo.BranchUProject InGameProj, bool bInLabelPromoted)
: base(InBranchConfig, InGameProj.GameName, "", bInLabelPromoted)
{
GameProj = InGameProj;
}
public CookNode(GUBPBranchConfig BranchConfig, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform, string InCookPlatform)
: base(InHostPlatform)
{
GameProj = InGameProj;
TargetPlatform = InTargetPlatform;
CookPlatform = InCookPlatform;
bIsMassive = false;
AddDependency(EditorAndToolsNode.StaticGetFullName(HostPlatform));
bool bIsShared = false;
// is this the "base game" or a non code project?
if (InGameProj.GameName != BranchConfig.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
var Options = InGameProj.Options(HostPlatform);
bIsMassive = Options.bIsMassive;
AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj));
// add an arc to prevent cooks from running until promotable is labeled
if (Options.bIsPromotable)
{
if (!Options.bSeparateGamePromotion)
{
bIsShared = true;
}
}
else if (Options.bTestWithShared)
{
bIsShared = true;
}
if (!BranchConfig.BranchOptions.bNoMonolithicDependenciesForCooks)
{
AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, TargetPlatform));
}
}
else
{
bIsShared = true;
AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, TargetPlatform));
}
if (bIsShared)
{
// add an arc to prevent cooks from running until promotable is labeled
AddPseudodependency(WaitForTestShared.StaticGetFullName());
AgentSharingGroup = "SharedCooks" + StaticGetHostPlatformSuffix(HostPlatform);
// If the cook fails for the base engine, don't bother trying
if (InGameProj.GameName != BranchConfig.Branch.BaseEngineProject.GameName && BranchConfig.HasNode(CookNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, CookPlatform)))
{
AddPseudodependency(CookNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, CookPlatform));
}
// If the base cook platform fails, don't bother trying other ones
string BaseCookedPlatform = Platform.Platforms[HostPlatform].GetCookPlatform(false, false, "");
if (InGameProj.GameName == BranchConfig.Branch.BaseEngineProject.GameName && CookPlatform != BaseCookedPlatform &&
BranchConfig.HasNode(CookNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, BaseCookedPlatform)))
{
AddPseudodependency(CookNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, BaseCookedPlatform));
}
}
if(GamePlatformMonolithicsNode.IsSample(BranchConfig, GameProj))
{
AddDependency(WaitToPackageSamplesNode.StaticGetFullName());
AgentSharingGroup = "SampleCooks" + StaticGetHostPlatformSuffix(HostPlatform);
}
}
public FormalBuildNode(GUBP.GUBPBranchConfig InBranchConfig,
BranchInfo.BranchUProject InGameProj,
UnrealTargetPlatform InHostPlatform,
List<UnrealTargetPlatform> InClientTargetPlatforms = null,
List<UnrealTargetConfiguration> InClientConfigs = null,
List<UnrealTargetPlatform> InServerTargetPlatforms = null,
List<UnrealTargetConfiguration> InServerConfigs = null,
bool InClientNotGame = false
)
: base(InHostPlatform)
{
BranchConfig = InBranchConfig;
GameProj = InGameProj;
ClientTargetPlatforms = InClientTargetPlatforms;
ServerTargetPlatforms = InServerTargetPlatforms;
ClientConfigs = InClientConfigs;
ServerConfigs = InServerConfigs;
ClientNotGame = InClientNotGame;
GameOrClient = TargetRules.TargetType.Game;
if (ClientNotGame)
{
GameOrClient = TargetRules.TargetType.Client;
}
if (InGameProj.GameName != BranchConfig.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
bIsCode = true;
}
else
{
bIsCode = false;
}
// verify we actually built these
var WorkingGameProject = InGameProj;
if (!WorkingGameProject.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
// this is a codeless project, use the base project
WorkingGameProject = BranchConfig.Branch.BaseEngineProject;
}
var AllTargetPlatforms = new List<UnrealTargetPlatform>();
if (ClientTargetPlatforms != null)
{
if (!WorkingGameProject.Properties.Targets.ContainsKey(GameOrClient))
{
throw new AutomationException("Can't make a game build for {0} because it doesn't have a {1} target.", WorkingGameProject.GameName, GameOrClient.ToString());
}
foreach (var Plat in ClientTargetPlatforms)
{
if (!AllTargetPlatforms.Contains(Plat))
{
AllTargetPlatforms.Add(Plat);
}
}
if (ClientConfigs == null)
{
ClientConfigs = new List<UnrealTargetConfiguration>() { UnrealTargetConfiguration.Development };
}
foreach (var Plat in ClientTargetPlatforms)
{
if (!WorkingGameProject.Properties.Targets[GameOrClient].Rules.GUBP_GetPlatforms_MonolithicOnly(HostPlatform).Contains(Plat))
{
throw new AutomationException("Can't make a game/client build for {0} because we didn't build platform {1}.", WorkingGameProject.GameName, Plat.ToString());
}
foreach (var Config in ClientConfigs)
{
if (!WorkingGameProject.Properties.Targets[GameOrClient].Rules.GUBP_GetConfigs_MonolithicOnly(HostPlatform, Plat).Contains(Config))
{
throw new AutomationException("Can't make a game/client build for {0} because we didn't build platform {1} config {2}.", WorkingGameProject.GameName, Plat.ToString(), Config.ToString());
}
}
}
}
if (ServerTargetPlatforms != null)
{
if (!WorkingGameProject.Properties.Targets.ContainsKey(TargetRules.TargetType.Server) && ServerTargetPlatforms != null)
{
throw new AutomationException("Can't make a server build for {0} because it doesn't have a server target.", WorkingGameProject.GameName);
}
foreach (var Plat in ServerTargetPlatforms)
{
if (!AllTargetPlatforms.Contains(Plat))
{
AllTargetPlatforms.Add(Plat);
}
}
if (ServerConfigs == null)
{
ServerConfigs = new List<UnrealTargetConfiguration>() { UnrealTargetConfiguration.Development };
}
foreach (var Plat in ServerTargetPlatforms)
{
if (!WorkingGameProject.Properties.Targets[TargetRules.TargetType.Server].Rules.GUBP_GetPlatforms_MonolithicOnly(HostPlatform).Contains(Plat))
{
throw new AutomationException("Can't make a server build for {0} because we didn't build platform {1}.", WorkingGameProject.GameName, Plat.ToString());
}
foreach (var Config in ServerConfigs)
{
if (!WorkingGameProject.Properties.Targets[TargetRules.TargetType.Server].Rules.GUBP_GetConfigs_MonolithicOnly(HostPlatform, Plat).Contains(Config))
{
throw new AutomationException("Can't make a server build for {0} because we didn't build platform {1} config {2}.", WorkingGameProject.GameName, Plat.ToString(), Config.ToString());
}
}
}
}
// add dependencies for cooked and compiled
foreach (var Plat in AllTargetPlatforms)
{
AddDependency(GamePlatformCookedAndCompiledNode.StaticGetFullName(HostPlatform, GameProj, Plat));
}
}
public GamePlatformCookedAndCompiledNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform, bool bCodeProject)
: base(InHostPlatform)
{
GameProj = InGameProj;
TargetPlatform = InTargetPlatform;
foreach (var Kind in BranchInfo.MonolithicKinds)
{
if (bCodeProject)
{
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))
{
//@todo how do we get the client target platform?
string CookedPlatform = Platform.Platforms[TargetPlatform].GetCookPlatform(Kind == TargetRules.TargetType.Server, Kind == TargetRules.TargetType.Client, "");
if (Target.Rules.GUBP_AlternateCookPlatform(HostPlatform, CookedPlatform) != "")
{
CookedPlatform = Target.Rules.GUBP_AlternateCookPlatform(HostPlatform, CookedPlatform);
}
AddDependency(CookNode.StaticGetFullName(HostPlatform, GameProj, CookedPlatform));
AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, TargetPlatform));
if(Target.Rules.GUBP_BuildWindowsXPMonolithics())
{
AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, TargetPlatform, true));
}
}
}
}
else
{
if (Kind == TargetRules.TargetType.Game) //for now, non-code projects don't do client or server.
{
if (bp.Branch.BaseEngineProject.Properties.Targets.ContainsKey(Kind))
{
var Target = bp.Branch.BaseEngineProject.Properties.Targets[Kind];
var Platforms = Target.Rules.GUBP_GetPlatforms_MonolithicOnly(HostPlatform);
if (Platforms.Contains(TargetPlatform) && Target.Rules.SupportsPlatform(TargetPlatform))
{
//@todo how do we get the client target platform?
string CookedPlatform = Platform.Platforms[TargetPlatform].GetCookPlatform(Kind == TargetRules.TargetType.Server, Kind == TargetRules.TargetType.Client, "");
AddDependency(CookNode.StaticGetFullName(HostPlatform, GameProj, CookedPlatform));
AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, TargetPlatform));
}
}
}
}
}
// put these in the right agent group, even though they aren't exposed to EC to sort right.
if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
var Options = InGameProj.Options(HostPlatform);
if ((Options.bIsPromotable || Options.bTestWithShared) && !Options.bSeparateGamePromotion)
{
AgentSharingGroup = "SharedCooks" + StaticGetHostPlatformSuffix(HostPlatform);
}
}
else
{
AgentSharingGroup = "SharedCooks" + StaticGetHostPlatformSuffix(HostPlatform);
}
}
public WaitForGamePromotionUserInput(GUBP bp, BranchInfo.BranchUProject InGameProj, bool bInLabelPromoted)
: base(InGameProj.GameName, "", bInLabelPromoted)
{
GameProj = InGameProj;
var Options = InGameProj.Options(UnrealTargetPlatform.Win64);
bCustomWorkflow = Options.bCustomWorkflowForPromotion;
}
public DDCNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform, string InCookPlatform)
: base(InHostPlatform)
{
GameProj = InGameProj;
TargetPlatform = InTargetPlatform;
CookPlatform = InCookPlatform;
bIsMassive = false;
AddDependency(RootEditorNode.StaticGetFullName(HostPlatform));
if (bp.bOrthogonalizeEditorPlatforms)
{
if (TargetPlatform != HostPlatform && TargetPlatform != GUBP.GetAltHostPlatform(HostPlatform))
{
AddDependency(EditorPlatformNode.StaticGetFullName(HostPlatform, TargetPlatform));
}
}
bool bIsShared = false;
// is this the "base game" or a non code project?
if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
var Options = InGameProj.Options(HostPlatform);
bIsMassive = Options.bIsMassive;
AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj));
// add an arc to prevent DDCNode from running until promotable is labeled
if (Options.bIsPromotable)
{
if (Options.bSeparateGamePromotion)
{
// AddPseudodependency(GameLabelPromotableNode.StaticGetFullName(GameProj, false));
}
else
{
bIsShared = true;
}
}
else if (Options.bTestWithShared)
{
bIsShared = true;
}
//AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, TargetPlatform));
}
else
{
bIsShared = true;
//AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, TargetPlatform));
}
if (bIsShared)
{
// add an arc to prevent cooks from running until promotable is labeled
//AddPseudodependency(WaitForTestShared.StaticGetFullName());
//AgentSharingGroup = "SharedCooks" + StaticGetHostPlatformSuffix(HostPlatform);
// If the cook fails for the base engine, don't bother trying
if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && bp.HasNode(DDCNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, CookPlatform)))
{
//AddPseudodependency(DDCNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, CookPlatform));
}
// If the base cook platform fails, don't bother trying other ones
string BaseCookedPlatform = Platform.Platforms[HostPlatform].GetCookPlatform(false, false, "");
if (InGameProj.GameName == bp.Branch.BaseEngineProject.GameName && CookPlatform != BaseCookedPlatform &&
bp.HasNode(DDCNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, BaseCookedPlatform)))
{
//AddPseudodependency(DDCNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, BaseCookedPlatform));
}
}
}
public GameAggregatePromotableNode(GUBP bp, List<UnrealTargetPlatform> InHostPlatforms, BranchInfo.BranchUProject InGameProj, bool IsSeparate)
: base(InHostPlatforms, InGameProj.GameName)
{
GameProj = InGameProj;
foreach (var HostPlatform in HostPlatforms)
{
AddDependency(RootEditorNode.StaticGetFullName(HostPlatform));
if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj));
}
// add all of the platforms I use
{
var Platforms = bp.GetMonolithicPlatformsForUProject(HostPlatform, InGameProj, false);
if (bp.bOrthogonalizeEditorPlatforms)
{
foreach (var Plat in Platforms)
{
AddDependency(EditorPlatformNode.StaticGetFullName(HostPlatform, Plat));
}
}
}
{
if (!GameProj.Options(HostPlatform).bPromoteEditorOnly)
{
var Platforms = bp.GetMonolithicPlatformsForUProject(HostPlatform, InGameProj, true);
foreach (var Plat in Platforms)
{
AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, Plat));
if (Plat == UnrealTargetPlatform.Win32 && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Game))
{
if (GameProj.Properties.Targets[TargetRules.TargetType.Game].Rules.GUBP_BuildWindowsXPMonolithics())
{
AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, Plat, true));
}
}
}
}
}
}
}
public GamePlatformMonolithicsNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform, bool InWithXp = false)
: base(InHostPlatform)
{
GameProj = InGameProj;
TargetPlatform = InTargetPlatform;
WithXp = InWithXp;
if (TargetPlatform == UnrealTargetPlatform.PS4)
{
var PS4MapFileUtil = bp.Branch.FindProgram("PS4MapFileUtil");
if(PS4MapFileUtil.Rules == null)
{
throw new AutomationException("PS4MapFileUtil is not is this branch, but is required to build PS4 monolithics");
}
AddDependency(SingleToolsNode.StaticGetFullName(HostPlatform, PS4MapFileUtil));
}
if (TargetPlatform == UnrealTargetPlatform.XboxOne)
{
var XboxOnePDBFileUtil = bp.Branch.FindProgram("XboxOnePDBFileUtil");
if (XboxOnePDBFileUtil.Rules == null)
{
throw new AutomationException("XboxOnePDBFileUtil is not is this branch, but is required to build Xbox One monolithics");
}
AddDependency(SingleToolsNode.StaticGetFullName(HostPlatform, XboxOnePDBFileUtil));
}
if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
if (!bp.BranchOptions.ExcludePlatformsForEditor.Contains(InHostPlatform))
{
AddPseudodependency(EditorGameNode.StaticGetFullName(InHostPlatform, GameProj));
}
if (bp.HasNode(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, TargetPlatform)))
{
AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, TargetPlatform));
}
}
else
{
if (TargetPlatform != InHostPlatform && bp.HasNode(GamePlatformMonolithicsNode.StaticGetFullName(InHostPlatform, bp.Branch.BaseEngineProject, InHostPlatform))
&& !GUBP.bBuildRocket) // more errors and more performance by just starting, for example, IOS without waiting for mac
{
AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(InHostPlatform, bp.Branch.BaseEngineProject, InHostPlatform));
}
if (GUBP.bBuildRocket && InGameProj.GameName == bp.Branch.BaseEngineProject.GameName)
{
AgentSharingGroup = "UE4_" + InTargetPlatform + "_Mono" + StaticGetHostPlatformSuffix(InHostPlatform);
// lets just start this right away AddPseudodependency(RootEditorHeadersNode.StaticGetFullName(HostPlatform)); // maybe we should start these sooner, but that rather tangles the agent groups
}
}
if (InGameProj.Options(InHostPlatform).bTestWithShared) /// compiling templates is only for testing purposes, and we will group them to avoid saturating the farm
{
AddPseudodependency(WaitForTestShared.StaticGetFullName());
AgentSharingGroup = "TemplateMonolithics" + StaticGetHostPlatformSuffix(InHostPlatform);
}
if (GUBP.bBuildRocket)
{
var Target = bp.Branch.BaseEngineProject.Properties.Targets[TargetRules.TargetType.Game];
var Configs = Target.Rules.GUBP_GetConfigs_MonolithicOnly(HostPlatform, TargetPlatform);
foreach (var Config in Configs)
{
if (HostPlatform == UnrealTargetPlatform.Win64)
{
if (TargetPlatform == UnrealTargetPlatform.Win32 && Config != UnrealTargetConfiguration.Shipping)
{
continue;
}
if (TargetPlatform == UnrealTargetPlatform.Win64 && Config != UnrealTargetConfiguration.Development)
{
continue;
}
if (TargetPlatform == UnrealTargetPlatform.Android && Config != UnrealTargetConfiguration.Shipping && Config != UnrealTargetConfiguration.Development)
{
continue;
}
if (TargetPlatform == UnrealTargetPlatform.HTML5 && Config != UnrealTargetConfiguration.Shipping && Config != UnrealTargetConfiguration.Development)
{
continue;
}
if (TargetPlatform == UnrealTargetPlatform.Linux && Config != UnrealTargetConfiguration.Shipping && Config != UnrealTargetConfiguration.Development)
{
continue;
}
}
else if (Config != UnrealTargetConfiguration.Shipping && Config != UnrealTargetConfiguration.Development)
{
continue;
}
Log("Building {0} for Host={1} Target={2} Config={3} for rocket. Node={4}", Target.TargetName, HostPlatform, TargetPlatform, Config, GetFullName());
}
}
}
public MakeFeaturePackNode(UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj)
: base(InHostPlatform)
{
GameProj = InGameProj;
AddDependency(ToolsNode.StaticGetFullName(InHostPlatform)); // for UnrealPak
AgentSharingGroup = "FeaturePacks" + StaticGetHostPlatformSuffix(InHostPlatform);
}
public EditorGameNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj)
: base(InHostPlatform)
{
AgentSharingGroup = "Editor" + StaticGetHostPlatformSuffix(InHostPlatform);
GameProj = InGameProj;
AddDependency(RootEditorNode.StaticGetFullName(InHostPlatform));
}
public WaitForGamePromotionUserInput(GUBP bp, BranchInfo.BranchUProject InGameProj, bool bInLabelPromoted)
: base(InGameProj.GameName, bInLabelPromoted)
{
GameProj = InGameProj;
}
public CookNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform, string InCookPlatform)
: base(InHostPlatform)
{
GameProj = InGameProj;
TargetPlatform = InTargetPlatform;
CookPlatform = InCookPlatform;
bIsMassive = false;
AddDependency(EditorAndToolsNode.StaticGetFullName(HostPlatform));
if (TargetPlatform != HostPlatform && TargetPlatform != GUBP.GetAltHostPlatform(HostPlatform))
{
AddDependency(EditorPlatformNode.StaticGetFullName(HostPlatform, TargetPlatform));
}
// is this the "base game" or a non code project?
if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
var Options = InGameProj.Options(HostPlatform);
bIsMassive = Options.bIsMassive;
AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj));
if (!bp.bWide || bIsMassive)
{
// add an arc to prevent cooks from running until promotable is labeled
if (Options.bIsPromotable)
{
if (Options.bSeparateGamePromotion)
{
AddPseudodependency(GameLabelPromotableNode.StaticGetFullName(GameProj, false));
}
else
{
AddPseudodependency(WaitForTestShared.StaticGetFullName());
}
}
}
AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, TargetPlatform));
}
else
{
if (!bp.bWide)
{
// add an arc to prevent cooks from running until promotable is labeled
AddPseudodependency(WaitForTestShared.StaticGetFullName());
}
AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, bp.Branch.BaseEngineProject, TargetPlatform));
}
}
public GamePlatformMonolithicsNode(GUBPBranchConfig InBranchConfig, UnrealTargetPlatform InHostPlatform, List<UnrealTargetPlatform> InActivePlatforms, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform, bool InWithXp = false, bool InPrecompiled = false)
: base(InBranchConfig, InHostPlatform)
{
GameProj = InGameProj;
TargetPlatform = InTargetPlatform;
ActivePlatforms = InActivePlatforms;
WithXp = InWithXp;
Precompiled = InPrecompiled;
EnhanceAgentRequirements = BranchConfig.BranchOptions.EnhanceAgentRequirements.Contains(StaticGetFullName(HostPlatform, GameProj, TargetPlatform, WithXp, Precompiled));
if (TargetPlatform == UnrealTargetPlatform.PS4 || TargetPlatform == UnrealTargetPlatform.XboxOne)
{
// Required for PS4MapFileUtil/XboxOnePDBFileUtil
AddDependency(ToolsNode.StaticGetFullName(InHostPlatform));
}
if(IsSample(BranchConfig, InGameProj))
{
AddDependency(WaitToPackageSamplesNode.StaticGetFullName());
}
if (InGameProj.GameName != BranchConfig.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
if (!BranchConfig.BranchOptions.ExcludePlatformsForEditor.Contains(InHostPlatform))
{
AddPseudodependency(EditorGameNode.StaticGetFullName(InHostPlatform, GameProj));
}
if (BranchConfig.HasNode(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, TargetPlatform)))
{
AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, TargetPlatform));
}
}
else
{
if (TargetPlatform != InHostPlatform && BranchConfig.HasNode(GamePlatformMonolithicsNode.StaticGetFullName(InHostPlatform, BranchConfig.Branch.BaseEngineProject, InHostPlatform, Precompiled: Precompiled)))
{
AddPseudodependency(GamePlatformMonolithicsNode.StaticGetFullName(InHostPlatform, BranchConfig.Branch.BaseEngineProject, InHostPlatform, Precompiled: Precompiled));
}
}
if (InGameProj.Options(InHostPlatform).bTestWithShared) /// compiling templates is only for testing purposes, and we will group them to avoid saturating the farm
{
AddPseudodependency(WaitForTestShared.StaticGetFullName());
AgentSharingGroup = "TemplateMonolithics" + StaticGetHostPlatformSuffix(InHostPlatform);
}
}
public EditorGameNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj)
: base(InHostPlatform)
{
GameProj = InGameProj;
AddDependency(RootEditorNode.StaticGetFullName(InHostPlatform));
}
public GamePlatformCookedAndCompiledNode(GUBP.GUBPBranchConfig BranchConfig, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, UnrealTargetPlatform InTargetPlatform, bool bCodeProject)
: base(InHostPlatform)
{
GameProj = InGameProj;
TargetPlatform = InTargetPlatform;
foreach (var Kind in BranchInfo.MonolithicKinds)
{
if (bCodeProject)
{
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))
{
//@todo how do we get the client target platform?
string CookedPlatform = Platform.Platforms[TargetPlatform].GetCookPlatform(Kind == TargetRules.TargetType.Server, Kind == TargetRules.TargetType.Client, "");
if (Target.Rules.GUBP_AlternateCookPlatform(HostPlatform, CookedPlatform) != "")
{
CookedPlatform = Target.Rules.GUBP_AlternateCookPlatform(HostPlatform, CookedPlatform);
}
AddDependency(CookNode.StaticGetFullName(HostPlatform, GameProj, CookedPlatform));
AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, TargetPlatform));
if(Target.Rules.GUBP_BuildWindowsXPMonolithics())
{
AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, TargetPlatform, true));
}
}
}
}
else
{
if (Kind == TargetRules.TargetType.Game) //for now, non-code projects don't do client or server.
{
if (BranchConfig.Branch.BaseEngineProject.Properties.Targets.ContainsKey(Kind))
{
var Target = BranchConfig.Branch.BaseEngineProject.Properties.Targets[Kind];
var Platforms = Target.Rules.GUBP_GetPlatforms_MonolithicOnly(HostPlatform);
if (Platforms.Contains(TargetPlatform) && Target.Rules.SupportsPlatform(TargetPlatform))
{
//@todo how do we get the client target platform?
string CookedPlatform = Platform.Platforms[TargetPlatform].GetCookPlatform(Kind == TargetRules.TargetType.Server, Kind == TargetRules.TargetType.Client, "");
AddDependency(CookNode.StaticGetFullName(HostPlatform, GameProj, CookedPlatform));
AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, BranchConfig.Branch.BaseEngineProject, TargetPlatform));
}
}
}
}
}
}
public GameAggregateNode(GUBP bp, UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, string InAggregateName, List<string> Dependencies, bool bInExposeToEC, float InECPriority = 100.0f)
: base(InHostPlatform)
{
GameProj = InGameProj;
AggregateName = InAggregateName;
bExposeToEC = bInExposeToEC;
ECPriority = InECPriority;
foreach (var Dep in Dependencies)
{
AddDependency(Dep);
}
}
public FormalBuildTestNode(GUBP.GUBPBranchConfig InBranchConfig,
BranchInfo.BranchUProject InGameProj,
UnrealTargetPlatform InHostPlatform,
UnrealTargetPlatform InClientTargetPlatform,
UnrealTargetConfiguration InClientConfig
)
: base(InHostPlatform)
{
BranchConfig = InBranchConfig;
GameProj = InGameProj;
ClientTargetPlatform = InClientTargetPlatform;
ClientConfig = InClientConfig;
GameOrClient = TargetRules.TargetType.Game;
// verify we actually built these
var WorkingGameProject = InGameProj;
if (!WorkingGameProject.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
// this is a codeless project, use the base project
WorkingGameProject = BranchConfig.Branch.BaseEngineProject;
}
if (!WorkingGameProject.Properties.Targets.ContainsKey(GameOrClient))
{
throw new AutomationException("Can't make a game build for {0} because it doesn't have a {1} target.", WorkingGameProject.GameName, GameOrClient.ToString());
}
if (!WorkingGameProject.Properties.Targets[GameOrClient].Rules.GUBP_GetPlatforms_MonolithicOnly(HostPlatform).Contains(ClientTargetPlatform))
{
throw new AutomationException("Can't make a game/client build for {0} because we didn't build platform {1}.", WorkingGameProject.GameName, ClientTargetPlatform.ToString());
}
if (!WorkingGameProject.Properties.Targets[GameOrClient].Rules.GUBP_GetConfigs_MonolithicOnly(HostPlatform, ClientTargetPlatform).Contains(ClientConfig))
{
throw new AutomationException("Can't make a game/client build for {0} because we didn't build platform {1} config {2}.", WorkingGameProject.GameName, ClientTargetPlatform.ToString(), ClientConfig.ToString());
}
AddDependency(FormalBuildNode.StaticGetFullName(GameProj, HostPlatform, new List<UnrealTargetPlatform>() { ClientTargetPlatform }, InClientConfigs: new List<UnrealTargetConfiguration>() { ClientConfig }, InClientNotGame: GameOrClient == TargetRules.TargetType.Client));
}
public GameAggregatePromotableNode(GUBP bp, List<UnrealTargetPlatform> InHostPlatforms, BranchInfo.BranchUProject InGameProj)
: base(InHostPlatforms, InGameProj.GameName)
{
GameProj = InGameProj;
foreach (var HostPlatform in HostPlatforms)
{
if (InGameProj.GameName != bp.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj));
}
// add all of the platforms I use
{
var Platforms = bp.GetMonolithicPlatformsForUProject(HostPlatform, InGameProj, false);
foreach (var Plat in Platforms)
{
AddDependency(EditorPlatformNode.StaticGetFullName(HostPlatform, Plat));
}
}
{
var Platforms = bp.GetMonolithicPlatformsForUProject(HostPlatform, InGameProj, true);
foreach (var Plat in Platforms)
{
AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, Plat));
}
}
}
}
public GameAggregateNode(UnrealTargetPlatform InHostPlatform, BranchInfo.BranchUProject InGameProj, string InAggregateName, List<string> Dependencies)
: base(InHostPlatform)
{
GameProj = InGameProj;
AggregateName = InAggregateName;
foreach (var Dep in Dependencies)
{
AddDependency(Dep);
}
}
public GameAggregatePromotableNode(GUBP.GUBPBranchConfig BranchConfig, List<UnrealTargetPlatform> InHostPlatforms, List<UnrealTargetPlatform> InActivePlatforms, BranchInfo.BranchUProject InGameProj, bool IsSeparate, bool bNoIOSOnPC)
: base(InHostPlatforms, InGameProj.GameName)
{
GameProj = InGameProj;
foreach (var HostPlatform in HostPlatforms)
{
AddDependency(RootEditorNode.StaticGetFullName(HostPlatform));
if(!BranchConfig.BranchOptions.PromotablesWithoutTools.Contains(GameProj.GameName))
{
AddDependency(ToolsNode.StaticGetFullName(HostPlatform));
AddDependency(InternalToolsNode.StaticGetFullName(HostPlatform));
}
if (InGameProj.GameName != BranchConfig.Branch.BaseEngineProject.GameName && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Editor))
{
AddDependency(EditorGameNode.StaticGetFullName(HostPlatform, GameProj));
}
// add all of the platforms I use
{
if (!GameProj.Options(HostPlatform).bPromoteEditorOnly)
{
var Platforms = GamePlatformMonolithicsNode.GetMonolithicPlatformsForUProject(HostPlatform, InActivePlatforms, InGameProj, true, bNoIOSOnPC);
foreach (var Plat in Platforms)
{
AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, Plat));
if (Plat == UnrealTargetPlatform.Win32 && GameProj.Properties.Targets.ContainsKey(TargetRules.TargetType.Game))
{
if (GameProj.Properties.Targets[TargetRules.TargetType.Game].Rules.GUBP_BuildWindowsXPMonolithics())
{
AddDependency(GamePlatformMonolithicsNode.StaticGetFullName(HostPlatform, GameProj, Plat, true));
}
}
}
}
}
}
}
