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")); }