/// <summary>
/// Try to parse the project file from the command line
/// </summary>
/// <param name="Arguments">The command line arguments</param>
/// <param name="ProjectFile">The project file that was parsed</param>
/// <returns>True if the project file was parsed, false otherwise</returns>
public static bool TryParseProjectFileArgument(CommandLineArguments Arguments, out FileReference ProjectFile)
{
FileReference ExplicitProjectFile;
if (Arguments.TryGetValue("-Project=", out ExplicitProjectFile))
{
ProjectFile = ExplicitProjectFile;
return(true);
}
for (int Idx = 0; Idx < Arguments.Count; Idx++)
{
if (Arguments[Idx][0] != '-' && Arguments[Idx].EndsWith(".uproject", StringComparison.OrdinalIgnoreCase))
{
Arguments.MarkAsUsed(Idx);
ProjectFile = new FileReference(Arguments[Idx]);
return(true);
}
}
if (UnrealBuildTool.IsProjectInstalled())
{
ProjectFile = UnrealBuildTool.GetInstalledProjectFile();
return(true);
}
ProjectFile = null;
return(false);
}
/// <summary>
/// Creates a rules assembly with the given parameters.
/// </summary>
/// <param name="ProjectFileName">The project file to create rules for. Null for the engine.</param>
/// <param name="bUsePrecompiled">Whether to use a precompiled engine</param>
/// <param name="bSkipCompile">Whether to skip compilation for this assembly</param>
/// <returns>New rules assembly</returns>
public static RulesAssembly CreateProjectRulesAssembly(FileReference ProjectFileName, bool bUsePrecompiled, bool bSkipCompile)
{
// Check if there's an existing assembly for this project
RulesAssembly ProjectRulesAssembly;
if (!LoadedAssemblyMap.TryGetValue(ProjectFileName, out ProjectRulesAssembly))
{
ProjectDescriptor Project = ProjectDescriptor.FromFile(ProjectFileName);
// Create the parent assembly
RulesAssembly Parent;
if (Project.IsEnterpriseProject)
{
Parent = CreateEnterpriseRulesAssembly(bUsePrecompiled, bSkipCompile);
}
else
{
Parent = CreateEngineRulesAssembly(bUsePrecompiled, bSkipCompile);
}
// Find all the rules under the project source directory
DirectoryReference ProjectDirectory = ProjectFileName.Directory;
DirectoryReference ProjectSourceDirectory = DirectoryReference.Combine(ProjectDirectory, "Source");
List <FileReference> ModuleFiles = new List <FileReference>(FindAllRulesFiles(ProjectSourceDirectory, RulesFileType.Module));
List <FileReference> TargetFiles = new List <FileReference>(FindAllRulesFiles(ProjectSourceDirectory, RulesFileType.Target));
// Find all the project plugins
List <PluginInfo> ProjectPlugins = new List <PluginInfo>(Plugins.ReadProjectPlugins(ProjectFileName.Directory));
// Add the project's additional plugin directories plugins too
if (Project.AdditionalPluginDirectories != null)
{
foreach (string AdditionalPluginDirectory in Project.AdditionalPluginDirectories)
{
ProjectPlugins.AddRange(Plugins.ReadAdditionalPlugins(DirectoryReference.Combine(ProjectFileName.Directory, AdditionalPluginDirectory)));
}
}
// Find all the plugin module rules
Dictionary <FileReference, PluginInfo> ModuleFileToPluginInfo = new Dictionary <FileReference, PluginInfo>();
FindModuleRulesForPlugins(ProjectPlugins, ModuleFiles, ModuleFileToPluginInfo);
// Add the games project's intermediate source folder
DirectoryReference ProjectIntermediateSourceDirectory = DirectoryReference.Combine(ProjectDirectory, "Intermediate", "Source");
if (DirectoryReference.Exists(ProjectIntermediateSourceDirectory))
{
ModuleFiles.AddRange(FindAllRulesFiles(ProjectIntermediateSourceDirectory, RulesFileType.Module));
TargetFiles.AddRange(FindAllRulesFiles(ProjectIntermediateSourceDirectory, RulesFileType.Target));
}
// Compile the assembly
FileReference AssemblyFileName = FileReference.Combine(ProjectDirectory, "Intermediate", "Build", "BuildRules", ProjectFileName.GetFileNameWithoutExtension() + "ModuleRules" + FrameworkAssemblyExtension);
ProjectRulesAssembly = new RulesAssembly(ProjectDirectory, ProjectPlugins, ModuleFiles, TargetFiles, ModuleFileToPluginInfo, AssemblyFileName, bContainsEngineModules: false, bUseBackwardsCompatibleDefaults: true, bReadOnly: UnrealBuildTool.IsProjectInstalled(), bSkipCompile: bSkipCompile, Parent: Parent);
LoadedAssemblyMap.Add(ProjectFileName, ProjectRulesAssembly);
}
return(ProjectRulesAssembly);
}
/// <summary>
/// Creates a rules assembly with the given parameters.
/// </summary>
/// <param name="ProjectFileName">The project file to create rules for. Null for the engine.</param>
/// <param name="bUsePrecompiled">Whether to use a precompiled engine</param>
/// <param name="bSkipCompile">Whether to skip compilation for this assembly</param>
/// <returns>New rules assembly</returns>
public static RulesAssembly CreateProjectRulesAssembly(FileReference ProjectFileName, bool bUsePrecompiled, bool bSkipCompile)
{
// Check if there's an existing assembly for this project
RulesAssembly ProjectRulesAssembly;
if (!LoadedAssemblyMap.TryGetValue(ProjectFileName, out ProjectRulesAssembly))
{
ProjectDescriptor Project = ProjectDescriptor.FromFile(ProjectFileName);
// Create the parent assembly
RulesAssembly Parent;
if (Project.IsEnterpriseProject)
{
Parent = CreateEnterpriseRulesAssembly(bUsePrecompiled, bSkipCompile);
}
else
{
Parent = CreateEngineRulesAssembly(bUsePrecompiled, bSkipCompile);
}
DirectoryReference MainProjectDirectory = ProjectFileName.Directory;
//DirectoryReference MainProjectSourceDirectory = DirectoryReference.Combine(MainProjectDirectory, "Source");
// Create a scope for things in this assembly
RulesScope Scope = new RulesScope("Project", Parent.Scope);
// Create a new context for modules created by this assembly
ModuleRulesContext DefaultModuleContext = new ModuleRulesContext(Scope, MainProjectDirectory);
DefaultModuleContext.bCanBuildDebugGame = true;
DefaultModuleContext.bCanHotReload = true;
DefaultModuleContext.bClassifyAsGameModuleForUHT = true;
DefaultModuleContext.bCanUseForSharedPCH = false;
// gather modules from project and platforms
Dictionary <FileReference, ModuleRulesContext> ModuleFiles = new Dictionary <FileReference, ModuleRulesContext>();
List <FileReference> TargetFiles = new List <FileReference>();
// Find all the project directories
List <DirectoryReference> ProjectDirectories = new List <DirectoryReference>(UnrealBuildTool.GetAllProjectDirectories(ProjectFileName));
if (Project.AdditionalRootDirectories != null)
{
ProjectDirectories.AddRange(Project.AdditionalRootDirectories);
}
// Find all the rules/plugins under the project source directories
foreach (DirectoryReference ProjectDirectory in ProjectDirectories)
{
DirectoryReference ProjectSourceDirectory = DirectoryReference.Combine(ProjectDirectory, "Source");
AddModuleRulesWithContext(ProjectSourceDirectory, DefaultModuleContext, ModuleFiles);
TargetFiles.AddRange(FindAllRulesFiles(ProjectSourceDirectory, RulesFileType.Target));
}
// Find all the project plugins
List <PluginInfo> ProjectPlugins = new List <PluginInfo>();
ProjectPlugins.AddRange(Plugins.ReadProjectPlugins(MainProjectDirectory));
// Add the project's additional plugin directories plugins too
if (Project.AdditionalPluginDirectories != null)
{
foreach (DirectoryReference AdditionalPluginDirectory in Project.AdditionalPluginDirectories)
{
ProjectPlugins.AddRange(Plugins.ReadAdditionalPlugins(AdditionalPluginDirectory));
}
}
// Find all the plugin module rules
FindModuleRulesForPlugins(ProjectPlugins, DefaultModuleContext, ModuleFiles);
// Add the games project's intermediate source folder
DirectoryReference ProjectIntermediateSourceDirectory = DirectoryReference.Combine(MainProjectDirectory, "Intermediate", "Source");
if (DirectoryReference.Exists(ProjectIntermediateSourceDirectory))
{
AddModuleRulesWithContext(ProjectIntermediateSourceDirectory, DefaultModuleContext, ModuleFiles);
TargetFiles.AddRange(FindAllRulesFiles(ProjectIntermediateSourceDirectory, RulesFileType.Target));
}
// Compile the assembly. If there are no module or target files, just use the parent assembly.
FileReference AssemblyFileName = FileReference.Combine(MainProjectDirectory, "Intermediate", "Build", "BuildRules", ProjectFileName.GetFileNameWithoutExtension() + "ModuleRules" + FrameworkAssemblyExtension);
if (ModuleFiles.Count == 0 && TargetFiles.Count == 0)
{
ProjectRulesAssembly = Parent;
}
else
{
ProjectRulesAssembly = new RulesAssembly(Scope, new List <DirectoryReference> {
MainProjectDirectory
}, ProjectPlugins, ModuleFiles, TargetFiles, AssemblyFileName, bContainsEngineModules: false, DefaultBuildSettings: null, bReadOnly: UnrealBuildTool.IsProjectInstalled(), bSkipCompile: bSkipCompile, Parent: Parent);
}
LoadedAssemblyMap.Add(ProjectFileName, ProjectRulesAssembly);
}
return(ProjectRulesAssembly);
}
private void AddProjectsForAllTargets(
PlatformProjectGeneratorCollection PlatformProjectGenerators,
List <FileReference> AllGames,
out ProjectFile EngineProject,
out List <ProjectFile> GameProjects,
out Dictionary <FileReference, ProjectFile> ProgramProjects)
{
// 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 List <ProjectFile>();
ProgramProjects = new Dictionary <FileReference, 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.
List <FileReference> AllTargetFiles = DiscoverTargets(AllGames);
// Sort the targets by name. When we have multiple targets of a given type for a project, we'll use the order to determine which goes in the primary project file (so that client names with a suffix will go into their own project).
AllTargetFiles = AllTargetFiles.OrderBy(x => x.FullName, StringComparer.OrdinalIgnoreCase).ToList();
foreach (FileReference TargetFilePath in AllTargetFiles)
{
string TargetName = TargetFilePath.GetFileNameWithoutAnyExtensions();
// Check to see if this is an Engine target. That is, the target is located under the "Engine" folder
bool IsEngineTarget = false;
bool IsEnterpriseTarget = 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 = bIncludeEngineSource;
}
}
else if (TargetFilePath.IsUnderDirectory(UnrealBuildTool.EnterpriseSourceDirectory))
{
// This is an enterprise target
IsEnterpriseTarget = true;
if (TargetFilePath.IsUnderDirectory(EnterpriseSourceProgramsDirectory))
{
WantProjectFileForTarget = bIncludeEnterpriseSource && IncludeEnginePrograms;
}
else
{
WantProjectFileForTarget = bIncludeEnterpriseSource;
}
}
if (WantProjectFileForTarget)
{
RulesAssembly RulesAssembly;
FileReference CheckProjectFile =
AllGames.FirstOrDefault(x => TargetFilePath.IsUnderDirectory(x.Directory));
if (CheckProjectFile == null)
{
if (TargetFilePath.IsUnderDirectory(UnrealBuildTool.EnterpriseDirectory))
{
RulesAssembly = RulesCompiler.CreateEnterpriseRulesAssembly(false, false);
}
else
{
RulesAssembly = RulesCompiler.CreateEngineRulesAssembly(false, false);
}
}
else
{
RulesAssembly = RulesCompiler.CreateProjectRulesAssembly(CheckProjectFile, false, false);
}
// 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,
BuildHostPlatform.Current.Platform, UnrealTargetConfiguration.Development, "", CheckProjectFile,
null);
bool IsProgramTarget = false;
DirectoryReference GameFolder = null;
string ProjectFileNameBase;
if (TargetRulesObject.Type == TargetType.Program)
{
IsProgramTarget = true;
ProjectFileNameBase = TargetName;
}
else if (IsEngineTarget)
{
ProjectFileNameBase = EngineProjectFileNameBase;
}
else if (IsEnterpriseTarget)
{
ProjectFileNameBase = EnterpriseProjectFileNameBase;
}
else
{
// Figure out which game project this target belongs to
FileReference 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.Directory;
ProjectFileNameBase = ProjectInfo.GetFileNameWithoutExtension();
}
// Get the suffix to use for this project file. If we have multiple targets of the same type, we'll have to split them out into separate IDE project files.
string GeneratedProjectName = TargetRulesObject.GeneratedProjectName;
if (GeneratedProjectName == null)
{
ProjectFile ExistingProjectFile;
if (ProjectFileMap.TryGetValue(GetRiderProjectLocation(ProjectFileNameBase), out ExistingProjectFile) &&
ExistingProjectFile.ProjectTargets.Any(x => x.TargetRules.Type == TargetRulesObject.Type))
{
GeneratedProjectName = TargetRulesObject.Name;
}
else
{
GeneratedProjectName = ProjectFileNameBase;
}
}
FileReference ProjectFilePath = GetRiderProjectLocation(GeneratedProjectName);
if (TargetRulesObject.Type == TargetType.Game || TargetRulesObject.Type == TargetType.Client ||
TargetRulesObject.Type == TargetType.Server)
{
// Allow platforms to generate stub projects here...
PlatformProjectGenerators.GenerateGameProjectStubs(
InGenerator: this,
InTargetName: TargetName,
InTargetFilepath: TargetFilePath.FullName,
InTargetRules: TargetRulesObject,
InPlatforms: SupportedPlatforms,
InConfigurations: SupportedConfigurations);
}
DirectoryReference BaseFolder;
if (IsProgramTarget)
{
BaseFolder = TargetFilePath.Directory;
}
else if (IsEngineTarget)
{
BaseFolder = UnrealBuildTool.EngineDirectory;
}
else if (IsEnterpriseTarget)
{
BaseFolder = UnrealBuildTool.EnterpriseDirectory;
}
else
{
BaseFolder = GameFolder;
}
bool bProjectAlreadyExisted;
ProjectFile ProjectFile = FindOrAddProject(ProjectFilePath, BaseFolder,
true, out bProjectAlreadyExisted);
ProjectFile.IsForeignProject =
CheckProjectFile != null && !NativeProjects.IsNativeProject(CheckProjectFile);
ProjectFile.IsGeneratedProject = true;
ProjectFile.IsStubProject = UnrealBuildTool.IsProjectInstalled();
if (TargetRulesObject.bBuildInSolutionByDefault.HasValue)
{
ProjectFile.ShouldBuildByDefaultForSolutionTargets =
TargetRulesObject.bBuildInSolutionByDefault.Value;
}
// Add the project to the right output list
if (IsProgramTarget)
{
ProgramProjects[TargetFilePath] = ProjectFile;
}
else if (IsEngineTarget)
{
EngineProject = ProjectFile;
if (UnrealBuildTool.IsEngineInstalled())
{
// Allow engine projects to be created but not built for Installed Engine builds
EngineProject.IsForeignProject = false;
EngineProject.IsGeneratedProject = true;
EngineProject.IsStubProject = true;
}
}
else if (IsEnterpriseTarget)
{
ProjectFile EnterpriseProject = ProjectFile;
if (UnrealBuildTool.IsEnterpriseInstalled())
{
// Allow enterprise projects to be created but not built for Installed Engine builds
EnterpriseProject.IsForeignProject = false;
EnterpriseProject.IsGeneratedProject = true;
EnterpriseProject.IsStubProject = true;
}
}
else
{
if (!bProjectAlreadyExisted)
{
GameProjects.Add(ProjectFile);
// Add the .uproject file for this game/template
FileReference UProjectFilePath =
FileReference.Combine(BaseFolder, ProjectFileNameBase + ".uproject");
if (FileReference.Exists(UProjectFilePath))
{
ProjectFile.AddFileToProject(UProjectFilePath, BaseFolder);
}
else
{
throw new BuildException(
"Not expecting to find a game with no .uproject file. File '{0}' doesn't exist",
UProjectFilePath);
}
}
}
foreach (ProjectTarget ExistingProjectTarget in ProjectFile.ProjectTargets)
{
if (ExistingProjectTarget.TargetRules.Type == TargetRulesObject.Type)
{
throw new BuildException(
"Not expecting project {0} to already have a target rules of with configuration name {1} ({2}) while trying to add: {3}",
ProjectFilePath, TargetRulesObject.Type.ToString(),
ExistingProjectTarget.TargetRules.ToString(), TargetRulesObject.ToString());
}
// Not expecting to have both a game and a program in the same project. These would alias because we share the project and solution configuration names (just because it makes sense to)
if ((ExistingProjectTarget.TargetRules.Type == TargetType.Game &&
TargetRulesObject.Type == TargetType.Program) ||
(ExistingProjectTarget.TargetRules.Type == TargetType.Program &&
TargetRulesObject.Type == TargetType.Game))
{
throw new BuildException(
"Not expecting project {0} to already have a Game/Program target ({1}) associated with it while trying to add: {2}",
ProjectFilePath, ExistingProjectTarget.TargetRules.ToString(),
TargetRulesObject.ToString());
}
}
ProjectTarget ProjectTarget = new ProjectTarget()
{
TargetRules = TargetRulesObject,
TargetFilePath = TargetFilePath,
ProjectFilePath = ProjectFilePath,
UnrealProjectFilePath = CheckProjectFile,
SupportedPlatforms = TargetRulesObject.GetSupportedPlatforms()
.Where(x => UEBuildPlatform.GetBuildPlatform(x, true) != null).ToArray(),
CreateRulesDelegate = (Platform, Configuration) =>
RulesAssembly.CreateTargetRules(TargetName, Platform, Configuration, "", CheckProjectFile,
null)
};
ProjectFile.ProjectTargets.Add(ProjectTarget);
// Make sure the *.Target.cs file is in the project.
ProjectFile.AddFileToProject(TargetFilePath, BaseFolder);
Log.TraceVerbose("Generating target {0} for {1}", TargetRulesObject.Type.ToString(),
ProjectFilePath);
}
}
}
