public static List<string> FindAllRulesSourceFiles( RulesFileType RulesFileType, List<string> AdditionalSearchPaths )
{
List<string> Folders = new List<string>();
// Add all engine source (including third party source)
Folders.Add( Path.Combine( ProjectFileGenerator.EngineRelativePath, "Source" ) );
// @todo plugin: Disallow modules from including plugin modules as dependency modules? (except when the module is part of that plugin)
// Get all the root folders for plugins
List<string> RootFolders = new List<string>();
RootFolders.Add(ProjectFileGenerator.EngineRelativePath);
RootFolders.AddRange(AllGameFolders);
// Find all the plugin source directories
foreach(string RootFolder in RootFolders)
{
string PluginsFolder = Path.Combine(RootFolder, "Plugins");
foreach(string PluginFile in Plugins.EnumeratePlugins(PluginsFolder))
{
string PluginDirectory = Path.GetDirectoryName(PluginFile);
Folders.Add(Path.Combine(PluginDirectory, "Source"));
}
}
// Add all the extra plugin folders
if( ForeignPlugins != null )
{
foreach(string ForeignPlugin in ForeignPlugins)
{
string PluginDirectory = Path.GetDirectoryName(Path.GetFullPath(ForeignPlugin));
Folders.Add(Path.Combine(PluginDirectory, "Source"));
}
}
// Add in the game folders to search
if( AllGameFolders != null )
{
foreach( var GameFolder in AllGameFolders )
{
var GameSourceFolder = Path.GetFullPath(Path.Combine( GameFolder, "Source" ));
Folders.Add( GameSourceFolder );
var GameIntermediateSourceFolder = Path.GetFullPath(Path.Combine(GameFolder, "Intermediate", "Source"));
Folders.Add(GameIntermediateSourceFolder);
}
}
// Process the additional search path, if sent in
if( AdditionalSearchPaths != null )
{
foreach( var AdditionalSearchPath in AdditionalSearchPaths )
{
if (!string.IsNullOrEmpty(AdditionalSearchPath))
{
if (Directory.Exists(AdditionalSearchPath))
{
Folders.Add(AdditionalSearchPath);
}
else
{
throw new BuildException( "Couldn't find AdditionalSearchPath for rules source files '{0}'", AdditionalSearchPath );
}
}
}
}
var SourceFiles = new List<string>();
// Iterate over all the folders to check
foreach( string Folder in Folders )
{
// Check to see if we've already cached source files for this folder
RulesFileCache FolderRulesFileCache;
if (!RootFolderToRulesFileCache.TryGetValue(Folder, out FolderRulesFileCache))
{
FolderRulesFileCache = new RulesFileCache();
FindAllRulesFilesRecursively(new DirectoryInfo(Folder), FolderRulesFileCache);
RootFolderToRulesFileCache[Folder] = FolderRulesFileCache;
if (BuildConfiguration.bPrintDebugInfo)
{
foreach (var CurType in Enum.GetValues(typeof(RulesFileType)))
{
var RulesFiles = FolderRulesFileCache.RulesFilePaths[(int)CurType];
if (RulesFiles != null)
{
Log.TraceVerbose("Found {0} rules files for folder {1} of type {2}", RulesFiles.Count, Folder, CurType.ToString());
}
}
}
}
var RulesFilePathsForType = FolderRulesFileCache.RulesFilePaths[(int)RulesFileType];
if (RulesFilePathsForType != null)
{
foreach (string RulesFilePath in RulesFilePathsForType)
{
if (!SourceFiles.Contains(RulesFilePath))
{
SourceFiles.Add(RulesFilePath);
}
}
}
}
return SourceFiles;
}
/// <summary>
///
/// </summary>
/// <param name="RulesFileType"></param>
/// <param name="GameFolders"></param>
/// <param name="ForeignPlugins"></param>
/// <param name="AdditionalSearchPaths"></param>
/// <param name="bIncludeEngine"></param>
/// <param name="bIncludeEnterprise"></param>
/// <returns></returns>
public static List <FileReference> FindAllRulesSourceFiles(RulesFileType RulesFileType, List <DirectoryReference> GameFolders, List <FileReference> ForeignPlugins, List <DirectoryReference> AdditionalSearchPaths, bool bIncludeEngine = true, bool bIncludeEnterprise = true)
{
List <DirectoryReference> Folders = new List <DirectoryReference>();
// Add all engine source (including third party source)
if (bIncludeEngine)
{
Folders.Add(UnrealBuildTool.EngineSourceDirectory);
}
if (bIncludeEnterprise)
{
Folders.Add(UnrealBuildTool.EnterpriseSourceDirectory);
}
// @todo plugin: Disallow modules from including plugin modules as dependency modules? (except when the module is part of that plugin)
// Get all the root folders for plugins
List <DirectoryReference> RootFolders = new List <DirectoryReference>();
if (bIncludeEngine)
{
RootFolders.Add(UnrealBuildTool.EngineDirectory);
}
if (bIncludeEnterprise)
{
RootFolders.Add(UnrealBuildTool.EnterpriseDirectory);
}
if (GameFolders != null)
{
RootFolders.AddRange(GameFolders);
}
// Find all the plugin source directories
foreach (DirectoryReference RootFolder in RootFolders)
{
DirectoryReference PluginsFolder = DirectoryReference.Combine(RootFolder, "Plugins");
foreach (FileReference PluginFile in Plugins.EnumeratePlugins(PluginsFolder))
{
Folders.Add(DirectoryReference.Combine(PluginFile.Directory, "Source"));
}
}
// Add all the extra plugin folders
if (ForeignPlugins != null)
{
foreach (FileReference ForeignPlugin in ForeignPlugins)
{
Folders.Add(DirectoryReference.Combine(ForeignPlugin.Directory, "Source"));
}
}
// Add in the game folders to search
if (GameFolders != null)
{
foreach (DirectoryReference GameFolder in GameFolders)
{
DirectoryReference GameSourceFolder = DirectoryReference.Combine(GameFolder, "Source");
Folders.Add(GameSourceFolder);
DirectoryReference GameIntermediateSourceFolder = DirectoryReference.Combine(GameFolder, "Intermediate", "Source");
Folders.Add(GameIntermediateSourceFolder);
}
}
// Process the additional search path, if sent in
if (AdditionalSearchPaths != null)
{
foreach (DirectoryReference AdditionalSearchPath in AdditionalSearchPaths)
{
if (AdditionalSearchPath != null)
{
if (DirectoryReference.Exists(AdditionalSearchPath))
{
Folders.Add(AdditionalSearchPath);
}
else
{
throw new BuildException("Couldn't find AdditionalSearchPath for rules source files '{0}'", AdditionalSearchPath);
}
}
}
}
// Iterate over all the folders to check
List <FileReference> SourceFiles = new List <FileReference>();
HashSet <FileReference> UniqueSourceFiles = new HashSet <FileReference>();
foreach (DirectoryReference Folder in Folders)
{
IReadOnlyList <FileReference> SourceFilesForFolder = FindAllRulesFiles(Folder, RulesFileType);
foreach (FileReference SourceFile in SourceFilesForFolder)
{
if (UniqueSourceFiles.Add(SourceFile))
{
SourceFiles.Add(SourceFile);
}
}
}
return(SourceFiles);
}
private static IReadOnlyList <FileReference> FindAllRulesFiles(DirectoryReference Directory, RulesFileType Type)
{
// Check to see if we've already cached source files for this folder
RulesFileCache Cache;
if (!RootFolderToRulesFileCache.TryGetValue(Directory, out Cache))
{
Cache = new RulesFileCache();
FindAllRulesFilesRecursively(Directory, Cache);
RootFolderToRulesFileCache[Directory] = Cache;
}
// Get the list of files of the type we're looking for
if (Type == RulesCompiler.RulesFileType.Module)
{
return(Cache.ModuleRules);
}
else if (Type == RulesCompiler.RulesFileType.Target)
{
return(Cache.TargetRules);
}
else if (Type == RulesCompiler.RulesFileType.AutomationModule)
{
return(Cache.AutomationModules);
}
else
{
throw new BuildException("Unhandled rules type: {0}", Type);
}
}
/// <summary>
/// Finds all the rules of the given type under a given directory
/// </summary>
/// <param name="Directory">Directory to search</param>
/// <param name="Type">Type of rules to return</param>
/// <returns>List of rules files of the given type</returns>
private static IReadOnlyList <FileReference> FindAllRulesFiles(DirectoryReference Directory, RulesFileType Type)
{
// Check to see if we've already cached source files for this folder
RulesFileCache Cache;
if (!RootFolderToRulesFileCache.TryGetValue(Directory, out Cache))
{
Cache = new RulesFileCache();
using (ThreadPoolWorkQueue Queue = new ThreadPoolWorkQueue())
{
DirectoryItem BaseDirectory = DirectoryItem.GetItemByDirectoryReference(Directory);
Queue.Enqueue(() => FindAllRulesFilesRecursively(BaseDirectory, Cache, Queue));
}
Cache.ModuleRules.Sort((A, B) => A.FullName.CompareTo(B.FullName));
Cache.TargetRules.Sort((A, B) => A.FullName.CompareTo(B.FullName));
Cache.AutomationModules.Sort((A, B) => A.FullName.CompareTo(B.FullName));
RootFolderToRulesFileCache[Directory] = Cache;
}
// Get the list of files of the type we're looking for
if (Type == RulesCompiler.RulesFileType.Module)
{
return(Cache.ModuleRules);
}
else if (Type == RulesCompiler.RulesFileType.Target)
{
return(Cache.TargetRules);
}
else if (Type == RulesCompiler.RulesFileType.AutomationModule)
{
return(Cache.AutomationModules);
}
else
{
throw new BuildException("Unhandled rules type: {0}", Type);
}
}
private static IReadOnlyList<FileReference> FindAllRulesFiles(DirectoryReference Directory, RulesFileType Type)
{
// Check to see if we've already cached source files for this folder
RulesFileCache Cache;
if (!RootFolderToRulesFileCache.TryGetValue(Directory, out Cache))
{
Cache = new RulesFileCache();
FindAllRulesFilesRecursively(Directory, Cache);
RootFolderToRulesFileCache[Directory] = Cache;
}
// Get the list of files of the type we're looking for
if (Type == RulesCompiler.RulesFileType.Module)
{
return Cache.ModuleRules;
}
else if (Type == RulesCompiler.RulesFileType.Target)
{
return Cache.TargetRules;
}
else if (Type == RulesCompiler.RulesFileType.AutomationModule)
{
return Cache.AutomationModules;
}
else
{
throw new BuildException("Unhandled rules type: {0}", Type);
}
}
public static List<FileReference> FindAllRulesSourceFiles(RulesFileType RulesFileType, List<DirectoryReference> GameFolders, List<FileReference> ForeignPlugins, List<DirectoryReference> AdditionalSearchPaths, bool bIncludeEngine = true)
{
List<DirectoryReference> Folders = new List<DirectoryReference>();
// Add all engine source (including third party source)
if (bIncludeEngine)
{
Folders.Add(UnrealBuildTool.EngineSourceDirectory);
}
// @todo plugin: Disallow modules from including plugin modules as dependency modules? (except when the module is part of that plugin)
// Get all the root folders for plugins
List<DirectoryReference> RootFolders = new List<DirectoryReference>();
if (bIncludeEngine)
{
RootFolders.Add(UnrealBuildTool.EngineDirectory);
}
if (GameFolders != null)
{
RootFolders.AddRange(GameFolders);
}
// Find all the plugin source directories
foreach (DirectoryReference RootFolder in RootFolders)
{
DirectoryReference PluginsFolder = DirectoryReference.Combine(RootFolder, "Plugins");
foreach (FileReference PluginFile in Plugins.EnumeratePlugins(PluginsFolder))
{
Folders.Add(DirectoryReference.Combine(PluginFile.Directory, "Source"));
}
}
// Add all the extra plugin folders
if (ForeignPlugins != null)
{
foreach (FileReference ForeignPlugin in ForeignPlugins)
{
Folders.Add(DirectoryReference.Combine(ForeignPlugin.Directory, "Source"));
}
}
// Add in the game folders to search
if (GameFolders != null)
{
foreach (DirectoryReference GameFolder in GameFolders)
{
DirectoryReference GameSourceFolder = DirectoryReference.Combine(GameFolder, "Source");
Folders.Add(GameSourceFolder);
DirectoryReference GameIntermediateSourceFolder = DirectoryReference.Combine(GameFolder, "Intermediate", "Source");
Folders.Add(GameIntermediateSourceFolder);
}
}
// Process the additional search path, if sent in
if (AdditionalSearchPaths != null)
{
foreach (DirectoryReference AdditionalSearchPath in AdditionalSearchPaths)
{
if (AdditionalSearchPath != null)
{
if (AdditionalSearchPath.Exists())
{
Folders.Add(AdditionalSearchPath);
}
else
{
throw new BuildException("Couldn't find AdditionalSearchPath for rules source files '{0}'", AdditionalSearchPath);
}
}
}
}
// Iterate over all the folders to check
List<FileReference> SourceFiles = new List<FileReference>();
HashSet<FileReference> UniqueSourceFiles = new HashSet<FileReference>();
foreach (DirectoryReference Folder in Folders)
{
IReadOnlyList<FileReference> SourceFilesForFolder = FindAllRulesFiles(Folder, RulesFileType);
foreach (FileReference SourceFile in SourceFilesForFolder)
{
if (UniqueSourceFiles.Add(SourceFile))
{
SourceFiles.Add(SourceFile);
}
}
}
return SourceFiles;
}
