public FreeImage(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; PublicSystemIncludePaths.Add(Path.Combine(ModuleDirectory, "Source")); string BinaryLibraryFolder = Path.Combine(Target.UEThirdPartyBinariesDirectory, "FreeImage", Target.Platform.ToString()); string LibraryFileName = ""; bool bWithFreeImage = false; if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32) { LibraryFileName = "FreeImage.dll"; string DynLibPath = Path.Combine(BinaryLibraryFolder, LibraryFileName); string LibPath = Path.Combine(ModuleDirectory, "lib", Target.Platform.ToString()); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "FreeImage.lib")); PublicDelayLoadDLLs.Add(LibraryFileName); RuntimeDependencies.Add(DynLibPath); bWithFreeImage = true; } else if (Target.Platform == UnrealTargetPlatform.Linux) { LibraryFileName = "libfreeimage-3.18.0.so"; string DynLibPath = Path.Combine(BinaryLibraryFolder, LibraryFileName); PublicRuntimeLibraryPaths.Add(BinaryLibraryFolder); PublicAdditionalLibraries.Add(DynLibPath); PublicDelayLoadDLLs.Add(LibraryFileName); RuntimeDependencies.Add(DynLibPath); PublicSystemLibraries.Add("stdc++"); bWithFreeImage = true; } else if (Target.Platform == UnrealTargetPlatform.Mac) { LibraryFileName = "libfreeimage-3.18.0.dylib"; string DynLibPath = Path.Combine(BinaryLibraryFolder, LibraryFileName); PublicRuntimeLibraryPaths.Add(BinaryLibraryFolder); PublicAdditionalLibraries.Add(DynLibPath); PublicDelayLoadDLLs.Add(DynLibPath); RuntimeDependencies.Add(DynLibPath); PublicSystemLibraries.Add("stdc++"); bWithFreeImage = true; } PublicDefinitions.Add("WITH_FREEIMAGE_LIB=" + (bWithFreeImage ? '1' : '0')); if (LibraryFileName != "") { PublicDefinitions.Add("FREEIMAGE_LIB_FILENAME=\"" + LibraryFileName + "\""); } }
public PRT(ReadOnlyTargetRules Target) : base(Target) { bUseRTTI = true; bEnableExceptions = true; Type = ModuleType.External; AbstractPlatform Platform; if (Target.Platform == UnrealTargetPlatform.Win64) { Platform = new WindowsPlatform(); } else if (Target.Platform == UnrealTargetPlatform.Mac) { Platform = new MacPlatform(); } else { throw new System.PlatformNotSupportedException(); } string LibDir = Path.Combine(ModuleDirectory, "lib", Platform.Name, "Release"); string BinDir = Path.Combine(ModuleDirectory, "bin", Platform.Name, "Release"); string IncludeDir = Path.Combine(ModuleDirectory, "include"); // 1. Check if prt is already available and has correct version, otherwise download from official github repo bool PrtInstalled = Directory.Exists(LibDir) && Directory.Exists(BinDir); string PrtCorePath = Path.Combine(BinDir, PrtCoreDllName); bool PrtCoreExists = File.Exists(PrtCorePath); bool PrtVersionMatch = PrtCoreExists && CheckDllVersion(PrtCorePath, PrtMajor, PrtMinor, PrtBuild); if (!PrtInstalled || !PrtVersionMatch) { string PrtUrl = "https://github.com/Esri/esri-cityengine-sdk/releases/download"; string PrtVersion = string.Format("{0}.{1}.{2}", PrtMajor, PrtMinor, PrtBuild); string PrtLibName = string.Format("esri_ce_sdk-{0}-{1}", PrtVersion, Platform.PrtPlatform); string PrtLibZipFile = PrtLibName + ".zip"; string PrtDownloadUrl = Path.Combine(PrtUrl, PrtVersion, PrtLibZipFile); try { if (Directory.Exists(LibDir)) { Directory.Delete(LibDir, true); } if (Directory.Exists(BinDir)) { Directory.Delete(BinDir, true); } if (Directory.Exists(IncludeDir)) { Directory.Delete(IncludeDir, true); } if (Debug) { if (!PrtInstalled) { Console.WriteLine("PRT not found"); } Console.WriteLine("Updating PRT"); } if (Debug) { System.Console.WriteLine("Downloading " + PrtDownloadUrl + "..."); } using (var Client = new WebClient()) { Client.DownloadFile(PrtDownloadUrl, Path.Combine(ModuleDirectory, PrtLibZipFile)); } if (Debug) { System.Console.WriteLine("Extracting " + PrtLibZipFile + "..."); } Platform.ZipExtractor.Unzip(ModuleDirectory, PrtLibZipFile, PrtLibName); Directory.CreateDirectory(LibDir); Directory.CreateDirectory(BinDir); Copy(Path.Combine(ModuleDirectory, PrtLibName, "lib"), Path.Combine(ModuleDirectory, LibDir)); Copy(Path.Combine(ModuleDirectory, PrtLibName, "bin"), Path.Combine(ModuleDirectory, BinDir)); Copy(Path.Combine(ModuleDirectory, PrtLibName, "include"), Path.Combine(ModuleDirectory, "include")); } finally { Directory.Delete(Path.Combine(ModuleDirectory, PrtLibName), true); File.Delete(Path.Combine(ModuleDirectory, PrtLibZipFile)); } } else if (Debug) { Console.WriteLine("PRT found"); } // 2. Copy libraries to module binaries directory and add dependencies string ModuleBinariesDir = Path.GetFullPath(Path.Combine(ModuleDirectory, "../../..", "Binaries", Platform.Name)); if (Debug) { System.Console.WriteLine("PRT Source Lib Dir: " + LibDir); System.Console.WriteLine("PRT Source Bin Dir: " + BinDir); System.Console.WriteLine("PRT Source Include Dir: " + IncludeDir); System.Console.WriteLine("Module Binaries Dir: " + ModuleBinariesDir); } Directory.CreateDirectory(ModuleBinariesDir); PublicRuntimeLibraryPaths.Add(ModuleBinariesDir); // Copy PRT core libraries if (Debug) { Console.WriteLine("Adding PRT core libraries"); } foreach (string FilePath in Directory.GetFiles(BinDir)) { string LibraryName = Path.GetFileName(FilePath); Platform.AddPrtCoreLibrary(FilePath, LibraryName, this); } // Delete unused PRT extension libraries if (Debug) { Console.WriteLine("Deleting unused PRT extension libraries"); } foreach (string FilePath in Directory.GetFiles(LibDir)) { string FileName = Path.GetFileName(FilePath); if (Path.GetExtension(FilePath) == Platform.DynamicLibExtension) { if (!Array.Exists(ExtensionLibraries, e => e == Path.GetFileName(FilePath))) { File.Delete(FilePath); } else { RuntimeDependencies.Add(FilePath); PublicDelayLoadDLLs.Add(FileName); } } } // Delete all sub directories from the extensions foreach (string DirectoryPath in Directory.GetDirectories(LibDir)) { Directory.Delete(DirectoryPath, true); } // Add include search path if (Debug) { Console.WriteLine("Adding include search path " + IncludeDir); } PublicSystemIncludePaths.Add(IncludeDir); }
public VAPlugin(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; bEnableExceptions = true; PublicIncludePaths.AddRange( new string[] { // ... add public include paths required here ... //"VALibrary/include" } ); PrivateIncludePaths.AddRange( new string[] { // ... add other private include paths required here ... "VALibrary/include" } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "Projects", "CoreUObject", "Engine", "DisplayCluster", "DisplayClusterExtensions", "InputCore", "Sockets", "Networking" //, //"VALibrary" // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { // ... add private dependencies that you statically link with here ... } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); // Path pPath = Path.Combine(ModuleDirectory, "..", "VALibrary", "lib"); PublicLibraryPaths.Add(Path.Combine(ModuleDirectory, "..", "VALibrary", "lib")); PublicRuntimeLibraryPaths.Add(Path.Combine(ModuleDirectory, "..", "VALibrary", "lib")); if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64)) { // Add the import library //PublicLibraryPaths.Add("VALibrary/lib"); //PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "x64", "Release")); PublicAdditionalLibraries.Add("VABase.lib"); PublicAdditionalLibraries.Add("VistaBase.lib"); PublicAdditionalLibraries.Add("VistaAspects.lib"); PublicAdditionalLibraries.Add("VistaInterProcComm.lib"); PublicAdditionalLibraries.Add("VANet.lib"); // Delay-load the DLL, so we can load it from the right place first PublicDelayLoadDLLs.Add("VABase.dll"); PublicDelayLoadDLLs.Add("VistaBase.dll"); PublicDelayLoadDLLs.Add("VistaAspects.dll"); PublicDelayLoadDLLs.Add("VistaInterProcComm.dll"); PublicDelayLoadDLLs.Add("VANet.dll"); } else // if (Target.Platform == UnrealTargetPlatform.Linux) { // PublicRuntimeLibraryPaths.Add(Path.Combine(ModuleDirectory, "..", "VALibrary", "lib")); // Tried PublicAdditionalLibraries("VABase.so"); // PublicAdditionalLibraries.Add("VistaBase.so"); // PublicAdditionalLibraries.Add("VistaAspects.so"); // PublicAdditionalLibraries.Add("VistaInterProcComm.so"); // PublicAdditionalLibraries.Add("VABase.so"); // PublicAdditionalLibraries.Add("VANet.so"); // PublicAdditionalLibraries.Add("VABase.so"); // PublicAdditionalLibraries.Add("VistaBase.so"); // PublicAdditionalLibraries.Add("VistaAspects.so"); // PublicAdditionalLibraries.Add("VistaInterProcComm.so"); // PublicAdditionalLibraries.Add("VANet.so"); // Path.GetFullPath(Path.Combine(ModuleDirectory, actualPath)) // run fr 3.5. 18.00 // PublicDelayLoadDLLs.Add("VABase.so"); // PublicDelayLoadDLLs.Add("VistaBase.so"); // PublicDelayLoadDLLs.Add("VistaAspects.so"); // PublicDelayLoadDLLs.Add("VistaInterProcComm.so"); // PublicDelayLoadDLLs.Add("VANet.so"); // PublicAdditionalLibraries.Add("VABase.so"); // PublicAdditionalLibraries.Add("VistaBase.so"); // PublicAdditionalLibraries.Add("VistaAspects.so"); // PublicAdditionalLibraries.Add("VistaInterProcComm.so"); // PublicAdditionalLibraries.Add("VANet.so"); // PublicAdditionalLibraries.Add("VistaBase.so"); // PublicAdditionalLibraries.Add("VistaAspects.so"); // PublicAdditionalLibraries.Add("VistaInterProcComm.so"); // PublicAdditionalLibraries.Add("VABase.so"); // PublicAdditionalLibraries.Add("VANet.so"); // from USDImporter.Build.cs (G:\Programme\UE_4.21\Engine\Plugins\Editor\USDImporter\Source\USDImporter) /* * else if (Target.Platform == UnrealTargetPlatform.Linux && Target.Architecture.StartsWith("x86_64")) * { * // link directly to runtime libs on Linux, as this also puts them into rpath * string RuntimeLibraryPath = Path.Combine(ModuleDirectory, "../../Binaries", Target.Platform.ToString(), Target.Architecture.ToString()); * PrivateRuntimeLibraryPaths.Add(RuntimeLibraryPath); * PublicAdditionalLibraries.Add(RuntimeLibraryPath + "/libUnrealUSDWrapper.so"); * * foreach (string FilePath in Directory.EnumerateFiles(RuntimeLibraryPath, "*.so*", SearchOption.AllDirectories)) * { * RuntimeDependencies.Add(FilePath); * } * } */ // PrivateRuntimeLibraryPaths.Add(RuntimeLibraryPath); string RuntimeLibraryPath = Path.Combine(ModuleDirectory, "..", "VALibrary", "lib"); PrivateRuntimeLibraryPaths.Add(RuntimeLibraryPath); PublicLibraryPaths.Add(RuntimeLibraryPath); foreach (string FilePath in Directory.EnumerateFiles(RuntimeLibraryPath, "*.so", SearchOption.AllDirectories)) { PublicAdditionalLibraries.Add(FilePath); RuntimeDependencies.Add(FilePath); } foreach (string FilePath in Directory.EnumerateFiles(RuntimeLibraryPath, "*.so.*", SearchOption.AllDirectories)) { RuntimeDependencies.Add(FilePath); } // RuntimeDependencies.Add("VistaBase.so"); // RuntimeDependencies.Add("VistaAspects.so"); // RuntimeDependencies.Add("VistaInterProcComm.so"); // RuntimeDependencies.Add("VABase.so"); // RuntimeDependencies.Add("VANet.so"); } //this is needed to register on Editor delegates, i.e., BeginPIE and EndPIE, but only in Editor builds if (Target.Type == TargetRules.TargetType.Editor) { PrivateDependencyModuleNames.AddRange( new string[] { "UnrealEd" } ); } }
void ThirdPartyCustom(ReadOnlyTargetRules Target) { PublicDefinitions.Add("V8_COMPRESS_POINTERS"); string LibraryPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty", "Library")); if (Target.Platform == UnrealTargetPlatform.Win64) { bool UseMonolith = Target.LinkType == TargetLinkType.Monolithic; string V8LibraryPath = Path.Combine(LibraryPath, "V8", "Win64"); if (UseMonolith) { PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "v8_monolith.lib")); } else { PublicRuntimeLibraryPaths.Add(V8LibraryPath); System.Action <string> AddLib = (string Name) => { string DllName = Name + ".dll"; string LibName = DllName + ".lib"; string DllFullPath = Path.Combine(V8LibraryPath, DllName); string LibFullName = Path.Combine(V8LibraryPath, LibName); PublicAdditionalLibraries.Add(LibFullName); PublicDelayLoadDLLs.Add(DllFullPath); RuntimeDependencies.Add(Path.Combine(ModuleDirectory, "../../Binaries/Win64", DllName), DllFullPath); }; AddLib("zlib"); AddLib("v8_libbase"); AddLib("v8"); AddLib("v8_libplatform"); } } else if (Target.Platform == UnrealTargetPlatform.Android) { if (Target.Version.MajorVersion == 5 || (Target.Version.MajorVersion == 4 && Target.Version.MinorVersion >= 25)) { // for armv7 string V8LibraryPath = Path.Combine(LibraryPath, "V8", "Android", "armv7a-release", "8.4.371.19"); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libwee8.a")); // for arm64 V8LibraryPath = Path.Combine(LibraryPath, "V8", "Android", "arm64-release", "8.5.210.20"); PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libv8_monolith.a")); } else if (Target.Version.MajorVersion == 4 && Target.Version.MinorVersion < 25) { // for armv7 string V8LibraryPath = Path.Combine(LibraryPath, "V8", "Android", "armv7a-release", "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-release", "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.Platform == UnrealTargetPlatform.Mac) { 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")); } string HeaderPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty", "Include")); // External headers if (Target.Platform == UnrealTargetPlatform.Android) { if (Target.Version.MajorVersion == 5 || (Target.Version.MajorVersion == 4 && Target.Version.MinorVersion >= 25)) { PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "v8", "8.5.210.20") }); } 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", "8.5.210.20") }); PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "websocketpp") }); PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "asio") }); } //if (Target.Platform == UnrealTargetPlatform.Mac) //{ // PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "ffi", "macOS") }); //} //else if (Target.Platform == UnrealTargetPlatform.IOS) //{ // PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "ffi", "iOS") }); //} }
public NDIIO(ReadOnlyTargetRules Target) : base(Target) { bEnforceIWYU = true; PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; #region Public Includes // Include the Public include paths if (Directory.Exists(Path.Combine(ModuleDirectory, "Public"))) { PublicIncludePaths.AddRange(new string[] { // ... add public include paths required here ... Path.Combine(ModuleDirectory, "Public"), }); } // Define the public dependencies PublicDependencyModuleNames.AddRange(new string[] { "Engine", "Core", "CoreUObject", "Projects" }); #endregion #region Private Includes if (Directory.Exists(Path.Combine(ModuleDirectory, "Private"))) { PrivateIncludePaths.AddRange(new string[] { // ... add other private include paths required here ... Path.Combine(ModuleDirectory, "Private") }); } PrivateDependencyModuleNames.AddRange(new string[] { "Renderer", "RenderCore", "RHI", "Slate", "SlateCore", "UMG", "ImageWrapper", "AudioMixer", "InputCore", "Media", "MediaAssets", "MediaUtils", "CinematicCamera" }); #endregion #region Editor Includes if (Target.bBuildEditor == true) { PrivateIncludePathModuleNames.AddRange(new string[] { "AssetTools", "TargetPlatform", }); PrivateDependencyModuleNames.AddRange(new string[] { "UnrealEd", "AssetTools", "MaterialUtilities" }); } #endregion #region ThirdParty Includes // Our plugin only support the Win64 platform if (Target.Platform == UnrealTargetPlatform.Win64) { // Get the environment variables for the sdk and runtime for NDI string sdk_path = Path.GetFullPath(Path.Combine(ModuleDirectory, "ThirdParty", "NDI")); string runtime_path = Environment.GetEnvironmentVariable("NDI_RUNTIME_DIR_V4"); // When building the project you must have the NDI SDK installed... // verify the sdk and runtime environment variables exist if (!string.IsNullOrEmpty(sdk_path) && !string.IsNullOrEmpty(runtime_path)) { // Retrieve the directories from the environmental paths string SDK_DIRECTORY = Path.GetFullPath(sdk_path); string LIB_DIRECTORY = Path.GetFullPath(Path.Combine(sdk_path, "Libraries/Win64")); string RUNTIME_DIRECTORY = Path.GetFullPath(runtime_path); // Determine if the 'SDK' directory exists if (Directory.Exists(Path.Combine(SDK_DIRECTORY, "Includes"))) { PublicIncludePaths.AddRange(new string[] { // ... add other private include paths required here ... Path.Combine(SDK_DIRECTORY, "Includes"), }); } // ensure that we have both the sdk and runtime directories if (Directory.Exists(LIB_DIRECTORY) && Directory.Exists(RUNTIME_DIRECTORY)) { // Add the Library Files to a collection String[] LibraryFilePaths = new string[] { Path.Combine(LIB_DIRECTORY, "Processing.NDI.Lib.x64.lib"), }; // Load the .lib files from the FilePaths collection foreach (var FilePath in LibraryFilePaths) { PublicAdditionalLibraries.Add(FilePath); } // Load the DLL from the runtime directory PublicDelayLoadDLLs.Add("Processing.NDI.Lib.x64.dll"); PublicRuntimeLibraryPaths.Add(RUNTIME_DIRECTORY); // Ensure that we define our c++ define PublicDefinitions.Add("NDI_SDK_ENABLED"); } } } #endregion }
public SpatialGDK(ReadOnlyTargetRules Target) : base(Target) { bLegacyPublicIncludePaths = false; PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; bUseUnity = BuildUtils.GetUnityModeSetting(); PrivateIncludePaths.Add("SpatialGDK/Private"); var WorkerSDKPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "Public", "WorkerSDK")); PublicIncludePaths.Add(WorkerSDKPath); // Worker SDK uses a different include format <improbable/x.h> PrivateIncludePaths.Add(WorkerSDKPath); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "EngineSettings", "Http", "InputCore", "OnlineSubsystemUtils", "Projects", "ReplicationGraph", "Sockets", "Slate", "UMG" }); if (Target.bWithPushModel) { PublicDependencyModuleNames.Add("NetCore"); } if (Target.bBuildDeveloperTools || (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test)) { PublicDependencyModuleNames.Add("GameplayDebugger"); PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=1"); } else { PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=0"); } if (Target.bBuildEditor) { PublicDependencyModuleNames.Add("UnrealEd"); PublicDependencyModuleNames.Add("SpatialGDKServices"); } if (Target.bWithPerfCounters) { PublicDependencyModuleNames.Add("PerfCounters"); } var WorkerLibraryDir = Path.Combine(ModuleDirectory, "..", "..", "Binaries", "ThirdParty", "Improbable", Target.Platform.ToString()); string LibPrefix = "libimprobable_"; string ImportLibSuffix = ".so"; string SharedLibSuffix = ".so"; bool bAddDelayLoad = false; if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { LibPrefix = "improbable_"; ImportLibSuffix = ".lib"; SharedLibSuffix = ".dll"; bAddDelayLoad = true; } else if (Target.Platform == UnrealTargetPlatform.Mac) { ImportLibSuffix = SharedLibSuffix = ".dylib"; } else if (Target.Platform == UnrealTargetPlatform.PS4) { ImportLibSuffix = "_stub.a"; SharedLibSuffix = ".prx"; bAddDelayLoad = true; } else if (Target.Platform == UnrealTargetPlatform.XboxOne) { LibPrefix = "improbable_"; ImportLibSuffix = ".lib"; SharedLibSuffix = ".dll"; // We don't set bAddDelayLoad = true here, because we get "unresolved external symbol __delayLoadHelper2". // See: https://www.fmod.org/questions/question/deploy-issue-on-xboxone-with-unrealengine-4-14/ } else if (Target.Platform == UnrealTargetPlatform.IOS) { ImportLibSuffix = SharedLibSuffix = "_static.a"; } else if (!(Target.Platform == UnrealTargetPlatform.Linux || Target.Platform == UnrealTargetPlatform.Android)) { throw new System.Exception(System.String.Format("Unsupported platform {0}", Target.Platform.ToString())); } string WorkerImportLib = System.String.Format("{0}worker{1}", LibPrefix, ImportLibSuffix); string WorkerSharedLib = System.String.Format("{0}worker{1}", LibPrefix, SharedLibSuffix); if (Target.Platform != UnrealTargetPlatform.Android) { RuntimeDependencies.Add(Path.Combine(WorkerLibraryDir, WorkerSharedLib), StagedFileType.NonUFS); if (bAddDelayLoad) { PublicDelayLoadDLLs.Add(WorkerSharedLib); } WorkerImportLib = Path.Combine(WorkerLibraryDir, WorkerImportLib); PublicRuntimeLibraryPaths.Add(WorkerLibraryDir); PublicAdditionalLibraries.Add(WorkerImportLib); } else { var WorkerLibraryPaths = new List <string> { Path.Combine(WorkerLibraryDir, "arm64-v8a"), Path.Combine(WorkerLibraryDir, "armeabi-v7a"), Path.Combine(WorkerLibraryDir, "x86_64"), }; string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath); AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "SpatialGDK_APL.xml")); PublicRuntimeLibraryPaths.AddRange(WorkerLibraryPaths); var WorkerLibraries = new List <string> { Path.Combine(WorkerLibraryDir, "arm64-v8a", WorkerSharedLib), Path.Combine(WorkerLibraryDir, "armeabi-v7a", WorkerSharedLib), Path.Combine(WorkerLibraryDir, "x86_64", WorkerSharedLib), }; PublicAdditionalLibraries.AddRange(WorkerLibraries); } }
public SpatialGDK(ReadOnlyTargetRules Target) : base(Target) { bLegacyPublicIncludePaths = false; PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; #pragma warning disable 0618 bFasterWithoutUnity = true; // Deprecated in 4.24, replace with bUseUnity = false; once we drop support for 4.23 if (Target.Version.MinorVersion == 24) // Due to a bug in 4.24, bFasterWithoutUnity is inversed, fixed in master, so should hopefully roll into the next release, remove this once it does { bFasterWithoutUnity = false; } #pragma warning restore 0618 PrivateIncludePaths.Add("SpatialGDK/Private"); var WorkerSDKPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "Public", "WorkerSDK")); PublicIncludePaths.Add(WorkerSDKPath); // Worker SDK uses a different include format <improbable/x.h> PrivateIncludePaths.Add(WorkerSDKPath); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "EngineSettings", "InputCore", "OnlineSubsystemUtils", "Projects", "ReplicationGraph", "Sockets", "Slate", "UMG" }); if (Target.bBuildDeveloperTools || (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test)) { PublicDependencyModuleNames.Add("GameplayDebugger"); } if (Target.bBuildEditor) { PublicDependencyModuleNames.Add("UnrealEd"); PublicDependencyModuleNames.Add("SpatialGDKServices"); } if (Target.bWithPerfCounters) { PublicDependencyModuleNames.Add("PerfCounters"); } var WorkerLibraryDir = Path.Combine(ModuleDirectory, "..", "..", "Binaries", "ThirdParty", "Improbable", Target.Platform.ToString()); var WorkerLibraryPaths = new List <string> { WorkerLibraryDir, }; string LibPrefix = "improbable_"; string ImportLibSuffix = ""; string SharedLibSuffix = ""; bool bAddDelayLoad = false; if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { ImportLibSuffix = ".lib"; SharedLibSuffix = ".dll"; bAddDelayLoad = true; } else if (Target.Platform == UnrealTargetPlatform.Mac) { LibPrefix = "libimprobable_"; ImportLibSuffix = SharedLibSuffix = ".dylib"; } else if (Target.Platform == UnrealTargetPlatform.Linux) { LibPrefix = "libimprobable_"; ImportLibSuffix = SharedLibSuffix = ".so"; } else if (Target.Platform == UnrealTargetPlatform.PS4) { LibPrefix = "libimprobable_"; ImportLibSuffix = "_stub.a"; SharedLibSuffix = ".prx"; bAddDelayLoad = true; } else if (Target.Platform == UnrealTargetPlatform.XboxOne) { ImportLibSuffix = ".lib"; SharedLibSuffix = ".dll"; // We don't set bAddDelayLoad = true here, because we get "unresolved external symbol __delayLoadHelper2". // See: https://www.fmod.org/questions/question/deploy-issue-on-xboxone-with-unrealengine-4-14/ } else if (Target.Platform == UnrealTargetPlatform.IOS) { LibPrefix = "libimprobable_"; ImportLibSuffix = SharedLibSuffix = "_static.a"; } else if (Target.Platform == UnrealTargetPlatform.Android) { LibPrefix = "improbable_"; WorkerLibraryPaths.AddRange(new string[] { Path.Combine(WorkerLibraryDir, "arm64-v8a"), Path.Combine(WorkerLibraryDir, "armeabi-v7a"), Path.Combine(WorkerLibraryDir, "x86_64"), }); string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath); AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "SpatialGDK_APL.xml")); } else { throw new System.Exception(System.String.Format("Unsupported platform {0}", Target.Platform.ToString())); } string WorkerImportLib = System.String.Format("{0}worker{1}", LibPrefix, ImportLibSuffix); string WorkerSharedLib = System.String.Format("{0}worker{1}", LibPrefix, SharedLibSuffix); if (Target.Platform != UnrealTargetPlatform.Android) { RuntimeDependencies.Add(Path.Combine(WorkerLibraryDir, WorkerSharedLib), StagedFileType.NonUFS); if (bAddDelayLoad) { PublicDelayLoadDLLs.Add(WorkerSharedLib); } WorkerImportLib = Path.Combine(WorkerLibraryDir, WorkerImportLib); } PublicAdditionalLibraries.Add(WorkerImportLib); PublicRuntimeLibraryPaths.Add(WorkerLibraryDir); // Detect existence of trace library, if present add preprocessor string TraceStaticLibPath = ""; string TraceDynamicLib = ""; string TraceDynamicLibPath = ""; if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { TraceStaticLibPath = Path.Combine(WorkerLibraryDir, "trace_dynamic.lib"); TraceDynamicLib = "trace_dynamic.dll"; TraceDynamicLibPath = Path.Combine(WorkerLibraryDir, TraceDynamicLib); } else if (Target.Platform == UnrealTargetPlatform.Linux) { TraceStaticLibPath = Path.Combine(WorkerLibraryDir, "libtrace_dynamic.so"); TraceDynamicLib = "libtrace_dynamic.so"; TraceDynamicLibPath = Path.Combine(WorkerLibraryDir, TraceDynamicLib); } if (File.Exists(TraceStaticLibPath) && File.Exists(TraceDynamicLibPath)) { Log.TraceInformation("Detection of trace libraries found at {0} and {1}, enabling trace functionality.", TraceStaticLibPath, TraceDynamicLibPath); PublicDefinitions.Add("TRACE_LIB_ACTIVE=1"); PublicAdditionalLibraries.Add(TraceStaticLibPath); RuntimeDependencies.Add(TraceDynamicLibPath, StagedFileType.NonUFS); if (bAddDelayLoad) { PublicDelayLoadDLLs.Add(TraceDynamicLib); } } else { Log.TraceInformation("Didn't find trace libraries at {0} and {1}, disabling trace functionality.", TraceStaticLibPath, TraceDynamicLibPath); PublicDefinitions.Add("TRACE_LIB_ACTIVE=0"); } }