public override void AddFilesToManifest(BuildManifest Manifest, UEBuildBinary Binary)
{
// ok, this is pretty awful, we want the import libraries that go with the editor, only on the PC
if (UnrealBuildTool.BuildingRocket() &&
Path.GetFileNameWithoutExtension(Binary.Config.OutputFilePath).StartsWith("UE4Editor-", StringComparison.InvariantCultureIgnoreCase) &&
Path.GetExtension(Binary.Config.OutputFilePath).EndsWith("dll", StringComparison.InvariantCultureIgnoreCase) &&
Binary.Config.Type == UEBuildBinaryType.DynamicLinkLibrary)
{
// ok, this is pretty awful, we want the import libraries that go with the editor, only on the PC
Manifest.AddBuildProduct(Path.Combine(Binary.Config.IntermediateDirectory, Path.GetFileNameWithoutExtension(Binary.Config.OutputFilePath) + ".lib"), "");
}
}
/// <summary>
/// Write the project files manifest
/// This is used by CIS to verify all files referenced are checked into perforce.
/// </summary>
protected virtual bool WriteProjectFileManifest()
{
BuildManifest Manifest = new BuildManifest();
foreach( var CurProject in GeneratedProjectFiles )
{
foreach( var SourceFile in CurProject.SourceFiles )
{
Manifest.AddBuildProduct( SourceFile.FilePath );
}
}
string ManifestName = Path.Combine( ProjectFileGenerator.IntermediateProjectFilesPath, "UE4SourceFiles.xml" );
Utils.WriteClass<BuildManifest>( Manifest, ManifestName, "" );
return true;
}
public override void AddFilesToManifest(BuildManifest Manifest, UEBuildBinary Binary)
{
if (Binary.Target.GlobalLinkEnvironment.Config.bIsBuildingConsoleApplication)
{
return;
}
if (BundleContentsDirectory == "" && Binary.Config.Type == UEBuildBinaryType.Executable)
{
BundleContentsDirectory = Path.GetDirectoryName(Path.GetDirectoryName(Binary.Config.OutputFilePath)) + "/";
}
// We need to know what third party dylibs would be copied to the bundle
var Modules = Binary.GetAllDependencyModules(bIncludeDynamicallyLoaded: false, bForceCircular: false);
var BinaryLinkEnvironment = Binary.Target.GlobalLinkEnvironment.DeepCopy();
var BinaryDependencies = new List<UEBuildBinary>();
var LinkEnvironmentVisitedModules = new Dictionary<UEBuildModule, bool>();
foreach (var Module in Modules)
{
Module.SetupPrivateLinkEnvironment(ref BinaryLinkEnvironment, ref BinaryDependencies, ref LinkEnvironmentVisitedModules);
}
foreach (string AdditionalLibrary in BinaryLinkEnvironment.Config.AdditionalLibraries)
{
string LibName = Path.GetFileName(AdditionalLibrary);
if (LibName.StartsWith("lib"))
{
if (Path.GetExtension(AdditionalLibrary) == ".dylib")
{
string Entry = BundleContentsDirectory + "MacOS/" + LibName;
Manifest.AddBuildProduct(Entry);
}
}
}
foreach (UEBuildBundleResource Resource in BinaryLinkEnvironment.Config.AdditionalBundleResources)
{
if (Directory.Exists(Resource.ResourcePath))
{
foreach (string ResourceFile in Directory.GetFiles(Resource.ResourcePath, "*", SearchOption.AllDirectories))
{
Manifest.AddBuildProduct(Path.Combine(BundleContentsDirectory, Resource.BundleContentsSubdir, ResourceFile.Substring(Path.GetDirectoryName(Resource.ResourcePath).Length + 1)));
}
}
else
{
Manifest.AddBuildProduct(Path.Combine(BundleContentsDirectory, Resource.BundleContentsSubdir, Path.GetFileName(Resource.ResourcePath)));
}
}
if (Binary.Config.Type == UEBuildBinaryType.Executable)
{
// And we also need all the resources
Manifest.AddBuildProduct(BundleContentsDirectory + "Info.plist");
Manifest.AddBuildProduct(BundleContentsDirectory + "PkgInfo");
Manifest.AddBuildProduct(BundleContentsDirectory + "Resources/UE4.icns");
if (Binary.Config.TargetName.StartsWith("UE4Editor"))
{
Manifest.AddBuildProduct(BundleContentsDirectory + "Resources/UProject.icns");
}
}
}
public override void AddFilesToManifest(BuildManifest Manifest, UEBuildBinary Binary)
{
if (BuildConfiguration.bCreateStubIPA)
{
string StubFile = Path.Combine (Path.GetDirectoryName (Binary.Config.OutputFilePath), Path.GetFileNameWithoutExtension (Binary.Config.OutputFilePath) + ".stub");
Manifest.AddBuildProduct(StubFile);
}
}
public override void AddFilesToManifest(BuildManifest Manifest, UEBuildBinary Binary)
{
// the binary will have all of the .so's in the output files, we need to trim down to the shared apk (which is what needs to go into the manifest)
foreach (string BinaryPath in Binary.Config.OutputFilePaths)
{
string ApkFile = Path.ChangeExtension(BinaryPath, ".apk");
Manifest.AddBuildProduct(ApkFile);
}
}
public override void AddFilesToManifest(BuildManifest Manifest, UEBuildBinary Binary)
{
// we need to include the generated .mem file.
Manifest.AddBuildProduct(Binary.Config.OutputFilePath + ".mem");
}
/** Generates a public manifest file for writing out */
public void GenerateManifest()
{
string ManifestPath;
if (UnrealBuildTool.RunningRocket() && UnrealBuildTool.HasUProjectFile())
{
ManifestPath = Path.Combine(UnrealBuildTool.GetUProjectPath(), BuildConfiguration.BaseIntermediateFolder, "Manifest.xml");
}
else
{
ManifestPath = "../Intermediate/Build/Manifest.xml";
}
BuildManifest Manifest = new BuildManifest();
if (UEBuildConfiguration.bMergeManifests)
{
// Load in existing manifest (if any)
Manifest = Utils.ReadClass<BuildManifest>(ManifestPath);
}
// Expand all the paths in the receipt; they'll currently use variables for the engine and project directories
BuildReceipt ReceiptWithFullPaths = new BuildReceipt(Receipt);
ReceiptWithFullPaths.ExpandPathVariables(BuildConfiguration.RelativeEnginePath, ProjectDirectory);
foreach(BuildProduct BuildProduct in ReceiptWithFullPaths.BuildProducts)
{
// If we're cleaning, don't add any precompiled binaries to the manifest. We don't want to delete them.
if(UEBuildConfiguration.bCleanProject && bUsePrecompiled && BuildProduct.IsPrecompiled)
{
continue;
}
// Don't add static libraries into the manifest unless we're explicitly building them; we don't submit them to Perforce.
if(!UEBuildConfiguration.bCleanProject && !bPrecompile && (BuildProduct.Type == BuildProductType.StaticLibrary || BuildProduct.Type == BuildProductType.ImportLibrary))
{
continue;
}
// Otherwise add it
Manifest.AddBuildProduct(BuildProduct.Path);
}
IUEBuildPlatform BuildPlatform = UEBuildPlatform.GetBuildPlatform(Platform);
if(OnlyModules.Count == 0)
{
Manifest.AddBuildProduct(BuildReceipt.GetDefaultPath(ProjectDirectory, TargetName, Platform, Configuration, BuildPlatform.GetActiveArchitecture()));
}
if (UEBuildConfiguration.bCleanProject)
{
CleanTarget(Manifest);
}
if (UEBuildConfiguration.bGenerateManifest)
{
Utils.WriteClass<BuildManifest>(Manifest, ManifestPath, "");
}
}
/** Generates a public manifest file for writing out */
public void GenerateManifest(IUEToolChain ToolChain, List<UEBuildBinary> Binaries, CPPTargetPlatform Platform, List<string> SpecialRocketLibFilesThatAreBuildProducts)
{
string ManifestPath;
if (UnrealBuildTool.RunningRocket())
{
ManifestPath = Path.Combine(UnrealBuildTool.GetUProjectPath(), BuildConfiguration.BaseIntermediateFolder, "Manifest.xml");
}
else
{
ManifestPath = "../Intermediate/Build/Manifest.xml";
}
BuildManifest Manifest = new BuildManifest();
if (UEBuildConfiguration.bMergeManifests)
{
// Load in existing manifest (if any)
Manifest = Utils.ReadClass<BuildManifest>(ManifestPath);
}
UnrealTargetPlatform TargetPlatform = CPPTargetPlatformToUnrealTargetPlatform( Platform );
var BuildPlatform = UEBuildPlatform.GetBuildPlatform( TargetPlatform );
// Iterate over all the binaries, and add the relevant info to the manifest
foreach( UEBuildBinary Binary in Binaries )
{
// Get the platform specific extension for debug info files
// Don't add static library files to the manifest as we do not check them into perforce.
// However, add them to the manifest when cleaning the project as we do want to delete
// them in that case.
if (UEBuildConfiguration.bCleanProject == false)
{
if (Binary.Config.Type == UEBuildBinaryType.StaticLibrary)
{
continue;
}
}
string DebugInfoExtension = BuildPlatform.GetDebugInfoExtension(Binary.Config.Type);
// Create and add the binary and associated debug info
foreach (string OutputFilePath in Binary.Config.OutputFilePaths)
{
Manifest.AddBuildProduct(OutputFilePath, DebugInfoExtension);
}
// Add all the stripped debug symbols
if(UnrealBuildTool.BuildingRocket() && (Platform == CPPTargetPlatform.Win32 || Platform == CPPTargetPlatform.Win64))
{
foreach(string OutputFilePath in Binary.Config.OutputFilePaths)
{
string StrippedPath = Path.Combine(Path.GetDirectoryName(OutputFilePath), Path.GetFileNameWithoutExtension(OutputFilePath) + "-Stripped" + DebugInfoExtension);
Manifest.AddBuildProduct(StrippedPath);
}
}
if (Binary.Config.Type == UEBuildBinaryType.Executable &&
GlobalLinkEnvironment.Config.CanProduceAdditionalConsoleApp &&
UEBuildConfiguration.bBuildEditor)
{
foreach (string OutputFilePath in Binary.Config.OutputFilePaths)
{
Manifest.AddBuildProduct(UEBuildBinary.GetAdditionalConsoleAppPath(OutputFilePath), DebugInfoExtension);
}
}
ToolChain.AddFilesToManifest(Manifest, Binary);
}
{
string DebugInfoExtension = BuildPlatform.GetDebugInfoExtension(UEBuildBinaryType.StaticLibrary);
foreach (var RedistLib in SpecialRocketLibFilesThatAreBuildProducts)
{
Manifest.AddBuildProduct(RedistLib, DebugInfoExtension);
}
}
if (UEBuildConfiguration.bCleanProject)
{
CleanTarget(Binaries, Platform, Manifest);
}
if (UEBuildConfiguration.bGenerateManifest)
{
Utils.WriteClass<BuildManifest>(Manifest, ManifestPath, "");
}
}
