public XAudio2(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("TargetPlatform");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
// VS2015 updated some of the CRT definitions but not all of the Windows SDK has been updated to match.
// Microsoft provides this shim library to enable building with VS2015 until they fix everything up.
//@todo: remove when no longer neeeded (no other code changes should be necessary).
if (Target.WindowsPlatform.bNeedsLegacyStdioDefinitionsLib)
{
PublicAdditionalLibraries.Add("legacy_stdio_definitions.lib");
}
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PrivateDependencyModuleNames.Add("XMA2");
}
AddEngineThirdPartyPrivateStaticDependencies(Target,
"DX11Audio",
"UEOgg",
"Vorbis",
"VorbisFile"
);
PublicDefinitions.Add("WITH_OGGVORBIS=1");
}
public ShaderFormatOpenGL(TargetInfo Target)
{
PrivateIncludePathModuleNames.Add("TargetPlatform");
PrivateIncludePathModuleNames.Add("OpenGLDrv");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"ShaderCore",
"ShaderCompilerCommon",
"ShaderPreprocessor"
}
);
AddThirdPartyPrivateStaticDependencies(Target,
"OpenGL",
"HLSLCC"
);
if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
}
public NetworkFile(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("DerivedDataCache");
PrivateDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Sockets" });
PublicIncludePaths.Add("Runtime/CoreUObject/Public/Interfaces");
PublicIncludePaths.Add("Runtime/CoreUObject/Public/UObject");
PublicIncludePaths.Add("Runtime/CoreUObject/Public");
if (!UEBuildConfiguration.bBuildRequiresCookedData)
{
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"DerivedDataCache",
}
);
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
Definitions.Add("ENABLE_HTTP_FOR_NF=1");
if (Target.Architecture == "-win32")
{
PrivateDependencyModuleNames.Add("HTML5Win32");
}
else
{
PrivateDependencyModuleNames.Add("HTML5JS");
}
}
else
{
Definitions.Add("ENABLE_HTTP_FOR_NF=0");
}
}
public ALAudio(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("TargetPlatform");
PrivateDependencyModuleNames.AddRange(new string[]
{
"Core",
"CoreUObject",
"Engine",
});
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenAL");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"OpenAL",
"UEOgg",
"Vorbis",
"VorbisFile"
);
if (Target.Platform != UnrealTargetPlatform.HTML5)
{
PrecompileForTargets = PrecompileTargetsType.None;
}
}
public PIEPreviewDeviceProfileSelector(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("Engine");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"RHI",
"Json",
"JsonUtilities",
"MaterialShaderQualitySettings",
"Slate",
"SlateCore"
}
);
}
public Spatialization(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
OptimizeCode = CodeOptimization.Never;
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"SignalProcessing"
}
);
PrivateIncludePathModuleNames.Add("TargetPlatform");
}
public IOSAudio(ReadOnlyTargetRules Target) : base(Target)
{
BinariesSubFolder = "IOS";
PrivateIncludePathModuleNames.Add("TargetPlatform");
PublicIncludePaths.AddRange(new string[]
{
});
PrivateDependencyModuleNames.AddRange(new string[]
{
"Core",
"CoreUObject",
"Engine",
});
PublicFrameworks.AddRange(new string[]
{
"AudioToolbox",
"CoreAudio",
"AVFoundation"
});
}
public Android_PVRTCTargetPlatform(ReadOnlyTargetRules Target) : base(Target)
{
BinariesSubFolder = "Android";
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"TargetPlatform",
"DesktopPlatform",
"AndroidDeviceDetection",
}
);
PublicIncludePaths.AddRange(
new string[]
{
"Runtime/Core/Public/Android"
}
);
if (Target.bCompileAgainstEngine)
{
PrivateDependencyModuleNames.Add("Engine");
PrivateIncludePathModuleNames.Add("TextureCompressor"); //@todo android: AndroidTargetPlatform.Build
}
PublicDefinitions.Add("WITH_OGGVORBIS=1");
PrivateIncludePaths.AddRange(
new string[]
{
"Developer/Android/AndroidTargetPlatform/Private",
}
);
}
public ViewportSnapping(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("UnrealEd");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
// "RenderCore",
// "RHI",
"Slate",
"UnrealEd"
}
);
// DynamicallyLoadedModuleNames.AddRange(
// new string[] {
// "MainFrame",
// "WorkspaceMenuStructure",
// "PropertyEditor"
// }
// );
}
public HotReload(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Analytics",
"DirectoryWatcher",
"DesktopPlatform",
"Projects"
}
);
if (Target.bCompileAgainstEngine)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Engine",
"UnrealEd",
}
);
}
if (Target.bWithLiveCoding)
{
PrivateIncludePathModuleNames.Add("LiveCoding");
}
}
public Landscape(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Engine/Private", // for Engine/Private/Collision/PhysXCollision.h
"Runtime/Landscape/Private"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"DerivedDataCache",
"Foliage",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"Engine",
"RenderCore",
"RHI",
"ShaderCore",
"Renderer",
"Foliage",
}
);
SetupModulePhysXAPEXSupport(Target);
if (Target.bCompilePhysX && Target.bBuildEditor)
{
DynamicallyLoadedModuleNames.Add("PhysXCooking");
}
if (Target.bBuildDeveloperTools && Target.Type != TargetType.Server)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"RawMesh"
}
);
}
if (Target.bBuildEditor == true)
{
// TODO: Remove all landscape editing code from the Landscape module!!!
PrivateIncludePathModuleNames.Add("LandscapeEditor");
PrivateDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"MaterialUtilities",
"SlateCore",
"Slate",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"MaterialUtilities",
}
);
}
}
public Core(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/CorePrivatePCH.h";
SharedPCHHeaderFile = "Public/CoreSharedPCH.h";
PrivateDependencyModuleNames.Add("BuildSettings");
PublicDependencyModuleNames.Add("TraceLog");
PublicIncludePaths.Add("Runtime/TraceLog/Public");
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Core/Private",
"Runtime/Core/Private/Misc",
"Runtime/Core/Private/Internationalization",
"Runtime/Core/Private/Internationalization/Cultures",
"Runtime/Engine/Public",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"DerivedDataCache",
"InputDevice",
"Analytics",
"RHI"
}
);
if (Target.bBuildEditor == true)
{
DynamicallyLoadedModuleNames.Add("SourceCodeAccess");
PrivateIncludePathModuleNames.Add("DirectoryWatcher");
DynamicallyLoadedModuleNames.Add("DirectoryWatcher");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"IntelVTune"
);
if (Target.Platform == UnrealTargetPlatform.Win64 && Target.WindowsPlatform.bUseBundledDbgHelp)
{
PublicDelayLoadDLLs.Add("DBGHELP.DLL");
PrivateDefinitions.Add("USE_BUNDLED_DBGHELP=1");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/DbgHelp/dbghelp.dll");
}
else
{
PrivateDefinitions.Add("USE_BUNDLED_DBGHELP=0");
}
}
else if ((Target.Platform == UnrealTargetPlatform.HoloLens))
{
PublicIncludePaths.Add("Runtime/Core/Public/HoloLens");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"XInput"
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"zlib",
"PLCrashReporter",
"rd_route"
);
PublicFrameworks.AddRange(new string[] { "Cocoa", "Carbon", "IOKit", "Security" });
if (Target.bBuildEditor == true)
{
PublicAdditionalLibraries.Add("/System/Library/PrivateFrameworks/MultitouchSupport.framework/Versions/Current/MultitouchSupport");
}
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib"
);
PublicFrameworks.AddRange(new string[] { "UIKit", "Foundation", "AudioToolbox", "AVFoundation", "GameKit", "StoreKit", "CoreVideo", "CoreMedia", "CoreGraphics", "GameController", "SystemConfiguration", "DeviceCheck", "UserNotifications" });
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.AddRange(new string[] { "CoreMotion", "AdSupport", "WebKit" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"PLCrashReporter"
);
}
PrivateIncludePathModuleNames.Add("ApplicationCore");
bool bSupportAdvertising = Target.Platform == UnrealTargetPlatform.IOS;
if (bSupportAdvertising)
{
PublicFrameworks.AddRange(new string[] { "iAD" });
}
// export Core symbols for embedded Dlls
ModuleSymbolVisibility = ModuleRules.SymbolVisibility.VisibileForDll;
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"cxademangle",
"zlib"
);
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib",
"jemalloc"
);
// Core uses dlopen()
PublicSystemLibraries.Add("dl");
}
if (Target.bCompileICU == true)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "ICU");
}
PublicDefinitions.Add("UE_ENABLE_ICU=" + (Target.bCompileICU ? "1" : "0")); // Enable/disable (=1/=0) ICU usage in the codebase. NOTE: This flag is for use while integrating ICU and will be removed afterward.
// If we're compiling with the engine, then add Core's engine dependencies
if (Target.bCompileAgainstEngine == true)
{
if (!Target.bBuildRequiresCookedData)
{
DynamicallyLoadedModuleNames.AddRange(new string[] { "DerivedDataCache" });
}
}
// On Windows platform, VSPerfExternalProfiler.cpp needs access to "VSPerf.h". This header is included with Visual Studio, but it's not in a standard include path.
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
var VisualStudioVersionNumber = "11.0";
var SubFolderName = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64/PerfSDK" : "PerfSDK";
string PerfIncludeDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), String.Format("Microsoft Visual Studio {0}/Team Tools/Performance Tools/{1}", VisualStudioVersionNumber, SubFolderName));
if (File.Exists(Path.Combine(PerfIncludeDirectory, "VSPerf.h")))
{
PrivateIncludePaths.Add(PerfIncludeDirectory);
PublicDefinitions.Add("WITH_VS_PERF_PROFILER=1");
}
else
{
PublicDefinitions.Add("WITH_VS_PERF_PROFILER=0");
}
}
if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
PublicDefinitions.Add("WITH_VS_PERF_PROFILER=0");
}
WhitelistRestrictedFolders.Add("Private/NoRedist");
if (Target.Platform == UnrealTargetPlatform.XboxOne ||
(Target.bWithDirectXMath && (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)))
{
PublicDefinitions.Add("WITH_DIRECTXMATH=1");
}
else
{
PublicDefinitions.Add("WITH_DIRECTXMATH=0");
}
// Set a macro to allow FApp::GetBuildTargetType() to detect client targts
if (Target.Type == TargetRules.TargetType.Client)
{
PrivateDefinitions.Add("IS_CLIENT_TARGET=1");
}
else
{
PrivateDefinitions.Add("IS_CLIENT_TARGET=0");
}
// Decide if validating memory allocator (aka MallocStomp) can be used on the current platform.
// Run-time validation must be enabled through '-stompmalloc' command line argument.
bool bWithMallocStomp = false;
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
if (Target.Platform == UnrealTargetPlatform.Mac ||
Target.Platform == UnrealTargetPlatform.Linux ||
Target.Platform == UnrealTargetPlatform.LinuxAArch64 ||
Target.Platform == UnrealTargetPlatform.Win64)
// Target.Platform == UnrealTargetPlatform.Win32: // 32-bit windows can technically be supported, but will likely run out of virtual memory space quickly
// Target.Platform == UnrealTargetPlatform.XboxOne: // XboxOne could be supported, as it's similar enough to Win64
{
bWithMallocStomp = true;
}
}
PublicDefinitions.Add("WITH_MALLOC_STOMP=" + (bWithMallocStomp ? "1" : "0"));
PrivateDefinitions.Add("PLATFORM_COMPILER_OPTIMIZATION_LTCG=" + (Target.bAllowLTCG ? "1" : "0"));
PrivateDefinitions.Add("PLATFORM_COMPILER_OPTIMIZATION_PG=" + (Target.bPGOOptimize ? "1" : "0"));
PrivateDefinitions.Add("PLATFORM_COMPILER_OPTIMIZATION_PG_PROFILING=" + (Target.bPGOProfile ? "1" : "0"));
}
public AudioMixer(TargetInfo Target)
{
OptimizeCode = CodeOptimization.Always;
//OptimizeCode = CodeOptimization.Never;
PrivateIncludePathModuleNames.Add("TargetPlatform");
PrivateIncludePaths.AddRange(
new string[]
{
"Runtime/AudioMixer/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"libOpus"
);
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
}
public Engine(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/EnginePrivatePCH.h";
SharedPCHHeaderFile = "Public/EngineSharedPCH.h";
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "NetworkReplayStreaming", "AudioMixer" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"ImageWrapper",
"HeadMountedDisplay",
"MRMesh",
"Advertising",
"NetworkReplayStreaming",
"MovieSceneCapture",
"AutomationWorker",
"MovieSceneCapture",
"DesktopPlatform",
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
}
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"MessagingCommon",
"RenderCore",
"RHI",
"ShaderCore",
"UtilityShaders",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"GameplayTags",
"AIModule",
"DatabaseSupport",
"PacketHandler",
"HardwareSurvey",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Sockets",
"Landscape",
"UMG",
"Projects",
"MaterialShaderQualitySettings",
"CinematicCamera",
"Analytics",
"AnalyticsET"
}
);
if (Target.bUseXGEController &&
Target.Type == TargetType.Editor &&
(Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32))
{
PrivateDependencyModuleNames.Add("XGEController");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.Add("Localization");
DynamicallyLoadedModuleNames.Add("Localization");
}
// to prevent "causes WARNING: Non-editor build cannot depend on non-redistributable modules."
if (Target.Type == TargetType.Editor)
{
// for now we depend on this
PrivateDependencyModuleNames.Add("RawMesh");
}
bool bVariadicTemplatesSupported = true;
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Use reflection to allow type not to exist if console code is not present
System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool");
if (XboxOnePlatformType != null)
{
System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
if (VersionName.ToString().Equals("2012"))
{
bVariadicTemplatesSupported = false;
}
}
AddEngineThirdPartyPrivateStaticDependencies(Target,
"libOpus"
);
}
if (bVariadicTemplatesSupported)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
if (Target.Type == TargetType.Editor)
{
// these modules require variadic templates
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
}
}
CircularlyReferencedDependentModules.Add("GameplayTags");
CircularlyReferencedDependentModules.Add("AIModule");
CircularlyReferencedDependentModules.Add("Landscape");
CircularlyReferencedDependentModules.Add("UMG");
CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings");
CircularlyReferencedDependentModules.Add("CinematicCamera");
// The AnimGraphRuntime module is not needed by Engine proper, but it is loaded in LaunchEngineLoop.cpp,
// and needs to be listed in an always-included module in order to be compiled into standalone games
DynamicallyLoadedModuleNames.Add("AnimGraphRuntime");
// So does Geometry Cache
DynamicallyLoadedModuleNames.Add("GeometryCache");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneCapture",
"MovieSceneTracks",
"HeadMountedDisplay",
"MRMesh",
"StreamingPauseRendering",
}
);
if (Target.Type != TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
if (Target.Type == TargetType.Server || Target.Type == TargetType.Editor)
{
PrivateDependencyModuleNames.Add("PerfCounters");
}
if (Target.bBuildDeveloperTools)
{
// Add "BlankModule" so that it gets compiled as an example and will be maintained and tested. This can be removed
// at any time if needed. The module isn't actually loaded by the engine so there is no runtime cost.
DynamicallyLoadedModuleNames.Add("BlankModule");
if (Target.Type != TargetType.Server)
{
PrivateIncludePathModuleNames.Add("MeshUtilities");
DynamicallyLoadedModuleNames.Add("MeshUtilities");
PrivateDependencyModuleNames.AddRange(
new string[] {
"ImageCore",
"RawMesh"
}
);
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test && Target.Type != TargetType.Server)
{
PrivateDependencyModuleNames.Add("CollisionAnalyzer");
CircularlyReferencedDependentModules.Add("CollisionAnalyzer");
PrivateDependencyModuleNames.Add("LogVisualizer");
CircularlyReferencedDependentModules.Add("LogVisualizer");
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WindowsTargetPlatform",
"WindowsNoEditorTargetPlatform",
"WindowsServerTargetPlatform",
"WindowsClientTargetPlatform",
"AllDesktopTargetPlatform",
"WindowsPlatformEditor",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform",
"AllDesktopTargetPlatform",
"MacPlatformEditor",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"LinuxClientTargetPlatform",
"AllDesktopTargetPlatform",
"LinuxPlatformEditor",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"Advertising"
}
);
if (Target.Type != TargetType.Server)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ImageWrapper"
}
);
}
WhitelistRestrictedFolders.Add("Private/NotForLicensees");
if (!Target.bBuildRequiresCookedData && Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"DerivedDataCache",
"TargetPlatform",
"DesktopPlatform"
}
);
}
if (Target.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
); // @todo api: Only public because of WITH_EDITOR and UNREALED_API
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
);
PrivateIncludePathModuleNames.Add("TextureCompressor");
PrivateIncludePaths.Add("Developer/TextureCompressor/Public");
PrivateIncludePathModuleNames.Add("HierarchicalLODUtilities");
DynamicallyLoadedModuleNames.Add("HierarchicalLODUtilities");
DynamicallyLoadedModuleNames.Add("AnimationModifiers");
PrivateIncludePathModuleNames.Add("AssetTools");
DynamicallyLoadedModuleNames.Add("AssetTools");
PrivateIncludePathModuleNames.Add("PIEPreviewDeviceProfileSelector");
}
SetupModulePhysXAPEXSupport(Target);
if (Target.bCompilePhysX && (Target.bBuildEditor || Target.bCompileAPEX))
{
DynamicallyLoadedModuleNames.Add("PhysXCooking");
}
// Engine public headers need to know about some types (enums etc.)
PublicIncludePathModuleNames.Add("ClothingSystemRuntimeInterface");
PublicDependencyModuleNames.Add("ClothingSystemRuntimeInterface");
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.Add("ClothingSystemEditorInterface");
PrivateIncludePathModuleNames.Add("ClothingSystemEditorInterface");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
// Head Mounted Display support
// PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
// DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
// TODO test this for HTML5 !
//AddEngineThirdPartyPrivateStaticDependencies(Target,
// "UEOgg",
// "Vorbis",
// "VorbisFile"
// );
PublicDependencyModuleNames.Add("HTML5JS");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"libOpus"
);
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
if (Target.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
PublicDefinitions.Add("WITH_RECAST=1");
}
else
{
// Because we test WITH_RECAST in public Engine header files, we need to make sure that modules
// that import this also have this definition set appropriately. Recast is a private dependency
// module, so it's definitions won't propagate to modules that import Engine.
PublicDefinitions.Add("WITH_RECAST=0");
}
/*
* ConfigHierarchy Ini = ConfigCache.ReadHierarchy(ConfigHierarchyType.Engine, System.IO.DirectoryReference.FromFile(Target.ProjectFile), Target.Platform);
* bool bLocalVectorFieldOnly = false;
* Ini.GetBool("/Script/Engine.RendererSettings", "bGPUParticlesLocalVFOnly", out bLocalVectorFieldOnly);
* if (bLocalVectorFieldOnly)
* {
* PublicDefinitions.Add("GPUPARTICLE_LOCAL_VF_ONLY=1");
* }
* else
* {
* PublicDefinitions.Add("GPUPARTICLE_LOCAL_VF_ONLY=0");
* }
*/
PublicDefinitions.Add("GPUPARTICLE_LOCAL_VF_ONLY=0");
// Add a reference to the stats HTML files referenced by UEngine::DumpFPSChartToHTML. Previously staged by CopyBuildToStagingDirectory.
if (Target.bBuildEditor || Target.Configuration != UnrealTargetConfiguration.Shipping)
{
RuntimeDependencies.Add("$(EngineDir)/Content/Stats/...", StagedFileType.UFS);
}
// @third party code - BEGIN HairWorks
AddEngineThirdPartyPrivateStaticDependencies(Target, "HairWorks");
// @third party code - END HairWorks
// NVCHANGE_BEGIN: Add VXGI
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDependencyModuleNames.Add("VXGI");
}
// NVCHANGE_END: Add VXGI
}
public LevelEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetTools",
"ClassViewer",
"MainFrame",
"PlacementMode",
"SlateReflector",
"IntroTutorials",
"AppFramework",
"PortalServices",
"Persona",
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"Settings",
"IntroTutorials",
"HeadMountedDisplay",
"UnrealEd",
"VREditor",
"CommonMenuExtensions"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"LevelSequence",
"Analytics",
"Core",
"CoreUObject",
"LauncherPlatform",
"InputCore",
"Slate",
"SlateCore",
"EditorStyle",
"Engine",
"MessageLog",
"SourceControl",
"SourceControlWindows",
"StatsViewer",
"UnrealEd",
"DeveloperSettings",
"RenderCore",
"DeviceProfileServices",
"ContentBrowser",
"SceneOutliner",
"ActorPickerMode",
"RHI",
"Projects",
"TargetPlatform",
"EngineSettings",
"PropertyEditor",
"Kismet",
"KismetWidgets",
"Sequencer",
"Foliage",
"HierarchicalLODOutliner",
"HierarchicalLODUtilities",
"MaterialShaderQualitySettings",
"PixelInspectorModule",
"CommonMenuExtensions",
"ToolMenus",
"EnvironmentLightingViewer",
"DesktopPlatform",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MainFrame",
"ClassViewer",
"DeviceManager",
"SettingsEditor",
"SessionFrontend",
"SlateReflector",
"AutomationWindow",
"Layers",
"WorldBrowser",
"EditorWidgets",
"AssetTools",
"WorkspaceMenuStructure",
"NewLevelDialog",
"DeviceProfileEditor",
"PlacementMode",
"IntroTutorials",
"HeadMountedDisplay",
"VREditor",
"Persona",
}
);
if (Target.bWithLiveCoding)
{
PrivateIncludePathModuleNames.Add("LiveCoding");
}
}
public TargetPlatform(TargetInfo Target)
{
PrivateDependencyModuleNames.Add("Core");
PublicDependencyModuleNames.Add("DesktopPlatform");
PrivateIncludePathModuleNames.Add("PhysXFormats");
// no need for all these modules if the program doesn't want developer tools at all (like UnrealFileServer)
if (!UEBuildConfiguration.bBuildRequiresCookedData && UEBuildConfiguration.bBuildDeveloperTools)
{
// these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor
DynamicallyLoadedModuleNames.Add("ShaderPreprocessor");
DynamicallyLoadedModuleNames.Add("ShaderFormatOpenGL");
DynamicallyLoadedModuleNames.Add("ImageWrapper");
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatIntelISPCTexComp");
}
}
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64 ||
(Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32"))
{
// these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor
DynamicallyLoadedModuleNames.Add("ShaderFormatD3D");
DynamicallyLoadedModuleNames.Add("MetalShaderFormat");
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
}
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatADPCM"); // For IOS cooking
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
}
if (Target.Type == TargetRules.TargetType.Editor || Target.Type == TargetRules.TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_PVRTCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ATCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_DXTTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ETC1TargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ETC2TargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ASTCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_MultiTargetPlatform");
DynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("TVOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
DynamicallyLoadedModuleNames.Add("MacTargetPlatform");
DynamicallyLoadedModuleNames.Add("MacNoEditorTargetPlatform");
DynamicallyLoadedModuleNames.Add("MacServerTargetPlatform");
DynamicallyLoadedModuleNames.Add("MacClientTargetPlatform");
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
}
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
}
if (Target.Type == TargetRules.TargetType.Editor || Target.Type == TargetRules.TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_MultiTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_PVRTCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ATCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_DXTTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ETC1TargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ETC2TargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ASTCTargetPlatform");
DynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("TVOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
}
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
}
if (Target.Type == TargetRules.TargetType.Editor || Target.Type == TargetRules.TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_MultiTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_PVRTCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ATCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_DXTTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ETC1TargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ETC2TargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ASTCTargetPlatform");
}
}
}
if (UEBuildConfiguration.bBuildDeveloperTools == true && (UEBuildConfiguration.bBuildRequiresCookedData || UEBuildConfiguration.bRuntimePhysicsCooking) && UEBuildConfiguration.bCompileAgainstEngine && UEBuildConfiguration.bCompilePhysX)
{
DynamicallyLoadedModuleNames.Add("PhysXFormats");
}
}
public AudioMixer(ReadOnlyTargetRules Target) : base(Target)
{
OptimizeCode = CodeOptimization.Always;
PrivateIncludePathModuleNames.Add("TargetPlatform");
PrivateIncludePaths.AddRange(
new string[]
{
"Runtime/AudioMixer/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
// TODO test this for HTML5 !
//if (Target.Platform == UnrealTargetPlatform.HTML5)
//{
// AddEngineThirdPartyPrivateStaticDependencies(Target,
// "UEOgg",
// "Vorbis",
// "VorbisFile"
// );
//}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"libOpus"
);
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"libOpus"
);
}
}
public Launch(TargetInfo Target)
{
PrivateIncludePaths.Add("Runtime/Launch/Private");
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AutomationController",
"OnlineSubsystem",
"TaskGraph",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Media",
"MediaAssets",
"MoviePlayer",
"Networking",
"PakFile",
"Projects",
"RenderCore",
"RHI",
"SandboxFile",
"ShaderCore",
"Slate",
"SlateCore",
"Sockets",
}
);
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"HeadMountedDisplay",
}
);
if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateDependencyModuleNames.Add("ALAudio");
}
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateRHIRenderer",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateRHIRenderer",
"HeadMountedDisplay"
}
);
}
// UFS clients are not available in shipping builds
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"NetworkFile",
"StreamingFile",
"AutomationWorker",
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Renderer",
}
);
if (UEBuildConfiguration.bCompileAgainstEngine)
{
PrivateIncludePathModuleNames.Add("Messaging");
PublicDependencyModuleNames.Add("SessionServices");
PrivateIncludePaths.Add("Developer/DerivedDataCache/Public");
// LaunchEngineLoop.cpp does a LoadModule() on OnlineSubsystem and OnlineSubsystemUtils when compiled WITH_ENGINE, so they must be marked as dependencies so that they get compiled and cleaned
DynamicallyLoadedModuleNames.Add("OnlineSubsystem");
DynamicallyLoadedModuleNames.Add("OnlineSubsystemUtils");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PublicIncludePathModuleNames.Add("ProfilerService");
DynamicallyLoadedModuleNames.AddRange(new string[] { "TaskGraph", "RealtimeProfiler", "ProfilerService" });
}
if (UEBuildConfiguration.bBuildEditor == true)
{
PublicIncludePathModuleNames.Add("ProfilerClient");
PrivateDependencyModuleNames.AddRange(
new string[] {
"SourceControl",
"UnrealEd",
"DesktopPlatform"
}
);
// ExtraModules that are loaded when WITH_EDITOR=1 is true
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AutomationController",
"AutomationWorker",
"AutomationWindow",
"ProfilerClient",
"Toolbox",
"GammaUI",
"ModuleUI",
"OutputLog",
"TextureCompressor",
"MeshUtilities",
"SourceCodeAccess"
}
);
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PrivateDependencyModuleNames.Add("MainFrame");
PrivateDependencyModuleNames.Add("Settings");
}
else
{
DynamicallyLoadedModuleNames.Add("MainFrame");
}
}
if ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64))
{
DynamicallyLoadedModuleNames.Add("D3D11RHI");
DynamicallyLoadedModuleNames.Add("XAudio2");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.Add("CoreAudio");
}
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PrivateDependencyModuleNames.Add("OpenGLDrv");
DynamicallyLoadedModuleNames.Add("IOSAudio");
DynamicallyLoadedModuleNames.Add("IOSRuntimeSettings");
PublicFrameworks.Add("OpenGLES");
// this is weak for IOS8 support for CAMetalLayer that is in QuartzCore
PublicWeakFrameworks.Add("QuartzCore");
PrivateDependencyModuleNames.Add("LaunchDaemonMessages");
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("OpenGLDrv");
PrivateDependencyModuleNames.Add("AndroidAudio");
DynamicallyLoadedModuleNames.Add("AndroidRuntimeSettings");
}
if ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Mac) ||
(Target.Platform == UnrealTargetPlatform.Linux && Target.Type != TargetRules.TargetType.Server))
{
// TODO: re-enable after implementing resource tables for OpenGL.
DynamicallyLoadedModuleNames.Add("OpenGLDrv");
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PrivateDependencyModuleNames.Add("HTML5Audio");
if (Target.Architecture == "-win32")
{
PrivateDependencyModuleNames.Add("HTML5Win32");
PublicIncludePathModuleNames.Add("HTML5Win32");
AddThirdPartyPrivateStaticDependencies(Target, "SDL");
}
}
// @todo ps4 clang bug: this works around a PS4/clang compiler bug (optimizations)
if (Target.Platform == UnrealTargetPlatform.PS4)
{
bFasterWithoutUnity = true;
}
}
public AudioMixer(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("TargetPlatform");
PrivateIncludePaths.AddRange(
new string[]
{
"Runtime/AudioMixer/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus",
"UELibSampleRate"
);
// TODO test this for HTML5 !
//if (Target.Platform == UnrealTargetPlatform.HTML5)
//{
// AddEngineThirdPartyPrivateStaticDependencies(Target,
// "UEOgg",
// "Vorbis",
// "VorbisFile"
// );
//}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"libOpus"
);
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"libOpus"
);
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Windows))
{
string PlatformName = Target.Platform == UnrealTargetPlatform.Win32 ? "Win32" : "Win64";
string LibSndFilePath = Target.UEThirdPartyBinariesDirectory + "libsndfile/";
LibSndFilePath += PlatformName;
PublicAdditionalLibraries.Add("libsndfile-1.lib");
PublicDelayLoadDLLs.Add("libsndfile-1.dll");
PublicIncludePathModuleNames.Add("UELibSampleRate");
PublicLibraryPaths.Add(LibSndFilePath);
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/libsndfile/" + PlatformName + "/libsndfile-1.dll");
}
}
public FUCK15(TargetInfo Target)
{
//PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
//PrivateDependencyModuleNames.AddRange(new string[] { });
// 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
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "NetworkReplayStreaming" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"ImageWrapper",
"HeadMountedDisplay",
"Advertising",
"NetworkReplayStreaming",
"MovieSceneCapture",
"AutomationWorker",
"MovieSceneCapture",
"DesktopPlatform",
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
}
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"RenderCore",
"RHI",
"ShaderCore",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"GameplayTags",
"AIModule",
"DatabaseSupport",
"PacketHandler",
"HardwareSurvey",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "CrashTracker" });
DynamicallyLoadedModuleNames.AddRange(new string[] { "CrashTracker" });
PublicDependencyModuleNames.AddRange(
new string[] {
}
);
}
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Sockets",
"Landscape",
"UMG",
"Projects",
"Internationalization",
"MaterialShaderQualitySettings",
"CinematicCamera",
"Analytics",
"AnalyticsET",
}
);
// to prevent "causes WARNING: Non-editor build cannot depend on non-redistributable modules."
if (Target.Type == TargetRules.TargetType.Editor)
{
// for now we depend on this
PrivateDependencyModuleNames.Add("RawMesh");
}
bool bVariadicTemplatesSupported = true;
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Use reflection to allow type not to exist if console code is not present
System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool");
if (XboxOnePlatformType != null)
{
System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
if (VersionName.ToString().Equals("2012"))
{
bVariadicTemplatesSupported = false;
}
}
}
if (bVariadicTemplatesSupported)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
// these modules require variadic templates
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
}
}
CircularlyReferencedDependentModules.Add("GameplayTags");
CircularlyReferencedDependentModules.Add("AIModule");
CircularlyReferencedDependentModules.Add("Landscape");
CircularlyReferencedDependentModules.Add("UMG");
CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings");
CircularlyReferencedDependentModules.Add("CinematicCamera");
// The AnimGraphRuntime module is not needed by Engine proper, but it is loaded in LaunchEngineLoop.cpp,
// and needs to be listed in an always-included module in order to be compiled into standalone games
DynamicallyLoadedModuleNames.Add("AnimGraphRuntime");
// So does Geometry Cache
DynamicallyLoadedModuleNames.Add("GeometryCache");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"ActorSequence",
"MovieScene",
"MovieSceneCapture",
"MovieSceneTracks",
"HeadMountedDisplay",
"StreamingPauseRendering",
}
);
PrivateIncludePathModuleNames.Add("LightPropagationVolumeRuntime");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
if (Target.Type == TargetRules.TargetType.Server || Target.Type == TargetRules.TargetType.Editor)
{
PrivateDependencyModuleNames.Add("PerfCounters");
}
if (UEBuildConfiguration.bBuildDeveloperTools)
{
// Add "BlankModule" so that it gets compiled as an example and will be maintained and tested. This can be removed
// at any time if needed. The module isn't actually loaded by the engine so there is no runtime cost.
DynamicallyLoadedModuleNames.Add("BlankModule");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.Add("MeshUtilities");
DynamicallyLoadedModuleNames.Add("MeshUtilities");
PrivateDependencyModuleNames.AddRange(
new string[] {
"ImageCore",
"RawMesh"
});
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test && Target.Type != TargetRules.TargetType.Server)
{
PrivateDependencyModuleNames.Add("CollisionAnalyzer");
CircularlyReferencedDependentModules.Add("CollisionAnalyzer");
PrivateDependencyModuleNames.Add("LogVisualizer");
CircularlyReferencedDependentModules.Add("LogVisualizer");
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WindowsTargetPlatform",
"WindowsNoEditorTargetPlatform",
"WindowsServerTargetPlatform",
"WindowsClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"LinuxClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"Advertising"
}
);
if (Target.Type.Value != TargetRules.TargetType.Server)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ImageWrapper",
"GameLiveStreaming"
}
);
}
if (!UEBuildConfiguration.bBuildRequiresCookedData && UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"DerivedDataCache",
"TargetPlatform",
"DesktopPlatform"
}
);
}
if (UEBuildConfiguration.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
); // @todo api: Only public because of WITH_EDITOR and UNREALED_API
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
);
PrivateIncludePathModuleNames.Add("TextureCompressor");
PrivateIncludePaths.Add("Developer/TextureCompressor/Public");
PrivateIncludePathModuleNames.Add("HierarchicalLODUtilities");
DynamicallyLoadedModuleNames.Add("HierarchicalLODUtilities");
}
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompilePhysX && UEBuildConfiguration.bRuntimePhysicsCooking)
{
DynamicallyLoadedModuleNames.Add("PhysXFormats");
PrivateIncludePathModuleNames.Add("PhysXFormats");
}
SetupModuleBox2DSupport(Target);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus",
"OpenSubdiv"
);
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectShow");
}
// Head Mounted Display support
// PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
// DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32")
{
PublicDependencyModuleNames.Add("HTML5JS");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"libOpus"
);
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
if (UEBuildConfiguration.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
Definitions.Add("WITH_RECAST=1");
}
else
{
// Because we test WITH_RECAST in public Engine header files, we need to make sure that modules
// that import this also have this definition set appropriately. Recast is a private dependency
// module, so it's definitions won't propagate to modules that import Engine.
Definitions.Add("WITH_RECAST=0");
}
// Add a reference to the stats HTML files referenced by UEngine::DumpFPSChartToHTML. Previously staged by CopyBuildToStagingDirectory.
if (UEBuildConfiguration.bBuildEditor || Target.Configuration != UnrealTargetConfiguration.Shipping)
{
RuntimeDependencies.Add("$(EngineDir)/Content/Stats/...", StagedFileType.UFS);
}
DynamicallyLoadedModuleNames.Add("Niagara");
}
public UnrealEd(ReadOnlyTargetRules Target) : base(Target)
{
if (Target.Type != TargetType.Editor)
{
throw new BuildException("Unable to instantiate UnrealEd module for non-editor targets.");
}
PrivatePCHHeaderFile = "Private/UnrealEdPrivatePCH.h";
SharedPCHHeaderFile = "Public/UnrealEdSharedPCH.h";
PrivateIncludePaths.AddRange(
new string[]
{
"Editor/UnrealEd/Private",
"Editor/UnrealEd/Private/Settings",
"Editor/PackagesDialog/Public",
"Developer/DerivedDataCache/Public",
"Developer/TargetPlatform/Public",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"BehaviorTreeEditor",
"ClassViewer",
"StructViewer",
"ContentBrowser",
"DerivedDataCache",
"DesktopPlatform",
"LauncherPlatform",
"EnvironmentQueryEditor",
"GameProjectGeneration",
"ProjectTargetPlatformEditor",
"ImageWrapper",
"MainFrame",
"MaterialEditor",
"MergeActors",
"MeshUtilities",
"MessagingCommon",
"MovieSceneCapture",
"PlacementMode",
"Settings",
"SettingsEditor",
"AudioEditor",
"ViewportSnapping",
"SourceCodeAccess",
"IntroTutorials",
"OutputLog",
"Landscape",
"LocalizationService",
"HierarchicalLODUtilities",
"MessagingRpc",
"PortalRpc",
"PortalServices",
"BlueprintNativeCodeGen",
"ViewportInteraction",
"VREditor",
"Persona",
"PhysicsAssetEditor",
"ClothingSystemEditorInterface",
"NavigationSystem",
"Media",
"VirtualTexturingEditor",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"BspMode",
"Core",
"CoreUObject",
"ApplicationCore",
"DirectoryWatcher",
"Documentation",
"Engine",
"Json",
"Projects",
"SandboxFile",
"Slate",
"SlateCore",
"EditorStyle",
"SourceControl",
"UnrealEdMessages",
"GameplayDebugger",
"BlueprintGraph",
"Http",
"UnrealAudio",
"FunctionalTesting",
"AutomationController",
"Localization",
"AudioEditor",
"NetworkFileSystem",
"UMG",
"NavigationSystem",
"MeshDescription",
"StaticMeshDescription",
"MeshDescriptionOperations",
"MeshBuilder",
"MaterialShaderQualitySettings",
"EditorSubsystem",
"InteractiveToolsFramework",
"ToolMenusEditor",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AssetRegistry",
"AssetTagsEditor",
"LevelSequence",
"AnimGraph",
"AppFramework",
"BlueprintGraph",
"CinematicCamera",
"CurveEditor",
"DesktopPlatform",
"LauncherPlatform",
"EditorStyle",
"EngineSettings",
"ImageWriteQueue",
"InputCore",
"InputBindingEditor",
"LauncherServices",
"MaterialEditor",
"MessageLog",
"PakFile",
"PropertyEditor",
"Projects",
"RawMesh",
"MeshUtilitiesCommon",
"SkeletalMeshUtilitiesCommon",
"RenderCore",
"RHI",
"Sockets",
"SourceControlWindows",
"StatsViewer",
"SwarmInterface",
"TargetPlatform",
"TargetDeviceServices",
"EditorWidgets",
"GraphEditor",
"Kismet",
"InternationalizationSettings",
"JsonUtilities",
"Landscape",
"HeadMountedDisplay",
"MeshPaint",
"MeshPaintMode",
"Foliage",
"VectorVM",
"MaterialUtilities",
"Localization",
"LocalizationService",
"AddContentDialog",
"GameProjectGeneration",
"HierarchicalLODUtilities",
"Analytics",
"AnalyticsET",
"PluginWarden",
"PixelInspectorModule",
"MovieScene",
"MovieSceneTracks",
"ViewportInteraction",
"VREditor",
"ClothingSystemEditor",
"ClothingSystemRuntimeInterface",
"ClothingSystemRuntimeCommon",
"ClothingSystemRuntimeNv",
"PIEPreviewDeviceProfileSelector",
"PakFileUtilities",
"TimeManagement",
"LandscapeEditorUtilities",
"DerivedDataCache",
"ScriptDisassembler",
"ToolMenus",
"FreeImage",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"FontEditor",
"StaticMeshEditor",
"TextureEditor",
"Cascade",
"UMGEditor",
"Matinee",
"AssetTools",
"ClassViewer",
"StructViewer",
"CollectionManager",
"ContentBrowser",
"CurveTableEditor",
"DataTableEditor",
"EditorSettingsViewer",
"LandscapeEditor",
"KismetCompiler",
"DetailCustomizations",
"ComponentVisualizers",
"MainFrame",
"LevelEditor",
"PackagesDialog",
"Persona",
"PhysicsAssetEditor",
"ProjectLauncher",
"DeviceManager",
"SettingsEditor",
"SessionFrontend",
"StringTableEditor",
"GeometryMode",
"TextureAlignMode",
"FoliageEdit",
"ImageWrapper",
"Blutility",
"IntroTutorials",
"WorkspaceMenuStructure",
"PlacementMode",
"MeshUtilities",
"MergeActors",
"ProjectSettingsViewer",
"ProjectTargetPlatformEditor",
"PListEditor",
"BehaviorTreeEditor",
"EnvironmentQueryEditor",
"ViewportSnapping",
"GameplayTasksEditor",
"UndoHistory",
"SourceCodeAccess",
"HotReload",
"PortalProxies",
"PortalServices",
"BlueprintNativeCodeGen",
"OverlayEditor",
"AnimationModifiers",
"ClothPainter",
"Media",
"TimeManagementEditor",
"VirtualTexturingEditor",
"EditorInteractiveToolsFramework"
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.Add("IOSPlatformEditor");
}
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.Add("AndroidPlatformEditor");
}
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.Add("LuminPlatformEditor");
}
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"GraphEditor",
"Kismet",
"AudioEditor",
"ViewportInteraction",
"VREditor",
}
);
// Add include directory for Lightmass
PublicIncludePaths.Add("Programs/UnrealLightmass/Public");
PublicIncludePaths.Add("Developer/Android/AndroidDeviceDetection/Public/Interfaces");
PublicIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTagsEditor",
"CollectionManager",
"BlueprintGraph",
"AddContentDialog",
"MeshUtilities",
"AssetTools",
"KismetCompiler",
"NavigationSystem",
"GameplayTasks",
"AIModule",
"Engine",
"SourceControl",
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDependencyModuleNames.Add("XAudio2");
PublicDependencyModuleNames.Add("AudioMixerXAudio2");
PrivateDependencyModuleNames.Add("WindowsPlatformFeatures");
PrivateDependencyModuleNames.Add("GameplayMediaEncoder");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"DX11Audio"
);
}
AddEngineThirdPartyPrivateStaticDependencies(Target,
"VHACD",
"FBX",
"FreeType2"
);
SetupModulePhysicsSupport(Target);
if (Target.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
PublicDefinitions.Add("WITH_RECAST=1");
}
else
{
PublicDefinitions.Add("WITH_RECAST=0");
}
if (Target.bWithLiveCoding)
{
PrivateIncludePathModuleNames.Add("LiveCoding");
}
}
public TranslationEditor(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePathModuleNames.Add("LevelEditor");
PublicIncludePathModuleNames.Add("WorkspaceMenuStructure");
PrivateIncludePathModuleNames.Add("LocalizationService");
PrivateIncludePathModuleNames.AddRange(
new string[] {
"DesktopPlatform",
"MessageLog",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Json",
"PropertyEditor",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"GraphEditor",
"SourceControl",
"MessageLog",
"Documentation",
"Localization",
"LocalizationCommandletExecution",
"LocalizationService",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Localization",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WorkspaceMenuStructure",
"DesktopPlatform",
}
);
PrivateIncludePaths.AddRange(
new string[]
{
"Editor/TranslationEditor/Private",
}
);
PublicIncludePaths.AddRange(
new string[]
{
"Editor/TranslationEditor/Public",
}
);
}
public Core(TargetInfo Target)
{
PrivatePCHHeaderFile = "Private/CorePrivatePCH.h";
SharedPCHHeaderFile = "Public/CoreSharedPCH.h";
PublicIncludePaths.AddRange(
new string[] {
"Runtime/Core/Public",
"Runtime/Core/Public/Internationalization",
"Runtime/Core/Public/Async",
"Runtime/Core/Public/Concurrency",
"Runtime/Core/Public/Containers",
"Runtime/Core/Public/Delegates",
"Runtime/Core/Public/GenericPlatform",
"Runtime/Core/Public/HAL",
"Runtime/Core/Public/Logging",
"Runtime/Core/Public/Math",
"Runtime/Core/Public/Misc",
"Runtime/Core/Public/Modules",
"Runtime/Core/Public/Modules/Boilerplate",
"Runtime/Core/Public/ProfilingDebugging",
"Runtime/Core/Public/Serialization",
"Runtime/Core/Public/Serialization/Csv",
"Runtime/Core/Public/Stats",
"Runtime/Core/Public/Templates",
"Runtime/Core/Public/UObject",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Core/Private",
"Runtime/Core/Private/Misc",
"Runtime/Core/Private/Serialization/Json",
"Runtime/Core/Private/Internationalization",
"Runtime/Core/Private/Internationalization/Cultures",
"Runtime/Analytics/Public",
"Runtime/Engine/Public",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"DerivedDataCache",
"InputDevice",
"Analytics",
"RHI"
}
);
if (UEBuildConfiguration.bBuildEditor == true)
{
DynamicallyLoadedModuleNames.Add("SourceCodeAccess");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
PublicIncludePaths.Add("Runtime/Core/Public/Windows");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"XInput"
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicIncludePaths.AddRange(new string[] { "Runtime/Core/Public/Apple", "Runtime/Core/Public/Mac" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"zlib",
"OpenGL",
"PLCrashReporter"
);
PublicFrameworks.AddRange(new string[] { "Cocoa", "Carbon", "IOKit", "Security" });
if (UEBuildConfiguration.bBuildEditor == true)
{
PublicAdditionalLibraries.Add("/System/Library/PrivateFrameworks/MultitouchSupport.framework/Versions/Current/MultitouchSupport");
}
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PublicIncludePaths.AddRange(new string[] { "Runtime/Core/Public/Apple", "Runtime/Core/Public/IOS" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib"
);
PublicFrameworks.AddRange(new string[] { "UIKit", "Foundation", "AudioToolbox", "AVFoundation", "GameKit", "StoreKit", "CoreVideo", "CoreMedia", "CoreGraphics", "GameController", "SystemConfiguration" });
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.AddRange(new string[] { "CoreMotion" });
}
bool bSupportAdvertising = Target.Platform == UnrealTargetPlatform.IOS;
if (bSupportAdvertising)
{
PublicFrameworks.AddRange(new string[] { "iAD" });
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicIncludePaths.Add("Runtime/Core/Public/Android");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"cxademangle",
"zlib"
);
}
else if ((Target.Platform == UnrealTargetPlatform.Linux))
{
PublicIncludePaths.Add("Runtime/Core/Public/Linux");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib",
"jemalloc",
"elftoolchain",
"SDL2"
);
// Core uses dlopen()
PublicAdditionalLibraries.Add("dl");
// We need FreeType2 and GL for the Splash, but only in the Editor
if (Target.Type == TargetRules.TargetType.Editor)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "FreeType2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
PrivateIncludePathModuleNames.Add("ImageWrapper");
}
}
else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
PublicIncludePaths.Add("Runtime/Core/Public/HTML5");
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenAL");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
PrivateDependencyModuleNames.Add("HTML5JS");
PrivateDependencyModuleNames.Add("MapPakDownloader");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicAdditionalLibraries.Add("SceRtc_stub_weak"); //ORBIS SDK rtc.h, used in PS4Time.cpp
}
if (UEBuildConfiguration.bCompileICU == true)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "ICU");
}
Definitions.Add("UE_ENABLE_ICU=" + (UEBuildConfiguration.bCompileICU ? "1" : "0")); // Enable/disable (=1/=0) ICU usage in the codebase. NOTE: This flag is for use while integrating ICU and will be removed afterward.
// If we're compiling with the engine, then add Core's engine dependencies
if (UEBuildConfiguration.bCompileAgainstEngine == true)
{
if (!UEBuildConfiguration.bBuildRequiresCookedData)
{
DynamicallyLoadedModuleNames.AddRange(new string[] { "DerivedDataCache" });
}
}
// On Windows platform, VSPerfExternalProfiler.cpp needs access to "VSPerf.h". This header is included with Visual Studio, but it's not in a standard include path.
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
var VisualStudioVersionNumber = "11.0";
var SubFolderName = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64/PerfSDK" : "PerfSDK";
string PerfIncludeDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), String.Format("Microsoft Visual Studio {0}/Team Tools/Performance Tools/{1}", VisualStudioVersionNumber, SubFolderName));
if (File.Exists(Path.Combine(PerfIncludeDirectory, "VSPerf.h")))
{
PrivateIncludePaths.Add(PerfIncludeDirectory);
Definitions.Add("WITH_VS_PERF_PROFILER=1");
}
}
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
Definitions.Add("WITH_DIRECTXMATH=1");
}
else if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
// To enable this requires Win8 SDK
Definitions.Add("WITH_DIRECTXMATH=0"); // Enable to test on Win64/32.
//PublicDependencyModuleNames.AddRange( // Enable to test on Win64/32.
// new string[] {
// "DirectXMath"
//});
}
else
{
Definitions.Add("WITH_DIRECTXMATH=0");
}
}
public GameProjectGeneration(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"HardwareTargeting",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"ContentBrowser",
"DesktopPlatform",
"LauncherPlatform",
"MainFrame",
"AddContentDialog",
"HardwareTargeting",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Analytics",
"ApplicationCore",
"AppFramework",
"ClassViewer",
"Core",
"CoreUObject",
"Engine",
"EngineSettings",
"InputCore",
"Projects",
"RenderCore",
"Slate",
"SlateCore",
"EditorStyle",
"SourceControl",
"TargetPlatform",
"UnrealEd",
"DesktopPlatform",
"LauncherPlatform",
"HardwareTargeting",
"AddContentDialog",
"AudioMixer",
"AudioMixerCore"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetRegistry",
"ContentBrowser",
"Documentation",
"MainFrame",
}
);
if (Target.bWithLiveCoding)
{
PrivateIncludePathModuleNames.Add("LiveCoding");
}
}
public Engine(TargetInfo Target)
{
SharedPCHHeaderFile = "Runtime/Engine/Public/Engine.h";
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/Online/OnlineSubsystem/Public",
"Runtime/Online/OnlineSubsystemUtils/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"OnlineSubsystem",
"TargetPlatform",
"ImageWrapper",
"HeadMountedDisplay",
"Advertising",
"NetworkReplayStreaming",
"MovieSceneCapture",
"AutomationWorker",
"Analytics",
"MovieSceneCapture",
"DesktopPlatform",
"Analytics"
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
}
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"RenderCore",
"RHI",
"ShaderCore",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"AIModule",
"DatabaseSupport",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "CrashTracker" });
DynamicallyLoadedModuleNames.AddRange(new string[] { "CrashTracker" });
PublicDependencyModuleNames.AddRange(
new string[] {
"CookingStats",
}
);
}
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Sockets",
"Landscape",
"UMG",
"Projects",
"Niagara",
"Internationalization",
"PacketHandler",
"MaterialShaderQualitySettings",
}
);
if (Target.Platform != UnrealTargetPlatform.XboxOne)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
// these modules require variadic templates
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
}
}
CircularlyReferencedDependentModules.Add("AIModule");
CircularlyReferencedDependentModules.Add("Landscape");
CircularlyReferencedDependentModules.Add("UMG");
CircularlyReferencedDependentModules.Add("Niagara");
CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings");
// The AnimGraphRuntime module is not needed by Engine proper, but it is loaded in LaunchEngineLoop.cpp,
// and needs to be listed in an always-included module in order to be compiled into standalone games
DynamicallyLoadedModuleNames.Add("AnimGraphRuntime");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneCapture",
"MovieSceneTracks",
"HeadMountedDisplay",
"StreamingPauseRendering",
}
);
PrivateIncludePathModuleNames.Add("LightPropagationVolumeRuntime");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
if (Target.Type == TargetRules.TargetType.Server || Target.Type == TargetRules.TargetType.Editor)
{
PrivateDependencyModuleNames.Add("PerfCounters");
}
if (UEBuildConfiguration.bBuildDeveloperTools)
{
// Add "BlankModule" so that it gets compiled as an example and will be maintained and tested. This can be removed
// at any time if needed. The module isn't actually loaded by the engine so there is no runtime cost.
DynamicallyLoadedModuleNames.Add("BlankModule");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.Add("MeshUtilities");
DynamicallyLoadedModuleNames.Add("MeshUtilities");
PrivateDependencyModuleNames.AddRange(
new string[] {
"ImageCore",
"RawMesh"
});
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test && Target.Type != TargetRules.TargetType.Server)
{
PrivateDependencyModuleNames.Add("CollisionAnalyzer");
CircularlyReferencedDependentModules.Add("CollisionAnalyzer");
PrivateDependencyModuleNames.Add("LogVisualizer");
CircularlyReferencedDependentModules.Add("LogVisualizer");
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WindowsTargetPlatform",
"WindowsNoEditorTargetPlatform",
"WindowsServerTargetPlatform",
"WindowsClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Analytics",
"AnalyticsET",
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"OnlineSubsystem",
"OnlineSubsystemUtils",
"Advertising"
}
);
if (Target.Type.Value != TargetRules.TargetType.Server)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ImageWrapper",
"GameLiveStreaming"
}
);
}
if (!UEBuildConfiguration.bBuildRequiresCookedData && UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"DerivedDataCache",
"TargetPlatform",
"DesktopPlatform"
}
);
}
if (UEBuildConfiguration.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
); // @todo api: Only public because of WITH_EDITOR and UNREALED_API
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
);
PrivateIncludePathModuleNames.Add("TextureCompressor");
PrivateIncludePaths.Add("Developer/TextureCompressor/Public");
}
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompilePhysX && UEBuildConfiguration.bRuntimePhysicsCooking)
{
DynamicallyLoadedModuleNames.Add("PhysXFormats");
PrivateIncludePathModuleNames.Add("PhysXFormats");
}
SetupModuleBox2DSupport(Target);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
AddThirdPartyPrivateStaticDependencies(Target, "DirectShow");
}
// Head Mounted Display support
// PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
// DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
AddThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32")
{
PublicDependencyModuleNames.Add("HTML5JS");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"libOpus"
);
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
AddThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
if (UEBuildConfiguration.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
Definitions.Add("WITH_RECAST=1");
}
else
{
// Because we test WITH_RECAST in public Engine header files, we need to make sure that modules
// that import this also have this definition set appropriately. Recast is a private dependency
// module, so it's definitions won't propagate to modules that import Engine.
Definitions.Add("WITH_RECAST=0");
}
}
public TargetPlatform(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.Add("Core");
PrivateDependencyModuleNames.Add("SlateCore");
PrivateDependencyModuleNames.Add("Slate");
PrivateDependencyModuleNames.Add("EditorStyle");
PrivateDependencyModuleNames.Add("Projects");
PublicDependencyModuleNames.Add("AudioPlatformConfiguration");
PublicDependencyModuleNames.Add("DesktopPlatform");
PublicDependencyModuleNames.Add("LauncherPlatform");
PrivateIncludePathModuleNames.Add("Engine");
PrivateIncludePathModuleNames.Add("PhysicsCore");
// no need for all these modules if the program doesn't want developer tools at all (like UnrealFileServer)
if (!Target.bBuildRequiresCookedData && Target.bBuildDeveloperTools)
{
// these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor
DynamicallyLoadedModuleNames.Add("ShaderPreprocessor");
DynamicallyLoadedModuleNames.Add("ShaderFormatOpenGL");
DynamicallyLoadedModuleNames.Add("ShaderFormatVectorVM");
DynamicallyLoadedModuleNames.Add("ImageWrapper");
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
DynamicallyLoadedModuleNames.Add("TextureFormatIntelISPCTexComp");
}
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
// these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor
DynamicallyLoadedModuleNames.Add("ShaderFormatD3D");
DynamicallyLoadedModuleNames.Add("MetalShaderFormat");
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatADPCM"); // For IOS cooking
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
}
if (Target.Type == TargetType.Editor || Target.Type == TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("TVOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("MacTargetPlatform");
DynamicallyLoadedModuleNames.Add("MacNoEditorTargetPlatform");
DynamicallyLoadedModuleNames.Add("MacServerTargetPlatform");
DynamicallyLoadedModuleNames.Add("MacClientTargetPlatform");
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
DynamicallyLoadedModuleNames.Add("AudioFormatADPCM");
}
if (Target.Type == TargetType.Editor || Target.Type == TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("TVOSTargetPlatform");
}
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Linux))
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
DynamicallyLoadedModuleNames.Add("AudioFormatADPCM");
}
if (Target.Type == TargetType.Editor || Target.Type == TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
}
}
}
if (Target.bBuildDeveloperTools == true && Target.bBuildRequiresCookedData && Target.bCompileAgainstEngine && Target.bCompilePhysX)
{
DynamicallyLoadedModuleNames.Add("PhysXCooking");
}
}
public ApplicationCore(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Core"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"RHI"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"InputDevice",
"Analytics",
"SynthBenchmark"
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"XInput"
);
if (Target.bCompileWithAccessibilitySupport && !Target.bIsBuildingConsoleApplication)
{
PublicAdditionalLibraries.Add("uiautomationcore.lib");
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"OpenGL"
);
if (Target.bBuildEditor == true)
{
PublicAdditionalLibraries.Add("/System/Library/PrivateFrameworks/MultitouchSupport.framework/Versions/Current/MultitouchSupport");
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"SDL2"
);
// We need FreeType2 and GL for the Splash, but only in the Editor
if (Target.Type == TargetType.Editor)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "FreeType2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
PrivateIncludePathModuleNames.Add("ImageWrapper");
}
}
else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenAL");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
PrivateDependencyModuleNames.Add("HTML5JS");
PrivateDependencyModuleNames.Add("MapPakDownloader");
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PublicIncludePaths.AddRange(new string[] { "Runtime/ApplicationCore/Public/IOS" });
AddEngineThirdPartyPrivateStaticDependencies(Target, "SoundSwitch");
// export ApplicationCore symbols for embedded Dlls
ModuleSymbolVisibility = ModuleRules.SymbolVisibility.VisibileForDll;
}
else if (Target.Platform == UnrealTargetPlatform.Android || Target.Platform == UnrealTargetPlatform.Lumin)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Launch"
}
);
}
if (!Target.bCompileAgainstApplicationCore)
{
throw new System.Exception("ApplicationCore cannot be used when Target.bCompileAgainstApplicationCore = false.");
}
}
public ApplicationCore(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Core"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"RHI"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"InputDevice",
"Analytics",
"SynthBenchmark"
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"XInput"
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"OpenGL"
);
if (Target.bBuildEditor == true)
{
PublicAdditionalLibraries.Add("/System/Library/PrivateFrameworks/MultitouchSupport.framework/Versions/Current/MultitouchSupport");
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"SDL2"
);
// We need FreeType2 and GL for the Splash, but only in the Editor
if (Target.Type == TargetType.Editor)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "FreeType2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
PrivateIncludePathModuleNames.Add("ImageWrapper");
}
}
else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenAL");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
PrivateDependencyModuleNames.Add("HTML5JS");
PrivateDependencyModuleNames.Add("MapPakDownloader");
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PublicIncludePaths.AddRange(new string[] { "Runtime/ApplicationCore/Public/IOS" });
}
}
public Launch(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Runtime/Launch/Private");
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AutomationController",
"TaskGraph",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"MediaAssets",
"MoviePlayer",
"Networking",
"PakFile",
"Projects",
"RenderCore",
"RHI",
"SandboxFile",
"Serialization",
"ShaderCore",
"Slate",
"SlateCore",
"Sockets",
"Overlay",
"UtilityShaders",
}
);
// Enable the LauncherCheck module to be used for platforms that support the Launcher.
// Projects should set Target.bUseLauncherChecks in their Target.cs to enable the functionality.
if (Target.bUseLauncherChecks &&
((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Mac)))
{
PrivateDependencyModuleNames.Add("LauncherCheck");
Definitions.Add("WITH_LAUNCHERCHECK=1");
}
else
{
Definitions.Add("WITH_LAUNCHERCHECK=0");
}
if (Target.Type != TargetType.Server)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"HeadMountedDisplay",
"MRMesh",
}
);
if ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64))
{
DynamicallyLoadedModuleNames.Add("D3D12RHI");
DynamicallyLoadedModuleNames.Add("D3D11RHI");
DynamicallyLoadedModuleNames.Add("XAudio2");
DynamicallyLoadedModuleNames.Add("AudioMixerXAudio2");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
DynamicallyLoadedModuleNames.Add("AudioMixerSDL");
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.Add("CoreAudio");
DynamicallyLoadedModuleNames.Add("AudioMixerAudioUnit");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.Add("ALAudio");
PrivateDependencyModuleNames.Add("Json");
}
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
// UFS clients are not available in shipping builds
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"NetworkFile",
"StreamingFile",
"CookedIterativeFile",
"AutomationWorker",
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
"Renderer",
}
);
if (Target.bCompileAgainstEngine)
{
PrivateIncludePathModuleNames.Add("Messaging");
PublicDependencyModuleNames.Add("SessionServices");
PrivateIncludePaths.Add("Developer/DerivedDataCache/Public");
// LaunchEngineLoop.cpp will still attempt to load XMPP but not all projects require it so it will silently fail unless referenced by the project's build.cs file.
// DynamicallyLoadedModuleNames.Add("XMPP");
DynamicallyLoadedModuleNames.Add("HTTP");
PrivateDependencyModuleNames.Add("ClothingSystemRuntimeInterface");
PrivateDependencyModuleNames.Add("ClothingSystemRuntime");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PublicIncludePathModuleNames.Add("ProfilerService");
DynamicallyLoadedModuleNames.AddRange(new string[] { "TaskGraph", "RealtimeProfiler", "ProfilerService" });
}
// The engine can use AutomationController in any connfiguration besides shipping. This module is loaded
// dynamically in LaunchEngineLoop.cpp in non-shipping configurations
if (Target.bCompileAgainstEngine && Target.Configuration != UnrealTargetConfiguration.Shipping)
{
DynamicallyLoadedModuleNames.AddRange(new string[] { "AutomationController" });
}
if (Target.bBuildEditor == true)
{
PublicIncludePathModuleNames.Add("ProfilerClient");
PrivateDependencyModuleNames.AddRange(
new string[] {
"SourceControl",
"UnrealEd",
"DesktopPlatform",
"PIEPreviewDeviceProfileSelector",
}
);
// ExtraModules that are loaded when WITH_EDITOR=1 is true
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AutomationWindow",
"ProfilerClient",
"Toolbox",
"GammaUI",
"ModuleUI",
"OutputLog",
"TextureCompressor",
"MeshUtilities",
"SourceCodeAccess"
}
);
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PrivateDependencyModuleNames.Add("MainFrame");
PrivateDependencyModuleNames.Add("Settings");
}
else
{
DynamicallyLoadedModuleNames.Add("MainFrame");
}
}
if (Target.Platform == UnrealTargetPlatform.IOS ||
Target.Platform == UnrealTargetPlatform.TVOS)
{
PrivateDependencyModuleNames.Add("OpenGLDrv");
PrivateDependencyModuleNames.Add("IOSAudio");
PrivateDependencyModuleNames.Add("AudioMixerAudioUnit");
DynamicallyLoadedModuleNames.Add("IOSRuntimeSettings");
DynamicallyLoadedModuleNames.Add("IOSLocalNotification");
PublicFrameworks.Add("OpenGLES");
// this is weak for IOS8 support for CAMetalLayer that is in QuartzCore
PublicWeakFrameworks.Add("QuartzCore");
PrivateDependencyModuleNames.Add("LaunchDaemonMessages");
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("OpenGLDrv");
PrivateDependencyModuleNames.Add("AndroidAudio");
PrivateDependencyModuleNames.Add("AudioMixerAndroid");
DynamicallyLoadedModuleNames.Add("AndroidRuntimeSettings");
DynamicallyLoadedModuleNames.Add("AndroidLocalNotification");
}
if ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Linux && Target.Type != TargetType.Server))
{
// TODO: re-enable after implementing resource tables for OpenGL.
DynamicallyLoadedModuleNames.Add("OpenGLDrv");
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PrivateDependencyModuleNames.Add("ALAudio");
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
// @todo ps4 clang bug: this works around a PS4/clang compiler bug (optimizations)
if (Target.Platform == UnrealTargetPlatform.PS4)
{
bFasterWithoutUnity = true;
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"LinuxCommonStartup"
}
);
}
}
public Core(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/CorePrivatePCH.h";
SharedPCHHeaderFile = "Public/CoreSharedPCH.h";
PrivateDependencyModuleNames.Add("BuildSettings");
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Core/Private",
"Runtime/Core/Private/Misc",
"Runtime/Core/Private/Internationalization",
"Runtime/Core/Private/Internationalization/Cultures",
"Runtime/Engine/Public",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"DerivedDataCache",
"InputDevice",
"Analytics",
"RHI"
}
);
if (Target.bBuildEditor == true)
{
DynamicallyLoadedModuleNames.Add("SourceCodeAccess");
PrivateIncludePathModuleNames.Add("DirectoryWatcher");
DynamicallyLoadedModuleNames.Add("DirectoryWatcher");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"IntelVTune"
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"zlib",
"PLCrashReporter",
"rd_route"
);
PublicFrameworks.AddRange(new string[] { "Cocoa", "Carbon", "IOKit", "Security" });
if (Target.bBuildEditor == true)
{
PublicAdditionalLibraries.Add("/System/Library/PrivateFrameworks/MultitouchSupport.framework/Versions/Current/MultitouchSupport");
}
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib"
);
PublicFrameworks.AddRange(new string[] { "UIKit", "Foundation", "AudioToolbox", "AVFoundation", "GameKit", "StoreKit", "CoreVideo", "CoreMedia", "CoreGraphics", "GameController", "SystemConfiguration" });
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.AddRange(new string[] { "CoreMotion", "AdSupport", "WebKit" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"PLCrashReporter"
);
}
PrivateIncludePathModuleNames.Add("ApplicationCore");
bool bSupportAdvertising = Target.Platform == UnrealTargetPlatform.IOS;
if (bSupportAdvertising)
{
PublicFrameworks.AddRange(new string[] { "iAD" });
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"cxademangle",
"zlib"
);
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PublicIncludePaths.Add(string.Format("Runtime/Core/Public/{0}", Target.Platform.ToString()));
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib",
"jemalloc",
"elftoolchain"
);
// Core uses dlopen()
PublicAdditionalLibraries.Add("dl");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PrivateDependencyModuleNames.Add("HTML5JS");
PrivateDependencyModuleNames.Add("MapPakDownloader");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicAdditionalLibraries.Add("SceRtc_stub_weak"); //ORBIS SDK rtc.h, used in PS4Time.cpp
}
if (Target.bCompileICU == true)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "ICU");
}
PublicDefinitions.Add("UE_ENABLE_ICU=" + (Target.bCompileICU ? "1" : "0")); // Enable/disable (=1/=0) ICU usage in the codebase. NOTE: This flag is for use while integrating ICU and will be removed afterward.
// If we're compiling with the engine, then add Core's engine dependencies
if (Target.bCompileAgainstEngine == true)
{
if (!Target.bBuildRequiresCookedData)
{
DynamicallyLoadedModuleNames.AddRange(new string[] { "DerivedDataCache" });
}
}
// On Windows platform, VSPerfExternalProfiler.cpp needs access to "VSPerf.h". This header is included with Visual Studio, but it's not in a standard include path.
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
var VisualStudioVersionNumber = "11.0";
var SubFolderName = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64/PerfSDK" : "PerfSDK";
string PerfIncludeDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), String.Format("Microsoft Visual Studio {0}/Team Tools/Performance Tools/{1}", VisualStudioVersionNumber, SubFolderName));
if (File.Exists(Path.Combine(PerfIncludeDirectory, "VSPerf.h")))
{
PrivateIncludePaths.Add(PerfIncludeDirectory);
PublicDefinitions.Add("WITH_VS_PERF_PROFILER=1");
}
else
{
PublicDefinitions.Add("WITH_VS_PERF_PROFILER=0");
}
}
WhitelistRestrictedFolders.Add("Private/NoRedist");
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PublicDefinitions.Add("WITH_DIRECTXMATH=1");
}
else if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
// To enable this requires Win8 SDK
PublicDefinitions.Add("WITH_DIRECTXMATH=0"); // Enable to test on Win64/32.
//PublicDependencyModuleNames.AddRange( // Enable to test on Win64/32.
// new string[] {
// "DirectXMath"
//});
}
else
{
PublicDefinitions.Add("WITH_DIRECTXMATH=0");
}
// Decide if validating memory allocator (aka MallocStomp) can be used on the current platform.
// Run-time validation must be enabled through '-stompmalloc' command line argument.
bool bWithMallocStomp = false;
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
switch (Target.Platform)
{
case UnrealTargetPlatform.Mac:
case UnrealTargetPlatform.Linux:
//case UnrealTargetPlatform.Win32: // 32-bit windows can technically be supported, but will likely run out of virtual memory space quickly
//case UnrealTargetPlatform.XboxOne: // XboxOne could be supported, as it's similar enough to Win64
case UnrealTargetPlatform.Win64:
bWithMallocStomp = true;
break;
}
}
PublicDefinitions.Add("WITH_MALLOC_STOMP=" + (bWithMallocStomp ? "1" : "0"));
}
