예제 #1
0
    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",
        }
            );
    }
예제 #2
0
    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"
            }
                );
        }
    }
예제 #4
0
    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",
        }
            );
    }
예제 #7
0
    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");
    }
예제 #8
0
    // 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);
    }
예제 #9
0
    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",
        }
            );
    }
예제 #10
0
    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"
            }
                );
        }
예제 #12
0
    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;
    }
예제 #13
0
    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");
    }
예제 #14
0
        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",
            }
                );
        }
    }
예제 #17
0
    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);
        }
    }
예제 #19
0
    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;
        }
    }
예제 #22
0
    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",
            }
                );
        }
    }
예제 #23
0
    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;
        }
    }
예제 #24
0
    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",
        }
            );
    }
예제 #25
0
    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");
            }
        }
예제 #27
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 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");
        }
    }