public Landscape(TargetInfo Target)
{
bIsAutoStartupModule = true;
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"DerivedDataCache",
"ImageWrapper",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"RHI",
"ShaderCore",
}
);
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompilePhysX && UEBuildConfiguration.bRuntimePhysicsCooking)
{
DynamicallyLoadedModuleNames.Add("PhysXFormats");
PrivateIncludePathModuleNames.Add("PhysXFormats");
}
if (UEBuildConfiguration.bBuildDeveloperTools && Target.Type != TargetRules.TargetType.Server)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"RawMesh"
}
);
}
if (UEBuildConfiguration.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
}
);
}
}
public AnimGraph(TargetInfo Target)
{
PrivateIncludePaths.Add("Editor/AnimGraph/Private");
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Slate",
"AnimGraphRuntime",
"BlueprintGraph",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"InputCore",
"SlateCore",
"UnrealEd",
"GraphEditor",
"PropertyEditor",
"EditorStyle"
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"GraphEditor",
}
);
}
public KinectV2Editor(TargetInfo Target)
{
PrivateIncludePaths.Add("KinectV2Editor/Private");
PublicIncludePaths.Add("KinectV2Editor/Public");
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Slate",
"BlueprintGraph",
"AnimGraph",
"AnimGraphRuntime",
"KinectV2"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"SlateCore",
"UnrealEd",
"GraphEditor",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"GraphEditor",
}
);
}
public FoliageEdit(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"InputCore",
"Engine",
"UnrealEd",
"Slate",
"SlateCore",
"EditorStyle",
"RenderCore",
"LevelEditor",
"Landscape",
"PropertyEditor",
"DetailCustomizations",
"AssetTools",
"Foliage",
"ViewportInteraction",
"VREditor"
}
);
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"ViewportInteraction",
"VREditor"
}
);
}
public MaterialUtilities(TargetInfo Target)
{
PrivateDependencyModuleNames.AddRange(
new string [] {
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"RHI",
"Landscape",
"UnrealEd",
"ShaderCore"
}
);
PublicDependencyModuleNames.AddRange(
new string [] {
"RawMesh",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Landscape"
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"Landscape"
}
);
}
public LocalizationDashboard(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"PropertyEditor",
"Localization"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Engine",
"Slate",
"SlateCore",
"InputCore",
"UnrealEd",
"EditorStyle",
"DesktopPlatform",
"TranslationEditor",
"MainFrame",
"SourceControl",
"SharedSettingsWidgets",
"Localization",
"LocalizationCommandletExecution",
"LocalizationService",
"InternationalizationSettings",
"ToolMenus",
}
);
PrivateIncludePaths.AddRange(
new string[]
{
"Editor/LocalizationDashboard/Private",
}
);
PublicIncludePaths.AddRange(
new string[]
{
"Editor/LocalizationDashboard/Public",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"LocalizationService",
"MainFrame",
"TranslationEditor"
}
);
}
public MeshPaint(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"DesktopPlatform",
"Engine",
"InputCore",
"RenderCore",
"RHI",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"MeshDescription",
"StaticMeshDescription",
"SourceControl",
"ViewportInteraction",
"VREditor",
"PropertyEditor",
"MainFrame",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"ViewportInteraction",
"VREditor"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"AssetTools",
"LevelEditor"
});
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools"
}
);
}
public GameplayTagsEditor(TargetInfo Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/GameplayTagsEditor/Private",
"Developer/AssetTools/Private",
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"AssetTools",
"AssetRegistry",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
// ... add private dependencies that you statically link with here ...
"Core",
"CoreUObject",
"Engine",
"AssetTools",
"AssetRegistry",
"GameplayTags",
"InputCore",
"Slate",
"SlateCore",
"EditorStyle",
"BlueprintGraph",
"KismetCompiler",
"GraphEditor",
"ContentBrowser",
"MainFrame",
"UnrealEd",
"SourceControl",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Settings"
}
);
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"BlueprintGraph",
}
);
}
public GameplayAbilitiesEditor(TargetInfo Target)
{
var EngineDir = Path.GetFullPath(BuildConfiguration.RelativeEnginePath);
// These nodes are not public so are hard to subclass
PrivateIncludePaths.AddRange(
new string[] {
"GameplayAbilitiesEditor/Private",
Path.Combine(EngineDir, @"Source/Editor/GraphEditor/Private"),
Path.Combine(EngineDir, @"Source/Editor/Kismet/Private"),
Path.Combine(EngineDir, @"Source/Developer/AssetTools/Private")
});
PublicDependencyModuleNames.Add("GameplayTasks");
PrivateDependencyModuleNames.AddRange(
new string[]
{
// ... add private dependencies that you statically link with here ...
"Core",
"CoreUObject",
"Engine",
"AssetTools",
"ClassViewer",
"GameplayTags",
"GameplayTagsEditor",
"GameplayAbilities",
"GameplayTasksEditor",
"InputCore",
"PropertyEditor",
"Slate",
"SlateCore",
"EditorStyle",
"BlueprintGraph",
"Kismet",
"KismetCompiler",
"GraphEditor",
"MainFrame",
"UnrealEd",
"WorkspaceMenuStructure",
"ContentBrowser",
"EditorWidgets",
"SourceControl",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"GameplayTagsEditor",
}
);
}
public AnimGraph(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/AnimGraph/Private",
}
);
OverridePackageType = PackageOverrideType.EngineDeveloper;
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Slate",
"AnimGraphRuntime",
"BlueprintGraph",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"InputCore",
"SlateCore",
"UnrealEd",
"GraphEditor",
"PropertyEditor",
"EditorStyle",
"ContentBrowser",
"KismetWidgets",
"ToolMenus",
"KismetCompiler",
"Kismet",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"GraphEditor",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Persona",
"SkeletonEditor",
"AdvancedPreviewScene",
"AnimationBlueprintEditor",
}
);
}
public AudioMixer(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("TargetPlatform");
PublicIncludePathModuleNames.Add("TargetPlatform");
PublicIncludePathModuleNames.Add("Engine");
PrivateIncludePaths.AddRange(
new string[]
{
"Runtime/AudioMixer/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"NonRealtimeAudioRenderer",
"AudioMixerCore",
"SignalProcessing",
"AudioPlatformConfiguration",
"SoundFieldRendering",
"AudioExtensions",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus",
"UELibSampleRate"
);
// Circular references that need to be cleaned up
CircularlyReferencedDependentModules.AddRange(
new string[] {
"NonRealtimeAudioRenderer",
"SoundFieldRendering"
}
);
}
public HierarchicalLODOutliner(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange
(
new string[] {
"Core",
"InputCore",
"CoreUObject",
"RHI",
"RenderCore",
"Slate",
"EditorStyle",
"Engine",
"UnrealEd",
"PropertyEditor",
"HierarchicalLODUtilities",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Engine",
"UnrealEd"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"LevelEditor"
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"SlateCore",
"Slate",
"ToolMenus",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd"
}
);
}
}
public FunctionalTesting(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"Slate",
"SlateCore",
"MessageLog",
"NavigationSystem",
"AIModule",
"RenderCore",
"AssetRegistry",
"RHI",
"UMG",
"AutomationController",
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"SourceControl",
"UnrealEd",
"LevelEditor"
}
);
// Circular references that need to be cleaned up
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
}
);
}
PrivateIncludePaths.AddRange(
new string[]
{
"Developer/FunctionalTesting/Private",
}
);
//make sure this is compiled for binary builds
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrecompileForTargets = PrecompileTargetsType.Any;
}
}
public ConfigEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/ConfigEditor/Private",
"Editor/ConfigEditor/Private/PropertyVisualization",
}
);
PublicIncludePaths.AddRange(
new string[] {
"Editor/ConfigEditor/Public",
"Editor/ConfigEditor/Public/PropertyVisualization",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"EditorStyle",
"InputCore",
"PropertyEditor",
"Slate",
"SlateCore",
"SourceControl",
"TargetPlatform",
"WorkspaceMenuStructure",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"PropertyEditor",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
}
);
}
public PixelInspectorModule(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange
(
new string[] {
"Core",
"InputCore",
"CoreUObject",
"RHI",
"RenderCore",
"Slate",
"EditorStyle",
"Engine",
"UnrealEd",
"PropertyEditor",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Engine",
"UnrealEd"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"LevelEditor"
}
);
if (UEBuildConfiguration.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"SlateCore",
"Slate",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd"
}
);
}
}
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 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",
}
);
}
// 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 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 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 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 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 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 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 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 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"
}
);
}
