/// <summary>
		/// Recursively searches for the specified project and returns the folder that it lives in, or null if not found
		/// </summary>
		/// <param name="Project">The project file to look for</param>
		/// <returns>The found folder that the project is in, or null</returns>
		public MasterProjectFolder FindFolderForProject( ProjectFile Project )
		{
			foreach( var CurFolder in SubFolders )
			{
				MasterProjectFolder FoundFolder = CurFolder.FindFolderForProject( Project );
				if( FoundFolder != null )
				{
					return FoundFolder;
				}
			}

			foreach( var ChildProject in ChildProjects )
			{
				if( ChildProject == Project )
				{
					return this;
				}
			}

			return null;
		}

		/// <summary>
		/// Creates project entries for all known targets (*.Target.cs files)
		/// </summary>
		/// <param name="AllGameFolders">All game folders</param>
		/// <param name="EngineProject">The engine project we created</param>
		/// <param name="GameProjects">Map of game folder name to all of the game projects we created</param>
		/// <param name="ProgramProjects">Map of program names to all of the program projects we created</param>
		/// <param name="TemplateGameProjects">Set of template game projects we found.  These will also be in the GameProjects map</param>
		private void AddProjectsForAllTargets( List<UProjectInfo> AllGames, out ProjectFile EngineProject, out Dictionary<DirectoryReference, ProjectFile> GameProjects, out Dictionary<string, ProjectFile> ProgramProjects, out HashSet<ProjectFile> TemplateGameProjects )
		{
			// As we're creating project files, we'll also keep track of whether we created an "engine" project and return that if we have one
			EngineProject = null;
			GameProjects = new Dictionary<DirectoryReference,ProjectFile>();
			ProgramProjects = new Dictionary<string,ProjectFile>( StringComparer.InvariantCultureIgnoreCase );
			TemplateGameProjects = new HashSet<ProjectFile>();

			// Get some standard directories
			DirectoryReference EngineSourceProgramsDirectory = DirectoryReference.Combine(UnrealBuildTool.EngineSourceDirectory, "Programs");
			DirectoryReference TemplatesDirectory = DirectoryReference.Combine(UnrealBuildTool.EngineDirectory, "..", "Templates");

			// Find all of the target files.  This will filter out any modules or targets that don't
			// belong to platforms we're generating project files for.
			List<FileReference> AllTargetFiles = DiscoverTargets(AllGames);
			foreach( FileReference TargetFilePath in AllTargetFiles )
			{
				string TargetName = TargetFilePath.GetFileNameWithoutAnyExtensions();		// Remove both ".cs" and ".Target"

				// Check to see if this is an Engine target.  That is, the target is located under the "Engine" folder
				bool IsEngineTarget = false;
				bool WantProjectFileForTarget = true;
				if(TargetFilePath.IsUnderDirectory(UnrealBuildTool.EngineDirectory))
				{
					// This is an engine target
					IsEngineTarget = true;

					if(TargetFilePath.IsUnderDirectory(EngineSourceProgramsDirectory))
					{
						WantProjectFileForTarget = IncludeEnginePrograms;
					}
					else if(TargetFilePath.IsUnderDirectory(UnrealBuildTool.EngineSourceDirectory))
					{
						WantProjectFileForTarget = IncludeEngineSource;
					}
				}

				if (WantProjectFileForTarget)
				{
					RulesAssembly RulesAssembly;

					FileReference CheckProjectFile;
					if(!UProjectInfo.TryGetProjectForTarget(TargetName, out CheckProjectFile))
					{
						RulesAssembly = RulesCompiler.CreateEngineRulesAssembly();
					}
					else
					{
						RulesAssembly = RulesCompiler.CreateProjectRulesAssembly(CheckProjectFile);
					}

					// Create target rules for all of the platforms and configuration combinations that we want to enable support for.
					// Just use the current platform as we only need to recover the target type and both should be supported for all targets...
					TargetRules TargetRulesObject = RulesAssembly.CreateTargetRules(TargetName, new TargetInfo(BuildHostPlatform.Current.Platform, UnrealTargetConfiguration.Development, ""), false);

					bool IsProgramTarget = false;

					DirectoryReference GameFolder = null;
					string ProjectFileNameBase = null;
					if (TargetRulesObject.Type == TargetRules.TargetType.Program)
					{
						IsProgramTarget = true;
						ProjectFileNameBase = TargetName;
					}
					else if (IsEngineTarget)
					{
						ProjectFileNameBase = EngineProjectFileNameBase;
					}
					else
					{
						// Figure out which game project this target belongs to
						UProjectInfo ProjectInfo = FindGameContainingFile(AllGames, TargetFilePath);
						if (ProjectInfo == null)
						{
							throw new BuildException("Found a non-engine target file (" + TargetFilePath + ") that did not exist within any of the known game folders");
						}
						GameFolder = ProjectInfo.Folder;
						ProjectFileNameBase = ProjectInfo.GameName;
					}

					// @todo projectfiles: We should move all of the Target.cs files out of sub-folders to clean up the project directories a bit (e.g. GameUncooked folder)

					FileReference ProjectFilePath = FileReference.Combine(IntermediateProjectFilesPath, ProjectFileNameBase + ProjectFileExtension);

					if (TargetRules.IsGameType(TargetRulesObject.Type) &&
						(TargetRules.IsEditorType(TargetRulesObject.Type) == false))
					{
						// Allow platforms to generate stub projects here...
						UEPlatformProjectGenerator.GenerateGameProjectStubs(
							InGenerator: this,
							InTargetName: TargetName,
							InTargetFilepath: TargetFilePath.FullName,
//.........这里部分代码省略.........

        /// Adds shader source code to the specified project
        protected void AddEngineShaderSource( ProjectFile EngineProject )
        {
            // Setup a project file entry for this module's project.  Remember, some projects may host multiple modules!
            var ShadersDirectory = Path.Combine( EngineRelativePath, "Shaders" );

            var DirectoriesToSearch = new List<string>();
            DirectoriesToSearch.Add( ShadersDirectory );
            var SubdirectoryNamesToExclude = new List<string>();
            {
                // Don't include binary shaders in the project file.
                SubdirectoryNamesToExclude.Add( "Binaries" );
                // We never want shader intermediate files in our project file
                SubdirectoryNamesToExclude.Add( "PDBDump" );
                SubdirectoryNamesToExclude.Add( "WorkingDirectory" );
            }
            EngineProject.AddFilesToProject( SourceFileSearch.FindFiles(
                DirectoriesToSearch: DirectoriesToSearch,
                ExcludeNoRedistFiles: bExcludeNoRedistFiles,
                SubdirectoryNamesToExclude: SubdirectoryNamesToExclude ), EngineRelativePath );
        }

        /// Adds engine build infrastructure files to the specified project
        protected void AddEngineBuildFiles( ProjectFile EngineProject )
        {
            var BuildDirectory = Path.Combine( EngineRelativePath, "Build" );

            var DirectoriesToSearch = new List<string>();
            DirectoriesToSearch.Add( BuildDirectory );
            var SubdirectoryNamesToExclude = new List<string>();
            {
                // Nothing to exclude, yet!
                // SubdirectoryNamesToExclude.Add( "DirectoryName" );
            }
            EngineProject.AddFilesToProject( SourceFileSearch.FindFiles(
                DirectoriesToSearch: DirectoriesToSearch,
                ExcludeNoRedistFiles: bExcludeNoRedistFiles,
                SubdirectoryNamesToExclude: SubdirectoryNamesToExclude ), EngineRelativePath );
        }

        /// <summary>
        /// Adds the given project to the OtherProjects list
        /// </summary>
        /// <param name="InProject">The project to add</param>
        /// <returns>True if successful</returns>
        public void AddExistingProjectFile(ProjectFile InProject, bool bNeedsAllPlatformAndConfigurations = false, bool bForceDevelopmentConfiguration = false, bool bProjectDeploys = false, List<UnrealTargetPlatform> InSupportedPlatforms = null, List<UnrealTargetConfiguration> InSupportedConfigurations = null)
        {
            if( InProject.ProjectTargets.Count != 0 )
            {
                throw new BuildException( "Expecting existing project to not have any ProjectTargets defined yet." );
            }

            var ProjectTarget = new ProjectTarget();
            if( bForceDevelopmentConfiguration )
            {
                ProjectTarget.ForceDevelopmentConfiguration = true;
            }
            ProjectTarget.ProjectDeploys = bProjectDeploys;

            if (bNeedsAllPlatformAndConfigurations)
            {
                // Add all platforms
                var AllPlatforms = Enum.GetValues(typeof(UnrealTargetPlatform));
                foreach (UnrealTargetPlatform CurPlatfrom in AllPlatforms)
                {
                    ProjectTarget.ExtraSupportedPlatforms.Add(CurPlatfrom);
                }

                // Add all configurations
                var AllConfigurations = Enum.GetValues(typeof(UnrealTargetConfiguration));
                foreach (UnrealTargetConfiguration CurConfiguration in AllConfigurations)
                {
                    ProjectTarget.ExtraSupportedConfigurations.Add( CurConfiguration );
                }
            }
            else if (InSupportedPlatforms != null || InSupportedConfigurations != null)
            {
                if (InSupportedPlatforms != null)
                {
                    // Add all explicitly specified platforms
                    foreach (UnrealTargetPlatform CurPlatfrom in InSupportedPlatforms)
                    {
                        ProjectTarget.ExtraSupportedPlatforms.Add(CurPlatfrom);
                    }
                }
                else
                {
                    // Otherwise, add all platforms
                    var AllPlatforms = Enum.GetValues(typeof(UnrealTargetPlatform));
                    foreach (UnrealTargetPlatform CurPlatfrom in AllPlatforms)
                    {
                        ProjectTarget.ExtraSupportedPlatforms.Add(CurPlatfrom);
                    }
                }

                if (InSupportedConfigurations != null)
                {
                    // Add all explicitly specified configurations
                    foreach (UnrealTargetConfiguration CurConfiguration in InSupportedConfigurations)
                    {
                        ProjectTarget.ExtraSupportedConfigurations.Add(CurConfiguration);
                    }
                }
                else
                {
                    // Otherwise, add all configurations
                    var AllConfigurations = Enum.GetValues(typeof(UnrealTargetConfiguration));
                    foreach (UnrealTargetConfiguration CurConfiguration in AllConfigurations)
                    {
                        ProjectTarget.ExtraSupportedConfigurations.Add(CurConfiguration);
                    }
                }
            }
            else
            {
                // For existing project files, just support the default desktop platforms and configurations
                UnrealBuildTool.GetAllDesktopPlatforms(ref ProjectTarget.ExtraSupportedPlatforms, false);
                // Debug and Development only
                ProjectTarget.ExtraSupportedConfigurations.Add(UnrealTargetConfiguration.Debug);
                ProjectTarget.ExtraSupportedConfigurations.Add(UnrealTargetConfiguration.Development);
            }

            InProject.ProjectTargets.Add( ProjectTarget );

            // Existing projects must always have a GUID.  This will throw an exception if one isn't found.
            InProject.LoadGUIDFromExistingProject();

            OtherProjectFiles.Add( InProject );
        }

        /// <summary>
        /// Adds UnrealBuildTool to the master project
        /// </summary>
        private void AddUnrealBuildToolProject( MasterProjectFolder ProgramsFolder, IEnumerable<ProjectFile> Dependencies )
        {
            var ProjectFileName = Utils.MakePathRelativeTo( Path.Combine( Path.Combine( EngineRelativePath, "Source" ), "Programs", "UnrealBuildTool", "UnrealBuildTool.csproj" ), MasterProjectRelativePath );
            var UnrealBuildToolProject = new VCSharpProjectFile( ProjectFileName );
            UnrealBuildToolProject.ShouldBuildForAllSolutionTargets = true;

            foreach (var Dependent in Dependencies)
            {
                UnrealBuildToolProject.AddDependsOnProject( Dependent );
            }

            // Store it off as we need it when generating target projects.
            UBTProject = UnrealBuildToolProject;

            // Add the project
            AddExistingProjectFile(UnrealBuildToolProject, bNeedsAllPlatformAndConfigurations:true, bForceDevelopmentConfiguration:true);

            // Put this in a solution folder
            ProgramsFolder.ChildProjects.Add( UnrealBuildToolProject );
        }

        /// <summary>
        /// Creates project entries for all known targets (*.Target.cs files)
        /// </summary>
        /// <param name="AllGameFolders">All game folders</param>
        /// <param name="EngineProject">The engine project we created</param>
        /// <param name="GameProjects">Map of game folder name to all of the game projects we created</param>
        /// <param name="ProgramProjects">Map of program names to all of the program projects we created</param>
        /// <param name="TemplateGameProjects">Set of template game projects we found.  These will also be in the GameProjects map</param>
        private void AddProjectsForAllTargets( List<UProjectInfo> AllGames, out ProjectFile EngineProject, out Dictionary<string, ProjectFile> GameProjects, out Dictionary<string, ProjectFile> ProgramProjects, out HashSet<ProjectFile> TemplateGameProjects )
        {
            // As we're creating project files, we'll also keep track of whether we created an "engine" project and return that if we have one
            EngineProject = null;
            GameProjects = new Dictionary<string,ProjectFile>( StringComparer.InvariantCultureIgnoreCase );
            ProgramProjects = new Dictionary<string,ProjectFile>( StringComparer.InvariantCultureIgnoreCase );
            TemplateGameProjects = new HashSet<ProjectFile>();

            // Find all of the target files.  This will filter out any modules or targets that don't
            // belong to platforms we're generating project files for.
            var AllTargetFiles = DiscoverTargets();

            foreach( var TargetFilePath in AllTargetFiles )
            {
                var TargetName = Utils.GetFilenameWithoutAnyExtensions(TargetFilePath);		// Remove both ".cs" and ".Target"

                // Check to see if this is an Engine target.  That is, the target is located under the "Engine" folder
                bool IsEngineTarget = false;
                string TargetFileRelativeToEngineDirectory = Utils.MakePathRelativeTo(TargetFilePath, Path.Combine(EngineRelativePath), AlwaysTreatSourceAsDirectory: false);
                if (!TargetFileRelativeToEngineDirectory.StartsWith( ".." ) && !Path.IsPathRooted( TargetFileRelativeToEngineDirectory ))
                {
                    // This is an engine target
                    IsEngineTarget = true;
                }

                if (IsEngineTarget && bGeneratingRocketProjectFiles)
                {
                    // Rocket project file must never include engine targets.
                    continue;
                }

                bool WantProjectFileForTarget = true;
                if(TargetFileRelativeToEngineDirectory.StartsWith(Path.Combine("Source", "Programs"), StringComparison.InvariantCultureIgnoreCase))
                {
                    WantProjectFileForTarget = IncludeEnginePrograms;
                }
                else if(TargetFileRelativeToEngineDirectory.StartsWith(Path.Combine("Source"), StringComparison.InvariantCultureIgnoreCase))
                {
                    WantProjectFileForTarget = IncludeEngineSource;
                }

                if (WantProjectFileForTarget)
                {
                    // Create target rules for all of the platforms and configuration combinations that we want to enable support for.
                    // Just use the current platform as we only need to recover the target type and both should be supported for all targets...
                    string UnusedTargetFilePath;
                    var TargetRulesObject = RulesCompiler.CreateTargetRules(TargetName, new TargetInfo(BuildHostPlatform.Current.Platform, UnrealTargetConfiguration.Development), false, out UnusedTargetFilePath);

                    // Exclude client and server targets under binary Rocket; it's impossible to build without precompiled engine binaries
                    if (!UnrealBuildTool.RunningRocket() || (TargetRulesObject.Type != TargetRules.TargetType.Client && TargetRulesObject.Type != TargetRules.TargetType.Server))
                    {
                        bool IsProgramTarget = false;

                        string GameFolder = null;
                        string ProjectFileNameBase = null;
                        if (TargetRulesObject.Type == TargetRules.TargetType.Program)
                        {
                            IsProgramTarget = true;
                            ProjectFileNameBase = TargetName;
                        }
                        else if (IsEngineTarget)
                        {
                            ProjectFileNameBase = EngineProjectFileNameBase;
                        }
                        else
                        {
                            // Figure out which game project this target belongs to
                            UProjectInfo ProjectInfo = FindGameContainingFile(AllGames, TargetFilePath);
                            if (ProjectInfo == null)
                            {
                                throw new BuildException("Found a non-engine target file (" + TargetFilePath + ") that did not exist within any of the known game folders");
                            }
                            GameFolder = ProjectInfo.Folder;
                            ProjectFileNameBase = ProjectInfo.GameName;
                        }

                        // @todo projectfiles: We should move all of the Target.cs files out of sub-folders to clean up the project directories a bit (e.g. GameUncooked folder)

                        var ProjectFilePath = Path.Combine(IntermediateProjectFilesPath, ProjectFileNameBase + ProjectFileExtension);

                        if (TargetRules.IsGameType(TargetRulesObject.Type) &&
                            (TargetRules.IsEditorType(TargetRulesObject.Type) == false))
                        {
                            // Allow platforms to generate stub projects here...
                            UEPlatformProjectGenerator.GenerateGameProjectStubs(
                                InGenerator: this,
                                InTargetName: TargetName,
                                InTargetFilepath: TargetFilePath,
                                InTargetRules: TargetRulesObject,
                                InPlatforms: SupportedPlatforms,
                                InConfigurations: SupportedConfigurations);
                        }
//.........这里部分代码省略.........

 /// <summary>
 /// Writes the master project file (e.g. Visual Studio Solution file)
 /// </summary>
 /// <param name="UBTProject">The UnrealBuildTool project</param>
 /// <returns>True if successful</returns>
 protected abstract bool WriteMasterProjectFile( ProjectFile UBTProject );

		/// Adds all engine extras files to the specified project
		protected virtual void AddEngineExtrasFiles(ProjectFile EngineProject)
		{
		}

		/// Adds all engine config files to the specified project
		private void AddEngineConfigFiles( ProjectFile EngineProject )
		{
            DirectoryReference EngineConfigDirectory = DirectoryReference.Combine(UnrealBuildTool.EngineDirectory, "Config" );
			if( EngineConfigDirectory.Exists( ) )
			{
				EngineProject.AddFilesToProject( SourceFileSearch.FindFiles( EngineConfigDirectory ), UnrealBuildTool.EngineDirectory );
			}
		}

        /// Adds all engine template text files to the specified project
        private void AddEngineTemplateFiles( ProjectFile EngineProject )
        {
            DirectoryReference EngineTemplateDirectory = DirectoryReference.Combine(UnrealBuildTool.EngineDirectory, "Content", "Editor", "Templates");
            if (EngineTemplateDirectory.Exists())
            {
				EngineProject.AddFilesToProject( SourceFileSearch.FindFiles( EngineTemplateDirectory ), UnrealBuildTool.EngineDirectory );
			}
        }

		/// Adds all engine localization text files to the specified project
		private void AddEngineLocalizationFiles( ProjectFile EngineProject )
		{
			DirectoryReference EngineLocalizationDirectory = DirectoryReference.Combine( UnrealBuildTool.EngineDirectory, "Content", "Localization" );
			if( EngineLocalizationDirectory.Exists( ) )
			{
				EngineProject.AddFilesToProject( SourceFileSearch.FindFiles( EngineLocalizationDirectory ), UnrealBuildTool.EngineDirectory );
			}
		}

		/// Adds engine build infrastructure files to the specified project
		protected void AddEngineBuildFiles( ProjectFile EngineProject )
		{
			DirectoryReference BuildDirectory = DirectoryReference.Combine( UnrealBuildTool.EngineDirectory, "Build" );

			List<string> SubdirectoryNamesToExclude = new List<string>();
			SubdirectoryNamesToExclude.Add("Receipts");

			EngineProject.AddFilesToProject( SourceFileSearch.FindFiles( BuildDirectory, SubdirectoryNamesToExclude ), UnrealBuildTool.EngineDirectory );
		}

		/// Adds shader source code to the specified project
		protected void AddEngineShaderSource( ProjectFile EngineProject )
		{
			// Setup a project file entry for this module's project.  Remember, some projects may host multiple modules!
			DirectoryReference ShadersDirectory = DirectoryReference.Combine( UnrealBuildTool.EngineDirectory, "Shaders" );

			List<string> SubdirectoryNamesToExclude = new List<string>();
			{
                // Don't include binary shaders in the project file.
                SubdirectoryNamesToExclude.Add( "Binaries" );
				// We never want shader intermediate files in our project file
				SubdirectoryNamesToExclude.Add( "PDBDump" );
				SubdirectoryNamesToExclude.Add( "WorkingDirectory" );
			}

			EngineProject.AddFilesToProject( SourceFileSearch.FindFiles( ShadersDirectory, SubdirectoryNamesToExclude ), UnrealBuildTool.EngineDirectory );
		}

		/// <summary>
		/// Adds Extra files that are specific to Visual Studio projects
		/// </summary>
		/// <param name="EngineProject">Project to add files to</param>
		protected override void AddEngineExtrasFiles(ProjectFile EngineProject)
		{
			base.AddEngineExtrasFiles(EngineProject);

			// Add our UE4.natvis file
			var NatvisFilePath = FileReference.Combine(UnrealBuildTool.EngineDirectory, "Extras", "VisualStudioDebugging", "UE4.natvis");
			if (NatvisFilePath.Exists())
			{
				EngineProject.AddFileToProject(NatvisFilePath, UnrealBuildTool.EngineDirectory);
			}
		}

		protected override bool WriteMasterProjectFile(ProjectFile UBTProject)
		{
			bool bSuccess = true;

			string SolutionFileName = MasterProjectName + ".sln";

			// Setup solution file content
			StringBuilder VCSolutionFileContent = new StringBuilder();

			const string VersionTag = "# UnrealEngineGeneratedSolutionVersion=1.0";

			// Solution file header
			if (ProjectFileFormat == VCProjectFileFormat.VisualStudio2017)
			{
				VCSolutionFileContent.Append(
					ProjectFileGenerator.NewLine +
					"Microsoft Visual Studio Solution File, Format Version 12.00" + ProjectFileGenerator.NewLine +
					"# Visual Studio 15" + ProjectFileGenerator.NewLine +
					"VisualStudioVersion = 15.0.25618.0" + ProjectFileGenerator.NewLine +
					"MinimumVisualStudioVersion = 10.0.40219.1" + ProjectFileGenerator.NewLine);
			}
			else if (ProjectFileFormat == VCProjectFileFormat.VisualStudio2015)
			{
				VCSolutionFileContent.Append(
					ProjectFileGenerator.NewLine +
					"Microsoft Visual Studio Solution File, Format Version 12.00" + ProjectFileGenerator.NewLine +
					"# Visual Studio 14" + ProjectFileGenerator.NewLine +
					"VisualStudioVersion = 14.0.22310.1" + ProjectFileGenerator.NewLine +
					"MinimumVisualStudioVersion = 10.0.40219.1" + ProjectFileGenerator.NewLine);
			}
			else if (ProjectFileFormat == VCProjectFileFormat.VisualStudio2013)
			{
				VCSolutionFileContent.Append(
					ProjectFileGenerator.NewLine +
					"Microsoft Visual Studio Solution File, Format Version 12.00" + ProjectFileGenerator.NewLine +
					"# Visual Studio 2013" + ProjectFileGenerator.NewLine +
					VersionTag + ProjectFileGenerator.NewLine);
            }
            else if (ProjectFileFormat == VCProjectFileFormat.VisualStudio2012)
            {
                VCSolutionFileContent.Append(
                    ProjectFileGenerator.NewLine +
                    "Microsoft Visual Studio Solution File, Format Version 12.00" + ProjectFileGenerator.NewLine +
                    "# Visual Studio 2012" + ProjectFileGenerator.NewLine +
                    VersionTag + ProjectFileGenerator.NewLine);
            }
			else
			{
				throw new BuildException("Unexpected ProjectFileFormat");
			}

			// Find the projects for ShaderCompileWorker and UnrealLightmass
			ProjectFile ShaderCompileWorkerProject = null;
			ProjectFile UnrealLightmassProject = null;
			foreach (ProjectFile Project in AllProjectFiles)
			{
				if (Project.ProjectTargets.Count == 1)
				{
					FileReference TargetFilePath = Project.ProjectTargets[0].TargetFilePath;
					if (TargetFilePath != null)
					{
						string TargetFileName = TargetFilePath.GetFileNameWithoutAnyExtensions();
						if (TargetFileName.Equals("ShaderCompileWorker", StringComparison.InvariantCultureIgnoreCase))
						{
							ShaderCompileWorkerProject = Project;
						}
						else if (TargetFileName.Equals("UnrealLightmass", StringComparison.InvariantCultureIgnoreCase))
						{
							UnrealLightmassProject = Project;
						}
					}
					if (ShaderCompileWorkerProject != null
						&& UnrealLightmassProject != null)
					{
						break;
					}
				}
			}

			// Solution folders, files and project entries
			{
				// This the GUID that Visual Studio uses to identify a solution folder
				string SolutionFolderEntryGUID = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}";

				// Solution folders
				{
					List<MasterProjectFolder> AllSolutionFolders = new List<MasterProjectFolder>();
					System.Action<List<MasterProjectFolder> /* Folders */ > GatherFoldersFunction = null;
					GatherFoldersFunction = FolderList =>
						{
							AllSolutionFolders.AddRange(FolderList);
							foreach (MasterProjectFolder CurSubFolder in FolderList)
							{
								GatherFoldersFunction(CurSubFolder.SubFolders);
							}
						};
					GatherFoldersFunction(RootFolder.SubFolders);

					foreach (VisualStudioSolutionFolder CurFolder in AllSolutionFolders)
					{
//.........这里部分代码省略.........

		/// Adds UnrealHeaderTool config files to the specified project
		private void AddUnrealHeaderToolConfigFiles(ProjectFile EngineProject)
		{
			DirectoryReference UHTConfigDirectory = DirectoryReference.Combine(UnrealBuildTool.EngineDirectory, "Programs", "UnrealHeaderTool", "Config");
			if (UHTConfigDirectory.Exists())
			{
				EngineProject.AddFilesToProject(SourceFileSearch.FindFiles(UHTConfigDirectory), UnrealBuildTool.EngineDirectory);
			}
		}

 /// Adds all engine template text files to the specified project
 private void AddEngineTemplateFiles( ProjectFile EngineProject )
 {
     var EngineTemplateDirectory = Path.Combine(EngineRelativePath, "Content", "Editor", "Templates");
     if (Directory.Exists(EngineTemplateDirectory))
     {
         var DirectoriesToSearch = new List<string>();
         DirectoriesToSearch.Add( EngineTemplateDirectory );
         EngineProject.AddFilesToProject( SourceFileSearch.FindFiles( DirectoriesToSearch, ExcludeNoRedistFiles:bExcludeNoRedistFiles), EngineRelativePath );
     }
 }

		protected override bool WriteMasterProjectFile(ProjectFile UBTProject)
		{
			return WriteXcodeWorkspace();
		}

        /// <summary>
        /// Adds detected UBT configuration files (BuildConfiguration.xml) to engine project.
        /// </summary>
        /// <param name="EngineProject">Engine project to add files to.</param>
        private void AddUBTConfigFilesToEngineProject(ProjectFile EngineProject)
        {
            EngineProject.AddAliasedFileToProject(new AliasedFile(
                    XmlConfigLoader.GetXSDPath(),
                    Path.Combine("Programs", "UnrealBuildTool")
                ));

            foreach(var BuildConfigurationPath in XmlConfigLoader.ConfigLocationHierarchy)
            {
                if(!BuildConfigurationPath.bExists)
                {
                    continue;
                }

                EngineProject.AddAliasedFileToProject(
                        new AliasedFile(
                            BuildConfigurationPath.FSLocation,
                            Path.Combine("Config", "UnrealBuildTool", BuildConfigurationPath.IDEFolderName)
                        )
                    );
            }
        }