public WebMMoviePlayer(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Engine",
"MoviePlayer",
"RenderCore",
"RHI",
"SlateCore",
"Slate",
"MediaUtils",
"WebMMedia",
});
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PrivateDependencyModuleNames.Add("SDL2");
PrivateIncludePaths.Add("WebMMoviePlayer/Private/Audio/Unix");
}
else
{
PrivateIncludePaths.Add("WebMMoviePlayer/Private/Audio/Null");
}
PrivateIncludePaths.Add("WebMMoviePlayer/Private/Audio");
// Some Linux architectures don't have the libs built yet
bool bHaveWebMlibs = (!Target.IsInPlatformGroup(UnrealPlatformGroup.Unix) || Target.Architecture.StartsWith("x86_64"));
PublicDefinitions.Add("WITH_WEBM_LIBS=" + (bHaveWebMlibs ? "1" : "0"));
}
public JavascriptWebSocket(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] {
"Core",
"CoreUObject",
"Engine",
"V8",
"Sockets",
"OnlineSubSystemUtils",
"Networking"
});
bool bPlatformSupportsLibWebsockets =
Target.IsInPlatformGroup(UnrealPlatformGroup.Windows) ||
Target.Platform == UnrealTargetPlatform.Android ||
Target.Platform == UnrealTargetPlatform.Mac ||
Target.IsInPlatformGroup(UnrealPlatformGroup.Unix);
if (bPlatformSupportsLibWebsockets)
{
PublicDefinitions.Add("WITH_JSWEBSOCKET=1");
HackWebSocketIncludeDir(Path.Combine(Directory.GetCurrentDirectory(), "ThirdParty", "libWebSockets", "libWebSockets"), Target);
}
else
{
PublicDefinitions.Add("WITH_JSWEBSOCKET=0");
}
}
public XMPP(ReadOnlyTargetRules Target) : base(Target)
{
PublicDefinitions.Add("XMPP_PACKAGE=1");
PrivateIncludePaths.AddRange(
new string[]
{
"Runtime/Online/XMPP/Private"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Json"
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealTargetPlatform.Win32 ||
Target.IsInPlatformGroup(UnrealPlatformGroup.Unix) ||
Target.Platform == UnrealTargetPlatform.Mac ||
Target.Platform == UnrealTargetPlatform.PS4)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "WebRTC");
PublicDefinitions.Add("WITH_XMPP_JINGLE=1");
}
else
{
PublicDefinitions.Add("WITH_XMPP_JINGLE=0");
}
if (Target.Platform == UnrealTargetPlatform.XboxOne ||
Target.Platform == UnrealTargetPlatform.Android ||
Target.Platform == UnrealTargetPlatform.IOS)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "libstrophe");
}
else
{
PublicDefinitions.Add("WITH_XMPP_STROPHE=0");
}
if (Target.Platform == UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Mac ||
Target.Platform == UnrealTargetPlatform.PS4)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenSSL");
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "libcurl");
}
}
public RHI(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.Add("Core");
PrivateDependencyModuleNames.Add("TraceLog");
PrivateDependencyModuleNames.Add("ApplicationCore");
if (Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("NullDrv");
if (Target.Type != TargetRules.TargetType.Server) // Dedicated servers should skip loading everything but NullDrv
{
// UEBuildAndroid.cs adds VulkanRHI for Android builds if it is enabled
if (Target.Platform == UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealTargetPlatform.Win32)
{
DynamicallyLoadedModuleNames.Add("D3D11RHI");
}
if (Target.Platform.IsInGroup(UnrealPlatformGroup.Windows))
{
//#todo-rco: D3D12 requires different SDK headers not compatible with WinXP
DynamicallyLoadedModuleNames.Add("D3D12RHI");
}
if ((Target.Platform == UnrealTargetPlatform.HoloLens))
{
DynamicallyLoadedModuleNames.Add("D3D11RHI");
DynamicallyLoadedModuleNames.Add("D3D12RHI");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.IsInPlatformGroup(UnrealPlatformGroup.Unix) && (Target.Architecture.StartsWith("x86_64") || Target.Architecture.StartsWith("aarch64")))) // temporary, not all archs can support Vulkan atm
{
DynamicallyLoadedModuleNames.Add("VulkanRHI");
}
if ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.IsInPlatformGroup(UnrealPlatformGroup.Linux) && Target.Type != TargetRules.TargetType.Server)) // @todo should servers on all platforms skip this?
{
DynamicallyLoadedModuleNames.Add("OpenGLDrv");
}
}
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
PrivateIncludePaths.Add("Runtime/RHI/Private");
AddEngineThirdPartyPrivateStaticDependencies(Target, "GeForceNOW");
}
public OpenGLDrv(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Runtime/OpenGLDrv/Private");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"Engine",
"RHI",
"RenderCore",
"PreLoadScreen"
}
);
PrivateIncludePathModuleNames.Add("ImageWrapper");
DynamicallyLoadedModuleNames.Add("ImageWrapper");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Linux))
{
string GLPath = Target.UEThirdPartySourceDirectory + "OpenGL/";
PublicIncludePaths.Add(GLPath);
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Linux))
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"TaskGraph"
}
);
}
if ((Target.Platform == UnrealTargetPlatform.Android) || (Target.Platform == UnrealTargetPlatform.Lumin))
{
PrivateDependencyModuleNames.Add("detex");
}
if (Target.Platform != UnrealTargetPlatform.Win32 && Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.IOS && Target.Platform != UnrealTargetPlatform.Android &&
!Target.IsInPlatformGroup(UnrealPlatformGroup.Linux) &&
Target.Platform != UnrealTargetPlatform.TVOS && Target.Platform != UnrealTargetPlatform.Lumin)
{
PrecompileForTargets = PrecompileTargetsType.None;
}
}
public libcurl(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
PublicDefinitions.Add("WITH_LIBCURL=1");
string LinuxLibCurlPath = Target.UEThirdPartySourceDirectory + "libcurl/7_48_0/";
string WinLibCurlPath = Target.UEThirdPartySourceDirectory + "libcurl/curl-7.55.1/";
string AndroidLibCurlPath = Target.UEThirdPartySourceDirectory + "libcurl/";
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
string platform = "/Linux/" + Target.Architecture;
string IncludePath = LinuxLibCurlPath + "include" + platform;
string LibraryPath = LinuxLibCurlPath + "lib" + platform;
PublicIncludePaths.Add(IncludePath);
PublicLibraryPaths.Add(LibraryPath);
PublicAdditionalLibraries.Add(LibraryPath + "/libcurl.a");
PrivateDependencyModuleNames.Add("SSL");
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
// toolchain will filter properly
PublicIncludePaths.Add(AndroidLibCurlPath + "include/Android/ARMv7");
PublicLibraryPaths.Add(AndroidLibCurlPath + "lib/Android/ARMv7");
PublicIncludePaths.Add(AndroidLibCurlPath + "include/Android/ARM64");
PublicLibraryPaths.Add(AndroidLibCurlPath + "lib/Android/ARM64");
PublicIncludePaths.Add(AndroidLibCurlPath + "include/Android/x86");
PublicLibraryPaths.Add(AndroidLibCurlPath + "lib/Android/x86");
PublicIncludePaths.Add(AndroidLibCurlPath + "include/Android/x64");
PublicLibraryPaths.Add(AndroidLibCurlPath + "lib/Android/x64");
PublicAdditionalLibraries.Add("curl");
// PublicAdditionalLibraries.Add("crypto");
// PublicAdditionalLibraries.Add("ssl");
// PublicAdditionalLibraries.Add("dl");
}
else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens)
{
PublicIncludePaths.Add(WinLibCurlPath + "include/" + Target.Platform.ToString() + "/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
PublicLibraryPaths.Add(WinLibCurlPath + "lib/" + Target.Platform.ToString() + "/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
PublicAdditionalLibraries.Add("libcurl_a.lib");
PublicDefinitions.Add("CURL_STATICLIB=1");
// Our build requires OpenSSL and zlib, so ensure thye're linked in
AddEngineThirdPartyPrivateStaticDependencies(Target, new string[]
{
"OpenSSL",
"zlib"
});
}
}
public QDesktopPlatform(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = Path.GetFullPath(Path.Combine(PrivateDirectory, "DesktopPlatformPrivate.h"));
PrivateIncludePaths.Add(PrivateDirectory);
PublicIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Public/")));
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"ApplicationCore",
"Json",
}
);
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Linux))
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"QSlateFileDialogs",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"QSlateFileDialogs",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
}
public WebMMedia(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"WebMMediaFactory",
"Core",
"Engine",
"RenderCore",
"RHI",
});
PublicDependencyModuleNames.AddRange(
new string[] {
"Media",
"MediaUtils",
"libOpus",
"UEOgg",
"Vorbis",
});
// Some Linux architectures don't have the libs built yet
bool bHaveWebMlibs = (!Target.IsInPlatformGroup(UnrealPlatformGroup.Unix) || Target.Architecture.StartsWith("x86_64"));
if (bHaveWebMlibs)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"LibVpx",
"LibWebM",
});
}
PublicDefinitions.Add("WITH_WEBM_LIBS=" + (bHaveWebMlibs ? "1" : "0"));
}
public VulkanShaderFormat(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("TargetPlatform");
// Do not link the module (as that would require the vulkan dll), only the include paths
PublicIncludePaths.Add("Runtime/VulkanRHI/Public");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"RenderCore",
"ShaderCompilerCommon",
"ShaderPreprocessor",
"RHI", // @todo platplug: This would not be needed if we could move FDataDriveShaderPlatformInfo (and ERHIFeatureLevel) into RenderCore or maybe its own module?
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "HLSLCC");
AddEngineThirdPartyPrivateStaticDependencies(Target, "GlsLang");
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Win32 &&
Target.Platform != UnrealTargetPlatform.Android &&
!Target.IsInPlatformGroup(UnrealPlatformGroup.Linux) &&
Target.Platform != UnrealTargetPlatform.Mac)
{
PrecompileForTargets = PrecompileTargetsType.None;
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
}
public DesktopPlatform(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Developer/DesktopPlatform/Private");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"ApplicationCore",
"Json",
}
);
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Linux))
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateFileDialogs",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateFileDialogs",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
}
public SDL2(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
// assume SDL to be built with extensions
PublicDefinitions.Add("SDL_WITH_EPIC_EXTENSIONS=1");
PublicIncludePaths.Add(SDL2IncPath);
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
if (Target.Configuration == UnrealTargetConfiguration.Debug)
{
// Debug version should be built with -fPIC and usable in all targets
PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "Linux", Target.Architecture, "libSDL2_fPIC_Debug.a"));
}
else if (Target.LinkType == TargetLinkType.Monolithic)
{
PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "Linux", Target.Architecture, "libSDL2.a"));
}
else
{
PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "Linux", Target.Architecture, "libSDL2_fPIC.a"));
}
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "Win64", "SDL2.lib"));
RuntimeDependencies.Add(Path.Combine("$(EngineDir)", "Binaries", "ThirdParty", "SDL2", "Win64/SDL2.dll"));
PublicDelayLoadDLLs.Add("SDL2.dll");
}
}
public WebSockets(ReadOnlyTargetRules Target) : base(Target)
{
PublicDefinitions.Add("WEBSOCKETS_PACKAGE=1");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"HTTP"
}
);
bool bPlatformSupportsLibWebsockets =
Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealTargetPlatform.Android ||
Target.Platform == UnrealTargetPlatform.Mac ||
Target.IsInPlatformGroup(UnrealPlatformGroup.Unix) ||
Target.Platform == UnrealTargetPlatform.IOS ||
Target.Platform == UnrealTargetPlatform.PS4 ||
Target.Platform == UnrealTargetPlatform.Switch;
bool bUsePlatformSSL = Target.Platform == UnrealTargetPlatform.Switch;
bool bPlatformSupportsXboxWebsockets = Target.Platform == UnrealTargetPlatform.XboxOne;
bool bShouldUseModule =
bPlatformSupportsLibWebsockets ||
bPlatformSupportsXboxWebsockets;
if (bShouldUseModule)
{
PublicDefinitions.Add("WITH_WEBSOCKETS=1");
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Online/WebSockets/Private",
}
);
if (bPlatformSupportsLibWebsockets)
{
PublicDefinitions.Add("WITH_LIBWEBSOCKETS=1");
if (bUsePlatformSSL)
{
PrivateDefinitions.Add("WITH_SSL=0");
AddEngineThirdPartyPrivateStaticDependencies(Target, "libWebSockets");
}
else
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenSSL", "libWebSockets", "zlib");
PrivateDependencyModuleNames.Add("SSL");
}
}
}
else
{
PublicDefinitions.Add("WITH_WEBSOCKETS=0");
}
}
public MikkTSpace(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string MikkTSpacePath = Target.UEThirdPartySourceDirectory + "MikkTSpace/";
PublicIncludePaths.Add(MikkTSpacePath + "inc/");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.Add(MikkTSpacePath + "lib/Win64/VS2017/MikkTSpace.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicAdditionalLibraries.Add(MikkTSpacePath + "lib/Win32/VS2017/MikkTSpace.lib");
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PublicAdditionalLibraries.Add(MikkTSpacePath + "/lib/Linux/" + Target.Architecture + "/libMikkTSpace.a");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(MikkTSpacePath + "/lib/Mac/libMikkTSpace.a");
}
}
public MikkTSpace(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
bool bWithMikkTSpace = true;
string MikkTSpacePath = Target.UEThirdPartySourceDirectory + "MikkTSpace/";
PublicIncludePaths.Add(MikkTSpacePath + "inc/");
if (Target.Platform.IsInGroup(UnrealPlatformGroup.Windows) && Target.Platform != UnrealTargetPlatform.Win32)
{
PublicAdditionalLibraries.Add(MikkTSpacePath + "lib/Win64/VS2017/MikkTSpace.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicAdditionalLibraries.Add(MikkTSpacePath + "lib/Win32/VS2017/MikkTSpace.lib");
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PublicAdditionalLibraries.Add(MikkTSpacePath + "/lib/Linux/" + Target.Architecture + "/libMikkTSpace.a");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(MikkTSpacePath + "/lib/Mac/libMikkTSpace.a");
}
else
{
bWithMikkTSpace = false;
}
PublicDefinitions.Add(bWithMikkTSpace ? "WITH_MIKKTSPACE=1" : "WITH_MIKKTSPACE=0");
}
public GameHAL(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore" });
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public"));
PrivateDependencyModuleNames.AddRange(new string[] { });
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
PublicDependencyModuleNames.Add("Launch");
string ModulePath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
Console.Write(ModulePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(ModulePath, "Private/AndroidUPL.xml"));
}
// Uncomment if you are using Slate UI
//PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore","UMG"});
// 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
}
private void HackWebSocketIncludeDir(String WebsocketPath, ReadOnlyTargetRules Target)
{
string PlatformSubdir = Target.Platform.ToString();
bool bHasZlib = false;
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Windows))
{
PlatformSubdir = Path.Combine(PlatformSubdir, "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
bHasZlib = true;
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PlatformSubdir = Path.Combine(PlatformSubdir, Target.Architecture);
}
PrivateDependencyModuleNames.Add("libWebSockets");
if (bHasZlib)
{
PrivateDependencyModuleNames.Add("zlib");
}
PrivateIncludePaths.Add(Path.Combine(WebsocketPath, "include"));
PrivateIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir));
}
public MCPP(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
PublicIncludePaths.Add(Target.UEThirdPartySourceDirectory + "MCPP/mcpp-2.7.2/inc");
string LibPath = Target.UEThirdPartySourceDirectory + "MCPP/mcpp-2.7.2/lib/";
if (Target.Platform == UnrealTargetPlatform.Win64)
{
LibPath += ("Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
PublicLibraryPaths.Add(LibPath);
PublicAdditionalLibraries.Add("mcpp_64.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
LibPath += ("Win32/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
PublicLibraryPaths.Add(LibPath);
PublicAdditionalLibraries.Add("mcpp.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(LibPath + "Mac/libmcpp.a");
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
LibPath += "Linux/" + Target.Architecture;
PublicAdditionalLibraries.Add(LibPath + "/libmcpp.a");
}
}
public AudioFormatOgg(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("TargetPlatform");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"Engine"
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.HoloLens) ||
(Target.Platform == UnrealTargetPlatform.Mac) ||
Target.IsInPlatformGroup(UnrealPlatformGroup.Linux)
)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
}
public LibWebM(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string RootPath = ModuleDirectory;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string LibPath = RootPath + "/lib/Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
PublicLibraryPaths.Add(LibPath);
string LibFileName = "libwebm.lib";
PublicAdditionalLibraries.Add(LibFileName);
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PublicAdditionalLibraries.Add(RootPath + "/lib/Unix/" + Target.Architecture + ((Target.LinkType == TargetLinkType.Monolithic) ? "/libwebm" : "/libwebm_fPIC") + ".a");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(RootPath + "/lib/Mac" + ((Target.LinkType == TargetLinkType.Monolithic) ? "/libwebm" : "/libwebm_fPIC") + ".a");
}
string IncludePath = RootPath + "/include";
PublicIncludePaths.Add(IncludePath);
}
public MeshBuilder(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"RHI",
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"MeshDescription",
"RenderCore",
"MeshDescriptionOperations",
"MeshReductionInterface",
"RawMesh",
"MeshUtilitiesCommon",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "nvTriStrip");
AddEngineThirdPartyPrivateStaticDependencies(Target, "ForsythTriOptimizer");
AddEngineThirdPartyPrivateStaticDependencies(Target, "nvTessLib");
AddEngineThirdPartyPrivateStaticDependencies(Target, "QuadricMeshReduction");
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PublicAdditionalLibraries.Add("stdc++"); // can be fixed, see UE-70769
}
}
public WebMMediaFactory(ReadOnlyTargetRules Target) : base(Target)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"MediaAssets",
});
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Media",
});
PrivateIncludePaths.AddRange(
new string[] {
"WebMMediaFactory/Private",
});
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
});
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
DynamicallyLoadedModuleNames.Add("WebMMedia");
}
}
public TestPAL(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.Add("Runtime/Launch/Public");
PrivateIncludePaths.Add("Runtime/Launch/Private"); // For LaunchEngineLoop.cpp include
PrivateIncludePaths.Add("Programs/TestPAL/Private");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"ApplicationCore",
"Projects",
}
);
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Windows) || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"DirectoryWatcher"
}
);
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"SDL2",
}
);
}
}
public libWebSockets(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string WebsocketPath = Path.Combine(Target.UEThirdPartySourceDirectory, "libWebSockets", "libwebsockets");
string PlatformSubdir = Target.Platform.ToString();
bool bUseDebugBuild = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT);
string ConfigurationSubdir = bUseDebugBuild ? "Debug" : "Release";
switch (Target.Platform)
{
case UnrealTargetPlatform.HTML5:
return;
case UnrealTargetPlatform.Win64:
case UnrealTargetPlatform.Win32:
PlatformSubdir = Path.Combine(PlatformSubdir, "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
PublicAdditionalLibraries.Add("websockets_static.lib");
break;
case UnrealTargetPlatform.Mac:
case UnrealTargetPlatform.IOS:
PublicAdditionalShadowFiles.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), ConfigurationSubdir, "libwebsockets.a"));
PublicAdditionalLibraries.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), ConfigurationSubdir, "libwebsockets.a"));
break;
case UnrealTargetPlatform.PS4:
PublicAdditionalLibraries.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), ConfigurationSubdir, "libwebsockets.a"));
break;
case UnrealTargetPlatform.Android:
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir, "ARMv7"));
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), "ARMv7", ConfigurationSubdir));
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir, "ARM64"));
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), "ARM64", ConfigurationSubdir));
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir, "x86"));
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), "x86", ConfigurationSubdir));
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir, "x64"));
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), "x64", ConfigurationSubdir));
PublicAdditionalLibraries.Add("websockets");
break;
default:
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PlatformSubdir = "Linux/" + Target.Architecture;
PublicAdditionalLibraries.Add(Path.Combine(WebsocketPath, "lib", PlatformSubdir, ConfigurationSubdir, "libwebsockets.a"));
break;
}
return;
}
if (Target.Platform != UnrealTargetPlatform.Android)
{
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", PlatformSubdir, ConfigurationSubdir));
}
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir));
PublicDependencyModuleNames.Add("OpenSSL");
}
public AudioFormatOpus(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("TargetPlatform");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"Engine"
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.HoloLens) ||
Target.IsInPlatformGroup(UnrealPlatformGroup.Linux) ||
(Target.Platform == UnrealTargetPlatform.Mac) ||
(Target.Platform == UnrealTargetPlatform.XboxOne)
)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"libOpus"
);
}
PublicDefinitions.Add("WITH_OGGVORBIS=1");
}
public AudioMixer(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("TargetPlatform");
PublicIncludePathModuleNames.Add("TargetPlatform");
PublicIncludePathModuleNames.Add("Engine");
PrivateIncludePaths.AddRange(
new string[]
{
"Runtime/AudioMixer/Private",
}
);
PublicIncludePaths.Add("Runtime/AudioMixer/Private");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"NonRealtimeAudioRenderer",
"AudioMixerCore",
"SignalProcessing"
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus",
"UELibSampleRate"
);
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Windows))
{
string PlatformName = Target.Platform == UnrealTargetPlatform.Win32 ? "Win32" : "Win64";
string LibSndFilePath = Target.UEThirdPartyBinariesDirectory + "libsndfile/";
LibSndFilePath += PlatformName;
PublicAdditionalLibraries.Add(LibSndFilePath + "/libsndfile-1.lib");
PublicDelayLoadDLLs.Add("libsndfile-1.dll");
PublicIncludePathModuleNames.Add("UELibSampleRate");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/libsndfile/" + PlatformName + "/libsndfile-1.dll");
}
}
public TextureShareCore(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[]
{
"TextureShareCore/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core"
}
);
if (Target.bShouldCompileAsDLL)
{
PublicDefinitions.Add("TEXTURESHARECORE_RHI=0");
}
else
{
PublicDefinitions.Add("TEXTURESHARECORE_RHI=1");
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Engine",
"RHI",
"RenderCore",
"TextureShareD3D11",
"TextureShareD3D12",
});
}
string TextureShareLibPlatformName = Target.Platform.ToString();
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens)
{
PublicDefinitions.Add("TEXTURESHARELIB_PLATFORM_WINDOWS=1");
TextureShareLibPlatformName = "Windows";
// Configure supported render devices for windows platform:
PublicDefinitions.Add("TEXTURESHARELIB_USE_D3D11=1");
PublicDefinitions.Add("TEXTURESHARELIB_USE_D3D12=1");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicDefinitions.Add("TEXTURESHARELIB_PLATFORM_MAC=1");
TextureShareLibPlatformName = "Mac";
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PublicDefinitions.Add("TEXTURESHARELIB_PLATFORM_LINUX=1");
TextureShareLibPlatformName = "Linux";
}
PublicDefinitions.Add("TEXTURESHARELIB_PLATFORM=" + TextureShareLibPlatformName);
}
public OpenAL(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string version = Target.IsInPlatformGroup(UnrealPlatformGroup.Unix) ? "1.18.1" : "1.15.1";
string OpenALPath = Target.UEThirdPartySourceDirectory + "OpenAL/" + version + "/";
PublicIncludePaths.Add(OpenALPath + "include");
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
// link against runtime path since this avoids hardcoing an RPATH
string OpenALRuntimePath = Path.Combine(Target.UEThirdPartyBinariesDirectory, "OpenAL/Linux", Target.Architecture, "libopenal.so");
PublicAdditionalLibraries.Add(OpenALRuntimePath);
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/OpenAL/Linux/" + Target.Architecture + "/libopenal.so.1");
}
}
public PhysXVehicleLib(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
// Libraries and DLLs for windows platform
string LibDir = Path.Combine(PhysXLibDir, Target.Platform.ToString());
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens ||
Target.Platform == UnrealTargetPlatform.Win32)
{
PublicAdditionalLibraries.Add(Path.Combine(LibDir, "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(), String.Format("PhysX3Vehicle{0}_{1}.lib", LibrarySuffix, Target.WindowsPlatform.GetArchitectureSubpath())));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(Path.Combine(LibDir, String.Format("libPhysX3Vehicle{0}.a", LibrarySuffix)));
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
PublicAdditionalLibraries.Add(Path.Combine(PhysXLibDir, "Android", "ARM64", String.Format("libPhysX3Vehicle{0}.a", LibrarySuffix)));
PublicAdditionalLibraries.Add(Path.Combine(PhysXLibDir, "Android", "ARMv7", String.Format("libPhysX3Vehicle{0}.a", LibrarySuffix)));
PublicAdditionalLibraries.Add(Path.Combine(PhysXLibDir, "Android", "x64", String.Format("libPhysX3Vehicle{0}.a", LibrarySuffix)));
PublicAdditionalLibraries.Add(Path.Combine(PhysXLibDir, "Android", "x86", String.Format("libPhysX3Vehicle{0}.a", LibrarySuffix)));
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PublicAdditionalLibraries.Add(Path.Combine(PhysXLibDir, "Linux", Target.Architecture, String.Format("libPhysX3Vehicle{0}.a", LibrarySuffix)));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalLibraries.Add(Path.Combine(LibDir, String.Format("libPhysX3Vehicle{0}.a", LibrarySuffix)));
}
else if (Target.Platform == UnrealTargetPlatform.TVOS)
{
PublicAdditionalLibraries.Add(Path.Combine(LibDir, String.Format("libPhysX3Vehicle{0}.a", LibrarySuffix)));
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PublicAdditionalLibraries.Add(Path.Combine(LibDir, "VS2015", String.Format("PhysX3Vehicle{0}.lib", LibrarySuffix)));
}
else if (Target.Platform == UnrealTargetPlatform.Switch)
{
PublicAdditionalLibraries.Add(Path.Combine(LibDir, String.Format("libPhysX3Vehicle{0}.a", LibrarySuffix)));
}
}
public nvTextureTools(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string nvttPath = Target.UEThirdPartySourceDirectory + "nvTextureTools/nvTextureTools-2.0.8/";
string nvttLibPath = nvttPath + "lib";
PublicIncludePaths.Add(nvttPath + "src/src");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
nvttLibPath += ("/Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
PublicLibraryPaths.Add(nvttLibPath);
PublicAdditionalLibraries.Add("nvtt_64.lib");
PublicDelayLoadDLLs.Add("nvtt_64.dll");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/nvTextureTools/Win64/nvtt_64.dll");
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
nvttLibPath += ("/Win32/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
PublicLibraryPaths.Add(nvttLibPath);
PublicAdditionalLibraries.Add("nvtt.lib");
PublicDelayLoadDLLs.Add("nvtt.dll");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/nvTextureTools/Win32/nvtt.dll");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(nvttPath + "lib/Mac/libnvcore.dylib");
PublicAdditionalLibraries.Add(nvttPath + "lib/Mac/libnvimage.dylib");
PublicAdditionalLibraries.Add(nvttPath + "lib/Mac/libnvmath.dylib");
PublicAdditionalLibraries.Add(nvttPath + "lib/Mac/libnvtt.dylib");
PublicAdditionalLibraries.Add(nvttPath + "lib/Mac/libsquish.a");
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
string NvBinariesDir = Target.UEThirdPartyBinariesDirectory + "nvTextureTools/Linux/" + Target.Architecture;
PrivateRuntimeLibraryPaths.Add(NvBinariesDir);
PublicAdditionalLibraries.Add(NvBinariesDir + "/libnvcore.so");
PublicAdditionalLibraries.Add(NvBinariesDir + "/libnvimage.so");
PublicAdditionalLibraries.Add(NvBinariesDir + "/libnvmath.so");
PublicAdditionalLibraries.Add(NvBinariesDir + "/libnvtt.so");
RuntimeDependencies.Add(NvBinariesDir + "/libnvcore.so");
RuntimeDependencies.Add(NvBinariesDir + "/libnvimage.so");
RuntimeDependencies.Add(NvBinariesDir + "/libnvmath.so");
RuntimeDependencies.Add(NvBinariesDir + "/libnvtt.so");
}
}
public libstrophe(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
PrivateDefinitions.Add("XML_STATIC");
PublicSystemIncludePaths.Add(Path.Combine(ModuleDirectory, StropheVersion));
if (bRequireExpat)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Expat");
}
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Use reflection to allow type not to exist if console code is not present
string ToolchainName = "VS";
System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool");
if (XboxOnePlatformType != null)
{
System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
ToolchainName += VersionName.ToString();
}
string LibraryPath = Path.Combine(StrophePackagePath, "XboxOne", ToolchainName, ConfigName);
PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, "strophe.lib"));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, "Android", ConfigName, "arm64", "libstrophe.a"));
PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, "Android", ConfigName, "armv7", "libstrophe.a"));
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, Target.Platform.ToString(), ConfigName, "libstrophe.a"));
PublicSystemLibraries.Add("resolv");
}
else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
string LibrayPath = Path.Combine(StrophePackagePath, Target.Platform.ToString(), "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(), ConfigName) + "/";
PublicAdditionalLibraries.Add(LibrayPath + "strophe.lib");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
string LibrayPath = Path.Combine(StrophePackagePath, Target.Platform.ToString(), ConfigName) + "/";
PublicSystemLibraries.Add(LibrayPath + "libstrophe.a");
}
else if (Target.Platform == UnrealTargetPlatform.Switch)
{
PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, Target.Platform.ToString(), ConfigName, "libstrophe.a"));
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, "Linux", Target.Architecture.ToString(), ConfigName, "libstrophe" + ((Target.LinkType != TargetLinkType.Monolithic) ? "_fPIC" : "") + ".a"));
PublicSystemLibraries.Add("resolv");
}
}