public AzureSpatialAnchorsForOpenXR(ReadOnlyTargetRules Target) : base(Target)
{
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens)
{
// these parameters mandatory for winrt support
bEnableExceptions = true;
bUseUnity = false;
CppStandard = CppStandardVersion.Cpp17;
PublicSystemLibraries.AddRange(new string[] { "shlwapi.lib", "runtimeobject.lib" });
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"AugmentedReality",
"HeadMountedDisplay",
"OpenXRHMD",
"NuGetModule",
"Projects",
"MicrosoftOpenXR"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"AzureSpatialAnchors",
"MicrosoftOpenXR"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay",
"NuGetModule"
}
);
PublicIncludePathModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay",
"NuGetModule"
}
);
string OpenXRPluginIncludePath = Path.Combine(PluginDirectory, "Source", "MicrosoftOpenXR", "Private");
string OpenXRPrivateIncludePath = Path.Combine(PluginDirectory, "Source", "MicrosoftOpenXR", "Private", "External");
PrivateIncludePaths.Add(OpenXRPluginIncludePath);
PrivateIncludePaths.Add(OpenXRPrivateIncludePath);
}
public DX11Audio(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string DirectXSDKDir = "";
if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
DirectXSDKDir = Target.WindowsPlatform.bUseWindowsSDK10 ?
Target.UEThirdPartySourceDirectory + "Windows/DirectXLegacy" :
Target.UEThirdPartySourceDirectory + "Windows/DirectX";
}
else
{
DirectXSDKDir = Target.UEThirdPartySourceDirectory + "Windows/DirectX";
}
string LibDir = null;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
LibDir = DirectXSDKDir + "/Lib/x64/";
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
LibDir = DirectXSDKDir + "/Lib/x86/";
}
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PublicSystemIncludePaths.Add(DirectXSDKDir + "/include");
PublicAdditionalLibraries.AddRange(
new string[]
{
LibDir + "dxguid.lib",
LibDir + "X3DAudio.lib",
LibDir + "xapobase.lib",
LibDir + "XAPOFX.lib"
}
);
}
else if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
PublicSystemIncludePaths.Add(DirectXSDKDir + "/include");
PublicSystemLibraries.AddRange(
new string[]
{
LibDir + "dxguid.lib",
LibDir + "xapobase.lib"
}
);
}
}
public GoogleSTT(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
// ... add other private include paths required here ...
Path.GetFullPath(Path.Combine(EngineDirectory, "Source/Runtime/AudioCaptureImplementations/AudioCaptureRtAudio/Private")),
}
);
PublicSystemIncludePaths.AddRange(
new string[] {
SystemPath + "Include/10.0.18362.0/um",
SystemPath + "Include/10.0.18362.0/shared",
}
);
PublicSystemLibraryPaths.AddRange(
new string[] {
SystemPath + "Lib/10.0.18362.0/um/x64",
}
);
PublicSystemLibraries.AddRange(
new string[] {
"Crypt32.Lib",
"bcrypt.lib",
"Winhttp.lib",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"InputCore",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"AudioCaptureCore",
"AudioCaptureRtAudio",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
PublicDefinitions.AddRange(
new string[] {
"CPPREST_FORCE_PPLX=0",
"_WIN32_WINNT_VISTA=0",
}
);
LoadThirdParty(Target);
}
public DX11(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string DirectXSDKDir = "";
if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
DirectXSDKDir = Target.WindowsPlatform.bUseWindowsSDK10 ?
Target.UEThirdPartySourceDirectory + "Windows/DirectXLegacy" :
Target.UEThirdPartySourceDirectory + "Windows/DirectX";
}
else
{
DirectXSDKDir = Target.UEThirdPartySourceDirectory + "Windows/DirectX";
}
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
PublicSystemIncludePaths.Add(DirectXSDKDir + "/Include");
PublicDefinitions.Add("WITH_D3DX_LIBS=1");
string LibDir = null;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
LibDir = DirectXSDKDir + "/Lib/x64/";
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
LibDir = DirectXSDKDir + "/Lib/x86/";
}
PublicAdditionalLibraries.AddRange(
new string[] {
LibDir + "dxgi.lib",
LibDir + "d3d9.lib",
LibDir + "d3d11.lib",
LibDir + "dxguid.lib",
LibDir + "d3dcompiler.lib",
(Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ? LibDir + "d3dx11d.lib" : LibDir + "d3dx11.lib",
LibDir + "dinput8.lib",
LibDir + "X3DAudio.lib",
LibDir + "xapobase.lib",
LibDir + "XAPOFX.lib"
}
);
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PublicDefinitions.Add("WITH_D3DX_LIBS=0");
}
else if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
PublicSystemIncludePaths.Add(DirectXSDKDir + "/Include");
PublicDefinitions.Add("WITH_D3DX_LIBS=0");
PublicSystemLibraries.AddRange(
new string[] {
"dxguid.lib",
}
);
}
}
public IOSApsalar(ReadOnlyTargetRules Target) : base(Target)
{
BinariesSubFolder = "NotForLicensees";
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Analytics",
// ... add private dependencies that you statically link with here ...
}
);
PublicIncludePathModuleNames.Add("Analytics");
PublicFrameworks.AddRange(
new string[] {
"CoreTelephony",
"SystemConfiguration",
"UIKit",
"Foundation",
"CoreGraphics",
"MobileCoreServices",
"StoreKit",
"CFNetwork",
"CoreData",
"Security",
"CoreLocation"
});
PublicSystemLibraries.AddRange(
new string[] {
"sqlite3",
"z"
});
bool bHasApsalarSDK =
(System.IO.Directory.Exists(System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "Apsalar")) &&
System.IO.Directory.Exists(System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "Apsalar", "IOS"))) ||
(System.IO.Directory.Exists(System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "NotForLicensees")) &&
System.IO.Directory.Exists(System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "NotForLicensees", "Apsalar")) &&
System.IO.Directory.Exists(System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "NotForLicensees", "Apsalar", "IOS")));
if (bHasApsalarSDK)
{
PublicIncludePaths.Add(Target.UEThirdPartySourceDirectory + "NotForLicensees/Apsalar/IOS/");
PublicAdditionalLibraries.Add(Target.UEThirdPartySourceDirectory + "NotForLicensees/Apsalar/IOS/libApsalar.a");
PublicDefinitions.Add("WITH_APSALAR=1");
}
else
{
PublicDefinitions.Add("WITH_APSALAR=0");
}
}
public MicrosoftOpenXR(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = @"Private\OpenXRCommon.h";
PrivateIncludePaths.AddRange(
new string[] {
// This private include path ensures our newer copy of the openxr headers take precedence over the engine's copy.
"MicrosoftOpenXR/Private/External"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"ApplicationCore",
"Engine",
"Slate",
"SlateCore",
"InputCore",
"OpenXRHMD",
"MicrosoftOpenXRRuntimeSettings",
"HeadMountedDisplay",
"AugmentedReality",
"OpenXRAR",
"RHI",
"RenderCore",
"Projects",
}
);
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd"
}
);
}
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay"
}
);
PublicIncludePathModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay"
}
);
// WinRT with Nuget support
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens)
{
// these parameters mandatory for winrt support
bEnableExceptions = true;
bUseUnity = false;
CppStandard = CppStandardVersion.Cpp17;
PublicSystemLibraries.AddRange(new string [] { "shlwapi.lib", "runtimeobject.lib" });
// prepare everything for nuget
string MyModuleName = GetType().Name;
string NugetFolder = Path.Combine(PluginDirectory, "Intermediate", "Nuget", MyModuleName);
Directory.CreateDirectory(NugetFolder);
string BinariesSubFolder = Path.Combine("Binaries", "ThirdParty", Target.Type.ToString(), Target.Platform.ToString(), Target.Architecture);
PrivateDefinitions.Add(string.Format("THIRDPARTY_BINARY_SUBFOLDER=\"{0}\"", BinariesSubFolder.Replace(@"\", @"\\")));
string BinariesFolder = Path.Combine(PluginDirectory, BinariesSubFolder);
Directory.CreateDirectory(BinariesFolder);
// download nuget
string NugetExe = Path.Combine(NugetFolder, "nuget.exe");
if (!File.Exists(NugetExe))
{
using (System.Net.WebClient myWebClient = new System.Net.WebClient())
{
// we aren't focusing on a specific nuget version, we can use any of them but the latest one is preferable
myWebClient.DownloadFile(@"https://dist.nuget.org/win-x86-commandline/latest/nuget.exe", NugetExe);
}
}
// run nuget to update the packages
{
var StartInfo = new System.Diagnostics.ProcessStartInfo(NugetExe, string.Format("install \"{0}\" -OutputDirectory \"{1}\"", Path.Combine(ModuleDirectory, "packages.config"), NugetFolder));
StartInfo.UseShellExecute = false;
StartInfo.CreateNoWindow = true;
var ExitCode = Utils.RunLocalProcessAndPrintfOutput(StartInfo);
if (ExitCode < 0)
{
throw new BuildException("Failed to get nuget packages. See log for details.");
}
}
// get list of the installed packages, that's needed because the code should get particular versions of the installed packages
string[] InstalledPackages = Utils.RunLocalProcessAndReturnStdOut(NugetExe, string.Format("list -Source \"{0}\"", NugetFolder)).Split(new char[] { '\r', '\n' });
// get WinRT package
string CppWinRTPackage = InstalledPackages.FirstOrDefault(x => x.StartsWith("Microsoft.Windows.CppWinRT"));
if (!string.IsNullOrEmpty(CppWinRTPackage))
{
string CppWinRTName = CppWinRTPackage.Replace(" ", ".");
string CppWinRTExe = Path.Combine(NugetFolder, CppWinRTName, "bin", "cppwinrt.exe");
string CppWinRTFolder = Path.Combine(PluginDirectory, "Intermediate", CppWinRTName, MyModuleName);
Directory.CreateDirectory(CppWinRTFolder);
// search all downloaded packages for winmd files
string[] WinMDFiles = Directory.GetFiles(NugetFolder, "*.winmd", SearchOption.AllDirectories);
// all downloaded winmd file with WinSDK to be processed by cppwinrt.exe
var WinMDFilesStringbuilder = new System.Text.StringBuilder();
foreach (var winmd in WinMDFiles)
{
WinMDFilesStringbuilder.Append(" -input \"");
WinMDFilesStringbuilder.Append(winmd);
WinMDFilesStringbuilder.Append("\"");
}
// generate winrt headers and add them into include paths
var StartInfo = new System.Diagnostics.ProcessStartInfo(CppWinRTExe, string.Format("{0} -input \"{1}\" -output \"{2}\"", WinMDFilesStringbuilder, Target.WindowsPlatform.WindowsSdkVersion, CppWinRTFolder));
StartInfo.UseShellExecute = false;
StartInfo.CreateNoWindow = true;
var ExitCode = Utils.RunLocalProcessAndPrintfOutput(StartInfo);
if (ExitCode < 0)
{
throw new BuildException("Failed to get generate WinRT headers. See log for details.");
}
PrivateIncludePaths.Add(CppWinRTFolder);
}
else
{
// fall back to default WinSDK headers if no winrt package in our list
PrivateIncludePaths.Add(Path.Combine(Target.WindowsPlatform.WindowsSdkDir, "Include", Target.WindowsPlatform.WindowsSdkVersion, "cppwinrt"));
}
// WinRT lib for some job
string QRPackage = InstalledPackages.FirstOrDefault(x => x.StartsWith("Microsoft.MixedReality.QR"));
if (!string.IsNullOrEmpty(QRPackage))
{
string QRFolderName = QRPackage.Replace(" ", ".");
// copying dll and winmd binaries to our local binaries folder
// !!!!! please make sure that you use the path of file! Unreal can't do it for you !!!!!
SafeCopy(Path.Combine(NugetFolder, QRFolderName, @"lib\uap10.0.18362\Microsoft.MixedReality.QR.winmd"),
Path.Combine(BinariesFolder, "Microsoft.MixedReality.QR.winmd"));
SafeCopy(Path.Combine(NugetFolder, QRFolderName, string.Format(@"runtimes\win10-{0}\native\Microsoft.MixedReality.QR.dll", Target.WindowsPlatform.Architecture.ToString())),
Path.Combine(BinariesFolder, "Microsoft.MixedReality.QR.dll"));
// also both both binaries must be in RuntimeDependencies, unless you get failures in Hololens platform
RuntimeDependencies.Add(Path.Combine(BinariesFolder, "Microsoft.MixedReality.QR.dll"));
RuntimeDependencies.Add(Path.Combine(BinariesFolder, "Microsoft.MixedReality.QR.winmd"));
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// Microsoft.VCRTForwarders.140 is needed to run WinRT dlls in Win64 platforms
string VCRTForwardersPackage = InstalledPackages.FirstOrDefault(x => x.StartsWith("Microsoft.VCRTForwarders.140"));
if (!string.IsNullOrEmpty(VCRTForwardersPackage))
{
string VCRTForwardersName = VCRTForwardersPackage.Replace(" ", ".");
foreach (var Dll in Directory.EnumerateFiles(Path.Combine(NugetFolder, VCRTForwardersName, "runtimes/win10-x64/native/release"), "*_app.dll"))
{
string newDll = Path.Combine(BinariesFolder, Path.GetFileName(Dll));
SafeCopy(Dll, newDll);
RuntimeDependencies.Add(newDll);
}
}
string RemotingPackage = InstalledPackages.FirstOrDefault(x => x.StartsWith("Microsoft.Holographic.Remoting.OpenXr"));
if (!string.IsNullOrEmpty(RemotingPackage))
{
string RemotingFolderName = RemotingPackage.Replace(" ", ".");
SafeCopy(Path.Combine(NugetFolder, RemotingFolderName, @"build\native\bin\x64\Desktop\Microsoft.Holographic.AppRemoting.OpenXr.dll"),
Path.Combine(BinariesFolder, "Microsoft.Holographic.AppRemoting.OpenXr.dll"));
SafeCopy(Path.Combine(NugetFolder, RemotingFolderName, @"build\native\bin\x64\Desktop\RemotingXR.json"),
Path.Combine(BinariesFolder, "RemotingXR.json"));
PrivateIncludePaths.Add(Path.Combine(NugetFolder, RemotingFolderName, @"build\native\include\openxr"));
RuntimeDependencies.Add(Path.Combine(BinariesFolder, "Microsoft.Holographic.AppRemoting.OpenXr.dll"));
RuntimeDependencies.Add(Path.Combine(BinariesFolder, "RemotingXR.json"));
}
}
}
}
public AkAudio(ReadOnlyTargetRules Target) : base(Target)
{
string ThirdPartyFolder = Path.Combine(ModuleDirectory, "../../ThirdParty");
AkUEPlatformInstance = AkUEPlatform.GetAkUEPlatformInstance(Target, ThirdPartyFolder);
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivateIncludePathModuleNames.AddRange(new[] { "Settings", "UMG", "TargetPlatform" });
PublicDependencyModuleNames.AddRange(new[] { "UMG", "PhysX", "APEX" });
PrivateDependencyModuleNames.AddRange(new[]
{
"Core",
"CoreUObject",
"Engine",
"SlateCore",
"NetworkReplayStreaming",
"MovieScene",
"MovieSceneTracks",
"Projects",
"Json",
"Slate",
"InputCore",
"Projects"
});
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd",
"DesktopPlatform",
"TargetPlatform"
});
foreach (var Platform in GetAvailablePlatforms(ModuleDirectory))
{
PublicDefinitions.Add("AK_PLATFORM_" + Platform.ToUpper());
}
}
PrivateIncludePaths.Add("AkAudio/Private");
PublicIncludePaths.Add(Path.Combine(ThirdPartyFolder, "include"));
PublicDefinitions.Add("AK_UNREAL_MAX_CONCURRENT_IO=32");
PublicDefinitions.Add("AK_UNREAL_IO_GRANULARITY=32768");
if (Target.Configuration == UnrealTargetConfiguration.Shipping)
{
PublicDefinitions.Add("AK_OPTIMIZED");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && AkUEPlatformInstance.SupportsCommunication)
{
AkLibs.Add("CommunicationCentral");
PublicDefinitions.Add("AK_ENABLE_COMMUNICATION=1");
}
else
{
PublicDefinitions.Add("AK_ENABLE_COMMUNICATION=0");
}
if (AkUEPlatformInstance.SupportsAkAutobahn)
{
AkLibs.Add("AkAutobahn");
PublicDefinitions.Add("AK_SUPPORT_WAAPI=1");
}
else
{
PublicDefinitions.Add("AK_SUPPORT_WAAPI=0");
}
if (AkUEPlatformInstance.SupportsOpus)
{
AkLibs.Add("AkOpusDecoder");
PublicDefinitions.Add("AK_SUPPORT_OPUS=1");
}
else
{
PublicDefinitions.Add("AK_SUPPORT_OPUS=0");
}
if (AkUEPlatformInstance.SupportsDeviceMemory)
{
PublicDefinitions.Add("AK_SUPPORT_DEVICE_MEMORY=1");
}
else
{
PublicDefinitions.Add("AK_SUPPORT_DEVICE_MEMORY=0");
}
// Platform-specific dependencies
#if UE_4_24_OR_LATER
PublicSystemLibraries.AddRange(AkUEPlatformInstance.GetPublicSystemLibraries());
#else
PublicLibraryPaths.AddRange(AkUEPlatformInstance.GetPublicLibraryPaths());
PublicAdditionalLibraries.AddRange(AkUEPlatformInstance.GetPublicSystemLibraries());
#endif
AkLibs.AddRange(AkUEPlatformInstance.GetAdditionalWwiseLibs());
PublicDefinitions.AddRange(AkUEPlatformInstance.GetPublicDefinitions());
PublicDefinitions.Add(string.Format("AK_CONFIGURATION=\"{0}\"", AkUEPlatformInstance.akConfigurationDir));
var AdditionalProperty = AkUEPlatformInstance.GetAdditionalPropertyForReceipt(ModuleDirectory);
if (AdditionalProperty != null)
{
AdditionalPropertiesForReceipt.Add(AdditionalProperty.Item1, AdditionalProperty.Item2);
}
var Frameworks = AkUEPlatformInstance.GetPublicAdditionalFrameworks();
foreach (var fw in Frameworks)
{
#if UE_4_22_OR_LATER
PublicAdditionalFrameworks.Add(new ModuleRules.Framework(fw));
#else
PublicAdditionalFrameworks.Add(new UEBuildFramework(fw));
#endif
}
PublicAdditionalLibraries.AddRange(AkUEPlatformInstance.GetSanitizedAkLibList(AkLibs));
}
public MicrosoftOpenXR(ReadOnlyTargetRules Target) : base(Target)
{
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens)
{
// these parameters mandatory for winrt support
bEnableExceptions = true;
bUseUnity = false;
CppStandard = CppStandardVersion.Cpp17;
PublicSystemLibraries.AddRange(new string[] { "shlwapi.lib", "runtimeobject.lib" });
}
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = @"Private\OpenXRCommon.h";
PrivateIncludePaths.AddRange(
new string[] {
// This private include path ensures our newer copy of the openxr headers take precedence over the engine's copy.
"MicrosoftOpenXR/Private/External"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"ApplicationCore",
"Engine",
"Slate",
"SlateCore",
"InputCore",
"OpenXRHMD",
"MicrosoftOpenXRRuntimeSettings",
"HeadMountedDisplay",
"AugmentedReality",
"OpenXRAR",
"RHI",
"RenderCore",
"Projects",
"NuGetModule"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"NuGetModule"
}
);
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd"
}
);
}
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay",
"NuGetModule"
}
);
PublicIncludePathModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay",
"NuGetModule"
}
);
// DX-specific code for webcam texture processing
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"D3D11RHI",
"D3D12RHI"
});
var EngineDir = Path.GetFullPath(Target.RelativeEnginePath);
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(EngineDir, @"Source\Runtime\Windows\D3D11RHI\Private"),
Path.Combine(EngineDir, @"Source\Runtime\Windows\D3D11RHI\Private\Windows"),
Path.Combine(EngineDir, @"Source\Runtime\D3D12RHI\Private"),
Path.Combine(EngineDir, @"Source\Runtime\D3D12RHI\Private\Windows")
});
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX12");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAPI");
AddEngineThirdPartyPrivateStaticDependencies(Target, "AMD_AGS");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAftermath");
AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelMetricsDiscovery");
AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelExtensionsFramework");
}
}
public MicrosoftOpenXR(ReadOnlyTargetRules Target) : base(Target)
{
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens)
{
// these parameters mandatory for winrt support
bEnableExceptions = true;
bUseUnity = false;
CppStandard = CppStandardVersion.Cpp17;
PublicSystemLibraries.AddRange(new string[] { "shlwapi.lib", "runtimeobject.lib" });
}
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = @"Private\OpenXRCommon.h";
PrivateIncludePaths.AddRange(
new string[] {
// This private include path ensures our newer copy of the openxr headers take precedence over the engine's copy.
"MicrosoftOpenXR/Private/External"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"ApplicationCore",
"Engine",
"Slate",
"SlateCore",
"InputCore",
"OpenXRHMD",
"MicrosoftOpenXRRuntimeSettings",
"HeadMountedDisplay",
"AugmentedReality",
"OpenXRAR",
"RHI",
"RenderCore",
"Projects",
"NuGetModule"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"NuGetModule"
}
);
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd"
}
);
}
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay",
"NuGetModule"
}
);
PublicIncludePathModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay",
"NuGetModule"
}
);
}
