/// <summary>
/// The configuration class for a binary build.
/// </summary>
/// <param name="InType"></param>
/// <param name="InOutputFilePath"></param>
/// <param name="bInAllowExports"></param>
/// <param name="bInCreateImportLibrarySeparately"></param>
/// <param name="bInIsCrossTarget">For most binaries, this is false. If this is a cross-platform binary build for a specific platform (for example XB1 DLL for a windows editor) this will be true.</param>
/// <param name="InProjectFilePath"></param>
/// <param name="InModuleNames"></param>
public STBuildBinaryConfiguration(
STBuildBinaryType InType,
string[] InOutputFilePaths = null,
string InIntermediateDirectory = null,
bool bInAllowExports = false,
bool bInCreateImportLibrarySeparately = false,
bool bInIncludeDependentLibrariesInLibrary = false,
bool bInAllowCompilation = true,
bool bInHasModuleRules = true,
bool bInIsCrossTarget = false,
bool bInCompileMonolithic = false,
STTargetConfiguration InTargetConfiguration = STTargetConfiguration.Development,
string InTargetName = "",
string InProjectFilePath = "",
List<string> InModuleNames = null
)
{
Type = InType;
OutputFilePaths = InOutputFilePaths != null ? (string[])InOutputFilePaths.Clone() : null;
IntermediateDirectory = InIntermediateDirectory;
bAllowExports = bInAllowExports;
bCreateImportLibrarySeparately = bInCreateImportLibrarySeparately;
bIncludeDependentLibrariesInLibrary = bInIncludeDependentLibrariesInLibrary;
bAllowCompilation = bInAllowCompilation;
bHasModuleRules = bInHasModuleRules;
bIsCrossTarget = bInIsCrossTarget;
bCompileMonolithic = bInCompileMonolithic;
TargetConfiguration = InTargetConfiguration;
TargetName = InTargetName;
ProjectFilePath = InProjectFilePath;
ModuleNames = InModuleNames;
}
/** Given a UBT-built binary name (e.g. "Core"), returns a relative path to the binary for the current build configuration (e.g. "../Binaries/Win64/Core-Win64-Debug.lib") */
public static string[] MakeBinaryPaths(string ModuleName, string BinaryName, STTargetPlatform Platform,
STTargetConfiguration Configuration, STBuildBinaryType BinaryType, TargetRules.TargetType? TargetType, PluginInfo PluginInfo, string AppName, bool bForceNameAsForDevelopment = false, string ExeBinariesSubFolder = null)
{
// Determine the binary extension for the platform and binary type.
var BuildPlatform = STBuildPlatform.GetBuildPlatform(Platform);
string BinaryExtension;
if (!BuildConfiguration.bRunUnrealCodeAnalyzer)
{
BinaryExtension = BuildPlatform.GetBinaryExtension(BinaryType);
}
else
{
BinaryExtension = @"-" + BuildConfiguration.UCAModuleToAnalyze + @".analysis";
}
STTargetConfiguration LocalConfig = Configuration;
if (Configuration == STTargetConfiguration.DebugGame && !String.IsNullOrEmpty(ModuleName) && !RulesCompiler.IsGameModule(ModuleName))
{
LocalConfig = STTargetConfiguration.Development;
}
string ModuleBinariesSubDir = "";
if (BinaryType == STBuildBinaryType.DynamicLinkLibrary && (string.IsNullOrEmpty(ModuleName) == false))
{
// Allow for modules to specify sub-folders in the Binaries folder
var RulesFilename = RulesCompiler.GetModuleFilename(ModuleName);
// Plugins can be binary-only and can have no rules object
if (PluginInfo == null || !String.IsNullOrEmpty(RulesFilename))
{
ModuleRules ModuleRulesObj = RulesCompiler.CreateModuleRules(ModuleName, new TargetInfo(Platform, Configuration, TargetType), out RulesFilename);
if (ModuleRulesObj != null)
{
ModuleBinariesSubDir = ModuleRulesObj.BinariesSubFolder;
}
}
}
else if (BinaryType == STBuildBinaryType.Executable && string.IsNullOrEmpty(ExeBinariesSubFolder) == false)
{
ModuleBinariesSubDir = ExeBinariesSubFolder;
}
//@todo.Rocket: This just happens to work since exp and lib files go into intermediate...
// Build base directory string ("../Binaries/<Platform>/")
string BinariesDirName;
if (TargetType.HasValue && TargetType.Value == TargetRules.TargetType.Program && STBuildTool.HasUProjectFile() && !ProjectFileGenerator.bGenerateProjectFiles)
{
BinariesDirName = Path.Combine(STBuildTool.GetUProjectPath(), "Binaries");
}
else if (PluginInfo != null)
{
BinariesDirName = Path.Combine(PluginInfo.Directory, "Binaries");
}
else
{
BinariesDirName = Path.Combine("..", "Binaries");
}
var BaseDirectory = Path.Combine(BinariesDirName, Platform.ToString());
if (ModuleBinariesSubDir.Length > 0)
{
BaseDirectory = Path.Combine(BaseDirectory, ModuleBinariesSubDir);
}
string BinarySuffix = "";
if ((PluginInfo != null) && (BinaryType != STBuildBinaryType.DynamicLinkLibrary))
{
BinarySuffix = "-Static";
}
// append the architecture to the end of the binary name
BinarySuffix = BuildPlatform.ApplyArchitectureName(BinarySuffix);
string OutBinaryPath = "";
// Append binary file name
string Prefix = "";
if (Platform == STTargetPlatform.Linux && (BinaryType == STBuildBinaryType.DynamicLinkLibrary || BinaryType == STBuildBinaryType.StaticLibrary))
{
Prefix = "lib";
}
if (LocalConfig == STTargetConfiguration.Development || bForceNameAsForDevelopment)
{
OutBinaryPath = Path.Combine(BaseDirectory, String.Format("{3}{0}{1}{2}", BinaryName, BinarySuffix, BinaryExtension, Prefix));
}
else
{
OutBinaryPath = Path.Combine(BaseDirectory, String.Format("{5}{0}-{1}-{2}{3}{4}",
BinaryName, Platform.ToString(), LocalConfig.ToString(), BinarySuffix, BinaryExtension, Prefix));
}
return BuildPlatform.FinalizeBinaryPaths(OutBinaryPath);
}
/** Given a UBT-built binary name (e.g. "Core"), returns a relative path to the binary for the current build configuration (e.g. "../../Binaries/Win64/Core-Win64-Debug.lib") */
public string[] MakeBinaryPaths(string ModuleName, string BinaryName, STBuildBinaryType BinaryType, TargetRules.TargetType? TargetType, PluginInfo PluginInfo, string AppName, bool bForceNameAsForDevelopment = false, string ExeBinariesSubFolder = null)
{
if (String.IsNullOrEmpty(ModuleName) && Configuration == STTargetConfiguration.DebugGame && !bCompileMonolithic)
{
return MakeBinaryPaths(ModuleName, BinaryName, Platform, STTargetConfiguration.Development, BinaryType, TargetType, PluginInfo, AppName, bForceNameAsForDevelopment);
}
else
{
return MakeBinaryPaths(ModuleName, BinaryName, Platform, Configuration, BinaryType, TargetType, PluginInfo, AppName, bForceNameAsForDevelopment, ExeBinariesSubFolder);
}
}
/**
* Get the extension to use for debug info for the given binary type
*
* @param InBinaryType The binary type being built
*
* @return string The debug info extension (i.e. 'pdb')
*/
public override string GetDebugInfoExtension(STBuildBinaryType InBinaryType)
{
switch (InBinaryType)
{
case STBuildBinaryType.DynamicLinkLibrary:
case STBuildBinaryType.Executable:
return ".pdb";
}
return "";
}
/**
* Get the extension to use for the given binary type
*
* @param InBinaryType The binrary type being built
*
* @return string The binary extenstion (ie 'exe' or 'dll')
*/
public override string GetBinaryExtension(STBuildBinaryType InBinaryType)
{
switch (InBinaryType)
{
case STBuildBinaryType.DynamicLinkLibrary:
return ".dll";
case STBuildBinaryType.Executable:
return ".exe";
case STBuildBinaryType.StaticLibrary:
return ".lib";
case STBuildBinaryType.Object:
if (!BuildConfiguration.bRunUnrealCodeAnalyzer)
{
return ".obj";
}
else
{
return @".includes";
}
case STBuildBinaryType.PrecompiledHeader:
return ".pch";
}
return base.GetBinaryExtension(InBinaryType);
}
/**
* Get the extension to use for debug info for the given binary type
*
* @param InBinaryType The binary type being built
*
* @return string The debug info extension (i.e. 'pdb')
*/
public virtual string GetDebugInfoExtension(STBuildBinaryType InBinaryType)
{
throw new BuildException("GetDebugInfoExtension for {0} not handled in {1}", InBinaryType.ToString(), this.ToString());
}
