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