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