public FFmpeg(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32) { string PlatformDir = Target.Platform.ToString(); string IncPath = Path.Combine(ModuleDirectory, "include"); { DirectoryInfo root = new DirectoryInfo(IncPath); DirectoryInfo[] IncludeDirs = root.GetDirectories(); for (int i = 0; i < IncludeDirs.Length; i++) { PublicSystemIncludePaths.Add(IncludeDirs[i].FullName); } } PublicSystemIncludePaths.Add(IncPath); string LibPath = Path.Combine(ModuleDirectory, "lib", PlatformDir); string dllPath = Path.Combine(ModuleDirectory, "dll", PlatformDir); { DirectoryInfo root = new DirectoryInfo(LibPath); FileInfo[] files = root.GetFiles(); for (Int32 i = 0; i < files.Length; i++) { FileInfo ItemFile = files[i]; PublicAdditionalLibraries.Add(Path.Combine(LibPath, ItemFile.Name)); } } { DirectoryInfo root = new DirectoryInfo(dllPath); FileInfo[] files = root.GetFiles(); for (Int32 i = 0; i < files.Length; i++) { FileInfo ItemFile = files[i]; PublicDelayLoadDLLs.Add(ItemFile.Name); CopyDllAndLibToProjectBinaries(Path.Combine(dllPath, ItemFile.Name), Target); } } } }
public bool LoadOeip(ReadOnlyTargetRules Target) { string OeipPath = Path.Combine(ThirdPartyPath, "Oeip"); string libPath = Path.Combine(OeipPath, "lib"); string dllPath = Path.Combine(OeipPath, "bin"); PublicIncludePaths.AddRange(new string[] { Path.Combine(OeipPath, "include") }); PublicLibraryPaths.Add(libPath); PublicAdditionalLibraries.Add("oeip.lib"); PublicAdditionalLibraries.Add("oeip-live.lib"); //需要加载的dll,不加的话,需把相应dll拷贝到工程的Binaries,否则编辑器到75%就因加载不了dll crash. PublicDelayLoadDLLs.Add("oeip.dll"); PublicDelayLoadDLLs.Add("oeip-live.dll"); foreach (string path in Directory.GetFiles(dllPath)) { RuntimeDependencies.Add(path); } return(true); }
public WindowsMoviePlayer(ReadOnlyTargetRules Target) : base(Target) { PublicIncludePaths.AddRange( new string[] { } ); PrivateIncludePaths.AddRange( new string[] { "Runtime/WindowsMoviePlayer/Private", } ); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", // @todo Mac: for some reason CoreUObject and Engine are needed to link in debug on Mac "Engine", // @todo Mac: for some reason CoreUObject and Engine are needed to link in debug on Mac "InputCore", "MoviePlayer", "RenderCore", "RHI", "SlateCore", "Slate" } ); DynamicallyLoadedModuleNames.AddRange( new string[] { } ); if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32) { PublicDelayLoadDLLs.Add("shlwapi.dll"); PublicDelayLoadDLLs.Add("mf.dll"); PublicDelayLoadDLLs.Add("mfplat.dll"); PublicDelayLoadDLLs.Add("mfplay.dll"); PublicDelayLoadDLLs.Add("mfuuid.dll"); } }
public bool LoadSphinxBase(ReadOnlyTargetRules Target) { bool isLibrarySupported = false; if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { isLibrarySupported = true; string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64" : "x86"; string LibrariesPath = Path.Combine(ThirdPartyPath, "SphinxBase", "Libraries"); LibrariesPath = Path.Combine(LibrariesPath, PlatformString); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "SphinxBase.lib")); // TODO: Copy dlls to alternative package directory, to be loaded through a manual process PublicDelayLoadDLLs.Add("SphinxBase.dll"); RuntimeDependencies.Add("PocketSphinx.dll"); } if (Target.Platform == UnrealTargetPlatform.Mac) { isLibrarySupported = true; string LibraryPath = Path.Combine(ThirdPartyPath, "SphinxBase", "Libraries"); LibraryPath = Path.Combine(LibraryPath, "osx"); PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, "libopenal.dylib")); PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, "libsphinxad.a")); PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, "libsphinxbase.a")); } if (isLibrarySupported) { // Include path PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "SphinxBase", "Includes")); PrivateIncludePaths.Add(Path.Combine(ThirdPartyPath, "SphinxBase", "Includes")); } PublicDefinitions.Add(string.Format("WITH_SPHINX_BASE_BINDING={0}", isLibrarySupported ? 1 : 0)); return(isLibrarySupported); }
public discordrpcLibrary(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; if (Target.Platform == UnrealTargetPlatform.Win64) { // Add the import library PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Include")); PublicLibraryPaths.Add(Path.Combine(ModuleDirectory, "x64", "Release")); PublicAdditionalLibraries.Add("discord-rpc.lib"); // Delay-load the DLL, so we can load it from the right place first PublicDelayLoadDLLs.Add("discord-rpc.dll"); } else if (Target.Platform == UnrealTargetPlatform.Mac) { PublicDelayLoadDLLs.Add(Path.Combine(ModuleDirectory, "Mac", "Release", "libdiscord-rpc.dylib")); } }
public IntelISPCTexComp(TargetInfo Target) { Type = ModuleType.External; string LibraryPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelISPCTexComp/ispc_texcomp/"; string BinaryFolder = UEBuildConfiguration.UEThirdPartyBinariesDirectory + "IntelISPCTexComp/"; PublicIncludePaths.Add(LibraryPath); //NOTE: If you change bUseDebugBuild, you must also change FTextureFormatIntelISPCTexCompModule.GetTextureFormat() to load the corresponding DLL bool bUseDebugBuild = false; if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { string platformName = (Target.Platform == UnrealTargetPlatform.Win64) ? "Win64" : "Win32"; string configName = bUseDebugBuild ? "Debug" : "Release"; string LibFolder = LibraryPath + "lib/" + platformName + "-" + configName; string DLLFolder = BinaryFolder + platformName + "-" + configName; string DLLFilePath = DLLFolder + "/ispc_texcomp.dll"; PublicLibraryPaths.Add(LibFolder); PublicLibraryPaths.Add(DLLFolder); PublicAdditionalLibraries.Add("ispc_texcomp.lib"); PublicDelayLoadDLLs.Add("ispc_texcomp.dll"); RuntimeDependencies.Add(new RuntimeDependency(DLLFilePath)); } else if (Target.Platform == UnrealTargetPlatform.Mac) { string BinaryLibraryFolder = BinaryFolder + "Mac64-Release"; string LibraryFilePath = BinaryLibraryFolder + "/libispc_texcomp.dylib"; PublicAdditionalLibraries.Add(LibraryFilePath); PublicDelayLoadDLLs.Add(LibraryFilePath); PublicAdditionalShadowFiles.Add(LibraryFilePath); RuntimeDependencies.Add(new RuntimeDependency(LibraryFilePath)); } else if (Target.Platform == UnrealTargetPlatform.Linux && Target.Architecture.StartsWith("x86_64")) { string BinaryLibraryFolder = BinaryFolder + "Linux64-Release"; string LibraryFilePath = BinaryLibraryFolder + "/libispc_texcomp.so"; PublicAdditionalLibraries.Add(LibraryFilePath); PublicDelayLoadDLLs.Add("libispc_texcomp.so"); RuntimeDependencies.Add(new RuntimeDependency(LibraryFilePath)); } }
public bool LoadOpenCV(ReadOnlyTargetRules Target) { // Start OpenCV linking here bool islibrarySupported = false; // Create OpenCV Path string OpenCVPath = Path.Combine(ThirdPartyPath, "OpenCV"); //Get Library Path string LibPath = ""; // bool isdebug = Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildActuallyUseDebugCRT; if (Target.Platform == UnrealTargetPlatform.Win64) { LibPath = Path.Combine(OpenCVPath, "Libraries", "Win64"); islibrarySupported = true; } else { string Err = string.Format("{0} dedicated server is made to depend on {1}. We want to aboid this, please correct module dependencies.", Target.Platform.ToString(), this.ToString()); System.Console.WriteLine(Err); } if (islibrarySupported) { // Add Include Path PublicIncludePaths.AddRange(new string[] { Path.Combine(OpenCVPath, "Includes") }); // Add Library Path PublicLibraryPaths.Add(LibPath); // Add Static Libraries PublicAdditionalLibraries.Add("opencv_world345.lib"); // Add Dynamic Libraries PublicDelayLoadDLLs.Add("opencv_world345.dll"); PublicDelayLoadDLLs.Add("opencv_ffmpeg345_64.dll"); } PublicDefinitions.Add(string.Format("WITH_OPENCV_BINDING={0}", islibrarySupported ? 1 : 0)); return(islibrarySupported); }
public OnlineSubsystemEpicLibrary(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; // Add header files to include path PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Include")); string BaseDirectory = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty", "OnlineSubsystemEpicLibrary")); PublicIncludePaths.Add(Path.Combine(BaseDirectory, "Include")); // Handle libraries if (Target.Platform == UnrealTargetPlatform.Win64) { // Add the import library PublicAdditionalLibraries.Add(Path.Combine(BaseDirectory, "Lib", "EOSSDK-Win64-Shipping.lib")); // Dlls RuntimeDependencies.Add(Path.Combine(BaseDirectory, "Bin", "EOSSDK-Win64-Shipping.dll")); PublicDelayLoadDLLs.Add("EOSSDK-Win64-Shipping.dll"); } else if (Target.Platform == UnrealTargetPlatform.Win32) { // Add the import library PublicAdditionalLibraries.Add(Path.Combine(BaseDirectory, "Lib", "EOSSDK-Win32-Shipping.lib")); // Dlls RuntimeDependencies.Add(Path.Combine(BaseDirectory, "Bin", "EOSSDK-Win32-Shipping.dll")); PublicDelayLoadDLLs.Add("EOSSDK-Win32-Shipping.dll"); } else if (Target.Platform == UnrealTargetPlatform.Linux) { // Add the import library PublicAdditionalLibraries.Add(Path.Combine(BaseDirectory, "Bin", "libEOSSDK-Linux-Shipping.so")); RuntimeDependencies.Add(Path.Combine(BaseDirectory, "Bin", "libEOSSDK-Linux-Shipping.so")); } else if (Target.Platform == UnrealTargetPlatform.Mac) { // Add the import library PublicAdditionalLibraries.Add(Path.Combine(BaseDirectory, "Bin", "libEOSSDK-Mac-Shipping.dylib")); RuntimeDependencies.Add(Path.Combine(BaseDirectory, "Bin", "libEOSSDK-Mac-Shipping.dylib")); } }
public VLC_PlayerLibrary(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; if (Target.Platform == UnrealTargetPlatform.Win64) { // Add the import library PublicLibraryPaths.Add(Path.Combine(ModuleDirectory, "x64", "Release")); //PublicAdditionalLibraries.Add("ExampleLibrary.lib"); PublicAdditionalLibraries.Add(Path.Combine(ModuleDirectory, "x64", "Release", "libvlc.lib")); PublicAdditionalLibraries.Add(Path.Combine(ModuleDirectory, "x64", "Release", "libvlccore.lib")); //PublicAdditionalLibraries.Add("libvlc.lib"); //PublicAdditionalLibraries.Add("libvlccore.lib"); // Delay-load the DLL, so we can load it from the right place first //PublicDelayLoadDLLs.Add("ExampleLibrary.dll"); //PublicDelayLoadDLLs.Add("libvlc.dll"); //PublicDelayLoadDLLs.Add("libvlccore.dll"); PublicDelayLoadDLLs.Add(Path.Combine(ModuleDirectory, "x64", "Release", "libvlc.dll")); PublicDelayLoadDLLs.Add(Path.Combine(ModuleDirectory, "x64", "Release", "libvlccore.dll")); RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(ModuleDirectory, "x64", "Release", "libvlc.dll"))); RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(ModuleDirectory, "x64", "Release", "libvlccore.dll"))); // add VLC plug-ins string PluginDirectory = Path.Combine(ModuleDirectory, "x64", "Release", "plugins"); if (Directory.Exists(PluginDirectory)) { foreach (string Plugin in Directory.EnumerateFiles(PluginDirectory, "*.*", SearchOption.AllDirectories)) { RuntimeDependencies.Add(Path.Combine(PluginDirectory, Plugin)); } } } else if (Target.Platform == UnrealTargetPlatform.Mac) { //PublicDelayLoadDLLs.Add(Path.Combine(ModuleDirectory, "Mac", "Release", "libExampleLibrary.dylib")); } }
public QualcommTextureConverter(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Mac) || (Target.Platform == UnrealTargetPlatform.Linux && Target.Architecture.StartsWith("x86_64"))) { PublicIncludePaths.Add(Target.UEThirdPartySourceDirectory + "Qualcomm/TextureConverter/Include"); string LibraryPath = Target.UEThirdPartySourceDirectory + "Qualcomm/TextureConverter/Lib/"; string LibraryName = "TextureConverter"; string LibraryExtension = ".lib"; if (Target.Platform == UnrealTargetPlatform.Win64) { LibraryPath += "vs" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName() + "/x64"; PublicDelayLoadDLLs.Add("TextureConverter.dll"); RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Qualcomm/Win64/TextureConverter.dll"); } else if (Target.Platform == UnrealTargetPlatform.Mac) { LibraryPath += "osx64"; LibraryExtension = ".dylib"; LibraryName = LibraryPath + "/lib" + LibraryName; } else if (Target.Platform == UnrealTargetPlatform.Linux) { LibraryPath += "linux_x64"; // FIXME: change to proper architecture LibraryExtension = ".so"; LibraryName = LibraryPath + "/lib" + LibraryName; PrivateRuntimeLibraryPaths.Add("$(EngineDir)/Binaries/ThirdParty/Qualcomm/Linux"); RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Qualcomm/Linux/libTextureConverter.so"); } PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryName + LibraryExtension); } }
public WmfMedia(TargetInfo Target) { DynamicallyLoadedModuleNames.AddRange( new string[] { "Media", "Settings", } ); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "RenderCore", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "Media", "Settings", } ); PrivateIncludePaths.AddRange( new string[] { "WmfMedia/Private", "WmfMedia/Private/Player", "WmfMedia/Private/Tracks", "WmfMedia/Private/Wmf", } ); if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { PublicDelayLoadDLLs.Add("shlwapi.dll"); PublicDelayLoadDLLs.Add("mf.dll"); PublicDelayLoadDLLs.Add("mfplat.dll"); PublicDelayLoadDLLs.Add("mfplay.dll"); PublicDelayLoadDLLs.Add("mfuuid.dll"); } }
public OpenColorIOLib(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; bool bIsPlatformAdded = false; if (Target.bBuildEditor == true) { if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32) { string PlatformDir = Target.Platform.ToString(); string IncPath = Path.Combine(ModuleDirectory, "distribution", "include"); PublicSystemIncludePaths.Add(IncPath); string LibPath = Path.Combine(ModuleDirectory, "distribution", "lib", PlatformDir); PublicLibraryPaths.Add(LibPath); string BinaryPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "../../../Binaries/ThirdParty", PlatformDir)); string LibName = "OpenColorIO"; PublicAdditionalLibraries.Add(LibName + ".lib"); string DLLName = LibName + ".dll"; PublicDelayLoadDLLs.Add(DLLName); RuntimeDependencies.Add(Path.Combine(BinaryPath, DLLName)); PublicDefinitions.Add("WITH_OCIO=1"); PublicDefinitions.Add("OCIO_PLATFORM_PATH=Binaries/ThirdParty/" + PlatformDir); PublicDefinitions.Add("OCIO_DLL_NAME=" + DLLName); //The header file OpenColorIOABI.h that is generated depends on this definition. PublicDefinitions.Add("__GNUC__=0"); bIsPlatformAdded = true; } } if (bIsPlatformAdded == false) { PublicDefinitions.Add("WITH_OCIO=0"); } }
public MeMedia(TargetInfo Target) { DynamicallyLoadedModuleNames.AddRange( new string[] { "Media", } ); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "RenderCore", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "Media", } ); PrivateIncludePaths.AddRange( new string[] { "MeMedia/Private", "MeMedia/Private/Player", } ); if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { PublicDelayLoadDLLs.Add("d3d11.dll"); PublicDelayLoadDLLs.Add("mf.dll"); PublicDelayLoadDLLs.Add("mfplat.dll"); PublicDelayLoadDLLs.Add("uuid.dll"); } if (Target.Platform == UnrealTargetPlatform.XboxOne) { PublicAdditionalLibraries.Add("mfplat.lib"); PublicAdditionalLibraries.Add("mfuuid.lib"); } }
public bool LoadPython(ReadOnlyTargetRules Target) { // Start OpenCV linking here! bool isLibrarySupported = false; // Create OpenCV Path string PythonPath = Environment.GetEnvironmentVariable("userprofile") + "\\AppData\\Local\\Programs\\Python\\Python36"; // Get Library Path string LibPath = ""; bool isdebug = Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT; if (Target.Platform == UnrealTargetPlatform.Win64) { LibPath = Path.Combine(PythonPath, "libs"); isLibrarySupported = true; } else { string Err = string.Format("{0} dedicated server is made to depend on {1}. We want to avoid this, please correct module dependencies.", Target.Platform.ToString(), this.ToString()); System.Console.WriteLine(Err); } if (isLibrarySupported) { //Add Include path PublicIncludePaths.AddRange(new string[] { Path.Combine(PythonPath, "include") }); // Add Library Path PublicLibraryPaths.Add(LibPath); //Add Static Libraries PublicAdditionalLibraries.Add("python36.lib"); //Add Dynamic Libraries PublicDelayLoadDLLs.Add("python36.dll"); } Definitions.Add(string.Format("WITH_PYTHON_BINDING={0}", isLibrarySupported ? 1 : 0)); return(isLibrarySupported); }
public TopDown1(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "NavigationSystem", "AIModule", "Json", "JsonUtilities", "Http" }); // копируем sqlite3.dll в папку Binary RuntimeDependencies.Add("$(BinaryOutputDir)/sqlite3.dll", Path.Combine(ModuleDirectory, "sqlite", "bin", "sqlite3.dll")); // добавляем билиотеку PublicAdditionalLibraries.Add(Path.Combine(ModuleDirectory, "sqlite", "bin", "sqlite3.lib")); // задержка на загрузку бибиотеки PublicDelayLoadDLLs.Add("sqlite3.dll"); }
public MixedRealityInteropLibrary(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; string ThirdPartyPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "../ThirdParty")); if (Target.Platform == UnrealTargetPlatform.Win32) { PublicLibraryPaths.Add(Path.Combine(ThirdPartyPath, "Lib", "x86")); } else if (Target.Platform == UnrealTargetPlatform.Win64) { PublicLibraryPaths.Add(Path.Combine(ThirdPartyPath, "Lib", "x64")); } PublicAdditionalLibraries.Add("MixedRealityInterop.lib"); // Delay-load the DLL, so we can load it from the right place first PublicDelayLoadDLLs.Add("MixedRealityInterop.dll"); RuntimeDependencies.Add(PluginDirectory + "/Binaries/ThirdParty/MixedRealityInteropLibrary/" + Target.Platform.ToString() + "/MixedRealityInterop.dll"); }
public DatasmithCADWorker(ReadOnlyTargetRules Target) : base(Target) { PublicIncludePaths.Add("Runtime/Launch/Public"); PrivateIncludePaths.Add("Runtime/Launch/Private"); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "Projects", "ApplicationCore", "Sockets", "DatasmithDispatcher", "CADInterfaces", "CADTools", } ); PublicDelayLoadDLLs.Add("kernel_io.dll"); }
public YAMLUE4(ReadOnlyTargetRules Target) : base(Target) { PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private")); PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public")); PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine" }); if (Target.Platform != UnrealTargetPlatform.Win64) { throw new System.Exception("This plugin is only available for Win64 right now."); } PrivateIncludePaths.Add(Path.Combine(yamlcppPath, "include/")); addLibrary("Win64", "yaml-cpp.lib"); PublicDelayLoadDLLs.Add("yaml-cpp.dll"); addDependency("Win64", "yaml-cpp.dll"); bEnableExceptions = true; }
public void AddImageProcessingLibrary(ReadOnlyTargetRules Target) { PublicIncludePaths.Add(Path.Combine(ThirdPartyDirectory, @"RadeonProImageProcessingSDK/include")); if (Target.Platform == UnrealTargetPlatform.Win64) { PublicLibraryPaths.Add(Path.Combine(ThirdPartyDirectory, @"RadeonProImageProcessingSDK/Windows")); PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyDirectory, @"RadeonProImageProcessingSDK/Windows/RadeonImageFilters.lib")); PublicDelayLoadDLLs.Add("RadeonImageFilters.dll"); } else if (Target.Platform == UnrealTargetPlatform.Linux) { PublicLibraryPaths.Add(Path.Combine(ThirdPartyDirectory, @"RadeonProImageProcessingSDK/Ubuntu18")); PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyDirectory, @"RadeonProImageProcessingSDK/Ubuntu18/libRadeonImageFilters.so")); } else { Console.WriteLine("warning: ImageProcessingLibrary doesn't support Platform '{0}'", Target.Platform); } }
public libPhonon(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; string LibraryPath = Target.UEThirdPartySourceDirectory + "libPhonon/phonon_api/"; string BinaryPath = "$(EngineDir)/Binaries/ThirdParty/Phonon/"; PublicIncludePaths.Add(LibraryPath + "include"); if (Target.Platform == UnrealTargetPlatform.Win64) { PublicLibraryPaths.Add(LibraryPath + "/lib/Win64"); PublicAdditionalLibraries.Add("phonon.lib"); string DllName = "phonon.dll"; PublicDelayLoadDLLs.Add(DllName); BinaryPath += "Win64/"; RuntimeDependencies.Add(new RuntimeDependency(BinaryPath + DllName)); } else if (Target.Platform == UnrealTargetPlatform.Win32) { PublicLibraryPaths.Add(LibraryPath + "/lib/Win32"); PublicAdditionalLibraries.Add("phonon.lib"); string DllName = "phonon.dll"; PublicDelayLoadDLLs.Add(DllName); BinaryPath += "Win32/"; RuntimeDependencies.Add(new RuntimeDependency(BinaryPath + DllName)); } else if (Target.Platform == UnrealTargetPlatform.Android) { PublicLibraryPaths.Add(LibraryPath + "/lib/Android"); PublicAdditionalLibraries.Add("phonon"); } }
public SDL2(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; string SDL2Path = UEBuildConfiguration.UEThirdPartySourceDirectory + "SDL2/SDL-gui-backend/"; string SDL2LibPath = SDL2Path + "lib/"; // assume SDL to be built with extensions Definitions.Add("SDL_WITH_EPIC_EXTENSIONS=1"); if (Target.Platform == UnrealTargetPlatform.Linux) { PublicIncludePaths.Add(SDL2Path + "include"); if (Target.Configuration == UnrealTargetConfiguration.Debug) { // Debug version should be built with -fPIC and usable in all targets PublicAdditionalLibraries.Add(SDL2LibPath + "Linux/" + Target.Architecture + "/libSDL2_fPIC_Debug.a"); } else if (Target.LinkType == TargetLinkType.Monolithic) { PublicAdditionalLibraries.Add(SDL2LibPath + "Linux/" + Target.Architecture + "/libSDL2.a"); } else { PublicAdditionalLibraries.Add(SDL2LibPath + "Linux/" + Target.Architecture + "/libSDL2_fPIC.a"); } } else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32") { PublicIncludePaths.Add(SDL2Path + "include"); SDL2LibPath += "Win32/"; PublicAdditionalLibraries.Add(SDL2LibPath + "SDL2.lib"); PublicDelayLoadDLLs.Add("SDL2.dll"); } else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32") { PublicIncludePaths.Add(UEBuildConfiguration.UEThirdPartySourceDirectory + "SDL2/HTML5/SDL2-master/include/"); SDL2LibPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "SDL2/HTML5/SDL2-master/libs/"; PublicAdditionalLibraries.Add(SDL2LibPath + "/libSDL2.a"); } }
public OpenXR(ReadOnlyTargetRules Target) : base(Target) { /** Mark the current version of the OpenXR SDK */ string OpenXRVersion = "1_0"; Type = ModuleType.External; string RootPath = Target.UEThirdPartySourceDirectory + "OpenXR"; string LoaderPath = RootPath + "/loader"; PublicSystemIncludePaths.Add(RootPath + "/include"); if (Target.Platform == UnrealTargetPlatform.Win32) { PublicAdditionalLibraries.Add(LoaderPath + "/win32/" + String.Format("openxr_loader-{0}.lib", OpenXRVersion)); PublicDelayLoadDLLs.Add(String.Format("openxr_loader-{0}.dll", OpenXRVersion)); RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/OpenXR/win32/" + String.Format("openxr_loader-{0}.dll", OpenXRVersion)); } else if (Target.Platform == UnrealTargetPlatform.Win64) { PublicAdditionalLibraries.Add(LoaderPath + "/win64/" + String.Format("openxr_loader-{0}.lib", OpenXRVersion)); PublicDelayLoadDLLs.Add(String.Format("openxr_loader-{0}.dll", OpenXRVersion)); RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/OpenXR/win64/" + String.Format("openxr_loader-{0}.dll", OpenXRVersion)); } else if (Target.Platform == UnrealTargetPlatform.HoloLens && Target.WindowsPlatform.Architecture == WindowsArchitecture.x64) { PublicAdditionalLibraries.Add(LoaderPath + "/hololens/x64/openxr_loader.lib"); PublicDelayLoadDLLs.Add("openxr_loader.dll"); RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/OpenXR/hololens/x64/openxr_loader.dll"); } else if (Target.Platform == UnrealTargetPlatform.HoloLens && Target.WindowsPlatform.Architecture == WindowsArchitecture.ARM64) { PublicAdditionalLibraries.Add(LoaderPath + "/hololens/arm64/openxr_loader.lib"); PublicDelayLoadDLLs.Add("openxr_loader.dll"); RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/OpenXR/hololens/arm64/openxr_loader.dll"); } }
public CognitoIdentity(ReadOnlyTargetRules Target) : base(Target) { PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private")); PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public")); PublicDependencyModuleNames.AddRange(new string[] { "Engine", "Core", "CoreUObject", "InputCore", "Projects" }); // This is required to fix a warning for Unreal Engine 4.21 and later PrivatePCHHeaderFile = "Private/CognitoIdentityPrivatePCH.h"; bEnforceIWYU = true; 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 CognitoLibFile = System.IO.Path.Combine(ThirdPartyPath, "aws-cpp-sdk-cognito-identity.lib"); if (File.Exists(CognitoLibFile)) { PublicAdditionalLibraries.Add(CognitoLibFile); } else { throw new BuildException("aws-cpp-sdk-cognito-identity.lib not found. Expected in this location: " + CognitoLibFile); } string CognitoDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-cpp-sdk-cognito-identity.dll"); if (File.Exists(CognitoDLLFile)) { PublicDelayLoadDLLs.Add("aws-cpp-sdk-cognito-identity.dll"); RuntimeDependencies.Add(CognitoDLLFile); } else { throw new BuildException("aws-cpp-sdk-cognito-identity.dll not found. Expected in this location: " + CognitoDLLFile); } } }
public bool LoadLib(ReadOnlyTargetRules Target) { bool isLibrarySupported = false; if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { isLibrarySupported = true; string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "Win64" : "Win32"; // lib PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, PlatformString, "UE4x360ce", "UE4x360ce.lib")); PublicAdditionalLibraries.Add("atls.lib"); // Add dll PublicDelayLoadDLLs.Add("UE4x360ce.dll"); RuntimeDependencies.Add(Path.Combine(BinariesPath, PlatformString, "UE4x360ce", "UE4x360ce.dll")); } return(isLibrarySupported); }
public OpenXR(ReadOnlyTargetRules Target) : base(Target) { /** Mark the current version of the OpenXR SDK */ string OpenXRVersion = "0_90"; Type = ModuleType.External; string RootPath = Target.UEThirdPartySourceDirectory + "OpenXR"; string LoaderPath = RootPath + "/loader"; PublicSystemIncludePaths.Add(RootPath + "/include"); if (Target.Platform == UnrealTargetPlatform.Win64) { PublicLibraryPaths.Add(LoaderPath + "/win64"); PublicAdditionalLibraries.Add(String.Format("openxr_loader-{0}.lib", OpenXRVersion)); PublicDelayLoadDLLs.Add(String.Format("openxr_loader-{0}.dll", OpenXRVersion)); RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/OpenXR/win64/" + String.Format("openxr_loader-{0}.dll", OpenXRVersion)); } }
public GIMUE(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" }); PrivateDependencyModuleNames.AddRange(new string[] { }); PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include")); PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "lib", "Mylib.lib")); PublicDelayLoadDLLs.Add("Mylib.dll"); RuntimeDependencies.Add(new RuntimeDependency(ThirdPartyPath + "bin" + "Mylib.dll")); // Uncomment if you are using Slate UI // PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" }); // Uncomment if you are using online features // PrivateDependencyModuleNames.Add("OnlineSubsystem"); // To include OnlineSubsystemSteam, add it to the plugins section in your uproject file with the Enabled attribute set to true }
public LeapUnrealLibrary(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; if (Target.Platform == UnrealTargetPlatform.Win64) { // Add the import library PublicAdditionalLibraries.Add(Path.Combine(ModuleDirectory, "x64", "Release", "ExampleLibrary.lib")); // Delay-load the DLL, so we can load it from the right place first PublicDelayLoadDLLs.Add("ExampleLibrary.dll"); // Ensure that the DLL is staged along with the executable RuntimeDependencies.Add("$(PluginDir)/Binaries/ThirdParty/LeapUnrealLibrary/Win64/ExampleLibrary.dll"); } else if (Target.Platform == UnrealTargetPlatform.Mac) { PublicDelayLoadDLLs.Add(Path.Combine(ModuleDirectory, "Mac", "Release", "libExampleLibrary.dylib")); RuntimeDependencies.Add("$(PluginDir)/Source/ThirdParty/LeapUnrealLibrary/Mac/Release/libExampleLibrary.dylib"); } }
public LibOVRAudio(ReadOnlyTargetRules Target) : base(Target) { /** Mark the current version of the Oculus SDK */ Type = ModuleType.External; string OculusThirdPartyDirectory = Target.UEThirdPartySourceDirectory + "Oculus/LibOVRAudio/LibOVRAudio"; if (Target.Platform == UnrealTargetPlatform.Win64) { PublicIncludePaths.Add(OculusThirdPartyDirectory + "/include"); string LibraryPath = OculusThirdPartyDirectory + "/lib/win64"; string LibraryName = "ovraudio64"; PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryName + ".lib"); PublicDelayLoadDLLs.Add("ovraudio64.dll"); RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Oculus/Audio/Win64/ovraudio64.dll"); } }
public bool LoadLib(ReadOnlyTargetRules Target) { bool isLibrarySupported = false; if ((Target.Platform == UnrealTargetPlatform.Win64)) { isLibrarySupported = true; string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "Win64" : "Win32"; string TensorflowLibPlatformPath = Path.Combine(ThirdPartyPath, "Tensorflow/Lib", PlatformString); string TensorflowLibPath = Path.GetFullPath(Path.Combine(TensorflowLibPlatformPath, "tensorflow.lib")); string TensorflowDLLPath = Path.GetFullPath(Path.Combine(TensorflowLibPlatformPath, "tensorflow.dll")); PublicAdditionalLibraries.Add(TensorflowLibPath); PublicDelayLoadDLLs.Add(TensorflowDLLPath); RuntimeDependencies.Add(TensorflowDLLPath); CopyToProjectBinaries(TensorflowDLLPath, Target); } return(isLibrarySupported); }
public XAudio2_9(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; string XAudio2_9Dir = Target.UEThirdPartySourceDirectory + "Windows/XAudio2_9"; PublicSystemIncludePaths.Add(XAudio2_9Dir + "/Include"); if (Target.Platform.IsInGroup(UnrealPlatformGroup.Windows) && Target.Platform != UnrealTargetPlatform.Win32) { PublicDelayLoadDLLs.Add("XAudio2_9redist.dll"); PublicAdditionalLibraries.Add(XAudio2_9Dir + "/Lib/x64/xaudio2_9redist.lib"); RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Windows/XAudio2_9/x64/xaudio2_9redist.dll"); } else if (Target.Platform == UnrealTargetPlatform.Win32) { PublicDelayLoadDLLs.Add("XAudio2_9redist.dll"); PublicAdditionalLibraries.Add(XAudio2_9Dir + "/Lib/x86/xaudio2_9redist.lib"); RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Windows/XAudio2_9/x86/xaudio2_9redist.dll"); } }