public BlueprintGraph(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/BlueprintGraph/Private",
"Editor/KismetCompiler/Public",
}
);
OverridePackageType = PackageOverrideType.EngineDeveloper;
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"EditorStyle",
"EditorSubsystem",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"EditorStyle",
"KismetCompiler",
"UnrealEd",
"GraphEditor",
"SlateCore",
"Kismet",
"KismetWidgets",
"PropertyEditor",
"ToolMenus",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"KismetCompiler",
"UnrealEd",
"GraphEditor",
"Kismet",
}
);
}
public AnimGraph(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/AnimGraph/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Slate",
"AnimGraphRuntime",
"BlueprintGraph",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"InputCore",
"SlateCore",
"UnrealEd",
"GraphEditor",
"PropertyEditor",
"EditorStyle",
"ContentBrowser",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"GraphEditor",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Persona",
"SkeletonEditor",
"AdvancedPreviewScene",
}
);
}
public HierarchicalLODOutliner(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange
(
new string[] {
"Core",
"InputCore",
"CoreUObject",
"RHI",
"RenderCore",
"Slate",
"EditorStyle",
"Engine",
"UnrealEd",
"PropertyEditor",
"HierarchicalLODUtilities"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Engine",
"UnrealEd"
}
);
if (UEBuildConfiguration.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"SlateCore",
"Slate",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd"
}
);
}
}
public MaterialUtilities(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string [] {
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"Renderer",
"RHI",
"Landscape",
"UnrealEd",
"MaterialBaking",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MeshMergeUtilities",
}
);
PublicDependencyModuleNames.AddRange(
new string [] {
"MeshDescription",
"MeshDescriptionOperations",
"StaticMeshDescription"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Landscape",
"MeshMergeUtilities",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"Landscape"
}
);
}
public AudiokineticTools(TargetInfo Target)
{
PrivateIncludePaths.Add("AudiokineticTools/Private");
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"TargetPlatform",
"MainFrame",
"LevelEditor"
});
PublicIncludePathModuleNames.AddRange(
new string[]
{
"AssetTools",
"ContentBrowser",
"Matinee"
});
PublicDependencyModuleNames.AddRange(
new string[]
{
"AkAudio",
"Core",
"InputCore",
"CoreUObject",
"Engine",
"UnrealEd",
"Slate",
"SlateCore",
"Matinee",
"EditorStyle",
"Json",
"XmlParser",
"WorkspaceMenuStructure",
"DirectoryWatcher",
"Projects",
"PropertyEditor"
});
CircularlyReferencedDependentModules.Add("AkAudio");
}
public BlueprintGraph(TargetInfo Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/BlueprintGraph/Private",
"Editor/KismetCompiler/Public",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"EditorStyle",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"EditorStyle",
"KismetCompiler",
"UnrealEd",
"GraphEditor",
"SlateCore",
"Kismet",
"KismetWidgets",
"PropertyEditor",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"KismetCompiler",
"UnrealEd",
"GraphEditor",
"Kismet",
}
);
}
public Sequencer(TargetInfo Target)
{
PrivateIncludePaths.Add("Editor/Sequencer/Private");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"InputCore",
"Engine",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"MovieScene",
"MovieSceneTracks",
"MovieSceneTools",
"MovieSceneCapture",
"EditorWidgets",
"SequencerWidgets",
"BlueprintGraph",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"PropertyEditor",
"Kismet",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"PropertyEditor",
"LevelEditor",
"WorkspaceMenuStructure",
}
);
CircularlyReferencedDependentModules.Add("MovieSceneTools");
}
// https://wiki.unrealengine.com/Linking_Static_Libraries_Using_The_Build_System
//private bool LoadSockets_bak(TargetInfo Target)
// 4.17
//private bool LoadSockets_bak(ReadOnlyTargetRules Target)
//{
// // https://wiki.unrealengine.com/Integrating_OpenCV_Into_Unreal_Engine_4
// // UE4.9.1 error CS0122: “UnrealBuildTool.BuildConfiguration”不可访问，因为它受保护级别限制
// //bool isdebug = Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT;
// bool isdebug = Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT;
// if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
// {
// //string PlatformString;
// string LibrariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "Sockets");
// if (Target.Platform == UnrealTargetPlatform.Win64)
// {
// //PlatformString = "x64";
// //LibrariesPath = Path.Combine(LibrariesPath, "Win64");
// if (Target.Configuration == UnrealTargetConfiguration.Debug)
// {
// LibrariesPath = Path.Combine(LibrariesPath, "Debug");
// }
// }
// else
// {
// //PlatformString = "ia32";
// //LibrariesPath = Path.Combine(LibrariesPath, "Win32");
// }
// //LibrariesPath = Path.Combine(LibrariesPath, "Debug");
// //PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "icui18n.lib"));
// //PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "icuuc.lib"));
// //PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base.lib"));
// //PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_libbase.lib"));
// //PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_nosnapshot.lib"));
// //PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_snapshot.lib"));
// //PublicIncludePaths.Add(Path.Combine(this.getMyProjectThirdPartyPath(), "v8", "Includes"));
// //Definitions.Add(string.Format("WITH_COUPLING=1"));
// if (Target.Configuration == UnrealTargetConfiguration.Debug)
// {
// // 添加库目录
// // PublicLibraryPaths.Add(LuaLibDirectory);
// PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "Sockets.lib"));
// //Add Dynamic Libraries (Debug Version)
// //PublicDelayLoadDLLs.Add("opencv_world300d.dll");
// }
// else
// {
// PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "Sockets.lib"));
// }
// return true;
// }
// //Definitions.Add(string.Format("WITH_COUPLING=0"));
// return false;
//}
//private bool LoadSockets(TargetInfo Target)
// 4.17
//private bool LoadSockets(ReadOnlyTargetRules Target)
//{
// string LibrariesPath;
// LibrariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "Sockets", "Sockets_d.lib");
// PublicAdditionalLibraries.Add(LibrariesPath);
// return true;
//}
//private bool LoadTestExtern(TargetInfo Target)
// 4.17
//private bool LoadTestExtern(ReadOnlyTargetRules Target)
//{
// string LibrariesPath;
// LibrariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "TestStaticLib", "TestStaticLib_d.lib");
// PublicAdditionalLibraries.Add(LibrariesPath);
// return true;
//}
//private bool LoadGtest(TargetInfo Target)
// 4.17
//private bool LoadGtest(ReadOnlyTargetRules Target)
//{
// string LibrariesPath;
// LibrariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "gtest", "gtest_d.lib");
// PublicAdditionalLibraries.Add(LibrariesPath);
// return true;
//}
// 加载 Lua
//private bool LoadLua(TargetInfo Target)
// 4.17
//private bool LoadLua(ReadOnlyTargetRules Target)
//{
// string librariesPath = "";
// if (UnrealTargetPlatform.Mac == Target.Platform)
// {
// }
// else if(UnrealTargetPlatform.Win32 == Target.Platform)
// {
// /**
// * @brief bDebugBuildsActuallyUseDebugCRT 开启这个会有很多链接错误，因此暂时不开启
// * @ref Engine\Source\Programs\UnrealBuildTool\Configuration\TargetRules.cs
// * @ref Engine\Saved\UnrealBuildTool\BuildConfiguration.xml
// */
// if (UnrealTargetConfiguration.Debug == Target.Configuration/* &&
// Target.bDebugBuildsActuallyUseDebugCRT */)
// {
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "Lua", "Win32", "Lua_d.lib");
// PublicAdditionalLibraries.Add(librariesPath);
// }
// else
// {
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "Lua", "Win32", "Lua.lib");
// PublicAdditionalLibraries.Add(librariesPath);
// }
// }
// else if (UnrealTargetPlatform.Win64 == Target.Platform)
// {
// if (UnrealTargetConfiguration.Debug == Target.Configuration/* &&
// Target.bDebugBuildsActuallyUseDebugCRT */)
// {
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "Lua", "Win64", "Lua_d.lib");
// PublicAdditionalLibraries.Add(librariesPath);
// }
// else
// {
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "Lua", "Win64", "Lua.lib");
// PublicAdditionalLibraries.Add(librariesPath);
// }
// }
// else if (UnrealTargetPlatform.Android == Target.Platform)
// {
// // UE4.19.1 error CS0122: “UnrealBuildTool.BuildConfiguration”不可访问，因为它受保护级别限制
// //string BuildPath = Utils.MakePathRelativeTo(ModuleDirectory, BuildConfiguration.RelativeEnginePath);
// //string BuildPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
// // UE4.19.1 warning CS0618: “UnrealBuildTool.ModuleRules.ReceiptPropertyList.Add(UnrealBuildTool.ReceiptProperty)”已过时:“Constructing a ReceiptProperty object is deprecated. Call RuntimeDependencies.Add() with the path to the file to stage.”
// //AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(BuildPath, "My_APL_armv7.xml")));
// //RuntimeDependencies.Add(Path.Combine(BuildPath, "My_APL_armv7.xml"));
// //PublicAdditionalLibraries.Add(BuildPath + "/armv7/libLua.so");
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "Lua", "Android/armv7");
// PublicLibraryPaths.Add(librariesPath);
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "Lua", "Android/arm64");
// PublicLibraryPaths.Add(librariesPath);
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "Lua", "Android/x86");
// PublicLibraryPaths.Add(librariesPath);
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "Lua", "Android/x86_64");
// PublicLibraryPaths.Add(librariesPath);
// if (UnrealTargetConfiguration.Debug == Target.Configuration/* &&
// Target.bDebugBuildsActuallyUseDebugCRT */)
// {
// PublicAdditionalLibraries.Add("Lua_d");
// }
// else
// {
// PublicAdditionalLibraries.Add("Lua");
// }
// }
// else if (UnrealTargetPlatform.IOS == Target.Platform)
// {
// }
// else
// {
// throw new System.Exception("Not support platform");
// }
// return true;
//}
//private bool LoadLuaSocket(TargetInfo Target)
// 4.17
//private bool LoadLuaSocket(ReadOnlyTargetRules Target)
//{
// /**
// * @brief UnrealTargetPlatform
// * @url Engine\Source\Programs\UnrealBuildTool\Configuration\UEBuildTarget.cs
// */
// string librariesPath = "";
// if (UnrealTargetPlatform.Mac == Target.Platform)
// {
// }
// else if(UnrealTargetPlatform.Win32 == Target.Platform)
// {
// if (UnrealTargetConfiguration.Debug == Target.Configuration/* &&
// Target.bDebugBuildsActuallyUseDebugCRT */)
// {
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "LuaSocket", "Win32", "LuaSocket_d.lib");
// PublicAdditionalLibraries.Add(librariesPath);
// }
// else
// {
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "LuaSocket", "Win32", "LuaSocket.lib");
// PublicAdditionalLibraries.Add(librariesPath);
// }
// }
// else if (UnrealTargetPlatform.Win64 == Target.Platform)
// {
// if (UnrealTargetConfiguration.Debug == Target.Configuration/* &&
// Target.bDebugBuildsActuallyUseDebugCRT*/)
// {
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "LuaSocket", "Win64", "LuaSocket_d.lib");
// PublicAdditionalLibraries.Add(librariesPath);
// }
// else
// {
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "LuaSocket", "Win64", "LuaSocket_d.lib");
// PublicAdditionalLibraries.Add(librariesPath);
// }
// }
// else if (UnrealTargetPlatform.Android == Target.Platform)
// {
// /**
// * @brief AndroidToolChain
// * @url Engine\Source\Programs\UnrealBuildTool\Platform\Android\AndroidToolChain.cs
// * @ref Engine\Source\ThirdParty\GoogleVR\GoogleVR.Build.cs
// * @brief Target.UEThirdPartySourceDirectory \
// */
// // error CS0122: “UnrealBuildTool.BuildConfiguration”不可访问，因为它受保护级别限制
// // string BuildPath = Utils.MakePathRelativeTo(ModuleDirectory, BuildConfiguration.RelativeEnginePath);
// //string BuildPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
// // UE4.19.1 warning CS0618: “UnrealBuildTool.ModuleRules.ReceiptPropertyList.Add(UnrealBuildTool.ReceiptProperty)”已过时:“Constructing a ReceiptProperty object is deprecated. Call RuntimeDependencies.Add() with the path to the file to stage.”
// //AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(BuildPath, "My_APL_armv7.xml")));
// //RuntimeDependencies.Add(Path.Combine(BuildPath, "My_APL_armv7.xml"));
// //PublicAdditionalLibraries.Add(BuildPath + "/armv7/libLuaSocket.so");
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "LibSocket", "Android/armv7");
// PublicLibraryPaths.Add(librariesPath);
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "LibSocket", "Android/arm64");
// PublicLibraryPaths.Add(librariesPath);
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "LibSocket", "Android/x86");
// PublicLibraryPaths.Add(librariesPath);
// librariesPath = Path.Combine(this.getMyProjectThirdPartyPath(), "Lib", "LibSocket", "Android/x86_64");
// PublicLibraryPaths.Add(librariesPath);
// if (UnrealTargetConfiguration.Debug == Target.Configuration/* &&
// Target.bDebugBuildsActuallyUseDebugCRT */)
// {
// PublicAdditionalLibraries.Add("libLuaSocket_d");
// }
// else
// {
// PublicAdditionalLibraries.Add("libLuaSocket");
// }
// }
// else if (UnrealTargetPlatform.IOS == Target.Platform)
// {
// }
// else
// {
// throw new System.Exception("Not support platform");
// }
// return true;
//}
// 加载 ProjectEditor
//private bool LoadMyProjectEditor(TargetInfo Target)
// 4.17
private bool LoadMyProjectEditor(ReadOnlyTargetRules Target)
{
// warning CS0618: “UnrealBuildTool.ModuleRules.BuildConfiguration”已过时:“The BuildConfiguration alias is deprecated in 4.18. Set the same properties on the ReadOnlyTargetRules instance passed into the ModuleRules constructor instead.”
//if (UEBuildConfiguration.bBuildEditor == true)
if (Target.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"MyProjectEditor"
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"MyProjectEditor",
}
);
}
return(true);
}
public KismetWidgets(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Editor/KismetWidgets/Private");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"InputCore",
"Engine",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"BlueprintGraph",
"ClassViewer"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"ContentBrowser",
"AssetTools",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ContentBrowser",
"AssetTools",
}
);
// Circular references that need to be cleaned up
CircularlyReferencedDependentModules.AddRange(
new string[] {
"BlueprintGraph",
}
);
}
public BlockEncryptionHandlerComponent(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"PacketHandler",
"XORBlockEncryptor",
}
);
CircularlyReferencedDependentModules.Add("XORBlockEncryptor");
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddThirdPartyPrivateStaticDependencies(Target,
"CryptoPP"
);
}
PublicIncludePathModuleNames.Add("CryptoPP");
}
public PIEPreviewDeviceProfileSelector(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("Engine");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Json",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"PIEPreviewDeviceSpecification",
"RHI",
"JsonUtilities",
"MaterialShaderQualitySettings",
"Slate",
"SlateCore",
"ApplicationCore",
"Engine",
"UnrealEd",
"EditorStyle"
}
);
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"UnrealEd"
}
);
}
public BlockEncryptionHandlerComponent(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"PacketHandler",
"XORBlockEncryptor",
}
);
CircularlyReferencedDependentModules.Add("XORBlockEncryptor");
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"CryptoPP"
);
}
PublicIncludePathModuleNames.Add("CryptoPP");
PrecompileForTargets = PrecompileTargetsType.None;
}
public Sequencer(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/Sequencer/Private",
"Editor/Sequencer/Private/DisplayNodes",
"Editor/UnrealEd/Private" // TODO: Fix this, for now it's needed for the fbx exporter
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"CinematicCamera",
"Core",
"CoreUObject",
"InputCore",
"Engine",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"MovieScene",
"MovieSceneTracks",
"MovieSceneTools",
"MovieSceneCapture",
"MovieSceneCaptureDialog",
"EditorWidgets",
"SequencerWidgets",
"BlueprintGraph",
"LevelSequence"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"ContentBrowser",
"PropertyEditor",
"Kismet",
"SceneOutliner",
"SequenceRecorder",
"LevelEditor",
"MainFrame",
"DesktopPlatform"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"PropertyEditor",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"PropertyEditor",
"LevelEditor",
"SceneOutliner",
"WorkspaceMenuStructure",
"SequenceRecorder",
"SequenceRecorderSections",
"MainFrame",
}
);
CircularlyReferencedDependentModules.Add("MovieSceneTools");
AddEngineThirdPartyPrivateStaticDependencies(Target, "FBX");
}
public AIModule(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
"Runtime/NavigationSystem/Public",
"Runtime/AIModule/Public",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/AIModule/Private",
"Runtime/Engine/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"GameplayTags",
"GameplayTasks",
"NavigationSystem",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"RHI",
"RenderCore",
"ShaderCore",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
PrivateDependencyModuleNames.Add("AITestSuite");
CircularlyReferencedDependentModules.Add("AITestSuite");
}
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.bBuildDeveloperTools || (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test))
{
PrivateDependencyModuleNames.Add("GameplayDebugger");
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=1");
}
else
{
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=0");
}
}
public GraphEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/GraphEditor/Private",
"Editor/GraphEditor/Private/KismetNodes",
"Editor/GraphEditor/Private/KismetPins",
"Editor/GraphEditor/Private/MaterialNodes",
"Editor/GraphEditor/Private/MaterialPins",
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"IntroTutorials",
"ClassViewer",
"StructViewer",
}
);
// PublicDependencyModuleNames.AddRange(
// new string[] {
// "AudioEditor"
// }
// );
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"EditorStyle",
"EditorWidgets",
"UnrealEd",
"AssetRegistry",
"Kismet",
"KismetWidgets",
"BlueprintGraph",
"Documentation",
"RenderCore",
"RHI",
"ToolMenus",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ContentBrowser",
"ClassViewer",
"StructViewer",
}
);
// Circular references that need to be cleaned up
CircularlyReferencedDependentModules.AddRange(
new string[] {
"Kismet"
}
);
}
public UnrealTournament(TargetInfo Target)
{
bFasterWithoutUnity = true;
MinFilesUsingPrecompiledHeaderOverride = 1;
PrivateIncludePaths.AddRange(new string[] {
"UnrealTournament/Private/Slate",
"UnrealTournament/Private/Slate/Base",
"UnrealTournament/Private/Slate/Dialogs",
"UnrealTournament/Private/Slate/Menus",
"UnrealTournament/Private/Slate/Panels",
"UnrealTournament/Private/Slate/Toasts",
"UnrealTournament/Private/Slate/Widgets",
"UnrealTournament/Private/Slate/UIWindows",
});
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"UTReplayStreamer",
}
);
PublicDependencyModuleNames.AddRange(new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"GameplayTasks",
"AIModule",
"OnlineSubsystem",
"OnlineSubsystemUtils",
"RenderCore",
"Navmesh",
"WebBrowser",
"NetworkReplayStreaming",
"InMemoryNetworkReplayStreaming",
"Json",
"JsonUtilities",
"HTTP",
"UMG",
"Party",
"Lobby",
"Qos",
"BlueprintContext",
"EngineSettings",
"Landscape",
"Foliage",
"PerfCounters",
"PakFile",
"UnrealTournamentFullScreenMovie"
});
PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore", "FriendsAndChat", "Sockets", "Analytics", "AnalyticsET" });
if (Target.Type != TargetRules.TargetType.Server)
{
PublicDependencyModuleNames.AddRange(new string[] { "AppFramework", "RHI", "SlateRHIRenderer", "MoviePlayer" });
}
if (Target.Type == TargetRules.TargetType.Editor)
{
PublicDependencyModuleNames.AddRange(new string[] { "UnrealEd", "SourceControl", "Matinee", "PropertyEditor", "ShaderCore" });
}
CircularlyReferencedDependentModules.Add("BlueprintContext");
if (!IsLicenseeBuild())
{
Definitions.Add("WITH_PROFILE=1");
Definitions.Add("WITH_SOCIAL=1");
PublicIncludePathModuleNames.Add("Social");
PublicDependencyModuleNames.AddRange(
new string[]
{
"OnlineSubsystemMcp",
"McpProfileSys",
"UTMcpProfile",
"Social",
}
);
}
else
{
Definitions.Add("WITH_PROFILE=0");
Definitions.Add("WITH_SOCIAL=0");
PublicDependencyModuleNames.AddRange(
new string[]
{
"GithubStubs",
}
);
}
}
public MeshPaintMode(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools"
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"MeshPaint",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"DesktopPlatform",
"Engine",
"InputCore",
"RenderCore",
"RHI",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"RawMesh",
"SourceControl",
"ViewportInteraction",
"VREditor",
"PropertyEditor",
"MainFrame",
"MeshPaint",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"ViewportInteraction",
"VREditor"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"AssetTools",
"LevelEditor"
});
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools"
}
);
}
public Engine(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("../Shaders/Shared");
PrivatePCHHeaderFile = "Private/EnginePrivatePCH.h";
SharedPCHHeaderFile = "Public/EngineSharedPCH.h";
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "AudioMixer", "AudioMixerCore", "AnimationCore" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"ImageWrapper",
"ImageWriteQueue",
"HeadMountedDisplay",
"EyeTracker",
"MRMesh",
"Advertising",
"MovieSceneCapture",
"AutomationWorker",
"MovieSceneCapture",
"DesktopPlatform",
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TaskGraph",
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"EditorAnalyticsSession",
}
);
}
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"NetCore",
"ApplicationCore",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"MessagingCommon",
"RenderCore",
"RHI",
"Sockets",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"GameplayTags",
"PacketHandler",
"AudioPlatformConfiguration",
"MeshDescription",
"StaticMeshDescription",
"PakFile",
"NetworkReplayStreaming",
"PhysicsCore",
"SignalProcessing"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Landscape",
"UMG",
"Projects",
"MaterialShaderQualitySettings",
"CinematicCamera",
"Analytics",
"AnalyticsET",
"AudioMixer",
"AudioMixerCore",
"SignalProcessing",
"CrunchCompression",
}
);
// Cross platform Audio Codecs:
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
DynamicallyLoadedModuleNames.Add("EyeTracker");
if (Target.bUseXGEController &&
Target.Type == TargetType.Editor &&
(Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32))
{
PrivateDependencyModuleNames.Add("XGEController");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.Add("Localization");
DynamicallyLoadedModuleNames.Add("Localization");
}
// to prevent "causes WARNING: Non-editor build cannot depend on non-redistributable modules."
if (Target.Type == TargetType.Editor)
{
// for now we depend on this
PrivateDependencyModuleNames.Add("RawMesh");
PrivateDependencyModuleNames.Add("MeshDescriptionOperations");
}
bool bVariadicTemplatesSupported = true;
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Use reflection to allow type not to exist if console code is not present
System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool");
if (XboxOnePlatformType != null)
{
System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
if (VersionName.ToString().Equals("2012"))
{
bVariadicTemplatesSupported = false;
}
}
AddEngineThirdPartyPrivateStaticDependencies(Target,
"libOpus"
);
}
if (bVariadicTemplatesSupported)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
if (Target.Type == TargetType.Editor)
{
// these modules require variadic templates
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
}
}
CircularlyReferencedDependentModules.Add("GameplayTags");
CircularlyReferencedDependentModules.Add("Landscape");
CircularlyReferencedDependentModules.Add("UMG");
CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings");
CircularlyReferencedDependentModules.Add("CinematicCamera");
CircularlyReferencedDependentModules.Add("AudioMixer");
if (Target.Type == TargetType.Editor)
{
PrivateIncludePathModuleNames.Add("Foliage");
}
// The AnimGraphRuntime module is not needed by Engine proper, but it is loaded in LaunchEngineLoop.cpp,
// and needs to be listed in an always-included module in order to be compiled into standalone games
DynamicallyLoadedModuleNames.Add("AnimGraphRuntime");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneCapture",
"MovieSceneTracks",
"LevelSequence",
"HeadMountedDisplay",
"MRMesh",
"StreamingPauseRendering",
}
);
if (Target.Type != TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Media",
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
if (Target.Type == TargetType.Server || Target.Type == TargetType.Editor)
{
PrivateDependencyModuleNames.Add("PerfCounters");
}
if (Target.Type == TargetType.Editor)
{
PrivateIncludePathModuleNames.Add("MeshUtilities");
PrivateIncludePathModuleNames.Add("MeshUtilitiesCommon");
DynamicallyLoadedModuleNames.Add("MeshUtilities");
PrivateDependencyModuleNames.AddRange(
new string[] {
"ImageCore",
"RawMesh"
}
);
PrivateDependencyModuleNames.Add("CollisionAnalyzer");
CircularlyReferencedDependentModules.Add("CollisionAnalyzer");
PrivateDependencyModuleNames.Add("LogVisualizer");
CircularlyReferencedDependentModules.Add("LogVisualizer");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WindowsTargetPlatform",
"WindowsNoEditorTargetPlatform",
"WindowsServerTargetPlatform",
"WindowsClientTargetPlatform",
"AllDesktopTargetPlatform",
"WindowsPlatformEditor",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform",
"AllDesktopTargetPlatform",
"MacPlatformEditor",
}
);
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxAArch64NoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"LinuxAArch64ServerTargetPlatform",
"LinuxClientTargetPlatform",
"LinuxAArch64ClientTargetPlatform",
"AllDesktopTargetPlatform",
"LinuxPlatformEditor",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"NullNetworkReplayStreaming",
"LocalFileNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"Advertising"
}
);
if (Target.bWithLiveCoding)
{
DynamicallyLoadedModuleNames.Add("LiveCoding");
}
if (Target.Type != TargetType.Server)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ImageWrapper"
}
);
}
WhitelistRestrictedFolders.Add("Private/NotForLicensees");
if (!Target.bBuildRequiresCookedData && Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"DerivedDataCache",
"TargetPlatform",
"DesktopPlatform"
}
);
}
if (Target.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
); // @todo api: Only public because of WITH_EDITOR and UNREALED_API
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
);
PrivateIncludePathModuleNames.Add("TextureCompressor");
PrivateIncludePaths.Add("Developer/TextureCompressor/Public");
PrivateIncludePathModuleNames.Add("HierarchicalLODUtilities");
DynamicallyLoadedModuleNames.Add("HierarchicalLODUtilities");
DynamicallyLoadedModuleNames.Add("AnimationModifiers");
PrivateIncludePathModuleNames.Add("AssetTools");
DynamicallyLoadedModuleNames.Add("AssetTools");
PrivateIncludePathModuleNames.Add("PIEPreviewDeviceProfileSelector");
}
SetupModulePhysicsSupport(Target);
if (Target.bCompilePhysX && (Target.bBuildEditor || Target.bCompileAPEX))
{
DynamicallyLoadedModuleNames.Add("PhysXCooking");
}
PublicDependencyModuleNames.AddRange(
new string[] {
"PhysicsSQ",
"ChaosSolvers"
}
);
// Engine public headers need to know about some types (enums etc.)
PublicIncludePathModuleNames.Add("ClothingSystemRuntimeInterface");
PublicDependencyModuleNames.Add("ClothingSystemRuntimeInterface");
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.Add("ClothingSystemEditorInterface");
PrivateIncludePathModuleNames.Add("ClothingSystemEditorInterface");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
// Head Mounted Display support
// PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
// DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
PrivateDependencyModuleNames.Add("AndroidRuntimeSettings");
}
if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PrivateDependencyModuleNames.Add("IOSRuntimeSettings");
}
if (Target.Platform == UnrealTargetPlatform.Switch)
{
PrivateDependencyModuleNames.Add("SwitchRuntimeSettings");
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
PublicDefinitions.Add("GPUPARTICLE_LOCAL_VF_ONLY=0");
// Add a reference to the stats HTML files referenced by UEngine::DumpFPSChartToHTML. Previously staged by CopyBuildToStagingDirectory.
if (Target.bBuildEditor || Target.Configuration != UnrealTargetConfiguration.Shipping)
{
RuntimeDependencies.Add("$(EngineDir)/Content/Stats/...", StagedFileType.UFS);
}
}
public Engine(TargetInfo Target)
{
SharedPCHHeaderFile = "Runtime/Engine/Public/Engine.h";
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/Online/OnlineSubsystem/Public",
"Runtime/Online/OnlineSubsystemUtils/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"OnlineSubsystem",
"TargetPlatform",
"ImageWrapper",
"HeadMountedDisplay",
"Advertising",
"NetworkReplayStreaming",
"MovieSceneCapture",
"AutomationWorker",
"Analytics",
"MovieSceneCapture",
"DesktopPlatform",
"Analytics"
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
}
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"RenderCore",
"RHI",
"ShaderCore",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"AIModule",
"DatabaseSupport",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "CrashTracker" });
DynamicallyLoadedModuleNames.AddRange(new string[] { "CrashTracker" });
PublicDependencyModuleNames.AddRange(
new string[] {
"CookingStats",
}
);
}
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Sockets",
"Landscape",
"UMG",
"Projects",
"Niagara",
"Internationalization",
"PacketHandler",
"MaterialShaderQualitySettings",
}
);
if (Target.Platform != UnrealTargetPlatform.XboxOne)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
// these modules require variadic templates
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
}
}
CircularlyReferencedDependentModules.Add("AIModule");
CircularlyReferencedDependentModules.Add("Landscape");
CircularlyReferencedDependentModules.Add("UMG");
CircularlyReferencedDependentModules.Add("Niagara");
CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings");
// The AnimGraphRuntime module is not needed by Engine proper, but it is loaded in LaunchEngineLoop.cpp,
// and needs to be listed in an always-included module in order to be compiled into standalone games
DynamicallyLoadedModuleNames.Add("AnimGraphRuntime");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneCapture",
"MovieSceneTracks",
"HeadMountedDisplay",
"StreamingPauseRendering",
}
);
PrivateIncludePathModuleNames.Add("LightPropagationVolumeRuntime");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
if (Target.Type == TargetRules.TargetType.Server || Target.Type == TargetRules.TargetType.Editor)
{
PrivateDependencyModuleNames.Add("PerfCounters");
}
if (UEBuildConfiguration.bBuildDeveloperTools)
{
// Add "BlankModule" so that it gets compiled as an example and will be maintained and tested. This can be removed
// at any time if needed. The module isn't actually loaded by the engine so there is no runtime cost.
DynamicallyLoadedModuleNames.Add("BlankModule");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.Add("MeshUtilities");
DynamicallyLoadedModuleNames.Add("MeshUtilities");
PrivateDependencyModuleNames.AddRange(
new string[] {
"ImageCore",
"RawMesh"
});
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test && Target.Type != TargetRules.TargetType.Server)
{
PrivateDependencyModuleNames.Add("CollisionAnalyzer");
CircularlyReferencedDependentModules.Add("CollisionAnalyzer");
PrivateDependencyModuleNames.Add("LogVisualizer");
CircularlyReferencedDependentModules.Add("LogVisualizer");
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WindowsTargetPlatform",
"WindowsNoEditorTargetPlatform",
"WindowsServerTargetPlatform",
"WindowsClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Analytics",
"AnalyticsET",
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"OnlineSubsystem",
"OnlineSubsystemUtils",
"Advertising"
}
);
if (Target.Type.Value != TargetRules.TargetType.Server)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ImageWrapper",
"GameLiveStreaming"
}
);
}
if (!UEBuildConfiguration.bBuildRequiresCookedData && UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"DerivedDataCache",
"TargetPlatform",
"DesktopPlatform"
}
);
}
if (UEBuildConfiguration.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
); // @todo api: Only public because of WITH_EDITOR and UNREALED_API
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
);
PrivateIncludePathModuleNames.Add("TextureCompressor");
PrivateIncludePaths.Add("Developer/TextureCompressor/Public");
}
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompilePhysX && UEBuildConfiguration.bRuntimePhysicsCooking)
{
DynamicallyLoadedModuleNames.Add("PhysXFormats");
PrivateIncludePathModuleNames.Add("PhysXFormats");
}
SetupModuleBox2DSupport(Target);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
AddThirdPartyPrivateStaticDependencies(Target, "DirectShow");
}
// Head Mounted Display support
// PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
// DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
AddThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32")
{
PublicDependencyModuleNames.Add("HTML5JS");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"libOpus"
);
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
AddThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
if (UEBuildConfiguration.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
Definitions.Add("WITH_RECAST=1");
}
else
{
// Because we test WITH_RECAST in public Engine header files, we need to make sure that modules
// that import this also have this definition set appropriately. Recast is a private dependency
// module, so it's definitions won't propagate to modules that import Engine.
Definitions.Add("WITH_RECAST=0");
}
}
public LandscapeEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"Slate",
"SlateCore",
"EditorStyle",
"Engine",
"Landscape",
"RenderCore",
"RHI",
"InputCore",
"UnrealEd",
"PropertyEditor",
"ImageWrapper",
"EditorWidgets",
"Foliage",
"ViewportInteraction",
"VREditor",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"ViewportInteraction",
"VREditor"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MainFrame",
"DesktopPlatform",
"ContentBrowser",
"AssetTools",
"LevelEditor"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MainFrame",
"DesktopPlatform",
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
// VS2015 updated some of the CRT definitions but not all of the Windows SDK has been updated to match.
// Microsoft provides this shim library to enable building with VS2015 until they fix everything up.
//@todo: remove when no longer neeeded (no other code changes should be necessary).
if (Target.WindowsPlatform.bNeedsLegacyStdioDefinitionsLib)
{
PublicAdditionalLibraries.Add("legacy_stdio_definitions.lib");
}
}
// KissFFT is used by the smooth tool.
if (Target.bCompileLeanAndMeanUE == false &&
(Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux))
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Kiss_FFT");
}
else
{
Definitions.Add("WITH_KISSFFT=0");
}
}
public WebBrowser(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.Add("Runtime/WebBrowser/Public");
PrivateIncludePaths.Add("Runtime/WebBrowser/Private");
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"ApplicationCore",
"RHI",
"InputCore",
"Serialization",
"HTTP"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Slate",
"SlateCore"
}
);
if (Target.Platform == UnrealTargetPlatform.Android ||
Target.Platform == UnrealTargetPlatform.IOS ||
Target.Platform == UnrealTargetPlatform.TVOS)
{
// We need these on mobile for external texture support
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Engine",
"Launch",
"WebBrowserTexture"
}
);
// We need this one on Android for URL decoding
PrivateDependencyModuleNames.Add("HTTP");
CircularlyReferencedDependentModules.Add("WebBrowserTexture");
}
if (Target.Platform == UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Mac ||
Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateDependencyModuleNames.Add("CEF3Utils");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"CEF3"
);
if (Target.Type != TargetType.Server)
{
if (Target.Platform == UnrealTargetPlatform.Mac)
{
// Add contents of UnrealCefSubProcess.app directory as runtime dependencies
foreach (string FilePath in Directory.EnumerateFiles(Target.RelativeEnginePath + "/Binaries/Mac/UnrealCEFSubProcess.app", "*", SearchOption.AllDirectories))
{
RuntimeDependencies.Add(FilePath);
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
RuntimeDependencies.Add("$(EngineDir)/Binaries/" + Target.Platform.ToString() + "/UnrealCEFSubProcess");
}
else
{
RuntimeDependencies.Add("$(EngineDir)/Binaries/" + Target.Platform.ToString() + "/UnrealCEFSubProcess.exe");
}
}
}
if (Target.Platform == UnrealTargetPlatform.PS4 &&
Target.bCompileAgainstEngine)
{
PrivateDependencyModuleNames.Add("Engine");
}
if (Target.Platform == UnrealTargetPlatform.Lumin)
{
PrecompileForTargets = ModuleRules.PrecompileTargetsType.None;
}
}
public Landscape(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Engine/Private", // for Engine/Private/Collision/PhysXCollision.h
"Runtime/Landscape/Private"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"DerivedDataCache",
"Foliage",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"Engine",
"RenderCore",
"RHI",
"ShaderCore",
"Renderer",
"Foliage",
}
);
SetupModulePhysXAPEXSupport(Target);
if (Target.bCompilePhysX && Target.bBuildEditor)
{
DynamicallyLoadedModuleNames.Add("PhysXCooking");
}
if (Target.bBuildDeveloperTools && Target.Type != TargetType.Server)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"RawMesh"
}
);
}
if (Target.bBuildEditor == true)
{
// TODO: Remove all landscape editing code from the Landscape module!!!
PrivateIncludePathModuleNames.Add("LandscapeEditor");
PrivateDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"MaterialUtilities",
"SlateCore",
"Slate",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"MaterialUtilities",
}
);
}
}
public SourceControl(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Developer/SourceControl/Private");
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"InputCore",
}
);
if (Target.Platform == UnrealTargetPlatform.Linux && Target.Type == TargetType.Program)
{
PublicDefinitions.Add("SOURCE_CONTROL_WITH_SLATE=0");
}
else
{
PublicDefinitions.Add("SOURCE_CONTROL_WITH_SLATE=1");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Slate",
"SlateCore",
"EditorStyle"
}
);
}
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Engine",
"UnrealEd",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetTools"
}
);
CircularlyReferencedDependentModules.Add("UnrealEd");
}
if (Target.bBuildDeveloperTools)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessageLog",
}
);
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrecompileForTargets = PrecompileTargetsType.Any;
}
}
public Kismet(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Editor/Kismet/Private");
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"BlueprintRuntime",
"ClassViewer",
"Analytics",
"DerivedDataCache",
"LevelEditor",
"GameProjectGeneration",
"Sequencer",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"Slate",
"SlateCore",
"EditorStyle",
"EditorWidgets",
"Engine",
"Json",
"Merge",
"MessageLog",
"UnrealEd",
"GraphEditor",
"KismetWidgets",
"BlueprintGraph",
"AnimGraph",
"PropertyEditor",
"SourceControl",
"SharedSettingsWidgets",
"InputCore",
"EngineSettings",
"Projects",
"JsonUtilities",
"DerivedDataCache",
"DesktopPlatform",
"HotReload",
"BlueprintNativeCodeGen",
"BlueprintProfiler",
"UMGEditor",
"UMG" // for SBlueprintDiff
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"BlueprintRuntime",
"ClassViewer",
"Documentation",
"GameProjectGeneration",
"BlueprintCompilerCppBackend",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"BlueprintGraph",
"UMGEditor",
}
);
}
public FUCK15(TargetInfo Target)
{
//PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
//PrivateDependencyModuleNames.AddRange(new string[] { });
// Uncomment if you are using Slate UI
// PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" });
// Uncomment if you are using online features
// PrivateDependencyModuleNames.Add("OnlineSubsystem");
// To include OnlineSubsystemSteam, add it to the plugins section in your uproject file with the Enabled attribute set to true
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "NetworkReplayStreaming" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"ImageWrapper",
"HeadMountedDisplay",
"Advertising",
"NetworkReplayStreaming",
"MovieSceneCapture",
"AutomationWorker",
"MovieSceneCapture",
"DesktopPlatform",
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
}
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"RenderCore",
"RHI",
"ShaderCore",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"GameplayTags",
"AIModule",
"DatabaseSupport",
"PacketHandler",
"HardwareSurvey",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "CrashTracker" });
DynamicallyLoadedModuleNames.AddRange(new string[] { "CrashTracker" });
PublicDependencyModuleNames.AddRange(
new string[] {
}
);
}
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Sockets",
"Landscape",
"UMG",
"Projects",
"Internationalization",
"MaterialShaderQualitySettings",
"CinematicCamera",
"Analytics",
"AnalyticsET",
}
);
// to prevent "causes WARNING: Non-editor build cannot depend on non-redistributable modules."
if (Target.Type == TargetRules.TargetType.Editor)
{
// for now we depend on this
PrivateDependencyModuleNames.Add("RawMesh");
}
bool bVariadicTemplatesSupported = true;
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Use reflection to allow type not to exist if console code is not present
System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool");
if (XboxOnePlatformType != null)
{
System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
if (VersionName.ToString().Equals("2012"))
{
bVariadicTemplatesSupported = false;
}
}
}
if (bVariadicTemplatesSupported)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
// these modules require variadic templates
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
}
}
CircularlyReferencedDependentModules.Add("GameplayTags");
CircularlyReferencedDependentModules.Add("AIModule");
CircularlyReferencedDependentModules.Add("Landscape");
CircularlyReferencedDependentModules.Add("UMG");
CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings");
CircularlyReferencedDependentModules.Add("CinematicCamera");
// The AnimGraphRuntime module is not needed by Engine proper, but it is loaded in LaunchEngineLoop.cpp,
// and needs to be listed in an always-included module in order to be compiled into standalone games
DynamicallyLoadedModuleNames.Add("AnimGraphRuntime");
// So does Geometry Cache
DynamicallyLoadedModuleNames.Add("GeometryCache");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"ActorSequence",
"MovieScene",
"MovieSceneCapture",
"MovieSceneTracks",
"HeadMountedDisplay",
"StreamingPauseRendering",
}
);
PrivateIncludePathModuleNames.Add("LightPropagationVolumeRuntime");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
if (Target.Type == TargetRules.TargetType.Server || Target.Type == TargetRules.TargetType.Editor)
{
PrivateDependencyModuleNames.Add("PerfCounters");
}
if (UEBuildConfiguration.bBuildDeveloperTools)
{
// Add "BlankModule" so that it gets compiled as an example and will be maintained and tested. This can be removed
// at any time if needed. The module isn't actually loaded by the engine so there is no runtime cost.
DynamicallyLoadedModuleNames.Add("BlankModule");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.Add("MeshUtilities");
DynamicallyLoadedModuleNames.Add("MeshUtilities");
PrivateDependencyModuleNames.AddRange(
new string[] {
"ImageCore",
"RawMesh"
});
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test && Target.Type != TargetRules.TargetType.Server)
{
PrivateDependencyModuleNames.Add("CollisionAnalyzer");
CircularlyReferencedDependentModules.Add("CollisionAnalyzer");
PrivateDependencyModuleNames.Add("LogVisualizer");
CircularlyReferencedDependentModules.Add("LogVisualizer");
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WindowsTargetPlatform",
"WindowsNoEditorTargetPlatform",
"WindowsServerTargetPlatform",
"WindowsClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"LinuxClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"Advertising"
}
);
if (Target.Type.Value != TargetRules.TargetType.Server)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ImageWrapper",
"GameLiveStreaming"
}
);
}
if (!UEBuildConfiguration.bBuildRequiresCookedData && UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"DerivedDataCache",
"TargetPlatform",
"DesktopPlatform"
}
);
}
if (UEBuildConfiguration.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
); // @todo api: Only public because of WITH_EDITOR and UNREALED_API
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
);
PrivateIncludePathModuleNames.Add("TextureCompressor");
PrivateIncludePaths.Add("Developer/TextureCompressor/Public");
PrivateIncludePathModuleNames.Add("HierarchicalLODUtilities");
DynamicallyLoadedModuleNames.Add("HierarchicalLODUtilities");
}
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompilePhysX && UEBuildConfiguration.bRuntimePhysicsCooking)
{
DynamicallyLoadedModuleNames.Add("PhysXFormats");
PrivateIncludePathModuleNames.Add("PhysXFormats");
}
SetupModuleBox2DSupport(Target);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus",
"OpenSubdiv"
);
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectShow");
}
// Head Mounted Display support
// PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
// DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32")
{
PublicDependencyModuleNames.Add("HTML5JS");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"libOpus"
);
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
if (UEBuildConfiguration.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
Definitions.Add("WITH_RECAST=1");
}
else
{
// Because we test WITH_RECAST in public Engine header files, we need to make sure that modules
// that import this also have this definition set appropriately. Recast is a private dependency
// module, so it's definitions won't propagate to modules that import Engine.
Definitions.Add("WITH_RECAST=0");
}
// Add a reference to the stats HTML files referenced by UEngine::DumpFPSChartToHTML. Previously staged by CopyBuildToStagingDirectory.
if (UEBuildConfiguration.bBuildEditor || Target.Configuration != UnrealTargetConfiguration.Shipping)
{
RuntimeDependencies.Add("$(EngineDir)/Content/Stats/...", StagedFileType.UFS);
}
DynamicallyLoadedModuleNames.Add("Niagara");
}
public 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",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"TargetPlatform",
}
);
if (!Target.bBuildRequiresCookedData && Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("DerivedDataCache");
}
SetupModulePhysicsSupport(Target);
if (Target.bCompileChaos || Target.bUseChaos)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Chaos",
"GeometryCollectionEngine",
}
);
}
if (Target.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
PublicDefinitions.Add("WITH_RECAST=1");
if (Target.bCompileNavmeshSegmentLinks)
{
PublicDefinitions.Add("WITH_NAVMESH_SEGMENT_LINKS=1");
}
else
{
PublicDefinitions.Add("WITH_NAVMESH_SEGMENT_LINKS=0");
}
if (Target.bCompileNavmeshClusterLinks)
{
PublicDefinitions.Add("WITH_NAVMESH_CLUSTER_LINKS=1");
}
else
{
PublicDefinitions.Add("WITH_NAVMESH_CLUSTER_LINKS=0");
}
}
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");
PublicDefinitions.Add("WITH_NAVMESH_CLUSTER_LINKS=0");
PublicDefinitions.Add("WITH_NAVMESH_SEGMENT_LINKS=0");
}
if (Target.bBuildEditor == true)
{
// @todo api: Only public because of WITH_EDITOR and UNREALED_API
PublicDependencyModuleNames.Add("UnrealEd");
CircularlyReferencedDependentModules.Add("UnrealEd");
}
}
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[]
{
"BehaviorTreeEditor",
"ClassViewer",
"ContentBrowser",
"DerivedDataCache",
"DesktopPlatform",
"LauncherPlatform",
"EnvironmentQueryEditor",
"GameProjectGeneration",
"ProjectTargetPlatformEditor",
"ImageWrapper",
"MainFrame",
"MaterialEditor",
"MergeActors",
"MeshUtilities",
"MessagingCommon",
"MovieSceneCapture",
"PlacementMode",
"Settings",
"SettingsEditor",
"AudioEditor",
"ViewportSnapping",
"SourceCodeAccess",
"ReferenceViewer",
"IntroTutorials",
"OutputLog",
"Landscape",
"SizeMap",
"LocalizationService",
"HierarchicalLODUtilities",
"MessagingRpc",
"PortalRpc",
"PortalServices",
"BlueprintNativeCodeGen",
"ViewportInteraction",
"VREditor",
"Persona",
"PhysicsAssetEditor",
"ClothingSystemEditorInterface",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"BspMode",
"Core",
"CoreUObject",
"ApplicationCore",
"DirectoryWatcher",
"Documentation",
"Engine",
"Json",
"Projects",
"SandboxFile",
"Slate",
"SlateCore",
"EditorStyle",
"SourceControl",
"UnrealEdMessages",
"AIModule",
"GameplayDebugger",
"BlueprintGraph",
"Http",
"UnrealAudio",
"FunctionalTesting",
"AutomationController",
"Localization",
"AudioEditor",
"NetworkFileSystem",
"UMG",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AssetRegistry",
"LevelSequence",
"AnimGraph",
"AppFramework",
"BlueprintGraph",
"CinematicCamera",
"DesktopPlatform",
"LauncherPlatform",
"EditorStyle",
"EngineSettings",
"InputCore",
"InputBindingEditor",
"LauncherServices",
"MaterialEditor",
"MessageLog",
"PakFile",
"PropertyEditor",
"Projects",
"RawMesh",
"RenderCore",
"RHI",
"ShaderCore",
"Sockets",
"SourceControlWindows",
"StatsViewer",
"SwarmInterface",
"TargetPlatform",
"TargetDeviceServices",
"EditorWidgets",
"GraphEditor",
"Kismet",
"InternationalizationSettings",
"JsonUtilities",
"Landscape",
"HeadMountedDisplay",
"MeshPaint",
"MeshPaintMode",
"Foliage",
"VectorVM",
"TreeMap",
"MaterialUtilities",
"Localization",
"LocalizationService",
"AddContentDialog",
"GameProjectGeneration",
"HierarchicalLODUtilities",
"Analytics",
"AnalyticsET",
"PluginWarden",
"PixelInspectorModule",
"MovieScene",
"MovieSceneTracks",
"ViewportInteraction",
"VREditor",
"ClothingSystemEditor",
"ClothingSystemRuntime",
"ClothingSystemRuntimeInterface",
"PIEPreviewDeviceProfileSelector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"FontEditor",
"StaticMeshEditor",
"TextureEditor",
"Cascade",
"UMGEditor",
"Matinee",
"AssetTools",
"ClassViewer",
"CollectionManager",
"ContentBrowser",
"CurveTableEditor",
"DataTableEditor",
"EditorSettingsViewer",
"LandscapeEditor",
"KismetCompiler",
"DetailCustomizations",
"ComponentVisualizers",
"MainFrame",
"LevelEditor",
"PackagesDialog",
"Persona",
"PhysicsAssetEditor",
"ProjectLauncher",
"DeviceManager",
"SettingsEditor",
"SessionFrontend",
"Sequencer",
"StringTableEditor",
"GeometryMode",
"TextureAlignMode",
"FoliageEdit",
"ImageWrapper",
"Blutility",
"IntroTutorials",
"WorkspaceMenuStructure",
"PlacementMode",
"MeshUtilities",
"MergeActors",
"ProjectSettingsViewer",
"ProjectTargetPlatformEditor",
"PListEditor",
"BehaviorTreeEditor",
"EnvironmentQueryEditor",
"ViewportSnapping",
"GameplayTasksEditor",
"UndoHistory",
"SourceCodeAccess",
"ReferenceViewer",
"HotReload",
"HTML5PlatformEditor",
"SizeMap",
"PortalProxies",
"PortalServices",
"GeometryCacheEd",
"BlueprintNativeCodeGen",
"OverlayEditor",
"AnimationModifiers",
"ClothPainter",
}
);
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");
}
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"GraphEditor",
"Kismet",
"AudioEditor",
"ViewportInteraction",
"VREditor"
}
);
// Add include directory for Lightmass
PublicIncludePaths.Add("Programs/UnrealLightmass/Public");
PublicIncludePathModuleNames.AddRange(
new string[] {
"CollectionManager",
"BlueprintGraph",
"AddContentDialog",
"MeshUtilities",
"AssetTools",
"KismetCompiler",
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDependencyModuleNames.Add("XAudio2");
PublicDependencyModuleNames.Add("AudioMixerXAudio2");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"DX11Audio"
);
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PublicDependencyModuleNames.Add("ALAudio");
PublicDependencyModuleNames.Add("AudioMixerSDL");
}
AddEngineThirdPartyPrivateStaticDependencies(Target,
"VHACD",
"FBX",
"FreeType2"
);
SetupModulePhysXAPEXSupport(Target);
if (Target.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
Definitions.Add("WITH_RECAST=1");
}
else
{
Definitions.Add("WITH_RECAST=0");
}
// @third party code - BEGIN HairWorks
AddEngineThirdPartyPrivateStaticDependencies(Target, "HairWorks");
// @third party code - END HairWorks
}
public MovieSceneTools(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/MovieSceneTools/Private",
"Editor/MovieSceneTools/Private/CurveKeyEditors",
"Editor/MovieSceneTools/Private/TrackEditors",
"Editor/MovieSceneTools/Private/TrackEditors/PropertyTrackEditors",
"Editor/MovieSceneTools/Private/TrackEditorThumbnail",
"Editor/MovieSceneTools/Private/Sections",
"Editor/UnrealEd/Private", //compatibility for FBX importer
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"MovieSceneCapture",
"UnrealEd",
"Sequencer",
"EditorWidgets",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"ActorPickerMode",
"CinematicCamera",
"CurveEditor",
"DesktopPlatform",
"Json",
"JsonUtilities",
"LevelSequence",
"LiveLinkInterface",
"MessageLog",
"MovieScene",
"MovieSceneTracks",
"BlueprintGraph",
"Kismet",
"KismetCompiler",
"GraphEditor",
"ContentBrowser",
"Slate",
"SlateCore",
"EditorStyle",
"PropertyEditor",
"MaterialEditor",
"RenderCore",
"RHI",
"SequenceRecorder",
"TimeManagement",
"AnimationCore",
"TimeManagement",
"XmlParser",
"ToolMenus",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"Sequencer",
"Settings",
"SceneOutliner",
"MainFrame",
"UnrealEd",
"Analytics",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"SceneOutliner",
"MainFrame",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"Sequencer",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "FBX");
}
public Engine(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/EnginePrivatePCH.h";
SharedPCHHeaderFile = "Public/EngineSharedPCH.h";
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "NetworkReplayStreaming", "AudioMixer" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"ImageWrapper",
"HeadMountedDisplay",
"MRMesh",
"Advertising",
"NetworkReplayStreaming",
"MovieSceneCapture",
"AutomationWorker",
"MovieSceneCapture",
"DesktopPlatform",
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
}
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"MessagingCommon",
"RenderCore",
"RHI",
"ShaderCore",
"UtilityShaders",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"GameplayTags",
"AIModule",
"DatabaseSupport",
"PacketHandler",
"HardwareSurvey",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Sockets",
"Landscape",
"UMG",
"Projects",
"MaterialShaderQualitySettings",
"CinematicCamera",
"Analytics",
"AnalyticsET"
}
);
if (Target.bUseXGEController &&
Target.Type == TargetType.Editor &&
(Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32))
{
PrivateDependencyModuleNames.Add("XGEController");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.Add("Localization");
DynamicallyLoadedModuleNames.Add("Localization");
}
// to prevent "causes WARNING: Non-editor build cannot depend on non-redistributable modules."
if (Target.Type == TargetType.Editor)
{
// for now we depend on this
PrivateDependencyModuleNames.Add("RawMesh");
}
bool bVariadicTemplatesSupported = true;
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Use reflection to allow type not to exist if console code is not present
System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool");
if (XboxOnePlatformType != null)
{
System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
if (VersionName.ToString().Equals("2012"))
{
bVariadicTemplatesSupported = false;
}
}
AddEngineThirdPartyPrivateStaticDependencies(Target,
"libOpus"
);
}
if (bVariadicTemplatesSupported)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
if (Target.Type == TargetType.Editor)
{
// these modules require variadic templates
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
}
}
CircularlyReferencedDependentModules.Add("GameplayTags");
CircularlyReferencedDependentModules.Add("AIModule");
CircularlyReferencedDependentModules.Add("Landscape");
CircularlyReferencedDependentModules.Add("UMG");
CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings");
CircularlyReferencedDependentModules.Add("CinematicCamera");
// The AnimGraphRuntime module is not needed by Engine proper, but it is loaded in LaunchEngineLoop.cpp,
// and needs to be listed in an always-included module in order to be compiled into standalone games
DynamicallyLoadedModuleNames.Add("AnimGraphRuntime");
// So does Geometry Cache
DynamicallyLoadedModuleNames.Add("GeometryCache");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneCapture",
"MovieSceneTracks",
"HeadMountedDisplay",
"MRMesh",
"StreamingPauseRendering",
}
);
if (Target.Type != TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
if (Target.Type == TargetType.Server || Target.Type == TargetType.Editor)
{
PrivateDependencyModuleNames.Add("PerfCounters");
}
if (Target.bBuildDeveloperTools)
{
// Add "BlankModule" so that it gets compiled as an example and will be maintained and tested. This can be removed
// at any time if needed. The module isn't actually loaded by the engine so there is no runtime cost.
DynamicallyLoadedModuleNames.Add("BlankModule");
if (Target.Type != TargetType.Server)
{
PrivateIncludePathModuleNames.Add("MeshUtilities");
DynamicallyLoadedModuleNames.Add("MeshUtilities");
PrivateDependencyModuleNames.AddRange(
new string[] {
"ImageCore",
"RawMesh"
}
);
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test && Target.Type != TargetType.Server)
{
PrivateDependencyModuleNames.Add("CollisionAnalyzer");
CircularlyReferencedDependentModules.Add("CollisionAnalyzer");
PrivateDependencyModuleNames.Add("LogVisualizer");
CircularlyReferencedDependentModules.Add("LogVisualizer");
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WindowsTargetPlatform",
"WindowsNoEditorTargetPlatform",
"WindowsServerTargetPlatform",
"WindowsClientTargetPlatform",
"AllDesktopTargetPlatform",
"WindowsPlatformEditor",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform",
"AllDesktopTargetPlatform",
"MacPlatformEditor",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"LinuxClientTargetPlatform",
"AllDesktopTargetPlatform",
"LinuxPlatformEditor",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"Advertising"
}
);
if (Target.Type != TargetType.Server)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ImageWrapper"
}
);
}
WhitelistRestrictedFolders.Add("Private/NotForLicensees");
if (!Target.bBuildRequiresCookedData && Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"DerivedDataCache",
"TargetPlatform",
"DesktopPlatform"
}
);
}
if (Target.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
); // @todo api: Only public because of WITH_EDITOR and UNREALED_API
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
);
PrivateIncludePathModuleNames.Add("TextureCompressor");
PrivateIncludePaths.Add("Developer/TextureCompressor/Public");
PrivateIncludePathModuleNames.Add("HierarchicalLODUtilities");
DynamicallyLoadedModuleNames.Add("HierarchicalLODUtilities");
DynamicallyLoadedModuleNames.Add("AnimationModifiers");
PrivateIncludePathModuleNames.Add("AssetTools");
DynamicallyLoadedModuleNames.Add("AssetTools");
PrivateIncludePathModuleNames.Add("PIEPreviewDeviceProfileSelector");
}
SetupModulePhysXAPEXSupport(Target);
if (Target.bCompilePhysX && (Target.bBuildEditor || Target.bCompileAPEX))
{
DynamicallyLoadedModuleNames.Add("PhysXCooking");
}
// Engine public headers need to know about some types (enums etc.)
PublicIncludePathModuleNames.Add("ClothingSystemRuntimeInterface");
PublicDependencyModuleNames.Add("ClothingSystemRuntimeInterface");
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.Add("ClothingSystemEditorInterface");
PrivateIncludePathModuleNames.Add("ClothingSystemEditorInterface");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
// Head Mounted Display support
// PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
// DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
// TODO test this for HTML5 !
//AddEngineThirdPartyPrivateStaticDependencies(Target,
// "UEOgg",
// "Vorbis",
// "VorbisFile"
// );
PublicDependencyModuleNames.Add("HTML5JS");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"libOpus"
);
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
if (Target.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
PublicDefinitions.Add("WITH_RECAST=1");
}
else
{
// Because we test WITH_RECAST in public Engine header files, we need to make sure that modules
// that import this also have this definition set appropriately. Recast is a private dependency
// module, so it's definitions won't propagate to modules that import Engine.
PublicDefinitions.Add("WITH_RECAST=0");
}
/*
* ConfigHierarchy Ini = ConfigCache.ReadHierarchy(ConfigHierarchyType.Engine, System.IO.DirectoryReference.FromFile(Target.ProjectFile), Target.Platform);
* bool bLocalVectorFieldOnly = false;
* Ini.GetBool("/Script/Engine.RendererSettings", "bGPUParticlesLocalVFOnly", out bLocalVectorFieldOnly);
* if (bLocalVectorFieldOnly)
* {
* PublicDefinitions.Add("GPUPARTICLE_LOCAL_VF_ONLY=1");
* }
* else
* {
* PublicDefinitions.Add("GPUPARTICLE_LOCAL_VF_ONLY=0");
* }
*/
PublicDefinitions.Add("GPUPARTICLE_LOCAL_VF_ONLY=0");
// Add a reference to the stats HTML files referenced by UEngine::DumpFPSChartToHTML. Previously staged by CopyBuildToStagingDirectory.
if (Target.bBuildEditor || Target.Configuration != UnrealTargetConfiguration.Shipping)
{
RuntimeDependencies.Add("$(EngineDir)/Content/Stats/...", StagedFileType.UFS);
}
// @third party code - BEGIN HairWorks
AddEngineThirdPartyPrivateStaticDependencies(Target, "HairWorks");
// @third party code - END HairWorks
// NVCHANGE_BEGIN: Add VXGI
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDependencyModuleNames.Add("VXGI");
}
// NVCHANGE_END: Add VXGI
}
public AudioEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange
(
new string[]
{
"Editor/AudioEditor/Private",
"Editor/AudioEditor/Private/Factories",
"Editor/AudioEditor/Private/AssetTypeActions"
}
);
PrivateDependencyModuleNames.AddRange
(
new string[]
{
"AudioMixer",
"EditorSubsystem",
"GameProjectGeneration",
"ToolMenus",
"UMG",
"UMGEditor",
"AudioExtensions"
}
);
PublicDependencyModuleNames.AddRange
(
new string[]
{
"Core",
"CoreUObject",
"ApplicationCore",
"AudioMixer",
"InputCore",
"Engine",
"UnrealEd",
"Slate",
"SlateCore",
"EditorStyle",
"RenderCore",
"LevelEditor",
"Landscape",
"PropertyEditor",
"DetailCustomizations",
"ClassViewer",
"GraphEditor",
"ContentBrowser",
}
);
PrivateIncludePathModuleNames.AddRange
(
new string[]
{
"AssetTools"
}
);
// Circular references that need to be cleaned up
CircularlyReferencedDependentModules.AddRange
(
new string[]
{
"DetailCustomizations",
}
);
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Windows))
{
string PlatformName = Target.Platform == UnrealTargetPlatform.Win32 ? "Win32" : "Win64";
string LibSndFilePath = Target.UEThirdPartyBinariesDirectory + "libsndfile/";
LibSndFilePath += PlatformName;
PublicAdditionalLibraries.Add(LibSndFilePath + "/libsndfile-1.lib");
PublicDelayLoadDLLs.Add("libsndfile-1.dll");
PublicIncludePathModuleNames.Add("UELibSampleRate");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/libsndfile/" + PlatformName + "/libsndfile-1.dll");
PublicDefinitions.Add("WITH_SNDFILE_IO=1");
}
else
{
PublicDefinitions.Add("WITH_SNDFILE_IO=0");
}
}