public CloudWatchSDK(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private")); PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public")); PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Projects", "Engine" }); PublicDefinitions.Add("USE_IMPORT_EXPORT"); PublicDefinitions.Add("USE_WINDOWS_DLL_SEMANTICS"); // This is required to fix a warning for Unreal Engine 4.21 and later PrivatePCHHeaderFile = "Private/CloudWatchSDKPrivatePCH.h"; bEnableExceptions = true; string BaseDirectory = System.IO.Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", "..")); string SDKDirectory = System.IO.Path.Combine(BaseDirectory, "ThirdParty", "CloudWatchSDK", Target.Platform.ToString()); bool bHasGameLiftSDK = System.IO.Directory.Exists(SDKDirectory); if (bHasGameLiftSDK) { if (Target.Type == TargetRules.TargetType.Server) { PublicDefinitions.Add("WITH_CLOUDWATCH=1"); } else { PublicDefinitions.Add("WITH_CLOUDWATCH=0"); } PublicLibraryPaths.Add(SDKDirectory); // aws-c-common PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-c-common.lib")); PublicDelayLoadDLLs.Add("aws-c-common.dll"); RuntimeDependencies.Add(System.IO.Path.Combine(SDKDirectory, "aws-c-common.dll")); // aws-c-event-stream PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-c-event-stream.lib")); PublicDelayLoadDLLs.Add("aws-c-event-stream.dll"); RuntimeDependencies.Add(System.IO.Path.Combine(SDKDirectory, "aws-c-event-stream.dll")); // aws-checksums PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-checksums.lib")); PublicDelayLoadDLLs.Add("aws-checksums.dll"); RuntimeDependencies.Add(System.IO.Path.Combine(SDKDirectory, "aws-checksums.dll")); // aws-cpp-sdk-core PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-core.lib")); PublicDelayLoadDLLs.Add("aws-cpp-sdk-core.dll"); RuntimeDependencies.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-core.dll")); // aws-cpp-sdk-monitoring PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-monitoring.lib")); PublicDelayLoadDLLs.Add("aws-cpp-sdk-monitoring.dll"); RuntimeDependencies.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-monitoring.dll")); // aws-cpp-sdk-logs PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-logs.lib")); PublicDelayLoadDLLs.Add("aws-cpp-sdk-logs.dll"); RuntimeDependencies.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-logs.dll")); } else { PublicDefinitions.Add("WITH_CLOUDWATCH=0"); } }
public KlawrClrHostNative(TargetInfo Target) { // This module is built externally, just need to let UBT know the include and library paths // that should be passed through to any targets that depend on this module. Type = ModuleType.External; var moduleName = this.GetType().Name; // path to directory containing this Build.cs file // var basePath = Path.GetDirectoryName(RulesCompiler.GetModuleFilename(moduleName)); var basePath = Path.GetDirectoryName(ModuleDirectory); string architecture = null; if (Target.Platform == UnrealTargetPlatform.Win64) { architecture = "x64"; } else if (Target.Platform == UnrealTargetPlatform.Win32) { architecture = "x86"; } else { architecture = "x64"; } string configuration = null; switch (Target.Configuration) { case UnrealTargetConfiguration.Debug: case UnrealTargetConfiguration.DebugGame: configuration = BuildConfiguration.bDebugBuildsActuallyUseDebugCRT ? "Debug" : "Release"; break; default: configuration = "Release"; break; } Console.WriteLine("KlawrClrHostNative Target.Configuration: " + configuration); if ((architecture != null) && (configuration != null)) { PublicIncludePaths.Add(Path.Combine(basePath, "Public")); var libName = "Klawr.ClrHost.Native-" + architecture + "-" + configuration + ".lib"; PublicLibraryPaths.Add(Path.Combine(basePath, "..", "Build")); PublicAdditionalLibraries.Add(libName); } // copy the CLR host assembly (assumed to have been built previously) to the engine binaries // directory so that it can be found and loaded at runtime by the unmanaged CLR host string hostAssemblyName = "Klawr.ClrHost.Managed"; string hostAssemblyDLL = hostAssemblyName + ".dll"; string hostAssemblyPDB = hostAssemblyName + ".pdb"; string hostAssemblySourceDir = Path.Combine(basePath, Path.Combine("ClrHostManaged", "bin", configuration)); Utils.CollapseRelativeDirectories(ref hostAssemblySourceDir); string binariesDir = Path.Combine( BuildConfiguration.RelativeEnginePath, "Binaries", Target.Platform.ToString() ); bool bOverwrite = true; var from = Path.Combine(hostAssemblySourceDir, hostAssemblyDLL); var to = Path.Combine(binariesDir, hostAssemblyDLL); if (!File.Exists(to)) { var msg = "Copy: " + from + "\nTo: " + to; Log.TraceInformation(msg); File.Copy(from, to, bOverwrite); } from = Path.Combine(hostAssemblySourceDir, hostAssemblyPDB); to = Path.Combine(binariesDir, hostAssemblyPDB); if (!File.Exists(to)) { File.Copy(from, to, bOverwrite); } }
public HarfBuzz(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; // Can't be used without our dependencies if (!Target.bCompileFreeType || !Target.bCompileICU) { PublicDefinitions.Add("WITH_HARFBUZZ=0"); return; } string HarfBuzzVersion = "harfbuzz-1.2.4"; string HarfBuzzRootPath = Target.UEThirdPartySourceDirectory + "HarfBuzz/" + HarfBuzzVersion + "/"; // Includes PublicSystemIncludePaths.Add(HarfBuzzRootPath + "src" + "/"); string PlatformFolderName = Target.Platform.ToString(); string HarfBuzzLibPath = HarfBuzzRootPath + PlatformFolderName + "/"; if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { PublicDefinitions.Add("WITH_HARFBUZZ=1"); string VSVersionFolderName = "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(); HarfBuzzLibPath += VSVersionFolderName + "/"; string BuildTypeFolderName = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ? "Debug" : "RelWithDebInfo"; HarfBuzzLibPath += BuildTypeFolderName + "/"; PublicLibraryPaths.Add(HarfBuzzLibPath); PublicAdditionalLibraries.Add("harfbuzz.lib"); } else if (Target.Platform == UnrealTargetPlatform.HTML5) { PublicDefinitions.Add("WITH_HARFBUZZ=1"); string OpimizationSuffix = "_Oz"; // i.e. bCompileForSize if (!Target.bCompileForSize) { switch (Target.Configuration) { case UnrealTargetConfiguration.Development: OpimizationSuffix = "_O2"; break; case UnrealTargetConfiguration.Shipping: OpimizationSuffix = "_O3"; break; default: OpimizationSuffix = ""; break; } } PublicAdditionalLibraries.Add(HarfBuzzRootPath + "HTML5/libharfbuzz" + OpimizationSuffix + ".bc"); } else if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.IOS) { PublicDefinitions.Add("WITH_HARFBUZZ=1"); PublicAdditionalLibraries.Add(HarfBuzzLibPath + "libharfbuzz.a"); } else if (Target.Platform == UnrealTargetPlatform.PS4) { PublicDefinitions.Add("WITH_HARFBUZZ=1"); string BuildTypeFolderName = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ? "Debug" : "Release"; HarfBuzzLibPath += BuildTypeFolderName + "/"; PublicLibraryPaths.Add(HarfBuzzLibPath); PublicAdditionalLibraries.Add("harfbuzz"); // Automatically transforms to libharfbuzz.a } else if (Target.Platform == UnrealTargetPlatform.XboxOne) { PublicDefinitions.Add("WITH_HARFBUZZ=1"); string BuildTypeFolderName = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ? "Debug" : "Release"; HarfBuzzLibPath += "VS2015/" + BuildTypeFolderName + "/"; PublicLibraryPaths.Add(HarfBuzzLibPath); PublicAdditionalLibraries.Add("harfbuzz.lib"); } else if (Target.Platform == UnrealTargetPlatform.Android) { PublicDefinitions.Add("WITH_HARFBUZZ=1"); string BuildTypeFolderName = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ? "Debug/" : "Release/"; PublicLibraryPaths.Add(HarfBuzzRootPath + "Android/ARMv7/" + BuildTypeFolderName); PublicLibraryPaths.Add(HarfBuzzRootPath + "Android/ARM64/" + BuildTypeFolderName); PublicLibraryPaths.Add(HarfBuzzRootPath + "Android/x86/" + BuildTypeFolderName); PublicLibraryPaths.Add(HarfBuzzRootPath + "Android/x64/" + BuildTypeFolderName); PublicAdditionalLibraries.Add("harfbuzz"); } else { PublicDefinitions.Add("WITH_HARFBUZZ=0"); } }
public AdMob(TargetInfo Target) { PublicIncludePaths.AddRange( new string[] { "AdMob/Public" // ... add public 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", "AdCollection", // ... 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.IOS) { PrivateIncludePaths.Add("Private/IOS"); PrivateIncludePaths.Add("../AdCollection/ThirdPartyFrameworks/VungleAdmobIOS/"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "../AdCollection/ThirdPartyFrameworks/VungleAdmobIOS/")); PublicLibraryPaths.Add(strStaticPath); PublicAdditionalFrameworks.Add( new UEBuildFramework( "GoogleMobileAds", // Framework name "../AdCollection/ThirdPartyFrameworks/GoogleMobileAds.embeddedframework.zip") ); PublicAdditionalFrameworks.Add( new UEBuildFramework( "UnityAds", // Framework name "../AdCollection/ThirdPartyFrameworks/UnityAds.embeddedframework.zip") ); PublicAdditionalFrameworks.Add( new UEBuildFramework( "VungleSDK", // Framework name "../AdCollection/ThirdPartyFrameworks/VungleSDK.embeddedframework.zip") ); PublicAdditionalFrameworks.Add( new UEBuildFramework( "Chartboost", // Framework name "../AdCollection/ThirdPartyFrameworks/Chartboost.embeddedframework.zip") ); PublicAdditionalFrameworks.Add( new UEBuildFramework( "AdColony", // Framework name "../AdCollection/ThirdPartyFrameworks/AdColony-iOS-SDK-3.zip") ); // adapter PublicAdditionalFrameworks.Add( new UEBuildFramework( "UnityAdapter", // Framework name "../AdCollection/ThirdPartyFrameworks/UnityAdapter-2.1.0.0.zip") ); PublicAdditionalFrameworks.Add( new UEBuildFramework( "ChartboostAdapter", // Framework name "../AdCollection/ThirdPartyFrameworks/ChartboostAdapter-6.6.3.0.zip") ); PublicAdditionalFrameworks.Add( new UEBuildFramework( "AdColonyAdapter", // Framework name "../AdCollection/ThirdPartyFrameworks/AdColonyAdapter-3.1.1.0.zip") ); // helper lib PublicAdditionalFrameworks.Add( new UEBuildFramework( "AdsUtil", // Framework name "../AdCollection/ThirdPartyFrameworks/AdsUtil.embeddedframework.zip") ); PublicAdditionalLibraries.Add("VungleAdapter"); PublicAdditionalShadowFiles.Add("../AdCollection/ThirdPartyFrameworks/VungleAdmobIOS/libVungleAdapter.a"); PublicFrameworks.AddRange( new string[] { "EventKit", "MediaPlayer", "AdSupport", "CoreLocation", "SystemConfiguration", "MessageUI", "Security", "CoreTelephony" } ); } else if (Target.Platform == UnrealTargetPlatform.Android) { PrivateIncludePaths.Add("Private/Android"); PrivateDependencyModuleNames.AddRange( new string[] { "Launch", } ); string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, BuildConfiguration.RelativeEnginePath); AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "AdMob_UPL.xml"))); } else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { PrivateIncludePaths.Add("Private/Windows"); } else if (Target.Platform == UnrealTargetPlatform.Mac) { PrivateIncludePaths.Add("Private/Mac"); } else { PrecompileForTargets = PrecompileTargetsType.None; } }
public CS_OpenSSL(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; string OpenSSL101sPath = Path.Combine(Target.UEThirdPartySourceDirectory, "OpenSSL", "1_0_1s"); string OpenSSL102hPath = Path.Combine(Target.UEThirdPartySourceDirectory, "OpenSSL", "1_0_2h"); string OpenSSL102Path = Path.Combine(Target.UEThirdPartySourceDirectory, "OpenSSL", "1.0.2g"); string OpenSSL111Path = Path.Combine(Target.UEThirdPartySourceDirectory, "OpenSSL", "1.1.1"); string PlatformSubdir = Target.Platform.ToString(); string ConfigFolder = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ? "Debug" : "Release"; if (Target.Platform == UnrealTargetPlatform.Mac) { PublicIncludePaths.Add(Path.Combine(OpenSSL102Path, "include", PlatformSubdir)); string LibPath = Path.Combine(OpenSSL102Path, "lib", PlatformSubdir, ConfigFolder); //PublicLibraryPaths.Add(LibPath); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.a")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.a")); PublicAdditionalLibraries.Add("z"); } else if (Target.Platform == UnrealTargetPlatform.PS4) { string IncludePath = Target.UEThirdPartySourceDirectory + "OpenSSL/1.0.2g" + "/" + "include/PS4"; string LibraryPath = Target.UEThirdPartySourceDirectory + "OpenSSL/1.0.2g" + "/" + "lib/PS4/release"; PublicIncludePaths.Add(IncludePath); PublicAdditionalLibraries.Add(LibraryPath + "/" + "libssl.a"); PublicAdditionalLibraries.Add(LibraryPath + "/" + "libcrypto.a"); } else if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32) { // Our OpenSSL 1.1.1 libraries are built with zlib compression support PrivateDependencyModuleNames.Add("zlib"); // string VSVersion = "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(); string VSVersion = "VS2015"; // Add includes PublicIncludePaths.Add(Path.Combine(OpenSSL111Path, "include", PlatformSubdir, VSVersion)); // Add Libs string LibPath = Path.Combine(OpenSSL111Path, "lib", PlatformSubdir, VSVersion, ConfigFolder); PublicLibraryPaths.Add(LibPath); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.lib")); PublicAdditionalLibraries.Add("crypt32.lib"); } else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix)) { string platform = "/Linux/" + Target.Architecture; string IncludePath = OpenSSL102hPath + "/include" + platform; string LibraryPath = OpenSSL102hPath + "/lib" + platform; PublicIncludePaths.Add(IncludePath); PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryPath + "/libssl.a"); PublicAdditionalLibraries.Add(LibraryPath + "/libcrypto.a"); PublicDependencyModuleNames.Add("zlib"); // PublicAdditionalLibraries.Add("z"); } else if (Target.Platform == UnrealTargetPlatform.Android) { string IncludePath = OpenSSL101sPath + "/include/Android"; PublicIncludePaths.Add(IncludePath); // unneeded since included in libcurl // string LibPath = Path.Combine(OpenSSL101sPath, "lib", PlatformSubdir); //PublicLibraryPaths.Add(LibPath); } else if (Target.Platform == UnrealTargetPlatform.IOS) { string IncludePath = OpenSSL101sPath + "/include/IOS"; string LibraryPath = OpenSSL101sPath + "/lib/IOS"; PublicIncludePaths.Add(IncludePath); PublicAdditionalLibraries.Add(LibraryPath + "/libssl.a"); PublicAdditionalLibraries.Add(LibraryPath + "/libcrypto.a"); } }
public WebSocket(ReadOnlyTargetRules Target) : base(Target) { PrivatePCHHeaderFile = "Public/WebSocket.h"; string strEngineDir = GetEngineDirectory(); string strEngineVersion = ReadEngineVersion(strEngineDir); System.Console.WriteLine("version:" + strEngineVersion); PrivateIncludePaths.AddRange( new string[] { "WebSocket/Private", // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "Json", "JsonUtilities", "Sockets", // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "Slate", "SlateCore", "Json", "JsonUtilities", // ... 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) { PublicDefinitions.Add("PLATFORM_UWP=0"); PrivateDependencyModuleNames.Add("zlib"); if (EngineMinorVersion == "21" || EngineMinorVersion == "20") { PrivateDependencyModuleNames.Add("OpenSSL"); } PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Win64"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Win64/")); //PublicLibraryPaths.Add(strStaticPath); // for 4.21 if (EngineMinorVersion == "21" || EngineMinorVersion == "20") { string[] StaticLibrariesX64 = new string[] { "websockets_static.lib", }; foreach (string Lib in StaticLibrariesX64) { PublicAdditionalLibraries.Add(strStaticPath + Lib); } } else { // for 4.22 and beyond if (Target.Type == TargetType.Editor) { PublicAdditionalLibraries.Add(strStaticPath + "websockets_static422.lib"); PublicAdditionalLibraries.Add(strStaticPath + "libeay32.lib"); PublicAdditionalLibraries.Add(strStaticPath + "ssleay32.lib"); } else { PublicAdditionalLibraries.Add(strStaticPath + "websockets_game_static422.lib"); } } } if (Target.Platform == UnrealTargetPlatform.Win32) { PublicDefinitions.Add("PLATFORM_UWP=0"); PrivateDependencyModuleNames.Add("zlib"); PrivateDependencyModuleNames.Add("OpenSSL"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Win32"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Win32/")); PublicLibraryPaths.Add(strStaticPath); // 4.22 and 4.21 if (EngineMinorVersion == "21" || EngineMinorVersion == "20") { string[] StaticLibrariesX32 = new string[] { "websockets_static.lib", //"libcrypto.lib", //"libssl.lib", }; foreach (string Lib in StaticLibrariesX32) { PublicAdditionalLibraries.Add(Lib); } } else if (EngineMinorVersion == "22") { string[] StaticLibrariesX32 = new string[] { "websockets_static422.lib", //"libcrypto.lib", //"libssl.lib", }; foreach (string Lib in StaticLibrariesX32) { PublicAdditionalLibraries.Add(Lib); } } } else if (Target.Platform == UnrealTargetPlatform.HTML5) { PublicDefinitions.Add("PLATFORM_UWP=0"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/HTML5/")); PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesHTML5 = new string[] { "WebSocket.js", }; foreach (string Lib in StaticLibrariesHTML5) { PublicAdditionalLibraries.Add(strStaticPath + Lib); } } else if (Target.Platform == UnrealTargetPlatform.Mac) { PublicDefinitions.Add("PLATFORM_UWP=0"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Mac"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Mac/")); //PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesMac = new string[] { "libwebsockets.a", "libssl.a", "libcrypto.a" }; foreach (string Lib in StaticLibrariesMac) { PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib)); } } else if (Target.Platform == UnrealTargetPlatform.Linux) { PublicDefinitions.Add("PLATFORM_UWP=0"); PrivateDependencyModuleNames.Add("OpenSSL"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Linux"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Linux/")); PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesMac = new string[] { "libwebsockets.a", //"libssl.a", //"libcrypto.a" }; foreach (string Lib in StaticLibrariesMac) { PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib)); } } else if (Target.Platform == UnrealTargetPlatform.IOS) { PublicDefinitions.Add("PLATFORM_UWP=0"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/IOS"); string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath + "/Source/"); PluginPath = PluginPath.Replace("\\", "/"); string strStaticPath = PluginPath + "/ThirdParty/lib/IOS/";// Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/IOS/")); PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesIOS = new string[] { "websockets", "ssl", "crypto" }; foreach (string Lib in StaticLibrariesIOS) { PublicAdditionalLibraries.Add(Lib); PublicAdditionalShadowFiles.Add(Path.Combine(strStaticPath, "lib" + Lib + ".a")); } } else if (Target.Platform == UnrealTargetPlatform.Android) { PublicDefinitions.Add("PLATFORM_UWP=0"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Android"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Android/armeabi-v7a")); PublicLibraryPaths.Add(strStaticPath); string strStaticArm64Path = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Android/arm64-v8a")); PublicLibraryPaths.Add(strStaticArm64Path); string[] StaticLibrariesAndroid = new string[] { "websockets", "ssl", "crypto" }; foreach (string Lib in StaticLibrariesAndroid) { PublicAdditionalLibraries.Add(Lib); } } }
public Python(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; string PythonRoot = null; string PythonIncludePath = null; string PythonLibPath = null; string PythonLibName = null; if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux) { // Check for an explicit version before using the auto-detection logic PythonRoot = System.Environment.GetEnvironmentVariable("UE_PYTHON_DIR"); } // Perform auto-detection to try and find the Python root if (PythonRoot == null) { var KnownPaths = new List <string>(); // todo: This isn't correct for cross-compilation, we need to consider the host platform too if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { KnownPaths.AddRange( new string[] { //"C:/Program Files/Python36", "C:/Python27", } ); } else if (Target.Platform == UnrealTargetPlatform.Mac) { KnownPaths.AddRange( new string[] { "/Library/Frameworks/Python.framework/Versions/2.7", //"/System/Library/Frameworks/Python.framework/Versions/2.7", } ); } foreach (var KnownPath in KnownPaths) { if (Directory.Exists(KnownPath)) { PythonRoot = KnownPath; break; } } } // Work out the include path if (PythonRoot != null) { PythonIncludePath = Path.Combine(PythonRoot, (Target.Platform == UnrealTargetPlatform.Mac) ? "Headers" : "include"); if (!Directory.Exists(PythonIncludePath)) { PythonRoot = null; } } // Work out the lib path if (PythonRoot != null) { string LibFolder = null; string LibNamePattern = null; switch (Target.Platform) { case UnrealTargetPlatform.Win32: case UnrealTargetPlatform.Win64: LibFolder = "libs"; LibNamePattern = "python*.lib"; break; case UnrealTargetPlatform.Mac: LibFolder = "lib"; LibNamePattern = "libpython*.dylib"; break; case UnrealTargetPlatform.Linux: LibFolder = "lib"; LibNamePattern = "libpython*.so"; break; default: break; } if (LibFolder != null && LibNamePattern != null) { PythonLibPath = Path.Combine(PythonRoot, LibFolder); if (Directory.Exists(PythonLibPath)) { string[] MatchingLibFiles = Directory.GetFiles(PythonLibPath, LibNamePattern); if (MatchingLibFiles.Length > 0) { PythonLibName = Path.GetFileName(MatchingLibFiles[0]); } } } if (PythonLibPath == null || PythonLibName == null) { PythonRoot = null; } } // Make sure the Python install is the correct architecture if (PythonRoot != null) { string ExpectedPointerSizeResult = Target.Platform == UnrealTargetPlatform.Win32 ? "4" : "8"; // Invoke Python to query the pointer size of the interpreter so we can work out whether it's 32-bit or 64-bit // todo: We probably need to do this for all platforms, but right now it's only an issue on Windows if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { string PythonBinary = Path.Combine(PythonRoot, "python"); string Result = InvokePython(PythonBinary, "-c \"import struct; print(struct.calcsize('P'))\""); Result = Result != null?Result.Replace("\r", "").Replace("\n", "") : null; if (Result == null || Result != ExpectedPointerSizeResult) { PythonRoot = null; } } } if (PythonRoot == null) { PublicDefinitions.Add("WITH_PYTHON=0"); } else { PublicDefinitions.Add("WITH_PYTHON=1"); PublicDefinitions.Add(string.Format("UE_PYTHON_DIR=\"{0}\"", PythonRoot.Replace('\\', '/'))); // Some versions of Python need this define set when building on MSVC if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { PublicDefinitions.Add("HAVE_ROUND=1"); } PublicSystemIncludePaths.Add(PythonIncludePath); if (Target.Platform == UnrealTargetPlatform.Mac) { // Mac doesn't understand PublicLibraryPaths PublicAdditionalLibraries.Add(Path.Combine(PythonLibPath, PythonLibName)); } else { PublicLibraryPaths.Add(PythonLibPath); PublicAdditionalLibraries.Add(PythonLibName); } } }
public UEOpenExr(TargetInfo Target) { Type = ModuleType.External; if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac) { bool bDebug = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT); string LibDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "openexr/Deploy/lib/"; string Platform; switch (Target.Platform) { case UnrealTargetPlatform.Win64: Platform = "x64"; LibDir += "VS" + WindowsPlatform.GetVisualStudioCompilerVersionName() + "/"; break; case UnrealTargetPlatform.Win32: Platform = "Win32"; LibDir += "VS" + WindowsPlatform.GetVisualStudioCompilerVersionName() + "/"; break; case UnrealTargetPlatform.Mac: Platform = "Mac"; bDebug = false; break; default: return; } LibDir = LibDir + "/" + Platform; LibDir = LibDir + "/Static" + (bDebug ? "Debug" : "Release"); PublicLibraryPaths.Add(LibDir); if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32) { PublicAdditionalLibraries.AddRange( new string[] { "Half.lib", "Iex.lib", "IlmImf.lib", "IlmThread.lib", "Imath.lib", } ); } else if (Target.Platform == UnrealTargetPlatform.Mac) { PublicAdditionalLibraries.AddRange( new string[] { LibDir + "/libHalf.a", LibDir + "/libIex.a", LibDir + "/libIlmImf.a", LibDir + "/libIlmThread.a", LibDir + "/libImath.a", } ); } PublicSystemIncludePaths.AddRange( new string[] { UEBuildConfiguration.UEThirdPartySourceDirectory + "openexr/Deploy/include", } ); } }
public libgltf_ue4(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; string glTFPath = System.IO.Path.Combine(ModuleDirectory, "libgltf-0.1.6"); string IncludePath = System.IO.Path.Combine(glTFPath, "include"); List <string> LibPaths = new List <string>(); string LibFilePath = ""; if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64)) { string PlatformName = ""; switch (Target.Platform) { case UnrealTargetPlatform.Win32: PlatformName = "win32"; break; case UnrealTargetPlatform.Win64: PlatformName = "win64"; break; } string TargetConfiguration = "Release"; string TargetPostfix = ""; if (Target.Configuration == UnrealTargetConfiguration.Debug) { TargetConfiguration = "Debug"; TargetPostfix = "d"; } LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", PlatformName, "vs2019", TargetConfiguration)); LibFilePath = "libgltf" + TargetPostfix + ".lib"; } else if (Target.Platform == UnrealTargetPlatform.Linux) { LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "linux")); LibFilePath = "libgltf.a"; } else if (Target.Platform == UnrealTargetPlatform.Mac) { LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "macos")); LibFilePath = "libgltf.a"; } else if (Target.Platform == UnrealTargetPlatform.Android) { LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "android", "armeabi-v7a")); LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "android", "armeabi-v7a-with-neon")); LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "android", "arm64-v8a")); LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "android", "x86")); LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "android", "x86_64")); LibFilePath = "libgltf.a"; } else if (Target.Platform == UnrealTargetPlatform.IOS) { LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "ios", "os")); LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "ios", "simulator")); LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "ios", "watchos")); LibFilePath = "libgltf.a"; } PublicIncludePaths.Add(IncludePath); PublicLibraryPaths.AddRange(LibPaths); PublicAdditionalLibraries.Add(LibFilePath); PublicDefinitions.Add("LIBGLTF_CHARACTOR_ENCODING_IS_UTF8"); }
public APEX(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; // Determine which kind of libraries to link against APEXLibraryMode LibraryMode = GetAPEXLibraryMode(Target.Configuration); string LibrarySuffix = GetAPEXLibrarySuffix(LibraryMode); string ApexVersion = "APEX_1.4"; string APEXDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "PhysX/" + ApexVersion + "/"; string APEXLibDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "PhysX/Lib"; PublicSystemIncludePaths.AddRange( new string[] { APEXDir + "include", APEXDir + "include/clothing", APEXDir + "include/destructible", APEXDir + "include/nvparameterized", APEXDir + "include/legacy", APEXDir + "include/PhysX3", APEXDir + "common/include", APEXDir + "common/include/autogen", APEXDir + "framework/include", APEXDir + "framework/include/autogen", APEXDir + "shared/general/RenderDebug/public", APEXDir + "shared/general/PairFilter/include", APEXDir + "shared/internal/include", APEXDir + "externals/CUDA_6.5.19/include", } ); // List of default library names (unused unless LibraryFormatString is non-null) List <string> ApexLibraries = new List <string>(); ApexLibraries.AddRange( new string[] { "ApexCommon{0}", "ApexFramework{0}", "ApexShared{0}", "APEX_Destructible{0}", "APEX_Clothing{0}", }); string LibraryFormatString = null; bool bIsApexStaticallyLinked = false; bool bHasApexLegacy = true; // Libraries and DLLs for windows platform if (Target.Platform == UnrealTargetPlatform.Win64) { APEXLibDir += "/Win64/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName(); PublicLibraryPaths.Add(APEXLibDir); PublicAdditionalLibraries.Add(String.Format("APEXFramework{0}_x64.lib", LibrarySuffix)); PublicDelayLoadDLLs.Add(String.Format("APEXFramework{0}_x64.dll", LibrarySuffix)); string[] RuntimeDependenciesX64 = { "APEX_Clothing{0}_x64.dll", "APEX_Destructible{0}_x64.dll", "APEX_Legacy{0}_x64.dll", "ApexFramework{0}_x64.dll", }; string ApexBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX/Win64/VS{0}/", WindowsPlatform.GetVisualStudioCompilerVersionName()); foreach (string RuntimeDependency in RuntimeDependenciesX64) { string FileName = ApexBinariesDir + String.Format(RuntimeDependency, LibrarySuffix); RuntimeDependencies.Add(FileName, StagedFileType.NonUFS); RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS); } if (LibrarySuffix != "") { Definitions.Add("UE_APEX_SUFFIX=" + LibrarySuffix); } } else if (Target.Platform == UnrealTargetPlatform.Win32) { APEXLibDir += "/Win32/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName(); PublicLibraryPaths.Add(APEXLibDir); PublicAdditionalLibraries.Add(String.Format("APEXFramework{0}_x86.lib", LibrarySuffix)); PublicDelayLoadDLLs.Add(String.Format("APEXFramework{0}_x86.dll", LibrarySuffix)); string[] RuntimeDependenciesX86 = { "APEX_Clothing{0}_x86.dll", "APEX_Destructible{0}_x86.dll", "APEX_Legacy{0}_x86.dll", "ApexFramework{0}_x86.dll", }; string ApexBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX/Win32/VS{0}/", WindowsPlatform.GetVisualStudioCompilerVersionName()); foreach (string RuntimeDependency in RuntimeDependenciesX86) { string FileName = ApexBinariesDir + String.Format(RuntimeDependency, LibrarySuffix); RuntimeDependencies.Add(FileName, StagedFileType.NonUFS); RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS); } if (LibrarySuffix != "") { Definitions.Add("UE_APEX_SUFFIX=" + LibrarySuffix); } } else if (Target.Platform == UnrealTargetPlatform.Mac) { APEXLibDir += "/Mac"; ApexLibraries.Clear(); ApexLibraries.AddRange( new string[] { "ApexCommon{0}", "ApexShared{0}", }); LibraryFormatString = APEXLibDir + "/lib{0}" + ".a"; string[] DynamicLibrariesMac = new string[] { "/libAPEX_Clothing{0}.dylib", "/libAPEX_Destructible{0}.dylib", "/libAPEX_Legacy{0}.dylib", "/libApexFramework{0}.dylib" }; string PhysXBinariesDir = UEBuildConfiguration.UEThirdPartyBinariesDirectory + "PhysX/Mac"; foreach (string Lib in DynamicLibrariesMac) { string LibraryPath = PhysXBinariesDir + String.Format(Lib, LibrarySuffix); PublicDelayLoadDLLs.Add(LibraryPath); RuntimeDependencies.Add(new RuntimeDependency(LibraryPath)); } if (LibrarySuffix != "") { Definitions.Add("UE_APEX_SUFFIX=" + LibrarySuffix); } } else if (Target.Platform == UnrealTargetPlatform.Linux) { if (Target.Architecture.StartsWith("x86_64")) { APEXLibDir += "/Linux/" + Target.Architecture; bIsApexStaticallyLinked = true; ApexLibraries.Add("APEX_Clothing{0}"); ApexLibraries.Add("APEX_Destructible{0}"); ApexLibraries.Add("APEX_Legacy{0}"); ApexLibraries.Add("ApexFramework{0}"); LibraryFormatString = APEXLibDir + "/lib{0}" + ".a"; } } else if (Target.Platform == UnrealTargetPlatform.PS4) { bIsApexStaticallyLinked = true; bHasApexLegacy = false; APEXLibDir += "/PS4"; PublicLibraryPaths.Add(APEXLibDir); ApexLibraries.Add("NvParameterized{0}"); ApexLibraries.Add("RenderDebug{0}"); LibraryFormatString = "{0}"; } else if (Target.Platform == UnrealTargetPlatform.XboxOne) { bIsApexStaticallyLinked = true; bHasApexLegacy = false; Definitions.Add("_XBOX_ONE=1"); // This MUST be defined for XboxOne! Definitions.Add("PX_HAS_SECURE_STRCPY=1"); APEXLibDir += "/XboxOne/VS2015"; PublicLibraryPaths.Add(APEXLibDir); ApexLibraries.Add("NvParameterized{0}"); ApexLibraries.Add("RenderDebug{0}"); LibraryFormatString = "{0}.lib"; } else if (Target.Platform == UnrealTargetPlatform.Switch) { bIsApexStaticallyLinked = true; bHasApexLegacy = false; APEXLibDir += "/Switch"; PublicLibraryPaths.Add(APEXLibDir); ApexLibraries.Add("NvParameterized{0}"); ApexLibraries.Add("RenderDebug{0}"); LibraryFormatString = "{0}"; } Definitions.Add("APEX_UE4=1"); Definitions.Add(string.Format("APEX_STATICALLY_LINKED={0}", bIsApexStaticallyLinked ? 1 : 0)); Definitions.Add(string.Format("WITH_APEX_LEGACY={0}", bHasApexLegacy ? 1 : 0)); // Add the libraries needed (used for all platforms except Windows) if (LibraryFormatString != null) { foreach (string Lib in ApexLibraries) { string ConfiguredLib = String.Format(Lib, LibrarySuffix); string FinalLib = String.Format(LibraryFormatString, ConfiguredLib); PublicAdditionalLibraries.Add(FinalLib); } } }
public AgogCore(TargetInfo Target) { Type = ModuleType.External; var bPlatformAllowed = false; string platPathSuffix = Target.Platform.ToString(); string libPathExt = ".a"; bool useDebugCRT = BuildConfiguration.bDebugBuildsActuallyUseDebugCRT; switch (Target.Platform) { case UnrealTargetPlatform.Win32: bPlatformAllowed = true; platPathSuffix = Path.Combine("Win32", "VS2013"); libPathExt = ".lib"; Definitions.Add("WIN32_LEAN_AND_MEAN"); break; case UnrealTargetPlatform.Win64: bPlatformAllowed = true; platPathSuffix = Path.Combine("Win64", "VS2013"); libPathExt = ".lib"; Definitions.Add("WIN32_LEAN_AND_MEAN"); break; case UnrealTargetPlatform.IOS: bPlatformAllowed = true; Definitions.Add("A_PLAT_iOS"); Definitions.Add("NO_AGOG_PLACEMENT_NEW"); Definitions.Add("A_NO_GLOBAL_EXCEPTION_CATCH"); useDebugCRT = true; break; } string libNameSuffix = ""; // NOTE: All modules inside the SkookumScript plugin folder must use the exact same definitions! switch (Target.Configuration) { case UnrealTargetConfiguration.Debug: case UnrealTargetConfiguration.DebugGame: Definitions.Add("A_EXTRA_CHECK=1"); Definitions.Add("A_UNOPTIMIZED=1"); Definitions.Add("SKOOKUM=31"); libNameSuffix = useDebugCRT ? "-Debug" : "-DebugCRTOpt"; break; case UnrealTargetConfiguration.Development: case UnrealTargetConfiguration.Test: Definitions.Add("A_EXTRA_CHECK=1"); Definitions.Add("SKOOKUM=31"); libNameSuffix = "-Development"; break; case UnrealTargetConfiguration.Shipping: Definitions.Add("A_SYMBOL_STR_DB=1"); Definitions.Add("A_NO_SYMBOL_REF_LINK=1"); Definitions.Add("SKOOKUM=8"); libNameSuffix = "-Shipping"; break; } PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public")); if (bPlatformAllowed) { var buildNumber = "1703"; var moduleName = "AgogCore"; // Get local file path where the library is located var libFileName = moduleName + libNameSuffix + libPathExt; var libDirPath = Path.Combine(ModuleDirectory, "..", "..", "Intermediate", "Lib", buildNumber, platPathSuffix); var libFilePath = Path.Combine(libDirPath, libFileName); if (!File.Exists(libFilePath)) { // Does not exist, try to download it if (!File.Exists(libDirPath)) { Directory.CreateDirectory(libDirPath); } var libUrl = ("http://download.skookumscript.com/beta/" + buildNumber + "/lib/" + platPathSuffix + "/" + libFileName).Replace('\\', '/'); WebClient client = new WebClient(); try { Log.TraceInformation("Downloading build {0} of {1}...", buildNumber, libFileName); client.DownloadFile(libUrl, @libFilePath); Log.TraceInformation("Success!"); } catch (System.Exception) { if (File.Exists(libFilePath)) { File.Delete(libFilePath); } throw new BuildException("Could not download {0}!", libUrl); } } // Check if a newer custom built library exists that we want to use instead var builtLibDirPath = Path.Combine(ModuleDirectory, "Lib", platPathSuffix); var builtLibFilePath = Path.Combine(builtLibDirPath, libFileName); if (File.Exists(builtLibFilePath) && (!File.Exists(libFilePath) || (File.GetLastWriteTime(builtLibFilePath) > File.GetLastWriteTime(libFilePath)))) { Log.TraceInformation("Using locally built AgogCore."); libDirPath = builtLibDirPath; libFilePath = builtLibFilePath; } PublicLibraryPaths.Add(libDirPath); PublicAdditionalLibraries.Add(libFilePath); Log.TraceVerbose("{0} library added to path: {1}", moduleName, libDirPath); } }
public glTFForUE4(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = PCHUsageMode.UseSharedPCHs; PrivatePCHHeaderFile = "Private/glTFForUE4PrivatePCH.h"; PrivateIncludePaths.AddRange(new [] { "glTFForUE4/Private", }); PublicDependencyModuleNames.AddRange(new [] { "Core", }); PrivateDependencyModuleNames.AddRange(new [] { "CoreUObject", "Engine", "Slate", "SlateCore", "InputCore", "AssetRegistry", }); string ExtraPathRoot = System.IO.Path.Combine(ModuleDirectory, "..", "..", "Extras"); // libgltf { string glTFPath = System.IO.Path.Combine(ExtraPathRoot, "libgltf_ue4", "libgltf-0.1.3"); string IncludePath = System.IO.Path.Combine(glTFPath, "include"); string LibPath = ""; string LibFilePath = ""; if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64)) { string PlatformName = ""; if (Target.Platform == UnrealTargetPlatform.Win32) { PlatformName = "win32"; } else if (Target.Platform == UnrealTargetPlatform.Win64) { PlatformName = "win64"; } string VSName = "vs" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(); LibPath = System.IO.Path.Combine(glTFPath, "lib", PlatformName, VSName); LibFilePath = System.IO.Path.Combine(LibPath, "libgltf.lib"); } else if (Target.Platform == UnrealTargetPlatform.Linux) { LibPath = System.IO.Path.Combine(glTFPath, "lib", "linux"); LibFilePath = System.IO.Path.Combine(LibPath, "libgltf.a"); } else if (Target.Platform == UnrealTargetPlatform.Mac) { LibPath = System.IO.Path.Combine(glTFPath, "lib", "macos"); LibFilePath = System.IO.Path.Combine(LibPath, "libgltf.a"); } else if (Target.Platform == UnrealTargetPlatform.IOS) { LibPath = System.IO.Path.Combine(glTFPath, "lib", "ios"); LibFilePath = System.IO.Path.Combine(LibPath, "libgltf.a"); } PublicIncludePaths.Add(IncludePath); PublicLibraryPaths.Add(LibPath); PublicAdditionalLibraries.Add(LibFilePath); } // libdraco { string DracoPath = System.IO.Path.Combine(ExtraPathRoot, "libdraco_ue4", "libdraco-1.2.5"); string IncludePath = System.IO.Path.Combine(DracoPath, "include"); string LibPath = ""; string LibFilePath1 = ""; string LibFilePath2 = ""; if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64)) { string PlatformName = ""; if (Target.Platform == UnrealTargetPlatform.Win32) { PlatformName = "win32"; } else if (Target.Platform == UnrealTargetPlatform.Win64) { PlatformName = "win64"; } string VSName = "vs" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(); LibPath = System.IO.Path.Combine(DracoPath, "lib", PlatformName, VSName); LibFilePath1 = System.IO.Path.Combine(LibPath, "dracodec.lib"); LibFilePath2 = System.IO.Path.Combine(LibPath, "dracoenc.lib"); } else if (Target.Platform == UnrealTargetPlatform.Linux) { LibPath = System.IO.Path.Combine(DracoPath, "lib", "linux"); LibFilePath1 = System.IO.Path.Combine(LibPath, "libdracodec.a"); LibFilePath2 = System.IO.Path.Combine(LibPath, "libdracoenc.a"); } else if (Target.Platform == UnrealTargetPlatform.Mac) { LibPath = System.IO.Path.Combine(DracoPath, "lib", "macos"); LibFilePath1 = System.IO.Path.Combine(LibPath, "libdracodec.a"); LibFilePath2 = System.IO.Path.Combine(LibPath, "libdracoenc.a"); } else if (Target.Platform == UnrealTargetPlatform.IOS) { LibPath = System.IO.Path.Combine(DracoPath, "lib", "ios"); LibFilePath1 = System.IO.Path.Combine(LibPath, "libdracodec.a"); LibFilePath2 = System.IO.Path.Combine(LibPath, "libdracoenc.a"); } PublicIncludePaths.Add(IncludePath); PublicLibraryPaths.Add(LibPath); PublicAdditionalLibraries.Add(LibFilePath1); PublicAdditionalLibraries.Add(LibFilePath2); } }
void OldThirdParty(ReadOnlyTargetRules Target) { string LibraryPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty", "Library")); if (Target.Platform == UnrealTargetPlatform.Win64) { string V8LibraryPath = Path.Combine(LibraryPath, "V8", "Win64"); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "encoding.lib")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "inspector.lib")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "inspector_string_conversions.lib")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "v8_base_without_compiler_0.lib")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "v8_base_without_compiler_1.lib")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "v8_compiler.lib")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "v8_external_snapshot.lib")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "v8_libbase.lib")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "v8_libplatform.lib")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "v8_libsampler.lib")); /* * if (Target.bBuildEditor) * { * string WSLibraryPath = Path.Combine(LibraryPath, "Websockets", "Win64"); * * PublicAdditionalLibraries.Add(Path.Combine(WSLibraryPath, "websockets_static.lib")); * PublicAdditionalLibraries.Add(Path.Combine(WSLibraryPath, "libssl_static.lib")); * PublicAdditionalLibraries.Add(Path.Combine(WSLibraryPath, "libcrypto_static.lib")); * PublicAdditionalLibraries.Add(Path.Combine(WSLibraryPath, "zlib_internal.lib")); * } */ } else if (Target.Platform == UnrealTargetPlatform.Android) { if (Target.Version.MajorVersion == 4 && Target.Version.MinorVersion >= 25) { // for arm7 string V8LibraryPath = Path.Combine(LibraryPath, "V8", "Android", "armeabi-v7a", "8.4.371.19"); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libwee8.a")); // for arm64 V8LibraryPath = Path.Combine(LibraryPath, "V8", "Android", "arm64-v8a", "8.4.371.19"); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libwee8.a")); } else if (Target.Version.MajorVersion == 4 && Target.Version.MinorVersion < 25 && Target.Version.MinorVersion >= 22) { // for arm7 string V8LibraryPath = Path.Combine(LibraryPath, "V8", "Android", "armeabi-v7a", "7.4.288"); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libinspector.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_base.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_external_snapshot.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_libbase.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_libplatform.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_libsampler.a")); // for arm64 V8LibraryPath = Path.Combine(LibraryPath, "V8", "Android", "arm64-v8a", "7.4.288"); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libinspector.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_base.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_external_snapshot.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_libbase.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_libplatform.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_libsampler.a")); } else if (Target.Version.MajorVersion == 4 && Target.Version.MinorVersion < 22) { string V8LibraryPath = Path.Combine(LibraryPath, "V8", "Android", "armeabi-v7a", "7.4.288"); PublicLibraryPaths.Add(V8LibraryPath); V8LibraryPath = Path.Combine(LibraryPath, "V8", "Android", "arm64-v8a", "7.4.288"); PublicLibraryPaths.Add(V8LibraryPath); PublicAdditionalLibraries.Add("inspector"); PublicAdditionalLibraries.Add("v8_base"); PublicAdditionalLibraries.Add("v8_external_snapshot"); PublicAdditionalLibraries.Add("v8_libbase"); PublicAdditionalLibraries.Add("v8_libplatform"); PublicAdditionalLibraries.Add("v8_libsampler"); } } else if (Target.Platform == UnrealTargetPlatform.Mac) { // PublicFrameworks.AddRange(new string[] { "WebKit", "JavaScriptCore" }); PublicFrameworks.AddRange(new string[] { "WebKit" }); string V8LibraryPath = Path.Combine(LibraryPath, "V8", "macOS"); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libbindings.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libencoding.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libinspector.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libinspector_string_conversions.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libtorque_base.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libtorque_generated_definitions.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libtorque_generated_initializers.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_base_without_compiler.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_compiler.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_external_snapshot.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_init.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_initializers.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_libbase.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_libplatform.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_libsampler.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_nosnapshot.a")); //PublicAdditionalLibraries.Add(Path.Combine(Path.Combine(LibraryPath, "ffi", "macOS"), "libffi.a")); } else if (Target.Platform == UnrealTargetPlatform.IOS) { PublicFrameworks.AddRange(new string[] { "WebKit" }); string V8LibraryPath = Path.Combine(LibraryPath, "V8", "iOS", "arm64"); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libbindings.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libencoding.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libinspector.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libinspector_string_conversions.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libtorque_generated_definitions.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_base_without_compiler.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_compiler.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_external_snapshot.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_libbase.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_libplatform.a")); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_libsampler.a")); //PublicAdditionalLibraries.Add(Path.Combine(Path.Combine(LibraryPath, "ffi", "iOS"), "libffi.a")); } else if (Target.Platform == UnrealTargetPlatform.Linux) { string V8LibraryPath = Path.Combine(LibraryPath, "V8", "Linux"); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libwee8.a")); } string HeaderPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty", "Include")); // External headers if (Target.Platform == UnrealTargetPlatform.Android) { if (Target.Version.MajorVersion == 4 && Target.Version.MinorVersion >= 25) { PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "v8", "8.4.371.19") }); } else if (Target.Version.MajorVersion == 4 && Target.Version.MinorVersion < 25) { PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "v8", "7.4.288") }); } PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "websocketpp") }); PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "asio") }); } else if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux) { PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "v8", "7.7.299") }); PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "websocketpp") }); PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "asio") }); } }
public GameLiftServerSDK(ReadOnlyTargetRules Target) : base(Target) { PublicIncludePaths.AddRange( new string[] { "GameLiftServerSDK/Public", }); PrivateIncludePaths.AddRange( new string[] { "GameLiftServerSDK/Private", }); PublicDependencyModuleNames.AddRange( new string[] { "Core", "Projects", }); PrivateDependencyModuleNames.AddRange( new string[] { }); DynamicallyLoadedModuleNames.AddRange( new string[] { }); string BaseDirectory = System.IO.Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", "..")); string SDKDirectory = System.IO.Path.Combine(BaseDirectory, "ThirdParty", "GameLiftServerSDK", Target.Platform.ToString()); bool bHasGameLiftSDK = System.IO.Directory.Exists(SDKDirectory); if (bHasGameLiftSDK) { if (Target.Type == TargetRules.TargetType.Server) { // Suppress build error 4577 bEnableExceptions = true; PublicDefinitions.Add("WITH_GAMELIFT=1"); if (Target.Platform == UnrealTargetPlatform.Linux) { SDKDirectory = System.IO.Path.Combine(SDKDirectory, "x86_64-unknown-linux-gnu"); string SDKLib = System.IO.Path.Combine(SDKDirectory, "libaws-cpp-sdk-gamelift-server.so"); PublicLibraryPaths.Add(SDKDirectory); PublicAdditionalLibraries.Add(SDKLib); RuntimeDependencies.Add(SDKLib); } else if (Target.Platform == UnrealTargetPlatform.Win64) { PublicLibraryPaths.Add(SDKDirectory); PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-gamelift-server.lib")); PublicDelayLoadDLLs.Add("aws-cpp-sdk-gamelift-server.dll"); string SDKLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-gamelift-server.dll"); RuntimeDependencies.Add(SDKLibWindows); } } else { PublicDefinitions.Add("WITH_GAMELIFT=0"); } } else { PublicDefinitions.Add("WITH_GAMELIFT=0"); } }
public Python(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; var EngineDir = Path.GetFullPath(Target.RelativeEnginePath); var PythonTPSDir = Path.Combine(EngineDir, "Source", "ThirdParty", "Python"); string PythonRoot = null; string PythonIncludePath = null; string PythonLibPath = null; string PythonLibName = null; if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux) { // Check for an explicit version before using the auto-detection logic PythonRoot = System.Environment.GetEnvironmentVariable("UE_PYTHON_DIR"); } // Perform auto-detection to try and find the Python root if (PythonRoot == null) { var KnownPaths = new List <string>(); // todo: This isn't correct for cross-compilation, we need to consider the host platform too if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { KnownPaths.AddRange( new string[] { Path.Combine(PythonTPSDir, Target.Platform == UnrealTargetPlatform.Win32 ? "Win32" : "Win64"), //"C:/Program Files/Python36", "C:/Python27", } ); } else if (Target.Platform == UnrealTargetPlatform.Mac) { KnownPaths.AddRange( new string[] { Path.Combine(PythonTPSDir, "Mac"), //"/Library/Frameworks/Python.framework/Versions/3.6", "/Library/Frameworks/Python.framework/Versions/2.7", //"/System/Library/Frameworks/Python.framework/Versions/2.7", } ); } foreach (var KnownPath in KnownPaths) { if (Directory.Exists(KnownPath)) { PythonRoot = KnownPath; break; } } } // Work out the include path if (PythonRoot != null) { PythonIncludePath = Path.Combine(PythonRoot, "include"); if (Target.Platform == UnrealTargetPlatform.Mac) { // On Mac the actual headers are inside a "pythonxy" directory, where x and y are the version number if (Directory.Exists(PythonIncludePath)) { string[] MatchingIncludePaths = Directory.GetDirectories(PythonIncludePath, "python*"); if (MatchingIncludePaths.Length > 0) { PythonIncludePath = Path.Combine(PythonIncludePath, Path.GetFileName(MatchingIncludePaths[0])); } } } if (!Directory.Exists(PythonIncludePath)) { PythonRoot = null; } } // Work out the lib path if (PythonRoot != null) { string LibFolder = null; string LibNamePattern = null; switch (Target.Platform) { case UnrealTargetPlatform.Win32: case UnrealTargetPlatform.Win64: LibFolder = "libs"; LibNamePattern = "python*.lib"; break; case UnrealTargetPlatform.Mac: LibFolder = "lib"; LibNamePattern = "libpython*.dylib"; break; case UnrealTargetPlatform.Linux: LibFolder = "lib"; LibNamePattern = "libpython*.so"; break; default: break; } if (LibFolder != null && LibNamePattern != null) { PythonLibPath = Path.Combine(PythonRoot, LibFolder); if (Directory.Exists(PythonLibPath)) { string[] MatchingLibFiles = Directory.GetFiles(PythonLibPath, LibNamePattern); if (MatchingLibFiles.Length > 0) { PythonLibName = Path.GetFileName(MatchingLibFiles[0]); } } } if (PythonLibPath == null || PythonLibName == null) { PythonRoot = null; } } // Make sure the Python install is the correct architecture if (PythonRoot != null) { string ExpectedPointerSizeResult = Target.Platform == UnrealTargetPlatform.Win32 ? "4" : "8"; // Invoke Python to query the pointer size of the interpreter so we can work out whether it's 32-bit or 64-bit // todo: We probably need to do this for all platforms, but right now it's only an issue on Windows if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { string Result = InvokePython(PythonRoot, "-c \"import struct; print(struct.calcsize('P'))\""); Result = Result != null?Result.Replace("\r", "").Replace("\n", "") : null; if (Result == null || Result != ExpectedPointerSizeResult) { PythonRoot = null; } } } if (PythonRoot == null) { PublicDefinitions.Add("WITH_PYTHON=0"); } else { // If the Python install we're using is within the Engine directory, make the path relative so that it's portable string EngineRelativePythonRoot = PythonRoot; if (EngineRelativePythonRoot.StartsWith(EngineDir)) { // Strip the Engine directory and then combine the path with the placeholder to ensure the path is delimited correctly EngineRelativePythonRoot = EngineRelativePythonRoot.Remove(0, EngineDir.Length); RuntimeDependencies.Add(Path.Combine("$(EngineDir)", EngineRelativePythonRoot, "...")); // Stage the Python SDK for use at runtime EngineRelativePythonRoot = Path.Combine("{ENGINE_DIR}", EngineRelativePythonRoot); // Can't use $(EngineDir) as the placeholder here as UBT is eating it } PublicDefinitions.Add("WITH_PYTHON=1"); PublicDefinitions.Add(string.Format("UE_PYTHON_DIR=\"{0}\"", EngineRelativePythonRoot.Replace('\\', '/'))); // Some versions of Python need this define set when building on MSVC if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { PublicDefinitions.Add("HAVE_ROUND=1"); } PublicSystemIncludePaths.Add(PythonIncludePath); if (Target.Platform == UnrealTargetPlatform.Mac) { // Mac doesn't understand PublicLibraryPaths PublicAdditionalLibraries.Add(Path.Combine(PythonLibPath, PythonLibName)); } else { PublicLibraryPaths.Add(PythonLibPath); PublicAdditionalLibraries.Add(PythonLibName); } } }
public ApexDestructionLib(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; if (Target.bCompileAPEX == false) { return; } // Determine which kind of libraries to link against APEXLibraryMode LibraryMode = GetAPEXLibraryMode(Target.Configuration); string LibrarySuffix = GetAPEXLibrarySuffix(LibraryMode); string ApexVersion = "APEX_1.4"; string APEXDir = Target.UEThirdPartySourceDirectory + "PhysX3/" + ApexVersion + "/"; string APEXLibDir = Target.UEThirdPartySourceDirectory + "PhysX3/Lib"; PublicSystemIncludePaths.AddRange( new string[] { APEXDir + "include/destructible", } ); // List of default library names (unused unless LibraryFormatString is non-null) List<string> ApexLibraries = new List<string>(); ApexLibraries.AddRange( new string[] { "APEX_Destructible{0}", }); string LibraryFormatString = null; // Libraries and DLLs for windows platform if (Target.Platform == UnrealTargetPlatform.Win64) { APEXLibDir += "/Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(); PublicLibraryPaths.Add(APEXLibDir); PublicAdditionalLibraries.Add(String.Format("APEXFramework{0}_x64.lib", LibrarySuffix)); PublicDelayLoadDLLs.Add(String.Format("APEXFramework{0}_x64.dll", LibrarySuffix)); string[] RuntimeDependenciesX64 = { "APEX_Destructible{0}_x64.dll", }; string ApexBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX3/Win64/VS{0}/", Target.WindowsPlatform.GetVisualStudioCompilerVersionName()); foreach (string RuntimeDependency in RuntimeDependenciesX64) { string FileName = ApexBinariesDir + String.Format(RuntimeDependency, LibrarySuffix); RuntimeDependencies.Add(FileName, StagedFileType.NonUFS); RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS); } } else if (Target.Platform == UnrealTargetPlatform.Win32) { APEXLibDir += "/Win32/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(); PublicLibraryPaths.Add(APEXLibDir); PublicAdditionalLibraries.Add(String.Format("APEXFramework{0}_x86.lib", LibrarySuffix)); PublicDelayLoadDLLs.Add(String.Format("APEXFramework{0}_x86.dll", LibrarySuffix)); string[] RuntimeDependenciesX86 = { "APEX_Destructible{0}_x86.dll", }; string ApexBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX3/Win32/VS{0}/", Target.WindowsPlatform.GetVisualStudioCompilerVersionName()); foreach (string RuntimeDependency in RuntimeDependenciesX86) { string FileName = ApexBinariesDir + String.Format(RuntimeDependency, LibrarySuffix); RuntimeDependencies.Add(FileName, StagedFileType.NonUFS); RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS); } } else if (Target.Platform == UnrealTargetPlatform.Mac) { APEXLibDir += "/Mac"; string[] DynamicLibrariesMac = new string[] { "/libAPEX_Destructible{0}.dylib" }; string PhysXBinariesDir = Target.UEThirdPartyBinariesDirectory + "PhysX3/Mac"; foreach (string Lib in DynamicLibrariesMac) { string LibraryPath = PhysXBinariesDir + String.Format(Lib, LibrarySuffix); PublicDelayLoadDLLs.Add(LibraryPath); RuntimeDependencies.Add(new RuntimeDependency(LibraryPath)); } } else if (Target.Platform == UnrealTargetPlatform.Linux) { if (Target.Architecture.StartsWith("x86_64")) { APEXLibDir += "/Linux/" + Target.Architecture; ApexLibraries.Add("APEX_Destructible{0}"); LibraryFormatString = APEXLibDir + "/lib{0}" + ".a"; } } else if (Target.Platform == UnrealTargetPlatform.PS4) { APEXLibDir += "/PS4"; PublicLibraryPaths.Add(APEXLibDir); LibraryFormatString = "{0}"; } else if (Target.Platform == UnrealTargetPlatform.XboxOne) { APEXLibDir += "/XboxOne/VS2015"; PublicLibraryPaths.Add(APEXLibDir); LibraryFormatString = "{0}.lib"; } else if (Target.Platform == UnrealTargetPlatform.Switch) { APEXLibDir += "/Switch"; PublicLibraryPaths.Add(APEXLibDir); LibraryFormatString = "{0}"; } // Add the libraries needed (used for all platforms except Windows and Mac) if (LibraryFormatString != null) { foreach (string Lib in ApexLibraries) { string ConfiguredLib = String.Format(Lib, LibrarySuffix); string FinalLib = String.Format(LibraryFormatString, ConfiguredLib); PublicAdditionalLibraries.Add(FinalLib); } } }
public SQLiteSupport(ReadOnlyTargetRules Target) : base(Target) { string PlatformName = ""; string ConfigurationName = ""; switch (Target.Platform) { case UnrealTargetPlatform.Win32: PlatformName = "Win32/"; break; case UnrealTargetPlatform.Win64: PlatformName = "x64/"; break; case UnrealTargetPlatform.IOS: case UnrealTargetPlatform.TVOS: PlatformName = "IOS/"; break; case UnrealTargetPlatform.Mac: PlatformName = "Mac/"; break; case UnrealTargetPlatform.Linux: PlatformName = "Linux/"; break; } switch (Target.Configuration) { case UnrealTargetConfiguration.Debug: ConfigurationName = "Debug/"; break; case UnrealTargetConfiguration.DebugGame: ConfigurationName = "Debug/"; break; default: ConfigurationName = "Release/"; break; } string LibraryPath = "" + Target.UEThirdPartySourceDirectory + "sqlite/lib/" + PlatformName + ConfigurationName; string LibraryFilename; if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.XboxOne) { LibraryFilename = Path.Combine(LibraryPath, "sqlite.lib"); } else { LibraryFilename = Path.Combine(LibraryPath, "sqlite.a"); } if (!File.Exists(LibraryFilename)) { throw new BuildException("Please refer to the Engine/Source/ThirdParty/sqlite/README.txt file prior to enabling this module."); } PublicIncludePaths.Add(Target.UEThirdPartySourceDirectory + "sqlite/sqlite/"); PublicDependencyModuleNames.AddRange( new string[] { "Core", "DatabaseSupport", } ); // Lib file PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryFilename); }
public Steamworks(TargetInfo Target) { /** Mark the current version of the Steam SDK */ string SteamVersion = "v132"; Type = ModuleType.External; string SdkBase = UEBuildConfiguration.UEThirdPartySourceDirectory + "Steamworks/Steam" + SteamVersion + "/sdk"; if (!Directory.Exists(SdkBase)) { string Err = string.Format("steamworks SDK not found in {0}", SdkBase); System.Console.WriteLine(Err); throw new BuildException(Err); } PublicIncludePaths.Add(SdkBase + "/public"); string LibraryPath = SdkBase + "/redistributable_bin/"; string LibraryName = "steam_api"; if (Target.Platform == UnrealTargetPlatform.Win32) { PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryName + ".lib"); PublicDelayLoadDLLs.Add(LibraryName + ".dll"); string SteamBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/Steamworks/Steam{0}/Win32/", SteamVersion); RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + "steam_api.dll")); if (Target.Type == TargetRules.TargetType.Server) { RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + "steamclient.dll")); RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + "tier0_s.dll")); RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + "vstdlib_s.dll")); } } else if (Target.Platform == UnrealTargetPlatform.Win64) { PublicLibraryPaths.Add(LibraryPath + "win64"); PublicAdditionalLibraries.Add(LibraryName + "64.lib"); PublicDelayLoadDLLs.Add(LibraryName + "64.dll"); string SteamBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/Steamworks/Steam{0}/Win64/", SteamVersion); RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + LibraryName + "64.dll")); if (Target.Type == TargetRules.TargetType.Server) { RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + "steamclient64.dll")); RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + "tier0_s64.dll")); RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + "vstdlib_s64.dll")); } } else if (Target.Platform == UnrealTargetPlatform.Mac) { LibraryPath += "osx32/libsteam_api.dylib"; PublicDelayLoadDLLs.Add(LibraryPath); PublicAdditionalShadowFiles.Add(LibraryPath); } else if (Target.Platform == UnrealTargetPlatform.Linux) { if (Target.IsMonolithic) { LibraryPath += "linux64"; PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryName); } else { LibraryPath += "linux64/libsteam_api.so"; PublicDelayLoadDLLs.Add(LibraryPath); } } }
public libcurl(TargetInfo Target) { Type = ModuleType.External; Definitions.Add("WITH_LIBCURL=1"); string NewLibCurlPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "libcurl/7_48_0/"; string LibCurlPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "libcurl/curl-7.47.1/"; // TODO: latest recompile for consoles and mobile platforms string OldLibCurlPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "libcurl/"; if (Target.Platform == UnrealTargetPlatform.Linux) { string platform = "/Linux/" + Target.Architecture; string IncludePath = NewLibCurlPath + "include" + platform; string LibraryPath = NewLibCurlPath + "lib" + platform; PublicIncludePaths.Add(IncludePath); PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryPath + "/libcurl.a"); PrivateDependencyModuleNames.Add("SSL"); } else if (Target.Platform == UnrealTargetPlatform.Android) { // toolchain will filter properly PublicIncludePaths.Add(OldLibCurlPath + "include/Android/ARMv7"); PublicLibraryPaths.Add(OldLibCurlPath + "lib/Android/ARMv7"); PublicIncludePaths.Add(OldLibCurlPath + "include/Android/ARM64"); PublicLibraryPaths.Add(OldLibCurlPath + "lib/Android/ARM64"); PublicIncludePaths.Add(OldLibCurlPath + "include/Android/x86"); PublicLibraryPaths.Add(OldLibCurlPath + "lib/Android/x86"); PublicIncludePaths.Add(OldLibCurlPath + "include/Android/x64"); PublicLibraryPaths.Add(OldLibCurlPath + "lib/Android/x64"); PublicAdditionalLibraries.Add("curl"); // PublicAdditionalLibraries.Add("crypto"); // PublicAdditionalLibraries.Add("ssl"); // PublicAdditionalLibraries.Add("dl"); } else if (Target.Platform == UnrealTargetPlatform.Mac) { string PlatformSubdir = "/Mac/"; PublicIncludePaths.Add(LibCurlPath + "include" + PlatformSubdir); // OSX needs full path PublicAdditionalLibraries.Add(LibCurlPath + "lib" + PlatformSubdir + "libcurl.a"); } else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")) { string PlatformSubdir = (Target.Platform == UnrealTargetPlatform.HTML5) ? "Win32" : Target.Platform.ToString(); PublicIncludePaths.Add(LibCurlPath + "/include/" + PlatformSubdir + "/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName()); PublicLibraryPaths.Add(LibCurlPath + "/lib/" + PlatformSubdir + "/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName()); PublicAdditionalLibraries.Add("libcurl_a.lib"); Definitions.Add("CURL_STATICLIB=1"); } }
public AWSCore(ReadOnlyTargetRules Target) : base(Target) { PrivateIncludePaths.AddRange(new string[] { "GameLiftClientSDK/AWSCore/Private" }); PublicIncludePaths.AddRange(new string[] { "GameLiftClientSDK/AWSCore/Public" }); PublicDependencyModuleNames.AddRange(new string[] { "Engine", "Core", "CoreUObject", "InputCore", "Projects" }); PrivateDependencyModuleNames.AddRange(new string[] { }); string BaseDirectory = System.IO.Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", "..", "..")); string ThirdPartyPath = System.IO.Path.Combine(BaseDirectory, "ThirdParty", "GameLiftClientSDK", Target.Platform.ToString()); bool bIsThirdPartyPathValid = System.IO.Directory.Exists(ThirdPartyPath); if (bIsThirdPartyPathValid) { PublicLibraryPaths.Add(ThirdPartyPath); //string AWSCCommonLibFile = System.IO.Path.Combine(ThirdPartyPath, "aws-c-common.lib"); //if (File.Exists(AWSCCommonLibFile)) //{ // PublicAdditionalLibraries.Add(AWSCCommonLibFile); //} //else //{ // throw new BuildException("aws-c-common.lib not found. Expected in this location: " + AWSCCommonLibFile); //} //string AWSCCommonDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-c-common.dll"); //if (File.Exists(AWSCCommonDLLFile)) //{ // PublicAdditionalLibraries.Add(AWSCCommonDLLFile); //} //else //{ // throw new BuildException("aws-c-common.dll not found. Expected in this location: " + AWSCCommonDLLFile); //} //string AWSCEventStreamLibFile = System.IO.Path.Combine(ThirdPartyPath, "aws-c-event-stream.lib"); //if (File.Exists(AWSCEventStreamLibFile)) //{ // PublicAdditionalLibraries.Add(AWSCEventStreamLibFile); //} //else //{ // throw new BuildException("aws-c-event-stream.lib not found. Expected in this location: " + AWSCEventStreamLibFile); //} //string AWSCEventStreamDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-c-event-stream.dll"); //if (File.Exists(AWSCEventStreamDLLFile)) //{ // PublicAdditionalLibraries.Add(AWSCEventStreamDLLFile); //} //else //{ // throw new BuildException("aws-c-event-stream.dll not found. Expected in this location: " + AWSCEventStreamDLLFile); //} string AWSCoreLibFile = System.IO.Path.Combine(ThirdPartyPath, "aws-cpp-sdk-core.lib"); if (File.Exists(AWSCoreLibFile)) { PublicAdditionalLibraries.Add(AWSCoreLibFile); } else { throw new BuildException("aws-cpp-sdk-core.lib not found. Expected in this location: " + AWSCoreLibFile); } string AWSCoreDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-cpp-sdk-core.dll"); string AWSCommonDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-c-common.dll"); string AWSStreamDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-c-event-stream.dll"); string AWSChecksumDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-checksums.dll"); if (File.Exists(AWSCoreDLLFile)) { RuntimeDependencies.Add(AWSCommonDLLFile); RuntimeDependencies.Add(AWSStreamDLLFile); RuntimeDependencies.Add(AWSChecksumDLLFile); PublicDelayLoadDLLs.Add("aws-cpp-sdk-core.dll"); RuntimeDependencies.Add(AWSCoreDLLFile); } else { throw new BuildException("aws-cpp-sdk-core.dll not found. Expected in this location: " + AWSCoreDLLFile); } string BinariesDirectory = System.IO.Path.Combine(BaseDirectory, "Binaries", Target.Platform.ToString()); if (!Directory.Exists(BinariesDirectory)) { Directory.CreateDirectory(BinariesDirectory); } if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "aws-cpp-sdk-core.dll")) == false) { File.Copy(System.IO.Path.Combine(ThirdPartyPath, "aws-cpp-sdk-core.dll"), System.IO.Path.Combine(BinariesDirectory, "aws-cpp-sdk-core.dll")); } if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "aws-c-common.dll")) == false) { File.Copy(System.IO.Path.Combine(ThirdPartyPath, "aws-c-common.dll"), System.IO.Path.Combine(BinariesDirectory, "aws-c-common.dll")); } if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "aws-c-event-stream.dll")) == false) { File.Copy(System.IO.Path.Combine(ThirdPartyPath, "aws-c-event-stream.dll"), System.IO.Path.Combine(BinariesDirectory, "aws-c-event-stream.dll")); } if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "aws-checksums.dll")) == false) { File.Copy(System.IO.Path.Combine(ThirdPartyPath, "aws-checksums.dll"), System.IO.Path.Combine(BinariesDirectory, "aws-checksums.dll")); } } }
public SQLiteSupport(TargetInfo Target) { string PlatformName = ""; string ConfigurationName = ""; switch (Target.Platform) { case UnrealTargetPlatform.Win32: PlatformName = "Win32/"; break; case UnrealTargetPlatform.Win64: PlatformName = "x64/"; break; case UnrealTargetPlatform.IOS: PlatformName = "IOS/"; break; case UnrealTargetPlatform.Mac: PlatformName = "Mac/"; break; case UnrealTargetPlatform.Linux: PlatformName = "Linux/"; break; } switch (Target.Configuration) { case UnrealTargetConfiguration.Debug: ConfigurationName = "Debug/"; break; case UnrealTargetConfiguration.DebugGame: ConfigurationName = "Debug/"; break; default: ConfigurationName = "Release/"; break; } string LibraryPath = "" + UEBuildConfiguration.UEThirdPartySourceDirectory + "sqlite/lib/" + PlatformName + ConfigurationName; string LibraryFilename = Path.Combine(LibraryPath, "sqlite" + UEBuildPlatform.GetBuildPlatform(Target.Platform).GetBinaryExtension(UEBuildBinaryType.StaticLibrary)); if (!File.Exists(LibraryFilename)) { throw new BuildException("Please refer to the Engine/Source/ThirdParty/sqlite/README.txt file prior to enabling this module."); } PublicIncludePaths.Add(UEBuildConfiguration.UEThirdPartySourceDirectory + "sqlite/sqlite/"); PublicDependencyModuleNames.AddRange( new string[] { "Core", "DatabaseSupport", } ); // Lib file PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryFilename); }
public void LoadZEDSDK(ReadOnlyTargetRules Target, string DirPath) { if (Target.Platform == UnrealTargetPlatform.Win64) { if (!Directory.Exists(DirPath)) { string Err = string.Format("ZED SDK missing"); System.Console.WriteLine(Err); throw new BuildException(Err); } // Check SDK version string DefinesHeaderFilePath = Path.Combine(DirPath, "include\\sl_zed\\defines.hpp"); string Major = "2"; string Minor = "7"; // Find SDK major and minor version and compare foreach (var line in File.ReadLines(DefinesHeaderFilePath)) { if (!string.IsNullOrEmpty(line)) { if (line.Contains("#define ZED_SDK_MAJOR_VERSION")) { string SDKMajor = line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)[2]; if (!SDKMajor.Equals(Major)) { string Err = string.Format("ZED SDK Major Version mismatch : found {0} expected {1}", SDKMajor, Major); System.Console.WriteLine(Err); throw new BuildException(Err); } } else if (line.Contains("#define ZED_SDK_MINOR_VERSION")) { string SDKMinor = line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)[2]; if (!SDKMinor.Equals(Minor)) { string Err = string.Format("ZED SDK Minor Version mismatch : found {0} expected {1}", SDKMinor, Minor); System.Console.WriteLine(Err); throw new BuildException(Err); } break; } } } // Set the paths to the SDK string[] LibrariesNames = Directory.GetFiles(Path.Combine(DirPath, "lib")); PublicIncludePaths.Add(Path.Combine(DirPath, "include")); PublicLibraryPaths.Add(Path.Combine(DirPath, "lib")); foreach (string Library in LibrariesNames) { PublicAdditionalLibraries.Add(Library); } } else if (Target.Platform == UnrealTargetPlatform.Win32) { string Err = string.Format("Attempt to build against ZED SDK on unsupported platform {0}", Target.Platform); System.Console.WriteLine(Err); throw new BuildException(Err); } }
private bool LoadV8(ReadOnlyTargetRules Target) { int[] v8_version = GetV8Version(); bool ShouldLink_libsampler = !(v8_version[0] == 5 && v8_version[1] < 3); if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { string LibrariesPath = Path.Combine(ThirdPartyPath, "v8", "lib"); if (Target.Platform == UnrealTargetPlatform.Win64) { LibrariesPath = Path.Combine(LibrariesPath, "Win64"); } else { LibrariesPath = Path.Combine(LibrariesPath, "Win32"); } if (Target.Configuration == UnrealTargetConfiguration.Debug) { LibrariesPath = Path.Combine(LibrariesPath, "Debug"); } else { LibrariesPath = Path.Combine(LibrariesPath, "Release"); } PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base_0.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base_1.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base_2.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base_3.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_libbase.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_libplatform.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_nosnapshot.lib")); if (ShouldLink_libsampler) { PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_libsampler.lib")); } Definitions.Add(string.Format("WITH_V8=1")); return(true); } else if (Target.Platform == UnrealTargetPlatform.Android) { string LibrariesPath = Path.Combine(ThirdPartyPath, "v8", "lib", "Android"); PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "ARMv7")); PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "ARM64")); PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "x86")); PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "x64")); PublicAdditionalLibraries.Add("v8_base"); PublicAdditionalLibraries.Add("v8_libbase"); PublicAdditionalLibraries.Add("v8_libplatform"); PublicAdditionalLibraries.Add("v8_nosnapshot"); if (ShouldLink_libsampler) { PublicAdditionalLibraries.Add("v8_libsampler"); } Definitions.Add(string.Format("WITH_V8=1")); return(true); } else if (Target.Platform == UnrealTargetPlatform.Linux) { string LibrariesPath = Path.Combine(ThirdPartyPath, "v8", "lib", "Linux"); PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "x64")); PublicAdditionalLibraries.Add("v8_base"); PublicAdditionalLibraries.Add("v8_libbase"); PublicAdditionalLibraries.Add("v8_libplatform"); PublicAdditionalLibraries.Add("v8_nosnapshot"); if (ShouldLink_libsampler) { PublicAdditionalLibraries.Add("v8_libsampler"); } Definitions.Add(string.Format("WITH_V8=1")); return(true); } else if (Target.Platform == UnrealTargetPlatform.Mac) { string LibrariesPath = Path.Combine(ThirdPartyPath, "v8", "lib", "Mac", "x64"); PublicLibraryPaths.Add(LibrariesPath); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_base.a")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_libbase.a")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_libplatform.a")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_nosnapshot.a")); if (ShouldLink_libsampler) { PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_libsampler.a")); } Definitions.Add(string.Format("WITH_V8=1")); return(true); } Definitions.Add(string.Format("WITH_V8=0")); return(false); }
public zlib(TargetInfo Target) { Type = ModuleType.External; string zlibPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "zlib/zlib-1.2.5/"; PublicIncludePaths.Add(zlibPath + "Inc"); if (Target.Platform == UnrealTargetPlatform.Win64) { PublicLibraryPaths.Add(zlibPath + "Lib/Win64"); PublicAdditionalLibraries.Add("zlib_64.lib"); } else if (Target.Platform == UnrealTargetPlatform.Win32 || (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32") // simulator ) { PublicLibraryPaths.Add(zlibPath + "Lib/Win32"); PublicAdditionalLibraries.Add("zlib.lib"); } else if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS) { PublicAdditionalLibraries.Add("z"); } else if (Target.Platform == UnrealTargetPlatform.Android) { PublicAdditionalLibraries.Add("z"); } else if (Target.Platform == UnrealTargetPlatform.HTML5) { string OpimizationSuffix = ""; if (UEBuildConfiguration.bCompileForSize) { OpimizationSuffix = "_Oz"; } else { if (Target.Configuration == UnrealTargetConfiguration.Development) { OpimizationSuffix = "_O2"; } else if (Target.Configuration == UnrealTargetConfiguration.Shipping) { OpimizationSuffix = "_O3"; } } PublicAdditionalLibraries.Add(zlibPath + "Lib/HTML5/zlib" + OpimizationSuffix + ".bc"); } else if (Target.Platform == UnrealTargetPlatform.Linux) { if (Target.IsMonolithic) { PublicAdditionalLibraries.Add(zlibPath + "Lib/Linux/" + Target.Architecture + "/libz.a"); } else { PublicAdditionalLibraries.Add(zlibPath + "Lib/Linux/" + Target.Architecture + "/libz_fPIC.a"); } } }
public VulkanRHI(ReadOnlyTargetRules Target) : base(Target) { bOutputPubliclyDistributable = true; PrivateIncludePaths.Add("Runtime/Vulkan/Private"); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "RHI", "RenderCore", "ShaderCore", "UtilityShaders", } ); if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { 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"); } } else if (Target.Platform == UnrealTargetPlatform.Linux) { AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2"); string VulkanSDKPath = Environment.GetEnvironmentVariable("VULKAN_SDK"); bool bSDKInstalled = !String.IsNullOrEmpty(VulkanSDKPath); if (BuildHostPlatform.Current.Platform != UnrealTargetPlatform.Linux || !bSDKInstalled) { AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan"); } else { PrivateIncludePaths.Add(VulkanSDKPath + "/include"); PrivateIncludePaths.Add(VulkanSDKPath + "/include/vulkan"); PublicLibraryPaths.Add(VulkanSDKPath + "/lib"); PublicAdditionalLibraries.Add("vulkan"); } } else if (Target.Platform == UnrealTargetPlatform.Android || Target.Platform == UnrealTargetPlatform.Mac) { string VulkanSDKPath = Environment.GetEnvironmentVariable("VULKAN_SDK"); bool bHaveVulkan = false; if (Target.Platform == UnrealTargetPlatform.Android) { // Note: header is the same for all architectures so just use arch-arm string NDKPath = Environment.GetEnvironmentVariable("NDKROOT"); string NDKVulkanIncludePath = NDKPath + "/platforms/android-24/arch-arm/usr/include/vulkan"; // Use NDK Vulkan header if discovered, or VulkanSDK if available if (File.Exists(NDKVulkanIncludePath + "/vulkan.h")) { bHaveVulkan = true; PrivateIncludePaths.Add(NDKVulkanIncludePath); } else if (!String.IsNullOrEmpty(VulkanSDKPath)) { // If the user has an installed SDK, use that instead bHaveVulkan = true; PrivateIncludePaths.Add(VulkanSDKPath + "/Include/vulkan"); } else { // Fall back to the Windows Vulkan SDK (the headers are the same) bHaveVulkan = true; PrivateIncludePaths.Add(UEBuildConfiguration.UEThirdPartySourceDirectory + "Vulkan/Windows/Include/vulkan"); } } else if (!String.IsNullOrEmpty(VulkanSDKPath)) { bHaveVulkan = true; PrivateIncludePaths.Add(VulkanSDKPath + "/Include"); if (Target.Platform == UnrealTargetPlatform.Win32) { PublicLibraryPaths.Add(VulkanSDKPath + "/Bin32"); } else { PublicLibraryPaths.Add(VulkanSDKPath + "/Bin"); } PublicAdditionalLibraries.Add("vulkan-1.lib"); PublicAdditionalLibraries.Add("vkstatic.1.lib"); } if (bHaveVulkan) { if (Target.Configuration != UnrealTargetConfiguration.Shipping) { PrivateIncludePathModuleNames.AddRange( new string[] { "TaskGraph", } ); } } else { PrecompileForTargets = PrecompileTargetsType.None; } } else { PrecompileForTargets = PrecompileTargetsType.None; } }
public GoogleTest(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; string RootPath = Target.UEThirdPartySourceDirectory + "GoogleTest/"; string DefaultConfiguration = "MinSizeRel"; // Includes PublicSystemIncludePaths.Add(RootPath + "include/"); // Libraries string PartialLibraryPath = "lib/" + Target.Platform.ToString() + "/"; string LibraryPath = RootPath; if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32) { PartialLibraryPath += "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(); if (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) { PartialLibraryPath += "/Debug"; } else { PartialLibraryPath += "/" + DefaultConfiguration; } //if (!Target.IsMonolithic) //{ // PartialLibraryPath += "_Shared"; //} PartialLibraryPath += "/"; LibraryPath += PartialLibraryPath; //i.e. Engine\Source\ThirdParty\GoogleTest\lib\Win64\VS2013\MinSizeRel_Shared\ // I was unable to get non-monolithic windows builds working without crashing within the // time box I was given for the integration. The workaround is to ensure that all tests // are included in the same dll when building monolithic, otherwise error messages // will not be routed properly. // We should re-investigate this integration problem in the future, as more teams want to // adopt usage of the library //if (!Target.IsMonolithic) //{ // PublicAdditionalLibraries.Add("gmock_main.lib"); // RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/ThirdParty/GoogleTest/" + PartialLibraryPath + "gmock_main.dll")); //} //else //{ PublicAdditionalLibraries.Add("gtest.lib"); PublicAdditionalLibraries.Add("gmock.lib"); PublicAdditionalLibraries.Add("gmock_main.lib"); //} } else if (Target.Platform == UnrealTargetPlatform.Mac) { if (Target.LinkType == TargetLinkType.Monolithic) { PartialLibraryPath += DefaultConfiguration + "/"; LibraryPath += PartialLibraryPath; PublicAdditionalLibraries.Add(LibraryPath + "libgtest.a"); PublicAdditionalLibraries.Add(LibraryPath + "libgmock.a"); PublicAdditionalLibraries.Add(LibraryPath + "libgmock_main.a"); } else { PartialLibraryPath += DefaultConfiguration + "_Shared/"; LibraryPath += PartialLibraryPath; PublicAdditionalLibraries.Add(LibraryPath + "libgmock_main.dylib"); } } PublicLibraryPaths.Add(LibraryPath); // The including module will also need these enabled Definitions.Add("WITH_GOOGLE_MOCK=1"); Definitions.Add("WITH_GOOGLE_TEST=1"); Definitions.Add("GTEST_HAS_POSIX_RE=0"); if (Target.LinkType != TargetLinkType.Monolithic) { //Definitions.Add("GTEST_LINKED_AS_SHARED_LIBRARY=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" + Target.Platform); } } 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 libstrophe(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; string StrophePackagePath = Path.Combine(Target.UEThirdPartySourceDirectory, "libstrophe", "libstrophe-0.9.1"); bool bIsSupported = Target.Platform == UnrealTargetPlatform.XboxOne || Target.Platform == UnrealTargetPlatform.Android || Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.PS4 || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Switch || Target.IsInPlatformGroup(UnrealPlatformGroup.Unix); if (bIsSupported) { PrivateDefinitions.Add("XML_STATIC"); PublicSystemIncludePaths.Add(StrophePackagePath); string ConfigName = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ? "Debug" : "Release"; if (!Target.IsInPlatformGroup(UnrealPlatformGroup.Unix)) { AddEngineThirdPartyPrivateStaticDependencies(Target, "Expat"); } if (Target.Platform == UnrealTargetPlatform.XboxOne) { // Use reflection to allow type not to exist if console code is not present string ToolchainName = "VS"; System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool"); if (XboxOnePlatformType != null) { System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null); ToolchainName += VersionName.ToString(); } string LibraryPath = Path.Combine(StrophePackagePath, "XboxOne", ToolchainName, ConfigName); PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, "strophe.lib")); } else if (Target.Platform == UnrealTargetPlatform.Android) { string LibraryPath = Path.Combine(StrophePackagePath, "Android", ConfigName); PublicLibraryPaths.Add(Path.Combine(LibraryPath, "armv7")); PublicLibraryPaths.Add(Path.Combine(LibraryPath, "arm64")); PublicAdditionalLibraries.Add("strophe"); } else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.Mac) { PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, Target.Platform.ToString(), ConfigName, "libstrophe.a")); PublicAdditionalLibraries.Add("resolv"); } else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { PublicLibraryPaths.Add(Path.Combine(StrophePackagePath, Target.Platform.ToString(), "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(), ConfigName)); PublicAdditionalLibraries.Add("strophe.lib"); } else if (Target.Platform == UnrealTargetPlatform.PS4) { PublicLibraryPaths.Add(Path.Combine(StrophePackagePath, Target.Platform.ToString(), ConfigName)); PublicAdditionalLibraries.Add("strophe"); } else if (Target.Platform == UnrealTargetPlatform.Switch) { PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, Target.Platform.ToString(), ConfigName, "libstrophe.a")); } else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix)) { PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, "Linux", Target.Architecture.ToString(), ConfigName, "libstrophe" + ((Target.LinkType != TargetLinkType.Monolithic) ? "_fPIC" : "") + ".a")); PublicAdditionalLibraries.Add("resolv"); } } }
public Steamworks(ReadOnlyTargetRules Target) : base(Target) { /** Mark the current version of the Steam SDK */ string SteamVersion = "v139"; Type = ModuleType.External; PublicDefinitions.Add("STEAM_SDK_VER=TEXT(\"1.39\")"); PublicDefinitions.Add("STEAM_SDK_VER_PATH=TEXT(\"Steam" + SteamVersion + "\")"); string SdkBase = Target.UEThirdPartySourceDirectory + "Steamworks/Steam" + SteamVersion + "/sdk"; if (!Directory.Exists(SdkBase)) { string Err = string.Format("steamworks SDK not found in {0}", SdkBase); System.Console.WriteLine(Err); throw new BuildException(Err); } PublicIncludePaths.Add(SdkBase + "/public"); string LibraryPath = SdkBase + "/redistributable_bin/"; string LibraryName = "steam_api"; if (Target.Platform == UnrealTargetPlatform.Win32) { PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryName + ".lib"); PublicDelayLoadDLLs.Add(LibraryName + ".dll"); string SteamBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/Steamworks/Steam{0}/Win32/", SteamVersion); RuntimeDependencies.Add(SteamBinariesDir + "steam_api.dll"); if (Target.Type == TargetType.Server) { RuntimeDependencies.Add(SteamBinariesDir + "steamclient.dll"); RuntimeDependencies.Add(SteamBinariesDir + "tier0_s.dll"); RuntimeDependencies.Add(SteamBinariesDir + "vstdlib_s.dll"); } } else if (Target.Platform == UnrealTargetPlatform.Win64) { PublicLibraryPaths.Add(LibraryPath + "win64"); PublicAdditionalLibraries.Add(LibraryName + "64.lib"); PublicDelayLoadDLLs.Add(LibraryName + "64.dll"); string SteamBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/Steamworks/Steam{0}/Win64/", SteamVersion); RuntimeDependencies.Add(SteamBinariesDir + LibraryName + "64.dll"); if (Target.Type == TargetType.Server) { RuntimeDependencies.Add(SteamBinariesDir + "steamclient64.dll"); RuntimeDependencies.Add(SteamBinariesDir + "tier0_s64.dll"); RuntimeDependencies.Add(SteamBinariesDir + "vstdlib_s64.dll"); } } else if (Target.Platform == UnrealTargetPlatform.Mac) { string SteamBinariesPath = String.Format(Target.UEThirdPartyBinariesDirectory + "Steamworks/Steam{0}/Mac/", SteamVersion); LibraryPath = SteamBinariesPath + "libsteam_api.dylib"; PublicDelayLoadDLLs.Add(LibraryPath); RuntimeDependencies.Add(LibraryPath); } else if (Target.Platform == UnrealTargetPlatform.Linux) { if (Target.LinkType == TargetLinkType.Monolithic) { LibraryPath += "linux64"; PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryName); } else { LibraryPath += "linux64/libsteam_api.so"; PublicDelayLoadDLLs.Add(LibraryPath); } string SteamBinariesPath = String.Format(Target.UEThirdPartyBinariesDirectory + "Steamworks/Steam{0}/{1}", SteamVersion, Target.Architecture); PrivateRuntimeLibraryPaths.Add(SteamBinariesPath); PublicAdditionalLibraries.Add(SteamBinariesPath + "/libsteam_api.so"); RuntimeDependencies.Add(SteamBinariesPath + "/libsteam_api.so"); } }
public UElibPNG(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; string libPNGPath = Target.UEThirdPartySourceDirectory + "libPNG/libPNG-1.5.2"; if (Target.Platform == UnrealTargetPlatform.Win64) { string LibPath = libPNGPath + "/lib/Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(); PublicLibraryPaths.Add(LibPath); string LibFileName = "libpng" + (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT ? "d" : "") + "_64.lib"; PublicAdditionalLibraries.Add(LibFileName); } else if (Target.Platform == UnrealTargetPlatform.Win32) { libPNGPath = libPNGPath + "/lib/Win32/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(); PublicLibraryPaths.Add(libPNGPath); string LibFileName = "libpng" + (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT ? "d" : "") + ".lib"; PublicAdditionalLibraries.Add(LibFileName); } else if (Target.Platform == UnrealTargetPlatform.Mac) { PublicAdditionalLibraries.Add(libPNGPath + "/lib/Mac/libpng.a"); } else if (Target.Platform == UnrealTargetPlatform.IOS) { if (Target.Architecture == "-simulator") { PublicLibraryPaths.Add(libPNGPath + "/lib/ios/Simulator"); } else { PublicLibraryPaths.Add(libPNGPath + "/lib/ios/Device"); } PublicAdditionalLibraries.Add("png152"); } else if (Target.Platform == UnrealTargetPlatform.TVOS) { if (Target.Architecture == "-simulator") { PublicLibraryPaths.Add(libPNGPath + "/lib/TVOS/Simulator"); } else { PublicLibraryPaths.Add(libPNGPath + "/lib/TVOS/Device"); } PublicAdditionalLibraries.Add("png152"); } else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android)) { libPNGPath = Target.UEThirdPartySourceDirectory + "libPNG/libPNG-1.5.27"; PublicLibraryPaths.Add(libPNGPath + "/lib/Android/ARMv7"); PublicLibraryPaths.Add(libPNGPath + "/lib/Android/ARM64"); PublicLibraryPaths.Add(libPNGPath + "/lib/Android/x86"); PublicLibraryPaths.Add(libPNGPath + "/lib/Android/x64"); PublicAdditionalLibraries.Add("png"); } else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix)) { // migrate all architectures to the newer binary if (Target.Architecture.StartsWith("aarch64") || Target.Architecture.StartsWith("i686")) { libPNGPath = Target.UEThirdPartySourceDirectory + "libPNG/libPNG-1.5.27"; } PublicAdditionalLibraries.Add(libPNGPath + "/lib/Linux/" + Target.Architecture + "/libpng.a"); } else if (Target.Platform == UnrealTargetPlatform.HTML5) { PublicLibraryPaths.Add(libPNGPath + "/lib/HTML5"); string OpimizationSuffix = ""; if (Target.bCompileForSize) { OpimizationSuffix = "_Oz"; } else { if (Target.Configuration == UnrealTargetConfiguration.Development) { OpimizationSuffix = "_O2"; } else if (Target.Configuration == UnrealTargetConfiguration.Shipping) { OpimizationSuffix = "_O3"; } } PublicAdditionalLibraries.Add(libPNGPath + "/lib/HTML5/libpng" + OpimizationSuffix + ".bc"); } else if (Target.Platform == UnrealTargetPlatform.PS4) { PublicLibraryPaths.Add(libPNGPath + "/lib/PS4"); PublicAdditionalLibraries.Add("png152"); } else if (Target.Platform == UnrealTargetPlatform.XboxOne) { // Use reflection to allow type not to exist if console code is not present System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool"); if (XboxOnePlatformType != null) { System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null); PublicLibraryPaths.Add(libPNGPath + "/lib/XboxOne/VS" + VersionName.ToString()); PublicAdditionalLibraries.Add("libpng125_XboxOne.lib"); } } else if (Target.Platform == UnrealTargetPlatform.Switch) { PublicAdditionalLibraries.Add(System.IO.Path.Combine(libPNGPath, "lib/Switch/libPNG.a")); } PublicIncludePaths.Add(libPNGPath); }