public GameAnalytics(TargetInfo Target)
#endif
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
var GameAnalyticsPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "../ThirdParty/"));
var libPath = Path.Combine(GameAnalyticsPath, "lib");
// Test plugin analytics in editor mode
PublicDefinitions.Add("TEST_NON_EDITOR_PLUGIN_ANALYTICS_MODE=0");
switch (Target.Platform)
{
case UnrealTargetPlatform.Win64:
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win64", "GameAnalytics.lib"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
break;
case UnrealTargetPlatform.Win32:
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win32", "GameAnalytics.lib"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
break;
case UnrealTargetPlatform.Android:
PrivateDependencyModuleNames.Add("Launch");
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private/Android"));
break;
case UnrealTargetPlatform.Mac:
PublicAdditionalLibraries.Add(Path.Combine(libPath, "osx", "libGameAnalytics.a"));
PublicAdditionalLibraries.Add("curl");
PublicFrameworks.AddRange(
new string[] {
"CoreFoundation",
"Foundation",
"CoreServices"
}
);
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL" });
break;
case UnrealTargetPlatform.Linux:
LoadLibrary(Path.Combine(libPath, "linux"), "libGameAnalytics.a");
//PublicAdditionalLibraries.Add(Path.Combine(libPath, "linux", "libGameAnalytics.a"));
//RuntimeDependencies.Add(Path.Combine(libPath, "linux", "libGameAnalytics.a"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
break;
case UnrealTargetPlatform.IOS:
PublicAdditionalLibraries.Add(Path.Combine(libPath, "ios", "libGameAnalytics.a"));
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private/IOS"));
PublicFrameworks.AddRange(
new string[] {
"AdSupport",
"SystemConfiguration"
}
);
PublicAdditionalLibraries.AddRange(
new string[] {
"sqlite3",
"z",
"c++"
});
break;
case UnrealTargetPlatform.HTML5:
if (Target.Architecture != "-win32")
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "html5", "GameAnalytics.jspre"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "html5", "GameAnalyticsUnreal.js"));
}
break;
case UnrealTargetPlatform.XboxOne:
case UnrealTargetPlatform.PS4:
default:
throw new NotImplementedException("This target platform is not configured for GameAnalytics SDK: " + Target.Platform.ToString());
}
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Private")));
PrivateIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Public")));
PublicIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Public")));
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Analytics",
"Engine"
}
);
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Json"
}
);
PublicIncludePathModuleNames.AddRange(
new string[]
{
"Json"
}
);
}
PublicIncludePathModuleNames.AddRange(
new string[]
{
"Analytics",
"Engine"
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(ModuleDirectory, "GameAnalytics_APL.xml"));
}
}
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 OculusHMD(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
// Relative to Engine\Plugins\Runtime\Oculus\OculusVR\Source
"../../../../../Source/Runtime/Renderer/Private",
"../../../../../Source/Runtime/OpenGLDrv/Private",
"../../../../../Source/Runtime/VulkanRHI/Private",
"../../../../../Source/Runtime/Engine/Classes/Components",
});
PublicIncludePathModuleNames.Add("Launch");
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"RHI",
"RenderCore",
"Renderer",
"ShaderCore",
"HeadMountedDisplay",
"Slate",
"SlateCore",
"ImageWrapper",
"MediaAssets",
"Analytics",
"UtilityShaders",
"OpenGLDrv",
"VulkanRHI",
"OVRPlugin",
});
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
// D3D
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"D3D11RHI",
"D3D12RHI",
});
PrivateIncludePaths.AddRange(
new string[]
{
"../../../../../Source/Runtime/Windows/D3D11RHI/Private",
"../../../../../Source/Runtime/Windows/D3D11RHI/Private/Windows",
"../../../../../Source/Runtime/D3D12RHI/Private",
"../../../../../Source/Runtime/D3D12RHI/Private/Windows",
});
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX12");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAPI");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11Audio");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectSound");
}
// Vulkan
{
string VulkanSDKPath = Environment.GetEnvironmentVariable("VULKAN_SDK");
if (!String.IsNullOrEmpty(VulkanSDKPath))
{
// If the user has an installed SDK, use that instead
PrivateIncludePaths.Add(VulkanSDKPath + "/Include");
// Older SDKs have an extra subfolder
PrivateIncludePaths.Add(VulkanSDKPath + "/Include/vulkan");
if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicLibraryPaths.Add(VulkanSDKPath + "/Source/lib32");
}
else
{
PublicLibraryPaths.Add(VulkanSDKPath + "/Source/lib");
}
PublicAdditionalLibraries.Add("vulkan-1.lib");
PublicAdditionalLibraries.Add("vkstatic.1.lib");
}
else
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
}
}
// OVRPlugin
{
PublicDelayLoadDLLs.Add("OVRPlugin.dll");
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/ThirdParty/Oculus/OVRPlugin/OVRPlugin/" + Target.Platform.ToString() + "/OVRPlugin.dll"));
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
// Vulkan
{
string NDKPath = Environment.GetEnvironmentVariable("NDKROOT");
// Note: header is the same for all architectures so just use arch-arm
string NDKVulkanIncludePath = NDKPath + "/platforms/android-24/arch-arm/usr/include/vulkan";
if (File.Exists(NDKVulkanIncludePath + "/vulkan.h"))
{
// Use NDK Vulkan header if discovered
PrivateIncludePaths.Add(NDKVulkanIncludePath);
}
else
{
string VulkanSDKPath = Environment.GetEnvironmentVariable("VULKAN_SDK");
if (!String.IsNullOrEmpty(VulkanSDKPath))
{
// If the user has an installed SDK, use that instead
PrivateIncludePaths.Add(VulkanSDKPath + "/Include/vulkan");
}
else
{
// Fall back to the Windows Vulkan SDK (the headers are the same)
PrivateIncludePaths.Add(Target.UEThirdPartySourceDirectory + "Vulkan/Windows/Include/vulkan");
}
}
}
// AndroidPlugin
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "GearVR_APL.xml")));
}
}
}
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 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" });
}
if (!Target.bCompileAgainstApplicationCore)
{
throw new System.Exception("ApplicationCore cannot be used when Target.bCompileAgainstApplicationCore = false.");
}
}
public Persona(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Editor/Persona/Private"); // For PCH includes (because they don't work with relative paths, yet)
PublicIncludePathModuleNames.AddRange(
new string[] {
"SkeletonEditor",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"AdvancedPreviewScene",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"MainFrame",
"DesktopPlatform",
"ContentBrowser",
"AssetTools",
"AnimationEditor",
"MeshReductionInterface"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"ApplicationCore",
"Slate",
"SlateCore",
"EditorStyle",
"Engine",
"UnrealEd",
"GraphEditor",
"InputCore",
"Kismet",
"KismetWidgets",
"AnimGraph",
"PropertyEditor",
"EditorWidgets",
"BlueprintGraph",
"RHI",
"Json",
"JsonUtilities",
"ClothingSystemRuntime",
"ClothingSystemEditorInterface",
"ClothingSystemRuntimeInterface",
"AnimGraphRuntime",
"UnrealEd",
"CommonMenuExtensions",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ContentBrowser",
"Documentation",
"MainFrame",
"DesktopPlatform",
"SkeletonEditor",
"AssetTools",
"AnimationEditor",
"MeshReductionInterface"
}
);
}
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))
{
PublicIncludePathModuleNames.Add("UELibSampleRate");
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.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 AntilatencyAltTracking(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
string BaseDirectory = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", ".."));
string BinaryDirectory = Path.Combine(BaseDirectory, "ThirdParty", "Antilatency", "Bin", Target.Platform.ToString());
string HeadersDirectory = Path.Combine(BaseDirectory, "ThirdParty", "Antilatency", "Include");
PublicIncludePathModuleNames.AddRange(
new string[] {
"Launch",
"Core"
}
);
PublicIncludePaths.AddRange(
new string[] {
HeadersDirectory
}
);
/*PrivateIncludePaths.AddRange(
* new string[] { }
* );*/
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Projects",
"AntilatencyDeviceNetwork",
"AntilatencyStorageClient"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] { }
);
DynamicallyLoadedModuleNames.AddRange(
new string[] { }
);
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
var DeviceNetworkLibraryPath = Path.Combine(BinaryDirectory, "AntilatencyDeviceNetwork.dll");
var StorageClientLibraryPath = Path.Combine(BinaryDirectory, "AntilatencyStorageClient.dll");
var AltTrackingLibraryPath = Path.Combine(BinaryDirectory, "AntilatencyAltTracking.dll");
#if UE_4_19_OR_LATER
RuntimeDependencies.Add(DeviceNetworkLibraryPath);
RuntimeDependencies.Add(StorageClientLibraryPath);
RuntimeDependencies.Add(AltTrackingLibraryPath);
#else
RuntimeDependencies.Add(new RuntimeDependency(DeviceNetworkLibraryPath));
RuntimeDependencies.Add(new RuntimeDependency(StorageClientLibraryPath));
RuntimeDependencies.Add(new RuntimeDependency(AltTrackingLibraryPath));
#endif
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
string AplPath = Path.Combine(PluginPath, "AntilatencyAltTracking_APL.xml");
#if UE_4_19_OR_LATER
AdditionalPropertiesForReceipt.Add("AndroidPlugin", AplPath);
#else
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", AplPath));
#endif
}
else
{
throw new NotImplementedException("NOT IMPLEMENTED YET FOR PLATFORM " + Target.Platform.ToString());
}
}
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",
"MoviePlayer",
"Networking",
"PakFile",
"Projects",
"RenderCore",
"RHI",
"SandboxFile",
"Serialization",
"ApplicationCore",
"Slate",
"SlateCore",
"Sockets",
"TraceLog",
"Overlay",
"UtilityShaders",
"PreLoadScreen"
});
// Set a macro allowing us to switch between debuggame/development configuration
if (Target.Configuration == UnrealTargetConfiguration.DebugGame)
{
PrivateDefinitions.Add("UE_BUILD_DEVELOPMENT_WITH_DEBUGGAME=1");
}
else
{
PrivateDefinitions.Add("UE_BUILD_DEVELOPMENT_WITH_DEBUGGAME=0");
}
// 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");
PublicDefinitions.Add("WITH_LAUNCHERCHECK=1");
}
else
{
PublicDefinitions.Add("WITH_LAUNCHERCHECK=0");
}
if (Target.Type != TargetType.Server)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"HeadMountedDisplay",
"MediaUtils",
"MRMesh",
});
if ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64))
{
DynamicallyLoadedModuleNames.AddRange(new string[] {
"AudioMixerXAudio2",
"D3D11RHI",
"D3D12RHI",
"XAudio2",
"WindowsPlatformFeatures",
"GameplayMediaEncoder",
});
}
else if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
DynamicallyLoadedModuleNames.Add("D3D11RHI");
DynamicallyLoadedModuleNames.Add("XAudio2");
DynamicallyLoadedModuleNames.Add("AudioMixerXAudio2");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(new string[] {
"AudioMixerAudioUnit",
"CoreAudio",
});
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
DynamicallyLoadedModuleNames.Add("AudioMixerSDL");
PrivateDependencyModuleNames.Add("Json");
}
PrivateIncludePathModuleNames.AddRange(new string[] {
"Media",
"SlateNullRenderer",
"SlateRHIRenderer",
});
DynamicallyLoadedModuleNames.AddRange(new string[] {
"Media",
"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[] {
"Renderer",
});
if (Target.bCompileAgainstEngine)
{
PrivateIncludePathModuleNames.AddRange(new string[] {
"MessagingCommon",
});
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.AddRange(new string[] {
"HTTP",
"MediaAssets",
});
PrivateDependencyModuleNames.AddRange(new string[] {
"ClothingSystemRuntime",
"ClothingSystemRuntimeInterface"
});
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"FunctionalTesting"
});
}
}
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.AddRange(new string[] {
"MainFrame",
"Settings",
});
}
else
{
DynamicallyLoadedModuleNames.Add("MainFrame");
}
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
PrivateDependencyModuleNames.Add("OpenGLDrv");
if (Target.Platform != UnrealTargetPlatform.Lumin)
{
PrivateDependencyModuleNames.Add("AndroidAudio");
PrivateDependencyModuleNames.Add("AudioMixerAndroid");
}
// these are, for now, only for basic android
if (Target.Platform == UnrealTargetPlatform.Android)
{
DynamicallyLoadedModuleNames.Add("AndroidRuntimeSettings");
DynamicallyLoadedModuleNames.Add("AndroidLocalNotification");
}
else if (Target.Platform == UnrealTargetPlatform.Lumin)
{
DynamicallyLoadedModuleNames.Add("LuminRuntimeSettings");
}
}
if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"AudioMixerAudioUnit",
"IOSAudio",
"LaunchDaemonMessages",
});
DynamicallyLoadedModuleNames.AddRange(new string[] {
"IOSLocalNotification",
"IOSRuntimeSettings",
});
// For 4.23 the below check fails for binary builds, re-enabling for all builds UE-77520
// ES support will be fully removed in 4.24
// no longer build GL for apps requiring iOS 12 or later
//if (Target.IOSPlatform.RuntimeVersion < 12.0)
{
PublicFrameworks.Add("OpenGLES");
PrivateDependencyModuleNames.Add("OpenGLDrv");
}
// needed for Metal layer
PublicFrameworks.Add("QuartzCore");
}
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.AddRange(
new string[] {
"ALAudio",
"AudioMixerSDL",
"Analytics",
"AnalyticsET"
}
);
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.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PrivateDependencyModuleNames.Add("UnixCommonStartup");
}
if (Target.LinkType == TargetLinkType.Monolithic && !Target.bFormalBuild)
{
PrivateDefinitions.Add(string.Format("COMPILED_IN_CL={0}", Target.Version.Changelist));
PrivateDefinitions.Add(string.Format("COMPILED_IN_COMPATIBLE_CL={0}", Target.Version.EffectiveCompatibleChangelist));
PrivateDefinitions.Add(string.Format("COMPILED_IN_BRANCH_NAME={0}", (Target.Version.BranchName == null || Target.Version.BranchName.Length == 0)? "UE4" : Target.Version.BranchName));
}
}
public ProteusAvatars(ReadOnlyTargetRules Target) : base(Target)
{
// Precompiled header usage for this module
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string BaseDirectory = Path.GetFullPath(Path.Combine(ModuleDirectory, ".."));
//(This setting is currently not need as we discover all files from the 'Public' folder) List of all paths to include files that are exposed to other modules
PublicIncludePaths.AddRange
(
new string[]
{
BaseDirectory + "/ProteusAvatars/Public",
// Access to ProteusOvrAvatarHelpers.h
BaseDirectory + "/ProteusAvatars/Private",
//Access to OVR_Avatar.h and OVR_Avatar_defs.h
EngineDirectory + "/Source/ThirdParty/Oculus/LibOVRAvatar/LibOVRAvatar/include",
// Access to OculusHMDModule.h
EngineDirectory + "/Plugins/Runtime/Oculus/OculusVR/Source/OculusHMD/Private"
}
);
// List of public dependency module names (no path needed) (automatically does the private/public include). These are modules that are required by our public source files.
PublicIncludePathModuleNames.AddRange
(
new string[]
{
//Access to the module /Source/ThirdParty/Oculus/OVRPlugin
"OVRPlugin"
}
);
// List of public dependency module names (no path needed) (automatically does the private/public include).
// These are modules that are required by our public source files
PublicDependencyModuleNames.AddRange
(
new string[]
{
"Core",
// "ProteusAvatarsLibrary",
"Projects",
//Access to the module /Source/ThirdParty/Oculus/OVRPlugin and /LibOVRAvatar
"OVRPlugin",
"LibOVRAvatar",
//Access to /Plugins/Runtime/Oculus/OculusVR/Source/OculusHMD
"OculusHMD",
"CoreUObject",
"Engine",
"InputCore",
"UMG",
"Slate",
"SlateCore",
"RenderCore",
"OnlineSubsystem",
"HeadMountedDisplay"
}
);
// List of all paths to this module's internal include files, not exposed to other modules (at least one include to the 'Private' path, more if we want to avoid relative paths)
PrivateIncludePaths.AddRange
(
new string[]
{
BaseDirectory + "/ProteusAvatars/Private"
}
);
// List of modules name(no path needed) with header files that our module's private code files needs access to, but we don't need to "import" or link against.
PrivateIncludePathModuleNames.AddRange
(
new string[]
{
//Access to /Plugins/Runtime/Oculus/OculusVR/Source/OculusHMD
"OculusHMD"
}
);
// List of private dependency module names.These are modules that our private code depends on but nothing in our public include files depend on.
PrivateDependencyModuleNames.AddRange
(
new string[]
{
"Core", "CoreUObject", "Engine", "InputCore", "UMG", "Slate", "SlateCore", "RenderCore",
"OnlineSubsystem", "HeadMountedDisplay", "OVRPlugin", "OculusHMD", "LibOVRAvatar"
}
);
// Addition modules this module may require at run-time
DynamicallyLoadedModuleNames.AddRange
(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// List of delay load DLLs - typically used for External (third party) modules
// Binaries/ThirdParty/Oculus/OVRPlugin/OVRPlugin/Win64/OVRPLugin.dll
PublicDelayLoadDLLs.Add("libovravatar.dll");
// Binaries/ThirdParty/Oculus/OVRPlugin/OVRPlugin/Win64/OVRPLugin.dll
PublicDelayLoadDLLs.Add("OVRPlugin.dll");
// List of files which this module depends on at runtime. These files will be staged along with the target.
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Oculus/OVRPlugin/OVRPlugin/" + Target.Platform.ToString() + "/OVRPlugin.dll");
}
// Which targets this module should be precompiled for
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicDelayLoadDLLs.Add("libovravatarloader.so");
PublicDelayLoadDLLs.Add("libOVRPlugin.so");
// List of files which this module depends on at runtime. These files will be staged along with the target.
// RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Oculus/OVRPlugin/OVRPlugin/Lib/armeabi-v7a/libOVRPlugin.so");
}
else
{
PrecompileForTargets = PrecompileTargetsType.None;
}
}
public IOSTapJoy(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Advertising",
"ApplicationCore",
// ... add private dependencies that you statically link with here ...
}
);
PublicIncludePathModuleNames.Add("Advertising");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
// Add the TapJoy framework
PublicAdditionalFrameworks.Add(
new Framework(
"TapJoy", // Framework name
"../../ThirdPartyFrameworks/Tapjoy.embeddedframework.zip", // Zip name
"Resources/TapjoyResources.bundle" // Resources we need copied and staged
)
);
PublicFrameworks.AddRange(
new string[]
{
"EventKit",
"MediaPlayer",
"AdSupport",
"CoreLocation",
"SystemConfiguration",
"MessageUI",
"Security",
"CoreTelephony",
"Twitter",
"Social"
}
);
}
public GraphEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/GraphEditor/Private",
"Editor/GraphEditor/Private/AnimationPins",
"Editor/GraphEditor/Private/AnimationStateNodes",
"Editor/GraphEditor/Private/KismetNodes",
"Editor/GraphEditor/Private/KismetPins",
"Editor/GraphEditor/Private/MaterialNodes",
"Editor/GraphEditor/Private/MaterialPins",
"Editor/GraphEditor/Private/SoundNodes",
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"IntroTutorials",
}
);
// PublicDependencyModuleNames.AddRange(
// new string[] {
// "AudioEditor"
// }
// );
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"EditorStyle",
"EditorWidgets",
"UnrealEd",
"AssetRegistry",
"ClassViewer",
"Kismet",
"KismetWidgets",
"BlueprintGraph",
"AnimGraph",
"Documentation",
"RenderCore",
"RHI",
}
);
// TODO: Move niagara code to niagara modules. This is temporarily necessary to fix the public include issues.
PrivateIncludePathModuleNames.AddRange(
new string[] {
"NiagaraEditor"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ContentBrowser",
}
);
}
public UnrealEd(TargetInfo Target)
{
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[]
{
"AssetRegistry",
"AssetTools",
"BehaviorTreeEditor",
"ClassViewer",
"ContentBrowser",
"CrashTracker",
"DerivedDataCache",
"DesktopPlatform",
"EnvironmentQueryEditor",
"GameProjectGeneration",
"ProjectTargetPlatformEditor",
"ImageWrapper",
"MainFrame",
"MaterialEditor",
"MergeActors",
"MeshUtilities",
"Messaging",
"MovieSceneCapture",
"NiagaraEditor",
"PlacementMode",
"Settings",
"SettingsEditor",
"SuperSearch",
"AudioEditor",
"ViewportSnapping",
"SourceCodeAccess",
"ReferenceViewer",
"IntroTutorials",
"OutputLog",
"Landscape",
"Niagara",
"SizeMap",
"LocalizationService",
"HierarchicalLODUtilities",
"MessagingRpc",
"PortalRpc",
"PortalServices",
"BlueprintNativeCodeGen",
"ViewportInteraction",
"VREditor",
"Persona",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"BspMode",
"Core",
"CoreUObject",
"DirectoryWatcher",
"Documentation",
"Engine",
"Json",
"Projects",
"SandboxFile",
"Slate",
"SlateCore",
"EditorStyle",
"SourceControl",
"UnrealEdMessages",
"AIModule",
"GameplayDebugger",
"BlueprintGraph",
"Http",
"UnrealAudio",
"FunctionalTesting",
"AutomationController",
"Internationalization",
"AudioEditor",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"LevelSequence",
"AnimGraph",
"AppFramework",
"BlueprintGraph",
"CinematicCamera",
"DesktopPlatform",
"EditorStyle",
"EngineSettings",
"InputCore",
"InputBindingEditor",
"LauncherServices",
"MaterialEditor",
"MessageLog",
"NetworkFileSystem",
"PakFile",
"PropertyEditor",
"Projects",
"RawMesh",
"RenderCore",
"RHI",
"ShaderCore",
"Sockets",
"SourceControlWindows",
"StatsViewer",
"SwarmInterface",
"TargetPlatform",
"TargetDeviceServices",
"EditorWidgets",
"GraphEditor",
"Kismet",
"InternationalizationSettings",
"JsonUtilities",
"Landscape",
"HeadMountedDisplay",
"MeshPaint",
"Foliage",
"VectorVM",
"TreeMap",
"MaterialUtilities",
"Localization",
"LocalizationService",
"AddContentDialog",
"GameProjectGeneration",
"HierarchicalLODUtilities",
"Analytics",
"AnalyticsET",
"PluginWarden",
"PixelInspectorModule",
"MovieScene",
"MovieSceneTracks",
"ViewportInteraction",
"VREditor"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"CrashTracker",
"FontEditor",
"StaticMeshEditor",
"TextureEditor",
"Cascade",
"UMGEditor",
"Matinee",
"AssetRegistry",
"AssetTools",
"ClassViewer",
"CollectionManager",
"ContentBrowser",
"CurveTableEditor",
"DataTableEditor",
"DestructibleMeshEditor",
"EditorSettingsViewer",
"LandscapeEditor",
"KismetCompiler",
"DetailCustomizations",
"ComponentVisualizers",
"MainFrame",
"LevelEditor",
"PackagesDialog",
"Persona",
"PhAT",
"ProjectLauncher",
"DeviceManager",
"SettingsEditor",
"SessionFrontend",
"Sequencer",
"SuperSearch",
"GeometryMode",
"TextureAlignMode",
"FoliageEdit",
"PackageDependencyInfo",
"ImageWrapper",
"Blutility",
"IntroTutorials",
"WorkspaceMenuStructure",
"PlacementMode",
"NiagaraEditor",
"MeshUtilities",
"MergeActors",
"ProjectSettingsViewer",
"ProjectTargetPlatformEditor",
"PListEditor",
"BehaviorTreeEditor",
"EnvironmentQueryEditor",
"ViewportSnapping",
"UserFeedback",
"GameplayTasksEditor",
"UndoHistory",
"SourceCodeAccess",
"ReferenceViewer",
"EditorLiveStreaming",
"HotReload",
"IOSPlatformEditor",
"HTML5PlatformEditor",
"SizeMap",
"PortalProxies",
"PortalServices",
"GeometryCacheEd",
"BlueprintNativeCodeGen",
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.Add("AndroidPlatformEditor");
}
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"GraphEditor",
"Kismet",
"AudioEditor"
}
);
// Add include directory for Lightmass
PublicIncludePaths.Add("Programs/UnrealLightmass/Public");
PublicIncludePathModuleNames.AddRange(
new string[] {
"UserFeedback",
"CollectionManager",
"BlueprintGraph",
"AddContentDialog",
"MeshUtilities"
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDependencyModuleNames.Add("XAudio2");
PublicDependencyModuleNames.Add("AudioMixerXAudio2");
PublicDependencyModuleNames.Add("UnrealAudioXAudio2");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"DX11Audio"
);
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicDependencyModuleNames.Add("UnrealAudioCoreAudio");
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PublicDependencyModuleNames.Add("ALAudio");
}
AddEngineThirdPartyPrivateStaticDependencies(Target,
"HACD",
"VHACD",
"FBX",
"FreeType2"
);
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
Definitions.Add("WITH_RECAST=1");
}
else
{
Definitions.Add("WITH_RECAST=0");
}
// @third party code - BEGIN HairWorks
AddEngineThirdPartyPrivateStaticDependencies(Target, "HairWorks");
// @third party code - END HairWorks
}
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 SimplygonSwarm(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.Add("Developer/SimplygonSwarm/Public");
PrivateIncludePaths.Add("Developer/SimplygonSwarm/Private");
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"InputCore",
"Json",
"RHI",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"RawMesh",
"MeshBoneReduction",
"ImageWrapper",
"HTTP",
"Json",
"UnrealEd",
"MaterialUtilities"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MeshUtilities",
"MaterialUtilities",
"SimplygonMeshReduction",
"MeshReductionInterface"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"MeshReductionInterface"
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "Simplygon");
AddEngineThirdPartyPrivateStaticDependencies(Target, "SSF");
AddEngineThirdPartyPrivateStaticDependencies(Target, "SPL");
AddEngineThirdPartyPrivateDynamicDependencies(Target, "PropertyEditor");
string SimplygonPath = Target.UEThirdPartySourceDirectory + "NotForLicensees/Simplygon/Simplygon-latest/Inc/SimplygonSDK.h";
if (Target.Platform == UnrealTargetPlatform.Win64 && File.Exists(SimplygonPath))
{
PrecompileForTargets = PrecompileTargetsType.Editor;
}
else
{
PrecompileForTargets = PrecompileTargetsType.None;
}
}
public Upsight(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
"../../../../Source/Runtime/Core/Public",
"../../../../Source/Runtime/Launch/Public"
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Upsight/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Settings"
}
);
PublicIncludePathModuleNames.Add("Launch");
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"UpsightKit",
"../../lib/iOS/UpsightKit.embeddedframework.zip"
)
);
PublicFrameworks.AddRange(
new string[]
{
"CoreData",
"SystemConfiguration",
"CoreTelephony",
"AdSupport"
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, BuildConfiguration.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "Upsight_APL.xml")));
}
}
public Voice(ReadOnlyTargetRules Target) : base(Target)
{
PublicDefinitions.Add("VOICE_PACKAGE=1");
bool bDontNeedCapture = (Target.Type == TargetType.Server);
if (bDontNeedCapture)
{
PublicDefinitions.Add("VOICE_MODULE_WITH_CAPTURE=0");
}
else
{
PublicDefinitions.Add("VOICE_MODULE_WITH_CAPTURE=1");
}
PublicIncludePathModuleNames.AddRange(
new string[] {
"AndroidPermission"
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Engine",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Online/Voice/Private",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"AudioMixer",
"SignalProcessing"
}
);
if (Target.Platform.IsInGroup(UnrealPlatformGroup.Windows))
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectSound");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.AddRange(new string[] { "CoreAudio", "AudioUnit", "AudioToolbox" });
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Linux) && !bDontNeedCapture)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "libOpus");
if (Target.Platform == UnrealTargetPlatform.Android)
{
string ModulePath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(ModulePath, "AndroidVoiceImpl_UPL.xml"));
}
}
public OodleHandlerComponent(ReadOnlyTargetRules Target) : base(Target)
{
ShortName = "OodleHC";
BinariesSubFolder = "NotForLicensees";
PrivateIncludePaths.Add("OodleHandlerComponent/Private");
PublicDependencyModuleNames.AddRange(
new string[]
{
"PacketHandler",
"Core",
"CoreUObject",
"Engine",
"Analytics"
});
bool bHaveOodleSDK = false;
string OodleNotForLicenseesLibDir = "";
// Check the NotForLicensees folder first
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "win", "lib");
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "linux", "lib");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "ps4", "lib");
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "XboxOne", "lib");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "Mac", "lib");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "Android", "lib");
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "IOS", "lib");
}
if (OodleNotForLicenseesLibDir.Length > 0)
{
try
{
bHaveOodleSDK = System.IO.Directory.Exists(OodleNotForLicenseesLibDir);
}
catch (System.Exception)
{
}
}
if (bHaveOodleSDK)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Oodle");
PublicIncludePathModuleNames.Add("Oodle");
PublicDefinitions.Add("HAS_OODLE_SDK=1");
}
else
{
PublicDefinitions.Add("HAS_OODLE_SDK=0");
}
}
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);
}
// NVCHANGE_BEGIN: Add VXGI
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDependencyModuleNames.Add("VXGI");
}
// NVCHANGE_END: Add VXGI
// @third party code - BEGIN HairWorks
AddEngineThirdPartyPrivateStaticDependencies(Target, "HairWorks");
// @third party code - END HairWorks
}
public LevelEditor(TargetInfo Target)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetTools",
"ClassViewer",
"MainFrame",
"PlacementMode",
"ReferenceViewer",
"SizeMap",
"SlateReflector",
"IntroTutorials",
"AppFramework",
"PortalServices"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"Settings",
"UserFeedback",
"IntroTutorials",
"HeadMountedDisplay",
"VREditor"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"LevelSequence",
"Analytics",
"Core",
"CoreUObject",
"DesktopPlatform",
"InputCore",
"Slate",
"SlateCore",
"EditorStyle",
"Engine",
"MessageLog",
"SourceControl",
"SourceControlWindows",
"StatsViewer",
"UnrealEd",
"RenderCore",
"DeviceProfileServices",
"ContentBrowser",
"SceneOutliner",
"ActorPickerMode",
"RHI",
"Projects",
"TargetPlatform",
"EngineSettings",
"PropertyEditor",
"WebBrowser",
"Persona",
"Kismet",
"KismetWidgets",
"Sequencer",
"Foliage",
"HierarchicalLODOutliner",
"HierarchicalLODUtilities",
"MaterialShaderQualitySettings",
"PixelInspectorModule",
"FunctionalTesting"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MainFrame",
"ClassViewer",
"DeviceManager",
"SettingsEditor",
"SessionFrontend",
"SlateReflector",
"AutomationWindow",
"Layers",
"WorldBrowser",
"EditorWidgets",
"AssetTools",
"WorkspaceMenuStructure",
"NewLevelDialog",
"DeviceProfileEditor",
"PlacementMode",
"UserFeedback",
"ReferenceViewer",
"SizeMap",
"IntroTutorials",
"HeadMountedDisplay",
"VREditor"
}
);
}
public OculusHMD(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
// Relative to Engine\Plugins\Runtime\Oculus\OculusVR\Source
"../../../../../Source/Runtime/Renderer/Private",
"../../../../../Source/Runtime/OpenGLDrv/Private",
"../../../../../Source/Runtime/VulkanRHI/Private",
"../../../../../Source/Runtime/Engine/Classes/Components",
"../../../../../Source/Runtime/Engine/Classes/Kismet",
});
PublicIncludePathModuleNames.AddRange(
new string[] {
"Launch",
"ProceduralMeshComponent",
});
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateIncludePaths.Add("../../../../../Source/Runtime/VulkanRHI/Private/Windows");
}
else
{
PrivateIncludePaths.Add("../../../../../Source/Runtime/VulkanRHI/Private/" + Target.Platform);
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"RHI",
"RenderCore",
"Renderer",
"Slate",
"SlateCore",
"ImageWrapper",
"MediaAssets",
"Analytics",
"UtilityShaders",
"OpenGLDrv",
"VulkanRHI",
"OVRPlugin",
"ProceduralMeshComponent",
"Projects",
});
PublicDependencyModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay",
});
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
// D3D
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"D3D11RHI",
"D3D12RHI",
});
PrivateIncludePaths.AddRange(
new string[]
{
"OculusMR/Public",
"../../../../../Source/Runtime/Windows/D3D11RHI/Private",
"../../../../../Source/Runtime/Windows/D3D11RHI/Private/Windows",
"../../../../../Source/Runtime/D3D12RHI/Private",
"../../../../../Source/Runtime/D3D12RHI/Private/Windows",
});
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX12");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAPI");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11Audio");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectSound");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAftermath");
AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelMetricsDiscovery");
}
// Vulkan
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
}
// OVRPlugin
{
PublicDelayLoadDLLs.Add("OVRPlugin.dll");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Oculus/OVRPlugin/OVRPlugin/" + Target.Platform.ToString() + "/OVRPlugin.dll");
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
// We are not currently supporting Mixed Reality on Android, but we need to include IOculusMRModule.h for OCULUS_MR_SUPPORTED_PLATFORMS definition
PrivateIncludePaths.AddRange(
new string[]
{
"OculusMR/Public"
});
// Vulkan
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
}
// AndroidPlugin
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "GearVR_APL.xml"));
}
}
}
public IOSApsalar(TargetInfo Target)
{
BinariesSubFolder = "NotForLicensees";
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Analytics",
// ... add private dependencies that you statically link with here ...
}
);
PublicIncludePathModuleNames.Add("Analytics");
PublicFrameworks.AddRange(
new string[] {
"CoreTelephony",
"SystemConfiguration",
"UIKit",
"Foundation",
"CoreGraphics",
"MobileCoreServices",
"StoreKit",
"CFNetwork",
"CoreData",
"Security",
"CoreLocation"
});
PublicAdditionalLibraries.AddRange(
new string[] {
"sqlite3",
"z"
});
bool bHasApsalarSDK =
(System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "Apsalar")) &&
System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "Apsalar", "IOS"))) ||
(System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "NotForLicensees")) &&
System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "NotForLicensees", "Apsalar")) &&
System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "NotForLicensees", "Apsalar", "IOS")));
if (bHasApsalarSDK)
{
PublicIncludePaths.Add(UEBuildConfiguration.UEThirdPartySourceDirectory + "NotForLicensees/Apsalar/IOS/");
PublicAdditionalLibraries.Add(UEBuildConfiguration.UEThirdPartySourceDirectory + "NotForLicensees/Apsalar/IOS/libApsalar.a");
Definitions.Add("WITH_APSALAR=1");
}
else
{
Definitions.Add("WITH_APSALAR=0");
}
}
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 ApplicationCore(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Core"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"RHI"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"InputDevice",
"Analytics",
"SynthBenchmark"
}
);
if ((Target.IsInPlatformGroup(UnrealPlatformGroup.Windows)))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"XInput"
);
if (Target.bCompileWithAccessibilitySupport && !Target.bIsBuildingConsoleApplication)
{
PublicSystemLibraries.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.IsInPlatformGroup(UnrealPlatformGroup.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.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 Engine(TargetInfo Target)
{
SharedPCHHeaderFile = "Runtime/Engine/Public/Engine.h";
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler" });
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",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"RenderCore",
"RHI",
"ShaderCore",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"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("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",
"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 Engine(TargetInfo Target)
{
SharedPCHHeaderFile = "Runtime/Engine/Public/Engine.h";
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/Online/OnlineSubsystem/Public",
"Runtime/Online/OnlineSubsystemUtils/Public",
"Developer/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"CrashTracker",
"OnlineSubsystem",
"TargetPlatform",
"ImageWrapper",
"HeadMountedDisplay",
"Advertising",
"NetworkReplayStreaming"
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
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",
"VectorVM",
"DatabaseSupport",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Sockets",
"SlateReflector",
"VectorVM",
"Landscape",
"UMG",
"Projects"
}
);
CircularlyReferencedDependentModules.Add("AIModule");
CircularlyReferencedDependentModules.Add("Landscape");
CircularlyReferencedDependentModules.Add("UMG");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"MovieSceneCore",
"MovieSceneCoreTypes",
"HeadMountedDisplay",
"StreamingPauseRendering",
}
);
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateRHIRenderer",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateRHIRenderer",
}
);
}
if (Target.Type == TargetRules.TargetType.Server)
{
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",
"DesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform",
"DesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"DesktopTargetPlatform",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Analytics",
"AnalyticsET",
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"OnlineSubsystem",
"OnlineSubsystemUtils",
"Advertising"
}
);
if (Target.Type.Value != TargetRules.TargetType.Server)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"CrashTracker",
"ImageWrapper",
"GameLiveStreaming"
}
);
}
if (!UEBuildConfiguration.bBuildRequiresCookedData && UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"DerivedDataCache",
"TargetPlatform"
}
);
}
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 us 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 PropertyEditor(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"ActorPickerMode",
"SceneDepthPickerMode",
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"IntroTutorials"
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Editor/PropertyEditor/Private",
"Editor/PropertyEditor/Private/Presentation",
"Editor/PropertyEditor/Private/Presentation/PropertyTable",
"Editor/PropertyEditor/Private/Presentation/PropertyEditor",
"Editor/PropertyEditor/Private/Presentation/PropertyDetails",
"Editor/PropertyEditor/Private/UserInterface",
"Editor/PropertyEditor/Private/UserInterface/PropertyTable",
"Editor/PropertyEditor/Private/UserInterface/PropertyEditor",
"Editor/PropertyEditor/Private/UserInterface/PropertyTree",
"Editor/PropertyEditor/Private/UserInterface/PropertyDetails",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MainFrame",
"AssetRegistry",
"AssetTools",
"ClassViewer",
"ContentBrowser",
"ConfigEditor",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"EditorStyle",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"EditorWidgets",
"Documentation",
"RHI",
"ConfigEditor",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"ClassViewer",
"ContentBrowser",
"MainFrame",
}
);
}
public Sequencer(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/Sequencer/Private",
"Editor/Sequencer/Private/DisplayNodes",
"Editor/UnrealEd/Private" // TODO: Fix this, for now it's needed for the fbx exporter
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"TimeManagement",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"ApplicationCore",
"AssetRegistry",
"CinematicCamera",
"ContentBrowser",
"Core",
"CoreUObject",
"CurveEditor",
"InputCore",
"Engine",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"MovieScene",
"MovieSceneTracks",
"MovieSceneTools",
"MovieSceneCapture",
"MovieSceneCaptureDialog",
"EditorWidgets",
"SequencerWidgets",
"BlueprintGraph",
"LevelSequence",
"GraphEditor",
"ViewportInteraction",
"SerializedRecorderInterface",
"ToolMenus",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"ViewportInteraction",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"ContentBrowser",
"PropertyEditor",
"Kismet",
"SequenceRecorder",
"LevelEditor",
"MainFrame",
"DesktopPlatform",
"SerializedRecorderInterface"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"PropertyEditor",
"SceneOutliner",
"CurveEditor",
"Analytics",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"PropertyEditor",
"LevelEditor",
"SceneOutliner",
"WorkspaceMenuStructure",
"SequenceRecorder",
"SequenceRecorderSections",
"MainFrame",
}
);
CircularlyReferencedDependentModules.Add("MovieSceneTools");
AddEngineThirdPartyPrivateStaticDependencies(Target, "FBX");
}
public UnLua(ReadOnlyTargetRules Target) : base(Target)
{
bEnforceIWYU = false;
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
}
);
PrivateIncludePaths.AddRange(
new string[] {
"UnLua/Private",
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"ApplicationCore",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Slate",
"InputCore",
"Projects",
"Lua",
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
}
bool bAutoStartup = true;
if (bAutoStartup)
{
PublicDefinitions.Add("AUTO_UNLUA_STARTUP=1");
}
bool bWithUE4Namespace = false;
if (bWithUE4Namespace)
{
PublicDefinitions.Add("WITH_UE4_NAMESPACE=1");
}
bool bSupportsRpcCall = false;
if (bSupportsRpcCall)
{
PublicDefinitions.Add("SUPPORTS_RPC_CALL=1");
}
}
public Engine(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("../Shaders/Shared");
PrivatePCHHeaderFile = "Private/EnginePrivatePCH.h";
SharedPCHHeaderFile = "Public/EngineSharedPCH.h";
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "AudioMixer", "AudioMixerCore", "AnimationCore" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"ImageWrapper",
"ImageWriteQueue",
"HeadMountedDisplay",
"EyeTracker",
"MRMesh",
"Advertising",
"MovieSceneCapture",
"AutomationWorker",
"MovieSceneCapture",
"DesktopPlatform",
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TaskGraph",
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"EditorAnalyticsSession",
}
);
}
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"NetCore",
"ApplicationCore",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"MessagingCommon",
"RenderCore",
"RHI",
"Sockets",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"GameplayTags",
"PacketHandler",
"AudioPlatformConfiguration",
"MeshDescription",
"StaticMeshDescription",
"PakFile",
"NetworkReplayStreaming",
"PhysicsCore",
"SignalProcessing"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Landscape",
"UMG",
"Projects",
"MaterialShaderQualitySettings",
"CinematicCamera",
"Analytics",
"AnalyticsET",
"AudioMixer",
"AudioMixerCore",
"SignalProcessing",
"CrunchCompression",
}
);
// Cross platform Audio Codecs:
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
DynamicallyLoadedModuleNames.Add("EyeTracker");
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");
PrivateDependencyModuleNames.Add("MeshDescriptionOperations");
}
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("Landscape");
CircularlyReferencedDependentModules.Add("UMG");
CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings");
CircularlyReferencedDependentModules.Add("CinematicCamera");
CircularlyReferencedDependentModules.Add("AudioMixer");
if (Target.Type == TargetType.Editor)
{
PrivateIncludePathModuleNames.Add("Foliage");
}
// 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",
"LevelSequence",
"HeadMountedDisplay",
"MRMesh",
"StreamingPauseRendering",
}
);
if (Target.Type != TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Media",
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
if (Target.Type == TargetType.Server || Target.Type == TargetType.Editor)
{
PrivateDependencyModuleNames.Add("PerfCounters");
}
if (Target.Type == TargetType.Editor)
{
PrivateIncludePathModuleNames.Add("MeshUtilities");
PrivateIncludePathModuleNames.Add("MeshUtilitiesCommon");
DynamicallyLoadedModuleNames.Add("MeshUtilities");
PrivateDependencyModuleNames.AddRange(
new string[] {
"ImageCore",
"RawMesh"
}
);
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.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxAArch64NoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"LinuxAArch64ServerTargetPlatform",
"LinuxClientTargetPlatform",
"LinuxAArch64ClientTargetPlatform",
"AllDesktopTargetPlatform",
"LinuxPlatformEditor",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"NullNetworkReplayStreaming",
"LocalFileNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"Advertising"
}
);
if (Target.bWithLiveCoding)
{
DynamicallyLoadedModuleNames.Add("LiveCoding");
}
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");
}
SetupModulePhysicsSupport(Target);
if (Target.bCompilePhysX && (Target.bBuildEditor || Target.bCompileAPEX))
{
DynamicallyLoadedModuleNames.Add("PhysXCooking");
}
PublicDependencyModuleNames.AddRange(
new string[] {
"PhysicsSQ",
"ChaosSolvers"
}
);
// 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))
{
// Head Mounted Display support
// PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
// DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
PrivateDependencyModuleNames.Add("AndroidRuntimeSettings");
}
if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PrivateDependencyModuleNames.Add("IOSRuntimeSettings");
}
if (Target.Platform == UnrealTargetPlatform.Switch)
{
PrivateDependencyModuleNames.Add("SwitchRuntimeSettings");
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
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);
}
}
