public UT_Framework(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; PublicIncludePaths.AddRange( new string[] { ModuleDirectory + "/Public", ModuleDirectory + "/Public/Blueprint", ModuleDirectory + "/Public/Blueprint/StateMachine", ModuleDirectory + "/Public/Component", ModuleDirectory + "/Public/Component/LookAt", ModuleDirectory + "/Public/Component/Pool", ModuleDirectory + "/Public/Component/StateMachine", ModuleDirectory + "/Public/Library", ModuleDirectory + "/Public/Manager", ModuleDirectory + "/Public/Manager/Pool", ModuleDirectory + "/Public/Object", ModuleDirectory + "/Public/Object/LoadSystem", ModuleDirectory + "/Public/Object/Pool", ModuleDirectory + "/Public/Object/StateMachine", ModuleDirectory + "/Public/Object/StateMachine/State", ModuleDirectory + "/Public/Object/StateMachine/Transition", ModuleDirectory + "/Public/Sequencer", ModuleDirectory + "/Public/Sequencer/Evaluation", ModuleDirectory + "/Public/Sequencer/Section", ModuleDirectory + "/Public/Sequencer/Track", ModuleDirectory + "/Public/Utility", ModuleDirectory + "/Public/Widget", ModuleDirectory + "/Public/Widget/Component", ModuleDirectory + "/Public/Widget/Navigation", }); PublicDependencyModuleNames.AddRange( new string[] { "Core", // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "InputCore", "Engine", "Slate", "SlateCore", "UMG", "AIModule", "Paper2D", "MovieScene", "MovieSceneTracks", "GameplayTasks", // ... add private dependencies that you statically link with here ... } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); }
public WmfMedia(ReadOnlyTargetRules Target) : base(Target) { bEnableExceptions = true; DynamicallyLoadedModuleNames.AddRange( new string[] { "Media", }); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "MediaUtils", "Projects", "RenderCore", "RHI", "UtilityShaders", "WmfMediaFactory", }); if (Target.Platform == UnrealTargetPlatform.Win64) { PrivateDependencyModuleNames.AddRange( new string[] { "HAPLib", "SnappyLib", }); PrivateDefinitions.Add("HAP_SUPPORTED=1"); } else { PrivateDefinitions.Add("HAP_SUPPORTED=0"); } if (Target.Platform != UnrealTargetPlatform.XboxOne) { PrivateDependencyModuleNames.Add("D3D11RHI"); } PrivateIncludePathModuleNames.AddRange( new string[] { "Media", }); PrivateIncludePaths.AddRange( new string[] { "WmfMedia/Private", "WmfMedia/Private/Player", "WmfMedia/Private/Wmf", "WmfMedia/Private/HAPDecoder", "../../../../Source/Runtime/Windows/D3D11RHI/Private", "../../../../Source/Runtime/Windows/D3D11RHI/Private/Windows", }); AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelMetricsDiscovery"); AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAftermath"); if (Target.bCompileAgainstEngine) { PrivateDependencyModuleNames.Add("Engine"); PrivateDependencyModuleNames.Add("HeadMountedDisplay"); } if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { PublicDelayLoadDLLs.Add("mf.dll"); PublicDelayLoadDLLs.Add("mfplat.dll"); PublicDelayLoadDLLs.Add("mfplay.dll"); PublicDelayLoadDLLs.Add("shlwapi.dll"); PublicAdditionalLibraries.Add("d3dcompiler.lib"); } }
public ShooterGame(ReadOnlyTargetRules Target) : base(Target) { PrivatePCHHeaderFile = "Public/ShooterGame.h"; PrivateIncludePaths.AddRange( new string[] { "ShooterGame/Private", "ShooterGame/Private/UI", "ShooterGame/Private/UI/Menu", "ShooterGame/Private/UI/Style", "ShooterGame/Private/UI/Widgets", } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "OnlineSubsystem", "OnlineSubsystemUtils", "AssetRegistry", "NavigationSystem", "AIModule", "GameplayTasks", "Gauntlet", } ); PrivateDependencyModuleNames.AddRange( new string[] { "InputCore", "Slate", "SlateCore", "ShooterGameLoadingScreen", "Json", "ApplicationCore", "ReplicationGraph", "PakFile", "Http", "FunapiDedicatedServer" } ); if (Target.Type != TargetRules.TargetType.Server && Target.Platform != UnrealTargetPlatform.Linux) { PrivateDependencyModuleNames.Add("Funapi"); } else { PublicDefinitions.Add("WITH_FUNAPI=0"); } DynamicallyLoadedModuleNames.AddRange( new string[] { "OnlineSubsystemNull", "NetworkReplayStreaming", "NullNetworkReplayStreaming", "HttpNetworkReplayStreaming", "LocalFileNetworkReplayStreaming" } ); PrivateIncludePathModuleNames.AddRange( new string[] { "NetworkReplayStreaming" } ); if (Target.bBuildDeveloperTools || (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test)) { PrivateDependencyModuleNames.Add("GameplayDebugger"); PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=1"); } else { PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=0"); } }
public DetailCustomizations(ReadOnlyTargetRules Target) : base(Target) { PrivateIncludePaths.Add("Editor/DetailCustomizations/Private"); // For PCH includes (because they don't work with relative paths, yet) PrivateDependencyModuleNames.AddRange( new string[] { "AppFramework", "Core", "CoreUObject", "DesktopWidgets", "Engine", "Landscape", "InputCore", "Slate", "SlateCore", "EditorStyle", "UnrealEd", "EditorWidgets", "KismetWidgets", "MovieSceneCapture", "MovieSceneTools", "MovieSceneTracks", "MovieScene", "SharedSettingsWidgets", "ContentBrowser", "BlueprintGraph", "AnimGraph", "PropertyEditor", "LevelEditor", "DesktopPlatform", "ClassViewer", "TargetPlatform", "ExternalImagePicker", "MoviePlayer", "SourceControl", "InternationalizationSettings", "SourceCodeAccess", "RHI", "HardwareTargeting", "SharedSettingsWidgets", "AIModule", "MeshUtilities", "ConfigEditor", "Persona", "CinematicCamera", "ComponentVisualizers", "SkeletonEditor", "LevelSequence", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "Engine", "Media", "Landscape", "LandscapeEditor", "PropertyEditor", "GameProjectGeneration", "ComponentVisualizers", "GraphEditor" } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "Layers", "GameProjectGeneration", } ); }
public AIModule(ReadOnlyTargetRules Target) : base(Target) { PublicIncludePaths.AddRange( new string[] { "Runtime/NavigationSystem/Public", "Runtime/AIModule/Public", } ); PrivateIncludePaths.AddRange( new string[] { "Runtime/AIModule/Private", "Runtime/Engine/Private", } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "GameplayTags", "GameplayTasks", "NavigationSystem", } ); PrivateDependencyModuleNames.AddRange( new string[] { "RHI", "RenderCore", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); if (Target.bBuildEditor == true) { PrivateDependencyModuleNames.Add("UnrealEd"); PrivateDependencyModuleNames.Add("AITestSuite"); CircularlyReferencedDependentModules.Add("AITestSuite"); } if (Target.bCompileRecast) { PrivateDependencyModuleNames.Add("Navmesh"); PublicDefinitions.Add("WITH_RECAST=1"); } else { // Because we test WITH_RECAST in public Engine header files, we need to make sure that modules // that import us also have this definition set appropriately. Recast is a private dependency // module, so it's definitions won't propagate to modules that import Engine. PublicDefinitions.Add("WITH_RECAST=0"); } if (Target.bBuildDeveloperTools || (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test)) { PrivateDependencyModuleNames.Add("GameplayDebugger"); PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=1"); } else { PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=0"); } }
public HoudiniEngineRuntime(ReadOnlyTargetRules Target) : base(Target) { bPrecompile = true; PCHUsage = PCHUsageMode.UseSharedPCHs; // Check if we are compiling for unsupported platforms. if (Target.Platform != UnrealTargetPlatform.Win64 && Target.Platform != UnrealTargetPlatform.Mac && Target.Platform != UnrealTargetPlatform.Linux && Target.Platform != UnrealTargetPlatform.Switch) { System.Console.WriteLine(string.Format("Houdini Engine: Compiling for untested target platform. Please let us know how it goes!")); } // Find HFS string HFSPath = GetHFSPath(); HFSPath = HFSPath.Replace("\\", "/"); if (HFSPath != "") { string Log = string.Format("Houdini Engine: Found Houdini in {0}", HFSPath); System.Console.WriteLine(Log); PlatformID buildPlatformId = Environment.OSVersion.Platform; if (buildPlatformId == PlatformID.Win32NT) { PublicDefinitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath); } } // Find the HAPI include directory string HAPIIncludePath = HFSPath + "/toolkit/include/HAPI"; if (!Directory.Exists(HAPIIncludePath)) { // Add the custom include path as well in case the toolkit path doesn't exist yet. HAPIIncludePath = HFSPath + "/custom/houdini/include/HAPI"; if (!Directory.Exists(HAPIIncludePath)) { System.Console.WriteLine(string.Format("Couldn't find the HAPI include folder!")); HAPIIncludePath = ""; } } if (HAPIIncludePath != "") { PublicIncludePaths.Add(HAPIIncludePath); } PublicIncludePaths.AddRange( new string[] { Path.Combine(ModuleDirectory, "Public/HAPI"), Path.Combine(ModuleDirectory, "Public") } ); PrivateIncludePaths.AddRange( new string[] { "HoudiniEngineRuntime/Private" } ); // Add common dependencies. PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "RenderCore", "ShaderCore", "InputCore", "RHI", "Foliage", "Landscape" } ); PrivateDependencyModuleNames.AddRange( new string[] { // ... add private dependencies that you statically link with here ... } ); if (Target.bBuildEditor == true) { PrivateDependencyModuleNames.AddRange( new string[] { "AppFramework", "AssetTools", "EditorStyle", "EditorWidgets", "LevelEditor", "MainFrame", "MeshPaint", "Projects", "PropertyEditor", "RawMesh", "Settings", "Slate", "SlateCore", "TargetPlatform", "UnrealEd", "ApplicationCore", } ); } DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); }
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; }
public LevelEditor(ReadOnlyTargetRules Target) : base(Target) { PrivateIncludePathModuleNames.AddRange( new string[] { "AssetTools", "ClassViewer", "MainFrame", "PlacementMode", "SlateReflector", "IntroTutorials", "AppFramework", "PortalServices" } ); PublicIncludePathModuleNames.AddRange( new string[] { "Settings", "IntroTutorials", "HeadMountedDisplay", "VREditor" } ); PrivateDependencyModuleNames.AddRange( new string[] { "LevelSequence", "Analytics", "Core", "CoreUObject", "LauncherPlatform", "InputCore", "Slate", "SlateCore", "EditorStyle", "Engine", "MessageLog", "SourceControl", "SourceControlWindows", "StatsViewer", "UnrealEd", "RenderCore", "DeviceProfileServices", "ContentBrowser", "SceneOutliner", "ActorPickerMode", "RHI", "Projects", "TargetPlatform", "EngineSettings", "PropertyEditor", "Persona", "Kismet", "KismetWidgets", "Sequencer", "Foliage", "HierarchicalLODOutliner", "HierarchicalLODUtilities", "MaterialShaderQualitySettings", "PixelInspectorModule", "FunctionalTesting" } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "MainFrame", "ClassViewer", "DeviceManager", "SettingsEditor", "SessionFrontend", "SlateReflector", "AutomationWindow", "Layers", "WorldBrowser", "EditorWidgets", "AssetTools", "WorkspaceMenuStructure", "NewLevelDialog", "DeviceProfileEditor", "PlacementMode", "IntroTutorials", "HeadMountedDisplay", "VREditor" } ); }
public WebSocket(ReadOnlyTargetRules Target) : base(Target) { PrivateIncludePaths.AddRange( new string[] { "WebSocket/Private", // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "Json", "JsonUtilities", "Sockets", // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "Slate", "SlateCore", "Json", "JsonUtilities", // ... 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) { Definitions.Add("PLATFORM_UWP=0"); PrivateDependencyModuleNames.Add("zlib"); PrivateDependencyModuleNames.Add("OpenSSL"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Win64"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Win64/")); PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesX64 = new string[] { "websockets_static.lib", //"libcrypto.lib", //"libssl.lib", }; foreach (string Lib in StaticLibrariesX64) { PublicAdditionalLibraries.Add(Lib); } } if (Target.Platform == UnrealTargetPlatform.Win32) { Definitions.Add("PLATFORM_UWP=0"); PrivateDependencyModuleNames.Add("zlib"); PrivateDependencyModuleNames.Add("OpenSSL"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Win32"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Win32/")); PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesX32 = new string[] { "websockets_static.lib", //"libcrypto.lib", //"libssl.lib", }; foreach (string Lib in StaticLibrariesX32) { PublicAdditionalLibraries.Add(Lib); } } else if (Target.Platform == UnrealTargetPlatform.HTML5) { Definitions.Add("PLATFORM_UWP=0"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/HTML5/")); PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesHTML5 = new string[] { "WebSocket.js", }; foreach (string Lib in StaticLibrariesHTML5) { PublicAdditionalLibraries.Add(strStaticPath + Lib); } } else if (Target.Platform == UnrealTargetPlatform.Mac) { Definitions.Add("PLATFORM_UWP=0"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Mac"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Mac/")); //PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesMac = new string[] { "libwebsockets.a", "libssl.a", "libcrypto.a" }; foreach (string Lib in StaticLibrariesMac) { PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib)); } } else if (Target.Platform == UnrealTargetPlatform.Linux) { Definitions.Add("PLATFORM_UWP=0"); PrivateDependencyModuleNames.Add("OpenSSL"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Linux"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Linux/")); PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesMac = new string[] { "libwebsockets.a", //"libssl.a", //"libcrypto.a" }; foreach (string Lib in StaticLibrariesMac) { PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib)); } } else if (Target.Platform == UnrealTargetPlatform.IOS) { Definitions.Add("PLATFORM_UWP=0"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/IOS"); string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath + "/Source/"); PluginPath = PluginPath.Replace("\\", "/"); string strStaticPath = PluginPath + "/ThirdParty/lib/IOS/";// Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/IOS/")); PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesIOS = new string[] { "websockets", "ssl", "crypto" }; foreach (string Lib in StaticLibrariesIOS) { PublicAdditionalLibraries.Add(Lib); PublicAdditionalShadowFiles.Add(Path.Combine(strStaticPath, "lib" + Lib + ".a")); } } else if (Target.Platform == UnrealTargetPlatform.Android) { Definitions.Add("PLATFORM_UWP=0"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Android"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Android/armeabi-v7a")); PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesAndroid = new string[] { "websockets", //"ssl", //"crypto" }; foreach (string Lib in StaticLibrariesAndroid) { PublicAdditionalLibraries.Add(Lib); } } }
public HoudiniPlusEditor(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = ModuleRules.PCHUsageMode.UseSharedPCHs; // Check if we are compiling on unsupported platforms. if (Target.Platform != UnrealTargetPlatform.Win64 && Target.Platform != UnrealTargetPlatform.Mac && Target.Platform != UnrealTargetPlatform.Linux && Target.Platform != UnrealTargetPlatform.Switch) { Console.WriteLine(string.Format("Houdini Engine : Compiling on untested platform. Please let us know how it goes!")); } // Find HFS var HFSPath = GetHFSPath(); HFSPath = HFSPath.Replace("\\", "/"); if (!string.IsNullOrEmpty(HFSPath)) { var Log = string.Format("Houdini Engine : Found Houdini in {0}", HFSPath); Console.WriteLine(Log); var BuildPlatformId = Environment.OSVersion.Platform; if (BuildPlatformId == PlatformID.Win32NT) { PublicDefinitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath); } } // Find the HAPI include directory var HAPIIncludePath = HFSPath + "/toolkit/include"; if (!Directory.Exists(HAPIIncludePath)) { // Add the custom include path as well in case the toolkit path doesn't exist yet. HAPIIncludePath = HFSPath + "/custom/houdini/include"; if (!Directory.Exists(HAPIIncludePath)) { throw new Exception(string.Format("Couldn't find the HAPI include folder!")); HAPIIncludePath = string.Empty; } } if (!string.IsNullOrEmpty(HAPIIncludePath)) { PublicIncludePaths.Add(HAPIIncludePath); } // Get the plugin path var PluginPath = Path.Combine(ModuleDirectory, "../../"); PluginPath = Utils.MakePathRelativeTo(PluginPath, Target.RelativeEnginePath); PublicIncludePaths.AddRange( new string[] { "HoudiniPlusEditor/Public" }); PrivateIncludePaths.AddRange( new string[] { "HoudiniPlusEditor/Private", }); PrivateIncludePathModuleNames.AddRange( new string[] { "PlacementMode" }); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "Foliage", "InputCore", "Landscape", "RenderCore", "RHI", "ShaderCore", "Slate", "SlateCore", "Happy" }); PrivateDependencyModuleNames.AddRange( new string[] { "AppFramework", "ApplicationCore", "AssetTools", "ContentBrowser", "DesktopWidgets", "EditorStyle", "EditorWidgets", "LevelEditor", "MainFrame", "Projects", "PropertyEditor", "RawMesh", "Settings", "Slate", "SlateCore", "TargetPlatform", "UnrealEd", }); DynamicallyLoadedModuleNames.AddRange( new string[] { "PlacementMode" }); var HAPILibPath = Path.Combine(HFSPath, GetLibFolder(), GetLibName()); HAPILibPath = HAPILibPath.Replace("\\", "/"); if (!File.Exists(HAPILibPath)) { throw new Exception(string.Format("Couldn't find the HAPI lib!")); } else { PublicDelayLoadDLLs.Add(GetLibName()); RuntimeDependencies.Add(HAPILibPath); } }
public CesiumEditor(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; PublicIncludePaths.AddRange( new string[] { // ... add public include paths required here ... } ); PrivateIncludePaths.AddRange( new string[] { Path.Combine(ModuleDirectory, "../ThirdParty/include") } ); string libPrefix; string libPostfix; string platform; if (Target.Platform == UnrealTargetPlatform.Win64) { platform = "Windows-x64"; libPostfix = ".lib"; libPrefix = ""; } else if (Target.Platform == UnrealTargetPlatform.Mac) { platform = "Darwin-x64"; libPostfix = ".a"; libPrefix = "lib"; } else if (Target.Platform == UnrealTargetPlatform.Android) { platform = "Android-xaarch64"; libPostfix = ".a"; libPrefix = "lib"; } else if (Target.Platform == UnrealTargetPlatform.Linux) { platform = "Linux-x64"; libPostfix = ".a"; libPrefix = "lib"; } else if (Target.Platform == UnrealTargetPlatform.IOS) { platform = "iOS-xarm64"; libPostfix = ".a"; libPrefix = "lib"; } else { platform = "Unknown"; libPostfix = ".Unknown"; libPrefix = "Unknown"; } string libPath = Path.Combine(ModuleDirectory, "../ThirdParty/lib/" + platform); string releasePostfix = ""; string debugPostfix = "d"; bool preferDebug = (Target.Configuration == UnrealTargetConfiguration.Debug || Target.Configuration == UnrealTargetConfiguration.DebugGame); string postfix = preferDebug ? debugPostfix : releasePostfix; string[] libs = new string[] { "CesiumIonClient", "csprng" }; if (preferDebug) { // We prefer Debug, but might still use Release if that's all that's available. foreach (string lib in libs) { string debugPath = Path.Combine(libPath, libPrefix + lib + debugPostfix + libPostfix); if (!File.Exists(debugPath)) { Console.WriteLine("Using release build of cesium-native because a debug build is not available."); preferDebug = false; postfix = releasePostfix; break; } } } PublicAdditionalLibraries.AddRange(libs.Select(lib => Path.Combine(libPath, libPrefix + lib + postfix + libPostfix))); PublicDependencyModuleNames.AddRange( new string[] { "Core", "UnrealEd", "CesiumRuntime" } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "ApplicationCore", "Slate", "SlateCore", "MeshDescription", "StaticMeshDescription", "HTTP", "MikkTSpace", "Chaos", "Projects", "InputCore", "PropertyEditor", "DeveloperSettings", "EditorStyle" // ... add private dependencies that you statically link with here ... } ); PublicDefinitions.AddRange( new string[] { } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; PrivatePCHHeaderFile = "Private/PCH.h"; CppStandard = CppStandardVersion.Cpp17; if (Target.Platform == UnrealTargetPlatform.IOS || (Target.Platform == UnrealTargetPlatform.Android && Target.Version.MajorVersion == 4 && Target.Version.MinorVersion == 26 && Target.Version.PatchVersion < 2)) { // In UE versions prior to 4.26.2, the Unreal Build Tool on Android // (AndroidToolChain.cs) ignores the CppStandard property and just // always uses C++14. Our plugin can't be compiled with C++14. // // So this hack uses reflection to add an additional argument to // the compiler command-line to force C++17 mode. Clang ignores all // but the last `-std=` argument, so the `-std=c++14` added by the // UBT is ignored. // // This is also needed for iOS builds on all engine versions as Unreal // defaults to c++14 regardless of the CppStandard setting Type type = Target.GetType(); FieldInfo innerField = type.GetField("Inner", BindingFlags.Instance | BindingFlags.NonPublic); TargetRules inner = (TargetRules)innerField.GetValue(Target); inner.AdditionalCompilerArguments += " -std=c++17"; } }
public VictoryBPLibrary(ReadOnlyTargetRules Target) : base(Target) { PrivatePCHHeaderFile = "Private/VictoryBPLibraryPrivatePCH.h"; //4.15 Include What You Use bEnforceIWYU = false; PublicIncludePaths.AddRange( new string[] { "VictoryBPLibrary/Public" // ... add public include paths required here ... } ); PrivateIncludePaths.AddRange( new string[] { "VictoryBPLibrary/Private", // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core" // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "InputCore", "RHI", "RenderCore", "HTTP", "UMG", "Slate", "SlateCore", "ImageWrapper", "PhysX", "HeadMountedDisplay", "AIModule", "NavigationSystem", "Vorbis", //FPlatformApplicationMisc "ApplicationCore" } ); //APEX EXCLUSIONS if (Target.Platform != UnrealTargetPlatform.Android && Target.Platform != UnrealTargetPlatform.HTML5 && Target.Platform != UnrealTargetPlatform.IOS) { PrivateDependencyModuleNames.AddRange( new string[] { "APEX" } ); PublicDependencyModuleNames.AddRange( new string[] { "ApexDestruction" } ); } DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); }
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[] { // ... add public include paths required here ... } ); PrivateIncludePaths.AddRange( new string[] { // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "Sockets", "Networking" // ... 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 (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); } else if (Target.Platform == UnrealTargetPlatform.Mac) { 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); string libPath = GetMacPythonLibFile(pythonHome); PublicLibraryPaths.Add(Path.GetDirectoryName(libPath)); PublicDelayLoadDLLs.Add(libPath); } else 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(new ReceiptProperty("AndroidPlugin", RelAPLPath)); } #endif }
public IOToolkit(TargetInfo Target) #endif { // uncomment code below to package project without rebuild this module //bUsePrecompiled = true; //PrecompileForTargets = PrecompileTargetsType.None; PublicIncludePaths.AddRange( new string[] { Path.Combine(pluginDir, "Source/IOToolkit/Public"), Path.Combine(pluginDir, "ThirdParty/IOToolkit/include") // ... add public include paths required here ... } ); PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; string _ioModuleDir = Path.Combine(pluginDir, "ThirdParty/IOToolkit"); if (!Directory.Exists(_ioModuleDir)) { Console.WriteLine("[Error]: Can not find IOToolkit module which should be located at: " + Path.GetFullPath(_ioModuleDir)); } string _platform = Target.Platform == UnrealTargetPlatform.Win32 ? "Win32" : "Win64"; CopyAll( new DirectoryInfo(Path.Combine(pluginDir, "ThirdParty/IOToolkit/binaries", _platform)), new DirectoryInfo(Path.Combine(pluginDir, "Binaries", _platform)) ); PrivateIncludePaths.AddRange( new string[] { "IOToolkit/Private", // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "Projects" // ... add other public dependencies that you statically link with here ... } ); PublicAdditionalLibraries.Add(Path.Combine(pluginDir, "Binaries", _platform, "IODevice.lib")); // Delay-load the DLL, so we can load it from the right place first PublicDelayLoadDLLs.Add("IODevice.dll"); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "Slate", "SlateCore", // ... add private dependencies that you statically link with here ... } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); RuntimeDependencies.Add(Path.Combine("$(PluginDir)/Binaries", _platform, "..."), StagedFileType.NonUFS); }
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 } }
public RuntimeMeshComponent(ReadOnlyTargetRules rules) : base(rules) { PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; PublicIncludePaths.AddRange( new string[] { "RuntimeMeshComponent/Public", // ... add public include paths required here ... //"RuntimeMeshComponent/Public/RuntimeDestructibleActor" } ); PrivateIncludePaths.AddRange( new string[] { "RuntimeMeshComponent/Private", // ... add other private include paths required here ... //"RuntimeMeshComponent/Private/RuntimeDestructibleActor" } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", // ... add other public dependencies that you statically link with here ... //"PhysX", "APEX","ApexDestruction" } ); string ApexVersion = "APEX_1.4"; string APEXDir = rules.UEThirdPartySourceDirectory + "PhysX3/" + ApexVersion + "/"; string APEXLibDir = rules.UEThirdPartySourceDirectory + "PhysX3/Lib"; string PxSharedVersion = "PxShared"; string PxSharedDir = rules.UEThirdPartySourceDirectory + "PhysX3/" + PxSharedVersion + "/"; string PxSharedIncludeDir = PxSharedDir + "include/"; //string PxSourceVersion = "Source/PhysX"; //string PxSourceDir = rules.UEThirdPartySourceDirectory + "PhysX3/" + PxSourceVersion + "/"; PublicSystemIncludePaths.AddRange( new string[] { PxSharedDir + "src/foundation/include", //PsArray.h APEXDir + "nvparameterized/include", //"NvParametersTypes.h" //APEXDir + "include/destructible",//DestructibleActorJoint.h APEXDir + "module/destructible/include/", //DestructibleScene.h, DestructibleActorImpl.h //APEXDir + "module/destructible/src/",// DestructibleActorImpl.cpp //PxSourceDir + "src", //PxSourceDir + "src/buffering" } ); //To fix issues with Atomic.h PublicDependencyModuleNames.AddRange(new string[] { "ApplicationCore" }); PrivateDependencyModuleNames.AddRange(new string[] { "PhysX", "APEX" }); //PhysX PrivateDependencyModuleNames.AddRange(new string[] { "RMC_ApexDestruction" }); if (rules.Type == TargetRules.TargetType.Editor) { PublicDependencyModuleNames.AddRange(new string[] { "MeshBuilder" }); } PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", // ... add private dependencies that you statically link with here ... "RenderCore", "ShaderCore", "RHI", //"MeshBuilder",//BuildSkeletalAdjacencyIndexBuffer() } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); }
public MotionMatchingEditor(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; PublicIncludePaths.AddRange( new string[] { "MotionMatchingEditor/Public" // ... add public include paths required here ... } ); PrivateIncludePaths.AddRange( new string[] { "MotionMatchingEditor/Private", // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Json", "Slate", "SlateCore", "Engine", "InputCore", "UnrealEd", // for FAssetEditorManager "KismetWidgets", "Kismet", // for FWorkflowCentricApplication "PropertyEditor", "RenderCore", "ContentBrowser", "WorkspaceMenuStructure", "EditorStyle", "MeshPaint", "EditorWidgets", "Projects", "MotionMatching", "AnimGraph", "BlueprintGraph", "AssetRegistry", "AdvancedPreviewScene", // ... add private dependencies that you statically link with here ... } ); PrivateIncludePathModuleNames.AddRange( new string[] { "Settings", "IntroTutorials", "AssetTools", "LevelEditor" } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "AssetTools" } ); }
public FLKinectPlugin(TargetInfo Target) { string KinectPathEnvVar = "%KINECTSDK20_DIR%"; string ExpandedKinectEnvVar = Environment.ExpandEnvironmentVariables(KinectPathEnvVar); //NOTE (OS): Safety check for comptuers that don't have the kinect plugin if (KinectPathEnvVar == ExpandedKinectEnvVar) { var err = "ERROR : Environment variable {0} does not exist in this Windows environment. Check if the Kinect for Windows 2.0 plugin is installed."; Console.WriteLine(err, KinectPathEnvVar); throw new Exception(err); } string ThirdPartyKinectIncludePath = Path.Combine(ExpandedKinectEnvVar, "inc"); string PlatformSpec = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64" : "x86"; string ThirdPartyKinectLibPath = Path.Combine(ExpandedKinectEnvVar, "Lib", PlatformSpec); PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyKinectLibPath, "Kinect20.lib")); PublicIncludePaths.AddRange( new string[] { // ... add public include paths required here ... } ); PrivateIncludePaths.AddRange( new string[] { "Developer/FLKinectPlugin/Private", ThirdPartyKinectIncludePath // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "Engine", // ... add private dependencies that you statically link with here ... } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); }
public HoudiniEngineEditor(TargetInfo Target) { string HFSPath = ""; string HoudiniVersion = "14.0.374"; // Check if we are compiling on unsupported platforms. if (Target.Platform != UnrealTargetPlatform.Win64 && Target.Platform != UnrealTargetPlatform.Mac) { string Err = string.Format("Houdini Engine Runtime: Compiling on unsupported platform."); System.Console.WriteLine(Err); throw new BuildException(Err); } if (HFSPath == "") { if (Target.Platform == UnrealTargetPlatform.Win64) { // We first check if Houdini Engine is installed. HFSPath = "C:/Program Files/Side Effects Software/Houdini Engine " + HoudiniVersion; if (!Directory.Exists(HFSPath)) { // If Houdini Engine is not installed, we check for Houdini installation. HFSPath = "C:/Program Files/Side Effects Software/Houdini " + HoudiniVersion; if (!Directory.Exists(HFSPath)) { string Err = string.Format("Houdini Engine Runtime: Please install Houdini or Houdini Engine {0}", HoudiniVersion); System.Console.WriteLine(Err); throw new BuildException(Err); } } } else if (Target.Platform == UnrealTargetPlatform.Mac) { HFSPath = "/Library/Frameworks/Houdini.framework/Versions/" + HoudiniVersion + "/Resources"; if (!Directory.Exists(HFSPath)) { string Err = string.Format("Houdini Engine Runtime: Please install Houdini {0}", HoudiniVersion); System.Console.WriteLine(Err); throw new BuildException(Err); } } } string HAPIIncludePath = HFSPath + "/toolkit/include/HAPI"; if (HFSPath != "") { if (Target.Platform == UnrealTargetPlatform.Win64) { Definitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath); } } PublicIncludePaths.AddRange( new string[] { // ... add public include paths required here ... HAPIIncludePath, "HoudiniEngineRuntime/Public", "HoudiniEngineEditor/Public" } ); PrivateIncludePaths.AddRange( new string[] { "HoudiniEngineEditor/Private", "HoudiniEngineRuntime/Private" // ... add other private include paths required here ... } ); // Add common dependencies. PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "RenderCore", "ShaderCore", "InputCore", "RHI", "AssetTools", "UnrealEd", "Slate", "SlateCore", "Projects", "PropertyEditor", "ContentBrowser", "RawMesh", "TargetPlatform", "LevelEditor", "MainFrame", "EditorStyle", "EditorWidgets", "AppFramework", "HoudiniEngineRuntime" } ); 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 ... } ); }
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", "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", "UtilityShaders", "AssetRegistry", // Here until FAssetData is moved to engine "EngineMessages", "EngineSettings", "SynthBenchmark", "GameplayTags", "DatabaseSupport", "PacketHandler", "AudioPlatformConfiguration", "MeshDescription", } ); PrivateDependencyModuleNames.AddRange( new string[] { "AppFramework", "Networking", "Sockets", "Landscape", "UMG", "Projects", "MaterialShaderQualitySettings", "CinematicCamera", "Analytics", "AnalyticsET", } ); 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"); 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"); } SetupModulePhysXAPEXSupport(Target); if (Target.bCompilePhysX && (Target.bBuildEditor || Target.bCompileAPEX)) { DynamicallyLoadedModuleNames.Add("PhysXCooking"); } // Engine public headers need to know about some types (enums etc.) PublicIncludePathModuleNames.Add("ClothingSystemRuntimeInterface"); PublicDependencyModuleNames.Add("ClothingSystemRuntimeInterface"); if (Target.bBuildEditor) { PrivateDependencyModuleNames.Add("ClothingSystemEditorInterface"); PrivateIncludePathModuleNames.Add("ClothingSystemEditorInterface"); } if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile", "libOpus" ); // Head Mounted Display support // PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" }); // DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" }); } if (Target.Platform == UnrealTargetPlatform.HTML5) { // TODO test this for HTML5 ! //AddEngineThirdPartyPrivateStaticDependencies(Target, // "UEOgg", // "Vorbis", // "VorbisFile" // ); PublicDependencyModuleNames.Add("HTML5JS"); } if (Target.Platform == UnrealTargetPlatform.Mac) { AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "libOpus" ); PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" }); } if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android)) { AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile" ); PrivateDependencyModuleNames.Add("AndroidRuntimeSettings"); } if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS) { PrivateDependencyModuleNames.Add("IOSRuntimeSettings"); } if (Target.Platform == UnrealTargetPlatform.Switch) { PrivateDependencyModuleNames.Add("SwitchRuntimeSettings"); } if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix)) { AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile", "libOpus" ); } PublicDefinitions.Add("GPUPARTICLE_LOCAL_VF_ONLY=0"); // Add a reference to the stats HTML files referenced by UEngine::DumpFPSChartToHTML. Previously staged by CopyBuildToStagingDirectory. if (Target.bBuildEditor || Target.Configuration != UnrealTargetConfiguration.Shipping) { RuntimeDependencies.Add("$(EngineDir)/Content/Stats/...", StagedFileType.UFS); } }
public SlateReflector(ReadOnlyTargetRules Target) : base(Target) { PublicDependencyModuleNames.AddRange( new string[] { "Core", } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "ApplicationCore", "InputCore", "Slate", "SlateCore", "EditorStyle", "Json", "AssetRegistry", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "Messaging", "MessagingCommon", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "Messaging", } ); PrivateIncludePaths.AddRange( new string[] { "Developer/SlateReflector/Private", "Developer/SlateReflector/Private/Models", "Developer/SlateReflector/Private/Widgets", } ); // Editor builds include SessionServices to populate the remote target drop-down for remote widget snapshots if (Target.Type == TargetType.Editor) { PublicDefinitions.Add("SLATE_REFLECTOR_HAS_SESSION_SERVICES=1"); PrivateIncludePathModuleNames.AddRange( new string[] { "SessionServices", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "SessionServices", } ); } else { PublicDefinitions.Add("SLATE_REFLECTOR_HAS_SESSION_SERVICES=0"); } // DesktopPlatform is only available for Editor and Program targets (running on a desktop platform) bool IsDesktopPlatformType = Target.Platform == UnrealBuildTool.UnrealTargetPlatform.Win32 || Target.Platform == UnrealBuildTool.UnrealTargetPlatform.Win64 || Target.Platform == UnrealBuildTool.UnrealTargetPlatform.Mac || Target.Platform == UnrealBuildTool.UnrealTargetPlatform.Linux; if (Target.Type == TargetType.Editor || (Target.Type == TargetType.Program && IsDesktopPlatformType)) { PublicDefinitions.Add("SLATE_REFLECTOR_HAS_DESKTOP_PLATFORM=1"); PrivateDependencyModuleNames.AddRange( new string[] { "DesktopPlatform", } ); } else { PublicDefinitions.Add("SLATE_REFLECTOR_HAS_DESKTOP_PLATFORM=0"); } if (Target.Configuration != UnrealTargetConfiguration.Shipping) { PrecompileForTargets = PrecompileTargetsType.Any; } }
public VictoryBPLibrary(ReadOnlyTargetRules Target) : base(Target) { //Get rid of debug commandline length compile error //https://developercommunity.visualstudio.com/content/problem/668411/command-line-error-d8049-still-happening.html bLegacyPublicIncludePaths = false; PrivatePCHHeaderFile = "Private/VictoryBPLibraryPrivatePCH.h"; //4.15 Include What You Use bEnforceIWYU = false; PublicIncludePaths.AddRange( new string[] { "VictoryBPLibrary/Public" // ... add public include paths required here ... } ); PrivateIncludePaths.AddRange( new string[] { "VictoryBPLibrary/Private", // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core" // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "InputCore", "RHI", "RenderCore", "HTTP", "UMG", "Slate", "SlateCore", "ImageWrapper", "PhysicsCore", "PhysX", "HeadMountedDisplay", "AIModule", "NavigationSystem", "Vorbis", //FPlatformApplicationMisc "ApplicationCore" } ); //APEX EXCLUSIONS if (Target.Platform != UnrealTargetPlatform.Android && Target.Platform != UnrealTargetPlatform.IOS) { PrivateDependencyModuleNames.AddRange( new string[] { "APEX" } ); PublicDependencyModuleNames.AddRange( new string[] { "ApexDestruction" } ); } DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); }
public WebSocket(ReadOnlyTargetRules Target) : base(Target) { PrivatePCHHeaderFile = "Public/WebSocket.h"; string strEngineDir = GetEngineDirectory(); string strEngineVersion = ReadEngineVersion(strEngineDir); System.Console.WriteLine("version:" + strEngineVersion); PrivateIncludePaths.AddRange( new string[] { "WebSocket/Private", // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "Json", "JsonUtilities", "Sockets", // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "Slate", "SlateCore", "Json", "JsonUtilities", // ... 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) { PublicDefinitions.Add("PLATFORM_UWP=0"); PrivateDependencyModuleNames.Add("zlib"); if (EngineMinorVersion == "21" || EngineMinorVersion == "20") { PrivateDependencyModuleNames.Add("OpenSSL"); } PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Win64"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Win64/")); //PublicLibraryPaths.Add(strStaticPath); // for 4.21 if (EngineMinorVersion == "21" || EngineMinorVersion == "20") { string[] StaticLibrariesX64 = new string[] { "websockets_static.lib", }; foreach (string Lib in StaticLibrariesX64) { PublicAdditionalLibraries.Add(strStaticPath + Lib); } } else { // for 4.22 and beyond if (Target.Type == TargetType.Editor) { PublicAdditionalLibraries.Add(strStaticPath + "websockets_static422.lib"); PublicAdditionalLibraries.Add(strStaticPath + "libeay32.lib"); PublicAdditionalLibraries.Add(strStaticPath + "ssleay32.lib"); } else { PublicAdditionalLibraries.Add(strStaticPath + "websockets_game_static422.lib"); } } } if (Target.Platform == UnrealTargetPlatform.Win32) { PublicDefinitions.Add("PLATFORM_UWP=0"); PrivateDependencyModuleNames.Add("zlib"); PrivateDependencyModuleNames.Add("OpenSSL"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Win32"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Win32/")); PublicLibraryPaths.Add(strStaticPath); // 4.22 and 4.21 if (EngineMinorVersion == "21" || EngineMinorVersion == "20") { string[] StaticLibrariesX32 = new string[] { "websockets_static.lib", //"libcrypto.lib", //"libssl.lib", }; foreach (string Lib in StaticLibrariesX32) { PublicAdditionalLibraries.Add(Lib); } } else if (EngineMinorVersion == "22") { string[] StaticLibrariesX32 = new string[] { "websockets_static422.lib", //"libcrypto.lib", //"libssl.lib", }; foreach (string Lib in StaticLibrariesX32) { PublicAdditionalLibraries.Add(Lib); } } } else if (Target.Platform == UnrealTargetPlatform.HTML5) { PublicDefinitions.Add("PLATFORM_UWP=0"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/HTML5/")); PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesHTML5 = new string[] { "WebSocket.js", }; foreach (string Lib in StaticLibrariesHTML5) { PublicAdditionalLibraries.Add(strStaticPath + Lib); } } else if (Target.Platform == UnrealTargetPlatform.Mac) { PublicDefinitions.Add("PLATFORM_UWP=0"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Mac"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Mac/")); //PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesMac = new string[] { "libwebsockets.a", "libssl.a", "libcrypto.a" }; foreach (string Lib in StaticLibrariesMac) { PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib)); } } else if (Target.Platform == UnrealTargetPlatform.Linux) { PublicDefinitions.Add("PLATFORM_UWP=0"); PrivateDependencyModuleNames.Add("OpenSSL"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Linux"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Linux/")); PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesMac = new string[] { "libwebsockets.a", //"libssl.a", //"libcrypto.a" }; foreach (string Lib in StaticLibrariesMac) { PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib)); } } else if (Target.Platform == UnrealTargetPlatform.IOS) { PublicDefinitions.Add("PLATFORM_UWP=0"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/IOS"); string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath + "/Source/"); PluginPath = PluginPath.Replace("\\", "/"); string strStaticPath = PluginPath + "/ThirdParty/lib/IOS/";// Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/IOS/")); PublicLibraryPaths.Add(strStaticPath); string[] StaticLibrariesIOS = new string[] { "websockets", "ssl", "crypto" }; foreach (string Lib in StaticLibrariesIOS) { PublicAdditionalLibraries.Add(Lib); PublicAdditionalShadowFiles.Add(Path.Combine(strStaticPath, "lib" + Lib + ".a")); } } else if (Target.Platform == UnrealTargetPlatform.Android) { PublicDefinitions.Add("PLATFORM_UWP=0"); PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Android"); string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Android/armeabi-v7a")); PublicLibraryPaths.Add(strStaticPath); string strStaticArm64Path = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Android/arm64-v8a")); PublicLibraryPaths.Add(strStaticArm64Path); string[] StaticLibrariesAndroid = new string[] { "websockets", "ssl", "crypto" }; foreach (string Lib in StaticLibrariesAndroid) { PublicAdditionalLibraries.Add(Lib); } } }
public SequenceRecorder(ReadOnlyTargetRules Target) : base(Target) { PublicIncludePaths.AddRange( new string[] { } ); PrivateIncludePaths.AddRange( new string[] { "Editor/SequenceRecorder/Private", "Editor/SequenceRecorder/Private/Sections", } ); PublicDependencyModuleNames.AddRange( new string[] { "TimeManagement", "SerializedRecorderInterface", } ); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "SlateCore", "Slate", "InputCore", "Engine", "UnrealEd", "EditorStyle", "Projects", "LevelEditor", "Persona", "WorkspaceMenuStructure", "PropertyEditor", "MovieScene", "MovieSceneTracks", "LevelSequence", "NetworkReplayStreaming", "AssetRegistry", "CinematicCamera", "EditorWidgets", "Kismet", "LiveLinkInterface", "SerializedRecorderInterface", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { } ); if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32) { // Add __WINDOWS_WASAPI__ so that RtAudio compiles with WASAPI PublicDefinitions.Add("__WINDOWS_WASAPI__"); } }
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"); } }
public SimpleUnrealPakView(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; PublicIncludePaths.AddRange( new string[] { // ... add public include paths required here ... } ); PrivateIncludePaths.AddRange( new string[] { // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "Projects", "InputCore", "CoreUObject", "Engine", "SimpleUnrealPak", "ProceduralMeshComponent" // ... add private dependencies that you statically link with here ... } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); if (Target.bBuildEditor == true) { PrivateDependencyModuleNames.AddRange( new string[] { "UnrealEd", "LevelEditor", "Slate", "SlateCore", "PropertyEditor", "AdvancedPreviewScene", "EditorStyle", // ... add private dependencies that you statically link with here ... } ); } }
public MovieSceneTools(ReadOnlyTargetRules Target) : base(Target) { PrivateIncludePaths.AddRange( new string[] { "Editor/MovieSceneTools/Private", "Editor/MovieSceneTools/Private/CurveKeyEditors", "Editor/MovieSceneTools/Private/TrackEditors", "Editor/MovieSceneTools/Private/TrackEditors/PropertyTrackEditors", "Editor/MovieSceneTools/Private/TrackEditorThumbnail", "Editor/MovieSceneTools/Private/Sections", "Editor/UnrealEd/Private", //compatibility for FBX importer } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "InputCore", "UnrealEd", "Sequencer" } ); PrivateDependencyModuleNames.AddRange( new string[] { "ActorPickerMode", "CinematicCamera", "DesktopPlatform", "LevelSequence", "MovieScene", "MovieSceneCapture", "MovieSceneTracks", "BlueprintGraph", "KismetCompiler", "GraphEditor", "ContentBrowser", "Slate", "SlateCore", "EditorStyle", "EditorWidgets", "PropertyEditor", "MaterialEditor", "RenderCore", "RHI", "ShaderCore", "SequenceRecorder", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "AssetRegistry", "AssetTools", "Sequencer", "Settings", "SceneOutliner", "MainFrame", "UnrealEd", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "AssetRegistry", "AssetTools", "SceneOutliner", "MainFrame", } ); CircularlyReferencedDependentModules.AddRange( new string[] { "Sequencer", } ); AddEngineThirdPartyPrivateStaticDependencies(Target, "FBX"); }
public JoystickPlugin(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "InputCore", "Slate", "SlateCore", // ... add other public dependencies that you statically link with here ... }); PrivateIncludePathModuleNames.AddRange( new string[] { "InputDevice", }); if (Target.Type == TargetRules.TargetType.Editor) { PrivateIncludePathModuleNames.AddRange( new string[] { "PropertyEditor", "ActorPickerMode", "DetailCustomizations", }); PrivateDependencyModuleNames.AddRange( new string[] { "PropertyEditor", "DetailCustomizations", // ... add private dependencies that you statically link with here ... }); } DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... }); if (UEBuildConfiguration.bBuildEditor == true) { LinkThirdPartyStaticallyOnWindows = false; } if (Target.Platform == UnrealTargetPlatform.Win64) { string SDL2Path = ThirdPartyPath + "SDL2/SDL/"; string SDL2LibPath = SDL2Path + "Lib/"; PublicIncludePaths.Add(Path.Combine(SDL2Path, "include/")); PrivateIncludePaths.Add(Path.Combine(SDL2Path, "include/")); // Public || Private !? is there documentation ? if (LinkThirdPartyStaticallyOnWindows) { PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2-static.lib")); PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2main.lib")); } else { PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2.lib")); } PublicAdditionalLibraries.Add("Version.lib"); } if (Target.Platform == UnrealTargetPlatform.Win32) { string SDL2Path = ThirdPartyPath + "SDL2/SDL/"; string SDL2LibPath = SDL2Path + "Lib32/"; PublicIncludePaths.Add(Path.Combine(SDL2Path, "include/")); if (LinkThirdPartyStaticallyOnWindows) { PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2-static.lib")); PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2main.lib")); } else { PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2.lib")); } PublicAdditionalLibraries.Add("Version.lib"); } else if (Target.Platform == UnrealTargetPlatform.Mac) { PublicFrameworks.Add("/Library/Frameworks/SDL2.framework"); } else if (Target.Platform == UnrealTargetPlatform.Linux) { //AddThirdPartyPrivateStaticDependencies(Target, "SDL2"); AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2"); } }
public UnrealEd(TargetInfo Target) { SharedPCHHeaderFile = "Editor/UnrealEd/Public/UnrealEd.h"; PrivateIncludePaths.AddRange( new string[] { "Editor/UnrealEd/Private", "Editor/UnrealEd/Private/Settings", "Editor/PackagesDialog/Public", "Developer/DerivedDataCache/Public", "Developer/TargetPlatform/Public", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "AssetRegistry", "AssetTools", "BehaviorTreeEditor", "ClassViewer", "ContentBrowser", "CrashTracker", "DerivedDataCache", "DesktopPlatform", "EnvironmentQueryEditor", "GameProjectGeneration", "ProjectTargetPlatformEditor", "ImageWrapper", "MainFrame", "MaterialEditor", "MergeActors", "MeshUtilities", "Messaging", "MovieSceneCapture", "NiagaraEditor", "PlacementMode", "Settings", "SettingsEditor", "SuperSearch", "SoundClassEditor", "ViewportSnapping", "SourceCodeAccess", "ReferenceViewer", "IntroTutorials", "OutputLog", "Landscape", "Niagara", "SizeMap", "LocalizationService", "HierarchicalLODUtilities", "MessagingRpc", "PortalRpc", "PortalServices", "BlueprintNativeCodeGen", "ViewportInteraction", "VREditor", "Persona", } ); PublicDependencyModuleNames.AddRange( new string[] { "BspMode", "Core", "CoreUObject", "DirectoryWatcher", "Documentation", "Engine", "Json", "Projects", "SandboxFile", "Slate", "SlateCore", "EditorStyle", "SourceControl", "UnrealEdMessages", "AIModule", "GameplayDebugger", "BlueprintGraph", "Http", "UnrealAudio", "FunctionalTesting", "AutomationController", "Internationalization", } ); PrivateDependencyModuleNames.AddRange( new string[] { "LevelSequence", "AnimGraph", "AppFramework", "BlueprintGraph", "CinematicCamera", "DesktopPlatform", "EditorStyle", "EngineSettings", "InputCore", "InputBindingEditor", "LauncherServices", "MaterialEditor", "MessageLog", "NetworkFileSystem", "PakFile", "PropertyEditor", "Projects", "RawMesh", "RenderCore", "RHI", "ShaderCore", "Sockets", "SoundClassEditor", "SoundCueEditor", "SourceControlWindows", "StatsViewer", "SwarmInterface", "TargetPlatform", "TargetDeviceServices", "EditorWidgets", "GraphEditor", "Kismet", "InternationalizationSettings", "JsonUtilities", "Landscape", "HeadMountedDisplay", "MeshPaint", "Foliage", "VectorVM", "TreeMap", "MaterialUtilities", "LocalizationService", "AddContentDialog", "GameProjectGeneration", "HierarchicalLODUtilities", "Analytics", "AnalyticsET", "PluginWarden", "PixelInspectorModule", "MovieScene", "MovieSceneTracks", "ViewportInteraction", "VREditor" } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "CrashTracker", "FontEditor", "StaticMeshEditor", "TextureEditor", "Cascade", "UMGEditor", "Matinee", "AssetRegistry", "AssetTools", "ClassViewer", "CollectionManager", "ContentBrowser", "CurveTableEditor", "DataTableEditor", "DestructibleMeshEditor", "EditorSettingsViewer", "LandscapeEditor", "KismetCompiler", "DetailCustomizations", "ComponentVisualizers", "MainFrame", "LevelEditor", "PackagesDialog", "Persona", "PhAT", "ProjectLauncher", "DeviceManager", "SettingsEditor", "SessionFrontend", "Sequencer", "SuperSearch", "GeometryMode", "TextureAlignMode", "FoliageEdit", "PackageDependencyInfo", "ImageWrapper", "Blutility", "IntroTutorials", "WorkspaceMenuStructure", "PlacementMode", "NiagaraEditor", "MeshUtilities", "MergeActors", "ProjectSettingsViewer", "ProjectTargetPlatformEditor", "PListEditor", "BehaviorTreeEditor", "EnvironmentQueryEditor", "ViewportSnapping", "UserFeedback", "GameplayTagsEditor", "GameplayTasksEditor", "GameplayAbilitiesEditor", "UndoHistory", "SourceCodeAccess", "ReferenceViewer", "EditorLiveStreaming", "HotReload", "IOSPlatformEditor", "HTML5PlatformEditor", "SizeMap", "PortalProxies", "PortalServices", "GeometryCacheEd", "BlueprintNativeCodeGen" } ); if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux) { DynamicallyLoadedModuleNames.Add("AndroidPlatformEditor"); } CircularlyReferencedDependentModules.AddRange( new string[] { "GraphEditor", "Kismet", } ); // Add include directory for Lightmass PublicIncludePaths.Add("Programs/UnrealLightmass/Public"); PublicIncludePathModuleNames.AddRange( new string[] { "UserFeedback", "CollectionManager", "BlueprintGraph", "AddContentDialog", "MeshUtilities" } ); if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { PublicDependencyModuleNames.Add("XAudio2"); PublicDependencyModuleNames.Add("AudioMixerXAudio2"); PublicDependencyModuleNames.Add("UnrealAudioXAudio2"); AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile", "DX11Audio" ); } if (Target.Platform == UnrealTargetPlatform.Mac) { PublicDependencyModuleNames.Add("UnrealAudioCoreAudio"); } if (Target.Platform == UnrealTargetPlatform.HTML5) { PublicDependencyModuleNames.Add("ALAudio"); } AddEngineThirdPartyPrivateStaticDependencies(Target, "HACD", "VHACD", "FBX", "FreeType2" ); SetupModulePhysXAPEXSupport(Target); if (UEBuildConfiguration.bCompileRecast) { PrivateDependencyModuleNames.Add("Navmesh"); Definitions.Add("WITH_RECAST=1"); } else { Definitions.Add("WITH_RECAST=0"); } }
public HoudiniEngineEditor(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = PCHUsageMode.UseSharedPCHs; // Check if we are compiling on unsupported platforms. if (Target.Platform != UnrealTargetPlatform.Win64 && Target.Platform != UnrealTargetPlatform.Mac && Target.Platform != UnrealTargetPlatform.Linux) { string Err = string.Format("Houdini Engine Runtime: Compiling on unsupported platform."); System.Console.WriteLine(Err); throw new BuildException(Err); } // Find HFS string HFSPath = GetHFSPath(); if (HFSPath != "") { PlatformID buildPlatformId = Environment.OSVersion.Platform; if (buildPlatformId == PlatformID.Win32NT) { Definitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath); } } // Find the HAPI include directory string HAPIIncludePath = HFSPath + "/toolkit/include/HAPI"; if (!Directory.Exists(HAPIIncludePath)) { // Try the custom include path as well in case the toolkit path doesn't exist yet. HAPIIncludePath = HFSPath + "/custom/houdini/include/HAPI"; if (!Directory.Exists(HAPIIncludePath)) { System.Console.WriteLine(string.Format("Couldnt find the HAPI include folder!")); HAPIIncludePath = ""; } } if (HAPIIncludePath != "") { PublicIncludePaths.Add(HAPIIncludePath); } // Get the plugin path string PluginPath = Path.Combine(ModuleDirectory, "../../"); PluginPath = Utils.MakePathRelativeTo(PluginPath, Target.RelativeEnginePath); PublicIncludePaths.AddRange( new string[] { "HoudiniEngineRuntime/Public/HAPI", "HoudiniEngineRuntime/Public", "HoudiniEngineEditor/Public" } ); PrivateIncludePaths.AddRange( new string[] { "HoudiniEngineEditor/Private", "HoudiniEngineRuntime/Private" } ); PrivateIncludePathModuleNames.AddRange( new string[] { "PlacementMode" } ); // Add common dependencies. PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "HoudiniEngineRuntime", "Slate", "SlateCore", "Landscape" } ); PrivateDependencyModuleNames.AddRange( new string[] { "AppFramework", "AssetTools", "ContentBrowser", "DesktopWidgets", "EditorStyle", "EditorWidgets", "Engine", "InputCore", "LevelEditor", "MainFrame", "Projects", "PropertyEditor", "RHI", "RawMesh", "RenderCore", "ShaderCore", "TargetPlatform", "UnrealEd", "ApplicationCore", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "PlacementMode", } ); }