public SpatialGDK(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[]
{
"Public",
"Public/WorkerSdk",
"Generated/Cpp",
"Generated/UClasses",
});
PrivateIncludePaths.Add("Private");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"EngineSettings",
"Projects",
"OnlineSubsystemUtils",
"InputCore",
"Sockets",
});
// Check if we're building in the editor.
if (Target.bBuildEditor)
{
// Required by USpatialGameInstance::StartPlayInEditorGameInstance.
PublicDependencyModuleNames.Add("UnrealEd");
}
var CoreSdkLibraryDir = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "Binaries", "ThirdParty", "Improbable", Target.Platform.ToString()));
string LibPrefix = "";
string ImportLibSuffix = "";
string SharedLibSuffix = "";
bool bAddDelayLoad = false;
switch (Target.Platform)
{
case UnrealTargetPlatform.Win32:
case UnrealTargetPlatform.Win64:
ImportLibSuffix = ".lib";
SharedLibSuffix = ".dll";
bAddDelayLoad = true;
break;
case UnrealTargetPlatform.Mac:
LibPrefix = "lib";
ImportLibSuffix = SharedLibSuffix = ".dylib";
break;
case UnrealTargetPlatform.Linux:
LibPrefix = "lib";
ImportLibSuffix = SharedLibSuffix = ".so";
break;
case UnrealTargetPlatform.PS4:
LibPrefix = "lib";
ImportLibSuffix = "_stub.a";
SharedLibSuffix = ".prx";
bAddDelayLoad = true;
break;
case UnrealTargetPlatform.XboxOne:
ImportLibSuffix = ".lib";
SharedLibSuffix = ".dll";
break;
default:
throw new System.Exception(System.String.Format("Unsupported platform {0}", Target.Platform.ToString()));
}
string CoreSdkImportLib = System.String.Format("{0}worker{1}", LibPrefix, ImportLibSuffix);
string CoreSdkSharedLib = System.String.Format("{0}worker{1}", LibPrefix, SharedLibSuffix);
PublicAdditionalLibraries.AddRange(new[] { Path.Combine(CoreSdkLibraryDir, CoreSdkImportLib) });
RuntimeDependencies.Add(Path.Combine(CoreSdkLibraryDir, CoreSdkSharedLib), StagedFileType.NonUFS);
PublicLibraryPaths.Add(CoreSdkLibraryDir);
if (bAddDelayLoad)
{
PublicDelayLoadDLLs.Add(CoreSdkSharedLib);
}
// Point generated code to the correct API spec.
PublicDefinitions.Add("IMPROBABLE_DLL_API=SPATIALGDK_API");
}
public Core(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/CorePrivatePCH.h";
SharedPCHHeaderFile = "Public/CoreSharedPCH.h";
bAddDefaultIncludePaths = false;
PublicIncludePaths.AddRange(
new string[] {
"Runtime/Core/Public",
"Runtime/Core/Public/Internationalization",
"Runtime/Core/Public/Async",
"Runtime/Core/Public/Concurrency",
"Runtime/Core/Public/Containers",
"Runtime/Core/Public/Delegates",
"Runtime/Core/Public/GenericPlatform",
"Runtime/Core/Public/HAL",
"Runtime/Core/Public/Logging",
"Runtime/Core/Public/Math",
"Runtime/Core/Public/Misc",
"Runtime/Core/Public/Modules",
"Runtime/Core/Public/Modules/Boilerplate",
"Runtime/Core/Public/ProfilingDebugging",
"Runtime/Core/Public/Serialization",
"Runtime/Core/Public/Serialization/Csv",
"Runtime/Core/Public/Stats",
"Runtime/Core/Public/Templates",
"Runtime/Core/Public/UObject",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Core/Private",
"Runtime/Core/Private/Misc",
"Runtime/Core/Private/Serialization/Json",
"Runtime/Core/Private/Internationalization",
"Runtime/Core/Private/Internationalization/Cultures",
"Runtime/Analytics/Public",
"Runtime/Engine/Public",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"DerivedDataCache",
"InputDevice",
"Analytics",
"RHI"
}
);
if (Target.bBuildEditor == true)
{
DynamicallyLoadedModuleNames.Add("SourceCodeAccess");
PrivateIncludePathModuleNames.Add("DirectoryWatcher");
DynamicallyLoadedModuleNames.Add("DirectoryWatcher");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
PublicIncludePaths.Add("Runtime/Core/Public/Windows");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB"
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicIncludePaths.AddRange(new string[] { "Runtime/Core/Public/Apple", "Runtime/Core/Public/Mac" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"zlib",
"PLCrashReporter"
);
PublicFrameworks.AddRange(new string[] { "Cocoa", "Carbon", "IOKit", "Security" });
if (Target.bBuildEditor == true)
{
PublicAdditionalLibraries.Add("/System/Library/PrivateFrameworks/MultitouchSupport.framework/Versions/Current/MultitouchSupport");
}
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PublicIncludePaths.AddRange(new string[] { "Runtime/Core/Public/Apple", "Runtime/Core/Public/IOS" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib"
);
PublicFrameworks.AddRange(new string[] { "UIKit", "Foundation", "AudioToolbox", "AVFoundation", "GameKit", "StoreKit", "CoreVideo", "CoreMedia", "CoreGraphics", "GameController", "SystemConfiguration" });
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.AddRange(new string[] { "CoreMotion", "AdSupport" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"PLCrashReporter"
);
}
PrivateIncludePathModuleNames.Add("ApplicationCore");
bool bSupportAdvertising = Target.Platform == UnrealTargetPlatform.IOS;
if (bSupportAdvertising)
{
PublicFrameworks.AddRange(new string[] { "iAD" });
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicIncludePaths.Add("Runtime/Core/Public/Android");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"cxademangle",
"zlib"
);
}
else if ((Target.Platform == UnrealTargetPlatform.Linux))
{
PublicIncludePaths.Add("Runtime/Core/Public/Linux");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib",
"jemalloc",
"elftoolchain"
);
// Core uses dlopen()
PublicAdditionalLibraries.Add("dl");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PrivateDependencyModuleNames.Add("HTML5JS");
PrivateDependencyModuleNames.Add("MapPakDownloader");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicAdditionalLibraries.Add("SceRtc_stub_weak"); //ORBIS SDK rtc.h, used in PS4Time.cpp
}
if (Target.bCompileICU == true)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "ICU");
}
Definitions.Add("UE_ENABLE_ICU=" + (Target.bCompileICU ? "1" : "0")); // Enable/disable (=1/=0) ICU usage in the codebase. NOTE: This flag is for use while integrating ICU and will be removed afterward.
// If we're compiling with the engine, then add Core's engine dependencies
if (Target.bCompileAgainstEngine == true)
{
if (!Target.bBuildRequiresCookedData)
{
DynamicallyLoadedModuleNames.AddRange(new string[] { "DerivedDataCache" });
}
}
// On Windows platform, VSPerfExternalProfiler.cpp needs access to "VSPerf.h". This header is included with Visual Studio, but it's not in a standard include path.
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
var VisualStudioVersionNumber = "11.0";
var SubFolderName = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64/PerfSDK" : "PerfSDK";
string PerfIncludeDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), String.Format("Microsoft Visual Studio {0}/Team Tools/Performance Tools/{1}", VisualStudioVersionNumber, SubFolderName));
if (File.Exists(Path.Combine(PerfIncludeDirectory, "VSPerf.h")))
{
PrivateIncludePaths.Add(PerfIncludeDirectory);
Definitions.Add("WITH_VS_PERF_PROFILER=1");
}
else
{
Definitions.Add("WITH_VS_PERF_PROFILER=0");
}
}
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
WhitelistRestrictedFolders.Add("Private/Windows/NoRedist");
}
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
Definitions.Add("WITH_DIRECTXMATH=1");
}
else if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
// To enable this requires Win8 SDK
Definitions.Add("WITH_DIRECTXMATH=0"); // Enable to test on Win64/32.
//PublicDependencyModuleNames.AddRange( // Enable to test on Win64/32.
// new string[] {
// "DirectXMath"
//});
}
else
{
Definitions.Add("WITH_DIRECTXMATH=0");
}
// NVCHANGE_BEGIN: Add VXGI
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDependencyModuleNames.Add("VXGI");
}
// NVCHANGE_END: Add VXGI
}
public SpatialGDK(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
bFasterWithoutUnity = true;
PrivateIncludePaths.Add("SpatialGDK/Private");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"EngineSettings",
"Projects",
"OnlineSubsystemUtils",
"InputCore",
"Sockets",
});
if (Target.bBuildEditor)
{
PublicDependencyModuleNames.Add("UnrealEd");
PublicDependencyModuleNames.Add("SpatialGDKEditorToolbar");
}
var WorkerLibraryDir = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "Binaries", "ThirdParty", "Improbable", Target.Platform.ToString()));
string LibPrefix = "";
string ImportLibSuffix = "";
string SharedLibSuffix = "";
bool bAddDelayLoad = false;
switch (Target.Platform)
{
case UnrealTargetPlatform.Win32:
case UnrealTargetPlatform.Win64:
ImportLibSuffix = ".lib";
SharedLibSuffix = ".dll";
bAddDelayLoad = true;
break;
case UnrealTargetPlatform.Mac:
LibPrefix = "lib";
ImportLibSuffix = SharedLibSuffix = ".dylib";
break;
case UnrealTargetPlatform.Linux:
LibPrefix = "lib";
ImportLibSuffix = SharedLibSuffix = ".so";
break;
case UnrealTargetPlatform.PS4:
LibPrefix = "lib";
ImportLibSuffix = "_stub.a";
SharedLibSuffix = ".prx";
bAddDelayLoad = true;
break;
case UnrealTargetPlatform.XboxOne:
ImportLibSuffix = ".lib";
SharedLibSuffix = ".dll";
// We don't set bAddDelayLoad = true here, because we get "unresolved external symbol __delayLoadHelper2".
// See: https://www.fmod.org/questions/question/deploy-issue-on-xboxone-with-unrealengine-4-14/
break;
case UnrealTargetPlatform.IOS:
LibPrefix = "lib";
ImportLibSuffix = SharedLibSuffix = "_static_fullylinked.a";
break;
default:
throw new System.Exception(System.String.Format("Unsupported platform {0}", Target.Platform.ToString()));
}
string WorkerImportLib = System.String.Format("{0}worker{1}", LibPrefix, ImportLibSuffix);
string WorkerSharedLib = System.String.Format("{0}worker{1}", LibPrefix, SharedLibSuffix);
PublicAdditionalLibraries.AddRange(new[] { Path.Combine(WorkerLibraryDir, WorkerImportLib) });
PublicLibraryPaths.Add(WorkerLibraryDir);
RuntimeDependencies.Add(Path.Combine(WorkerLibraryDir, WorkerSharedLib), StagedFileType.NonUFS);
if (bAddDelayLoad)
{
PublicDelayLoadDLLs.Add(WorkerSharedLib);
}
}
public Engine(TargetInfo Target)
{
PrivatePCHHeaderFile = "Private/EnginePrivatePCH.h";
SharedPCHHeaderFile = "Public/EngineSharedPCH.h";
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "NetworkReplayStreaming" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"ImageWrapper",
"HeadMountedDisplay",
"Advertising",
"NetworkReplayStreaming",
"MovieSceneCapture",
"AutomationWorker",
"MovieSceneCapture",
"DesktopPlatform",
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
}
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"RenderCore",
"RHI",
"ShaderCore",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"GameplayTags",
"AIModule",
"DatabaseSupport",
"PacketHandler",
"HardwareSurvey",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "CrashTracker" });
DynamicallyLoadedModuleNames.AddRange(new string[] { "CrashTracker" });
PublicDependencyModuleNames.AddRange(
new string[] {
}
);
}
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Sockets",
"Landscape",
"UMG",
"Projects",
"Internationalization",
"MaterialShaderQualitySettings",
"CinematicCamera",
"Analytics",
"AnalyticsET",
}
);
// to prevent "causes WARNING: Non-editor build cannot depend on non-redistributable modules."
if (Target.Type == TargetRules.TargetType.Editor)
{
// for now we depend on this
PrivateDependencyModuleNames.Add("RawMesh");
}
bool bVariadicTemplatesSupported = true;
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Use reflection to allow type not to exist if console code is not present
System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool");
if (XboxOnePlatformType != null)
{
System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
if (VersionName.ToString().Equals("2012"))
{
bVariadicTemplatesSupported = false;
}
}
}
if (bVariadicTemplatesSupported)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
// these modules require variadic templates
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
}
}
CircularlyReferencedDependentModules.Add("GameplayTags");
CircularlyReferencedDependentModules.Add("AIModule");
CircularlyReferencedDependentModules.Add("Landscape");
CircularlyReferencedDependentModules.Add("UMG");
CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings");
CircularlyReferencedDependentModules.Add("CinematicCamera");
// The AnimGraphRuntime module is not needed by Engine proper, but it is loaded in LaunchEngineLoop.cpp,
// and needs to be listed in an always-included module in order to be compiled into standalone games
DynamicallyLoadedModuleNames.Add("AnimGraphRuntime");
// So does Geometry Cache
DynamicallyLoadedModuleNames.Add("GeometryCache");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"ActorSequence",
"MovieScene",
"MovieSceneCapture",
"MovieSceneTracks",
"HeadMountedDisplay",
"StreamingPauseRendering",
}
);
PrivateIncludePathModuleNames.Add("LightPropagationVolumeRuntime");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
if (Target.Type == TargetRules.TargetType.Server || Target.Type == TargetRules.TargetType.Editor)
{
PrivateDependencyModuleNames.Add("PerfCounters");
}
if (UEBuildConfiguration.bBuildDeveloperTools)
{
// Add "BlankModule" so that it gets compiled as an example and will be maintained and tested. This can be removed
// at any time if needed. The module isn't actually loaded by the engine so there is no runtime cost.
DynamicallyLoadedModuleNames.Add("BlankModule");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.Add("MeshUtilities");
DynamicallyLoadedModuleNames.Add("MeshUtilities");
PrivateDependencyModuleNames.AddRange(
new string[] {
"ImageCore",
"RawMesh"
});
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test && Target.Type != TargetRules.TargetType.Server)
{
PrivateDependencyModuleNames.Add("CollisionAnalyzer");
CircularlyReferencedDependentModules.Add("CollisionAnalyzer");
PrivateDependencyModuleNames.Add("LogVisualizer");
CircularlyReferencedDependentModules.Add("LogVisualizer");
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WindowsTargetPlatform",
"WindowsNoEditorTargetPlatform",
"WindowsServerTargetPlatform",
"WindowsClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"LinuxClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"Advertising"
}
);
if (Target.Type.Value != TargetRules.TargetType.Server)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ImageWrapper",
"GameLiveStreaming"
}
);
}
if (!UEBuildConfiguration.bBuildRequiresCookedData && UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"DerivedDataCache",
"TargetPlatform",
"DesktopPlatform"
}
);
}
if (UEBuildConfiguration.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
); // @todo api: Only public because of WITH_EDITOR and UNREALED_API
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
);
PrivateIncludePathModuleNames.Add("TextureCompressor");
PrivateIncludePaths.Add("Developer/TextureCompressor/Public");
PrivateIncludePathModuleNames.Add("HierarchicalLODUtilities");
DynamicallyLoadedModuleNames.Add("HierarchicalLODUtilities");
}
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompilePhysX && UEBuildConfiguration.bRuntimePhysicsCooking)
{
DynamicallyLoadedModuleNames.Add("PhysXFormats");
PrivateIncludePathModuleNames.Add("PhysXFormats");
}
SetupModuleBox2DSupport(Target);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus",
"OpenSubdiv"
);
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectShow");
}
// Head Mounted Display support
// PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
// DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32")
{
PublicDependencyModuleNames.Add("HTML5JS");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"libOpus"
);
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
if (UEBuildConfiguration.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
Definitions.Add("WITH_RECAST=1");
}
else
{
// Because we test WITH_RECAST in public Engine header files, we need to make sure that modules
// that import this also have this definition set appropriately. Recast is a private dependency
// module, so it's definitions won't propagate to modules that import Engine.
Definitions.Add("WITH_RECAST=0");
}
// Add a reference to the stats HTML files referenced by UEngine::DumpFPSChartToHTML. Previously staged by CopyBuildToStagingDirectory.
if (UEBuildConfiguration.bBuildEditor || Target.Configuration != UnrealTargetConfiguration.Shipping)
{
RuntimeDependencies.Add("$(EngineDir)/Content/Stats/...", StagedFileType.UFS);
}
DynamicallyLoadedModuleNames.Add("Niagara");
}
public Launch(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Runtime/Launch/Private");
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AutomationController",
"Media",
"MediaUtils",
"TaskGraph",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"MoviePlayer",
"Networking",
"PakFile",
"Projects",
"RenderCore",
"RHI",
"SandboxFile",
"Serialization",
"ShaderCore",
"ApplicationCore",
"Slate",
"SlateCore",
"Sockets",
"Overlay",
"UtilityShaders",
}
);
// Enable the LauncherCheck module to be used for platforms that support the Launcher.
// Projects should set Target.bUseLauncherChecks in their Target.cs to enable the functionality.
if (Target.bUseLauncherChecks &&
((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Mac)))
{
PrivateDependencyModuleNames.Add("LauncherCheck");
Definitions.Add("WITH_LAUNCHERCHECK=1");
}
else
{
Definitions.Add("WITH_LAUNCHERCHECK=0");
}
if (Target.Type != TargetType.Server)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"HeadMountedDisplay",
"MRMesh",
}
);
if ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64))
{
DynamicallyLoadedModuleNames.Add("D3D12RHI");
DynamicallyLoadedModuleNames.Add("D3D11RHI");
DynamicallyLoadedModuleNames.Add("XAudio2");
DynamicallyLoadedModuleNames.Add("AudioMixerXAudio2");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.Add("CoreAudio");
DynamicallyLoadedModuleNames.Add("AudioMixerAudioUnit");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.Add("ALAudio");
DynamicallyLoadedModuleNames.Add("AudioMixerSDL");
PrivateDependencyModuleNames.Add("Json");
}
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
// UFS clients are not available in shipping builds
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"NetworkFile",
"StreamingFile",
"CookedIterativeFile",
"AutomationWorker",
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
"Renderer",
}
);
if (Target.bCompileAgainstEngine)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MessagingCommon",
"MediaAssets"
}
);
PublicDependencyModuleNames.Add("SessionServices");
PrivateIncludePaths.Add("Developer/DerivedDataCache/Public");
// LaunchEngineLoop.cpp will still attempt to load XMPP but not all projects require it so it will silently fail unless referenced by the project's build.cs file.
// DynamicallyLoadedModuleNames.Add("XMPP");
DynamicallyLoadedModuleNames.Add("HTTP");
PrivateDependencyModuleNames.Add("ClothingSystemRuntimeInterface");
PrivateDependencyModuleNames.Add("ClothingSystemRuntime");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PublicIncludePathModuleNames.Add("ProfilerService");
DynamicallyLoadedModuleNames.AddRange(new string[] { "TaskGraph", "RealtimeProfiler", "ProfilerService" });
}
// The engine can use AutomationController in any connfiguration besides shipping. This module is loaded
// dynamically in LaunchEngineLoop.cpp in non-shipping configurations
if (Target.bCompileAgainstEngine && Target.Configuration != UnrealTargetConfiguration.Shipping)
{
DynamicallyLoadedModuleNames.AddRange(new string[] { "AutomationController" });
}
if (Target.bBuildEditor == true)
{
PublicIncludePathModuleNames.Add("ProfilerClient");
PrivateDependencyModuleNames.AddRange(
new string[] {
"SourceControl",
"UnrealEd",
"DesktopPlatform",
"PIEPreviewDeviceProfileSelector",
}
);
// ExtraModules that are loaded when WITH_EDITOR=1 is true
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AutomationWindow",
"ProfilerClient",
"Toolbox",
"GammaUI",
"ModuleUI",
"OutputLog",
"TextureCompressor",
"MeshUtilities",
"SourceCodeAccess"
}
);
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PrivateDependencyModuleNames.Add("MainFrame");
PrivateDependencyModuleNames.Add("Settings");
}
else
{
DynamicallyLoadedModuleNames.Add("MainFrame");
}
}
if (Target.Platform == UnrealTargetPlatform.IOS ||
Target.Platform == UnrealTargetPlatform.TVOS)
{
PrivateDependencyModuleNames.Add("OpenGLDrv");
PrivateDependencyModuleNames.Add("IOSAudio");
PrivateDependencyModuleNames.Add("AudioMixerAudioUnit");
DynamicallyLoadedModuleNames.Add("IOSRuntimeSettings");
DynamicallyLoadedModuleNames.Add("IOSLocalNotification");
PublicFrameworks.Add("OpenGLES");
// this is weak for IOS8 support for CAMetalLayer that is in QuartzCore
PublicWeakFrameworks.Add("QuartzCore");
PrivateDependencyModuleNames.Add("LaunchDaemonMessages");
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("OpenGLDrv");
PrivateDependencyModuleNames.Add("AndroidAudio");
PrivateDependencyModuleNames.Add("AudioMixerAndroid");
DynamicallyLoadedModuleNames.Add("AndroidRuntimeSettings");
DynamicallyLoadedModuleNames.Add("AndroidLocalNotification");
}
if ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Linux && Target.Type != TargetType.Server))
{
// TODO: re-enable after implementing resource tables for OpenGL.
DynamicallyLoadedModuleNames.Add("OpenGLDrv");
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PrivateDependencyModuleNames.Add("ALAudio");
PrivateDependencyModuleNames.Add("AudioMixerSDL");
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
// @todo ps4 clang bug: this works around a PS4/clang compiler bug (optimizations)
if (Target.Platform == UnrealTargetPlatform.PS4)
{
bFasterWithoutUnity = true;
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"LinuxCommonStartup"
}
);
}
}
public HotPatcherEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
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",
"Json",
"ContentBrowser",
"SandboxFile",
"JsonUtilities",
"TargetPlatform",
"PropertyEditor",
"AssetManagerEx",
"PakFileUtilities",
"HotPatcherRuntime"
// ... add other public dependencies that you statically link with here ...
}
);
if (Target.Version.MinorVersion > 23)
{
PublicDependencyModuleNames.Add("ToolMenus");
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Projects",
"DesktopPlatform",
"InputCore",
"UnrealEd",
"EditorStyle",
"LevelEditor",
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"RenderCore"
// ... add private dependencies that you statically link with here ...
}
);
PublicDefinitions.AddRange(new string[]
{
"ENABLE_COOK_ENGINE_MAP=0",
"ENABLE_COOK_PLUGIN_MAP=0"
});
// BLOCK EDITOR
PublicDefinitions.AddRange(new string[]
{
"PATCH_BLOCK_EDITOR=0",
"RELEASE_BLOCK_EDITOR=0"
});
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Version.MinorVersion <= 21)
{
bUseRTTI = true;
}
System.Console.WriteLine("MajorVersion {0} MinorVersion: {1} PatchVersion {2}", Target.Version.MajorVersion, Target.Version.MinorVersion, Target.Version.PatchVersion);
bLegacyPublicIncludePaths = false;
OptimizeCode = CodeOptimization.InShippingBuildsOnly;
}
public TargetPlatform(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.Add("Core");
PrivateDependencyModuleNames.Add("SlateCore");
PrivateDependencyModuleNames.Add("Slate");
PrivateDependencyModuleNames.Add("EditorStyle");
PublicDependencyModuleNames.Add("AudioPlatformConfiguration");
PublicDependencyModuleNames.Add("DesktopPlatform");
PublicDependencyModuleNames.Add("LauncherPlatform");
PrivateIncludePathModuleNames.Add("Engine");
// no need for all these modules if the program doesn't want developer tools at all (like UnrealFileServer)
if (!Target.bBuildRequiresCookedData && Target.bBuildDeveloperTools)
{
// these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor
DynamicallyLoadedModuleNames.Add("ShaderPreprocessor");
DynamicallyLoadedModuleNames.Add("ShaderFormatOpenGL");
DynamicallyLoadedModuleNames.Add("ImageWrapper");
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
DynamicallyLoadedModuleNames.Add("TextureFormatIntelISPCTexComp");
}
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
// these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor
DynamicallyLoadedModuleNames.Add("ShaderFormatD3D");
DynamicallyLoadedModuleNames.Add("MetalShaderFormat");
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatADPCM"); // For IOS cooking
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
}
if (Target.Type == TargetType.Editor || Target.Type == TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("TVOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
DynamicallyLoadedModuleNames.Add("MacTargetPlatform");
DynamicallyLoadedModuleNames.Add("MacNoEditorTargetPlatform");
DynamicallyLoadedModuleNames.Add("MacServerTargetPlatform");
DynamicallyLoadedModuleNames.Add("MacClientTargetPlatform");
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
DynamicallyLoadedModuleNames.Add("AudioFormatADPCM");
}
if (Target.Type == TargetType.Editor || Target.Type == TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("TVOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
DynamicallyLoadedModuleNames.Add("AudioFormatADPCM");
}
if (Target.Type == TargetType.Editor || Target.Type == TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
}
}
}
if (Target.bBuildDeveloperTools == true && Target.bBuildRequiresCookedData && Target.bCompileAgainstEngine && Target.bCompilePhysX)
{
DynamicallyLoadedModuleNames.Add("PhysXCooking");
}
}
public HotPatcherRuntime(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(EngineDirectory, "Source/Runtime/Launch"),
Path.Combine(ModuleDirectory, "Public")
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
// ... add other private include paths required here ...
}
);
if (Target.bBuildEditor)
{
PublicDependencyModuleNames.Add("TargetPlatform");
}
PublicDependencyModuleNames.AddRange(
new string[]
{
"RHI",
"Core",
"Projects",
"Json",
"JsonUtilities",
"PakFile",
"AssetRegistry",
"AssetManagerEx"
// ... add other public dependencies that you statically link with here ...
}
);
// PackageContext
{
bool bEnablePackageContext = false;
BuildVersion Version;
if (BuildVersion.TryRead(BuildVersion.GetDefaultFileName(), out Version))
{
if (Version.MajorVersion > 4 || Version.MinorVersion > 24)
{
PublicDefinitions.Add("WITH_PACKAGE_CONTEXT=1");
bEnablePackageContext = true;
}
}
if (!bEnablePackageContext)
{
PublicDefinitions.Add("WITH_PACKAGE_CONTEXT=0");
}
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore"
// ... add private dependencies that you statically link with here ...
}
);
if (Target.Version.MajorVersion > 4 || Target.Version.MinorVersion > 21)
{
PrivateDependencyModuleNames.Add("RenderCore");
}
else
{
PrivateDependencyModuleNames.Add("ShaderCore");
}
bLegacyPublicIncludePaths = false;
OptimizeCode = CodeOptimization.InShippingBuildsOnly;
}
public SpatialGDK(ReadOnlyTargetRules Target) : base(Target)
{
bLegacyPublicIncludePaths = false;
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
#pragma warning disable 0618
bFasterWithoutUnity = true; // Deprecated in 4.24, replace with bUseUnity = false; once we drop support for 4.23
if (Target.Version.MinorVersion == 24) // Due to a bug in 4.24, bFasterWithoutUnity is inversed, fixed in master, so should hopefully roll into the next release, remove this once it does
{
bFasterWithoutUnity = false;
}
#pragma warning restore 0618
PrivateIncludePaths.Add("SpatialGDK/Private");
var WorkerSDKPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "Public", "WorkerSDK"));
PublicIncludePaths.Add(WorkerSDKPath); // Worker SDK uses a different include format <improbable/x.h>
PrivateIncludePaths.Add(WorkerSDKPath);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"EngineSettings",
"InputCore",
"OnlineSubsystemUtils",
"Projects",
"ReplicationGraph",
"Sockets",
"Slate",
"UMG"
});
if (Target.bBuildDeveloperTools || (Target.Configuration != UnrealTargetConfiguration.Shipping &&
Target.Configuration != UnrealTargetConfiguration.Test))
{
PublicDependencyModuleNames.Add("GameplayDebugger");
}
if (Target.bBuildEditor)
{
PublicDependencyModuleNames.Add("UnrealEd");
PublicDependencyModuleNames.Add("SpatialGDKServices");
}
if (Target.bWithPerfCounters)
{
PublicDependencyModuleNames.Add("PerfCounters");
}
var WorkerLibraryDir = Path.Combine(ModuleDirectory, "..", "..", "Binaries", "ThirdParty", "Improbable", Target.Platform.ToString());
string LibPrefix = "libimprobable_";
string ImportLibSuffix = ".so";
string SharedLibSuffix = ".so";
bool bAddDelayLoad = false;
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
LibPrefix = "improbable_";
ImportLibSuffix = ".lib";
SharedLibSuffix = ".dll";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
ImportLibSuffix = SharedLibSuffix = ".dylib";
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
ImportLibSuffix = "_stub.a";
SharedLibSuffix = ".prx";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
LibPrefix = "improbable_";
ImportLibSuffix = ".lib";
SharedLibSuffix = ".dll";
// We don't set bAddDelayLoad = true here, because we get "unresolved external symbol __delayLoadHelper2".
// See: https://www.fmod.org/questions/question/deploy-issue-on-xboxone-with-unrealengine-4-14/
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
ImportLibSuffix = SharedLibSuffix = "_static.a";
}
else if (!(Target.Platform == UnrealTargetPlatform.Linux || Target.Platform == UnrealTargetPlatform.Android))
{
throw new System.Exception(System.String.Format("Unsupported platform {0}", Target.Platform.ToString()));
}
string WorkerImportLib = System.String.Format("{0}worker{1}", LibPrefix, ImportLibSuffix);
string WorkerSharedLib = System.String.Format("{0}worker{1}", LibPrefix, SharedLibSuffix);
if (Target.Platform != UnrealTargetPlatform.Android)
{
RuntimeDependencies.Add(Path.Combine(WorkerLibraryDir, WorkerSharedLib), StagedFileType.NonUFS);
if (bAddDelayLoad)
{
PublicDelayLoadDLLs.Add(WorkerSharedLib);
}
WorkerImportLib = Path.Combine(WorkerLibraryDir, WorkerImportLib);
PublicRuntimeLibraryPaths.Add(WorkerLibraryDir);
PublicAdditionalLibraries.Add(WorkerImportLib);
}
else
{
var WorkerLibraryPaths = new List <string>
{
Path.Combine(WorkerLibraryDir, "arm64-v8a"),
Path.Combine(WorkerLibraryDir, "armeabi-v7a"),
Path.Combine(WorkerLibraryDir, "x86_64"),
};
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "SpatialGDK_APL.xml"));
PublicRuntimeLibraryPaths.AddRange(WorkerLibraryPaths);
var WorkerLibraries = new List <string>
{
Path.Combine(WorkerLibraryDir, "arm64-v8a", WorkerSharedLib),
Path.Combine(WorkerLibraryDir, "armeabi-v7a", WorkerSharedLib),
Path.Combine(WorkerLibraryDir, "x86_64", WorkerSharedLib),
};
PublicAdditionalLibraries.AddRange(WorkerLibraries);
}
// Detect existence of trace library, if present add preprocessor
string TraceStaticLibPath = "";
string TraceDynamicLib = "";
string TraceDynamicLibPath = "";
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
TraceStaticLibPath = Path.Combine(WorkerLibraryDir, "trace_dynamic.lib");
TraceDynamicLib = "trace_dynamic.dll";
TraceDynamicLibPath = Path.Combine(WorkerLibraryDir, TraceDynamicLib);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
TraceStaticLibPath = Path.Combine(WorkerLibraryDir, "libtrace_dynamic.so");
TraceDynamicLib = "libtrace_dynamic.so";
TraceDynamicLibPath = Path.Combine(WorkerLibraryDir, TraceDynamicLib);
}
if (File.Exists(TraceStaticLibPath) && File.Exists(TraceDynamicLibPath))
{
Log.TraceInformation("Detection of trace libraries found at {0} and {1}, enabling trace functionality.", TraceStaticLibPath, TraceDynamicLibPath);
PublicDefinitions.Add("TRACE_LIB_ACTIVE=1");
PublicAdditionalLibraries.Add(TraceStaticLibPath);
RuntimeDependencies.Add(TraceDynamicLibPath, StagedFileType.NonUFS);
if (bAddDelayLoad)
{
PublicDelayLoadDLLs.Add(TraceDynamicLib);
}
}
else
{
Log.TraceInformation("Didn't find trace libraries at {0} and {1}, disabling trace functionality.", TraceStaticLibPath, TraceDynamicLibPath);
PublicDefinitions.Add("TRACE_LIB_ACTIVE=0");
}
}
public Procedural(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"EjPx/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"EjPx/Private",
// ... add other private include paths required here ...
}
);
if (Target.Type == TargetType.Editor)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"UnrealEd",
"ComponentVisualizers"
// ... add other public dependencies that you statically link with here ...
}
);
}
else
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"RenderCore",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompilePhysX && (UEBuildConfiguration.bBuildEditor || UEBuildConfiguration.bCompileAPEX))
{
DynamicallyLoadedModuleNames.Add("PhysXCooking");
}
if (UEBuildConfiguration.bCompilePhysX)
{
// Engine public headers need to know about some types (enums etc.)
PublicIncludePathModuleNames.Add("ClothingSystemRuntimeInterface");
PublicDependencyModuleNames.Add("ClothingSystemRuntimeInterface");
if (UEBuildConfiguration.bBuildEditor)
{
PrivateDependencyModuleNames.Add("ClothingSystemEditorInterface");
PrivateIncludePathModuleNames.Add("ClothingSystemEditorInterface");
}
}
}
public CS_OpenSSL(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string OpenSSL101sPath = Path.Combine(Target.UEThirdPartySourceDirectory, "OpenSSL", "1_0_1s");
string OpenSSL102hPath = Path.Combine(Target.UEThirdPartySourceDirectory, "OpenSSL", "1_0_2h");
string OpenSSL102Path = Path.Combine(Target.UEThirdPartySourceDirectory, "OpenSSL", "1.0.2g");
string OpenSSL111Path = Path.Combine(Target.UEThirdPartySourceDirectory, "OpenSSL", "1.1.1");
string PlatformSubdir = Target.Platform.ToString();
string ConfigFolder = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ? "Debug" : "Release";
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicIncludePaths.Add(Path.Combine(OpenSSL102Path, "include", PlatformSubdir));
string LibPath = Path.Combine(OpenSSL102Path, "lib", PlatformSubdir, ConfigFolder);
//PublicLibraryPaths.Add(LibPath);
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.a"));
PublicAdditionalLibraries.Add("z");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
string IncludePath = Target.UEThirdPartySourceDirectory + "OpenSSL/1.0.2g" + "/" + "include/PS4";
string LibraryPath = Target.UEThirdPartySourceDirectory + "OpenSSL/1.0.2g" + "/" + "lib/PS4/release";
PublicIncludePaths.Add(IncludePath);
PublicAdditionalLibraries.Add(LibraryPath + "/" + "libssl.a");
PublicAdditionalLibraries.Add(LibraryPath + "/" + "libcrypto.a");
}
else if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
// Our OpenSSL 1.1.1 libraries are built with zlib compression support
PrivateDependencyModuleNames.Add("zlib");
// string VSVersion = "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
string VSVersion = "VS2015";
// Add includes
PublicIncludePaths.Add(Path.Combine(OpenSSL111Path, "include", PlatformSubdir, VSVersion));
// Add Libs
string LibPath = Path.Combine(OpenSSL111Path, "lib", PlatformSubdir, VSVersion, ConfigFolder);
PublicLibraryPaths.Add(LibPath);
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.lib"));
PublicAdditionalLibraries.Add("crypt32.lib");
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
string platform = "/Linux/" + Target.Architecture;
string IncludePath = OpenSSL102hPath + "/include" + platform;
string LibraryPath = OpenSSL102hPath + "/lib" + platform;
PublicIncludePaths.Add(IncludePath);
PublicLibraryPaths.Add(LibraryPath);
PublicAdditionalLibraries.Add(LibraryPath + "/libssl.a");
PublicAdditionalLibraries.Add(LibraryPath + "/libcrypto.a");
PublicDependencyModuleNames.Add("zlib");
// PublicAdditionalLibraries.Add("z");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string IncludePath = OpenSSL101sPath + "/include/Android";
PublicIncludePaths.Add(IncludePath);
// unneeded since included in libcurl
// string LibPath = Path.Combine(OpenSSL101sPath, "lib", PlatformSubdir);
//PublicLibraryPaths.Add(LibPath);
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
string IncludePath = OpenSSL101sPath + "/include/IOS";
string LibraryPath = OpenSSL101sPath + "/lib/IOS";
PublicIncludePaths.Add(IncludePath);
PublicAdditionalLibraries.Add(LibraryPath + "/libssl.a");
PublicAdditionalLibraries.Add(LibraryPath + "/libcrypto.a");
}
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Source"));
}
public PakFile(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.Add("Core");
PublicDependencyModuleNames.Add("RSA");
}
public AkAudio(ReadOnlyTargetRules Target) : base(Target)
{
string ThirdPartyFolder = Path.Combine(ModuleDirectory, "../../ThirdParty");
AkUEPlatformInstance = AkUEPlatform.GetAkUEPlatformInstance(Target, ThirdPartyFolder);
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivateIncludePathModuleNames.AddRange(new string[] { "Settings", "UMG" });
PublicDependencyModuleNames.Add("UMG");
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"SlateCore",
"NetworkReplayStreaming",
"MovieScene",
"MovieSceneTracks",
"Projects",
"Json",
"Slate",
"InputCore",
"Projects"
});
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd",
"DesktopPlatform"
});
foreach (var Platform in GetAvailablePlatforms(ModuleDirectory))
{
PublicDefinitions.Add("AK_PLATFORM_" + Platform.ToUpper());
}
}
PrivateIncludePaths.Add("AkAudio/Private");
PublicIncludePaths.Add(Path.Combine(ThirdPartyFolder, "include"));
PublicDefinitions.Add("AK_UNREAL_MAX_CONCURRENT_IO=32");
PublicDefinitions.Add("AK_UNREAL_IO_GRANULARITY=32768");
if (Target.Configuration == UnrealTargetConfiguration.Shipping)
{
PublicDefinitions.Add("AK_OPTIMIZED");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && AkUEPlatformInstance.SupportsCommunication)
{
AkLibs.Add("CommunicationCentral");
PublicDefinitions.Add("AK_ENABLE_COMMUNICATION=1");
}
else
{
PublicDefinitions.Add("AK_ENABLE_COMMUNICATION=0");
}
if (AkUEPlatformInstance.SupportsAkAutobahn)
{
PublicDefinitions.Add("AK_SUPPORT_WAAPI=1");
AkLibs.Add("AkAutobahn");
}
else
{
PublicDefinitions.Add("AK_SUPPORT_WAAPI=0");
}
AddWwisePlugins(AkPlugins, ref AkLibs);
// Platform-specific dependencies
#if UE_4_24_OR_LATER
PublicSystemLibraries.AddRange(AkUEPlatformInstance.GetPublicSystemLibraries());
#else
PublicLibraryPaths.AddRange(AkUEPlatformInstance.GetPublicLibraryPaths());
PublicAdditionalLibraries.AddRange(AkUEPlatformInstance.GetPublicSystemLibraries());
#endif
AkLibs.AddRange(AkUEPlatformInstance.GetAdditionalWwiseLibs());
PublicDefinitions.AddRange(AkUEPlatformInstance.GetPublicDefinitions());
var Frameworks = AkUEPlatformInstance.GetPublicAdditionalFrameworks();
foreach (var fw in Frameworks)
{
#if UE_4_22_OR_LATER
PublicAdditionalFrameworks.Add(new ModuleRules.Framework(fw));
#else
PublicAdditionalFrameworks.Add(new UEBuildFramework(fw));
#endif
}
PublicAdditionalLibraries.AddRange(AkUEPlatformInstance.GetSanitizedAkLibList(AkLibs));
}
public HotPatcherRuntime(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(EngineDirectory, "Source/Runtime/Launch"),
Path.Combine(ModuleDirectory, "Public"),
Path.Combine(ModuleDirectory, "Public/BaseTypes")
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
// ... add other private include paths required here ...
}
);
if (Target.bBuildEditor)
{
PublicDependencyModuleNames.Add("TargetPlatform");
}
PublicDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"RHI",
"Core",
"Projects",
"Json",
"JsonUtilities",
"PakFile",
"AssetRegistry",
"BinariesPatchFeature"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore"
// ... add private dependencies that you statically link with here ...
}
);
if (Target.Version.MajorVersion > 4 || Target.Version.MinorVersion > 21)
{
PrivateDependencyModuleNames.Add("RenderCore");
}
else
{
PrivateDependencyModuleNames.Add("ShaderCore");
}
BuildVersion Version;
BuildVersion.TryRead(BuildVersion.GetDefaultFileName(), out Version);
// PackageContext
System.Func <string, bool, bool> AddPublicDefinitions = (string MacroName, bool bEnable) =>
{
PublicDefinitions.Add(string.Format("{0}={1}", MacroName, bEnable ? 1 : 0));
return(true);
};
AddPublicDefinitions("WITH_EDITOR_SECTION", Version.MajorVersion > 4 || Version.MinorVersion > 24);
bool bEnableAssetDependenciesDebugLog = true;
AddPublicDefinitions("ASSET_DEPENDENCIES_DEBUG_LOG", bEnableAssetDependenciesDebugLog);
bool bCustomAssetGUID = false;
if (bCustomAssetGUID)
{
PublicDefinitions.Add("CUSTOM_ASSET_GUID");
}
bLegacyPublicIncludePaths = false;
OptimizeCode = CodeOptimization.InShippingBuildsOnly;
}
public NavigationSystem(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
"Runtime/NavigationSystem/Public",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/NavigationSystem/Private",
"Runtime/Engine/Private",
"Developer/DerivedDataCache/Public",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"RHI",
"RenderCore",
"ShaderCore",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"TargetPlatform",
}
);
if (!Target.bBuildRequiresCookedData && Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("DerivedDataCache");
}
SetupModulePhysXAPEXSupport(Target);
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 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.
PublicDefinitions.Add("WITH_RECAST=0");
}
if (Target.bBuildEditor == true)
{
// @todo api: Only public because of WITH_EDITOR and UNREALED_API
PublicDependencyModuleNames.Add("UnrealEd");
CircularlyReferencedDependentModules.Add("UnrealEd");
}
}
public Core(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/CorePrivatePCH.h";
SharedPCHHeaderFile = "Public/CoreSharedPCH.h";
PrivateDependencyModuleNames.Add("BuildSettings");
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Core/Private",
"Runtime/Core/Private/Misc",
"Runtime/Core/Private/Internationalization",
"Runtime/Core/Private/Internationalization/Cultures",
"Runtime/Engine/Public",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"DerivedDataCache",
"InputDevice",
"Analytics",
"RHI"
}
);
if (Target.bBuildEditor == true)
{
DynamicallyLoadedModuleNames.Add("SourceCodeAccess");
PrivateIncludePathModuleNames.Add("DirectoryWatcher");
DynamicallyLoadedModuleNames.Add("DirectoryWatcher");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"IntelVTune"
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"zlib",
"PLCrashReporter",
"rd_route"
);
PublicFrameworks.AddRange(new string[] { "Cocoa", "Carbon", "IOKit", "Security" });
if (Target.bBuildEditor == true)
{
PublicAdditionalLibraries.Add("/System/Library/PrivateFrameworks/MultitouchSupport.framework/Versions/Current/MultitouchSupport");
}
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib"
);
PublicFrameworks.AddRange(new string[] { "UIKit", "Foundation", "AudioToolbox", "AVFoundation", "GameKit", "StoreKit", "CoreVideo", "CoreMedia", "CoreGraphics", "GameController", "SystemConfiguration", "DeviceCheck", "UserNotifications" });
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.AddRange(new string[] { "CoreMotion", "AdSupport", "WebKit" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"PLCrashReporter"
);
}
PrivateIncludePathModuleNames.Add("ApplicationCore");
bool bSupportAdvertising = Target.Platform == UnrealTargetPlatform.IOS;
if (bSupportAdvertising)
{
PublicFrameworks.AddRange(new string[] { "iAD" });
}
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"cxademangle",
"zlib"
);
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PublicIncludePaths.Add(string.Format("Runtime/Core/Public/{0}", Target.Platform.ToString()));
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib",
"jemalloc"
);
// Core uses dlopen()
PublicAdditionalLibraries.Add("dl");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PrivateDependencyModuleNames.Add("HTML5JS");
PrivateDependencyModuleNames.Add("MapPakDownloader");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicAdditionalLibraries.Add("SceRtc_stub_weak"); //ORBIS SDK rtc.h, used in PS4Time.cpp
}
if (Target.bCompileICU == true)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "ICU");
}
PublicDefinitions.Add("UE_ENABLE_ICU=" + (Target.bCompileICU ? "1" : "0")); // Enable/disable (=1/=0) ICU usage in the codebase. NOTE: This flag is for use while integrating ICU and will be removed afterward.
// If we're compiling with the engine, then add Core's engine dependencies
if (Target.bCompileAgainstEngine == true)
{
if (!Target.bBuildRequiresCookedData)
{
DynamicallyLoadedModuleNames.AddRange(new string[] { "DerivedDataCache" });
}
}
// On Windows platform, VSPerfExternalProfiler.cpp needs access to "VSPerf.h". This header is included with Visual Studio, but it's not in a standard include path.
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
var VisualStudioVersionNumber = "11.0";
var SubFolderName = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64/PerfSDK" : "PerfSDK";
string PerfIncludeDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), String.Format("Microsoft Visual Studio {0}/Team Tools/Performance Tools/{1}", VisualStudioVersionNumber, SubFolderName));
if (File.Exists(Path.Combine(PerfIncludeDirectory, "VSPerf.h")))
{
PrivateIncludePaths.Add(PerfIncludeDirectory);
PublicDefinitions.Add("WITH_VS_PERF_PROFILER=1");
}
else
{
PublicDefinitions.Add("WITH_VS_PERF_PROFILER=0");
}
}
WhitelistRestrictedFolders.Add("Private/NoRedist");
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PublicDefinitions.Add("WITH_DIRECTXMATH=1");
}
else if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
// To enable this requires Win8 SDK
PublicDefinitions.Add("WITH_DIRECTXMATH=0"); // Enable to test on Win64/32.
//PublicDependencyModuleNames.AddRange( // Enable to test on Win64/32.
// new string[] {
// "DirectXMath"
//});
}
else
{
PublicDefinitions.Add("WITH_DIRECTXMATH=0");
}
// Decide if validating memory allocator (aka MallocStomp) can be used on the current platform.
// Run-time validation must be enabled through '-stompmalloc' command line argument.
bool bWithMallocStomp = false;
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
switch (Target.Platform)
{
case UnrealTargetPlatform.Mac:
case UnrealTargetPlatform.Linux:
//case UnrealTargetPlatform.Win32: // 32-bit windows can technically be supported, but will likely run out of virtual memory space quickly
//case UnrealTargetPlatform.XboxOne: // XboxOne could be supported, as it's similar enough to Win64
case UnrealTargetPlatform.Win64:
bWithMallocStomp = true;
break;
}
}
PublicDefinitions.Add("WITH_MALLOC_STOMP=" + (bWithMallocStomp ? "1" : "0"));
// NVCHANGE_BEGIN: Add VXGI
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDependencyModuleNames.Add("VXGI");
}
// NVCHANGE_END: Add VXGI
}
public libWebSockets(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string WebsocketPath = Path.Combine(Target.UEThirdPartySourceDirectory, "libWebSockets", "libwebsockets");
string PlatformSubdir = Target.Platform.ToString();
bool bUseDebugBuild = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT);
string ConfigurationSubdir = bUseDebugBuild ? "Debug" : "Release";
switch (Target.Platform)
{
case UnrealTargetPlatform.HTML5:
return;
case UnrealTargetPlatform.Win64:
case UnrealTargetPlatform.Win32:
PlatformSubdir = Path.Combine(PlatformSubdir, "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
PublicAdditionalLibraries.Add("websockets_static.lib");
break;
case UnrealTargetPlatform.Mac:
case UnrealTargetPlatform.IOS:
PublicAdditionalLibraries.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), ConfigurationSubdir, "libwebsockets.a"));
break;
case UnrealTargetPlatform.PS4:
PublicAdditionalLibraries.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), ConfigurationSubdir, "libwebsockets.a"));
break;
case UnrealTargetPlatform.Switch:
PublicAdditionalLibraries.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), ConfigurationSubdir, "libwebsockets.a"));
break;
case UnrealTargetPlatform.Android:
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir, "ARMv7"));
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), "ARMv7", ConfigurationSubdir));
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir, "ARM64"));
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), "ARM64", ConfigurationSubdir));
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir, "x86"));
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), "x86", ConfigurationSubdir));
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir, "x64"));
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), "x64", ConfigurationSubdir));
PublicAdditionalLibraries.Add("websockets");
break;
default:
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PlatformSubdir = "Linux/" + Target.Architecture;
PublicAdditionalLibraries.Add(Path.Combine(WebsocketPath, "lib", PlatformSubdir, ConfigurationSubdir, "libwebsockets.a"));
break;
}
return;
}
if (Target.Platform != UnrealTargetPlatform.Android)
{
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", PlatformSubdir, ConfigurationSubdir));
}
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir));
if (Target.Platform != UnrealTargetPlatform.Switch)
{
PublicDependencyModuleNames.Add("OpenSSL");
}
}
public SpatialGDK(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
bFasterWithoutUnity = true;
PrivateIncludePaths.Add("SpatialGDK/Private");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"EngineSettings",
"Projects",
"OnlineSubsystemUtils",
"InputCore",
"Sockets",
});
if (Target.bBuildEditor)
{
PublicDependencyModuleNames.Add("UnrealEd");
PublicDependencyModuleNames.Add("SpatialGDKServices");
}
if (Target.bWithPerfCounters)
{
PublicDependencyModuleNames.Add("PerfCounters");
}
var WorkerLibraryDir = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "Binaries", "ThirdParty", "Improbable", Target.Platform.ToString()));
string LibPrefix = "improbable_";
string ImportLibSuffix = "";
string SharedLibSuffix = "";
bool bAddDelayLoad = false;
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
ImportLibSuffix = ".lib";
SharedLibSuffix = ".dll";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
LibPrefix = "libimprobable_";
ImportLibSuffix = SharedLibSuffix = ".dylib";
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
LibPrefix = "libimprobable_";
ImportLibSuffix = SharedLibSuffix = ".so";
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
LibPrefix = "libimprobable_";
ImportLibSuffix = "_stub.a";
SharedLibSuffix = ".prx";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
ImportLibSuffix = ".lib";
SharedLibSuffix = ".dll";
// We don't set bAddDelayLoad = true here, because we get "unresolved external symbol __delayLoadHelper2".
// See: https://www.fmod.org/questions/question/deploy-issue-on-xboxone-with-unrealengine-4-14/
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
LibPrefix = "libimprobable_";
ImportLibSuffix = SharedLibSuffix = "_static.a";
}
else
{
throw new System.Exception(System.String.Format("Unsupported platform {0}", Target.Platform.ToString()));
}
string WorkerImportLib = System.String.Format("{0}worker{1}", LibPrefix, ImportLibSuffix);
string WorkerSharedLib = System.String.Format("{0}worker{1}", LibPrefix, SharedLibSuffix);
PublicLibraryPaths.Add(WorkerLibraryDir);
PublicAdditionalLibraries.Add(Path.Combine(WorkerLibraryDir, WorkerImportLib));
RuntimeDependencies.Add(Path.Combine(WorkerLibraryDir, WorkerSharedLib), StagedFileType.NonUFS);
if (bAddDelayLoad)
{
PublicDelayLoadDLLs.Add(WorkerSharedLib);
}
// Detect existence of trace library, if present add preprocessor
string TraceStaticLibPath = "";
string TraceDynamicLib = "";
string TraceDynamicLibPath = "";
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
TraceStaticLibPath = Path.Combine(WorkerLibraryDir, "trace_dynamic.lib");
TraceDynamicLib = "trace_dynamic.dll";
TraceDynamicLibPath = Path.Combine(WorkerLibraryDir, TraceDynamicLib);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
TraceStaticLibPath = Path.Combine(WorkerLibraryDir, "libtrace_dynamic.so");
TraceDynamicLib = "libtrace_dynamic.so";
TraceDynamicLibPath = Path.Combine(WorkerLibraryDir, TraceDynamicLib);
}
if (File.Exists(TraceStaticLibPath) && File.Exists(TraceDynamicLibPath))
{
Log.TraceInformation("Detection of trace libraries found at {0} and {1}, enabling trace functionality.", TraceStaticLibPath, TraceDynamicLibPath);
PublicDefinitions.Add("TRACE_LIB_ACTIVE=1");
PublicAdditionalLibraries.Add(TraceStaticLibPath);
RuntimeDependencies.Add(TraceDynamicLibPath, StagedFileType.NonUFS);
if (bAddDelayLoad)
{
PublicDelayLoadDLLs.Add(TraceDynamicLib);
}
}
else
{
Log.TraceInformation("Didn't find trace libraries at {0} and {1}, disabling trace functionality.", TraceStaticLibPath, TraceDynamicLibPath);
PublicDefinitions.Add("TRACE_LIB_ACTIVE=0");
}
}
public SpatialGDK(ReadOnlyTargetRules Target) : base(Target)
{
bLegacyPublicIncludePaths = false;
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
bUseUnity = false;
PrivateIncludePaths.Add("SpatialGDK/Private");
var WorkerSDKPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "Public", "WorkerSDK"));
PublicIncludePaths.Add(WorkerSDKPath); // Worker SDK uses a different include format <improbable/x.h>
PrivateIncludePaths.Add(WorkerSDKPath);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"EngineSettings",
"Http",
"InputCore",
"OnlineSubsystemUtils",
"Projects",
"ReplicationGraph",
"Sockets",
"Slate",
"UMG"
});
if (Target.bWithPushModel)
{
PublicDependencyModuleNames.Add("NetCore");
}
if (Target.bBuildDeveloperTools || (Target.Configuration != UnrealTargetConfiguration.Shipping &&
Target.Configuration != UnrealTargetConfiguration.Test))
{
PublicDependencyModuleNames.Add("GameplayDebugger");
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=1");
}
else
{
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=0");
}
if (Target.bBuildEditor)
{
PublicDependencyModuleNames.Add("UnrealEd");
PublicDependencyModuleNames.Add("SpatialGDKServices");
}
if (Target.bWithPerfCounters)
{
PublicDependencyModuleNames.Add("PerfCounters");
}
var WorkerLibraryDir = Path.Combine(ModuleDirectory, "..", "..", "Binaries", "ThirdParty", "Improbable", Target.Platform.ToString());
string LibPrefix = "libimprobable_";
string ImportLibSuffix = ".so";
string SharedLibSuffix = ".so";
bool bAddDelayLoad = false;
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
LibPrefix = "improbable_";
ImportLibSuffix = ".lib";
SharedLibSuffix = ".dll";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
ImportLibSuffix = SharedLibSuffix = ".dylib";
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
ImportLibSuffix = "_stub.a";
SharedLibSuffix = ".prx";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
LibPrefix = "improbable_";
ImportLibSuffix = ".lib";
SharedLibSuffix = ".dll";
// We don't set bAddDelayLoad = true here, because we get "unresolved external symbol __delayLoadHelper2".
// See: https://www.fmod.org/questions/question/deploy-issue-on-xboxone-with-unrealengine-4-14/
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
ImportLibSuffix = SharedLibSuffix = "_static.a";
}
else if (!(Target.Platform == UnrealTargetPlatform.Linux || Target.Platform == UnrealTargetPlatform.Android))
{
throw new System.Exception(System.String.Format("Unsupported platform {0}", Target.Platform.ToString()));
}
string WorkerImportLib = System.String.Format("{0}worker{1}", LibPrefix, ImportLibSuffix);
string WorkerSharedLib = System.String.Format("{0}worker{1}", LibPrefix, SharedLibSuffix);
if (Target.Platform != UnrealTargetPlatform.Android)
{
RuntimeDependencies.Add(Path.Combine(WorkerLibraryDir, WorkerSharedLib), StagedFileType.NonUFS);
if (bAddDelayLoad)
{
PublicDelayLoadDLLs.Add(WorkerSharedLib);
}
WorkerImportLib = Path.Combine(WorkerLibraryDir, WorkerImportLib);
PublicRuntimeLibraryPaths.Add(WorkerLibraryDir);
PublicAdditionalLibraries.Add(WorkerImportLib);
}
else
{
var WorkerLibraryPaths = new List <string>
{
Path.Combine(WorkerLibraryDir, "arm64-v8a"),
Path.Combine(WorkerLibraryDir, "armeabi-v7a"),
Path.Combine(WorkerLibraryDir, "x86_64"),
};
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "SpatialGDK_APL.xml"));
PublicRuntimeLibraryPaths.AddRange(WorkerLibraryPaths);
var WorkerLibraries = new List <string>
{
Path.Combine(WorkerLibraryDir, "arm64-v8a", WorkerSharedLib),
Path.Combine(WorkerLibraryDir, "armeabi-v7a", WorkerSharedLib),
Path.Combine(WorkerLibraryDir, "x86_64", WorkerSharedLib),
};
PublicAdditionalLibraries.AddRange(WorkerLibraries);
}
}
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"
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Json",
"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",
"SlateCore",
"SlateReflector",
"VectorVM",
"Landscape"
}
);
CircularlyReferencedDependentModules.Add("AIModule");
CircularlyReferencedDependentModules.Add("Landscape");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"MovieSceneCore",
"MovieSceneCoreTypes",
"HeadMountedDisplay",
"StreamingPauseRendering",
"UMG",
}
);
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateRHIRenderer",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateRHIRenderer",
}
);
}
;
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",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform"
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxServerTargetPlatform",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Analytics",
"AnalyticsET",
"OnlineSubsystem",
"OnlineSubsystemUtils",
"Advertising"
}
);
if (!UEBuildConfiguration.bBuildDedicatedServer)
{
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 FMODStudio(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = "Private/FMODStudioPrivatePCH.h";
bUseUnity = false;
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public/FMOD"));
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Classes"));
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Media",
"Projects"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneTracks"
}
);
if (Target.bBuildEditor == true)
{
PublicDependencyModuleNames.Add("DeveloperToolSettings");
PrivateDependencyModuleNames.Add("AssetRegistry");
PrivateDependencyModuleNames.Add("Settings");
PrivateDependencyModuleNames.Add("UnrealEd");
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
string configName = "";
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
configName = "L";
PublicDefinitions.Add("FMODSTUDIO_LINK_LOGGING=1");
}
else
{
configName = "";
PublicDefinitions.Add("FMODSTUDIO_LINK_RELEASE=1");
}
string linkExtension = "";
string dllExtension = "";
string libPrefix = "";
string libPath = FMODLibDir;
bool bAddRuntimeDependencies = true;
bool bAddDelayLoad = false;
bool bLinkDebugFiles = false;
if (libPath == null)
{
string platformName = Target.Platform.ToString();
libPath = System.IO.Path.Combine(LibRootDirectory, platformName);
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Windows))
{
linkExtension = "_vc.lib";
dllExtension = ".dll";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
linkExtension = dllExtension = ".dylib";
libPrefix = "lib";
libPath = System.IO.Path.Combine(ModuleDirectory, "../../Libs/Mac/");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
bAddRuntimeDependencies = false; // Don't use this system
linkExtension = dllExtension = ".so";
libPrefix = "lib";
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
linkExtension = "_iphoneos.a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
}
else if (Target.Platform == UnrealTargetPlatform.TVOS)
{
linkExtension = "_appletvos.a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
libPath = System.IO.Path.Combine(libPath, "x86_64");
linkExtension = ".so";
dllExtension = ".so";
libPrefix = "lib";
}
}
else
{
linkExtension = ConsoleLinkExt;
dllExtension = ConsoleDllExt;
libPrefix = ConsoleLibPrefix;
bAddRuntimeDependencies = ConsoleRuntimeDependencies;
bAddDelayLoad = ConsoleDelayLoad;
bLinkDebugFiles = LinkDebugFiles;
}
// Collapse the directory path, otherwise MacOS has issues with plugin paths.
libPath = Utils.CleanDirectorySeparators(libPath);
string fmodLibName = System.String.Format("{0}fmod{1}{2}", libPrefix, configName, linkExtension);
string fmodStudioLibName = System.String.Format("{0}fmodstudio{1}{2}", libPrefix, configName, linkExtension);
string fmodDllName = System.String.Format("{0}fmod{1}{2}", libPrefix, configName, dllExtension);
string fmodStudioDllName = System.String.Format("{0}fmodstudio{1}{2}", libPrefix, configName, dllExtension);
string fmodLibPath = System.IO.Path.Combine(libPath, fmodLibName);
string fmodStudioLibPath = System.IO.Path.Combine(libPath, fmodStudioLibName);
string fmodDllPath = System.IO.Path.Combine(libPath, fmodDllName);
string fmodStudioDllPath = System.IO.Path.Combine(libPath, fmodStudioDllName);
System.Collections.Generic.List <string> plugins = GetPlugins(libPath);
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
string[] archs = new string[] { "arm64-v8a", "x86_64" };
foreach (string arch in archs)
{
string LibPath = System.IO.Path.Combine(libPath, arch);
PublicAdditionalLibraries.Add(System.String.Format("{0}/{1}", LibPath, fmodLibName));
PublicAdditionalLibraries.Add(System.String.Format("{0}/{1}", LibPath, fmodStudioLibName));
}
}
else
{
PublicAdditionalLibraries.Add(fmodLibPath);
PublicAdditionalLibraries.Add(fmodStudioLibPath);
}
if (CopyLibs)
{
RuntimeDependencies.Add("$(TargetOutputDir)/" + fmodDllName, fmodDllPath);
RuntimeDependencies.Add("$(TargetOutputDir)/" + fmodStudioDllName, fmodStudioDllPath);
foreach (string plugin in plugins)
{
string pluginPath = System.IO.Path.Combine(libPath, plugin + dllExtension);
System.Console.WriteLine("Adding reference to FMOD plugin: " + pluginPath);
RuntimeDependencies.Add("$(TargetOutputDir)/" + plugin + dllExtension, pluginPath);
}
}
else if (bAddRuntimeDependencies)
{
RuntimeDependencies.Add(fmodDllPath);
RuntimeDependencies.Add(fmodStudioDllPath);
foreach (string plugin in plugins)
{
string pluginPath = System.IO.Path.Combine(libPath, plugin + dllExtension);
System.Console.WriteLine("Adding reference to FMOD plugin: " + pluginPath);
RuntimeDependencies.Add(pluginPath);
}
}
if (bLinkDebugFiles)
{
RuntimeDependencies.Add(fmodDllPath + ".debug", StagedFileType.DebugNonUFS);
RuntimeDependencies.Add(fmodStudioDllPath + ".debug", StagedFileType.DebugNonUFS);
}
if (bAddDelayLoad)
{
PublicDelayLoadDLLs.AddRange(
new string[] {
fmodDllName,
fmodStudioDllName
}
);
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
string APLName = System.String.Format("FMODStudio{0}_APL.xml", configName);
string RelAPLPath = Utils.MakePathRelativeTo(System.IO.Path.Combine(ModuleDirectory, APLName), Target.RelativeEnginePath);
System.Console.WriteLine("Adding {0}", RelAPLPath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", RelAPLPath);
foreach (string PluginName in System.IO.Directory.GetFiles(libPath))
{
if (PluginName.EndsWith("_APL.xml", System.StringComparison.OrdinalIgnoreCase))
{
string RelPluginPath = Utils.MakePathRelativeTo(PluginName, Target.RelativeEnginePath);
System.Console.WriteLine("Adding {0}", RelPluginPath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", RelPluginPath);
}
}
}
}
public AkAudio(ReadOnlyTargetRules Target) : base(Target)
{
string ThirdPartyFolder = Path.Combine(ModuleDirectory, "../../ThirdParty");
AkUEPlatformInstance = AkUEPlatform.GetAkUEPlatformInstance(Target, ThirdPartyFolder);
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivateIncludePathModuleNames.AddRange(new string[] { "Settings", "UMG" });
PublicDependencyModuleNames.Add("UMG");
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"SlateCore",
"NetworkReplayStreaming",
"MovieScene",
"MovieSceneTracks",
"Projects",
"Json",
"Slate",
"InputCore",
"Projects"
});
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd",
"DesktopPlatform"
});
foreach (var Platform in GetAvailablePlatforms(ModuleDirectory))
{
PublicDefinitions.Add("AK_PLATFORM_" + Platform.ToUpper());
}
}
PrivateIncludePaths.Add("AkAudio/Private");
PublicIncludePaths.Add(Path.Combine(ThirdPartyFolder, "include"));
PublicDefinitions.Add("AK_UNREAL_MAX_CONCURRENT_IO=32");
PublicDefinitions.Add("AK_UNREAL_IO_GRANULARITY=32768");
if (Target.Configuration == UnrealTargetConfiguration.Shipping)
{
PublicDefinitions.Add("AK_OPTIMIZED");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && AkUEPlatformInstance.SupportsCommunication)
{
AddWwiseLib("CommunicationCentral");
PublicDefinitions.Add("AK_ENABLE_COMMUNICATION=1");
}
else
{
PublicDefinitions.Add("AK_ENABLE_COMMUNICATION=0");
}
// Platform-specific dependencies
PublicLibraryPaths.AddRange(AkUEPlatformInstance.GetPublicLibraryPaths());
PublicAdditionalLibraries.AddRange(AkUEPlatformInstance.GetPublicAdditionalLibraries());
PublicDefinitions.AddRange(AkUEPlatformInstance.GetPublicDefinitions());
var Frameworks = AkUEPlatformInstance.GetPublicAdditionalFrameworks();
foreach (var fw in Frameworks)
{
#if UE_4_22_OR_LATER
PublicAdditionalFrameworks.Add(new ModuleRules.Framework(fw));
#else
PublicAdditionalFrameworks.Add(new UEBuildFramework(fw));
#endif
}
AddWwiseLib("AkSoundEngine");
AddWwiseLib("AkMemoryMgr");
AddWwiseLib("AkStreamMgr");
AddWwiseLib("AkMusicEngine");
AddWwiseLib("AkSpatialAudio");
AddWwiseLib("AkVorbisDecoder");
AddWwiseLib("AkSilenceSource");
AddWwiseLib("AkSineSource");
AddWwiseLib("AkToneSource");
AddWwiseLib("AkPeakLimiterFX");
AddWwiseLib("AkMatrixReverbFX");
AddWwiseLib("AkParametricEQFX");
AddWwiseLib("AkDelayFX");
AddWwiseLib("AkExpanderFX");
AddWwiseLib("AkFlangerFX");
AddWwiseLib("AkCompressorFX");
AddWwiseLib("AkGainFX");
AddWwiseLib("AkHarmonizerFX");
AddWwiseLib("AkTimeStretchFX");
AddWwiseLib("AkPitchShifterFX");
AddWwiseLib("AkStereoDelayFX");
AddWwiseLib("AkMeterFX");
AddWwiseLib("AkGuitarDistortionFX");
AddWwiseLib("AkTremoloFX");
AddWwiseLib("AkRoomVerbFX");
AddWwiseLib("AkAudioInputSource");
AddWwiseLib("AkSynthOneSource");
AddWwiseLib("AkRecorderFX");
AddWwiseLib("AkOpusDecoder");
AddWwisePlugin("AkReflectFX");
AddWwisePlugin("AkConvolutionReverbFX");
AddWwisePlugin("AuroHeadphoneFX");
if (AkUEPlatformInstance.SupportsAkAutobahn)
{
PublicDefinitions.Add("AK_SUPPORT_WAAPI=1");
AddWwiseLib("AkAutobahn");
}
else
{
PublicDefinitions.Add("AK_SUPPORT_WAAPI=0");
}
}
public AnselCapture(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string NvCameraSDKSourcePath = ThirdPartyPath + "NVAnselSDK/";
string NvCameraSDKIncPath = NvCameraSDKSourcePath + "include/";
PublicSystemIncludePaths.Add(NvCameraSDKIncPath);
string NvCameraSDKLibPath = NvCameraSDKSourcePath + "lib/";
PublicLibraryPaths.Add(NvCameraSDKLibPath);
bool FoundAnselDirs = true;
if (!Directory.Exists(NvCameraSDKSourcePath))
{
System.Console.WriteLine(string.Format("Ansel SDK source path not found: {0}", NvCameraSDKSourcePath));
FoundAnselDirs = false;
}
string LibName;
if ((Target.Platform == UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealTargetPlatform.Win32) &&
FoundAnselDirs)
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
LibName = "AnselSDK64";
}
else
{
LibName = "AnselSDK32";
}
bool HaveDebugLib = File.Exists(BinariesPath + LibName + "d" + ".dll");
if (HaveDebugLib &&
Target.Configuration == UnrealTargetConfiguration.Debug &&
Target.bDebugBuildsActuallyUseDebugCRT)
{
LibName += "d";
}
PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, LibName + ".lib"));
string DLLName = LibName + ".dll";
PublicDelayLoadDLLs.Add(DLLName);
RuntimeDependencies.Add(BinariesPath + DLLName);
PublicDefinitions.Add("WITH_ANSEL=1");
PublicDefinitions.Add("ANSEL_DLL=" + DLLName);
}
else
{
PublicDefinitions.Add("WITH_ANSEL=0");
PublicDefinitions.Add("ANSEL_DLL=");
}
PrivateDependencyModuleNames.AddRange(new string[]
{
"Core",
"CoreUObject",
"SlateCore",
"Engine",
});
PublicDependencyModuleNames.Add("Engine");
}
public UnrealEd(ReadOnlyTargetRules Target) : base(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",
"ClothingSystemEditorInterface",
}
);
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",
"ClothingSystemEditor",
"ClothingSystemRuntime"
}
);
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",
"StringTableEditor",
"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",
"AnimationModifiers",
}
);
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");
}
}
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.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",
});
// 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 SML(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
bLegacyPublicIncludePaths = false;
//SML transitive dependencies
PublicDependencyModuleNames.AddRange(new[] {
"Json",
"MovieScene",
"Projects"
});
PrivateDependencyModuleNames.AddRange(new[] { "RenderCore" });
PublicDependencyModuleNames.AddRange(new string[] { "FactoryGame" });
//FactoryGame transitive dependencies
PublicDependencyModuleNames.AddRange(new[] {
"Core", "CoreUObject",
"Engine",
"InputCore",
"OnlineSubsystem", "OnlineSubsystemNull", "OnlineSubsystemEOS", "OnlineSubsystemUtils",
"SignificanceManager",
"APEX", "ApexDestruction",
"AnimGraphRuntime",
"AkAudio",
"PhysXVehicles",
"AssetRegistry",
"NavigationSystem",
"ReplicationGraph",
"AIModule",
"GameplayTasks",
"SlateCore", "Slate", "UMG",
"InstancedSplines"
});
if (Target.bBuildEditor)
{
PublicDependencyModuleNames.Add("UnrealEd");
PrivateDependencyModuleNames.Add("MainFrame");
}
var factoryGamePchPath = new DirectoryReference(Path.Combine(Target.ProjectFile.Directory.ToString(), "Source", "FactoryGame", "Public", "FactoryGame.h"));
PrivatePCHHeaderFile = factoryGamePchPath.MakeRelativeTo(new DirectoryReference(ModuleDirectory));
var thirdPartyFolder = Path.Combine(ModuleDirectory, "../../ThirdParty");
PublicIncludePaths.Add(Path.Combine(thirdPartyFolder, "include"));
var platformName = Target.Platform.ToString();
var libraryFolder = Path.Combine(thirdPartyFolder, platformName);
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "funchook.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "detex.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "libfbxsdk-md.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "libxml2-md.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "zlib-md.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "AssemblyAnalyzer.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "Zydis.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "Zycore.lib"));
//Collect build metadata from the environment and pass it to C++
var currentBranch = Environment.GetEnvironmentVariable("BRANCH_NAME");
var buildId = Environment.GetEnvironmentVariable("BUILD_NUMBER");
if (currentBranch == null)
{
RetrieveHeadBranchAndCommitFromGit(Target.ProjectFile.Directory, out currentBranch, out buildId);
if (buildId != null && buildId.Length > 8)
{
buildId = buildId.Substring(0, 8);
}
}
Log.TraceInformation("Environment: Branch = {0} BuildId = {1}", currentBranch, buildId);
if (currentBranch != null && buildId != null)
{
var buildMetadataString = currentBranch == "master" ? buildId : string.Format("{0}+{1}", currentBranch, buildId);
PrivateDefinitions.Add(string.Format("SML_BUILD_METADATA=\"{0}\"", buildMetadataString));
}
}
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[]
{
"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",
"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",
"IoStoreUtilities",
}
);
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",
"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",
"TraceInsights",
}
);
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.bCompileChaos && Target.bUseChaos)
{
PrivateDependencyModuleNames.Add("ChaosSolvers");
}
if (Target.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
PublicDefinitions.Add("WITH_RECAST=1");
}
else
{
PublicDefinitions.Add("WITH_RECAST=0");
}
if (Target.bWithLiveCoding)
{
PrivateIncludePathModuleNames.Add("LiveCoding");
}
}
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",
"Runtime/Net/Core/Private/Net/Core/PushModel/Types"
}
);
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",
"AnalyticsET",
"RHI",
"Sockets",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"GameplayTags",
"PacketHandler",
"AudioPlatformConfiguration",
"MeshDescription",
"StaticMeshDescription",
"PakFile",
"NetworkReplayStreaming",
"PhysicsCore",
"SignalProcessing",
"AudioExtensions"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Landscape",
"UMG",
"Projects",
"MaterialShaderQualitySettings",
"CinematicCamera",
"Analytics",
"AudioMixer",
"AudioMixerCore",
"SignalProcessing",
"CrunchCompression",
"IntelISPC",
"TraceLog",
}
);
// 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");
}
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 == 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);
}
}
public TargetPlatform(TargetInfo Target)
{
PrivateDependencyModuleNames.Add("Core");
PublicDependencyModuleNames.Add("DesktopPlatform");
PrivateIncludePathModuleNames.Add("PhysXFormats");
// no need for all these modules if the program doesn't want developer tools at all (like UnrealFileServer)
if (!UEBuildConfiguration.bBuildRequiresCookedData && UEBuildConfiguration.bBuildDeveloperTools)
{
// these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor
DynamicallyLoadedModuleNames.Add("ShaderPreprocessor");
DynamicallyLoadedModuleNames.Add("ShaderFormatOpenGL");
DynamicallyLoadedModuleNames.Add("ImageWrapper");
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64 ||
(Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32"))
{
// these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor
DynamicallyLoadedModuleNames.Add("ShaderFormatD3D");
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
}
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatADPCM"); // For IOS cooking
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
}
if (Target.Type == TargetRules.TargetType.Editor || Target.Type == TargetRules.TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_PVRTCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ATCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_DXTTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ETC1TargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ETC2TargetPlatform");
DynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
if (!UnrealBuildTool.UnrealBuildTool.RunningRocket() && !UnrealBuildTool.UnrealBuildTool.BuildingRocket())
{
DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
}
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
}
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
}
if (Target.Type == TargetRules.TargetType.Editor || Target.Type == TargetRules.TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
if (!UnrealBuildTool.UnrealBuildTool.RunningRocket() && !UnrealBuildTool.UnrealBuildTool.BuildingRocket())
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_PVRTCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ATCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_DXTTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ETC1TargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ETC2TargetPlatform");
DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
}
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
}
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
}
}
}
if (UEBuildConfiguration.bBuildDeveloperTools == true && (UEBuildConfiguration.bBuildRequiresCookedData || UEBuildConfiguration.bRuntimePhysicsCooking) && UEBuildConfiguration.bCompileAgainstEngine && UEBuildConfiguration.bCompilePhysX)
{
DynamicallyLoadedModuleNames.Add("PhysXFormats");
}
}
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);
}
}
