/// <summary>
/// Gets all the runtime dependencies Copies all the runtime dependencies from any modules in
/// </summary>
/// <param name="RuntimeDependencies">The output list of runtime dependencies, mapping target file to type</param>
/// <param name="TargetFileToSourceFile">Map of target files to source files that need to be copied</param>
/// <param name="ExeDir">Output directory for the executable</param>
public void PrepareRuntimeDependencies(List <RuntimeDependency> RuntimeDependencies, Dictionary <FileReference, FileReference> TargetFileToSourceFile, DirectoryReference ExeDir)
{
foreach (UEBuildModule Module in Modules)
{
foreach (ModuleRules.RuntimeDependency Dependency in Module.Rules.RuntimeDependencies.Inner)
{
if (Dependency.SourcePath == null)
{
// Expand the target path
string ExpandedPath = Module.ExpandPathVariables(Dependency.Path, OutputDir, ExeDir);
if (FileFilter.FindWildcardIndex(ExpandedPath) == -1)
{
RuntimeDependencies.Add(new RuntimeDependency(new FileReference(ExpandedPath), Dependency.Type));
}
else
{
RuntimeDependencies.AddRange(FileFilter.ResolveWildcard(ExpandedPath).Select(x => new RuntimeDependency(x, Dependency.Type)));
}
}
else
{
// Parse the source and target patterns
FilePattern SourcePattern = new FilePattern(UnrealBuildTool.EngineSourceDirectory, Module.ExpandPathVariables(Dependency.SourcePath, OutputDir, ExeDir));
FilePattern TargetPattern = new FilePattern(UnrealBuildTool.EngineSourceDirectory, Module.ExpandPathVariables(Dependency.Path, OutputDir, ExeDir));
// Resolve all the wildcards between the source and target paths
Dictionary <FileReference, FileReference> Mapping;
try
{
Mapping = FilePattern.CreateMapping(null, ref SourcePattern, ref TargetPattern);
}
catch (FilePatternException Ex)
{
ExceptionUtils.AddContext(Ex, "while creating runtime dependencies for module '{0}'", Module.Name);
throw;
}
// Add actions to copy everything
foreach (KeyValuePair <FileReference, FileReference> Pair in Mapping)
{
FileReference ExistingSourceFile;
if (!TargetFileToSourceFile.TryGetValue(Pair.Key, out ExistingSourceFile))
{
TargetFileToSourceFile[Pair.Key] = Pair.Value;
RuntimeDependencies.Add(new RuntimeDependency(Pair.Key, Dependency.Type));
}
else if (ExistingSourceFile != Pair.Value)
{
throw new BuildException("Runtime dependency '{0}' is configured to be staged from '{1}' and '{2}'", Pair.Key, Pair.Value, ExistingSourceFile);
}
}
}
}
}
}
/// <summary>
/// Construct a PluginReferenceDescriptor from a Json object
/// </summary>
/// <param name="RawObject">The Json object containing a plugin reference descriptor</param>
/// <returns>New PluginReferenceDescriptor object</returns>
public static PluginReferenceDescriptor FromJsonObject(JsonObject RawObject)
{
string[] WhitelistPlatformNames = null;
string[] BlacklistPlatformNames = null;
string[] SupportedTargetPlatformNames = null;
PluginReferenceDescriptor Descriptor = new PluginReferenceDescriptor(RawObject.GetStringField("Name"), null, RawObject.GetBoolField("Enabled"));
RawObject.TryGetBoolField("Optional", out Descriptor.bOptional);
RawObject.TryGetStringField("Description", out Descriptor.Description);
RawObject.TryGetStringField("MarketplaceURL", out Descriptor.MarketplaceURL);
// Only parse platform information if enabled
if (Descriptor.bEnabled)
{
RawObject.TryGetStringArrayField("WhitelistPlatforms", out WhitelistPlatformNames);
RawObject.TryGetStringArrayField("BlacklistPlatforms", out BlacklistPlatformNames);
RawObject.TryGetEnumArrayField <UnrealTargetConfiguration>("WhitelistTargetConfigurations", out Descriptor.WhitelistTargetConfigurations);
RawObject.TryGetEnumArrayField <UnrealTargetConfiguration>("BlacklistTargetConfigurations", out Descriptor.BlacklistTargetConfigurations);
RawObject.TryGetEnumArrayField <TargetType>("WhitelistTargets", out Descriptor.WhitelistTargets);
RawObject.TryGetEnumArrayField <TargetType>("BlacklistTargets", out Descriptor.BlacklistTargets);
RawObject.TryGetStringArrayField("SupportedTargetPlatforms", out SupportedTargetPlatformNames);
}
try
{
// convert string array to UnrealTargetPlatform arrays
if (WhitelistPlatformNames != null)
{
Descriptor.WhitelistPlatforms = WhitelistPlatformNames.Select(x => UnrealTargetPlatform.Parse(x)).ToList();
}
if (BlacklistPlatformNames != null)
{
Descriptor.BlacklistPlatforms = BlacklistPlatformNames.Select(x => UnrealTargetPlatform.Parse(x)).ToList();
}
if (SupportedTargetPlatformNames != null)
{
Descriptor.SupportedTargetPlatforms = SupportedTargetPlatformNames.Select(x => UnrealTargetPlatform.Parse(x)).ToList();
}
}
catch (BuildException Ex)
{
ExceptionUtils.AddContext(Ex, "while parsing PluginReferenceDescriptor {0}", Descriptor.Name);
throw;
}
return(Descriptor);
}
/// <summary>
/// Reads a plugin descriptor from a json object
/// </summary>
/// <param name="RawObject">The object to read from</param>
/// <returns>New plugin descriptor</returns>
public PluginDescriptor(JsonObject RawObject)
{
// Read the version
if (!RawObject.TryGetIntegerField("FileVersion", out FileVersion))
{
if (!RawObject.TryGetIntegerField("PluginFileVersion", out FileVersion))
{
throw new BuildException("Plugin descriptor does not contain a valid FileVersion entry");
}
}
// Check it's not newer than the latest version we can parse
if (FileVersion > (int)PluginDescriptorVersion.Latest)
{
throw new BuildException("Plugin descriptor appears to be in a newer version ({0}) of the file format that we can load (max version: {1}).", FileVersion, (int)PluginDescriptorVersion.Latest);
}
// Read the other fields
RawObject.TryGetIntegerField("Version", out Version);
RawObject.TryGetStringField("VersionName", out VersionName);
RawObject.TryGetStringField("FriendlyName", out FriendlyName);
RawObject.TryGetStringField("Description", out Description);
if (!RawObject.TryGetStringField("Category", out Category))
{
// Category used to be called CategoryPath in .uplugin files
RawObject.TryGetStringField("CategoryPath", out Category);
}
// Due to a difference in command line parsing between Windows and Mac, we shipped a few Mac samples containing
// a category name with escaped quotes. Remove them here to make sure we can list them in the right category.
if (Category != null && Category.Length >= 2 && Category.StartsWith("\"") && Category.EndsWith("\""))
{
Category = Category.Substring(1, Category.Length - 2);
}
RawObject.TryGetStringField("CreatedBy", out CreatedBy);
RawObject.TryGetStringField("CreatedByURL", out CreatedByURL);
RawObject.TryGetStringField("DocsURL", out DocsURL);
RawObject.TryGetStringField("MarketplaceURL", out MarketplaceURL);
RawObject.TryGetStringField("SupportURL", out SupportURL);
RawObject.TryGetStringField("EngineVersion", out EngineVersion);
RawObject.TryGetStringArrayField("SupportedPrograms", out SupportedPrograms);
RawObject.TryGetBoolField("bIsPluginExtension", out bIsPluginExtension);
try
{
string[] SupportedTargetPlatformNames;
if (RawObject.TryGetStringArrayField("SupportedTargetPlatforms", out SupportedTargetPlatformNames))
{
SupportedTargetPlatforms = Array.ConvertAll(SupportedTargetPlatformNames, x => UnrealTargetPlatform.Parse(x));
}
}
catch (BuildException Ex)
{
ExceptionUtils.AddContext(Ex, "while parsing SupportedTargetPlatforms in plugin with FriendlyName '{0}'", FriendlyName);
throw;
}
JsonObject[] ModulesArray;
if (RawObject.TryGetObjectArrayField("Modules", out ModulesArray))
{
Modules = Array.ConvertAll(ModulesArray, x => ModuleDescriptor.FromJsonObject(x));
}
JsonObject[] LocalizationTargetsArray;
if (RawObject.TryGetObjectArrayField("LocalizationTargets", out LocalizationTargetsArray))
{
LocalizationTargets = Array.ConvertAll(LocalizationTargetsArray, x => LocalizationTargetDescriptor.FromJsonObject(x));
}
bool bEnabledByDefaultValue;
if (RawObject.TryGetBoolField("EnabledByDefault", out bEnabledByDefaultValue))
{
bEnabledByDefault = bEnabledByDefaultValue;
}
RawObject.TryGetBoolField("CanContainContent", out bCanContainContent);
RawObject.TryGetBoolField("IsBetaVersion", out bIsBetaVersion);
RawObject.TryGetBoolField("IsExperimentalVersion", out bIsExperimentalVersion);
RawObject.TryGetBoolField("Installed", out bInstalled);
bool bCanBeUsedWithUnrealHeaderTool;
if (RawObject.TryGetBoolField("CanBeUsedWithUnrealHeaderTool", out bCanBeUsedWithUnrealHeaderTool) && bCanBeUsedWithUnrealHeaderTool)
{
Array.Resize(ref SupportedPrograms, (SupportedPrograms == null)? 1 : SupportedPrograms.Length + 1);
SupportedPrograms[SupportedPrograms.Length - 1] = "UnrealHeaderTool";
}
RawObject.TryGetBoolField("RequiresBuildPlatform", out bRequiresBuildPlatform);
CustomBuildSteps.TryRead(RawObject, "PreBuildSteps", out PreBuildSteps);
CustomBuildSteps.TryRead(RawObject, "PostBuildSteps", out PostBuildSteps);
JsonObject[] PluginsArray;
if (RawObject.TryGetObjectArrayField("Plugins", out PluginsArray))
{
Plugins = Array.ConvertAll(PluginsArray, x => PluginReferenceDescriptor.FromJsonObject(x));
}
}
/// <summary>
/// Constructs a ModuleDescriptor from a Json object
/// </summary>
/// <param name="InObject"></param>
/// <returns>The new module descriptor</returns>
public static ModuleDescriptor FromJsonObject(JsonObject InObject)
{
ModuleDescriptor Module = new ModuleDescriptor(InObject.GetStringField("Name"), InObject.GetEnumField <ModuleHostType>("Type"));
ModuleLoadingPhase LoadingPhase;
if (InObject.TryGetEnumField <ModuleLoadingPhase>("LoadingPhase", out LoadingPhase))
{
Module.LoadingPhase = LoadingPhase;
}
try
{
string[] WhitelistPlatforms;
if (InObject.TryGetStringArrayField("WhitelistPlatforms", out WhitelistPlatforms))
{
Module.WhitelistPlatforms = Array.ConvertAll(WhitelistPlatforms, x => UnrealTargetPlatform.Parse(x));
}
string[] BlacklistPlatforms;
if (InObject.TryGetStringArrayField("BlacklistPlatforms", out BlacklistPlatforms))
{
Module.BlacklistPlatforms = Array.ConvertAll(BlacklistPlatforms, x => UnrealTargetPlatform.Parse(x));
}
}
catch (BuildException Ex)
{
ExceptionUtils.AddContext(Ex, "while parsing module descriptor '{0}'", Module.Name);
throw;
}
TargetType[] WhitelistTargets;
if (InObject.TryGetEnumArrayField <TargetType>("WhitelistTargets", out WhitelistTargets))
{
Module.WhitelistTargets = WhitelistTargets;
}
TargetType[] BlacklistTargets;
if (InObject.TryGetEnumArrayField <TargetType>("BlacklistTargets", out BlacklistTargets))
{
Module.BlacklistTargets = BlacklistTargets;
}
UnrealTargetConfiguration[] WhitelistTargetConfigurations;
if (InObject.TryGetEnumArrayField <UnrealTargetConfiguration>("WhitelistTargetConfigurations", out WhitelistTargetConfigurations))
{
Module.WhitelistTargetConfigurations = WhitelistTargetConfigurations;
}
UnrealTargetConfiguration[] BlacklistTargetConfigurations;
if (InObject.TryGetEnumArrayField <UnrealTargetConfiguration>("BlacklistTargetConfigurations", out BlacklistTargetConfigurations))
{
Module.BlacklistTargetConfigurations = BlacklistTargetConfigurations;
}
string[] WhitelistPrograms;
if (InObject.TryGetStringArrayField("WhitelistPrograms", out WhitelistPrograms))
{
Module.WhitelistPrograms = WhitelistPrograms;
}
string[] BlacklistPrograms;
if (InObject.TryGetStringArrayField("BlacklistPrograms", out BlacklistPrograms))
{
Module.BlacklistPrograms = BlacklistPrograms;
}
string[] AdditionalDependencies;
if (InObject.TryGetStringArrayField("AdditionalDependencies", out AdditionalDependencies))
{
Module.AdditionalDependencies = AdditionalDependencies;
}
return(Module);
}