public bool PrepForUATPackageOrDeploy(FileReference ProjectFile, string ProjectName, string ProjectDirectory, WindowsArchitecture Architecture, List <UnrealTargetConfiguration> TargetConfigurations, List <string> ExecutablePaths, string EngineDirectory, bool bForDistribution, string CookFlavor, bool bIsDataDeploy)
{
//@todo need to support dlc and other targets
//string LocalizedContentDirectory = Path.Combine(ProjectDirectory, "Content", "Localization", "Game");
string AbsoluteExeDirectory = Path.GetDirectoryName(ExecutablePaths[0]);
//bool IsGameSpecificExe = ProjectFile != null && AbsoluteExeDirectory.StartsWith(ProjectDirectory);
//string RelativeExeFilePath = Path.Combine(IsGameSpecificExe ? ProjectName : "Engine", "Binaries", "HoloLens", Path.GetFileName(ExecutablePaths[0]));
//string TargetDirectory = Path.Combine(ProjectDirectory, "Saved", "HoloLens");
// If using a secure networking manifest, copy it to the output directory.
string NetworkManifest = Path.Combine(ProjectDirectory, "Config", "HoloLens", "NetworkManifest.xml");
if (File.Exists(NetworkManifest))
{
CopyFile(NetworkManifest, Path.Combine(AbsoluteExeDirectory, "NetworkManifest.xml"), false);
}
// If using Xbox Live generate the json config file expected by the SDK
DirectoryReference ConfigDirRef = DirectoryReference.FromFile(ProjectFile);
if (ConfigDirRef == null && !string.IsNullOrEmpty(UnrealBuildTool.GetRemoteIniPath()))
{
ConfigDirRef = new DirectoryReference(UnrealBuildTool.GetRemoteIniPath());
}
MakeAppXPath = HoloLensExports.GetWindowsSdkToolPath("makeappx.exe");
SignToolPath = HoloLensExports.GetWindowsSdkToolPath("signtool.exe");
return(true);
}
public override bool PrepTargetForDeployment(TargetReceipt Receipt)
{
// Use the project name if possible - InTarget.AppName changes for 'Client'/'Server' builds
string ProjectName = Receipt.ProjectFile != null?Receipt.ProjectFile.GetFileNameWithoutAnyExtensions() : Receipt.Launch.GetFileNameWithoutExtension();
Log.TraceInformation("Prepping {0} for deployment to {1}", ProjectName, Receipt.Platform.ToString());
System.DateTime PrepDeployStartTime = DateTime.UtcNow;
// Note: TargetReceipt.Read now expands path variables internally.
TargetReceipt NewReceipt = null;
FileReference ReceiptFileName = TargetReceipt.GetDefaultPath(Receipt.ProjectDir != null ? Receipt.ProjectDir : UnrealBuildTool.EngineDirectory, Receipt.TargetName, Receipt.Platform, Receipt.Configuration, "Multi");
if (!TargetReceipt.TryRead(ReceiptFileName, UnrealBuildTool.EngineDirectory, out NewReceipt))
{
NewReceipt = new TargetReceipt(Receipt.ProjectFile, Receipt.TargetName, Receipt.TargetType, Receipt.Platform, Receipt.Configuration, Receipt.Version, "Multi");
}
AddWinMDReferencesFromReceipt(Receipt, Receipt.ProjectDir != null ? Receipt.ProjectDir : UnrealBuildTool.EngineDirectory, UnrealBuildTool.EngineDirectory.ParentDirectory.FullName);
//PrepForUATPackageOrDeploy(InTarget.ProjectFile, InAppName, InTarget.ProjectDirectory.FullName, InTarget.OutputPath.FullName, TargetBuildEnvironment.RelativeEnginePath, false, "", false);
List <UnrealTargetConfiguration> TargetConfigs = new List <UnrealTargetConfiguration> {
Receipt.Configuration
};
List <string> ExePaths = new List <string> {
Receipt.Launch.FullName
};
string RelativeEnginePath = UnrealBuildTool.EngineDirectory.MakeRelativeTo(DirectoryReference.GetCurrentDirectory());
WindowsArchitecture Arch = WindowsArchitecture.ARM64;
if (Receipt.Architecture.ToLower() == "x64")
{
Arch = WindowsArchitecture.x64;
}
string SDK = "";
var Results = Receipt.AdditionalProperties.Where(x => x.Name == "SDK");
if (Results.Any())
{
SDK = Results.First().Value;
}
HoloLensExports.InitWindowsSdkToolPath(SDK);
string AbsoluteExeDirectory = Path.GetDirectoryName(ExePaths[0]);
UnrealTargetPlatform Platform = UnrealTargetPlatform.HoloLens;
string IntermediateDirectory = Path.Combine(Receipt.ProjectDir != null ? Receipt.ProjectDir.FullName : UnrealBuildTool.EngineDirectory.FullName, "Intermediate", "Deploy", WindowsExports.GetArchitectureSubpath(Arch));
List <string> UpdatedFiles = new HoloLensManifestGenerator().CreateManifest(Platform, Arch, AbsoluteExeDirectory, IntermediateDirectory, Receipt.ProjectFile, Receipt.ProjectDir != null ? Receipt.ProjectDir.FullName : UnrealBuildTool.EngineDirectory.FullName, TargetConfigs, ExePaths, WinMDReferences);
PrepForUATPackageOrDeploy(Receipt.ProjectFile, ProjectName, Receipt.ProjectDir != null ? Receipt.ProjectDir.FullName : UnrealBuildTool.EngineDirectory.FullName, Arch, TargetConfigs, ExePaths, RelativeEnginePath, false, "", false);
MakePackage(Receipt, NewReceipt, Arch, UpdatedFiles);
CopyDataAndSymbolsBetweenReceipts(Receipt, NewReceipt, Arch);
NewReceipt.Write(ReceiptFileName, UnrealBuildTool.EngineDirectory);
// Log out the time taken to deploy...
double PrepDeployDuration = (DateTime.UtcNow - PrepDeployStartTime).TotalSeconds;
Log.TraceInformation("HoloLens deployment preparation took {0:0.00} seconds", PrepDeployDuration);
return(true);
}
public override void ValidateTarget(TargetRules Target)
{
// WindowsTargetRules are reused for HoloLens, so that build modules can keep the model that reuses "windows" configs for most cases
// That means overriding those settings here that need to be adjusted for HoloLens
// Compiler version and pix flags must be reloaded from the HoloLens hive
// Currently BP-only projects don't load build-related settings from their remote ini when building UE4Game.exe
// (see TargetRules.cs, where the possibly-null project directory is passed to ConfigCache.ReadSettings).
// It's important for HoloLens that we *do* use the project-specific settings when building (VS 2017 vs 2015 and
// retail Windows Store are both examples). Possibly this should be done on all platforms? But in the interest
// of not changing behavior on other platforms I'm limiting the scope.
DirectoryReference IniDirRef = DirectoryReference.FromFile(Target.ProjectFile);
if (IniDirRef == null && !string.IsNullOrEmpty(UnrealBuildTool.GetRemoteIniPath()))
{
IniDirRef = new DirectoryReference(UnrealBuildTool.GetRemoteIniPath());
}
// Stash the current compiler choice (accounts for command line) in case ReadSettings reverts it to default
WindowsCompiler CompilerBeforeReadSettings = Target.HoloLensPlatform.Compiler;
ConfigCache.ReadSettings(IniDirRef, Platform, Target.HoloLensPlatform);
if (Target.HoloLensPlatform.Compiler == WindowsCompiler.Default)
{
if (CompilerBeforeReadSettings != WindowsCompiler.Default)
{
// Previous setting was more specific, use that
Target.HoloLensPlatform.Compiler = CompilerBeforeReadSettings;
}
else
{
Target.HoloLensPlatform.Compiler = WindowsPlatform.GetDefaultCompiler(Target.ProjectFile);
}
}
if (!Target.bGenerateProjectFiles)
{
Log.TraceInformationOnce("Using {0} architecture for deploying to HoloLens device", Target.HoloLensPlatform.Architecture);
}
Target.WindowsPlatform.Compiler = Target.HoloLensPlatform.Compiler;
Target.WindowsPlatform.Architecture = Target.HoloLensPlatform.Architecture;
Target.WindowsPlatform.bPixProfilingEnabled = Target.HoloLensPlatform.bPixProfilingEnabled;
Target.WindowsPlatform.bUseWindowsSDK10 = true;
Target.bDeployAfterCompile = true;
Target.bCompileNvCloth = false; // requires CUDA
// Disable Simplygon support if compiling against the NULL RHI.
if (Target.GlobalDefinitions.Contains("USE_NULL_RHI=1"))
{
Target.bCompileSpeedTree = false;
}
// Use shipping binaries to avoid dependency on nvToolsExt which fails WACK.
if (Target.Configuration == UnrealTargetConfiguration.Shipping)
{
Target.bUseShippingPhysXLibraries = true;
}
// Be resilient to SDKs being uninstalled but still referenced in the INI file
VersionNumber SelectedWindowsSdkVersion;
DirectoryReference SelectedWindowsSdkDir;
if (!WindowsPlatform.TryGetWindowsSdkDir(Target.HoloLensPlatform.Win10SDKVersionString, out SelectedWindowsSdkVersion, out SelectedWindowsSdkDir))
{
Target.HoloLensPlatform.Win10SDKVersionString = "Latest";
}
// Initialize the VC environment for the target, and set all the version numbers to the concrete values we chose.
VCEnvironment Environment = VCEnvironment.Create(Target.WindowsPlatform.Compiler, Platform, Target.WindowsPlatform.Architecture, Target.WindowsPlatform.CompilerVersion, Target.HoloLensPlatform.Win10SDKVersionString, null);
Target.WindowsPlatform.Environment = Environment;
Target.WindowsPlatform.Compiler = Environment.Compiler;
Target.WindowsPlatform.CompilerVersion = Environment.CompilerVersion.ToString();
Target.WindowsPlatform.WindowsSdkVersion = Environment.WindowsSdkVersion.ToString();
// Windows 10 SDK version
// Auto-detect latest compatible by default (recommended), allow for explicit override if necessary
// Validate that the SDK isn't too old, and that the combination of VS and SDK is supported.
Target.HoloLensPlatform.Win10SDKVersion = new Version(Environment.WindowsSdkVersion.ToString());
if (!Target.bGenerateProjectFiles)
{
Log.TraceInformationOnce("Building using Windows SDK version {0} for HoloLens", Target.HoloLensPlatform.Win10SDKVersion);
if (Target.HoloLensPlatform.Win10SDKVersion < MinimumSDKVersionRecommended)
{
Log.TraceWarning("Your Windows SDK version {0} is older than the minimum recommended version ({1}) for HoloLens. Consider upgrading.", Target.HoloLensPlatform.Win10SDKVersion, MinimumSDKVersionRecommended);
}
else if (Target.HoloLensPlatform.Win10SDKVersion > MaximumSDKVersionTested)
{
Log.TraceInformationOnce("Your Windows SDK version ({0}) for HoloLens is newer than the highest tested with this version of UBT ({1}). This is probably fine, but if you encounter issues consider using an earlier SDK.", Target.HoloLensPlatform.Win10SDKVersion, MaximumSDKVersionTested);
}
}
HoloLensExports.InitWindowsSdkToolPath(Target.HoloLensPlatform.Win10SDKVersion.ToString());
}