コード例 #1
0
    public ApexDestructionLib(ReadOnlyTargetRules Target) : base(Target)
    {
        Type = ModuleType.External;

        if (Target.bCompileAPEX == false)
        {
            return;
        }
        
        // Determine which kind of libraries to link against
        APEXLibraryMode LibraryMode = GetAPEXLibraryMode(Target.Configuration);
        string LibrarySuffix = GetAPEXLibrarySuffix(LibraryMode);

        string ApexVersion = "APEX_1.4";

        string APEXDir = Target.UEThirdPartySourceDirectory + "PhysX3/" + ApexVersion + "/";

        string APEXLibDir = Target.UEThirdPartySourceDirectory + "PhysX3/Lib";

        PublicSystemIncludePaths.AddRange(
            new string[] {
                APEXDir + "include/destructible",
            }
            );

        // List of default library names (unused unless LibraryFormatString is non-null)
        List<string> ApexLibraries = new List<string>();
        ApexLibraries.AddRange(
            new string[]
            {
                "APEX_Destructible{0}",
            });
        string LibraryFormatString = null;
        

        // Libraries and DLLs for windows platform
        if (Target.Platform == UnrealTargetPlatform.Win64)
        {
            APEXLibDir += "/Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
            PublicLibraryPaths.Add(APEXLibDir);

            PublicAdditionalLibraries.Add(String.Format("APEXFramework{0}_x64.lib", LibrarySuffix));
            PublicDelayLoadDLLs.Add(String.Format("APEXFramework{0}_x64.dll", LibrarySuffix));

            string[] RuntimeDependenciesX64 =
            {
                "APEX_Destructible{0}_x64.dll",
            };

            string ApexBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX3/Win64/VS{0}/", Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
            foreach (string RuntimeDependency in RuntimeDependenciesX64)
            {
                string FileName = ApexBinariesDir + String.Format(RuntimeDependency, LibrarySuffix);
                RuntimeDependencies.Add(FileName, StagedFileType.NonUFS);
                RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS);
            }

        }
        else if (Target.Platform == UnrealTargetPlatform.Win32)
        {
            APEXLibDir += "/Win32/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
            PublicLibraryPaths.Add(APEXLibDir);

            PublicAdditionalLibraries.Add(String.Format("APEXFramework{0}_x86.lib", LibrarySuffix));
            PublicDelayLoadDLLs.Add(String.Format("APEXFramework{0}_x86.dll", LibrarySuffix));

            string[] RuntimeDependenciesX86 =
            {
                "APEX_Destructible{0}_x86.dll",
            };

            string ApexBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX3/Win32/VS{0}/", Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
            foreach (string RuntimeDependency in RuntimeDependenciesX86)
            {
                string FileName = ApexBinariesDir + String.Format(RuntimeDependency, LibrarySuffix);
                RuntimeDependencies.Add(FileName, StagedFileType.NonUFS);
                RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS);
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.Mac)
        {
            APEXLibDir += "/Mac";

            string[] DynamicLibrariesMac = new string[] {
                "/libAPEX_Destructible{0}.dylib"
            };

            string PhysXBinariesDir = Target.UEThirdPartyBinariesDirectory + "PhysX3/Mac";
            foreach (string Lib in DynamicLibrariesMac)
            {
                string LibraryPath = PhysXBinariesDir + String.Format(Lib, LibrarySuffix);
                PublicDelayLoadDLLs.Add(LibraryPath);
                RuntimeDependencies.Add(new RuntimeDependency(LibraryPath));
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.Linux)
        {
            if (Target.Architecture.StartsWith("x86_64"))
            {
                APEXLibDir += "/Linux/" + Target.Architecture;
                ApexLibraries.Add("APEX_Destructible{0}");
                LibraryFormatString = APEXLibDir + "/lib{0}" + ".a";
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.PS4)
        {
            APEXLibDir += "/PS4";
            PublicLibraryPaths.Add(APEXLibDir);

            LibraryFormatString = "{0}";
        }
        else if (Target.Platform == UnrealTargetPlatform.XboxOne)
        {
            APEXLibDir += "/XboxOne/VS2015";
            PublicLibraryPaths.Add(APEXLibDir);

            LibraryFormatString = "{0}.lib";
        }
        else if (Target.Platform == UnrealTargetPlatform.Switch)
        {
            APEXLibDir += "/Switch";
            PublicLibraryPaths.Add(APEXLibDir);

            LibraryFormatString = "{0}";
        }

        // Add the libraries needed (used for all platforms except Windows and Mac)
        if (LibraryFormatString != null)
        {
            foreach (string Lib in ApexLibraries)
            {
                string ConfiguredLib = String.Format(Lib, LibrarySuffix);
                string FinalLib = String.Format(LibraryFormatString, ConfiguredLib);
                PublicAdditionalLibraries.Add(FinalLib);
            }
        }
    }
コード例 #2
0
ファイル: VorbisFile.Build.cs プロジェクト: PatrickQQ/unreal
    public VorbisFile(ReadOnlyTargetRules Target) : base(Target)
    {
        Type = ModuleType.External;

        string VorbisPath = Target.UEThirdPartySourceDirectory + "Vorbis/libvorbis-1.3.2/";

        PublicIncludePaths.Add(VorbisPath + "include");
        if (Target.Platform == UnrealTargetPlatform.Win64)
        {
            string VorbisLibPath = VorbisPath + "Lib/win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName() + "/";
            PublicLibraryPaths.Add(VorbisLibPath);
            PublicAdditionalLibraries.Add("libvorbisfile_64.lib");
            PublicDelayLoadDLLs.Add("libvorbisfile_64.dll");
            RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Vorbis/Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName() + "/libvorbisfile_64.dll");
        }
        else if (Target.Platform == UnrealTargetPlatform.Win32)
        {
            string VorbisLibPath = VorbisPath + "Lib/win32/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName() + "/";
            PublicLibraryPaths.Add(VorbisLibPath);
            PublicAdditionalLibraries.Add("libvorbisfile.lib");
            PublicDelayLoadDLLs.Add("libvorbisfile.dll");
            RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Vorbis/Win32/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName() + "/libvorbisfile.dll");
        }
        else if (Target.Platform == UnrealTargetPlatform.HTML5)
        {
            string VorbisLibPath = VorbisPath + "lib/HTML5/";
            PublicLibraryPaths.Add(VorbisLibPath);

            string OpimizationSuffix = "";
            if (Target.bCompileForSize)
            {
                OpimizationSuffix = "_Oz";
            }
            else
            {
                if (Target.Configuration == UnrealTargetConfiguration.Development)
                {
                    OpimizationSuffix = "_O2";
                }
                else if (Target.Configuration == UnrealTargetConfiguration.Shipping)
                {
                    OpimizationSuffix = "_O3";
                }
            }
            PublicAdditionalLibraries.Add(VorbisLibPath + "libvorbisfile" + OpimizationSuffix + ".bc");
        }
        else if (Target.Platform == UnrealTargetPlatform.Android)
        {
            // filtered in toolchain
            PublicLibraryPaths.Add(VorbisPath + "Lib/Android/ARMv7");
            PublicLibraryPaths.Add(VorbisPath + "Lib/Android/ARM64");
            PublicLibraryPaths.Add(VorbisPath + "Lib/Android/x86");
            PublicLibraryPaths.Add(VorbisPath + "Lib/Android/x64");

            PublicAdditionalLibraries.Add("vorbisfile");
        }
        else if (Target.Platform == UnrealTargetPlatform.Linux)
        {
            PublicAdditionalLibraries.Add(VorbisPath + "lib/Linux/" + Target.Architecture + "/libvorbisfile.a");
            PublicAdditionalLibraries.Add(VorbisPath + "lib/Linux/" + Target.Architecture + "/libvorbisenc.a");
        }
        else 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);
                PublicLibraryPaths.Add(VorbisPath + "lib/XboxOne/VS" + VersionName.ToString());
                PublicAdditionalLibraries.Add("libvorbisfile_static.lib");
            }
        }
    }
コード例 #3
0
    public HapticsManager(ReadOnlyTargetRules Target) : base(Target)
    {
        PCHUsage             = PCHUsageMode.UseExplicitOrSharedPCHs;
        PrivatePCHHeaderFile = "Public/HapticsManager.h";

        PublicIncludePaths.AddRange(
            new string[] {
            //"HapticsManager/Public"
            // ... add public include paths required here ...
        }
            );

        PrivateIncludePaths.AddRange(
            new string[] {
            //"HapticsManager/Private",
            // ... add other private include paths required here ...
        }
            );

        PrivateIncludePathModuleNames.AddRange(
            new string[] {
            "Settings",
            "Launch",
        }
            );
        PublicDependencyModuleNames.AddRange(
            new string[]
        {
            "Core",
            "HapticsManager",
            //"System",
            // ... add other public dependencies that you statically link with here ...
        }
            );


        PrivateDependencyModuleNames.AddRange(
            new string[]
        {
            "CoreUObject",
            "Engine",
            "Slate",
            "SlateCore",
            "HapticsManager",
            "Json",
            "JsonUtilities",
            "Projects",
            "InputCore",
            "HapticLibrary"
            //"Sockets",
            // ... add private dependencies that you statically link with here ...
        }
            );


        DynamicallyLoadedModuleNames.AddRange(
            new string[]
        {
            // ... add any modules that your module loads dynamically here ...
        }
            );

        if (Target.Platform == UnrealTargetPlatform.Win64)
        {
            RuntimeDependencies.Add(Path.Combine(ModuleDirectory, "../../DLLs/win64/haptic_library.dll"));
        }
        else if (Target.Platform == UnrealTargetPlatform.Win32)
        {
            RuntimeDependencies.Add(Path.Combine(ModuleDirectory, "../../DLLs/win32/haptic_library.dll"));
        }
        else if (Target.Platform == UnrealTargetPlatform.Android)
        {
            string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
            AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "HapticsManager_APL.xml"));
        }
    }
コード例 #4
0
    public Engine(TargetInfo Target)
    {
        PrivatePCHHeaderFile = "Private/EnginePrivatePCH.h";

        SharedPCHHeaderFile = "Public/EngineSharedPCH.h";

        PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "NetworkReplayStreaming" });

        PrivateIncludePaths.AddRange(
            new string[] {
            "Developer/DerivedDataCache/Public",
            "Runtime/SynthBenchmark/Public",
            "Runtime/Engine/Private",
        }
            );

        PrivateIncludePathModuleNames.AddRange(
            new string[] {
            "TargetPlatform",
            "ImageWrapper",
            "HeadMountedDisplay",
            "Advertising",
            "NetworkReplayStreaming",
            "MovieSceneCapture",
            "AutomationWorker",
            "MovieSceneCapture",
            "DesktopPlatform",
        }
            );

        if (Target.Configuration != UnrealTargetConfiguration.Shipping)
        {
            PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
        }

        if (Target.Configuration != UnrealTargetConfiguration.Shipping)
        {
            PrivateIncludePathModuleNames.AddRange(
                new string[] {
                "SlateReflector",
            }
                );

            DynamicallyLoadedModuleNames.AddRange(
                new string[] {
                "SlateReflector",
            }
                );
        }

        PublicDependencyModuleNames.AddRange(
            new string[] {
            "Core",
            "CoreUObject",
            "Json",
            "SlateCore",
            "Slate",
            "InputCore",
            "Messaging",
            "RenderCore",
            "RHI",
            "ShaderCore",
            "AssetRegistry",                     // Here until FAssetData is moved to engine
            "EngineMessages",
            "EngineSettings",
            "SynthBenchmark",
            "GameplayTags",
            "AIModule",
            "DatabaseSupport",
            "PacketHandler",
            "HardwareSurvey",
        }
            );

        if (Target.Type == TargetRules.TargetType.Editor)
        {
            PrivateIncludePathModuleNames.AddRange(new string[] { "CrashTracker" });
            DynamicallyLoadedModuleNames.AddRange(new string[] { "CrashTracker" });
            PublicDependencyModuleNames.AddRange(
                new string[] {
            }
                );
        }


        PrivateDependencyModuleNames.AddRange(
            new string[] {
            "AppFramework",
            "Networking",
            "Sockets",
            "Landscape",
            "UMG",
            "Projects",
            "Internationalization",
            "MaterialShaderQualitySettings",
            "CinematicCamera",
            "Analytics",
            "AnalyticsET",
        }
            );

        // to prevent "causes WARNING: Non-editor build cannot depend on non-redistributable modules."
        if (Target.Type == TargetRules.TargetType.Editor)
        {
            // for now we depend on this
            PrivateDependencyModuleNames.Add("RawMesh");
        }

        bool bVariadicTemplatesSupported = true;

        if (Target.Platform == UnrealTargetPlatform.XboxOne)
        {
            // Use reflection to allow type not to exist if console code is not present
            System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool");
            if (XboxOnePlatformType != null)
            {
                System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
                if (VersionName.ToString().Equals("2012"))
                {
                    bVariadicTemplatesSupported = false;
                }
            }
        }

        if (bVariadicTemplatesSupported)
        {
            PrivateIncludePathModuleNames.AddRange(
                new string[] {
                "MessagingRpc",
                "PortalRpc",
                "PortalServices",
            }
                );

            if (Target.Type == TargetRules.TargetType.Editor)
            {
                // these modules require variadic templates
                PrivateDependencyModuleNames.AddRange(
                    new string[] {
                    "MessagingRpc",
                    "PortalRpc",
                    "PortalServices",
                }
                    );
            }
        }

        CircularlyReferencedDependentModules.Add("GameplayTags");
        CircularlyReferencedDependentModules.Add("AIModule");
        CircularlyReferencedDependentModules.Add("Landscape");
        CircularlyReferencedDependentModules.Add("UMG");
        CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings");
        CircularlyReferencedDependentModules.Add("CinematicCamera");

        // The AnimGraphRuntime module is not needed by Engine proper, but it is loaded in LaunchEngineLoop.cpp,
        // and needs to be listed in an always-included module in order to be compiled into standalone games
        DynamicallyLoadedModuleNames.Add("AnimGraphRuntime");
        // So does Geometry Cache
        DynamicallyLoadedModuleNames.Add("GeometryCache");

        DynamicallyLoadedModuleNames.AddRange(
            new string[]
        {
            "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");
    }
コード例 #5
0
        public WindowsMixedRealityHMD(ReadOnlyTargetRules Target) : base(Target)
        {
            bEnableExceptions = true;

            if (Target.Platform == UnrealTargetPlatform.Win32 ||
                Target.Platform == UnrealTargetPlatform.Win64 ||
                Target.Platform == UnrealTargetPlatform.HoloLens)
            {
                PublicDependencyModuleNames.AddRange(
                    new string[]
                {
                    "HeadMountedDisplay",
                    "ProceduralMeshComponent",
                    "MixedRealityInteropLibrary",
                    "InputDevice",
                }
                    );

                PrivateDependencyModuleNames.AddRange(
                    new string[]
                {
                    "Core",
                    "CoreUObject",
                    "ApplicationCore",
                    "Engine",
                    "InputCore",
                    "RHI",
                    "RenderCore",
                    "Renderer",
                    "HeadMountedDisplay",
                    "D3D11RHI",
                    "Slate",
                    "SlateCore",
                    "UtilityShaders",
                    "Projects",
                    "WindowsMixedRealityHandTracking",
                    "AugmentedReality",
                }
                    );

                if (Target.Platform == UnrealTargetPlatform.Win64 ||
                    Target.Platform == UnrealTargetPlatform.HoloLens)
                {
                    PrivateDependencyModuleNames.Add("HoloLensAR");
                }

                if (Target.bBuildEditor == true)
                {
                    PrivateDependencyModuleNames.Add("UnrealEd");
                }

                if (Target.Platform != UnrealTargetPlatform.HoloLens)
                {
                    AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAftermath");
                    AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelMetricsDiscovery");
                }

                AddEngineThirdPartyPrivateStaticDependencies(Target, "WindowsMixedRealityInterop");

                LoadMixedReality(Target);

                PrivateIncludePaths.AddRange(
                    new string[]
                {
                    "WindowsMixedRealityHMD/Private",
                    "../../../../Source/Runtime/Windows/D3D11RHI/Private",
                    "../../../../Source/Runtime/Renderer/Private",
                });

                if (Target.Platform == UnrealTargetPlatform.Win32 ||
                    Target.Platform == UnrealTargetPlatform.Win64)
                {
                    PrivateIncludePaths.Add("../../../../Source/Runtime/Windows/D3D11RHI/Private/Windows");
                }
                else if (Target.Platform == UnrealTargetPlatform.HoloLens)
                {
                    PrivateIncludePaths.Add("../../../../Source/Runtime/Windows/D3D11RHI/Private/HoloLens");
                }

                bFasterWithoutUnity = true;

                PCHUsage             = PCHUsageMode.NoSharedPCHs;
                PrivatePCHHeaderFile = "Private/WindowsMixedRealityPrecompiled.h";
            }

            if (Target.Platform == UnrealTargetPlatform.Win64 || (Target.Platform == UnrealTargetPlatform.HoloLens && Target.WindowsPlatform.Architecture == WindowsArchitecture.x64))
            {
                PublicDelayLoadDLLs.Add("QRCodesTrackerPlugin.dll");
                RuntimeDependencies.Add(Path.Combine("$(EngineDir)/Binaries/ThirdParty/Windows/x64", "QRCodesTrackerPlugin.dll"));
            }
            else if (Target.Platform == UnrealTargetPlatform.HoloLens)
            {
                PublicDelayLoadDLLs.Add("QRCodesTrackerPlugin.dll");
                RuntimeDependencies.Add(Path.Combine("$(EngineDir)/Binaries/ThirdParty/HoloLens/ARM64", "QRCodesTrackerPlugin.dll"));
            }

            // Add a dependency to SceneUnderstanding.dll if present
            string SceneUnderstandingPath = Path.Combine(Target.UEThirdPartyBinariesDirectory, "HoloLens", Target.WindowsPlatform.GetArchitectureSubpath(), "SceneUnderstanding.dll");

            if (File.Exists(SceneUnderstandingPath))
            {
                PublicDelayLoadDLLs.Add("SceneUnderstanding.dll");
                RuntimeDependencies.Add(SceneUnderstandingPath);
                PublicDefinitions.Add("WITH_SCENE_UNDERSTANDING=1");
            }
            else
            {
                PublicDefinitions.Add("WITH_SCENE_UNDERSTANDING=0");
            }
        }
コード例 #6
0
ファイル: ICU.Build.cs プロジェクト: emdepdev/UnrealEngine-1
    public ICU(TargetInfo Target)
    {
        Type = ModuleType.External;

        string ICUVersion  = "icu4c-53_1";
        string ICURootPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "ICU/" + ICUVersion + "/";

        // Includes
        PublicSystemIncludePaths.Add(ICURootPath + "include" + "/");

        string PlatformFolderName = Target.Platform.ToString();

        string TargetSpecificPath = ICURootPath + PlatformFolderName + "/";

        if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
        {
            TargetSpecificPath = ICURootPath + "Win32/";
        }

        if ((Target.Platform == UnrealTargetPlatform.Win64) ||
            (Target.Platform == UnrealTargetPlatform.Win32) ||
            (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32"))
        {
            string VSVersionFolderName = "VS" + WindowsPlatform.GetVisualStudioCompilerVersionName();
            TargetSpecificPath += VSVersionFolderName + "/";

            string[] LibraryNameStems =
            {
                "dt",                   // Data
                "uc",                   // Unicode Common
                "in",                   // Internationalization
                "le",                   // Layout Engine
                "lx",                   // Layout Extensions
                "io"                    // Input/Output
            };
            string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ?
                                        "d" : string.Empty;

            // Library Paths
            PublicLibraryPaths.Add(TargetSpecificPath + "lib" + "/");

            EICULinkType ICULinkType = Target.IsMonolithic ? EICULinkType.Static : EICULinkType.Dynamic;
            switch (ICULinkType)
            {
            case EICULinkType.Static:
                foreach (string Stem in LibraryNameStems)
                {
                    string LibraryName = "sicu" + Stem + LibraryNamePostfix + "." + "lib";
                    PublicAdditionalLibraries.Add(LibraryName);
                }
                break;

            case EICULinkType.Dynamic:
                foreach (string Stem in LibraryNameStems)
                {
                    string LibraryName = "icu" + Stem + LibraryNamePostfix + "." + "lib";
                    PublicAdditionalLibraries.Add(LibraryName);
                }

                foreach (string Stem in LibraryNameStems)
                {
                    string LibraryName = "icu" + Stem + LibraryNamePostfix + "53" + "." + "dll";
                    PublicDelayLoadDLLs.Add(LibraryName);
                }

                if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
                {
                    string BinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/ICU/{0}/{1}/VS{2}/", ICUVersion, Target.Platform.ToString(), WindowsPlatform.GetVisualStudioCompilerVersionName());
                    foreach (string Stem in LibraryNameStems)
                    {
                        string LibraryName = BinariesDir + String.Format("icu{0}{1}53.dll", Stem, LibraryNamePostfix);
                        RuntimeDependencies.Add(new RuntimeDependency(LibraryName));
                    }
                }

                break;
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.Linux || Target.Platform == UnrealTargetPlatform.Android)
        {
            string StaticLibraryExtension = "a";

            switch (Target.Platform)
            {
            case UnrealTargetPlatform.Linux:
                TargetSpecificPath += Target.Architecture + "/";
                break;

            case UnrealTargetPlatform.Android:
                PublicLibraryPaths.Add(TargetSpecificPath + "ARMv7/lib");
                PublicLibraryPaths.Add(TargetSpecificPath + "ARM64/lib");
                PublicLibraryPaths.Add(TargetSpecificPath + "x86/lib");
                PublicLibraryPaths.Add(TargetSpecificPath + "x64/lib");
                break;
            }

            string[] LibraryNameStems =
            {
                "data",                 // Data
                "uc",                   // Unicode Common
                "i18n",                 // Internationalization
                "le",                   // Layout Engine
                "lx",                   // Layout Extensions
                "io"                    // Input/Output
            };
            string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ?
                                        "d" : string.Empty;

            // Library Paths
            EICULinkType ICULinkType = (Target.Platform == UnrealTargetPlatform.Android || Target.IsMonolithic) ? EICULinkType.Static : EICULinkType.Dynamic;
            switch (ICULinkType)
            {
            case EICULinkType.Static:
                foreach (string Stem in LibraryNameStems)
                {
                    string LibraryName = "icu" + Stem + LibraryNamePostfix;
                    if (Target.Platform == UnrealTargetPlatform.Android)
                    {
                        // we will filter out in the toolchain
                        PublicAdditionalLibraries.Add(LibraryName);                                 // Android requires only the filename.
                    }
                    else
                    {
                        PublicAdditionalLibraries.Add(TargetSpecificPath + "lib/" + "lib" + LibraryName + "." + StaticLibraryExtension);     // Linux seems to need the path, not just the filename.
                    }
                }
                break;

            case EICULinkType.Dynamic:
                if (Target.Platform == UnrealTargetPlatform.Linux)
                {
                    string PathToBinary = String.Format("$(EngineDir)/Binaries/ThirdParty/ICU/{0}/{1}/{2}/", ICUVersion, Target.Platform.ToString(),
                                                        Target.Architecture);

                    foreach (string Stem in LibraryNameStems)
                    {
                        string LibraryName = "icu" + Stem + LibraryNamePostfix;
                        string LibraryPath = UEBuildConfiguration.UEThirdPartyBinariesDirectory + "ICU/icu4c-53_1/Linux/" + Target.Architecture + "/";

                        PublicLibraryPaths.Add(LibraryPath);
                        PublicAdditionalLibraries.Add(LibraryName);

                        // add runtime dependencies (for staging)
                        RuntimeDependencies.Add(new RuntimeDependency(PathToBinary + "lib" + LibraryName + ".so"));
                        RuntimeDependencies.Add(new RuntimeDependency(PathToBinary + "lib" + LibraryName + ".so.53"));      // version-dependent
                    }
                }
                break;
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.IOS)
        {
            string StaticLibraryExtension  = "a";
            string DynamicLibraryExtension = "dylib";

            string[] LibraryNameStems =
            {
                "data",                 // Data
                "uc",                   // Unicode Common
                "i18n",                 // Internationalization
                "le",                   // Layout Engine
                "lx",                   // Layout Extensions
                "io"                    // Input/Output
            };
            string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ?
                                        "d" : string.Empty;

            EICULinkType ICULinkType = (Target.Platform == UnrealTargetPlatform.IOS || Target.IsMonolithic) ? EICULinkType.Static : EICULinkType.Dynamic;
            // Library Paths
            switch (ICULinkType)
            {
            case EICULinkType.Static:
                foreach (string Stem in LibraryNameStems)
                {
                    string LibraryName = "libicu" + Stem + LibraryNamePostfix + "." + StaticLibraryExtension;
                    PublicAdditionalLibraries.Add(TargetSpecificPath + "lib/" + LibraryName);
                    if (Target.Platform == UnrealTargetPlatform.IOS)
                    {
                        PublicAdditionalShadowFiles.Add(TargetSpecificPath + "lib/" + LibraryName);
                    }
                }
                break;

            case EICULinkType.Dynamic:
                foreach (string Stem in LibraryNameStems)
                {
                    if (Target.Platform == UnrealTargetPlatform.Mac)
                    {
                        string LibraryName = "libicu" + Stem + ".53.1" + LibraryNamePostfix + "." + DynamicLibraryExtension;
                        string LibraryPath = UEBuildConfiguration.UEThirdPartyBinariesDirectory + "ICU/icu4c-53_1/Mac/" + LibraryName;

                        PublicDelayLoadDLLs.Add(LibraryPath);
                        PublicAdditionalShadowFiles.Add(LibraryPath);
                    }
                    else if (Target.Platform == UnrealTargetPlatform.Linux)
                    {
                        string LibraryName = "icu" + Stem + LibraryNamePostfix;
                        string LibraryPath = UEBuildConfiguration.UEThirdPartyBinariesDirectory + "ICU/icu4c-53_1/Linux/" + Target.Architecture + "/";

                        PublicLibraryPaths.Add(LibraryPath);
                        PublicAdditionalLibraries.Add(LibraryName);
                    }
                }
                break;
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.HTML5)
        {
            // we don't bother with debug libraries on HTML5. Mainly because debugging isn't viable on html5 currently
            string StaticLibraryExtension = "bc";

            string[] LibraryNameStems =
            {
                "data",                 // Data
                "uc",                   // Unicode Common
                "i18n",                 // Internationalization
                "le",                   // Layout Engine
                "lx",                   // Layout Extensions
                "io"                    // Input/Output
            };

            foreach (string Stem in LibraryNameStems)
            {
                string LibraryName = "libicu" + Stem + "." + StaticLibraryExtension;
                PublicAdditionalLibraries.Add(TargetSpecificPath + LibraryName);
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.PS4)
        {
            string   LibraryNamePrefix = "sicu";
            string[] LibraryNameStems  =
            {
                "dt",                   // Data
                "uc",                   // Unicode Common
                "in",                   // Internationalization
                "le",                   // Layout Engine
                "lx",                   // Layout Extensions
                "io"                    // Input/Output
            };
            string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug) ?
                                        "d" : string.Empty;
            string LibraryExtension = "lib";
            foreach (string Stem in LibraryNameStems)
            {
                string LibraryName = ICURootPath + "PS4/lib/" + LibraryNamePrefix + Stem + LibraryNamePostfix + "." + LibraryExtension;
                PublicAdditionalLibraries.Add(LibraryName);
            }
        }
        else 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)
            {
                string   LibraryNamePrefix = "sicu";
                string[] LibraryNameStems  =
                {
                    "dt",                       // Data
                    "uc",                       // Unicode Common
                    "in",                       // Internationalization
                    "le",                       // Layout Engine
                    "lx",                       // Layout Extensions
                    "io"                        // Input/Output
                };
                string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ?
                                            "d" : string.Empty;
                string LibraryExtension = "lib";
                foreach (string Stem in LibraryNameStems)
                {
                    System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
                    string        LibraryName = ICURootPath + "XboxOne/VS" + VersionName.ToString() + "/lib/" + LibraryNamePrefix + Stem + LibraryNamePostfix + "." + LibraryExtension;
                    PublicAdditionalLibraries.Add(LibraryName);
                }
            }
        }

        // common defines
        if ((Target.Platform == UnrealTargetPlatform.Win64) ||
            (Target.Platform == UnrealTargetPlatform.Win32) ||
            (Target.Platform == UnrealTargetPlatform.Linux) ||
            (Target.Platform == UnrealTargetPlatform.Android) ||
            (Target.Platform == UnrealTargetPlatform.Mac) ||
            (Target.Platform == UnrealTargetPlatform.IOS) ||
            (Target.Platform == UnrealTargetPlatform.PS4) ||
            (Target.Platform == UnrealTargetPlatform.XboxOne) ||
            (Target.Platform == UnrealTargetPlatform.HTML5))
        {
            // Definitions
            Definitions.Add("U_USING_ICU_NAMESPACE=0");              // Disables a using declaration for namespace "icu".
            Definitions.Add("U_STATIC_IMPLEMENTATION");              // Necessary for linking to ICU statically.
            Definitions.Add("U_NO_DEFAULT_INCLUDE_UTF_HEADERS=1");   // Disables unnecessary inclusion of headers - inclusions are for ease of use.
            Definitions.Add("UNISTR_FROM_CHAR_EXPLICIT=explicit");   // Makes UnicodeString constructors for ICU character types explicit.
            Definitions.Add("UNISTR_FROM_STRING_EXPLICIT=explicit"); // Makes UnicodeString constructors for "char"/ICU string types explicit.
            Definitions.Add("UCONFIG_NO_TRANSLITERATION=1");         // Disables declarations and compilation of unused ICU transliteration functionality.
        }

        if (Target.Platform == UnrealTargetPlatform.PS4)
        {
            // Definitions
            Definitions.Add("ICU_NO_USER_DATA_OVERRIDE=1");
            Definitions.Add("U_PLATFORM=U_PF_ORBIS");
        }

        if (Target.Platform == UnrealTargetPlatform.XboxOne)
        {
            // Definitions
            Definitions.Add("ICU_NO_USER_DATA_OVERRIDE=1");
            Definitions.Add("U_PLATFORM=U_PF_DURANGO");
        }
    }
コード例 #7
0
    public PhysX(TargetInfo Target)
    {
        Type = ModuleType.External;

        // Determine which kind of libraries to link against
        PhysXLibraryMode LibraryMode = GetPhysXLibraryMode(Target.Configuration);

        // Quick Mac hack
        if (Target.Platform == UnrealTargetPlatform.Mac && (LibraryMode == PhysXLibraryMode.Checked || LibraryMode == PhysXLibraryMode.Shipping))
        {
            LibraryMode = PhysXLibraryMode.Profile;
        }
        string LibrarySuffix = GetPhysXLibrarySuffix(LibraryMode);

        Definitions.Add("WITH_PHYSX=1");
        if (UEBuildConfiguration.bCompileAPEX == false)
        {
            // Since APEX is dependent on PhysX, if APEX is not being include, set the flag properly.
            // This will properly cover the case where PhysX is compiled but APEX is not.
            Definitions.Add("WITH_APEX=0");
        }
        if (UEBuildConfiguration.bCompilePhysXVehicle == false)
        {
            // Since PhysX Vehicle is dependent on PhysX, if Vehicle is not being include, set the flag properly.
            // This will properly cover the case where PhysX is compiled but Vehicle is not.
            Definitions.Add("WITH_VEHICLE=0");
        }

        if (LibraryMode == PhysXLibraryMode.Shipping)
        {
            Definitions.Add("WITH_PHYSX_RELEASE=1");
        }
        else
        {
            Definitions.Add("WITH_PHYSX_RELEASE=0");
        }

        if (LibraryMode == PhysXLibraryMode.Checked)
        {
            Definitions.Add("WITH_PHYSX_CHECKED=1");
        }
        else
        {
            Definitions.Add("WITH_PHYSX_CHECKED=0");
        }


        string PhysXVersion = "PhysX-3.3";

        string PhysXDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "PhysX/" + PhysXVersion + "/";

        string PhysXLibDir = PhysXDir + "lib/";

        PublicSystemIncludePaths.AddRange(
            new string[] {
            PhysXDir + "include",
            PhysXDir + "include/foundation",
            PhysXDir + "include/cooking",
            PhysXDir + "include/common",
            PhysXDir + "include/extensions",
            PhysXDir + "include/geometry",
            PhysXDir + "include/vehicle"
        }
            );

        // Libraries and DLLs for windows platform
        if (Target.Platform == UnrealTargetPlatform.Win64)
        {
            PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/windows");

            PhysXLibDir += "Win64/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName();
            PublicLibraryPaths.Add(PhysXLibDir);

            string[] StaticLibrariesX64 = new string[] {
                "PhysX3{0}_x64.lib",
                "PhysX3Extensions{0}.lib",
                "PhysX3Cooking{0}_x64.lib",
                "PhysX3Common{0}_x64.lib",
                "PhysX3Vehicle{0}.lib",
                "PxTask{0}.lib",
                "PhysXVisualDebuggerSDK{0}.lib",
                "PhysXProfileSDK{0}.lib"
            };

            string[] DelayLoadDLLsX64 = new string[] {
                "PhysX3{0}_x64.dll",
                "PhysX3Cooking{0}_x64.dll",
                "PhysX3Common{0}_x64.dll"
            };

            string[] RuntimeDependenciesX64 = new string[] {
                "PhysX3{0}_x64.dll",
                "PhysX3Common{0}_x64.dll",
                "PhysX3Cooking{0}_x64.dll",
            };

            foreach (string Lib in StaticLibrariesX64)
            {
                PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
            }

            foreach (string DLL in DelayLoadDLLsX64)
            {
                PublicDelayLoadDLLs.Add(String.Format(DLL, LibrarySuffix));
            }
            PublicDelayLoadDLLs.Add("nvToolsExt64_1.dll");

            string PhysXBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX/{0}/Win64/VS{1}/", PhysXVersion, WindowsPlatform.GetVisualStudioCompilerVersionName());
            foreach (string DLL in RuntimeDependenciesX64)
            {
                string FileName = PhysXBinariesDir + String.Format(DLL, LibrarySuffix);
                RuntimeDependencies.Add(FileName, StagedFileType.NonUFS);
                RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS);
            }
            RuntimeDependencies.Add(PhysXBinariesDir + "nvToolsExt64_1.dll", StagedFileType.NonUFS);
        }
        else if (Target.Platform == UnrealTargetPlatform.Win32 || (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32"))
        {
            PublicIncludePaths.Add(PhysXDir + "include/foundation/windows");

            PhysXLibDir += "Win32/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName();
            PublicLibraryPaths.Add(PhysXLibDir);

            string[] StaticLibrariesX86 = new string[] {
                "PhysX3{0}_x86.lib",
                "PhysX3Extensions{0}.lib",
                "PhysX3Cooking{0}_x86.lib",
                "PhysX3Common{0}_x86.lib",
                "PhysX3Vehicle{0}.lib",
                "PxTask{0}.lib",
                "PhysXVisualDebuggerSDK{0}.lib",
                "PhysXProfileSDK{0}.lib"
            };

            string[] DelayLoadDLLsX86 = new string[] {
                "PhysX3{0}_x86.dll",
                "PhysX3Cooking{0}_x86.dll",
                "PhysX3Common{0}_x86.dll"
            };

            string[] RuntimeDependenciesX86 = new string[] {
                "PhysX3{0}_x86.dll",
                "PhysX3Common{0}_x86.dll",
                "PhysX3Cooking{0}_x86.dll",
            };

            foreach (string Lib in StaticLibrariesX86)
            {
                PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
            }

            foreach (string DLL in DelayLoadDLLsX86)
            {
                PublicDelayLoadDLLs.Add(String.Format(DLL, LibrarySuffix));
            }
            PublicDelayLoadDLLs.Add("nvToolsExt32_1.dll");

            string PhysXBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX/{0}/Win32/VS{1}/", PhysXVersion, WindowsPlatform.GetVisualStudioCompilerVersionName());
            foreach (string DLL in RuntimeDependenciesX86)
            {
                string FileName = PhysXBinariesDir + String.Format(DLL, LibrarySuffix);
                RuntimeDependencies.Add(FileName, StagedFileType.NonUFS);
                RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS);
            }
            RuntimeDependencies.Add(PhysXBinariesDir + "nvToolsExt32_1.dll", StagedFileType.NonUFS);
        }
        else if (Target.Platform == UnrealTargetPlatform.Mac)
        {
            PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix");

            PhysXLibDir += "/osx64";
            PublicLibraryPaths.Add(PhysXLibDir);

            string[] StaticLibrariesMac = new string[] {
                PhysXLibDir + "/libLowLevel{0}.a",
                PhysXLibDir + "/libLowLevelCloth{0}.a",
                PhysXLibDir + "/libPhysX3{0}.a",
                PhysXLibDir + "/libPhysX3Extensions{0}.a",
                PhysXLibDir + "/libPhysX3Cooking{0}.a",
                PhysXLibDir + "/libPhysX3Common{0}.a",
                PhysXLibDir + "/libPhysX3Vehicle{0}.a",
                PhysXLibDir + "/libPxTask{0}.a",
                PhysXLibDir + "/libPhysXVisualDebuggerSDK{0}.a",
                PhysXLibDir + "/libPhysXProfileSDK{0}.a",
                PhysXLibDir + "/libPvdRuntime{0}.a",
                PhysXLibDir + "/libSceneQuery{0}.a",
                PhysXLibDir + "/libSimulationController{0}.a"
            };

            foreach (string Lib in StaticLibrariesMac)
            {
                PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.Android)
        {
            PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix");
            PublicLibraryPaths.Add(PhysXLibDir + "Android/ARMv7");
            PublicLibraryPaths.Add(PhysXLibDir + "Android/x86");
            PublicLibraryPaths.Add(PhysXLibDir + "Android/arm64");
            PublicLibraryPaths.Add(PhysXLibDir + "Android/x64");

            string[] StaticLibrariesAndroid = new string[] {
                "LowLevel{0}",
                "LowLevelCloth{0}",
                "PhysX3{0}",
                "PhysX3Extensions{0}",
                // "PhysX3Cooking{0}", // not needed until Apex
                "PhysX3Common{0}",
                "PhysX3Vehicle{0}",
                "PxTask{0}",
                "PhysXVisualDebuggerSDK{0}",
                "PhysXProfileSDK{0}",
                "PvdRuntime{0}",
                "SceneQuery{0}",
                "SimulationController{0}",
            };

            // shipping libs do not need this
            if (LibraryMode != PhysXLibraryMode.Shipping)
            {
                // use for profiling, but crash handler won't work
//				PublicAdditionalLibraries.Add("nvToolsExt");

                // disables profiling, crash handler will work
                PublicAdditionalLibraries.Add("nvToolsExtStub");
            }

            foreach (string Lib in StaticLibrariesAndroid)
            {
                PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.Linux)
        {
            PhysXLibDir += "/Linux/" + Target.Architecture;

            PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix");
            PublicLibraryPaths.Add(PhysXLibDir);

            string[] StaticLibrariesLinux = new string[] {
                "rt",
                "LowLevel{0}",
                "LowLevelCloth{0}",
                "PhysX3{0}",
                "PhysX3Extensions{0}",
                "PhysX3Cooking{0}",
                "PhysX3Common{0}",
                "PhysX3Vehicle{0}",
                "PxTask{0}",
                "PhysXVisualDebuggerSDK{0}",
                "PhysXProfileSDK{0}",
                "PvdRuntime{0}",
                "SceneQuery{0}",
                "SimulationController{0}",
            };

            if (LibraryMode == PhysXLibraryMode.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT)
            {
                //@TODO: Needed?
                PublicAdditionalLibraries.Add("m");
            }

            foreach (string Lib in StaticLibrariesLinux)
            {
                PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
        {
            PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix");

            PhysXLibDir = Path.Combine(PhysXLibDir, Target.Platform.ToString());
            PublicLibraryPaths.Add(PhysXLibDir);

            string[] PhysXLibs = new string[]
            {
                "LowLevel",
                "LowLevelCloth",
                "PhysX3",
                "PhysX3Common",
                // "PhysX3Cooking", // not needed until Apex
                "PhysX3Extensions",
                "PhysX3Vehicle",
                "PxTask",
                "PhysXVisualDebuggerSDK",
                "PhysXProfileSDK",
                "PvdRuntime",
                "SceneQuery",
                "SimulationController",
            };

            foreach (string PhysXLib in PhysXLibs)
            {
                PublicAdditionalLibraries.Add(PhysXLib + LibrarySuffix);
                PublicAdditionalShadowFiles.Add(Path.Combine(PhysXLibDir, "lib" + PhysXLib + LibrarySuffix + ".a"));
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.HTML5)
        {
            PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix");

            PhysXLibDir = Path.Combine(PhysXLibDir, "HTML5/");

            string[] PhysXLibs = new string[]
            {
                "LowLevel",
                "LowLevelCloth",
                "PhysX3",
                "PhysX3Common",
                "PhysX3Cooking",
                "PhysX3Extensions",
                "PxTask",
                "PhysXVisualDebuggerSDK",
                "PhysXProfileSDK",
                "PvdRuntime",
                "SceneQuery",
                "SimulationController",
            };

            foreach (var lib in PhysXLibs)
            {
                if (!lib.Contains("Cooking") || Target.IsCooked == false)
                {
                    PublicAdditionalLibraries.Add(PhysXLibDir + lib + (UEBuildConfiguration.bCompileForSize ? "_Oz" : "") + ".bc");
                }
            }

            if (UEBuildConfiguration.bCompilePhysXVehicle)
            {
                string[] PhysXVehicleLibs = new string[]
                {
                    "PhysX3Vehicle",
                };

                foreach (var lib in PhysXVehicleLibs)
                {
                    if (!lib.Contains("Cooking") || Target.IsCooked == false)
                    {
                        PublicAdditionalLibraries.Add(PhysXLibDir + lib + (UEBuildConfiguration.bCompileForSize ? "_Oz" : "") + ".bc");
                    }
                }
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.PS4)
        {
            PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/PS4");
            PublicLibraryPaths.Add(PhysXDir + "lib/PS4");

            string[] StaticLibrariesPS4 = new string[] {
                "PhysX3{0}",
                "PhysX3Extensions{0}",
                "PhysX3Cooking{0}",
                "PhysX3Common{0}",
                "PhysX3Vehicle{0}",
                "PxTask{0}",
                "PhysXVisualDebuggerSDK{0}",
                "PhysXProfileSDK{0}"
            };

            foreach (string Lib in StaticLibrariesPS4)
            {
                PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
            }
        }
        else 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);
                PublicSystemIncludePaths.Add("include/foundation/xboxone");
                PublicLibraryPaths.Add(PhysXDir + "Lib/XboxOne/VS" + VersionName.ToString());

                string[] StaticLibrariesXB1 = new string[] {
                    "PhysX3{0}.lib",
                    "PhysX3Extensions{0}.lib",
                    "PhysX3Cooking{0}.lib",
                    "PhysX3Common{0}.lib",
                    "PhysX3Vehicle{0}.lib",
                    "PxTask{0}.lib",
                    "PhysXVisualDebuggerSDK{0}.lib",
                    "PhysXProfileSDK{0}.lib"
                };

                foreach (string Lib in StaticLibrariesXB1)
                {
                    PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
                }
            }
        }
    }
コード例 #8
0
    public Python(ReadOnlyTargetRules Target) : base(Target)
    {
        Type = ModuleType.External;

        var EngineDir    = Path.GetFullPath(Target.RelativeEnginePath);
        var PythonTPSDir = Path.Combine(EngineDir, "Source", "ThirdParty", "Python");

        string PythonRoot        = null;
        string PythonIncludePath = null;
        string PythonLibPath     = null;
        string PythonLibName     = null;

        if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux)
        {
            // Check for an explicit version before using the auto-detection logic
            PythonRoot = System.Environment.GetEnvironmentVariable("UE_PYTHON_DIR");
        }

        // Perform auto-detection to try and find the Python root
        if (PythonRoot == null)
        {
            var KnownPaths = new List <string>();

            // todo: This isn't correct for cross-compilation, we need to consider the host platform too
            if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
            {
                KnownPaths.AddRange(
                    new string[] {
                    Path.Combine(PythonTPSDir, Target.Platform == UnrealTargetPlatform.Win32 ? "Win32" : "Win64"),
                    //"C:/Program Files/Python36",
                    "C:/Python27",
                }
                    );
            }
            else if (Target.Platform == UnrealTargetPlatform.Mac)
            {
                KnownPaths.AddRange(
                    new string[] {
                    Path.Combine(PythonTPSDir, "Mac"),
                    //"/Library/Frameworks/Python.framework/Versions/3.6",
                    "/Library/Frameworks/Python.framework/Versions/2.7",
                    //"/System/Library/Frameworks/Python.framework/Versions/2.7",
                }
                    );
            }

            foreach (var KnownPath in KnownPaths)
            {
                if (Directory.Exists(KnownPath))
                {
                    PythonRoot = KnownPath;
                    break;
                }
            }
        }

        // Work out the include path
        if (PythonRoot != null)
        {
            PythonIncludePath = Path.Combine(PythonRoot, "include");
            if (Target.Platform == UnrealTargetPlatform.Mac)
            {
                // On Mac the actual headers are inside a "pythonxy" directory, where x and y are the version number
                if (Directory.Exists(PythonIncludePath))
                {
                    string[] MatchingIncludePaths = Directory.GetDirectories(PythonIncludePath, "python*");
                    if (MatchingIncludePaths.Length > 0)
                    {
                        PythonIncludePath = Path.Combine(PythonIncludePath, Path.GetFileName(MatchingIncludePaths[0]));
                    }
                }
            }
            if (!Directory.Exists(PythonIncludePath))
            {
                PythonRoot = null;
            }
        }

        // Work out the lib path
        if (PythonRoot != null)
        {
            string LibFolder      = null;
            string LibNamePattern = null;
            switch (Target.Platform)
            {
            case UnrealTargetPlatform.Win32:
            case UnrealTargetPlatform.Win64:
                LibFolder      = "libs";
                LibNamePattern = "python*.lib";
                break;

            case UnrealTargetPlatform.Mac:
                LibFolder      = "lib";
                LibNamePattern = "libpython*.dylib";
                break;

            case UnrealTargetPlatform.Linux:
                LibFolder      = "lib";
                LibNamePattern = "libpython*.so";
                break;

            default:
                break;
            }

            if (LibFolder != null && LibNamePattern != null)
            {
                PythonLibPath = Path.Combine(PythonRoot, LibFolder);

                if (Directory.Exists(PythonLibPath))
                {
                    string[] MatchingLibFiles = Directory.GetFiles(PythonLibPath, LibNamePattern);
                    if (MatchingLibFiles.Length > 0)
                    {
                        PythonLibName = Path.GetFileName(MatchingLibFiles[0]);
                    }
                }
            }

            if (PythonLibPath == null || PythonLibName == null)
            {
                PythonRoot = null;
            }
        }

        // Make sure the Python install is the correct architecture
        if (PythonRoot != null)
        {
            string ExpectedPointerSizeResult = Target.Platform == UnrealTargetPlatform.Win32 ? "4" : "8";

            // Invoke Python to query the pointer size of the interpreter so we can work out whether it's 32-bit or 64-bit
            // todo: We probably need to do this for all platforms, but right now it's only an issue on Windows
            if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
            {
                string Result = InvokePython(PythonRoot, "-c \"import struct; print(struct.calcsize('P'))\"");
                Result = Result != null?Result.Replace("\r", "").Replace("\n", "") : null;

                if (Result == null || Result != ExpectedPointerSizeResult)
                {
                    PythonRoot = null;
                }
            }
        }

        if (PythonRoot == null)
        {
            PublicDefinitions.Add("WITH_PYTHON=0");
        }
        else
        {
            // If the Python install we're using is within the Engine directory, make the path relative so that it's portable
            string EngineRelativePythonRoot = PythonRoot;
            if (EngineRelativePythonRoot.StartsWith(EngineDir))
            {
                // Strip the Engine directory and then combine the path with the placeholder to ensure the path is delimited correctly
                EngineRelativePythonRoot = EngineRelativePythonRoot.Remove(0, EngineDir.Length);
                RuntimeDependencies.Add(Path.Combine("$(EngineDir)", EngineRelativePythonRoot, "..."));            // Stage the Python SDK for use at runtime
                EngineRelativePythonRoot = Path.Combine("{ENGINE_DIR}", EngineRelativePythonRoot);                 // Can't use $(EngineDir) as the placeholder here as UBT is eating it
            }

            PublicDefinitions.Add("WITH_PYTHON=1");
            PublicDefinitions.Add(string.Format("UE_PYTHON_DIR=\"{0}\"", EngineRelativePythonRoot.Replace('\\', '/')));

            // Some versions of Python need this define set when building on MSVC
            if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
            {
                PublicDefinitions.Add("HAVE_ROUND=1");
            }

            PublicSystemIncludePaths.Add(PythonIncludePath);
            if (Target.Platform == UnrealTargetPlatform.Mac)
            {
                // Mac doesn't understand PublicLibraryPaths
                PublicAdditionalLibraries.Add(Path.Combine(PythonLibPath, PythonLibName));
            }
            else
            {
                PublicLibraryPaths.Add(PythonLibPath);
                PublicAdditionalLibraries.Add(PythonLibName);
            }
        }
    }
コード例 #9
0
ファイル: Engine.Build.cs プロジェクト: LLChennn/UE4.21
    public Engine(ReadOnlyTargetRules Target) : base(Target)
    {
        PrivatePCHHeaderFile = "Private/EnginePrivatePCH.h";

        SharedPCHHeaderFile = "Public/EngineSharedPCH.h";

        PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "NetworkReplayStreaming", "AudioMixer", "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",
            "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",
            "Sockets",
            "UtilityShaders",
            "AssetRegistry",                     // Here until FAssetData is moved to engine
            "EngineMessages",
            "EngineSettings",
            "SynthBenchmark",
            "GameplayTags",
            "DatabaseSupport",
            "PacketHandler",
            "AudioPlatformConfiguration",
            "MeshDescription",
            "PakFile",
        }
            );

        PrivateDependencyModuleNames.AddRange(
            new string[] {
            "AppFramework",
            "Networking",
            "Landscape",
            "UMG",
            "Projects",
            "MaterialShaderQualitySettings",
            "CinematicCamera",
            "Analytics",
            "AnalyticsET",
            //"CrunchCompression"
        }
            );

        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");

        // 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",
            "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.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");
                PrivateIncludePathModuleNames.Add("MeshUtilitiesCommon");

                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.IsInPlatformGroup(UnrealPlatformGroup.Unix))
            {
                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");
        }

        SetupModulePhysicsSupport(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.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);
        }
    }
コード例 #10
0
    public UnrealEnginePython(TargetInfo Target)
#endif
    {
        PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
        string enableUnityBuild = System.Environment.GetEnvironmentVariable("UEP_ENABLE_UNITY_BUILD");

        bFasterWithoutUnity = string.IsNullOrEmpty(enableUnityBuild);

        PublicIncludePaths.AddRange(
            new string[] {
            Path.Combine(ModuleDirectory, "Public"),
            // ... add public include paths required here ...
        }
            );


        PrivateIncludePaths.AddRange(
            new string[] {
            Path.Combine(ModuleDirectory, "Private"),
            PythonHome,
            // ... add other private include paths required here ...
        }
            );


        PublicDependencyModuleNames.AddRange(
            new string[]
        {
            "Core",
            "Sockets",
            "Networking",
            "Projects"
            // ... add other public dependencies that you statically link with here ...
        }
            );


        PrivateDependencyModuleNames.AddRange(
            new string[]
        {
            "CoreUObject",
            "Engine",
            "InputCore",
            "Slate",
            "SlateCore",
            "MovieScene",
            "LevelSequence",
            "HTTP",
            "UMG",
            "AppFramework",
            "RHI",
            "Voice",
            "RenderCore",
            "MovieSceneCapture",
            "Landscape",
            "Foliage",
            "AIModule"
            // ... add private dependencies that you statically link with here ...
        }
            );


#if WITH_FORWARDED_MODULE_RULES_CTOR
        BuildVersion Version;
        if (BuildVersion.TryRead(BuildVersion.GetDefaultFileName(), out Version))
        {
            if (Version.MinorVersion >= 18)
            {
                PrivateDependencyModuleNames.Add("ApplicationCore");
            }
        }
#endif


        DynamicallyLoadedModuleNames.AddRange(
            new string[]
        {
            // ... add any modules that your module loads dynamically here ...
        }
            );

#if WITH_FORWARDED_MODULE_RULES_CTOR
        if (Target.bBuildEditor)
#else
        if (UEBuildConfiguration.bBuildEditor)
#endif
        {
            PrivateDependencyModuleNames.AddRange(new string[] {
                "UnrealEd",
                "LevelEditor",
                "BlueprintGraph",
                "Projects",
                "Sequencer",
                "SequencerWidgets",
                "AssetTools",
                "LevelSequenceEditor",
                "MovieSceneTools",
                "MovieSceneTracks",
                "CinematicCamera",
                "EditorStyle",
                "GraphEditor",
                "UMGEditor",
                "AIGraph",
                "RawMesh",
                "DesktopWidgets",
                "EditorWidgets",
                "FBX",
                "Persona",
                "PropertyEditor",
                "LandscapeEditor",
                "MaterialEditor"
            });
        }

        if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
        {
            if (UseThirdPartyPython)
            {
                PythonHome = ThirdPartyPythonHome;

                System.Console.WriteLine("Using Embedded Python at: " + PythonHome);
                PublicIncludePaths.Add(PythonHome);
                string libPath = Path.Combine(PythonHome, "Lib", string.Format("{0}.lib", PythonType.ToLower()));

                System.Console.WriteLine("full lib path: " + libPath);
                PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
                PublicAdditionalLibraries.Add(libPath);

                string dllPath = Path.Combine(BinariesPath, "Win64", string.Format("{0}.dll", PythonType.ToLower()));
                RuntimeDependencies.Add(dllPath);

                AddRuntimeDependenciesForCopying(Target);
            }
            else if (PythonHome == "")
            {
                PythonHome = DiscoverPythonPath(windowsKnownPaths, "Win64");
                if (PythonHome == "")
                {
                    throw new System.Exception("Unable to find Python installation");
                }

                System.Console.WriteLine("Using Python at: " + PythonHome);
                PublicIncludePaths.Add(PythonHome);
                string libPath = GetWindowsPythonLibFile(PythonHome);
                PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
                PublicAdditionalLibraries.Add(libPath);
            }
        }

        //other platforms
        else
        {
            if (PythonHome == "")
            {
                PythonHome = DiscoverPythonPath(macKnownPaths, "Mac");
                if (PythonHome == "")
                {
                    throw new System.Exception("Unable to find Python installation");
                }
                System.Console.WriteLine("Using Python at: " + PythonHome);
                PublicIncludePaths.Add(PythonHome);
                PublicAdditionalLibraries.Add(Path.Combine(PythonHome, "Lib", string.Format("{0}.lib", PythonType)));
            }
            System.Console.WriteLine("Using Python at: " + PythonHome);
            PublicIncludePaths.Add(PythonHome);
            string libPath = GetMacPythonLibFile(PythonHome);
            PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
            PublicDelayLoadDLLs.Add(libPath);
        }
        if (Target.Platform == UnrealTargetPlatform.Linux)
        {
            if (PythonHome == "")
            {
                string includesPath = DiscoverLinuxPythonIncludesPath();
                if (includesPath == null)
                {
                    throw new System.Exception("Unable to find Python includes, please add a search path to linuxKnownIncludesPaths");
                }
                string libsPath = DiscoverLinuxPythonLibsPath();
                if (libsPath == null)
                {
                    throw new System.Exception("Unable to find Python libs, please add a search path to linuxKnownLibsPaths");
                }
                PublicIncludePaths.Add(includesPath);
                PublicAdditionalLibraries.Add(libsPath);
            }
            else
            {
                string[] items = PythonHome.Split(';');
                PublicIncludePaths.Add(items[0]);
                PublicAdditionalLibraries.Add(items[1]);
            }
        }
#if WITH_FORWARDED_MODULE_RULES_CTOR
        else if (Target.Platform == UnrealTargetPlatform.Android)
        {
            PublicIncludePaths.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/python35/include"));
            PublicLibraryPaths.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/armeabi-v7a"));
            PublicAdditionalLibraries.Add("python3.5m");

            string APLName    = "UnrealEnginePython_APL.xml";
            string RelAPLPath = Utils.MakePathRelativeTo(System.IO.Path.Combine(ModuleDirectory, APLName), Target.RelativeEnginePath);
            AdditionalPropertiesForReceipt.Add("AndroidPlugin", RelAPLPath);
        }
#endif
    }
コード例 #11
0
    public PhysX(ReadOnlyTargetRules Target) : base(Target)
    {
        Type = ModuleType.External;

        if (LibraryMode == PhysXLibraryMode.Shipping)
        {
            PublicDefinitions.Add("WITH_PHYSX_RELEASE=1");
        }
        else
        {
            PublicDefinitions.Add("WITH_PHYSX_RELEASE=0");
        }

        PublicSystemIncludePaths.AddRange(new string[]
        {
            PxSharedIncludeDir,
            Path.Combine(PxSharedIncludeDir, "cudamanager"),
            Path.Combine(PxSharedIncludeDir, "filebuf"),
            Path.Combine(PxSharedIncludeDir, "foundation"),
            Path.Combine(PxSharedIncludeDir, "pvd"),
            Path.Combine(PxSharedIncludeDir, "task"),
            PhysXIncludeDir,
            Path.Combine(PhysXIncludeDir, "cooking"),
            Path.Combine(PhysXIncludeDir, "common"),
            Path.Combine(PhysXIncludeDir, "extensions"),
            Path.Combine(PhysXIncludeDir, "geometry")
        });

        string EngineBinThirdPartyPath = Path.Combine("$(EngineDir)", "Binaries", "ThirdParty", "PhysX3");

        // Libraries and DLLs for windows platform
        if (Target.Platform.IsInGroup(UnrealPlatformGroup.Windows) && Target.Platform != UnrealTargetPlatform.Win32)
        {
            string[] StaticLibrariesX64 = new string[] {
                "PhysX3{0}_x64.lib",
                "PhysX3Extensions{0}_x64.lib",
                "PhysX3Cooking{0}_x64.lib",
                "PhysX3Common{0}_x64.lib",
                "PsFastXml{0}_x64.lib",
                "PxFoundation{0}_x64.lib",
                "PxPvdSDK{0}_x64.lib",
                "PxTask{0}_x64.lib",
            };

            string[] DelayLoadDLLsX64 = new string[] {
                "PxFoundation{0}_x64.dll",
                "PxPvdSDK{0}_x64.dll",
                "PhysX3{0}_x64.dll",
                "PhysX3Cooking{0}_x64.dll",
                "PhysX3Common{0}_x64.dll",
            };

            string[] PxSharedRuntimeDependenciesX64 = new string[] {
                "PxFoundation{0}_x64.dll",
                "PxPvdSDK{0}_x64.dll",
            };

            foreach (string Lib in StaticLibrariesX64)
            {
                PublicAdditionalLibraries.Add(Path.Combine(PhysXLibDir, "Win64", "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(), String.Format(Lib, LibrarySuffix)));
            }

            foreach (string DLL in DelayLoadDLLsX64)
            {
                PublicDelayLoadDLLs.Add(String.Format(DLL, LibrarySuffix));
            }

            string PhysXBinariesDir = Path.Combine(EngineBinThirdPartyPath, "Win64", "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
            foreach (string DLL in DelayLoadDLLsX64)
            {
                string FileName = Path.Combine(PhysXBinariesDir, String.Format(DLL, LibrarySuffix));
                RuntimeDependencies.Add(FileName, StagedFileType.NonUFS);
                RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS);
            }

            if (LibrarySuffix != "")
            {
                PublicDefinitions.Add("UE_PHYSX_SUFFIX=" + LibrarySuffix);
            }

            foreach (string DLL in PxSharedRuntimeDependenciesX64)
            {
                RuntimeDependencies.Add(Path.Combine(PhysXBinariesDir, String.Format(DLL, LibrarySuffix)));
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.Win32)
        {
            string[] StaticLibrariesX86 = new string[] {
                "PhysX3{0}_x86.lib",
                "PhysX3Extensions{0}_x86.lib",
                "PhysX3Cooking{0}_x86.lib",
                "PhysX3Common{0}_x86.lib",
                "PsFastXml{0}_x86.lib",
                "PxFoundation{0}_x86.lib",
                "PxPvdSDK{0}_x86.lib",
                "PxTask{0}_x86.lib",
            };

            string[] DelayLoadDLLsX86 = new string[] {
                "PxFoundation{0}_x86.dll",
                "PxPvdSDK{0}_x86.dll",
                "PhysX3{0}_x86.dll",
                "PhysX3Cooking{0}_x86.dll",
                "PhysX3Common{0}_x86.dll"
            };

            foreach (string Lib in StaticLibrariesX86)
            {
                PublicAdditionalLibraries.Add(Path.Combine(PhysXLibDir, "Win32", "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(), String.Format(Lib, LibrarySuffix)));
            }

            foreach (string DLL in DelayLoadDLLsX86)
            {
                PublicDelayLoadDLLs.Add(String.Format(DLL, LibrarySuffix));
            }

            string PhysXBinariesDir = Path.Combine(EngineBinThirdPartyPath, "Win32", "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
            foreach (string DLL in DelayLoadDLLsX86)
            {
                string FileName = Path.Combine(PhysXBinariesDir, String.Format(DLL, LibrarySuffix));
                RuntimeDependencies.Add(FileName, StagedFileType.NonUFS);
                RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS);
            }

            if (LibrarySuffix != "")
            {
                PublicDefinitions.Add("UE_PHYSX_SUFFIX=" + LibrarySuffix);
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.HoloLens)
        {
            string Arch = Target.WindowsPlatform.GetArchitectureSubpath();

            string[] StaticLibraries = new string[] {
                "PhysX3{0}_{1}.lib",
                "PhysX3Extensions{0}_{1}.lib",
                "PhysX3Cooking{0}_{1}.lib",
                "PhysX3Common{0}_{1}.lib",
                "PsFastXml{0}_{1}.lib",
                "PxFoundation{0}_{1}.lib",
                "PxPvdSDK{0}_{1}.lib",
                "PxTask{0}_{1}.lib",
            };

            string[] DelayLoadDLLs = new string[] {
                "PxFoundation{0}_{1}.dll",
                "PxPvdSDK{0}_{1}.dll",
                "PhysX3{0}_{1}.dll",
                "PhysX3Cooking{0}_{1}.dll",
                "PhysX3Common{0}_{1}.dll",
            };

            string[] PxSharedRuntimeDependencies = new string[] {
                "PxFoundation{0}_{1}.dll",
                "PxPvdSDK{0}_{1}.dll",
            };

            foreach (string Lib in StaticLibraries)
            {
                PublicAdditionalLibraries.Add(Path.Combine(PhysXLibDir, Target.Platform.ToString(), "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(), String.Format(Lib, LibrarySuffix, Arch)));
            }

            foreach (string DLL in DelayLoadDLLs)
            {
                PublicDelayLoadDLLs.Add(String.Format(DLL, LibrarySuffix, Arch));
            }
            string PhysXBinariesDir = Path.Combine(EngineBinThirdPartyPath, Target.Platform.ToString(), "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
            foreach (string DLL in DelayLoadDLLs)
            {
                string FileName = Path.Combine(PhysXBinariesDir, String.Format(DLL, LibrarySuffix, Arch));
                RuntimeDependencies.Add(FileName, StagedFileType.NonUFS);
                RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS);
            }

            if (LibrarySuffix != "")
            {
                PublicDefinitions.Add("UE_PHYSX_SUFFIX=" + LibrarySuffix);
            }

            foreach (string DLL in PxSharedRuntimeDependencies)
            {
                RuntimeDependencies.Add(Path.Combine(PhysXBinariesDir, String.Format(DLL, LibrarySuffix, Arch)));
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.Mac)
        {
            string[] StaticLibrariesMac = new string[] {
                Path.Combine(PhysXLibDir, "Mac", "libLowLevel{0}.a"),
                Path.Combine(PhysXLibDir, "Mac", "libLowLevelCloth{0}.a"),
                Path.Combine(PhysXLibDir, "Mac", "libPhysX3Extensions{0}.a"),
                Path.Combine(PhysXLibDir, "Mac", "libSceneQuery{0}.a"),
                Path.Combine(PhysXLibDir, "Mac", "libSimulationController{0}.a"),
                Path.Combine(PxSharedLibDir, "Mac", "libPxTask{0}.a"),
                Path.Combine(PxSharedLibDir, "Mac", "libPsFastXml{0}.a")
            };

            foreach (string Lib in StaticLibrariesMac)
            {
                PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
            }

            string[] DynamicLibrariesMac = new string[] {
                "libPhysX3{0}.dylib",
                "libPhysX3Cooking{0}.dylib",
                "libPhysX3Common{0}.dylib",
                "libPxFoundation{0}.dylib",
                "libPxPvdSDK{0}.dylib",
            };

            string PhysXBinariesDir = Path.Combine(Target.UEThirdPartyBinariesDirectory, "PhysX3", "Mac");
            foreach (string Lib in DynamicLibrariesMac)
            {
                string LibraryPath = Path.Combine(PhysXBinariesDir, String.Format(Lib, LibrarySuffix));
                PublicDelayLoadDLLs.Add(LibraryPath);
                RuntimeDependencies.Add(LibraryPath);
            }

            if (LibrarySuffix != "")
            {
                PublicDefinitions.Add("UE_PHYSX_SUFFIX=" + LibrarySuffix);
            }
        }
        else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
        {
            string[] Architectures = new string[] {
                "ARMv7",
                "ARM64",
                "x86",
                "x64",
            };

            string[] StaticLibrariesAndroid = new string[] {
                "PhysX3{0}",
                "PhysX3Extensions{0}",
                "PhysX3Cooking{0}",                 // not needed until Apex
                "PhysX3Common{0}",
                //"PhysXVisualDebuggerSDK{0}",
                "PxFoundation{0}",
                "PxPvdSDK{0}",
                "PsFastXml{0}"
            };

            //if you are shipping, and you actually want the shipping libs, you do not need this lib
            if (!(LibraryMode == PhysXLibraryMode.Shipping && Target.bUseShippingPhysXLibraries))
            {
//				PublicAdditionalLibraries.Add("nvToolsExt");
            }

            foreach (string Architecture in Architectures)
            {
                foreach (string Lib in StaticLibrariesAndroid)
                {
                    PublicAdditionalLibraries.Add(Path.Combine(PhysXLibDir, "Android", Architecture, "lib" + String.Format(Lib, LibrarySuffix) + ".a"));
                }
            }
        }
        else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
        {
            PublicSystemLibraries.Add("rt");

            string[] StaticLibrariesPhysXLinux = new string[] {
                "PhysX3{0}",
                "PhysX3Extensions{0}",
                "PhysX3Cooking{0}",
                "PhysX3Common{0}",
                "PxFoundation{0}",
                "PxPvdSDK{0}",
                "PsFastXml{0}"
            };

            foreach (string Lib in StaticLibrariesPhysXLinux)
            {
                PublicAdditionalLibraries.Add(Path.Combine(PhysXLibDir, "Linux", Target.Architecture, "lib" + String.Format(Lib, LibrarySuffix) + ".a"));
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.IOS)
        {
            string[] PhysXLibs = new string[]
            {
                "LowLevel{0}",
                "LowLevelAABB{0}",
                "LowLevelCloth{0}",
                "LowLevelDynamics{0}",
                "LowLevelParticles{0}",
                "PhysX3{0}",
                "PhysX3Common{0}",
                // "PhysX3Cooking{0}", // not needed until Apex
                "PhysX3Extensions{0}",
                "SceneQuery{0}",
                "SimulationController{0}",
                "PxFoundation{0}",
                "PxTask{0}",
                "PxPvdSDK{0}",
                "PsFastXml{0}"
            };

            foreach (string PhysXLib in PhysXLibs)
            {
                PublicAdditionalLibraries.Add(Path.Combine(PhysXLibDir, "IOS", "lib" + String.Format(PhysXLib, LibrarySuffix) + ".a"));
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.TVOS)
        {
            string[] PhysXLibs = new string[]
            {
                "LowLevel{0}",
                "LowLevelAABB{0}",
                "LowLevelCloth{0}",
                "LowLevelDynamics{0}",
                "LowLevelParticles{0}",
                "PhysX3{0}",
                "PhysX3Common{0}",
                // "PhysX3Cooking{0}", // not needed until Apex
                "PhysX3Extensions{0}",
                "SceneQuery{0}",
                "SimulationController{0}",
                "PxFoundation{0}",
                "PxTask{0}",
                "PxPvdSDK{0}",
                "PsFastXml"
            };

            foreach (string PhysXLib in PhysXLibs)
            {
                PublicAdditionalLibraries.Add(Path.Combine(PhysXLibDir, "TVOS", "lib" + String.Format(PhysXLib, LibrarySuffix) + ".a"));
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.XboxOne)
        {
            PublicDefinitions.Add("PX_PHYSX_STATIC_LIB=1");
            PublicDefinitions.Add("_XBOX_ONE=1");

            string[] StaticLibrariesXB1 = new string[] {
                "PhysX3{0}.lib",
                "PhysX3Extensions{0}.lib",
                "PhysX3Cooking{0}.lib",
                "PhysX3Common{0}.lib",
                "LowLevel{0}.lib",
                "LowLevelAABB{0}.lib",
                "LowLevelCloth{0}.lib",
                "LowLevelDynamics{0}.lib",
                "LowLevelParticles{0}.lib",
                "SceneQuery{0}.lib",
                "SimulationController{0}.lib",
                "PxFoundation{0}.lib",
                "PxTask{0}.lib",
                "PxPvdSDK{0}.lib",
                "PsFastXml{0}.lib"
            };

            foreach (string Lib in StaticLibrariesXB1)
            {
                PublicAdditionalLibraries.Add(Path.Combine(PhysXLibDir, "XboxOne", "VS2015", String.Format(Lib, LibrarySuffix)));
            }
        }
    }
コード例 #12
0
        public FliteTTSPlugin(ReadOnlyTargetRules Target) : base(Target)
        {
            bEnableUndefinedIdentifierWarnings = false;
            PublicIncludePaths.AddRange(
                new string[] {
                "FliteTTSPlugin/Private",
                "FliteTTSPlugin/Public",
                "FliteTTSPlugin/ThirdParty/flite/include",    // ... add public include paths required here ...
            }
                );

            PrivateIncludePaths.AddRange(
                new string[] {
                // ... add other private include paths required here ...
            }
                );

            PublicDependencyModuleNames.AddRange(
                new string[]
                { "Core",
                  "CoreUObject",
                  "Engine",
                  "InputCore",
                  // ... add other public dependencies that you statically link with here ...
                }
                );

            PrivateDependencyModuleNames.AddRange(
                new string[]
            {
                // ... add private dependencies that you statically link with here ...
            }
                );

            DynamicallyLoadedModuleNames.AddRange(
                new string[]
            {
                // ... add any modules that your module loads dynamically here ...
            }
                );


            if (Target.Platform == UnrealTargetPlatform.Win32)
            {
                string FliteDirectory = Path.Combine(BaseDirectory, "ThirdParty", "flite", "lib");
                RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(FliteDirectory, "fliteDll.dll")));
                RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(FliteDirectory, "cmu_us_rms.dll")));
                // RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(FliteDirectory, "cmu_us_slt.dll")));
                PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "flite.lib"));
                PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "libflite-cmulex.lib"));
                PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "libflite-usenglish.lib"));
                PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "cmu_us_rms.lib"));
            }
            else if (Target.Platform == UnrealTargetPlatform.Win64)
            {
                string FliteDirectory = Path.Combine(BaseDirectory, "ThirdParty", "flite", "lib");
                RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(FliteDirectory, "fliteDll.dll")));
                RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(FliteDirectory, "cmu_us_rms.dll")));
                // RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(FliteDirectory, "cmu_us_slt.dll")));
                PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "flite.lib"));
                PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "libflite-cmulex.lib"));
                PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "libflite-usenglish.lib"));;
                PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "cmu_us_rms.lib"));
            }
            else
            {
                // Linux, Mac, WinRT: not supported
            }
        }
コード例 #13
0
    public AWSCore(ReadOnlyTargetRules Target) : base(Target)
    {
        PrivateIncludePaths.AddRange(new string[] { "GameLiftClientSDK/AWSCore/Private" });
        PublicIncludePaths.AddRange(new string[] { "GameLiftClientSDK/AWSCore/Public" });

        PublicDependencyModuleNames.AddRange(new string[] { "Engine", "Core", "CoreUObject", "InputCore", "Projects" });
        PrivateDependencyModuleNames.AddRange(new string[] { });

        string BaseDirectory          = System.IO.Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", "..", ".."));
        string ThirdPartyPath         = System.IO.Path.Combine(BaseDirectory, "ThirdParty", "GameLiftClientSDK", Target.Platform.ToString());
        bool   bIsThirdPartyPathValid = System.IO.Directory.Exists(ThirdPartyPath);

        if (bIsThirdPartyPathValid)
        {
            PublicLibraryPaths.Add(ThirdPartyPath);

            //string AWSCCommonLibFile = System.IO.Path.Combine(ThirdPartyPath, "aws-c-common.lib");
            //if (File.Exists(AWSCCommonLibFile))
            //{
            //    PublicAdditionalLibraries.Add(AWSCCommonLibFile);
            //}
            //else
            //{
            //    throw new BuildException("aws-c-common.lib not found. Expected in this location: " + AWSCCommonLibFile);
            //}

            //string AWSCCommonDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-c-common.dll");
            //if (File.Exists(AWSCCommonDLLFile))
            //{
            //    PublicAdditionalLibraries.Add(AWSCCommonDLLFile);
            //}
            //else
            //{
            //    throw new BuildException("aws-c-common.dll not found. Expected in this location: " + AWSCCommonDLLFile);
            //}

            //string AWSCEventStreamLibFile = System.IO.Path.Combine(ThirdPartyPath, "aws-c-event-stream.lib");
            //if (File.Exists(AWSCEventStreamLibFile))
            //{
            //    PublicAdditionalLibraries.Add(AWSCEventStreamLibFile);
            //}
            //else
            //{
            //    throw new BuildException("aws-c-event-stream.lib not found. Expected in this location: " + AWSCEventStreamLibFile);
            //}

            //string AWSCEventStreamDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-c-event-stream.dll");
            //if (File.Exists(AWSCEventStreamDLLFile))
            //{
            //    PublicAdditionalLibraries.Add(AWSCEventStreamDLLFile);
            //}
            //else
            //{
            //    throw new BuildException("aws-c-event-stream.dll not found. Expected in this location: " + AWSCEventStreamDLLFile);
            //}

            string AWSCoreLibFile = System.IO.Path.Combine(ThirdPartyPath, "aws-cpp-sdk-core.lib");
            if (File.Exists(AWSCoreLibFile))
            {
                PublicAdditionalLibraries.Add(AWSCoreLibFile);
            }
            else
            {
                throw new BuildException("aws-cpp-sdk-core.lib not found. Expected in this location: " + AWSCoreLibFile);
            }

            string AWSCoreDLLFile     = System.IO.Path.Combine(ThirdPartyPath, "aws-cpp-sdk-core.dll");
            string AWSCommonDLLFile   = System.IO.Path.Combine(ThirdPartyPath, "aws-c-common.dll");
            string AWSStreamDLLFile   = System.IO.Path.Combine(ThirdPartyPath, "aws-c-event-stream.dll");
            string AWSChecksumDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-checksums.dll");

            if (File.Exists(AWSCoreDLLFile))
            {
                RuntimeDependencies.Add(AWSCommonDLLFile);
                RuntimeDependencies.Add(AWSStreamDLLFile);
                RuntimeDependencies.Add(AWSChecksumDLLFile);

                PublicDelayLoadDLLs.Add("aws-cpp-sdk-core.dll");
                RuntimeDependencies.Add(AWSCoreDLLFile);
            }
            else
            {
                throw new BuildException("aws-cpp-sdk-core.dll not found. Expected in this location: " + AWSCoreDLLFile);
            }

            string BinariesDirectory = System.IO.Path.Combine(BaseDirectory, "Binaries", Target.Platform.ToString());
            if (!Directory.Exists(BinariesDirectory))
            {
                Directory.CreateDirectory(BinariesDirectory);
            }

            if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "aws-cpp-sdk-core.dll")) == false)
            {
                File.Copy(System.IO.Path.Combine(ThirdPartyPath, "aws-cpp-sdk-core.dll"), System.IO.Path.Combine(BinariesDirectory, "aws-cpp-sdk-core.dll"));
            }

            if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "aws-c-common.dll")) == false)
            {
                File.Copy(System.IO.Path.Combine(ThirdPartyPath, "aws-c-common.dll"), System.IO.Path.Combine(BinariesDirectory, "aws-c-common.dll"));
            }

            if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "aws-c-event-stream.dll")) == false)
            {
                File.Copy(System.IO.Path.Combine(ThirdPartyPath, "aws-c-event-stream.dll"), System.IO.Path.Combine(BinariesDirectory, "aws-c-event-stream.dll"));
            }

            if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "aws-checksums.dll")) == false)
            {
                File.Copy(System.IO.Path.Combine(ThirdPartyPath, "aws-checksums.dll"), System.IO.Path.Combine(BinariesDirectory, "aws-checksums.dll"));
            }
        }
    }
コード例 #14
0
    public Steamworks(TargetInfo Target)
    {
        /** Mark the current version of the Steam SDK */
        string SteamVersion = "v132";

        Type = ModuleType.External;

        string SdkBase = UEBuildConfiguration.UEThirdPartySourceDirectory + "Steamworks/Steam" + SteamVersion + "/sdk";

        if (!Directory.Exists(SdkBase))
        {
            string Err = string.Format("steamworks SDK not found in {0}", SdkBase);
            System.Console.WriteLine(Err);
            throw new BuildException(Err);
        }

        PublicIncludePaths.Add(SdkBase + "/public");

        string LibraryPath = SdkBase + "/redistributable_bin/";
        string LibraryName = "steam_api";

        if (Target.Platform == UnrealTargetPlatform.Win32)
        {
            PublicLibraryPaths.Add(LibraryPath);
            PublicAdditionalLibraries.Add(LibraryName + ".lib");
            PublicDelayLoadDLLs.Add(LibraryName + ".dll");

            string SteamBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/Steamworks/Steam{0}/Win32/", SteamVersion);
            RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + "steam_api.dll"));

            if (Target.Type == TargetRules.TargetType.Server)
            {
                RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + "steamclient.dll"));
                RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + "tier0_s.dll"));
                RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + "vstdlib_s.dll"));
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.Win64)
        {
            PublicLibraryPaths.Add(LibraryPath + "win64");
            PublicAdditionalLibraries.Add(LibraryName + "64.lib");
            PublicDelayLoadDLLs.Add(LibraryName + "64.dll");

            string SteamBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/Steamworks/Steam{0}/Win64/", SteamVersion);
            RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + LibraryName + "64.dll"));

            if (Target.Type == TargetRules.TargetType.Server)
            {
                RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + "steamclient64.dll"));
                RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + "tier0_s64.dll"));
                RuntimeDependencies.Add(new RuntimeDependency(SteamBinariesDir + "vstdlib_s64.dll"));
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.Mac)
        {
            LibraryPath += "osx32/libsteam_api.dylib";
            PublicDelayLoadDLLs.Add(LibraryPath);
            PublicAdditionalShadowFiles.Add(LibraryPath);
        }
        else if (Target.Platform == UnrealTargetPlatform.Linux)
        {
            if (Target.IsMonolithic)
            {
                LibraryPath += "linux64";
                PublicLibraryPaths.Add(LibraryPath);
                PublicAdditionalLibraries.Add(LibraryName);
            }
            else
            {
                LibraryPath += "linux64/libsteam_api.so";
                PublicDelayLoadDLLs.Add(LibraryPath);
            }
        }
    }
コード例 #15
0
        public HiveMPSDK(ReadOnlyTargetRules Target) : base(Target)
        {
            PublicDefinitions.Add("HIVEMPSDK_PACKAGE=1");
            PublicDefinitions.Add("CLIENT_CONNECT_TARGETING_UNREAL=1");
            PublicDefinitions.Add("HAVE_LIBINTL_H=0");
            PublicDefinitions.Add("HAVE_STRING_H=0");
            PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;

            PublicDependencyModuleNames.AddRange(
                new string[] {
                "Core",
                "CoreUObject",
                "Engine",
                "Sockets",
                "OnlineSubsystem",
                "OnlineSubsystemUtils",
                "Json",
                "Http",
                "PacketHandler",
                "WebSocket"
            }
                );

            string SdkBase = Path.GetFullPath(Path.Combine(ModuleDirectory, "Private/steam"));

            PrivateIncludePaths.Add(Path.Combine(SdkBase, "public"));

            string LibraryPath = SdkBase;
            string LibraryName = "steam_api";

            if (Target.Platform == UnrealTargetPlatform.Win32)
            {
                PublicDefinitions.Add("STEAMSDK_FOUND=1");
                PublicDefinitions.Add("WITH_STEAMWORKS=1");
                PublicLibraryPaths.Add(Path.Combine(LibraryPath, "win32"));
                PublicAdditionalLibraries.Add(LibraryName + ".lib");
                PublicDelayLoadDLLs.Add(LibraryName + ".dll");
                RuntimeDependencies.Add(Path.Combine(LibraryPath, "win32/" + LibraryName + ".dll"));
            }
            else if (Target.Platform == UnrealTargetPlatform.Win64)
            {
                PublicDefinitions.Add("STEAMSDK_FOUND=1");
                PublicDefinitions.Add("WITH_STEAMWORKS=1");
                PublicLibraryPaths.Add(Path.Combine(LibraryPath, "win64"));
                PublicAdditionalLibraries.Add(LibraryName + "64.lib");
                PublicDelayLoadDLLs.Add(LibraryName + "64.dll");
                RuntimeDependencies.Add(Path.Combine(LibraryPath, "win64/" + LibraryName + "64.dll"));
            }
            else if (Target.Platform == UnrealTargetPlatform.Mac)
            {
                PublicDefinitions.Add("STEAMSDK_FOUND=1");
                PublicDefinitions.Add("WITH_STEAMWORKS=1");
                PublicDelayLoadDLLs.Add(Path.Combine(LibraryPath, "osx/lib" + LibraryName + ".dylib"));
                PublicAdditionalShadowFiles.Add(LibraryPath);
                AdditionalBundleResources.Add(new UEBuildBundleResource(LibraryPath, "MacOS"));
            }
            else if (Target.Platform == UnrealTargetPlatform.Linux)
            {
                PublicDefinitions.Add("STEAMSDK_FOUND=1");
                PublicDefinitions.Add("WITH_STEAMWORKS=1");

                if (Target.LinkType == TargetLinkType.Monolithic)
                {
                    PublicLibraryPaths.Add(Path.Combine(LibraryPath, "linux64"));
                    PublicAdditionalLibraries.Add(LibraryName);
                }
                else
                {
                    PublicDelayLoadDLLs.Add(Path.Combine(LibraryPath, "linux64/lib" + LibraryName + ".so"));
                }
                PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, "linux64/lib" + LibraryName + ".so"));
                RuntimeDependencies.Add(Path.Combine(LibraryPath, "linux64/lib" + LibraryName + ".so"));
            }
        }
コード例 #16
0
    public Core(ReadOnlyTargetRules Target) : base(Target)
    {
        PrivatePCHHeaderFile = "Private/CorePrivatePCH.h";

        SharedPCHHeaderFile = "Public/CoreSharedPCH.h";

        PrivateDependencyModuleNames.Add("BuildSettings");

        PublicDependencyModuleNames.Add("TraceLog");
        PublicIncludePaths.Add("Runtime/TraceLog/Public");

        PrivateIncludePaths.AddRange(
            new string[] {
            "Developer/DerivedDataCache/Public",
            "Runtime/SynthBenchmark/Public",
            "Runtime/Core/Private",
            "Runtime/Core/Private/Misc",
            "Runtime/Core/Private/Internationalization",
            "Runtime/Core/Private/Internationalization/Cultures",
            "Runtime/Engine/Public",
        }
            );

        PrivateIncludePathModuleNames.AddRange(
            new string[] {
            "TargetPlatform",
            "DerivedDataCache",
            "InputDevice",
            "Analytics",
            "RHI"
        }
            );

        if (Target.bBuildEditor == true)
        {
            DynamicallyLoadedModuleNames.Add("SourceCodeAccess");

            PrivateIncludePathModuleNames.Add("DirectoryWatcher");
            DynamicallyLoadedModuleNames.Add("DirectoryWatcher");
        }

        if (Target.Platform.IsInGroup(UnrealPlatformGroup.Windows))
        {
            AddEngineThirdPartyPrivateStaticDependencies(Target,
                                                         "zlib");

            AddEngineThirdPartyPrivateStaticDependencies(Target,
                                                         "IntelTBB",
                                                         "IntelVTune"
                                                         );

            AddEngineThirdPartyPrivateStaticDependencies(Target,
                                                         "mimalloc");

            if (Target.Platform != UnrealTargetPlatform.Win32 && Target.WindowsPlatform.bUseBundledDbgHelp)
            {
                PublicDelayLoadDLLs.Add("DBGHELP.DLL");
                PrivateDefinitions.Add("USE_BUNDLED_DBGHELP=1");
                RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/DbgHelp/dbghelp.dll");
            }
            else
            {
                PrivateDefinitions.Add("USE_BUNDLED_DBGHELP=0");
            }
            PrivateDefinitions.Add("YIELD_BETWEEN_TASKS=1");
        }
        else if ((Target.Platform == UnrealTargetPlatform.HoloLens))
        {
            PublicIncludePaths.Add("Runtime/Core/Public/HoloLens");
            AddEngineThirdPartyPrivateStaticDependencies(Target,
                                                         "zlib");

            AddEngineThirdPartyPrivateStaticDependencies(Target,
                                                         "IntelTBB",
                                                         "XInput"
                                                         );
        }
        else if (Target.Platform == UnrealTargetPlatform.Mac)
        {
            AddEngineThirdPartyPrivateStaticDependencies(Target,
                                                         "IntelTBB",
                                                         "zlib",
                                                         "PLCrashReporter",
                                                         "rd_route"
                                                         );
            PublicFrameworks.AddRange(new string[] { "Cocoa", "Carbon", "IOKit", "Security" });

            if (Target.bBuildEditor == true)
            {
                string SDKROOT = Utils.RunLocalProcessAndReturnStdOut("/usr/bin/xcrun", "--sdk macosx --show-sdk-path");
                PublicAdditionalLibraries.Add(SDKROOT + "/System/Library/PrivateFrameworks/MultitouchSupport.framework/Versions/Current/MultitouchSupport.tbd");
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
        {
            AddEngineThirdPartyPrivateStaticDependencies(Target,
                                                         "zlib"
                                                         );
            PublicFrameworks.AddRange(new string[] { "UIKit", "Foundation", "AudioToolbox", "AVFoundation", "GameKit", "StoreKit", "CoreVideo", "CoreMedia", "CoreGraphics", "GameController", "SystemConfiguration", "DeviceCheck", "UserNotifications" });
            if (Target.Platform == UnrealTargetPlatform.IOS)
            {
                PublicFrameworks.AddRange(new string[] { "CoreMotion", "AdSupport", "WebKit" });
                AddEngineThirdPartyPrivateStaticDependencies(Target,
                                                             "PLCrashReporter"
                                                             );
            }

            PrivateIncludePathModuleNames.Add("ApplicationCore");

            bool bSupportAdvertising = Target.Platform == UnrealTargetPlatform.IOS;
            if (bSupportAdvertising)
            {
                PublicFrameworks.AddRange(new string[] { "iAD" });
            }

            // export Core symbols for embedded Dlls
            ModuleSymbolVisibility = ModuleRules.SymbolVisibility.VisibileForDll;
        }
        else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
        {
            AddEngineThirdPartyPrivateStaticDependencies(Target,
                                                         "cxademangle",
                                                         "zlib",
                                                         "libunwind"
                                                         );
        }
        else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
        {
            AddEngineThirdPartyPrivateStaticDependencies(Target,
                                                         "zlib",
                                                         "jemalloc"
                                                         );

            // Core uses dlopen()
            PublicSystemLibraries.Add("dl");
        }

        if (Target.bCompileICU == true)
        {
            AddEngineThirdPartyPrivateStaticDependencies(Target, "ICU");
        }
        PublicDefinitions.Add("UE_ENABLE_ICU=" + (Target.bCompileICU ? "1" : "0")); // Enable/disable (=1/=0) ICU usage in the codebase. NOTE: This flag is for use while integrating ICU and will be removed afterward.

        // If we're compiling with the engine, then add Core's engine dependencies
        if (Target.bCompileAgainstEngine == true)
        {
            if (!Target.bBuildRequiresCookedData)
            {
                DynamicallyLoadedModuleNames.AddRange(new string[] { "DerivedDataCache" });
            }
        }


        // On Windows platform, VSPerfExternalProfiler.cpp needs access to "VSPerf.h".  This header is included with Visual Studio, but it's not in a standard include path.
        if (Target.Platform.IsInGroup(UnrealPlatformGroup.Windows))
        {
            var VisualStudioVersionNumber = "11.0";
            var SubFolderName             = (Target.Platform == UnrealTargetPlatform.Win32) ? "PerfSDK" : "x64/PerfSDK";

            string PerfIncludeDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), String.Format("Microsoft Visual Studio {0}/Team Tools/Performance Tools/{1}", VisualStudioVersionNumber, SubFolderName));

            if (File.Exists(Path.Combine(PerfIncludeDirectory, "VSPerf.h")))
            {
                PrivateIncludePaths.Add(PerfIncludeDirectory);
                PublicDefinitions.Add("WITH_VS_PERF_PROFILER=1");
            }
            else
            {
                PublicDefinitions.Add("WITH_VS_PERF_PROFILER=0");
            }
        }

        if (Target.Platform == UnrealTargetPlatform.HoloLens)
        {
            PublicDefinitions.Add("WITH_VS_PERF_PROFILER=0");
        }

        if (Target.bWithDirectXMath && (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32))
        {
            PublicDefinitions.Add("WITH_DIRECTXMATH=1");
        }
        else
        {
            PublicDefinitions.Add("WITH_DIRECTXMATH=0");
        }

        // Set a macro to allow FApp::GetBuildTargetType() to detect client targts
        if (Target.Type == TargetRules.TargetType.Client)
        {
            PrivateDefinitions.Add("IS_CLIENT_TARGET=1");
        }
        else
        {
            PrivateDefinitions.Add("IS_CLIENT_TARGET=0");
        }

        // Decide if validating memory allocator (aka MallocStomp) can be used on the current platform.
        // Run-time validation must be enabled through '-stompmalloc' command line argument.

        bool bWithMallocStomp = false;

        if (Target.Configuration != UnrealTargetConfiguration.Shipping)
        {
            if (Target.Platform == UnrealTargetPlatform.Mac ||
                Target.Platform == UnrealTargetPlatform.Linux ||
                Target.Platform == UnrealTargetPlatform.LinuxAArch64 ||
                Target.Platform == UnrealTargetPlatform.Win64)
            // Target.Platform == UnrealTargetPlatform.Win32: // 32-bit windows can technically be supported, but will likely run out of virtual memory space quickly
            // Target.Platform == UnrealTargetPlatform.XboxOne: // XboxOne could be supported, as it's similar enough to Win64
            {
                bWithMallocStomp = true;
            }
        }

        PublicDefinitions.Add("WITH_MALLOC_STOMP=" + (bWithMallocStomp ? "1" : "0"));

        PrivateDefinitions.Add("PLATFORM_COMPILER_OPTIMIZATION_LTCG=" + (Target.bAllowLTCG ? "1" : "0"));
        PrivateDefinitions.Add("PLATFORM_COMPILER_OPTIMIZATION_PG=" + (Target.bPGOOptimize ? "1" : "0"));
        PrivateDefinitions.Add("PLATFORM_COMPILER_OPTIMIZATION_PG_PROFILING=" + (Target.bPGOProfile ? "1" : "0"));

        UnsafeTypeCastWarningLevel = WarningLevel.Warning;
    }
コード例 #17
0
    public TeamSpeak_SDK(ReadOnlyTargetRules Target) : base(Target)
    {
        PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;

        string BaseDirectory = Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", ".."));
        string SDKDirectory  = Path.Combine(BaseDirectory, "ThirdParty");

        PublicIncludePaths.AddRange(
            new string[] {
            Path.Combine(ModuleDirectory, "Public"),
            Path.Combine(SDKDirectory, "include")
        }
            );

        PublicDependencyModuleNames.AddRange(
            new string[] {
            "Core",
            "CoreUObject",
            "Engine",
            "InputCore",
            "Projects"
        }
            );

        bool bHasTeamspeakSDK = System.IO.Directory.Exists(SDKDirectory);

        if (bHasTeamspeakSDK)
        {
            PublicDefinitions.Add("WITH_TEAMSPEAK=1");
            if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
            {
                // Add the import library
                string platform     = Target.Platform == UnrealTargetPlatform.Win32 ? "win32" : "win64";
                string LibDirectory = Path.Combine(SDKDirectory, "lib", "windows", platform);

                PublicLibraryPaths.Add(LibDirectory);
                PublicAdditionalLibraries.Add("ts3client.lib");

                string SDKLibWindows = Path.Combine(SDKDirectory, "bin", "windows", platform, "ts3client.dll");

                string binariesDir = Path.Combine(BaseDirectory, "Binaries", Target.Platform.ToString());
                string filename    = "ts3client.dll";

                if (!Directory.Exists(binariesDir))
                {
                    Directory.CreateDirectory(binariesDir);
                }

                string binPath = Path.Combine(binariesDir, filename);
                if (!File.Exists(Path.Combine(binariesDir, filename)))
                {
                    File.Copy(SDKLibWindows, binPath, true);
                }

                RuntimeDependencies.Add(binPath);
            }
            else if (Target.Platform == UnrealTargetPlatform.Linux)
            {
                string binariesDir = Path.Combine(BaseDirectory, "Binaries", Target.Platform.ToString());
                string filename    = "libts3client.so";
                string binPath     = Path.Combine(binariesDir, filename);
                string SDKLibLinux = Path.Combine(SDKDirectory, "bin", "linux", "amd64", filename);

                if (!Directory.Exists(binariesDir))
                {
                    Directory.CreateDirectory(binariesDir);
                }

                if (!File.Exists(Path.Combine(binPath)))
                {
                    File.Copy(SDKLibLinux, binPath, true);
                }

                RuntimeDependencies.Add(binPath);
                PublicAdditionalLibraries.Add(Path.Combine(SDKDirectory, "bin", "linux", "amd64", "libts3client.so"));
            }
        }
        else
        {
            PublicDefinitions.Add("WITH_TEAMSPEAK=0");
        }
    }
コード例 #18
0
    public AWSCore(ReadOnlyTargetRules Target) : base(Target)
    {
        PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private"));
        PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public"));

        PublicDependencyModuleNames.AddRange(new string[] { "Engine", "Core", "CoreUObject", "InputCore", "Projects" });
        PrivateDependencyModuleNames.AddRange(new string[] { });

        // This is required to fix a warning for Unreal Engine 4.21 and later
        PrivatePCHHeaderFile = "Private/AWSCorePrivatePCH.h";

        string BaseDirectory          = System.IO.Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", ".."));
        string ThirdPartyPath         = System.IO.Path.Combine(BaseDirectory, "ThirdParty", "GameLiftClientSDK", Target.Platform.ToString());
        string BinariesDirectory      = System.IO.Path.Combine(BaseDirectory, "Binaries", Target.Platform.ToString());
        bool   bIsThirdPartyPathValid = System.IO.Directory.Exists(ThirdPartyPath);

        if (bIsThirdPartyPathValid)
        {
            if (Target.Type == TargetRules.TargetType.Client)
            {
                if (!Directory.Exists(BinariesDirectory))
                {
                    Directory.CreateDirectory(BinariesDirectory);
                }

                PublicDefinitions.Add("WITH_AWSCORE=1");
                //PublicLibraryPaths.Add(ThirdPartyPath);
                if (Target.Platform == UnrealTargetPlatform.Linux)
                {
                    // dependencies
                    string CommonSoFile = System.IO.Path.Combine(ThirdPartyPath, "libaws-c-common.so");
                    if (File.Exists(CommonSoFile))
                    {
                        PublicAdditionalLibraries.Add(CommonSoFile);
                        RuntimeDependencies.Add(CommonSoFile);
                    }
                    else
                    {
                        throw new BuildException("libaws-c-common.so not found. Expected in this location: " + CommonSoFile);
                    }

                    string EventStreamSoFile = System.IO.Path.Combine(ThirdPartyPath, "libaws-c-event-stream.so");
                    if (File.Exists(EventStreamSoFile))
                    {
                        PublicAdditionalLibraries.Add(EventStreamSoFile);
                        RuntimeDependencies.Add(EventStreamSoFile);
                    }
                    else
                    {
                        throw new BuildException("libaws-c-event-stream.so not found. Expected in this location: " + EventStreamSoFile);
                    }

                    string ChecksumsSoFile = System.IO.Path.Combine(ThirdPartyPath, "libaws-checksums.so");
                    if (File.Exists(ChecksumsSoFile))
                    {
                        PublicAdditionalLibraries.Add(ChecksumsSoFile);
                        RuntimeDependencies.Add(ChecksumsSoFile);
                    }
                    else
                    {
                        throw new BuildException("libaws-checksums.so not found. Expected in this location: " + ChecksumsSoFile);
                    }

                    // aws core
                    string AWSCoreSoFile = System.IO.Path.Combine(ThirdPartyPath, "libaws-cpp-sdk-core.so");
                    if (File.Exists(AWSCoreSoFile))
                    {
                        PublicAdditionalLibraries.Add(AWSCoreSoFile);
                        RuntimeDependencies.Add(AWSCoreSoFile);
                    }
                    else
                    {
                        throw new BuildException("libaws-cpp-sdk-core.so not found. Expected in this location: " + AWSCoreSoFile);
                    }

                    // binaries
                    if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "libaws-c-common.so")) == false)
                    {
                        File.Copy(System.IO.Path.Combine(ThirdPartyPath, "libaws-c-common.so"), System.IO.Path.Combine(BinariesDirectory, "libaws-c-common.so"));
                    }
                    if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "libaws-c-event-stream.so")) == false)
                    {
                        File.Copy(System.IO.Path.Combine(ThirdPartyPath, "libaws-c-event-stream.so"), System.IO.Path.Combine(BinariesDirectory, "libaws-c-event-stream.so"));
                    }
                    if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "libaws-checksums.so")) == false)
                    {
                        File.Copy(System.IO.Path.Combine(ThirdPartyPath, "libaws-checksums.so"), System.IO.Path.Combine(BinariesDirectory, "libaws-checksums.so"));
                    }
                    if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "libaws-cpp-sdk-core.so")) == false)
                    {
                        File.Copy(System.IO.Path.Combine(ThirdPartyPath, "libaws-cpp-sdk-core.so"), System.IO.Path.Combine(BinariesDirectory, "libaws-cpp-sdk-core.so"));
                    }
                }
                else if (Target.Platform == UnrealTargetPlatform.Win64)
                {
                    // dependencies
                    string CommonLibFile = System.IO.Path.Combine(ThirdPartyPath, "aws-c-common.lib");
                    if (File.Exists(CommonLibFile))
                    {
                        PublicAdditionalLibraries.Add(CommonLibFile);
                    }
                    else
                    {
                        throw new BuildException("aws-c-common.lib not found. Expected in this location: " + CommonLibFile);
                    }

                    string CommonDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-c-common.dll");
                    if (File.Exists(CommonDLLFile))
                    {
                        PublicDelayLoadDLLs.Add("aws-c-common.dll");
                        RuntimeDependencies.Add(CommonDLLFile);
                    }
                    else
                    {
                        throw new BuildException("aws-c-common.dll not found. Expected in this location: " + CommonDLLFile);
                    }

                    string EventStreamLibFile = System.IO.Path.Combine(ThirdPartyPath, "aws-c-event-stream.lib");
                    if (File.Exists(EventStreamLibFile))
                    {
                        PublicAdditionalLibraries.Add(EventStreamLibFile);
                    }
                    else
                    {
                        throw new BuildException("aws-c-event-stream.lib not found. Expected in this location: " + EventStreamLibFile);
                    }

                    string EventStreamDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-c-event-stream.dll");
                    if (File.Exists(EventStreamDLLFile))
                    {
                        PublicDelayLoadDLLs.Add("aws-c-event-stream.dll");
                        RuntimeDependencies.Add(EventStreamDLLFile);
                    }
                    else
                    {
                        throw new BuildException("aws-c-event-stream.dll not found. Expected in this location: " + EventStreamDLLFile);
                    }

                    string ChecksumsLibFile = System.IO.Path.Combine(ThirdPartyPath, "aws-checksums.lib");
                    if (File.Exists(ChecksumsLibFile))
                    {
                        PublicAdditionalLibraries.Add(ChecksumsLibFile);
                    }
                    else
                    {
                        throw new BuildException("aws-checksums.lib not found. Expected in this location: " + ChecksumsLibFile);
                    }

                    string ChecksumsDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-checksums.dll");
                    if (File.Exists(ChecksumsDLLFile))
                    {
                        PublicDelayLoadDLLs.Add("aws-checksums.dll");
                        RuntimeDependencies.Add(ChecksumsDLLFile);
                    }
                    else
                    {
                        throw new BuildException("aws-checksums.dll not found. Expected in this location: " + ChecksumsDLLFile);
                    }

                    // aws core
                    string AWSCoreLibFile = System.IO.Path.Combine(ThirdPartyPath, "aws-cpp-sdk-core.lib");
                    if (File.Exists(AWSCoreLibFile))
                    {
                        PublicAdditionalLibraries.Add(AWSCoreLibFile);
                    }
                    else
                    {
                        throw new BuildException("aws-cpp-sdk-core.lib not found. Expected in this location: " + AWSCoreLibFile);
                    }

                    string AWSCoreDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-cpp-sdk-core.dll");
                    if (File.Exists(AWSCoreDLLFile))
                    {
                        PublicDelayLoadDLLs.Add("aws-cpp-sdk-core.dll");
                        RuntimeDependencies.Add(AWSCoreDLLFile);
                    }
                    else
                    {
                        throw new BuildException("aws-cpp-sdk-core.dll not found. Expected in this location: " + AWSCoreDLLFile);
                    }

                    // binaries
                    if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "aws-c-common.dll")) == false)
                    {
                        File.Copy(System.IO.Path.Combine(ThirdPartyPath, "aws-c-common.dll"), System.IO.Path.Combine(BinariesDirectory, "aws-c-common.dll"));
                    }
                    if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "aws-c-event-stream.dll")) == false)
                    {
                        File.Copy(System.IO.Path.Combine(ThirdPartyPath, "aws-c-event-stream.dll"), System.IO.Path.Combine(BinariesDirectory, "aws-c-event-stream.dll"));
                    }
                    if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "aws-checksums.dll")) == false)
                    {
                        File.Copy(System.IO.Path.Combine(ThirdPartyPath, "aws-checksums.dll"), System.IO.Path.Combine(BinariesDirectory, "aws-checksums.dll"));
                    }
                    if (File.Exists(System.IO.Path.Combine(BinariesDirectory, "aws-cpp-sdk-core.dll")) == false)
                    {
                        File.Copy(System.IO.Path.Combine(ThirdPartyPath, "aws-cpp-sdk-core.dll"), System.IO.Path.Combine(BinariesDirectory, "aws-cpp-sdk-core.dll"));
                    }
                }
            }
            else
            {
                PublicDefinitions.Add("WITH_AWSCORE=0");
            }
        }
        else
        {
            PublicDefinitions.Add("WITH_AWSCORE=0");
        }
    }
コード例 #19
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[]
            {
                "WebBrowserTexture",
                "Engine",
                "Launch"
            }
                );

            // We need this one on Android for URL decoding
            PrivateDependencyModuleNames.Add("HTTP");
        }

        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;
        }
    }
コード例 #20
0
    public MeshUtilities(ReadOnlyTargetRules Target) : base(Target)
    {
        PublicDependencyModuleNames.AddRange(
            new string[] {
            "MaterialUtilities",
        }
            );

        PrivateDependencyModuleNames.AddRange(
            new string[] {
            "Core",
            "CoreUObject",
            "Engine",
            "RawMesh",
            "RenderCore",                     // For FPackedNormal
            "SlateCore",
            "Slate",
            "MaterialUtilities",
            "MeshBoneReduction",
            "UnrealEd",
            "RHI",
            "HierarchicalLODUtilities",
            "Landscape",
            "LevelEditor",
            "PropertyEditor",
            "EditorStyle",
            "GraphColor",
            "MeshBuilderCommon",
            "MeshUtilitiesCommon",
            "MeshDescription",
            "StaticMeshDescription",
            "ToolMenus",
        }
            );

        PublicIncludePathModuleNames.AddRange(
            new string[] {
            "MeshMergeUtilities"
        }
            );

        PrivateIncludePathModuleNames.AddRange(
            new string[] {
            "AnimationBlueprintEditor",
            "AnimationEditor",
            "MeshMergeUtilities",
            "MaterialBaking",
            "Persona",
            "SkeletalMeshEditor",
        }
            );

        DynamicallyLoadedModuleNames.AddRange(
            new string[] {
            "AnimationBlueprintEditor",
            "AnimationEditor",
            "MeshMergeUtilities",
            "MaterialBaking",
            "SkeletalMeshEditor",
        }
            );

        AddEngineThirdPartyPrivateStaticDependencies(Target, "nvTriStrip");
        AddEngineThirdPartyPrivateStaticDependencies(Target, "ForsythTriOptimizer");
        AddEngineThirdPartyPrivateStaticDependencies(Target, "QuadricMeshReduction");
        AddEngineThirdPartyPrivateStaticDependencies(Target, "MikkTSpace");
        AddEngineThirdPartyPrivateStaticDependencies(Target, "nvTessLib");

        if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
        {
            AddEngineThirdPartyPrivateStaticDependencies(Target, "DX9");
        }

        // Always use the official version of IntelTBB
        string IntelTBBLibs = Target.UEThirdPartySourceDirectory + "Intel/TBB/IntelTBB-2019u8/lib/";

        // EMBREE
        if (Target.Platform == UnrealTargetPlatform.Win64)
        {
            string SDKDir = Target.UEThirdPartySourceDirectory + "Intel/Embree/Embree2140/Win64/";

            PublicIncludePaths.Add(SDKDir + "include");
            PublicAdditionalLibraries.Add(SDKDir + "lib/embree.2.14.0.lib");
            RuntimeDependencies.Add("$(TargetOutputDir)/embree.2.14.0.dll", SDKDir + "lib/embree.2.14.0.dll");
            RuntimeDependencies.Add("$(TargetOutputDir)/tbb.dll", IntelTBBLibs + "Win64/vc14/tbb.dll");
            RuntimeDependencies.Add("$(TargetOutputDir)/tbbmalloc.dll", IntelTBBLibs + "Win64/vc14/tbbmalloc.dll");
            PublicDefinitions.Add("USE_EMBREE=1");
        }
        else if (Target.Platform == UnrealTargetPlatform.Mac)
        {
            string SDKDir = Target.UEThirdPartySourceDirectory + "Intel/Embree/Embree2140/MacOSX/";

            PublicIncludePaths.Add(SDKDir + "include");
            PublicAdditionalLibraries.Add(SDKDir + "lib/libembree.2.14.0.dylib");
            PublicAdditionalLibraries.Add(IntelTBBLibs + "Mac/libtbb.dylib");
            PublicAdditionalLibraries.Add(IntelTBBLibs + "Mac/libtbbmalloc.dylib");
            RuntimeDependencies.Add("$(TargetOutputDir)/libembree.2.14.0.dylib", SDKDir + "lib/libembree.2.14.0.dylib");
            RuntimeDependencies.Add("$(TargetOutputDir)/libtbb.dylib", IntelTBBLibs + "Mac/libtbb.dylib");
            RuntimeDependencies.Add("$(TargetOutputDir)/libtbbmalloc.dylib", IntelTBBLibs + "Mac/libtbbmalloc.dylib");
            PublicDefinitions.Add("USE_EMBREE=1");
        }
        else
        {
            PublicDefinitions.Add("USE_EMBREE=0");
        }
    }
コード例 #21
0
    public GameLiftServerSDK(ReadOnlyTargetRules Target) : base(Target)
    {
        PublicIncludePaths.AddRange(
            new string[] {
            "GameLiftServerSDK/Public"
        }
            );


        PrivateIncludePaths.AddRange(
            new string[] {
            "GameLiftServerSDK/Private",
        }
            );


        PublicDependencyModuleNames.AddRange(
            new string[]
        {
            "Core",
            "Projects"
        }
            );


        PrivateDependencyModuleNames.AddRange(
            new string[]
        {
        }
            );


        DynamicallyLoadedModuleNames.AddRange(
            new string[]
        {
        }
            );

        string BaseDirectory = System.IO.Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", ".."));
        string SDKDirectory  = System.IO.Path.Combine(BaseDirectory, "ThirdParty", "GameLiftServerSDK", Target.Platform.ToString());

        bool bHasGameLiftSDK = System.IO.Directory.Exists(SDKDirectory);

        if (bHasGameLiftSDK)
        {
            if (Target.Type == TargetRules.TargetType.Server)
            {
                Definitions.Add("WITH_GAMELIFT=1");
                if (Target.Platform == UnrealTargetPlatform.Linux)
                {
                    SDKDirectory = System.IO.Path.Combine(SDKDirectory, "x86_64-unknown-linux-gnu");
                    string SDKLib = System.IO.Path.Combine(SDKDirectory, "libaws-cpp-sdk-gamelift-server.so");

                    PublicLibraryPaths.Add(SDKDirectory);
                    PublicAdditionalLibraries.Add(SDKLib);
                    RuntimeDependencies.Add(new RuntimeDependency(SDKLib));
                }
                else if (Target.Platform == UnrealTargetPlatform.Win64)
                {
                    PublicLibraryPaths.Add(SDKDirectory);
                    PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-gamelift-server.lib"));
                    PublicDelayLoadDLLs.Add("aws-cpp-sdk-gamelift-server.dll");
                    string SDKLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-gamelift-server.dll");
                    RuntimeDependencies.Add(new RuntimeDependency(SDKLibWindows));
                }
            }
            else
            {
                Definitions.Add("WITH_GAMELIFT=0");
            }
        }
        else
        {
            Definitions.Add("WITH_GAMELIFT=0");
        }
    }
コード例 #22
0
    public ResonanceAudio(ReadOnlyTargetRules Target) : base(Target)
    {
        string ResonanceAudioPath        = ModuleDirectory + "/Private/ResonanceAudioLibrary";
        string ResonanceAudioLibraryPath = ModuleDirectory + "/Private/ResonanceAudioLibrary/resonance_audio";
        string PFFTPath = ModuleDirectory + "/Private/ResonanceAudioLibrary/third_party/pfft";

        PublicIncludePaths.AddRange(
            new string[] {
        }
            );

        PrivateIncludePaths.AddRange(
            new string[] {
            "ResonanceAudio/Private",
            ResonanceAudioPath,
            ResonanceAudioLibraryPath,
            PFFTPath,
            "../../../../Source/Runtime/AudioMixer/Private"
        }
            );

        PublicDependencyModuleNames.AddRange(
            new string[] {
            "Core",
            "CoreUObject",
            "Engine",
            "AudioMixer",
            "ProceduralMeshComponent",
        }
            );

        PrivateIncludePathModuleNames.AddRange(
            new string[] {
            "TargetPlatform"
        }
            );

        PrivateDependencyModuleNames.AddRange(
            new string[] {
            "Core",
            "CoreUObject",
            "Engine",
            "InputCore",
            "Projects",
            "AudioMixer",
            "ProceduralMeshComponent"
        }
            );

        if (Target.bBuildEditor == true)
        {
            PrivateDependencyModuleNames.Add("UnrealEd");
            PrivateDependencyModuleNames.Add("Landscape");
        }

        ShadowVariableWarningLevel = WarningLevel.Off;

        AddEngineThirdPartyPrivateStaticDependencies(Target,
                                                     "UEOgg",
                                                     "Vorbis",
                                                     "VorbisFile",
                                                     "Eigen"
                                                     );

        if (bSupportsProceduralMesh)
        {
            PrivateDependencyModuleNames.Add("ProceduralMeshComponent");
            PrivateDefinitions.Add("SUPPORTS_PROCEDURAL_MESH=1");
        }
        else
        {
            PrivateDefinitions.Add("SUPPORTS_PROCEDURAL_MESH=0");
        }

        if (Target.Platform == UnrealTargetPlatform.Android)
        {
            PrivateDefinitions.Add("PFFFT_SIMD_DISABLE=1");
            PrivateDefinitions.Add("EIGEN_HAS_CXX11_MATH=0");
        }

        //Embree support:
        if (Target.Platform == UnrealTargetPlatform.Win64)
        {
            string SDKDir = Target.UEThirdPartySourceDirectory + "IntelEmbree/Embree2140/Win64/";

            PublicIncludePaths.Add(SDKDir + "include");
            PublicAdditionalLibraries.Add(SDKDir + "lib/embree.2.14.0.lib");
            RuntimeDependencies.Add("$(TargetOutputDir)/embree.2.14.0.dll", SDKDir + "lib/embree.2.14.0.dll");
            RuntimeDependencies.Add("$(TargetOutputDir)/tbb.dll", SDKDir + "lib/tbb.dll");
            RuntimeDependencies.Add("$(TargetOutputDir)/tbbmalloc.dll", SDKDir + "lib/tbbmalloc.dll");
            PublicDefinitions.Add("USE_EMBREE=1");
        }
        else if (Target.Platform == UnrealTargetPlatform.Mac)
        {
            string SDKDir = Target.UEThirdPartySourceDirectory + "IntelEmbree/Embree2140/MacOSX/";

            PublicIncludePaths.Add(SDKDir + "include");

            PrivateDefinitions.Add("USE_EMBREE=1");
        }
        else
        {
            // In platforms that don't support Embree, we implement no-op versions of the functions.
            string SDKDir = Target.UEThirdPartySourceDirectory + "IntelEmbree/Embree2140/";
            PublicIncludePaths.Add(SDKDir + "include");
            PublicDefinitions.Add("USE_EMBREE=0");
            PrivateDefinitions.Add("EMBREE_STATIC_LIB=1");
        }
    }
コード例 #23
0
        public GoogleARCoreBase(ReadOnlyTargetRules Target) : base(Target)
        {
            PrivateIncludePaths.AddRange(
                new string[]
            {
                "GoogleARCoreBase/Private",
            }
                );

            PublicIncludePathModuleNames.Add("TargetPlatform");

            PublicDependencyModuleNames.AddRange(
                new string[]
            {
                "HeadMountedDisplay",
                "AugmentedReality",
            }
                );

            PrivateDependencyModuleNames.AddRange(
                new string[]
            {
                "Core",
                "CoreUObject",
                "Engine",
                "EngineSettings",
                "Slate",
                "SlateCore",
                "RHI",
                "RenderCore",
                "AndroidPermission",
                "GoogleARCoreRendering",
                "GoogleARCoreSDK",
                "OpenGL",
                "ProceduralMeshComponent",
                "UElibPNG",
                "zlib"
            }
                );

            PrivateIncludePathModuleNames.AddRange(
                new string[]
            {
                "Settings"                         // For editor settings panel.
            }
                );

            if (Target.Platform == UnrealTargetPlatform.Android)
            {
                // Additional dependencies on android...
                PrivateDependencyModuleNames.Add("Launch");

                // Register Plugin Language
                AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(ModuleDirectory, "GoogleARCoreBase_APL.xml"));
            }

            if (Target.bBuildEditor)
            {
                string ExecName = "";
                if (Target.Platform == UnrealTargetPlatform.Win64)
                {
                    ExecName = "Windows/arcoreimg.exe";
                }
                else if (Target.Platform == UnrealTargetPlatform.Linux)
                {
                    ExecName = "Linux/arcoreimg";
                }
                else if (Target.Platform == UnrealTargetPlatform.Mac)
                {
                    ExecName = "Mac/ptdbtool_macos_lipobin";
                }

                if (ExecName.Length > 0)
                {
                    RuntimeDependencies.Add("$(EngineDir)/Plugins/Runtime/AR/Google/GoogleARCore/Binaries/ThirdParty/Google/ARCoreImg/" + ExecName);
                }
            }

            bFasterWithoutUnity = false;
        }
コード例 #24
0
    public UnrealLightmass(ReadOnlyTargetRules Target) : base(Target)
    {
        PublicIncludePaths.Add("Runtime/Launch/Public");

        PrivateDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "zlib", "SwarmInterface", "Projects", "ApplicationCore" });

        PublicDefinitions.Add("UE_LIGHTMASS=1");

        if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
        {
            AddEngineThirdPartyPrivateStaticDependencies(Target, "DX9");

            // Unreallightmass requires GetProcessMemoryInfo exported by psapi.dll. http://msdn.microsoft.com/en-us/library/windows/desktop/ms683219(v=vs.85).aspx
            PublicSystemLibraries.Add("psapi.lib");
            PrivateDependencyModuleNames.AddRange(
                new string[] {
                "Messaging",
            }
                );
        }
        else if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux)
        {
            // On Mac/Linux UnrealLightmass is executed locally and communicates with the editor using Messaging module instead of SwarmAgent
            // @todo: allow for better plug-in support in standalone Slate apps
            PrivateDependencyModuleNames.AddRange(
                new string[] {
                "Networking",
                "Sockets",
                "Messaging",
                "UdpMessaging",
            }
                );

            PrivateIncludePathModuleNames.AddRange(
                new string[] {
                "Messaging",
            }
                );
        }

        // Lightmass ray tracing is 8% faster with buffer security checks disabled due to fixed size arrays on the stack in the kDOP ray tracing functions
        // Warning: This means buffer overwrites will not be detected
        bEnableBufferSecurityChecks = false;

        PrivateIncludePaths.Add("Runtime/Launch/Private");                      // For LaunchEngineLoop.cpp include
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/Launch");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/ImportExport");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/CPUSolver");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/Lighting");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/LightmassCore");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/LightmassCore/Misc");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/LightmassCore/Math");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/LightmassCore/Templates");

        // Always use the official version of IntelTBB
        string IntelTBBLibs = Target.UEThirdPartySourceDirectory + "IntelTBB/IntelTBB-2019u8/lib/";

        // EMBREE
        if (Target.Platform == UnrealTargetPlatform.Win64)
        {
            string SDKDir = Target.UEThirdPartySourceDirectory + "IntelEmbree/Embree270/Win64/";

            PublicIncludePaths.Add(SDKDir + "include");
            PublicAdditionalLibraries.Add(SDKDir + "lib/embree.lib");
            RuntimeDependencies.Add("$(EngineDir)/Binaries/Win64/embree.dll");
            RuntimeDependencies.Add("$(EngineDir)/Binaries/Win64/tbb.dll", IntelTBBLibs + "Win64/vc14/tbb.dll");
            RuntimeDependencies.Add("$(EngineDir)/Binaries/Win64/tbbmalloc.dll", IntelTBBLibs + "Win64/vc14/tbbmalloc.dll");
            PublicDefinitions.Add("USE_EMBREE=1");
        }
        else if (Target.Platform == UnrealTargetPlatform.Mac)
        {
            string SDKDir = Target.UEThirdPartySourceDirectory + "IntelEmbree/Embree270/MacOSX/";

            PublicIncludePaths.Add(SDKDir + "include");
            PublicAdditionalLibraries.Add(SDKDir + "lib/libembree.2.dylib");
            RuntimeDependencies.Add("$(EngineDir)/Binaries/Mac/libembree.2.dylib");
            RuntimeDependencies.Add("$(EngineDir)/Binaries/Mac/libtbb.dylib", IntelTBBLibs + "Mac/libtbb.dylib");             // Take latest version to avoid overwriting the editor's copy
            RuntimeDependencies.Add("$(EngineDir)/Binaries/Mac/libtbbmalloc.dylib", IntelTBBLibs + "Mac/libtbbmalloc.dylib");
            PublicDefinitions.Add("USE_EMBREE=1");
        }
        else
        {
            PublicDefinitions.Add("USE_EMBREE=0");
        }
    }
コード例 #25
0
ファイル: FBX.Build.cs プロジェクト: nikimar1/cloneofg4g2019
    public FBX(ReadOnlyTargetRules Target) : base(Target)
    {
        Type = ModuleType.External;

        string FBXSDKDir = Target.UEThirdPartySourceDirectory + "FBX/2018.1.1/";

        PublicSystemIncludePaths.AddRange(
            new string[] {
            FBXSDKDir + "include",
            FBXSDKDir + "include/fbxsdk",
        }
            );


        if (Target.Platform == UnrealTargetPlatform.Win64)
        {
            string FBxLibPath = FBXSDKDir + "lib/vs" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName() + "/";

            FBxLibPath += "x64/release/";
            PublicLibraryPaths.Add(FBxLibPath);

            if (Target.LinkType != TargetLinkType.Monolithic)
            {
                PublicAdditionalLibraries.Add("libfbxsdk.lib");

                // We are using DLL versions of the FBX libraries
                PublicDefinitions.Add("FBXSDK_SHARED");

                RuntimeDependencies.Add("$(TargetOutputDir)/libfbxsdk.dll", FBxLibPath + "libfbxsdk.dll");
            }
            else
            {
                if (Target.bUseStaticCRT)
                {
                    PublicAdditionalLibraries.Add("libfbxsdk-mt.lib");
                }
                else
                {
                    PublicAdditionalLibraries.Add("libfbxsdk-md.lib");
                }
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.Mac)
        {
            string FBxLibPath = FBXSDKDir + "lib/clang/release/";
            PublicAdditionalLibraries.Add(FBxLibPath + "libfbxsdk.dylib");
            RuntimeDependencies.Add("$(TargetOutputDir)/libfbxsdk.dylib", FBxLibPath + "libfbxsdk.dylib");
        }
        else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
        {
            string LibDir = FBXSDKDir + "lib/gcc4/" + Target.Architecture + "/release/";
            if (!Target.bIsEngineInstalled && !Directory.Exists(LibDir))
            {
                string Err = string.Format("FBX SDK not found in {0}", LibDir);
                System.Console.WriteLine(Err);
                throw new BuildException(Err);
            }

            PublicAdditionalLibraries.Add(LibDir + "/libfbxsdk.a");

            /* There is a bug in fbxarch.h where is doesn't do the check
             * for clang under linux */
            PublicDefinitions.Add("FBXSDK_COMPILER_CLANG");

            // libfbxsdk has been built against libstdc++ and as such needs this library
            PublicAdditionalLibraries.Add("stdc++");
        }
    }
コード例 #26
0
    public Slate(ReadOnlyTargetRules Target) : base(Target)
    {
        PrivateDefinitions.Add("SLATE_MODULE=1");
        SharedPCHHeaderFile = "Public/SlateSharedPCH.h";

        PublicDependencyModuleNames.AddRange(
            new string[] {
            "Core",
            "CoreUObject",
            "ApplicationCore",
            "InputCore",
            "Json",
            "SlateCore",
            "ImageWrapper"
        });

        PrivateIncludePaths.AddRange(
            new string[] {
            "Runtime/Slate/Private",
            "Runtime/Slate/Private/Framework",
            "Runtime/Slate/Private/Framework/Application",
            "Runtime/Slate/Private/Framework/Commands",
            "Runtime/Slate/Private/Framework/Docking",
            "Runtime/Slate/Private/Framework/Layout",
            "Runtime/Slate/Private/Framework/MultiBox",
            "Runtime/Slate/Private/Framework/Notifications",
            "Runtime/Slate/Private/Framework/Styling",
            "Runtime/Slate/Private/Framework/Text",
            "Runtime/Slate/Private/Framework/Text/IOS",
            "Runtime/Slate/Private/Widgets/Colors",
            "Runtime/Slate/Private/Widgets/Docking",
            "Runtime/Slate/Private/Widgets/Images",
            "Runtime/Slate/Private/Widgets/Input",
            "Runtime/Slate/Private/Widgets/Layout",
            "Runtime/Slate/Private/Widgets/Notifications",
            "Runtime/Slate/Private/Widgets/Text",
            "Runtime/Slate/Private/Widgets/Views",

            "Runtime/Toolbox/Public/"
        });

        if ((Target.Platform == UnrealTargetPlatform.Win64) ||
            (Target.Platform == UnrealTargetPlatform.Win32))
        {
            AddEngineThirdPartyPrivateStaticDependencies(Target, "XInput");
        }
        else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Linux))
        {
            AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
        }

        // Add slate runtime dependencies
        if (Target.bUsesSlate)
        {
            RuntimeDependencies.Add("$(EngineDir)/Content/Slate/...", StagedFileType.UFS);
            RuntimeDependencies.Add("$(EngineDir)/Content/SlateDebug/...", StagedFileType.DebugNonUFS);

            if (Target.ProjectFile != null)
            {
                RuntimeDependencies.Add("$(ProjectDir)/Content/Slate/...", StagedFileType.UFS);
                RuntimeDependencies.Add("$(ProjectDir)/Content/SlateDebug/...", StagedFileType.DebugNonUFS);
            }
        }

        if (Target.bBuildDeveloperTools)
        {
            DynamicallyLoadedModuleNames.Add("Settings");
        }
    }
    public GameLiftClientSDK(ReadOnlyTargetRules Target) : base(Target)
    {
        PublicIncludePaths.Add(System.IO.Path.Combine(ModuleDirectory, "Public"));

        PublicDependencyModuleNames.AddRange(
            new string[]
        {
            "Core",
            "Projects"
        }
            );


        PrivateDependencyModuleNames.AddRange(
            new string[]
        {
        }
            );


        DynamicallyLoadedModuleNames.AddRange(
            new string[]
        {
        }
            );

        // This is required to fix a warning for Unreal Engine 4.21 and later
        PrivatePCHHeaderFile = "Private/GameLiftClientSDKPrivatePCH.h";

        bEnableExceptions = true;

        string BaseDirectory = System.IO.Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", ".."));
        string SDKDirectory  = System.IO.Path.Combine(BaseDirectory, "ThirdParty", "GameLiftClientSDK", Target.Platform.ToString());

        bool bHasGameLiftSDK = System.IO.Directory.Exists(SDKDirectory);

        if (bHasGameLiftSDK)
        {
            if (Target.Type == TargetRules.TargetType.Server)
            {
                if (Target.Platform == UnrealTargetPlatform.Linux)
                {
                    /*SDKDirectory = System.IO.Path.Combine(SDKDirectory, "x86_64-unknown-linux-gnu");
                     * string SDKLib = System.IO.Path.Combine(SDKDirectory, "libaws-cpp-sdk-gamelift-server.so");
                     *
                     * //PublicAdditionalLibraries.Add(SDKDirectory);
                     * PublicAdditionalLibraries.Add(SDKLib);
                     * RuntimeDependencies.Add(SDKLib);*/
                }
                else if (Target.Platform == UnrealTargetPlatform.Win64)
                {
                    //PublicAdditionalLibraries.Add(SDKDirectory);
                    PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-c-common.lib"));
                    PublicDelayLoadDLLs.Add("aws-c-common.dll");
                    string CommonLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-c-common.dll");
                    RuntimeDependencies.Add(CommonLibWindows);

                    PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-c-event-stream.lib"));
                    PublicDelayLoadDLLs.Add("aws-c-event-stream.dll");
                    string EventStreamLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-c-event-stream.dll");
                    RuntimeDependencies.Add(EventStreamLibWindows);

                    PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-checksums.lib"));
                    PublicDelayLoadDLLs.Add("aws-checksums.dll");
                    string ChecksumsLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-checksums.dll");
                    RuntimeDependencies.Add(ChecksumsLibWindows);

                    PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-cognito-identity.lib"));
                    PublicDelayLoadDLLs.Add("aws-cpp-sdk-cognito-identity.dll");
                    string CognitoIdentityLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-cognito-identity.dll");
                    RuntimeDependencies.Add(CognitoIdentityLibWindows);

                    PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-cognito-idp.lib"));
                    PublicDelayLoadDLLs.Add("aws-cpp-sdk-cognito-idp.dll");
                    string CognitoIdpLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-cognito-idp.dll");
                    RuntimeDependencies.Add(CognitoIdpLibWindows);

                    PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-core.lib"));
                    PublicDelayLoadDLLs.Add("aws-cpp-sdk-core.dll");
                    string CoreLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-core.dll");
                    RuntimeDependencies.Add(CoreLibWindows);

                    PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-iam.lib"));
                    PublicDelayLoadDLLs.Add("aws-cpp-sdk-iam.dll");
                    string IamLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-iam.dll");
                    RuntimeDependencies.Add(IamLibWindows);

                    PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-kinesis.lib"));
                    PublicDelayLoadDLLs.Add("aws-cpp-sdk-kinesis.dll");
                    string KinesisLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-kinesis.dll");
                    RuntimeDependencies.Add(KinesisLibWindows);

                    PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-lambda.lib"));
                    PublicDelayLoadDLLs.Add("aws-cpp-sdk-lambda.dll");
                    string LambdaLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-lambda.dll");
                    RuntimeDependencies.Add(LambdaLibWindows);
                }
            }
        }
    }
コード例 #28
0
    public Steamworks(ReadOnlyTargetRules Target) : base(Target)
    {
        /** Mark the current version of the Steam SDK */
        string SteamVersion = "v139";

        Type = ModuleType.External;

        PublicDefinitions.Add("STEAM_SDK_VER=TEXT(\"1.39\")");
        PublicDefinitions.Add("STEAM_SDK_VER_PATH=TEXT(\"Steam" + SteamVersion + "\")");

        string SdkBase = Target.UEThirdPartySourceDirectory + "Steamworks/Steam" + SteamVersion + "/sdk";

        if (!Directory.Exists(SdkBase))
        {
            string Err = string.Format("steamworks SDK not found in {0}", SdkBase);
            System.Console.WriteLine(Err);
            throw new BuildException(Err);
        }

        PublicIncludePaths.Add(SdkBase + "/public");

        string LibraryPath = SdkBase + "/redistributable_bin/";
        string LibraryName = "steam_api";

        if (Target.Platform == UnrealTargetPlatform.Win32)
        {
            PublicLibraryPaths.Add(LibraryPath);
            PublicAdditionalLibraries.Add(LibraryName + ".lib");
            PublicDelayLoadDLLs.Add(LibraryName + ".dll");

            string SteamBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/Steamworks/Steam{0}/Win32/", SteamVersion);
            RuntimeDependencies.Add(SteamBinariesDir + "steam_api.dll");

            if (Target.Type == TargetType.Server)
            {
                RuntimeDependencies.Add(SteamBinariesDir + "steamclient.dll");
                RuntimeDependencies.Add(SteamBinariesDir + "tier0_s.dll");
                RuntimeDependencies.Add(SteamBinariesDir + "vstdlib_s.dll");
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.Win64)
        {
            PublicLibraryPaths.Add(LibraryPath + "win64");
            PublicAdditionalLibraries.Add(LibraryName + "64.lib");
            PublicDelayLoadDLLs.Add(LibraryName + "64.dll");

            string SteamBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/Steamworks/Steam{0}/Win64/", SteamVersion);
            RuntimeDependencies.Add(SteamBinariesDir + LibraryName + "64.dll");

            if (Target.Type == TargetType.Server)
            {
                RuntimeDependencies.Add(SteamBinariesDir + "steamclient64.dll");
                RuntimeDependencies.Add(SteamBinariesDir + "tier0_s64.dll");
                RuntimeDependencies.Add(SteamBinariesDir + "vstdlib_s64.dll");
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.Mac)
        {
            string SteamBinariesPath = String.Format(Target.UEThirdPartyBinariesDirectory + "Steamworks/Steam{0}/Mac/", SteamVersion);
            LibraryPath = SteamBinariesPath + "libsteam_api.dylib";
            PublicDelayLoadDLLs.Add(LibraryPath);
            RuntimeDependencies.Add(LibraryPath);
        }
        else if (Target.Platform == UnrealTargetPlatform.Linux)
        {
            if (Target.LinkType == TargetLinkType.Monolithic)
            {
                LibraryPath += "linux64";
                PublicLibraryPaths.Add(LibraryPath);
                PublicAdditionalLibraries.Add(LibraryName);
            }
            else
            {
                LibraryPath += "linux64/libsteam_api.so";
                PublicDelayLoadDLLs.Add(LibraryPath);
            }
            string SteamBinariesPath = String.Format(Target.UEThirdPartyBinariesDirectory + "Steamworks/Steam{0}/{1}", SteamVersion, Target.Architecture);
            PrivateRuntimeLibraryPaths.Add(SteamBinariesPath);
            PublicAdditionalLibraries.Add(SteamBinariesPath + "/libsteam_api.so");
            RuntimeDependencies.Add(SteamBinariesPath + "/libsteam_api.so");
        }
    }
コード例 #29
0
    public AlembicLib(ReadOnlyTargetRules Target) : base(Target)
    {
        Type = ModuleType.External;
        if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 ||
            Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux)
        {
            bool bDebug = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT);

            string LibDir = ModuleDirectory + "/AlembicDeploy/";
            string Platform;
            bool   bAllowDynamicLibs = true;
            switch (Target.Platform)
            {
            case UnrealTargetPlatform.Win64:
                Platform = "x64";
                LibDir  += "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName() + "/";
                break;

            case UnrealTargetPlatform.Mac:
                Platform          = "Mac";
                bAllowDynamicLibs = false;
                break;

            case UnrealTargetPlatform.Linux:
                Platform          = "Linux";
                bAllowDynamicLibs = false;
                break;

            default:
                return;
            }
            LibDir = LibDir + "/" + Platform + "/lib/";
            PublicLibraryPaths.Add(LibDir);

            string LibPostFix   = bDebug && bAllowDynamicLibs ? "d" : "";
            string LibExtension = (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux) ? ".a" : ".lib";

            if (Target.Platform == UnrealTargetPlatform.Win64)
            {
                PublicDefinitions.Add("H5_BUILT_AS_DYNAMIC_LIB");
                PublicDefinitions.Add("OPENEXR_DLL");

                List <string> ReqLibraryNames = new List <string>();
                ReqLibraryNames.AddRange
                (
                    new string[] {
                    "Half",
                    "Iex",
                    "IlmThread",
                    "Imath",
                    "IexMath",
                    (bDebug && bAllowDynamicLibs) ? "hdf5_" : "hdf5",
                    "Alembic"
                });
                foreach (string LibraryName in ReqLibraryNames)
                {
                    PublicAdditionalLibraries.Add(LibraryName + LibPostFix + LibExtension);
                }

                if (Target.bDebugBuildsActuallyUseDebugCRT && bDebug)
                {
                    RuntimeDependencies.Add("$(EngineDir)/Plugins/Experimental/AlembicImporter/Binaries/Win64/zlibd1.dll");
                    RuntimeDependencies.Add("$(EngineDir)/Plugins/Experimental/AlembicImporter/Binaries/Win64/hdf5_D.dll");
                }
                else
                {
                    RuntimeDependencies.Add("$(EngineDir)/Plugins/Experimental/AlembicImporter/Binaries/Win64/hdf5.dll");
                }
            }
            else if (Target.Platform == UnrealTargetPlatform.Mac)
            {
                List <string> ReqLibraryNames = new List <string>();
                ReqLibraryNames.AddRange
                (
                    new string[] {
                    "libHalf",
                    "libIex",
                    "libIlmThread",
                    "libImath",
                    (bDebug && bAllowDynamicLibs) ? "hdf5_" : "hdf5",
                    "libAlembic"
                });

                foreach (string LibraryName in ReqLibraryNames)
                {
                    PublicAdditionalLibraries.Add(LibDir + LibraryName + LibPostFix + LibExtension);
                }
            }
            else if (Target.Platform == UnrealTargetPlatform.Linux)
            {
                List <string> ReqLibraryNames = new List <string>();
                ReqLibraryNames.AddRange
                (
                    new string[] {
                    "libHalf",
                    "libIex",
                    "libIlmThread",
                    "libImath",
                    "hdf5",
                    "libAlembic"
                });

                foreach (string LibraryName in ReqLibraryNames)
                {
                    PublicAdditionalLibraries.Add(LibDir + Target.Architecture + "/" + LibraryName + LibExtension);
                }
            }

            PublicIncludePaths.Add(ModuleDirectory + "/AlembicDeploy/include/");
            PublicIncludePaths.Add(ModuleDirectory + "/AlembicDeploy/include/OpenEXR/");
        }
    }
コード例 #30
0
    public HoloLensAR(ReadOnlyTargetRules Target) : base(Target)
    {
        PublicDependencyModuleNames.AddRange(
            new string[]
        {
            "Core",
            "Engine",
            "MixedRealityInteropLibrary",
            "MRMesh"
            // ... add other public dependencies that you statically link with here ...
        }
            );

        PrivateDependencyModuleNames.AddRange(
            new string[]
        {
            "CoreUObject",
            "ApplicationCore",
            "HeadMountedDisplay",
            "AugmentedReality",
            "RenderCore",
            "RHI",
            "Projects",
            // ... add private dependencies that you statically link with here ...
        }
            );

        if (Target.bBuildEditor == true)
        {
            PrivateDependencyModuleNames.Add("UnrealEd");
        }
        if (Target.Platform == UnrealTargetPlatform.Win64)
        {
            RuntimeDependencies.Add(System.IO.Path.Combine("$(EngineDir)/Binaries/ThirdParty/Windows/x64", "Microsoft.MixedReality.QR.dll"));
            RuntimeDependencies.Add(System.IO.Path.Combine("$(EngineDir)/Binaries/ThirdParty/Windows/x64", "Microsoft.MixedReality.QR.winmd"));
            RuntimeDependencies.Add(System.IO.Path.Combine("$(EngineDir)/Binaries/ThirdParty/Windows/x64", "Microsoft.MixedReality.SceneUnderstanding.dll"));
            RuntimeDependencies.Add(System.IO.Path.Combine("$(EngineDir)/Binaries/ThirdParty/Windows/x64", "Microsoft.MixedReality.SceneUnderstanding.winmd"));
            PublicDefinitions.Add("WITH_SCENE_UNDERSTANDING=1");
            foreach (var Dll in Directory.EnumerateFiles(Path.Combine(Target.UEThirdPartyBinariesDirectory, "Windows/x64"), "*_app.dll"))
            {
                RuntimeDependencies.Add(Dll);
            }
        }
        else if (Target.Platform == UnrealTargetPlatform.HoloLens)
        {
            RuntimeDependencies.Add(System.IO.Path.Combine("$(EngineDir)/Binaries/ThirdParty/HoloLens", Target.WindowsPlatform.GetArchitectureSubpath(), "Microsoft.MixedReality.QR.dll"));
            RuntimeDependencies.Add(System.IO.Path.Combine("$(EngineDir)/Binaries/ThirdParty/HoloLens", Target.WindowsPlatform.GetArchitectureSubpath(), "Microsoft.MixedReality.QR.winmd"));

            // Add a dependency to SceneUnderstanding.dll if present
            string SceneUnderstandingDllPath   = System.IO.Path.Combine(Target.UEThirdPartyBinariesDirectory, "HoloLens", Target.WindowsPlatform.GetArchitectureSubpath(), "Microsoft.MixedReality.SceneUnderstanding.dll");
            string SceneUnderstandingWinMDPath = System.IO.Path.Combine(Target.UEThirdPartyBinariesDirectory, "HoloLens", Target.WindowsPlatform.GetArchitectureSubpath(), "Microsoft.MixedReality.SceneUnderstanding.winmd");
            if (System.IO.File.Exists(SceneUnderstandingDllPath) && System.IO.File.Exists(SceneUnderstandingWinMDPath))
            {
                RuntimeDependencies.Add(SceneUnderstandingDllPath);
                RuntimeDependencies.Add(SceneUnderstandingWinMDPath);
                PublicDefinitions.Add("WITH_SCENE_UNDERSTANDING=1");
            }
            else
            {
                PublicDefinitions.Add("WITH_SCENE_UNDERSTANDING=0");
            }
        }

        AddEngineThirdPartyPrivateStaticDependencies(Target, "WindowsMixedRealityInterop");

        PublicDefinitions.Add("WITH_WINDOWS_MIXED_REALITY=1");
    }