C# GUBP.AddNode方法代码示例

 public override void AddNodes(GUBP bp, UnrealTargetPlatform InHostPlatform)
 {
     if(InHostPlatform == UnrealTargetPlatform.Win64 && !bp.BranchOptions.bNoDocumentation)
     {
         bp.AddNode(new ToolsForDocumentationNode(InHostPlatform));
         bp.AddNode(new CodeDocumentationNode(InHostPlatform));
         bp.AddNode(new BlueprintDocumentationNode(InHostPlatform));
     }
 }

        public override void AddNodes(GUBP bp, UnrealTargetPlatform HostPlatform)
        {
            if(!bp.BranchOptions.bNoInstalledEngine)
            {
                // Find all the target platforms for this host platform.
                List<UnrealTargetPlatform> TargetPlatforms = GetTargetPlatforms(bp, HostPlatform);

                // Remove any platforms that aren't available on this machine
                TargetPlatforms.RemoveAll(x => !bp.ActivePlatforms.Contains(x));

                // Get the temp directory for stripped files for this host
                string StrippedDir = Path.GetFullPath(CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, "Engine", "Saved", "Rocket", HostPlatform.ToString()));

                // Strip the host platform
                if (StripRocketNode.IsRequiredForPlatform(HostPlatform))
                {
                    bp.AddNode(new StripRocketToolsNode(HostPlatform, StrippedDir));
                    bp.AddNode(new StripRocketEditorNode(HostPlatform, StrippedDir));
                }

                // Strip all the target platforms that are built on this host
                foreach (UnrealTargetPlatform TargetPlatform in TargetPlatforms)
                {
                    if (GetSourceHostPlatform(bp, HostPlatform, TargetPlatform) == HostPlatform && StripRocketNode.IsRequiredForPlatform(TargetPlatform))
                    {
                        bp.AddNode(new StripRocketMonolithicsNode(bp, HostPlatform, TargetPlatform, StrippedDir));
                    }
                }

                // Build the DDC
                bp.AddNode(new BuildDerivedDataCacheNode(HostPlatform, GetCookPlatforms(HostPlatform, TargetPlatforms), CurrentFeaturePacks));

                // Generate a list of files that needs to be copied for each target platform
                bp.AddNode(new FilterRocketNode(bp, HostPlatform, TargetPlatforms, CurrentFeaturePacks, CurrentTemplates));

                // Copy the install to the output directory
                string LocalOutputDir = CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, "LocalBuilds", "Rocket", CommandUtils.GetGenericPlatformName(HostPlatform));
                bp.AddNode(new GatherRocketNode(HostPlatform, TargetPlatforms, LocalOutputDir));

                // Add the aggregate node for the entire install
                GUBP.GUBPNode PromotableNode = bp.FindNode(GUBP.SharedAggregatePromotableNode.StaticGetFullName());
                PromotableNode.AddDependency(FilterRocketNode.StaticGetFullName(HostPlatform));
                PromotableNode.AddDependency(BuildDerivedDataCacheNode.StaticGetFullName(HostPlatform));

                // Add a node for GitHub promotions
                if(HostPlatform == UnrealTargetPlatform.Win64)
                {
                    string GitConfigRelativePath = "Engine/Build/Git/UnrealBot.ini";
                    if(CommandUtils.FileExists(CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, GitConfigRelativePath)))
                    {
                        bp.AddNode(new BuildGitPromotable(bp, HostPlatform, GitConfigRelativePath));
                        PromotableNode.AddDependency(BuildGitPromotable.StaticGetFullName(HostPlatform));
                    }
                }

                // Get the output directory for the build zips
                string PublishedEngineDir;
                if(ShouldDoSeriousThingsLikeP4CheckinAndPostToMCP())
                {
                    PublishedEngineDir = CommandUtils.CombinePaths(CommandUtils.RootSharedTempStorageDirectory(), "Rocket", "Automated", GetBuildLabel(), CommandUtils.GetGenericPlatformName(HostPlatform));
                }
                else
                {
                    PublishedEngineDir = CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, "LocalBuilds", "RocketPublish", CommandUtils.GetGenericPlatformName(HostPlatform));
                }

                // Publish the install to the network
                bp.AddNode(new PublishRocketNode(HostPlatform, LocalOutputDir, PublishedEngineDir));
                bp.AddNode(new PublishRocketSymbolsNode(bp, HostPlatform, TargetPlatforms, PublishedEngineDir + "Symbols"));

                // Add a dependency on this being published as part of the shared promotable being labeled
                GUBP.SharedLabelPromotableSuccessNode LabelPromotableNode = (GUBP.SharedLabelPromotableSuccessNode)bp.FindNode(GUBP.SharedLabelPromotableSuccessNode.StaticGetFullName());
                LabelPromotableNode.AddDependency(PublishRocketNode.StaticGetFullName(HostPlatform));
                LabelPromotableNode.AddDependency(PublishRocketSymbolsNode.StaticGetFullName(HostPlatform));

                // Add dependencies on a promotable to do these steps too
                GUBP.WaitForSharedPromotionUserInput WaitForPromotionNode = (GUBP.WaitForSharedPromotionUserInput)bp.FindNode(GUBP.WaitForSharedPromotionUserInput.StaticGetFullName(true));
                WaitForPromotionNode.AddDependency(PublishRocketNode.StaticGetFullName(HostPlatform));
                WaitForPromotionNode.AddDependency(PublishRocketSymbolsNode.StaticGetFullName(HostPlatform));

                // Push everything behind the promotion triggers if we're doing things on the build machines
                if(ShouldDoSeriousThingsLikeP4CheckinAndPostToMCP() || bp.ParseParam("WithRocketPromotable"))
                {
                    string WaitForTrigger = GUBP.WaitForSharedPromotionUserInput.StaticGetFullName(false);

                    GatherRocketNode GatherRocket = (GatherRocketNode)bp.FindNode(GatherRocketNode.StaticGetFullName(HostPlatform));
                    GatherRocket.AddDependency(WaitForTrigger);

                    PublishRocketSymbolsNode PublishRocketSymbols = (PublishRocketSymbolsNode)bp.FindNode(PublishRocketSymbolsNode.StaticGetFullName(HostPlatform));
                    PublishRocketSymbols.AddDependency(WaitForTrigger);
                }
            }
        }

	public override void AddNodes(GUBP bp, GUBP.GUBPBranchConfig BranchConfig, UnrealTargetPlatform InHostPlatform, List<UnrealTargetPlatform> InActivePlatforms)
	{
		if(InHostPlatform == UnrealTargetPlatform.Win64 && !BranchConfig.BranchOptions.bNoDocumentation)
		{
			BranchConfig.AddNode(new ToolsForDocumentationNode(BranchConfig, InHostPlatform));
			BranchConfig.AddNode(new CodeDocumentationNode(InHostPlatform));
			BranchConfig.AddNode(new BlueprintDocumentationNode(InHostPlatform));
		}
	}

		public override void AddNodes(GUBP bp, GUBP.GUBPBranchConfig BranchConfig, UnrealTargetPlatform HostPlatform, List<UnrealTargetPlatform> ActivePlatforms)
		{
			if (!BranchConfig.BranchOptions.bNoInstalledEngine)
			{
				// Add the aggregate for making a rocket build
				if(!BranchConfig.HasNode(WaitToMakeRocketBuild.StaticGetFullName()))
				{
					BranchConfig.AddNode(new WaitToMakeRocketBuild(BranchConfig));
				}

				// Find all the target platforms for this host platform.
				List<UnrealTargetPlatform> TargetPlatforms = GetTargetPlatforms(bp, HostPlatform);

				// Remove any platforms that aren't available on this machine
				TargetPlatforms.RemoveAll(x => !ActivePlatforms.Contains(x));

				// Get the temp directory for stripped files for this host
				string StrippedDir = Path.GetFullPath(CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, "Engine", "Saved", "Rocket", HostPlatform.ToString()));

				// Get the temp directory for signed files for this host
				string SignedDir = Path.GetFullPath(CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, "Engine", "Saved", "Rocket", "Signed", HostPlatform.ToString()));

				// Strip the host platform
				if (StripRocketNode.IsRequiredForPlatform(HostPlatform))
				{
					BranchConfig.AddNode(new StripRocketToolsNode(BranchConfig, HostPlatform, StrippedDir));
					BranchConfig.AddNode(new StripRocketEditorNode(BranchConfig, HostPlatform, StrippedDir));
				}
				BranchConfig.AddNode(new SignRocketToolsNode(BranchConfig, HostPlatform, SignedDir));
				BranchConfig.AddNode(new SignRocketEditorNode(BranchConfig, HostPlatform, SignedDir));

				// Strip all the target platforms that are built on this host
				foreach (UnrealTargetPlatform TargetPlatform in TargetPlatforms)
				{
					if (GetSourceHostPlatform(BranchConfig.HostPlatforms, HostPlatform, TargetPlatform) == HostPlatform && StripRocketNode.IsRequiredForPlatform(TargetPlatform))
					{
						BranchConfig.AddNode(new StripRocketMonolithicsNode(BranchConfig, HostPlatform, TargetPlatform, StrippedDir));
					}
					if (GetSourceHostPlatform(BranchConfig.HostPlatforms, HostPlatform, TargetPlatform) == HostPlatform && SignRocketNode.IsRequiredForPlatform(TargetPlatform))
					{
						BranchConfig.AddNode(new SignRocketMonolithicsNode(BranchConfig, HostPlatform, TargetPlatform, SignedDir));
					}
				}

				// Build the DDC
				BranchConfig.AddNode(new BuildDerivedDataCacheNode(BranchConfig, HostPlatform, GetCookPlatforms(HostPlatform, TargetPlatforms), CurrentFeaturePacks));

				// Generate a list of files that needs to be copied for each target platform
				BranchConfig.AddNode(new FilterRocketNode(BranchConfig, HostPlatform, TargetPlatforms, CurrentFeaturePacks, CurrentTemplates));

				// Copy the install to the output directory
				string LocalOutputDir = CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, "LocalBuilds", "Rocket", CommandUtils.GetGenericPlatformName(HostPlatform));
				BranchConfig.AddNode(new GatherRocketNode(BranchConfig, HostPlatform, TargetPlatforms, LocalOutputDir));

				// Add a node for GitHub promotions
				if(HostPlatform == UnrealTargetPlatform.Win64)
				{
					string GitConfigRelativePath = "Engine/Build/Git/UnrealBot.ini";
					if(CommandUtils.FileExists(CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, GitConfigRelativePath)))
					{
						BranchConfig.AddNode(new BuildGitPromotable(HostPlatform, BranchConfig.HostPlatforms, GitConfigRelativePath));
					}
				}

				// Get the output directory for the build zips
				string PublishedEngineDir;
				if (ShouldDoSeriousThingsLikeP4CheckinAndPostToMCP(BranchConfig))
				{
					PublishedEngineDir = CommandUtils.CombinePaths(CommandUtils.RootBuildStorageDirectory(), "Rocket", "Automated", GetBuildLabel(), CommandUtils.GetGenericPlatformName(HostPlatform));
				}
				else
				{
					PublishedEngineDir = CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, "LocalBuilds", "RocketPublish", CommandUtils.GetGenericPlatformName(HostPlatform));
				}

				// Publish the install to the network
				BranchConfig.AddNode(new PublishRocketNode(HostPlatform, LocalOutputDir, PublishedEngineDir));
				BranchConfig.AddNode(new PublishRocketSymbolsNode(BranchConfig, HostPlatform, TargetPlatforms, PublishedEngineDir + "Symbols"));
			}
		}