// public Funapi(TargetInfo Target) // <= 4.15 public Funapi(ReadOnlyTargetRules Target) : base(Target) // >= 4.16 { PublicDefinitions.Add("WITH_FUNAPI=1"); PublicDefinitions.Add("FUNAPI_UE4=1"); PublicDefinitions.Add("FUNAPI_HAVE_ZLIB=1"); PublicDefinitions.Add("FUNAPI_HAVE_DELAYED_ACK=1"); PublicDefinitions.Add("FUNAPI_HAVE_TCP_TLS=1"); PublicDefinitions.Add("FUNAPI_HAVE_WEBSOCKET=1"); if (Target.Platform == UnrealTargetPlatform.PS4) { PublicDefinitions.Add("FUNAPI_HAVE_RPC=0"); } else { PublicDefinitions.Add("FUNAPI_HAVE_RPC=1"); } if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { PublicDefinitions.Add("FUNAPI_PLATFORM_WINDOWS=1"); PublicDefinitions.Add("FUNAPI_UE4_PLATFORM_WINDOWS=1"); } if (Target.Platform == UnrealTargetPlatform.Linux) { PublicDefinitions.Add("FUNAPI_HAVE_ZSTD=0"); PublicDefinitions.Add("FUNAPI_HAVE_SODIUM=0"); PublicDefinitions.Add("FUNAPI_HAVE_AES128=0"); } else { PublicDefinitions.Add("FUNAPI_HAVE_ZSTD=1"); PublicDefinitions.Add("FUNAPI_HAVE_SODIUM=1"); if (Target.Platform == UnrealTargetPlatform.Android) { PublicDefinitions.Add("FUNAPI_HAVE_AES128=0"); } else { PublicDefinitions.Add("FUNAPI_HAVE_AES128=1"); } } PublicIncludePaths.AddRange( new string[] { // NOTE(sungjin): Path를 문자열로 넘겨주지 않고 // Path.Combine(ModuleDirectory,"Path") 을 사용한다. // 엔진이 플러그인의 Public, Private 폴더를 자동으로 추가해 주지만 // 잘못된 경로를 추가하는 현상이 있어 // Path.Combine 함수를 통해 명시적으로 표현하도록 하여 우회한다. Path.Combine(ModuleDirectory, "Public"), Path.Combine(ModuleDirectory, "Public/funapi"), Path.Combine(ModuleDirectory, "Public/funapi/management"), Path.Combine(ModuleDirectory, "Public/funapi/network"), Path.Combine(ModuleDirectory, "Public/funapi/service"), //... add public include paths required here... } ); PrivateIncludePaths.AddRange( new string[] { //ModuleDirectory = real dicractory path where Funapi.Build.cs Path.Combine(ModuleDirectory, "Private"), //... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "Engine", "zlib", // ... 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 ... } ); // definitions PublicDefinitions.Add("RAPIDJSON_HAS_STDSTRING=0"); PublicDefinitions.Add("RAPIDJSON_HAS_CXX11_RVALUE_REFS=0"); // definitions for zlib PublicDefinitions.Add("_LARGEFILE64_SOURCE=0"); PublicDefinitions.Add("_FILE_OFFSET_BITS=0"); // Third party library var ThirdPartyPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty/")); // include path PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include")); // library var LibPath = ThirdPartyPath; if (Target.Platform == UnrealTargetPlatform.Mac) { PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include", "Mac")); LibPath += "lib/Mac"; PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcurl.a")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.a")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.a")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libz.a")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.a")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libwebsockets.a")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libzstd.a")); } else if (Target.Platform == UnrealTargetPlatform.Win32) { PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include", "Windows", "x86")); LibPath += "lib/Windows/x86"; PublicLibraryPaths.Add(LibPath); PublicDefinitions.Add("CURL_STATICLIB=1"); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcurl_a.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libeay32.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "websockets_static.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libzstd_static.lib")); } else if (Target.Platform == UnrealTargetPlatform.Win64) { PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include", "Windows", "x64")); LibPath += "lib/Windows/x64"; PublicLibraryPaths.Add(LibPath); PublicDefinitions.Add("CURL_STATICLIB=1"); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcurl_a.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "websockets_static.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libzstd_static.lib")); } else if (Target.Platform == UnrealTargetPlatform.Android) { PublicDefinitions.Add("FUNAPI_UE4_PLATFORM_ANDROID=1"); // toolchain will filter properly PublicIncludePaths.Add(LibPath + "include/Android/ARMv7"); PublicLibraryPaths.Add(LibPath + "lib/Android/ARMv7"); PublicIncludePaths.Add(LibPath + "include/Android/ARM64"); PublicLibraryPaths.Add(LibPath + "lib/Android/ARM64"); PublicAdditionalLibraries.Add("sodium"); PublicAdditionalLibraries.Add("curl"); PublicAdditionalLibraries.Add("ssl"); PublicAdditionalLibraries.Add("crypto"); PublicAdditionalLibraries.Add("websockets"); PublicAdditionalLibraries.Add("zstd"); } else if (Target.Platform == UnrealTargetPlatform.IOS) { PublicDefinitions.Add("WITH_HOT_RELOAD=0"); PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include", "iOS")); LibPath += "lib/iOS"; PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcurl.a")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.a")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.a")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.a")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libwebsockets.a")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libzstd.a")); } else if (Target.Platform == UnrealTargetPlatform.PS4) { PublicDefinitions.Add("FUNAPI_UE4_PLATFORM_PS4=1"); PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include", "PS4")); LibPath += "lib/PS4"; PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.a")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libzstd_static.a")); PublicDependencyModuleNames.AddRange(new string[] { "WebSockets" }); AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenSSL", "libWebSockets"); } else if (Target.Platform == UnrealTargetPlatform.Linux) { PublicDefinitions.Add("FUNAPI_UE4_PLATFORM_LINUX=1"); AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenSSL", "libWebSockets", "libcurl"); } }
public CGAL(ReadOnlyTargetRules Target) : base(Target) { bEnableUndefinedIdentifierWarnings = false; PublicDefinitions.Add("WIN32"); PublicDefinitions.Add("_WINDOWS"); PublicDefinitions.Add("_CRT_SECURE_NO_DEPRECATE"); PublicDefinitions.Add("_SCL_SECURE_NO_DEPRECATE"); PublicDefinitions.Add("_CRT_SECURE_NO_WARNINGS"); PublicDefinitions.Add("_SCL_SECURE_NO_WARNINGS"); PublicDefinitions.Add("CGAL_USE_MPFR"); PublicDefinitions.Add("CGAL_USE_GMP"); // Startard Module Dependencies PublicDependencyModuleNames.AddRange(new string[] { "Core" }); PrivateDependencyModuleNames.AddRange(new string[] { "CoreUObject", "Engine", "Slate", "SlateCore" }); // Start CGAL linking here! bool isLibrarySupported = false; // Create CGAL Path string CGALPath = Path.Combine(ThirdPartyPath, "CGAL"); // Get Library Path string LibPath = ""; bool isdebug = Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT; if (Target.Platform == UnrealTargetPlatform.Win64) { LibPath = Path.Combine(CGALPath, "libraries", "Win64"); isLibrarySupported = true; } else { string Err = string.Format("{0} dedicated server is made to depend on {1}. We want to avoid this, please correct module dependencies.", Target.Platform.ToString(), this.ToString()); System.Console.WriteLine(Err); } if (isLibrarySupported) { //Add Include path PublicIncludePaths.AddRange(new string[] { Path.Combine(CGALPath, "includes") }); PublicIncludePaths.AddRange(new string[] { Path.Combine(CGALPath, "includes", "GMP") });//Dependencie // Add Library Path PublicLibraryPaths.Add(LibPath); // Add Dependencies if (!isdebug) { //Add Static Libraries PublicAdditionalLibraries.Add(Path.Combine("libgmp-10.lib")); PublicAdditionalLibraries.Add(Path.Combine("libmpfr-4.lib")); PublicAdditionalLibraries.Add(Path.Combine("libCGAL-vc140-mt-4.9.lib")); PublicAdditionalLibraries.Add(Path.Combine("libCGAL_Core-vc140-mt-4.9.lib")); } else { //Add Static Libraries (Debug Version) PublicAdditionalLibraries.Add(Path.Combine("libgmp-10.lib")); PublicAdditionalLibraries.Add(Path.Combine("libmpfr-4.lib")); PublicAdditionalLibraries.Add(Path.Combine("libCGAL-vc140-mt-gd-4.9.lib")); PublicAdditionalLibraries.Add(Path.Combine("libCGAL_Core-vc140-mt-gd-4.9.lib")); } } PublicDefinitions.Add(string.Format("WITH_CGAL_BINDING={0}", isLibrarySupported ? 1 : 0)); }
public MeshModelingToolsEditorOnly(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", "InteractiveToolsFramework", "MeshDescription", "StaticMeshDescription", "GeometricObjects", "DynamicMesh", "MeshConversion", "MeshModelingTools", "ModelingComponents", "ModelingOperators", "ModelingOperatorsEditorOnly", "ProxyLODMeshReduction", // currently required to be public due to IVoxelBasedCSG API // ... add other public dependencies that you statically link with here ... "HairStrandsCore" // required for Hair toolset } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "RenderCore", "RHI", "InputCore", "MeshUtilities", // tangents calculation "UnrealEd", "MeshBuilder", "MeshUtilitiesCommon", "MeshReductionInterface", // for UE4 standard simplification "ProxyLODMeshReduction", // for mesh merging voxel-based csg //"Slate", //"SlateCore", // ... add private dependencies that you statically link with here ... } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); }
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", "SoundClassEditor", "ViewportSnapping", "SourceCodeAccess", "ReferenceViewer", "IntroTutorials", "SuperSearch", "OutputLog", "Landscape", "Niagara", "SizeMap", "LocalizationService", "HierarchicalLODUtilities", "MessagingRpc", "PortalRpc", "PortalServices", "BlueprintNativeCodeGen", } ); PublicDependencyModuleNames.AddRange( new string[] { "BspMode", "Core", "CoreUObject", "DirectoryWatcher", "Documentation", "Engine", "Json", "Projects", "SandboxFile", "Slate", "SlateCore", "EditorStyle", "SourceControl", "UnrealEdMessages", "AIModule", "GameplayDebugger", "BlueprintGraph", "Http", "UnrealAudio", "Niagara", "VectorVM", "FunctionalTesting" } ); PrivateDependencyModuleNames.AddRange( new string[] { "LevelSequence", "AnimGraph", "AppFramework", "BlueprintGraph", "OnlineSubsystem", "OnlineSubsystemUtils", "OnlineBlueprintSupport", "DesktopPlatform", "EditorStyle", "EngineSettings", "InputCore", "InputBindingEditor", "Internationalization", "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", "AnalyticsET", "PluginWarden" } ); 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", "GeometryMode", "TextureAlignMode", "FoliageEdit", "PackageDependencyInfo", "ImageWrapper", "Blutility", "IntroTutorials", "SuperSearch", "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) { DynamicallyLoadedModuleNames.Add("AndroidPlatformEditor"); } if (Target.Type == TargetRules.TargetType.Editor) { DynamicallyLoadedModuleNames.Add("SequenceRecorder"); PrivateIncludePathModuleNames.Add("SequenceRecorder"); } CircularlyReferencedDependentModules.AddRange( new string[] { "GraphEditor", "Kismet", } ); // Add include directory for Lightmass PublicIncludePaths.Add("Programs/UnrealLightmass/Public"); PublicIncludePathModuleNames.AddRange( new string[] { "UserFeedback", "CollectionManager", "BlueprintGraph", "NiagaraEditor", "Niagara", "VectorVM", "AddContentDialog", "MeshUtilities" } ); if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { PublicDependencyModuleNames.Add("XAudio2"); 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 GPGPUPlugin(ReadOnlyTargetRules Target) : base(Target) { bEnableUndefinedIdentifierWarnings = false; PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; PublicIncludePaths.AddRange( new string[] { Path.Combine(ThirdPartyDirectory, "Include") // ... 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[] { "CoreUObject", "Engine", "Slate", "SlateCore", "AssetTools", "ClassViewer", "UnrealEd" // ... add private dependencies that you statically link with here ... } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "Win64" : "Win32"; string OpenCLLibrariesPath = Path.Combine(ThirdPartyDirectory, "Lib"); string NvidiaLibrariesPath = Path.Combine(OpenCLLibrariesPath, "NVIDIA", PlatformString); string IntelLibrariesPath = Path.Combine(OpenCLLibrariesPath, "Intel", PlatformString); string AmdLibrariesPath = Path.Combine(OpenCLLibrariesPath, "AMD", PlatformString); string BoostLibrariesPath = Path.Combine(OpenCLLibrariesPath, "Boost"); if (Target.Platform == UnrealTargetPlatform.Win64) { string[] BoostLibs = Directory.GetFiles(BoostLibrariesPath, "*x64*.lib", SearchOption.AllDirectories); foreach (string boostLib in BoostLibs) { PublicAdditionalLibraries.Add(boostLib); } } else if (Target.Platform == UnrealTargetPlatform.Win32) { string[] BoostLibs = Directory.GetFiles(BoostLibrariesPath, "*x32*.lib", SearchOption.AllDirectories); foreach (string boostLib in BoostLibs) { PublicAdditionalLibraries.Add(boostLib); } } if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32) { PublicAdditionalLibraries.Add(Path.Combine(NvidiaLibrariesPath, "OpenCL.lib")); PublicAdditionalLibraries.Add(Path.Combine(IntelLibrariesPath, "OpenCL.lib")); PublicAdditionalLibraries.Add(Path.Combine(AmdLibrariesPath, "OpenCL.lib")); PublicAdditionalLibraries.Add(Path.Combine(NvidiaLibrariesPath, "cuda.lib")); PublicAdditionalLibraries.Add(Path.Combine(NvidiaLibrariesPath, "cudadevrt.lib")); PublicAdditionalLibraries.Add(Path.Combine(NvidiaLibrariesPath, "cudart.lib")); PublicAdditionalLibraries.Add(Path.Combine(NvidiaLibrariesPath, "cudart_static.lib")); PublicAdditionalLibraries.Add(Path.Combine(NvidiaLibrariesPath, "nvcuvid.lib")); } else if (Target.Platform == UnrealTargetPlatform.Mac) { PublicAdditionalFrameworks.Add(new UEBuildFramework("OpenCL")); } if (Target.Platform == UnrealTargetPlatform.Win64) { PublicAdditionalLibraries.Add(Path.Combine(NvidiaLibrariesPath, "nvrtc.lib")); } }
public celestialdemo(TargetInfo Target) { PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "RHI", "SkyboxShader", "ShaderCopyHelper" }); PrivateDependencyModuleNames.AddRange(new string[] { }); }
public Voxel(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; bEnforceIWYU = true; bLegacyPublicIncludePaths = false; #if UE_4_24_OR_LATER #else #endif PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public")); PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private")); // For raytracing PrivateIncludePaths.Add(EngineDirectory + "/Shaders/Shared"); // For HLSL translator PrivateIncludePaths.Add(EngineDirectory + "/Source/Runtime/Engine/Private"); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "Networking", "Sockets", "RHI", #if UE_4_23_OR_LATER "PhysicsCore", #endif "RenderCore", "Landscape", "PhysX", #if UE_4_26_OR_LATER "DeveloperSettings", "TraceLog", #endif } ); PrivateDependencyModuleNames.AddRange( new string[] { "nvTessLib", "HTTP", "Projects", "Slate", "SlateCore", //"VHACD", // Not used, too slow } ); SetupModulePhysicsSupport(Target); if (Target.Platform == UnrealTargetPlatform.Win64) { PrivateDependencyModuleNames.Add("ForsythTriOptimizer"); } PrivateDependencyModuleNames.Add("zlib"); if (Target.Configuration == UnrealTargetConfiguration.DebugGame || Target.Configuration == UnrealTargetConfiguration.Debug) { PublicDefinitions.Add("VOXEL_DEBUG=1"); } PublicDefinitions.Add("VOXEL_PLUGIN_NAME=TEXT(\"VoxelFree\")"); }
public Launch(TargetInfo Target) { PrivateIncludePaths.Add("Runtime/Launch/Private"); PrivateIncludePathModuleNames.AddRange( new string[] { "AutomationController", "OnlineSubsystem", "TaskGraph", } ); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "InputCore", "MediaAssets", "MoviePlayer", "Networking", "PakFile", "Projects", "RenderCore", "RHI", "SandboxFile", "Serialization", "ShaderCore", "Slate", "SlateCore", "Sockets", } ); if (Target.Type != TargetRules.TargetType.Server) { PrivateDependencyModuleNames.AddRange( new string[] { "HeadMountedDisplay", } ); if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64)) { DynamicallyLoadedModuleNames.Add("D3D11RHI"); DynamicallyLoadedModuleNames.Add("XAudio2"); } else if (Target.Platform == UnrealTargetPlatform.Mac) { DynamicallyLoadedModuleNames.Add("CoreAudio"); } else if (Target.Platform == UnrealTargetPlatform.Linux) { DynamicallyLoadedModuleNames.Add("ALAudio"); } PrivateIncludePathModuleNames.AddRange( new string[] { "SlateRHIRenderer", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "SlateRHIRenderer", "HeadMountedDisplay" } ); } // UFS clients are not available in shipping builds if (Target.Configuration != UnrealTargetConfiguration.Shipping) { PrivateDependencyModuleNames.AddRange( new string[] { "NetworkFile", "StreamingFile", "AutomationWorker", } ); } DynamicallyLoadedModuleNames.AddRange( new string[] { "Media", "Renderer", } ); if (UEBuildConfiguration.bCompileAgainstEngine) { PrivateIncludePathModuleNames.Add("Messaging"); PublicDependencyModuleNames.Add("SessionServices"); PrivateIncludePaths.Add("Developer/DerivedDataCache/Public"); // LaunchEngineLoop.cpp does a LoadModule() on OnlineSubsystem and OnlineSubsystemUtils when compiled WITH_ENGINE, so they must be marked as dependencies so that they get compiled and cleaned DynamicallyLoadedModuleNames.Add("OnlineSubsystem"); DynamicallyLoadedModuleNames.Add("OnlineSubsystemUtils"); } if (Target.Configuration != UnrealTargetConfiguration.Shipping) { PublicIncludePathModuleNames.Add("ProfilerService"); DynamicallyLoadedModuleNames.AddRange(new string[] { "TaskGraph", "RealtimeProfiler", "ProfilerService" }); } if (UEBuildConfiguration.bBuildEditor == true) { PublicIncludePathModuleNames.Add("ProfilerClient"); PrivateDependencyModuleNames.AddRange( new string[] { "SourceControl", "UnrealEd", "DesktopPlatform" } ); // ExtraModules that are loaded when WITH_EDITOR=1 is true DynamicallyLoadedModuleNames.AddRange( new string[] { "AutomationController", "AutomationWorker", "AutomationWindow", "ProfilerClient", "Toolbox", "GammaUI", "ModuleUI", "OutputLog", "TextureCompressor", "MeshUtilities", "SourceCodeAccess" } ); if (Target.Platform == UnrealTargetPlatform.Mac) { PrivateDependencyModuleNames.Add("MainFrame"); PrivateDependencyModuleNames.Add("Settings"); } else { DynamicallyLoadedModuleNames.Add("MainFrame"); } } if (Target.Platform == UnrealTargetPlatform.IOS) { PrivateDependencyModuleNames.Add("OpenGLDrv"); DynamicallyLoadedModuleNames.Add("IOSAudio"); DynamicallyLoadedModuleNames.Add("IOSRuntimeSettings"); PublicFrameworks.Add("OpenGLES"); // this is weak for IOS8 support for CAMetalLayer that is in QuartzCore PublicWeakFrameworks.Add("QuartzCore"); PrivateDependencyModuleNames.Add("LaunchDaemonMessages"); } if (Target.Platform == UnrealTargetPlatform.Android) { PrivateDependencyModuleNames.Add("OpenGLDrv"); PrivateDependencyModuleNames.Add("AndroidAudio"); DynamicallyLoadedModuleNames.Add("AndroidRuntimeSettings"); } if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Mac) || (Target.Platform == UnrealTargetPlatform.Linux && Target.Type != TargetRules.TargetType.Server)) { // TODO: re-enable after implementing resource tables for OpenGL. DynamicallyLoadedModuleNames.Add("OpenGLDrv"); } if (Target.Platform == UnrealTargetPlatform.HTML5) { PrivateDependencyModuleNames.Add("HTML5Audio"); if (Target.Architecture == "-win32") { PrivateDependencyModuleNames.Add("HTML5Win32"); PublicIncludePathModuleNames.Add("HTML5Win32"); } AddThirdPartyPrivateStaticDependencies(Target, "SDL2"); } // @todo ps4 clang bug: this works around a PS4/clang compiler bug (optimizations) if (Target.Platform == UnrealTargetPlatform.PS4) { bFasterWithoutUnity = true; } }
public TimeAttackRacer(TargetInfo Target) { PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "PhysXVehicles", "HeadMountedDisplay", "UMG" }); PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" }); }
public AlphaOmega(TargetInfo Target) { PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "UMG", "ProceduralMeshComponent" }); PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" }); }
public glTFForUE4Ed(TargetInfo Target) { PublicIncludePaths.AddRange( new string[] { "glTFForUE4Ed/Public" // ... add public include paths required here ... } ); PrivateIncludePaths.AddRange( new string[] { "glTFForUE4Ed/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", "Slate", "SlateCore", "InputCore", "RenderCore", "UnrealEd", "MainFrame", "Documentation", "PropertyEditor", "EditorStyle", "RawMesh", "glTFForUE4", // ... add private dependencies that you statically link with here ... } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); // libgltf string LibName = "libgltf"; string LibPathRoot = System.IO.Path.Combine(ModuleDirectory, "..", "..", "Extras", LibName); string LibPathInclude = System.IO.Path.Combine(LibPathRoot, "include"); PublicIncludePaths.Add(LibPathInclude); string LibPathBinary = System.IO.Path.Combine(LibPathRoot, "bin"); if (Target.Platform == UnrealTargetPlatform.Win64) { LibPathBinary = System.IO.Path.Combine(LibPathBinary, "win64"); if (Target.Configuration == UnrealTargetConfiguration.Debug || Target.Configuration == UnrealTargetConfiguration.DebugGame) { LibPathBinary = System.IO.Path.Combine(LibPathBinary, "Debug"); LibName = LibName + "d"; } else { LibPathBinary = System.IO.Path.Combine(LibPathBinary, "Release"); } LibName = LibName + ".lib"; } else if (Target.Platform == UnrealTargetPlatform.Mac) { LibPathBinary = System.IO.Path.Combine(LibPathBinary, "macos"); if (Target.Configuration == UnrealTargetConfiguration.Debug || Target.Configuration == UnrealTargetConfiguration.DebugGame) { LibPathBinary = System.IO.Path.Combine(LibPathBinary, "Debug"); LibName = LibName + "d"; } else { LibPathBinary = System.IO.Path.Combine(LibPathBinary, "Release"); } LibName = LibPathBinary + "/" + LibName + ".a"; } PublicLibraryPaths.Add(LibPathBinary); PublicAdditionalLibraries.Add(LibName); }
public Fuse(TargetInfo Target) { PublicIncludePaths.AddRange( new string[] { // ... add public include paths required here ... } ); PrivateIncludePaths.AddRange( new string[] { "Developer/Fuse/Private", // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "OnlineSubsystem" // ... 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 ... } ); PrivateIncludePathModuleNames.AddRange( new string[] { "Settings" } ); if (Target.Platform == UnrealTargetPlatform.IOS) { // required frameworks PublicFrameworks.AddRange( new string[] { "Accelerate", "AdSupport", "AudioToolbox", "AVFoundation", "CoreGraphics", "CoreLocation", "CoreMedia", "CoreTelephony", "EventKit", "EventKitUI", "Foundation", "GameKit", "MediaPlayer", "MessageUI", "MobileCoreServices", "QuartzCore", "Social", "StoreKit", "SystemConfiguration", "Twitter", "UIKit" } ); // required libs PublicAdditionalLibraries.Add("sqlite3"); PublicAdditionalLibraries.Add("xml2"); PublicAdditionalLibraries.Add("z"); // include Fuse SDK var CodeDir = Path.Combine(ModulePath, "..", "..", "lib", "FuseSDKiOS", "Code"); PrivateIncludePaths.Add(CodeDir); PublicAdditionalLibraries.Add(Path.Combine(CodeDir, "libFuseSDK.a")); // collect settings ConfigCacheIni Ini = new ConfigCacheIni(UnrealTargetPlatform.IOS, "Engine", UnrealBuildTool.GetUProjectPath()); bool bIncludeAdColony = false; bool bIncludeAppLovin = false; bool bIncludeHyprMX = false; bool bIncludeAdMob = false; bool bIncludeChartboost = false; bool bIncludeFacebook = false; bool bIncludeiAd = false; bool bIncludeMillennial = false; string SettingsPath = "/Script/Fuse.FuseSettings"; Ini.GetBool(SettingsPath, "bIncludeAdColony", out bIncludeAdColony); Ini.GetBool(SettingsPath, "bIncludeAppLovin", out bIncludeAppLovin); Ini.GetBool(SettingsPath, "bIncludeHyprMX", out bIncludeHyprMX); Ini.GetBool(SettingsPath, "bIncludeAdMob", out bIncludeAdMob); Ini.GetBool(SettingsPath, "bIncludeChartboost", out bIncludeChartboost); Ini.GetBool(SettingsPath, "bIncludeFacebook", out bIncludeFacebook); Ini.GetBool(SettingsPath, "bIncludeiAd", out bIncludeiAd); Ini.GetBool(SettingsPath, "bIncludeMillennial", out bIncludeMillennial); // include optional adapters if (bIncludeAdColony) { PublicAdditionalLibraries.Add(Path.Combine(CodeDir, "libFuseAdapterAdcolony.a")); } if (bIncludeAppLovin) { PublicAdditionalLibraries.Add(Path.Combine(CodeDir, "libFuseAdapterAppLovin.a")); } if (bIncludeHyprMX) { PublicAdditionalLibraries.Add(Path.Combine(CodeDir, "libFuseAdapterHyprMX.a")); } var FuseExtrasDir = Path.Combine(ModulePath, "..", "..", "lib", "FuseSDKiOS", "Extras"); var ExtrasiOSDir = "../../lib/Extras/iOS"; if (bIncludeAdMob) { PublicAdditionalLibraries.Add(Path.Combine(FuseExtrasDir, "AdMob", "libFuseAdapterAdMob.a")); PublicAdditionalFrameworks.Add( new UEBuildFramework( "GoogleMobileAds", ExtrasiOSDir + "/AdMob/GoogleMobileAds.embeddedframework.zip" ) ); } if (bIncludeChartboost) { PublicAdditionalLibraries.Add(Path.Combine(FuseExtrasDir, "ChartBoost", "libFuseAdapterChartBoost.a")); PublicAdditionalFrameworks.Add( new UEBuildFramework( "Chartboost", ExtrasiOSDir + "/Chartboost/Chartboost.embeddedframework.zip" ) ); } if (bIncludeFacebook) { PublicAdditionalLibraries.Add(Path.Combine(FuseExtrasDir, "Facebook", "libFuseAdapterFacebook.a")); PublicAdditionalFrameworks.Add( new UEBuildFramework( "FBAudienceNetwork", ExtrasiOSDir + "/Facebook/FBAudienceNetwork.embeddedframework.zip" ) ); } if (bIncludeiAd) { PublicAdditionalLibraries.Add(Path.Combine(FuseExtrasDir, "iAd", "libFuseAdapteriAd.a")); } if (bIncludeMillennial) { PublicAdditionalLibraries.Add(Path.Combine(FuseExtrasDir, "Millennial", "libFuseAdapterMillennial.a")); PublicAdditionalFrameworks.Add( new UEBuildFramework( "MillennialMedia", ExtrasiOSDir + "/Millennial/MillennialMedia.embeddedframework.zip" ) ); PublicAdditionalLibraries.Add(Path.Combine(FuseExtrasDir, "AdMob", "libFuseAdapterAdMob.a")); PublicAdditionalFrameworks.Add( new UEBuildFramework( "SpeechKit", ExtrasiOSDir + "/Millennial/SpeechKit.embeddedframework.zip" ) ); } } }
public Landscape(TargetInfo Target) { PrivateIncludePaths.AddRange( new string[] { "Runtime/Engine/Private", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "TargetPlatform", "DerivedDataCache", "ImageWrapper", "Foliage", } ); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "RenderCore", "RHI", "ShaderCore", "Renderer", "Foliage", } ); SetupModulePhysXAPEXSupport(Target); if (UEBuildConfiguration.bCompilePhysX && UEBuildConfiguration.bRuntimePhysicsCooking) { DynamicallyLoadedModuleNames.Add("PhysXFormats"); PrivateIncludePathModuleNames.Add("PhysXFormats"); } if (UEBuildConfiguration.bBuildDeveloperTools && Target.Type != TargetRules.TargetType.Server) { PrivateDependencyModuleNames.AddRange( new string[] { "RawMesh" } ); } if (UEBuildConfiguration.bBuildEditor == true) { PrivateDependencyModuleNames.AddRange( new string[] { "UnrealEd", "MaterialUtilities", "SlateCore", "Slate", } ); CircularlyReferencedDependentModules.AddRange( new string[] { "UnrealEd", "MaterialUtilities", } ); } }
public modio(ReadOnlyTargetRules Target) : base(Target) { PublicDefinitions.Add("JSON_NOEXCEPTION"); PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; // For beeing able to declare something public inside of the module, but private to outsiders PrivateDefinitions.Add("MODIO_PACKAGE=1"); PrivateDependencyModuleNames.AddRange(new string[] { }); #if UE_4_24_OR_LATER DefaultBuildSettings = BuildSettingsVersion.V2; #endif LoadModio(Target); // @todo: Can we disable exceptions again? bEnableExceptions = true; // Made sure to disable unity builds, as exclusion of some files causes the project to explode // this was we atleast get deterministic builds even if they are slower MinSourceFilesForUnityBuildOverride = 256; PublicIncludePaths.AddRange( new string[] { //"modio/Public" /*, * "Runtime/Core/Public/Modules/", * "Editor/UnrealEd/Classes/Factories", * "Editor/UnrealEd/Classes", * "C:/Users/antar/Documents/Unreal Projects/ModioContainer21/Plugins/modio/Intermediate/Build/Win64/UE4Editor/Inc/modio", * "C:/Program Files/Epic Games/UE_4.21/Engine/Intermediate/Build/Win64/UE4Editor/Inc/UnrealEd" */ // ... add public include paths required here ... } ); PrivateIncludePaths.AddRange( new string[] { //"modio/Private", // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "InputCore", "Projects", "Int64" // ... 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 ... } ); }
public TargetPlatform(ReadOnlyTargetRules Target) : base(Target) { PrivateDependencyModuleNames.Add("Core"); PublicDependencyModuleNames.Add("AudioPlatformConfiguration"); PublicDependencyModuleNames.Add("DesktopPlatform"); PublicDependencyModuleNames.Add("LauncherPlatform"); PrivateIncludePathModuleNames.Add("Engine"); // no need for all these modules if the program doesn't want developer tools at all (like UnrealFileServer) if (!Target.bBuildRequiresCookedData && Target.bBuildDeveloperTools) { // these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor DynamicallyLoadedModuleNames.Add("ShaderPreprocessor"); DynamicallyLoadedModuleNames.Add("ShaderFormatOpenGL"); DynamicallyLoadedModuleNames.Add("ImageWrapper"); if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { if (Target.bCompileLeanAndMeanUE == false) { DynamicallyLoadedModuleNames.Add("TextureFormatIntelISPCTexComp"); } } if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { // these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor DynamicallyLoadedModuleNames.Add("ShaderFormatD3D"); DynamicallyLoadedModuleNames.Add("MetalShaderFormat"); if (Target.bCompileLeanAndMeanUE == false) { DynamicallyLoadedModuleNames.Add("TextureFormatDXT"); DynamicallyLoadedModuleNames.Add("TextureFormatPVR"); DynamicallyLoadedModuleNames.Add("TextureFormatASTC"); } DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed"); if (Target.bCompileAgainstEngine) { DynamicallyLoadedModuleNames.Add("AudioFormatADPCM"); // For IOS cooking DynamicallyLoadedModuleNames.Add("AudioFormatOgg"); DynamicallyLoadedModuleNames.Add("AudioFormatOpus"); } if (Target.Type == TargetType.Editor || Target.Type == TargetType.Program) { DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform"); DynamicallyLoadedModuleNames.Add("IOSTargetPlatform"); DynamicallyLoadedModuleNames.Add("TVOSTargetPlatform"); DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform"); DynamicallyLoadedModuleNames.Add("MacTargetPlatform"); DynamicallyLoadedModuleNames.Add("MacNoEditorTargetPlatform"); DynamicallyLoadedModuleNames.Add("MacServerTargetPlatform"); DynamicallyLoadedModuleNames.Add("MacClientTargetPlatform"); } } else if (Target.Platform == UnrealTargetPlatform.Mac) { if (Target.bCompileLeanAndMeanUE == false) { DynamicallyLoadedModuleNames.Add("TextureFormatDXT"); DynamicallyLoadedModuleNames.Add("TextureFormatPVR"); DynamicallyLoadedModuleNames.Add("TextureFormatASTC"); } DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed"); if (Target.bCompileAgainstEngine) { DynamicallyLoadedModuleNames.Add("AudioFormatOgg"); DynamicallyLoadedModuleNames.Add("AudioFormatOpus"); } if (Target.Type == TargetType.Editor || Target.Type == TargetType.Program) { DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform"); DynamicallyLoadedModuleNames.Add("IOSTargetPlatform"); DynamicallyLoadedModuleNames.Add("TVOSTargetPlatform"); DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform"); } } else if (Target.Platform == UnrealTargetPlatform.Linux) { if (Target.bCompileLeanAndMeanUE == false) { DynamicallyLoadedModuleNames.Add("TextureFormatDXT"); DynamicallyLoadedModuleNames.Add("TextureFormatPVR"); DynamicallyLoadedModuleNames.Add("TextureFormatASTC"); } DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed"); if (Target.bCompileAgainstEngine) { DynamicallyLoadedModuleNames.Add("AudioFormatOgg"); DynamicallyLoadedModuleNames.Add("AudioFormatOpus"); } if (Target.Type == TargetType.Editor || Target.Type == TargetType.Program) { DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform"); DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform"); } } } if (Target.bBuildDeveloperTools == true && Target.bBuildRequiresCookedData && Target.bCompileAgainstEngine && Target.bCompilePhysX) { DynamicallyLoadedModuleNames.Add("PhysXCooking"); } }
public DlgSystem(ReadOnlyTargetRules Target) : base(Target) { // Enable IWYU // https://docs.unrealengine.com/latest/INT/Programming/UnrealBuildSystem/IWYUReferenceGuide/index.html // https://docs.unrealengine.com/latest/INT/Programming/UnrealBuildSystem/Configuration/ PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; bEnforceIWYU = true; //MinFilesUsingPrecompiledHeaderOverride = 1; //bFasterWithoutUnity = true; //PrivatePCHHeaderFile = "Private/DlgSystemPrivatePCH.h"; PublicIncludePaths.AddRange( new string[] { Path.Combine(ModuleDirectory, "Public") // ... add public include paths required here ... }); PrivateIncludePaths.AddRange( new string[] { Path.Combine(ModuleDirectory, "Private") // ... add other private include paths required here ... }); PublicDependencyModuleNames.AddRange( new string[] { "Core", "Json", "JsonUtilities" // ... add other public dependencies that you statically link with here ... }); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "Projects", // IPluginManager // UI "SlateCore", "Slate", "InputCore" // ... add private dependencies that you statically link with here ... }); // We need this dependency when the DlgSystem works in the editor mode/built with editor if (Target.bBuildEditor) { PrivateDependencyModuleNames.Add("UnrealEd"); // Accessing the menu PrivateDependencyModuleNames.Add("WorkspaceMenuStructure"); } // Add GameplayDebugger functionality if not 'Shipping' or 'Test' Target. 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"); } DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... }); }
public HoudiniEngineEditor(TargetInfo Target) { bool bIsRelease = true; string HFSPath = ""; string HoudiniVersion = "15.0.389"; // 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 (bIsRelease) { if (Target.Platform == UnrealTargetPlatform.Win64) { // We first check if Houdini Engine is installed. string HPath = "C:/Program Files/Side Effects Software/Houdini Engine " + HoudiniVersion; if (!Directory.Exists(HPath)) { // If Houdini Engine is not installed, we check for Houdini installation. HPath = "C:/Program Files/Side Effects Software/Houdini " + HoudiniVersion; if (!Directory.Exists(HPath)) { if (!Directory.Exists(HFSPath)) { string Err = string.Format("Houdini Engine : Please install Houdini or Houdini Engine {0}", HoudiniVersion); System.Console.WriteLine(Err); } } else { HFSPath = HPath; } } else { HFSPath = HPath; } } else if (Target.Platform == UnrealTargetPlatform.Mac) { string HPath = "/Library/Frameworks/Houdini.framework/Versions/" + HoudiniVersion + "/Resources"; if (!Directory.Exists(HPath)) { if (!Directory.Exists(HFSPath)) { string Err = string.Format("Houdini Engine : Please install Houdini {0}", HoudiniVersion); System.Console.WriteLine(Err); } } else { HFSPath = HPath; } } } string HAPIIncludePath = ""; if (HFSPath != "") { HAPIIncludePath = HFSPath + "/toolkit/include/HAPI"; if (Target.Platform == UnrealTargetPlatform.Win64) { Definitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath); } } if (HAPIIncludePath != "") { PublicIncludePaths.Add(HAPIIncludePath); } PublicIncludePaths.AddRange( new string[] { "HoudiniEngineRuntime/Public/HAPI", "HoudiniEngineRuntime/Public", "HoudiniEngineEditor/Public" } ); PrivateIncludePaths.AddRange( new string[] { "HoudiniEngineEditor/Private", "HoudiniEngineRuntime/Private" } ); // 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 VaRestEditorPlugin(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; PublicIncludePaths.AddRange( new string[] { "VaRestPlugin", "VaRestPlugin/Public" // ... add public include paths required here ... }); PrivateIncludePaths.AddRange( new string[] { "VaRestEditorPlugin/Private", // ... add other private include paths required here ... }); PublicDependencyModuleNames.AddRange( new string[] { "Core", "VaRestPlugin" // ... add other public dependencies that you statically link with here ... }); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "Slate", "SlateCore", "InputCore", "AssetTools", "UnrealEd", // for FAssetEditorManager "KismetWidgets", "KismetCompiler", "BlueprintGraph", "GraphEditor", "Kismet", // for FWorkflowCentricApplication "PropertyEditor", "EditorStyle", "Sequencer", "DetailCustomizations", "Settings", "RenderCore" }); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... }); }
public FriendsAndChat(TargetInfo Target) { PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "InputCore", "Slate", "OnlineSubsystem" } ); PrivateDependencyModuleNames.AddRange( new string[] { "SlateCore", "Sockets", "OnlineSubsystem" } ); PrivateIncludePaths.AddRange( new string[] { "Developer/FriendsAndChat/Private", "Developer/FriendsAndChat/Private/UI/Widgets", "Developer/FriendsAndChat/Private/Models", "Developer/FriendsAndChat/Private/Core", } ); PublicIncludePaths.AddRange( new string[] { "Developer/FriendsAndChat/Public/Models", "Developer/FriendsAndChat/Public/Interfaces" } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "HTTP", "Analytics", "AnalyticsET", "EditorStyle", "OnlineSubsystem" } ); PrivateIncludePathModuleNames.AddRange( new string[] { "HTTP", "Analytics", "AnalyticsET", "EditorStyle", } ); if (UEBuildConfiguration.bCompileMcpOSS == true) { PublicDependencyModuleNames.AddRange( new string[] { "OnlineSubsystemMcp", } ); PrivateDependencyModuleNames.AddRange( new string[] { "OnlineSubsystemMcp", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "OnlineSubsystemMcp", } ); } }
public AdvancePakSSL(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; string OpenSSL101sPath = Path.Combine(Target.UEThirdPartySourceDirectory, "OpenSSL", "1_0_1s"); string OpenSSL111Path = Path.Combine(Target.UEThirdPartySourceDirectory, "OpenSSL", "1.1.1"); string OpenSSL111dPath = Path.Combine(Target.UEThirdPartySourceDirectory, "OpenSSL", "1.1.1c"); string PlatformSubdir = Target.Platform.ToString(); string ConfigFolder = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ? "Debug" : "Release"; if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.IOS) { PublicIncludePaths.Add(Path.Combine(OpenSSL111Path, "Include", PlatformSubdir)); string LibPath = Path.Combine(OpenSSL111Path, "Lib", PlatformSubdir); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.a")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.a")); } else if (Target.Platform == UnrealTargetPlatform.PS4) { string IncludePath = Target.UEThirdPartySourceDirectory + "OpenSSL/1.0.2g" + "/" + "include/PS4"; string LibraryPath = Target.UEThirdPartySourceDirectory + "OpenSSL/1.0.2g" + "/" + "lib/PS4/Release"; PublicIncludePaths.Add(IncludePath); PublicAdditionalLibraries.Add(LibraryPath + "/" + "libssl.a"); PublicAdditionalLibraries.Add(LibraryPath + "/" + "libcrypto.a"); } else if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.HoloLens) { // Our OpenSSL 1.1.1 libraries are built with zlib compression support PrivateDependencyModuleNames.Add("zlib"); string VSVersion = "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(); // Add includes PublicIncludePaths.Add(Path.Combine(OpenSSL111Path, "include", PlatformSubdir, VSVersion)); // Add Libs string LibPath = Path.Combine(OpenSSL111Path, "lib", PlatformSubdir, VSVersion, ConfigFolder); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.lib")); PublicSystemLibraries.Add("crypt32.lib"); } else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix)) { string platform = "/Linux/" + Target.Architecture; string IncludePath = OpenSSL111dPath + "/include" + platform; string LibraryPath = OpenSSL111dPath + "/lib" + platform; PublicIncludePaths.Add(IncludePath); PublicAdditionalLibraries.Add(LibraryPath + "/libssl.a"); PublicAdditionalLibraries.Add(LibraryPath + "/libcrypto.a"); PublicDependencyModuleNames.Add("zlib"); // PublicAdditionalLibraries.Add("z"); } else if (Target.Platform == UnrealTargetPlatform.Android || Target.Platform == UnrealTargetPlatform.Lumin) { string IncludePath = OpenSSL101sPath + "/include/Android"; PublicIncludePaths.Add(IncludePath); // unneeded since included in libcurl // string LibPath = Path.Combine(OpenSSL101sPath, "lib", PlatformSubdir); //PublicLibraryPaths.Add(LibPath); } }
public USDImporter(ReadOnlyTargetRules Target) : base(Target) { // We require the whole editor to be RTTI enabled on Linux for now if (Target.Platform != UnrealTargetPlatform.Linux) { bUseRTTI = true; } PrivateDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "JsonUtilities", "UnrealEd", "InputCore", "SlateCore", "PropertyEditor", "Slate", "EditorStyle", "RawMesh", "GeometryCache", "MeshDescription", "MeshUtilities", "MessageLog", "PythonScriptPlugin", "RenderCore", "RHI", "StaticMeshDescription", "UnrealUSDWrapper", "USDUtilities", } ); // Always use the official version of IntelTBB string IntelTBBLibs = Target.UEThirdPartySourceDirectory + "IntelTBB/IntelTBB-2019u8/lib/"; if (Target.Platform == UnrealTargetPlatform.Win64) { PrivateDependencyModuleNames.Add("UnrealUSDWrapper"); foreach (string FilePath in Directory.EnumerateFiles(Path.Combine(ModuleDirectory, "../../Binaries/Win64/"), "*.dll", SearchOption.AllDirectories)) { RuntimeDependencies.Add(FilePath); } RuntimeDependencies.Add(IntelTBBLibs + "Win64/vc14/tbb.dll"); } else if (Target.Platform == UnrealTargetPlatform.Linux && Target.Architecture.StartsWith("x86_64")) { PrivateDependencyModuleNames.Add("UnrealUSDWrapper"); // link directly to runtime libs on Linux, as this also puts them into rpath string RuntimeLibraryPath = Path.Combine(ModuleDirectory, "../../Binaries", Target.Platform.ToString(), Target.Architecture.ToString()); PrivateRuntimeLibraryPaths.Add(RuntimeLibraryPath); RuntimeDependencies.Add(IntelTBBLibs + "Linux/libtbb.so"); RuntimeDependencies.Add(IntelTBBLibs + "Linux/libtbb.so.2"); RuntimeDependencies.Add(IntelTBBLibs + "Linux/libtbbmalloc.so"); RuntimeDependencies.Add(IntelTBBLibs + "Linux/libtbbmalloc.so.2"); foreach (string FilePath in Directory.EnumerateFiles(RuntimeLibraryPath, "*.so*", SearchOption.AllDirectories)) { RuntimeDependencies.Add(FilePath); } } }
public FMODStudio(TargetInfo Target) #endif { PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; PrivatePCHHeaderFile = "Private/FMODStudioPrivatePCH.h"; bFasterWithoutUnity = true; PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public/FMOD")); PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Classes")); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "Media", "Projects" } ); PrivateDependencyModuleNames.AddRange( new string[] { "MovieScene", "MovieSceneTracks" } ); if (Target.bBuildEditor == true) { PrivateDependencyModuleNames.Add("AssetRegistry"); PrivateDependencyModuleNames.Add("UnrealEd"); PrivateDependencyModuleNames.Add("Settings"); } DynamicallyLoadedModuleNames.AddRange( new string[] { } ); string configName = ""; if (Target.Configuration != UnrealTargetConfiguration.Shipping) { configName = "L"; PublicDefinitions.Add("FMODSTUDIO_LINK_LOGGING=1"); } else { configName = ""; PublicDefinitions.Add("FMODSTUDIO_LINK_RELEASE=1"); } string platformName = Target.Platform.ToString(); string linkExtension = ""; string dllExtension = ""; string libPrefix = ""; // ModuleDirectory points to FMODStudio\source\FMODStudio, need to get back to binaries directory for our libs string BasePath = System.IO.Path.Combine(ModuleDirectory, "../../Binaries", platformName); // Collapse the directory path, otherwise OSX is having issues with plugin paths. BasePath = Utils.CleanDirectorySeparators(BasePath); string copyThirdPartyPath = ""; bool bAddRuntimeDependencies = true; bool bAddDelayLoad = false; bool bShortLinkNames = false; bool bLinkFromBinaries = true; // Minimum UE version for Switch 4.15 System.Console.WriteLine("Target Platform -- " + Target.Platform.ToString()); if (Target.Platform == UnrealTargetPlatform.Switch) { linkExtension = ".a"; dllExtension = ".a"; libPrefix = "lib"; bAddRuntimeDependencies = false; } else if (Target.Platform.ToString() == "UWP64") { linkExtension = ".lib"; dllExtension = ".dll"; bAddDelayLoad = true; } else if (Target.Platform == UnrealTargetPlatform.Win32) { linkExtension = "_vc.lib"; dllExtension = ".dll"; bAddDelayLoad = true; } else if (Target.Platform == UnrealTargetPlatform.Win64) { linkExtension = "_vc.lib"; dllExtension = ".dll"; bAddDelayLoad = true; } else if (Target.Platform == UnrealTargetPlatform.Mac) { linkExtension = dllExtension = ".dylib"; libPrefix = "lib"; bLinkFromBinaries = false; } else if (Target.Platform == UnrealTargetPlatform.XboxOne) { linkExtension = "_vc.lib"; dllExtension = ".dll"; copyThirdPartyPath = "../XBoxOne"; // XBoxOne still doesn't seem to support plugins with .dlls bAddDelayLoad = false; } else if (Target.Platform == UnrealTargetPlatform.PS4) { linkExtension = "_stub.a"; dllExtension = ".prx"; libPrefix = "lib"; bAddDelayLoad = true; } else if (Target.Platform == UnrealTargetPlatform.Android) { // Don't use an explicit path with the .so, let the architecture dirs be filtered by UBT PublicLibraryPaths.Add(System.IO.Path.Combine(BasePath, "armeabi-v7a")); PublicLibraryPaths.Add(System.IO.Path.Combine(BasePath, "arm64-v8a")); PublicLibraryPaths.Add(System.IO.Path.Combine(BasePath, "x86")); bAddRuntimeDependencies = false; // Don't use this system bShortLinkNames = true; // strip off lib and .so linkExtension = dllExtension = ".so"; libPrefix = "lib"; } else if (Target.Platform == UnrealTargetPlatform.IOS) { linkExtension = "_iphoneos.a"; libPrefix = "lib"; bAddRuntimeDependencies = false; } else if (Target.Platform == UnrealTargetPlatform.TVOS) { linkExtension = "_appletvos.a"; libPrefix = "lib"; bAddRuntimeDependencies = false; } else if (Target.Platform == UnrealTargetPlatform.Linux) { BasePath = System.IO.Path.Combine(BasePath, "x86_64"); linkExtension = ".so"; dllExtension = ".so"; libPrefix = "lib"; } else if (Target.Platform.ToString() == "Stadia") { linkExtension = ".so"; dllExtension = ".so"; libPrefix = "lib"; } else { //extName = ".a"; throw new System.Exception(System.String.Format("Unsupported platform {0}", Target.Platform.ToString())); //break; } //System.Console.WriteLine("FMOD Current path: " + System.IO.Path.GetFullPath(".")); //System.Console.WriteLine("FMOD Base path: " + BasePath); PublicLibraryPaths.Add(BasePath); string fmodLibName = System.String.Format("{0}fmod{1}{2}", libPrefix, configName, linkExtension); string fmodStudioLibName = System.String.Format("{0}fmodstudio{1}{2}", libPrefix, configName, linkExtension); string fmodDllName = System.String.Format("{0}fmod{1}{2}", libPrefix, configName, dllExtension); string fmodStudioDllName = System.String.Format("{0}fmodstudio{1}{2}", libPrefix, configName, dllExtension); string fmodLibPath = System.IO.Path.Combine(BasePath, fmodLibName); string fmodStudioLibPath = System.IO.Path.Combine(BasePath, fmodStudioLibName); string fmodDllPath = System.IO.Path.Combine(BasePath, fmodDllName); string fmodStudioDllPath = System.IO.Path.Combine(BasePath, fmodStudioDllName); System.Collections.Generic.List <string> plugins = GetPlugins(BasePath); if (bShortLinkNames) { // For android we have provided the paths to all architectures above // Just provide the name without "lib" and without extension PublicAdditionalLibraries.Add(System.String.Format("fmod{0}", configName)); PublicAdditionalLibraries.Add(System.String.Format("fmodstudio{0}", configName)); } else if (bLinkFromBinaries) { PublicAdditionalLibraries.Add(fmodLibPath); PublicAdditionalLibraries.Add(fmodStudioLibPath); } else { string LibPath = System.IO.Path.Combine(ModuleDirectory, "../../Libs/Mac/"); PublicAdditionalLibraries.Add(System.String.Format("{0}libfmod{1}.dylib", LibPath, configName)); PublicAdditionalLibraries.Add(System.String.Format("{0}libfmodStudio{1}.dylib", LibPath, configName)); } if (bAddRuntimeDependencies) { RuntimeDependencies.Add(fmodDllPath); RuntimeDependencies.Add(fmodStudioDllPath); foreach (string plugin in plugins) { string pluginPath = System.IO.Path.Combine(BasePath, plugin + dllExtension); System.Console.WriteLine("Adding reference to FMOD plugin: " + pluginPath); RuntimeDependencies.Add(pluginPath); } } if (copyThirdPartyPath.Length != 0) { string destPath = System.IO.Path.Combine(Target.UEThirdPartyBinariesDirectory, copyThirdPartyPath); System.IO.Directory.CreateDirectory(destPath); string fmodDllDest = System.IO.Path.Combine(destPath, fmodDllName); string fmodStudioDllDest = System.IO.Path.Combine(destPath, fmodStudioDllName); CopyFile(fmodDllPath, fmodDllDest); CopyFile(fmodStudioDllPath, fmodStudioDllDest); } if (bAddDelayLoad) { PublicDelayLoadDLLs.AddRange( new string[] { fmodDllName, fmodStudioDllName } ); } if (Target.Platform == UnrealTargetPlatform.Android) { string APLName = System.String.Format("FMODStudio{0}_APL.xml", configName); string RelAPLPath = Utils.MakePathRelativeTo(System.IO.Path.Combine(ModuleDirectory, APLName), Target.RelativeEnginePath); System.Console.WriteLine("Adding {0}", RelAPLPath); AdditionalPropertiesForReceipt.Add("AndroidPlugin", RelAPLPath); foreach (string PluginName in System.IO.Directory.GetFiles(BasePath)) { if (PluginName.EndsWith("_APL.xml", System.StringComparison.OrdinalIgnoreCase)) { string RelPluginPath = Utils.MakePathRelativeTo(PluginName, Target.RelativeEnginePath); System.Console.WriteLine("Adding {0}", RelPluginPath); AdditionalPropertiesForReceipt.Add("AndroidPlugin", RelPluginPath); } } } }
public HotPatcherEditor(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", "Json", "TargetPlatform", "PropertyEditor", "AssetManagerEx", "PakFileUtilities" // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "Projects", "DesktopPlatform", "InputCore", "UnrealEd", "EditorStyle", "LevelEditor", "CoreUObject", "Engine", "Slate", "SlateCore", "HotPatcherRuntime" // ... add private dependencies that you statically link with here ... } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); OptimizeCode = CodeOptimization.InShippingBuildsOnly; }
public TargetPlatform(TargetInfo Target) { PrivateDependencyModuleNames.Add("Core"); PublicDependencyModuleNames.Add("DesktopPlatform"); PrivateIncludePathModuleNames.Add("PhysXFormats"); // no need for all these modules if the program doesn't want developer tools at all (like UnrealFileServer) if (!UEBuildConfiguration.bBuildRequiresCookedData && UEBuildConfiguration.bBuildDeveloperTools) { // these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor DynamicallyLoadedModuleNames.Add("ShaderPreprocessor"); DynamicallyLoadedModuleNames.Add("ShaderFormatOpenGL"); DynamicallyLoadedModuleNames.Add("ImageWrapper"); if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { if (UEBuildConfiguration.bCompileLeanAndMeanUE == false) { DynamicallyLoadedModuleNames.Add("TextureFormatIntelISPCTexComp"); } } if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")) { // these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor DynamicallyLoadedModuleNames.Add("ShaderFormatD3D"); if (UEBuildConfiguration.bCompileLeanAndMeanUE == false) { DynamicallyLoadedModuleNames.Add("TextureFormatDXT"); DynamicallyLoadedModuleNames.Add("TextureFormatPVR"); DynamicallyLoadedModuleNames.Add("TextureFormatASTC"); } DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed"); if (UEBuildConfiguration.bCompileAgainstEngine) { DynamicallyLoadedModuleNames.Add("AudioFormatADPCM"); // For IOS cooking DynamicallyLoadedModuleNames.Add("AudioFormatOgg"); DynamicallyLoadedModuleNames.Add("AudioFormatOpus"); } if (Target.Type == TargetRules.TargetType.Editor || Target.Type == TargetRules.TargetType.Program) { DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform"); DynamicallyLoadedModuleNames.Add("Android_PVRTCTargetPlatform"); DynamicallyLoadedModuleNames.Add("Android_ATCTargetPlatform"); DynamicallyLoadedModuleNames.Add("Android_DXTTargetPlatform"); DynamicallyLoadedModuleNames.Add("Android_ETC1TargetPlatform"); DynamicallyLoadedModuleNames.Add("Android_ETC2TargetPlatform"); DynamicallyLoadedModuleNames.Add("Android_ASTCTargetPlatform"); DynamicallyLoadedModuleNames.Add("Android_MultiTargetPlatform"); DynamicallyLoadedModuleNames.Add("IOSTargetPlatform"); DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform"); } } else if (Target.Platform == UnrealTargetPlatform.Mac) { if (UEBuildConfiguration.bCompileLeanAndMeanUE == false) { DynamicallyLoadedModuleNames.Add("TextureFormatDXT"); DynamicallyLoadedModuleNames.Add("TextureFormatPVR"); DynamicallyLoadedModuleNames.Add("TextureFormatASTC"); } DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed"); if (UEBuildConfiguration.bCompileAgainstEngine) { DynamicallyLoadedModuleNames.Add("AudioFormatOgg"); DynamicallyLoadedModuleNames.Add("AudioFormatOpus"); } if (Target.Type == TargetRules.TargetType.Editor || Target.Type == TargetRules.TargetType.Program) { DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform"); DynamicallyLoadedModuleNames.Add("Android_MultiTargetPlatform"); DynamicallyLoadedModuleNames.Add("Android_PVRTCTargetPlatform"); DynamicallyLoadedModuleNames.Add("Android_ATCTargetPlatform"); DynamicallyLoadedModuleNames.Add("Android_DXTTargetPlatform"); DynamicallyLoadedModuleNames.Add("Android_ETC1TargetPlatform"); DynamicallyLoadedModuleNames.Add("Android_ETC2TargetPlatform"); DynamicallyLoadedModuleNames.Add("IOSTargetPlatform"); DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform"); } } else if (Target.Platform == UnrealTargetPlatform.Linux) { if (UEBuildConfiguration.bCompileLeanAndMeanUE == false) { DynamicallyLoadedModuleNames.Add("TextureFormatDXT"); DynamicallyLoadedModuleNames.Add("TextureFormatPVR"); DynamicallyLoadedModuleNames.Add("TextureFormatASTC"); } DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed"); if (UEBuildConfiguration.bCompileAgainstEngine) { DynamicallyLoadedModuleNames.Add("AudioFormatOgg"); DynamicallyLoadedModuleNames.Add("AudioFormatOpus"); } } } if (UEBuildConfiguration.bBuildDeveloperTools == true && (UEBuildConfiguration.bBuildRequiresCookedData || UEBuildConfiguration.bRuntimePhysicsCooking) && UEBuildConfiguration.bCompileAgainstEngine && UEBuildConfiguration.bCompilePhysX) { DynamicallyLoadedModuleNames.Add("PhysXFormats"); } }
public Sequencer(ReadOnlyTargetRules Target) : base(Target) { PrivateIncludePaths.AddRange( new string[] { "Editor/Sequencer/Private", "Editor/Sequencer/Private/DisplayNodes", "Editor/UnrealEd/Private" // TODO: Fix this, for now it's needed for the fbx exporter } ); PrivateDependencyModuleNames.AddRange( new string[] { "AppFramework", "ApplicationCore", "CinematicCamera", "Core", "CoreUObject", "InputCore", "Engine", "Slate", "SlateCore", "EditorStyle", "UnrealEd", "MovieScene", "MovieSceneTracks", "MovieSceneTools", "MovieSceneCapture", "MovieSceneCaptureDialog", "EditorWidgets", "SequencerWidgets", "BlueprintGraph", "LevelSequence", "GraphEditor", "ViewportInteraction" } ); CircularlyReferencedDependentModules.AddRange( new string[] { "ViewportInteraction", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "ContentBrowser", "PropertyEditor", "Kismet", "SequenceRecorder", "LevelEditor", "MainFrame", "DesktopPlatform" } ); PublicIncludePathModuleNames.AddRange( new string[] { "PropertyEditor", "SceneOutliner", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "PropertyEditor", "LevelEditor", "SceneOutliner", "WorkspaceMenuStructure", "SequenceRecorder", "SequenceRecorderSections", "MainFrame", } ); CircularlyReferencedDependentModules.Add("MovieSceneTools"); AddEngineThirdPartyPrivateStaticDependencies(Target, "FBX"); }
public MainFrame(ReadOnlyTargetRules Target) : base(Target) { PublicDependencyModuleNames.AddRange( new string[] { "Documentation", } ); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "ApplicationCore", "Engine", "EngineSettings", "InputCore", "RHI", "RenderCore", "Slate", "SlateCore", "EditorStyle", "SourceControl", "SourceControlWindows", "TargetPlatform", "DesktopPlatform", "UnrealEd", "WorkspaceMenuStructure", "MessageLog", "UATHelper", "TranslationEditor", "Projects", "DeviceProfileEditor", "UndoHistory", "Analytics", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "AssetTools", "DesktopPlatform", "GameProjectGeneration", "ProjectTargetPlatformEditor", "LevelEditor", "OutputLog", "Settings", "SourceCodeAccess", "Toolbox", "LocalizationDashboard", } ); PrivateIncludePaths.AddRange( new string[] { "Editor/MainFrame/Private", "Editor/MainFrame/Private/Frame", "Editor/MainFrame/Private/Menus", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "AssetTools", "GameProjectGeneration", "ProjectTargetPlatformEditor", "LevelEditor", "OutputLog", "SourceCodeAccess", "HotReload", "LocalizationDashboard", } ); }
public MicrosoftOpenXR(ReadOnlyTargetRules Target) : base(Target) { if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens) { // these parameters mandatory for winrt support bEnableExceptions = true; bUseUnity = false; CppStandard = CppStandardVersion.Cpp17; PublicSystemLibraries.AddRange(new string[] { "shlwapi.lib", "runtimeobject.lib" }); } PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; PrivatePCHHeaderFile = @"Private\OpenXRCommon.h"; PrivateIncludePaths.AddRange( new string[] { // This private include path ensures our newer copy of the openxr headers take precedence over the engine's copy. "MicrosoftOpenXR/Private/External" } ); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "ApplicationCore", "Engine", "Slate", "SlateCore", "InputCore", "OpenXRHMD", "MicrosoftOpenXRRuntimeSettings", "HeadMountedDisplay", "AugmentedReality", "OpenXRAR", "RHI", "RenderCore", "Projects", "NuGetModule" } ); PublicDependencyModuleNames.AddRange( new string[] { "NuGetModule" } ); if (Target.bBuildEditor) { PrivateDependencyModuleNames.AddRange( new string[] { "UnrealEd" } ); } PrivateIncludePathModuleNames.AddRange( new string[] { "HeadMountedDisplay", "NuGetModule" } ); PublicIncludePathModuleNames.AddRange( new string[] { "HeadMountedDisplay", "NuGetModule" } ); // DX-specific code for webcam texture processing if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens) { PrivateDependencyModuleNames.AddRange(new string[] { "D3D11RHI", "D3D12RHI" }); var EngineDir = Path.GetFullPath(Target.RelativeEnginePath); PrivateIncludePaths.AddRange( new string[] { Path.Combine(EngineDir, @"Source\Runtime\Windows\D3D11RHI\Private"), Path.Combine(EngineDir, @"Source\Runtime\Windows\D3D11RHI\Private\Windows"), Path.Combine(EngineDir, @"Source\Runtime\D3D12RHI\Private"), Path.Combine(EngineDir, @"Source\Runtime\D3D12RHI\Private\Windows") }); AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11"); AddEngineThirdPartyPrivateStaticDependencies(Target, "DX12"); AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAPI"); AddEngineThirdPartyPrivateStaticDependencies(Target, "AMD_AGS"); AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAftermath"); AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelMetricsDiscovery"); AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelExtensionsFramework"); } }
public VulkanRHI(ReadOnlyTargetRules Target) : base(Target) { bOutputPubliclyDistributable = true; PrivateIncludePaths.Add("Runtime/VulkanRHI/Private"); if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { PrivateIncludePaths.Add("Runtime/VulkanRHI/Private/Windows"); } else { PrivateIncludePaths.Add("Runtime/VulkanRHI/Private/" + Target.Platform); } PrivateDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "RHI", "RenderCore", "ShaderCore", "UtilityShaders", "HeadMountedDisplay", } ); if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Android || Target.Platform == UnrealTargetPlatform.Lumin) { AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan"); } else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix)) { if (Target.Platform == UnrealTargetPlatform.Linux) { AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2"); string VulkanSDKPath = Environment.GetEnvironmentVariable("VULKAN_SDK"); bool bSDKInstalled = !String.IsNullOrEmpty(VulkanSDKPath); if (BuildHostPlatform.Current.Platform != UnrealTargetPlatform.Linux || !bSDKInstalled) { AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan"); } else { PrivateIncludePaths.Add(VulkanSDKPath + "/include"); PrivateIncludePaths.Add(VulkanSDKPath + "/include/vulkan"); PublicLibraryPaths.Add(VulkanSDKPath + "/lib"); PublicAdditionalLibraries.Add("vulkan"); } } else { AddEngineThirdPartyPrivateStaticDependencies(Target, "VkHeadersExternal"); } } else if (Target.Platform == UnrealTargetPlatform.Mac) { string VulkanSDKPath = Environment.GetEnvironmentVariable("VULKAN_SDK"); bool bHaveVulkan = false; if (!String.IsNullOrEmpty(VulkanSDKPath)) { bHaveVulkan = true; PrivateIncludePaths.Add(VulkanSDKPath + "/Include"); } if (bHaveVulkan) { if (Target.Configuration != UnrealTargetConfiguration.Shipping) { PrivateIncludePathModuleNames.AddRange( new string[] { "TaskGraph", } ); } } else { PrecompileForTargets = PrecompileTargetsType.None; } } else { PrecompileForTargets = PrecompileTargetsType.None; } }
public SandboxFile(TargetInfo Target) { PrivateDependencyModuleNames.Add("Core"); }
public TranslationEditor(TargetInfo Target) { PublicIncludePathModuleNames.Add("LevelEditor"); PublicIncludePathModuleNames.Add("WorkspaceMenuStructure"); PrivateIncludePathModuleNames.Add("LocalizationService"); PrivateIncludePathModuleNames.AddRange( new string[] { "DesktopPlatform", "MessageLog", } ); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "InputCore", "Internationalization", "Json", "PropertyEditor", "Slate", "SlateCore", "EditorStyle", "UnrealEd", "GraphEditor", "SourceControl", "MessageLog", "Documentation", "Localization", "LocalizationService", } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "Localization", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "WorkspaceMenuStructure", "DesktopPlatform", } ); PrivateIncludePaths.AddRange( new string[] { "Editor/TranslationEditor/Private", } ); PublicIncludePaths.AddRange( new string[] { "Editor/TranslationEditor/Public", } ); }