public libWebSockets(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
if (!Supported)
{
return;
}
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
PublicIncludePaths.Add(IncludeDirectory);
PublicAdditionalLibraries.Add(Path.Combine(WebSocketsPackagePath, "lib", Target.Platform.ToString(), "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(), ConfigName, "websockets_static.lib"));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicIncludePaths.Add(Path.Combine(WebSocketsPackagePath, "include", Target.Platform.ToString(), "ARMv7"));
PublicIncludePaths.Add(Path.Combine(WebSocketsPackagePath, "include", Target.Platform.ToString(), "ARM64"));
PublicIncludePaths.Add(Path.Combine(WebSocketsPackagePath, "include", Target.Platform.ToString(), "x86"));
PublicIncludePaths.Add(Path.Combine(WebSocketsPackagePath, "include", Target.Platform.ToString(), "x64"));
PublicIncludePaths.Add(Path.Combine(WebSocketsPackagePath, "include", Target.Platform.ToString()));
PublicAdditionalLibraries.Add(Path.Combine(WebSocketsPackagePath, "lib", Target.Platform.ToString(), "ARMv7", ConfigName, "libwebsockets.a"));
PublicAdditionalLibraries.Add(Path.Combine(WebSocketsPackagePath, "lib", Target.Platform.ToString(), "ARM64", ConfigName, "libwebsockets.a"));
PublicAdditionalLibraries.Add(Path.Combine(WebSocketsPackagePath, "lib", Target.Platform.ToString(), "x86", ConfigName, "libwebsockets.a"));
PublicAdditionalLibraries.Add(Path.Combine(WebSocketsPackagePath, "lib", Target.Platform.ToString(), "x64", ConfigName, "libwebsockets.a"));
}
else
{
PublicIncludePaths.Add(IncludeDirectory);
PublicAdditionalLibraries.Add(Path.Combine(LibraryDirectory, "libwebsockets.a"));
}
if (bRequireOpenSSL)
{
PublicDependencyModuleNames.Add("OpenSSL");
}
}
public OpenSubdiv(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
// Compile and link with OpenSubDiv
string OpenSubdivPath = Target.UEThirdPartySourceDirectory + "OpenSubdiv/3.2.0";
PublicIncludePaths.Add(OpenSubdivPath + "/opensubdiv");
// @todo mesheditor subdiv: Support other platforms, 32-bit Windows, and older/newer compiler toolchains
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string LibFolder = "/lib/Win64/VS2015";
if (LibFolder != "")
{
bool bDebug = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT);
string ConfigFolder = bDebug ? "/Debug" : "/RelWithDebInfo";
PublicAdditionalLibraries.Add(OpenSubdivPath + LibFolder + ConfigFolder + "/osdCPU.lib");
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
// @todo: build Mac libraries
// string LibFolder = "/lib/Mac";
// string ConfigFolder = bDebug ? "" : "";
//
// PublicAdditionalLibraries.Add(OpenSubdivPath + LibFolder + ConfigFolder + "libosdCPU.a");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
// @todo: build Linux libraries
// string LibFolder = "/lib/Linux/" + Target.Architecture;
//
// PublicAdditionalLibraries.Add(OpenSubdivPath + LibFolder + "libosdCPU.a");
}
}
public coremod(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string CoreModVersion = "4.2.6";
string LibraryPath = Target.UEThirdPartySourceDirectory + "coremod/coremod-" + CoreModVersion + "/";
PublicIncludePaths.Add(LibraryPath + "include/coremod");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.Add(LibraryPath + "/lib/Win64/VS2013/" + "coremod.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicAdditionalLibraries.Add(LibraryPath + "/lib/Win32/VS2013/" + "coremod.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(LibraryPath + "/lib/Mac/libcoremodMac.a");
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
// TODO: Do we still need this?
// PublicLibraryPaths.Add(LibraryPath + "/lib/IOS");
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PublicAdditionalLibraries.Add(LibraryPath + "/lib/Linux/" + Target.Architecture + "/" + "libcoremodLinux.a");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicAdditionalLibraries.Add(LibraryPath + "/lib/Android/x86/libxmp-coremod.a");
PublicAdditionalLibraries.Add(LibraryPath + "/lib/Android/x64/libxmp-coremod.a");
PublicAdditionalLibraries.Add(LibraryPath + "/lib/Android/armeabi-v7a/libxmp-coremod.a");
}
}
private bool LoadLua(ReadOnlyTargetRules Target)
{
string PlatformString = ".a";
switch (Target.Platform)
{
case UnrealTargetPlatform.Win64:
PlatformString = ".x64.lib";
break;
case UnrealTargetPlatform.Win32:
PlatformString = ".x86.lib";
break;
}
string LibrariesPath = Path.Combine(ThirdPartyPath, "Lua", "libraries");
if (Target.Platform != UnrealTargetPlatform.Android)
{
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "lua53" + PlatformString));
}
else
{
PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "arm64-v8a"));
PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "armeabi"));
PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "armeabi-v7a"));
PublicAdditionalLibraries.Add("lua53");
}
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "Lua", "includes"));
PublicDefinitions.Add(string.Format("WITH_LUA_BINDING={0}", 1));
return(true);
}
public SodiumUE4(TargetInfo Target)
{
Definitions.Add("SODIUM_STATIC=1");
Definitions.Add("SODIUM_EXPORT=");
string sodiumIncludes = Path.Combine(ModuleDirectory, "../ThirdParty/libsodium/");
PublicIncludePaths.AddRange(
new string[] {
"SodiumUE4/Public",
sodiumIncludes
}
);
PrivateIncludePaths.AddRange(new string[] { "SodiumUE4/Private" });
PublicDependencyModuleNames.AddRange(new string[] { "Core" });
PrivateDependencyModuleNames.AddRange(
new string[] {
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"Projects"
}
);
string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64" : "Win32";
string path = Path.Combine(ModuleDirectory, "../ThirdParty/libsodium/Build/Release/" + PlatformString + "/libsodium.lib");
PublicAdditionalLibraries.Add(path);
}
public PythonConsole(TargetInfo Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"PythonConsole/Private",
// ... add other private include paths required here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject", // @todo Mac: for some reason it's needed to link in debug on Mac
"Engine",
"InputCore",
"UnrealEd",
"Slate",
"SlateCore",
"EditorStyle",
"TargetPlatform",
"DesktopPlatform",
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
PublicIncludePaths.Add(PythonHome);
PublicAdditionalLibraries.Add(Path.Combine(PythonHome, "libs", "python35.lib"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string mac_python = "/Library/Frameworks/Python.framework/Versions/3.5/";
PublicIncludePaths.Add(Path.Combine(mac_python, "include"));
PublicAdditionalLibraries.Add(Path.Combine(mac_python, "lib", "libpython3.5m.dylib"));
Definitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_MAC=1"));
}
}
public Blackmagic(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicDefinitions.Add("BLACKMAGICMEDIA_DLL_PLATFORM=1");
string SDKDir = ModuleDirectory;
string LibPath = Path.Combine(ModuleDirectory, "../../../Binaries/ThirdParty/Win64");
string LibraryName = "BlackmagicLib";
bool bHaveDebugLib = File.Exists(Path.Combine(LibPath, "BlackmagicLibd.dll"));
if (bHaveDebugLib && Target.Configuration == UnrealTargetConfiguration.Debug)
{
LibraryName = "BlackmagicLibd";
PublicDefinitions.Add("BLACKMAGICMEDIA_DLL_DEBUG=1");
}
else
{
PublicDefinitions.Add("BLACKMAGICMEDIA_DLL_DEBUG=0");
}
PublicIncludePaths.Add(Path.Combine(SDKDir, "Include"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, LibraryName + ".lib"));
PublicDelayLoadDLLs.Add(LibraryName + ".dll");
RuntimeDependencies.Add(Path.Combine(LibPath, LibraryName + ".dll"));
}
else
{
PublicDefinitions.Add("BLACKMAGICMEDIA_DLL_PLATFORM=0");
PublicDefinitions.Add("BLACKMAGICMEDIA_DLL_DEBUG=0");
System.Console.WriteLine("BLACKMAGIC not supported on this platform");
}
}
public DX11Input(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string DirectXSDKDir = Target.UEThirdPartySourceDirectory + "Windows/DirectX";
PublicSystemIncludePaths.Add(DirectXSDKDir + "/include");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicLibraryPaths.Add(DirectXSDKDir + "/Lib/x64");
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicLibraryPaths.Add(DirectXSDKDir + "/Lib/x86");
}
PublicAdditionalLibraries.AddRange(
new string[] {
"dxguid.lib",
"dinput8.lib"
}
);
}
public SSF(TargetInfo Target)
{
Type = ModuleType.External;
string SSFDirectory = UEBuildConfiguration.UEThirdPartySourceDirectory + "NotForLicensees/SSF/";
string SSFLibPath = SSFDirectory;
PublicIncludePaths.Add(SSFDirectory + "Public");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
SSFLibPath = SSFLibPath + "lib/win64/vs" + WindowsPlatform.GetVisualStudioCompilerVersionName() + "/";
PublicLibraryPaths.Add(SSFLibPath);
if (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT)
{
PublicAdditionalLibraries.Add("SSFd.lib");
}
else
{
PublicAdditionalLibraries.Add("SSF.lib");
}
}
}
public DirectSound(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";
}
PublicSystemIncludePaths.Add(DirectXSDKDir + "/include");
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 + "dxguid.lib",
LibDir + "dsound.lib"
}
);
}
public LibSvrApi(ReadOnlyTargetRules Target) : base(Target)
{
// current version of the Snapdragon SDK
Type = ModuleType.External;
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "include"));
//System.Console.WriteLine("[NSVR]"+Path.Combine(ModuleDirectory, "include"));
//string SnapdragonThirdPartyDirectory = UEBuildConfiguration.UEThirdPartySourceDirectory + "Qualcomm/LibSvrApi";
if (Target.Platform == UnrealTargetPlatform.Android)
{
//PublicLibraryPaths.Add(SnapdragonThirdPartyDirectory + "/Libs/Android/armeabi-v7a/");
PublicLibraryPaths.Add(Path.Combine(ModuleDirectory, "Libs", "armeabi-v7a"));
//PublicAdditionalLibraries.Add(SnapdragonThirdPartyDirectory + "/Libs/Android/armeabi-v7a/libsvrapi.so");
PublicAdditionalLibraries.Add("svrapi");
PublicSystemIncludePaths.Add(Path.Combine(ModuleDirectory, "include"));
}
}
public bool LoadLibsndfile(TargetInfo Target)
{
bool isLibrarySupported = false;
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
isLibrarySupported = true;
string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64" : "x86";
string LibrariesPath = Path.Combine(ThirdPartyPath, "libsndfile", PlatformString);
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libsndfile-1.lib"));
}
if (isLibrarySupported)
{
// Include path
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "libsndfile"));
}
Definitions.Add(string.Format("WITH_LIBSNDFILE_BINDING={0}", isLibrarySupported ? 1 : 0));
return(isLibrarySupported);
}
public Crunch(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string BasePath = Target.UEThirdPartySourceDirectory + "Crunch/";
PublicSystemIncludePaths.Add(BasePath + "include");
#if false
string LibPath = BasePath + "Lib/";
if (Target.Type == TargetType.Editor)
{
// link with lib to allow encoding
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
#if false
LibPath += (Target.Platform == UnrealTargetPlatform.Win64) ? "Win64/" : "Win32/";
PublicLibraryPaths.Add(LibPath);
PublicAdditionalLibraries.Add("crnlib.lib");
#endif
string Err = "Crunch not setup yet for this platform";
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
else
{
string Err = "Crunch not setup yet for this platform";
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
}
#endif
}
public bool LoadOmniLib(TargetInfo Target)
{
bool isLibrarySupported = false;
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
isLibrarySupported = true;
string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64" : "Win32";
string LibrariesPath = Path.Combine(ThirdPartyPath, "OpenHaptics", "Lib");
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "hd.lib"));
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicDelayLoadDLLs.Add(Path.Combine(ThirdPartyBinariesPath, "hd.dll"));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(ThirdPartyBinariesPath, "hd.dll")));
}
/* else
* {
* PublicDelayLoadDLLs.Add(Path.Combine(ThirdPartyBinariesPath, "Win32", "hd.dll"));
* RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(ThirdPartyBinariesPath, "Win32", "hd.dll")));
* } */
}
if (isLibrarySupported)
{
// Include path
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "OpenHaptics", "Include"));
}
return(isLibrarySupported);
}
public DirectSound(TargetInfo Target)
{
Type = ModuleType.External;
string DirectXSDKDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "Windows/DirectX";
PublicSystemIncludePaths.Add(DirectXSDKDir + "/include");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicLibraryPaths.Add(DirectXSDKDir + "/Lib/x64");
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicLibraryPaths.Add(DirectXSDKDir + "/Lib/x86");
}
PublicAdditionalLibraries.AddRange(
new string[] {
"dxguid.lib",
"dsound.lib"
}
);
}
public libPhonon(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string LibraryPath = Target.UEThirdPartySourceDirectory + "libPhonon/phonon_api/";
string BinaryPath = "$(EngineDir)/Binaries/ThirdParty/Phonon/";
PublicIncludePaths.Add(LibraryPath + "include");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicLibraryPaths.Add(LibraryPath + "/lib/Win64");
PublicAdditionalLibraries.Add("phonon.lib");
string DllName = "phonon.dll";
PublicDelayLoadDLLs.Add(DllName);
BinaryPath += "Win64/";
RuntimeDependencies.Add(new RuntimeDependency(BinaryPath + DllName));
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicLibraryPaths.Add(LibraryPath + "/lib/Win32");
PublicAdditionalLibraries.Add("phonon.lib");
string DllName = "phonon.dll";
PublicDelayLoadDLLs.Add(DllName);
BinaryPath += "Win32/";
RuntimeDependencies.Add(new RuntimeDependency(BinaryPath + DllName));
}
}
public Kiss_FFT(TargetInfo Target)
{
Type = ModuleType.External;
Definitions.Add("WITH_KISSFFT=1");
// Compile and link with kissFFT
string Kiss_FFTPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "Kiss_FFT/kiss_fft129";
PublicIncludePaths.Add(Kiss_FFTPath);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
if (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT)
{
PublicLibraryPaths.Add(Kiss_FFTPath + "/lib/x64/Debug");
}
else
{
PublicLibraryPaths.Add(Kiss_FFTPath + "/lib/x64/Release");
}
PublicAdditionalLibraries.Add("KissFFT.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT)
{
PublicAdditionalLibraries.Add(Kiss_FFTPath + "/Lib/Mac/Debug/libKissFFT.a");
}
else
{
PublicAdditionalLibraries.Add(Kiss_FFTPath + "/Lib/Mac/Release/libKissFFT.a");
}
}
}
public AMD_AGS(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string AmdAgsPath = Target.UEThirdPartySourceDirectory + "AMD/AMD_AGS/";
PublicSystemIncludePaths.Add(AmdAgsPath + "inc/");
if (Target.Platform.IsInGroup(UnrealPlatformGroup.Windows))
{
string AmdApiLibPath = AmdAgsPath + "lib/VS2017";
if (Target.Platform != UnrealTargetPlatform.Win32)
{
string LibraryName = "amd_ags_x64_2017_MD.lib";
PublicAdditionalLibraries.Add(Path.Combine(AmdApiLibPath, LibraryName));
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
string LibraryName = "amd_ags_x86_2017_MD.lib";
PublicAdditionalLibraries.Add(Path.Combine(AmdApiLibPath, LibraryName));
}
}
}
public bool LoadCreatureLib(TargetInfo Target)
{
bool isLibrarySupported = false;
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
isLibrarySupported = true;
string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64" : "x86";
string LibrariesPath = Path.Combine(ThirdPartyPath, "CreatureLib", "Libraries");
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "CreatureLib." + PlatformString + ".lib"));
}
if (isLibrarySupported)
{
// Include path
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "CreatureLib", "Includes"));
}
Definitions.Add(string.Format("WITH_CREATURE_LIB_BINDING={0}", isLibrarySupported ? 1 : 0));
return(isLibrarySupported);
}
public Proj(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
bEnableExceptions = true;
// add include path
string IncPath = Path.Combine(ModuleDirectory, "include");
PublicSystemIncludePaths.Add(IncPath);
// add lib path
string LibPath = Path.Combine(ModuleDirectory, "lib");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// Explicitly name the used libraries
LibPath = Path.Combine(LibPath, "Win64");
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "proj.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "sqlite3.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "tiff.lib"));
// add macros
PublicDefinitions.Add("__WINDOWS__");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
// Explicitly name the used libraries
LibPath = Path.Combine(LibPath, "Linux");
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libproj.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsqlite3.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libtiff.a"));
}
// add macros
PublicDefinitions.Add("WITH_PROJ_API=1");
}
public IntelMetricsDiscovery(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string IntelMetricsDiscoveryPath = Target.UEThirdPartySourceDirectory + "IntelMetricsDiscovery/MetricsDiscoveryHelper/";
bool bUseDebugBuild = false;
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
string PlatformName = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64" : "x86";
string BuildType = bUseDebugBuild ? "-md-debug" : "-md-release";
PublicSystemIncludePaths.Add(IntelMetricsDiscoveryPath + "build/include/metrics_discovery/");
string LibDir = IntelMetricsDiscoveryPath + "build/lib/" + PlatformName + BuildType + "/";
PublicAdditionalLibraries.Add(LibDir + "metrics_discovery_helper.lib");
PublicDefinitions.Add("INTEL_METRICSDISCOVERY=1");
}
else
{
PublicDefinitions.Add("INTEL_METRICSDISCOVERY=0");
}
}
public XAudio2(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("TargetPlatform");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
// VS2015 updated some of the CRT definitions but not all of the Windows SDK has been updated to match.
// Microsoft provides this shim library to enable building with VS2015 until they fix everything up.
//@todo: remove when no longer neeeded (no other code changes should be necessary).
if (WindowsPlatform.bNeedsLegacyStdioDefinitionsLib)
{
PublicAdditionalLibraries.Add("legacy_stdio_definitions.lib");
}
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PrivateDependencyModuleNames.Add("XMA2");
}
AddEngineThirdPartyPrivateStaticDependencies(Target,
"DX11Audio",
"UEOgg",
"Vorbis",
"VorbisFile"
);
Definitions.Add("WITH_OGGVORBIS=1");
}
public UnrealEnginePython(TargetInfo Target)
#endif
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string enableUnityBuild = System.Environment.GetEnvironmentVariable("UEP_ENABLE_UNITY_BUILD");
bFasterWithoutUnity = string.IsNullOrEmpty(enableUnityBuild);
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Sockets",
"Networking"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"MovieScene",
"LevelSequence",
"HTTP",
"UMG",
"AppFramework",
"RHI",
"Voice",
"RenderCore",
"MovieSceneCapture",
"Landscape",
"Foliage",
"AIModule"
// ... add private dependencies that you statically link with here ...
}
);
#if WITH_FORWARDED_MODULE_RULES_CTOR
BuildVersion Version;
if (BuildVersion.TryRead(BuildVersion.GetDefaultFileName(), out Version))
{
if (Version.MinorVersion >= 18)
{
PrivateDependencyModuleNames.Add("ApplicationCore");
}
}
#endif
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
#if WITH_FORWARDED_MODULE_RULES_CTOR
if (Target.bBuildEditor)
#else
if (UEBuildConfiguration.bBuildEditor)
#endif
{
PrivateDependencyModuleNames.AddRange(new string[] {
"UnrealEd",
"LevelEditor",
"BlueprintGraph",
"Projects",
"Sequencer",
"SequencerWidgets",
"AssetTools",
"LevelSequenceEditor",
"MovieSceneTools",
"MovieSceneTracks",
"CinematicCamera",
"EditorStyle",
"GraphEditor",
"UMGEditor",
"AIGraph",
"RawMesh",
"DesktopWidgets",
"EditorWidgets",
"FBX",
"Persona",
"PropertyEditor",
"LandscapeEditor",
"MaterialEditor"
});
}
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(windowsKnownPaths, "Win64");
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetWindowsPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicAdditionalLibraries.Add(libPath);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(macKnownPaths, "Mac");
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetMacPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicDelayLoadDLLs.Add(libPath);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (pythonHome == "")
{
string includesPath = DiscoverLinuxPythonIncludesPath();
if (includesPath == null)
{
throw new System.Exception("Unable to find Python includes, please add a search path to linuxKnownIncludesPaths");
}
string libsPath = DiscoverLinuxPythonLibsPath();
if (libsPath == null)
{
throw new System.Exception("Unable to find Python libs, please add a search path to linuxKnownLibsPaths");
}
PublicIncludePaths.Add(includesPath);
PublicAdditionalLibraries.Add(libsPath);
}
else
{
string[] items = pythonHome.Split(';');
PublicIncludePaths.Add(items[0]);
PublicAdditionalLibraries.Add(items[1]);
}
}
#if WITH_FORWARDED_MODULE_RULES_CTOR
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicIncludePaths.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/python35/include"));
PublicLibraryPaths.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/armeabi-v7a"));
PublicAdditionalLibraries.Add("python3.5m");
string APLName = "UnrealEnginePython_APL.xml";
string RelAPLPath = Utils.MakePathRelativeTo(System.IO.Path.Combine(ModuleDirectory, APLName), Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", RelAPLPath));
}
#endif
}
public BaseTPLibrary(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
PublicIncludePaths.Add(ModuleDirectory);
PublicDefinitions.Add("USE_IMPORT_EXPORT");
if (Target.Platform == UnrealTargetPlatform.Android)
{
string AndroidPath = System.IO.Path.Combine(ModuleDirectory, UnrealTargetPlatform.Android.ToString());
//Link to the APL (AndroidPluginLanguage) XML file
AdditionalPropertiesForReceipt.Add("AndroidPlugin", System.IO.Path.Combine(ModuleDirectory, "BaseAPL.xml"));
//armeabi-v7a
PublicLibraryPaths.Add(System.IO.Path.Combine(AndroidPath, "armeabi-v7a"));
PublicAdditionalLibraries.Add(System.IO.Path.Combine(AndroidPath, "armeabi-v7a", "libaws-c-common.so"));
RuntimeDependencies.Add(System.IO.Path.Combine(AndroidPath, "armeabi-v7a", "libaws-c-common.so"));
PublicAdditionalLibraries.Add(System.IO.Path.Combine(AndroidPath, "armeabi-v7a", "libaws-checksums.so"));
RuntimeDependencies.Add(System.IO.Path.Combine(AndroidPath, "armeabi-v7a", "libaws-checksums.so"));
PublicAdditionalLibraries.Add(System.IO.Path.Combine(AndroidPath, "armeabi-v7a", "libaws-c-event-stream.so"));
RuntimeDependencies.Add(System.IO.Path.Combine(AndroidPath, "armeabi-v7a", "libaws-c-event-stream.so"));
PublicAdditionalLibraries.Add(System.IO.Path.Combine(AndroidPath, "armeabi-v7a", "libaws-cpp-sdk-core.so"));
RuntimeDependencies.Add(System.IO.Path.Combine(AndroidPath, "armeabi-v7a", "libaws-cpp-sdk-core.so"));
//arm64-v8a
PublicLibraryPaths.Add(System.IO.Path.Combine(AndroidPath, "arm64-v8a"));
PublicAdditionalLibraries.Add(System.IO.Path.Combine(AndroidPath, "arm64-v8a", "libaws-c-common.so"));
RuntimeDependencies.Add(System.IO.Path.Combine(AndroidPath, "arm64-v8a", "libaws-c-common.so"));
PublicAdditionalLibraries.Add(System.IO.Path.Combine(AndroidPath, "arm64-v8a", "libaws-checksums.so"));
RuntimeDependencies.Add(System.IO.Path.Combine(AndroidPath, "arm64-v8a", "libaws-checksums.so"));
PublicAdditionalLibraries.Add(System.IO.Path.Combine(AndroidPath, "arm64-v8a", "libaws-c-event-stream.so"));
RuntimeDependencies.Add(System.IO.Path.Combine(AndroidPath, "arm64-v8a", "libaws-c-event-stream.so"));
PublicAdditionalLibraries.Add(System.IO.Path.Combine(AndroidPath, "arm64-v8a", "libaws-cpp-sdk-core.so"));
RuntimeDependencies.Add(System.IO.Path.Combine(AndroidPath, "arm64-v8a", "libaws-cpp-sdk-core.so"));
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
string WindowPath = System.IO.Path.Combine(ModuleDirectory, UnrealTargetPlatform.Win64.ToString());
PublicLibraryPaths.Add(WindowPath);
PublicAdditionalLibraries.Add(System.IO.Path.Combine(WindowPath, "aws-c-common.lib"));
RuntimeDependencies.Add(System.IO.Path.Combine(WindowPath, "aws-c-common.dll"));
PublicDelayLoadDLLs.Add("aws-c-common.dll");
PublicAdditionalLibraries.Add(System.IO.Path.Combine(WindowPath, "aws-checksums.lib"));
RuntimeDependencies.Add(System.IO.Path.Combine(WindowPath, "aws-checksums.dll"));
PublicDelayLoadDLLs.Add("aws-checksums.dll");
PublicAdditionalLibraries.Add(System.IO.Path.Combine(WindowPath, "aws-c-event-stream.lib"));
RuntimeDependencies.Add(System.IO.Path.Combine(WindowPath, "aws-c-event-stream.dll"));
PublicDelayLoadDLLs.Add("aws-c-event-stream.dll");
PublicAdditionalLibraries.Add(System.IO.Path.Combine(WindowPath, "aws-cpp-sdk-core.lib"));
PublicDelayLoadDLLs.Add("aws-cpp-sdk-core.dll");
RuntimeDependencies.Add(System.IO.Path.Combine(WindowPath, "aws-cpp-sdk-core.dll"));
}
}
public UnrealEngineJNI(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
if (javaHome == null)
{
javaHome = Environment.GetEnvironmentVariable("JAVA_HOME");
if (javaHome == null)
{
Console.WriteLine("JAVA_HOME is not set, compilation will fail...");
}
}
if (javaHome != null)
{
Console.WriteLine("Using JAVA_HOME={0}", javaHome);
if (!Directory.Exists(javaHome))
{
Console.WriteLine("The JAVA_HOME directory does not exist, compilation will fail...");
}
}
PublicIncludePaths.AddRange(
new string[] {
"UnrealEngineJNI/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"UnrealEngineJNI/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// Add the import library
PublicLibraryPaths.Add(Path.Combine(javaHome, "lib"));
PublicAdditionalLibraries.Add("jvm.lib");
PublicIncludePaths.Add(Path.Combine(javaHome, "include"));
PublicIncludePaths.Add(Path.Combine(javaHome, "include", "win32"));
}
}
public KlawrRuntimePlugin(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
// ... add other public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"KlawrRuntimePlugin/Private",
"ThirdParty/Klawr/ClrHostNative/Public"
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"SlateCore",
"Json",
"JsonUtilities"
// ... add other public dependencies that you statically link with here ...
}
);
if (UEBuildConfiguration.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd",
}
);
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
//this needs to be tied to that the code generator has run. when does it run?
var basePath = Path.GetDirectoryName(ModuleDirectory);
var pluginPath = Path.GetFullPath(Path.Combine(basePath, "..", @"Source\ThirdParty\Klawr", Target.Platform.ToString(), "Release", "Klawr.ClrHost.Native-x64-Release.lib"));
if (File.Exists(pluginPath))
{
Definitions.Add("WITH_KLAWR=1");
Log.TraceInformation("Klawr runntime module dir at " + ModuleDirectory);
Log.TraceInformation("Linking " + pluginPath);
PublicLibraryPaths.Add(Path.GetDirectoryName(pluginPath));
PublicAdditionalLibraries.Add(pluginPath);
PrivateDependencyModuleNames.Add("KlawrClrHostNative");
}
else
{
Log.TraceInformation("Error: File not found for runntime plugin: " + pluginPath);
}
}
public OculusHMD(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
// Relative to Engine\Plugins\Runtime\Oculus\OculusVR\Source
"../../../../../Source/Runtime/Renderer/Private",
"../../../../../Source/Runtime/OpenGLDrv/Private",
"../../../../../Source/Runtime/VulkanRHI/Private",
"../../../../../Source/Runtime/Engine/Classes/Components",
});
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateIncludePaths.Add("../../../../../Source/Runtime/VulkanRHI/Private/Android");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateIncludePaths.Add("../../../../../Source/Runtime/VulkanRHI/Private/Linux");
}
else if (Target.Platform == UnrealTargetPlatform.Quail)
{
PrivateIncludePaths.Add("../../../../../Source/Runtime/VulkanRHI/Private/Quail");
}
else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateIncludePaths.Add("../../../../../Source/Runtime/VulkanRHI/Private/Windows");
}
PublicIncludePathModuleNames.Add("Launch");
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"RHI",
"RenderCore",
"Renderer",
"ShaderCore",
"HeadMountedDisplay",
"Slate",
"SlateCore",
"ImageWrapper",
"MediaAssets",
"Analytics",
"UtilityShaders",
"OpenGLDrv",
"VulkanRHI",
"OVRPlugin",
});
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
// D3D
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"D3D11RHI",
"D3D12RHI",
});
PrivateIncludePaths.AddRange(
new string[]
{
"../../../../../Source/Runtime/Windows/D3D11RHI/Private",
"../../../../../Source/Runtime/Windows/D3D11RHI/Private/Windows",
"../../../../../Source/Runtime/D3D12RHI/Private",
"../../../../../Source/Runtime/D3D12RHI/Private/Windows",
});
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX12");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAPI");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11Audio");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectSound");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAftermath");
}
// Vulkan
{
string VulkanSDKPath = Environment.GetEnvironmentVariable("VULKAN_SDK");
bool bSDKInstalled = !String.IsNullOrEmpty(VulkanSDKPath);
bool bUseThirdParty = true;
if (bSDKInstalled)
{
// Check if the installed SDK is newer or the same than the provided headers distributed with the Engine
int ThirdPartyVersion = GetThirdPartyVersion();
int SDKVersion = GetSDKVersion(VulkanSDKPath);
if (SDKVersion >= ThirdPartyVersion)
{
// If the user has an installed SDK, use that instead
PrivateIncludePaths.Add(VulkanSDKPath + "/Include");
// Older SDKs have an extra subfolder
PrivateIncludePaths.Add(VulkanSDKPath + "/Include/vulkan");
if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicLibraryPaths.Add(VulkanSDKPath + "/Source/lib32");
}
else
{
PublicLibraryPaths.Add(VulkanSDKPath + "/Source/lib");
}
PublicAdditionalLibraries.Add("vulkan-1.lib");
PublicAdditionalLibraries.Add("vkstatic.1.lib");
bUseThirdParty = false;
}
}
if (bUseThirdParty)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
}
}
// OVRPlugin
{
PublicDelayLoadDLLs.Add("OVRPlugin.dll");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Oculus/OVRPlugin/OVRPlugin/" + Target.Platform.ToString() + "/OVRPlugin.dll");
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
// Vulkan
{
string NDKPath = Environment.GetEnvironmentVariable("NDKROOT");
// Note: header is the same for all architectures so just use arch-arm
string NDKVulkanIncludePath = NDKPath + "/platforms/android-24/arch-arm/usr/include/vulkan";
if (File.Exists(NDKVulkanIncludePath + "/vulkan.h"))
{
// Use NDK Vulkan header if discovered
PrivateIncludePaths.Add(NDKVulkanIncludePath);
}
else
{
string VulkanSDKPath = Environment.GetEnvironmentVariable("VULKAN_SDK");
if (!String.IsNullOrEmpty(VulkanSDKPath))
{
// If the user has an installed SDK, use that instead
PrivateIncludePaths.Add(VulkanSDKPath + "/Include/vulkan");
}
else
{
// Fall back to the Windows Vulkan SDK (the headers are the same)
PrivateIncludePaths.Add(Target.UEThirdPartySourceDirectory + "Vulkan/Windows/Include/vulkan");
}
}
}
// AndroidPlugin
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "GearVR_APL.xml"));
}
}
}
public RD(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
bUseRTTI = true;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// Add the import library
PublicDefinitions.Add("_WIN32");
PublicDefinitions.Add("_WINSOCK_DEPRECATED_NO_WARNINGS");
var libFolder = Path.Combine(ModuleDirectory, "libs", "Win", "x64", "Release");
string[] libs = new string[]
{
"rd_framework_cpp.lib",
"clsocket.lib",
"rd_core_cpp.lib"
};
foreach (string lib in libs)
{
PublicAdditionalLibraries.Add(Path.Combine(libFolder, lib));
}
string[] paths = new string[] {
"include",
"include/rd_core_cpp",
"include/rd_framework_cpp",
"include/thirdparty",
"include/rd_core_cpp/lifetime",
"include/rd_core_cpp/logger",
"include/rd_core_cpp/reactive",
"include/rd_core_cpp/std",
"include/rd_core_cpp/types",
"include/rd_core_cpp/util",
"include/rd_core_cpp/reactive/base",
"include/rd_framework_cpp/base",
"include/rd_framework_cpp/ext",
"include/rd_framework_cpp/impl",
"include/rd_framework_cpp/intern",
"include/rd_framework_cpp/scheduler",
"include/rd_framework_cpp/serialization",
"include/rd_framework_cpp/task",
"include/rd_framework_cpp/util",
"include/rd_framework_cpp/wire",
"include/rd_framework_cpp/scheduler/base",
"include/thirdparty/clsocket",
"include/thirdparty/mpark",
"include/thirdparty/nonstd",
"include/thirdparty/optional",
"include/thirdparty/tsl",
"include/thirdparty/clsocket/src",
"include/thirdparty/optional/tl"
};
foreach (var item in paths)
{
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, item));
}
}
}
public PhysXVehicleLib(TargetInfo Target)
{
Type = ModuleType.External;
// Determine which kind of libraries to link against
PhysXLibraryMode LibraryMode = GetPhysXLibraryMode(Target.Configuration);
string LibrarySuffix = GetPhysXLibrarySuffix(LibraryMode);
string PhysXLibDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "PhysX/Lib/";
// Libraries and DLLs for windows platform
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicLibraryPaths.Add(PhysXLibDir + "Win64/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName());
PublicAdditionalLibraries.Add(String.Format("PhysX3Vehicle{0}_x64.lib", LibrarySuffix));
}
else if (Target.Platform == UnrealTargetPlatform.Win32 || (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32"))
{
PublicLibraryPaths.Add(PhysXLibDir + "Win32/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName());
PublicAdditionalLibraries.Add(String.Format("PhysX3Vehicle{0}_x86.lib", LibrarySuffix));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicLibraryPaths.Add(PhysXLibDir + "Mac");
PublicAdditionalLibraries.Add(String.Format(PhysXLibDir + "Mac/libPhysX3Vehicle{0}.a", LibrarySuffix));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicLibraryPaths.Add(PhysXLibDir + "Android/ARMv7");
PublicLibraryPaths.Add(PhysXLibDir + "Android/x86");
PublicLibraryPaths.Add(PhysXLibDir + "Android/ARM64");
PublicLibraryPaths.Add(PhysXLibDir + "Android/x64");
PublicAdditionalLibraries.Add(String.Format("PhysX3Vehicle{0}", LibrarySuffix));
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PublicLibraryPaths.Add(PhysXLibDir + "Linux/" + Target.Architecture);
PublicAdditionalLibraries.Add(String.Format("PhysX3Vehicle{0}", LibrarySuffix));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicLibraryPaths.Add(PhysXLibDir + "IOS");
PublicAdditionalLibraries.Add("PhysX3Vehicle" + LibrarySuffix);
}
else if (Target.Platform == UnrealTargetPlatform.TVOS)
{
PublicLibraryPaths.Add(PhysXLibDir + "TVOS");
PublicAdditionalLibraries.Add("PhysX3Vehicle" + LibrarySuffix);
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PublicAdditionalLibraries.Add(PhysXLibDir + "HTML5/PhysX3Vehicle" + (UEBuildConfiguration.bCompileForSize ? "_Oz" : "") + ".bc");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicLibraryPaths.Add(PhysXLibDir + "PS4");
PublicAdditionalLibraries.Add(String.Format("PhysX3Vehicle{0}", LibrarySuffix));
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PublicLibraryPaths.Add(Path.Combine(PhysXLibDir, "XboxOne\\VS" + WindowsPlatform.GetVisualStudioCompilerVersionName()));
PublicAdditionalLibraries.Add(String.Format("PhysX3Vehicle{0}.lib", LibrarySuffix));
}
else if (Target.Platform == UnrealTargetPlatform.Switch)
{
PublicLibraryPaths.Add(PhysXLibDir + "Switch");
PublicAdditionalLibraries.Add("PhysX3Vehicle" + LibrarySuffix);
}
}
private void AddPhotonLibPathAndroid(TargetInfo Target, string name)
{
PublicAdditionalLibraries.Add(Path.Combine(PhotonPath, "lib", "Android", "lib" + name + "-cpp-static_debug_android_armeabi_no-rtti.a"));
}
