public Steamworks(ReadOnlyTargetRules Target) : base(Target) { /** Mark the current version of the Steam SDK */ string SteamVersion = "v139"; Type = ModuleType.External; PublicDefinitions.Add("STEAM_SDK_VER=TEXT(\"1.39\")"); PublicDefinitions.Add("STEAM_SDK_VER_PATH=TEXT(\"Steam" + SteamVersion + "\")"); string SdkBase = Target.UEThirdPartySourceDirectory + "Steamworks/Steam" + SteamVersion + "/sdk"; if (!Directory.Exists(SdkBase)) { string Err = string.Format("steamworks SDK not found in {0}", SdkBase); System.Console.WriteLine(Err); throw new BuildException(Err); } PublicIncludePaths.Add(SdkBase + "/public"); string LibraryPath = SdkBase + "/redistributable_bin/"; string LibraryName = "steam_api"; if (Target.Platform == UnrealTargetPlatform.Win32) { PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryName + ".lib"); PublicDelayLoadDLLs.Add(LibraryName + ".dll"); string SteamBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/Steamworks/Steam{0}/Win32/", SteamVersion); RuntimeDependencies.Add(SteamBinariesDir + "steam_api.dll"); if (Target.Type == TargetType.Server) { RuntimeDependencies.Add(SteamBinariesDir + "steamclient.dll"); RuntimeDependencies.Add(SteamBinariesDir + "tier0_s.dll"); RuntimeDependencies.Add(SteamBinariesDir + "vstdlib_s.dll"); } else { // assume SteamController is needed RuntimeDependencies.Add("$(EngineDir)/Config/controller.vdf"); } } else if (Target.Platform == UnrealTargetPlatform.Win64) { PublicLibraryPaths.Add(LibraryPath + "win64"); PublicAdditionalLibraries.Add(LibraryName + "64.lib"); PublicDelayLoadDLLs.Add(LibraryName + "64.dll"); string SteamBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/Steamworks/Steam{0}/Win64/", SteamVersion); RuntimeDependencies.Add(SteamBinariesDir + LibraryName + "64.dll"); if (Target.Type == TargetType.Server) { RuntimeDependencies.Add(SteamBinariesDir + "steamclient64.dll"); RuntimeDependencies.Add(SteamBinariesDir + "tier0_s64.dll"); RuntimeDependencies.Add(SteamBinariesDir + "vstdlib_s64.dll"); } else { // assume SteamController is needed RuntimeDependencies.Add("$(EngineDir)/Config/controller.vdf"); } } else if (Target.Platform == UnrealTargetPlatform.Mac) { LibraryPath += "osx32/libsteam_api.dylib"; PublicDelayLoadDLLs.Add(LibraryPath); PublicAdditionalShadowFiles.Add(LibraryPath); AdditionalBundleResources.Add(new UEBuildBundleResource(LibraryPath, "MacOS")); } else if (Target.Platform == UnrealTargetPlatform.Linux) { if (Target.LinkType == TargetLinkType.Monolithic) { LibraryPath += "linux64"; PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryName); } else { LibraryPath += "linux64/libsteam_api.so"; PublicDelayLoadDLLs.Add(LibraryPath); } string SteamBinariesPath = String.Format(Target.UEThirdPartyBinariesDirectory + "Steamworks/Steam{0}/{1}/{2}", SteamVersion, Target.Architecture, "libsteam_api.so"); PublicAdditionalLibraries.Add(SteamBinariesPath); RuntimeDependencies.Add(SteamBinariesPath); } }
public ArticyEditor(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; OptimizeCode = CodeOptimization.Never; 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", //"ClassViewer" // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "Projects", "InputCore", "UnrealEd", "LevelEditor", "CoreUObject", "Engine", "Slate", "SlateCore", // ... add private dependencies that you statically link with here ... "ArticyRuntime", "Json", "GameProjectGeneration", "ContentBrowser", "PropertyEditor", "EditorStyle", "EditorWidgets", "SourceControl", //"ClassViewer" } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically 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", "MovieSceneCapture", "UnrealEd", "Sequencer" } ); PrivateDependencyModuleNames.AddRange( new string[] { "ActorPickerMode", "CinematicCamera", "CurveEditor", "DesktopPlatform", "Json", "JsonUtilities", "LevelSequence", "MessageLog", "MovieScene", "MovieSceneTracks", "BlueprintGraph", "KismetCompiler", "GraphEditor", "ContentBrowser", "Slate", "SlateCore", "EditorStyle", "EditorWidgets", "PropertyEditor", "MaterialEditor", "RenderCore", "RHI", "ShaderCore", "SequenceRecorder", "TimeManagement", "AnimationCore", "TimeManagement", "XmlParser", } ); 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 QTMConnect(ReadOnlyTargetRules Target) : base(Target) { //Definitions.Add("RTCLIENTSDK_IMPORTS"); PublicIncludePaths.AddRange( new string[] { "QTMConnect/Public", // ... add public include paths required here ... } ); PrivateIncludePaths.AddRange( new string[] { "QTMConnect/Private", // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "Projects", "CoreUObject", "Engine", // ... 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 ... } ); string rtClientSDKPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty", "RTClientSDK")); PublicSystemIncludePaths.Add(System.IO.Path.Combine(rtClientSDKPath, "Include")); if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { string targetPlatformPathName = (Target.Platform == UnrealTargetPlatform.Win32) ? "Win32" : "Win64"; string rtClientSDKBinPath = Path.Combine(rtClientSDKPath, "Lib", targetPlatformPathName); PublicLibraryPaths.Add(rtClientSDKBinPath); PublicAdditionalLibraries.Add("RTClientSDK.lib"); PublicDelayLoadDLLs.Add("RTClientSDK.dll"); RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(rtClientSDKBinPath, "RTClientSDK.dll"))); } }
public VoxelEditor(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; PublicIncludePaths.AddRange( new string[] { "Public" }); PrivateIncludePaths.AddRange( new string[] { "VoxelEditor/Private", "VoxelEditor/Private/AssetTools", "VoxelEditor/Private/Factories", "VoxelEditor/Private/Graph", "VoxelEditor/Private/Details", }); AddEngineThirdPartyPrivateStaticDependencies(Target, "zlib", "UElibPNG", "UElibJPG" ); DynamicallyLoadedModuleNames.AddRange( new string[] { "AssetTools", "MainFrame", "DetailCustomizations", "AssetRegistry", "PlacementMode", }); PrivateDependencyModuleNames.AddRange( new string[] { "DesktopWidgets", "Projects", "Voxel", "Landscape", "LandscapeEditor", "Core", "CoreUObject", "ApplicationCore", "InputCore", "Engine", "UnrealEd", "Slate", "SlateCore", "EditorStyle", "RenderCore", "LevelEditor", "Landscape", "PropertyEditor", "ClassViewer", "GraphEditor", "ContentBrowser", "BlueprintGraph", }); PrivateIncludePathModuleNames.AddRange( new string[] { "AssetTools", "UnrealEd", "DetailCustomizations", "PlacementMode", }); }
public LuaMachine(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", "HTTP", "Json", "PakFile" // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "Slate", "SlateCore", "UMG", "InputCore", // ... 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) { PrivateDependencyModuleNames.AddRange(new string[] { "UnrealEd", "Projects" }); } string ThirdPartyDirectory = System.IO.Path.Combine(ModuleDirectory, "..", "ThirdParty"); if (Target.Platform == UnrealTargetPlatform.Win64) { PublicAdditionalLibraries.Add(System.IO.Path.Combine(ThirdPartyDirectory, "x64", "liblua53_win64.lib")); } if (Target.Platform == UnrealTargetPlatform.Mac) { PublicAdditionalLibraries.Add(System.IO.Path.Combine(ThirdPartyDirectory, "x64", "liblua53_mac.a")); } if (Target.Platform == UnrealTargetPlatform.Linux) { PublicAdditionalLibraries.Add(System.IO.Path.Combine(ThirdPartyDirectory, "x64", "liblua53_linux64.a")); } if (Target.Platform == UnrealTargetPlatform.LinuxAArch64) { PublicAdditionalLibraries.Add(System.IO.Path.Combine(ThirdPartyDirectory, "ARM64", "liblua53_linux_aarch64.a")); } if (Target.Platform == UnrealTargetPlatform.Android) { PublicAdditionalLibraries.Add(System.IO.Path.Combine(ThirdPartyDirectory, "ARMv7", "liblua53_android.a")); PublicAdditionalLibraries.Add(System.IO.Path.Combine(ThirdPartyDirectory, "ARM64", "liblua53_android64.a")); } if (Target.Platform == UnrealTargetPlatform.IOS) { PublicAdditionalLibraries.Add(System.IO.Path.Combine(ThirdPartyDirectory, "ARM64", "liblua53_ios.a")); } }
public DlgSystemEditor(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; // bUseUnity = false; //if ((Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) // && WindowsPlatform.Compiler >= WindowsCompiler.VisualStudio2015) //{ //Definitions.Add("/Wall"); //} // Docs see https://docs.unrealengine.com/latest/INT/Programming/UnrealBuildSystem/ModuleFiles/ PublicIncludePaths.AddRange( new string[] { Path.Combine(ModuleDirectory, "Public") // ... add public include paths required here ... }); string PrivateDirectory = Path.Combine(ModuleDirectory, "Private"); PrivateIncludePaths.AddRange( new string[] { PrivateDirectory, Path.Combine(PrivateDirectory, "Commandlets") // ... add other private include paths required here ... }); PublicDependencyModuleNames.AddRange( new string[] { "Core", "DlgSystem", // ... add other public dependencies that you statically link with here ... }); PrivateDependencyModuleNames.AddRange( new string[] { // Core modules "Engine", "CoreUObject", "Projects", // IPluginManager "UnrealEd", // for FAssetEditorManager "RenderCore", "InputCore", "SlateCore", "Slate", "EditorStyle", "MessageLog", "EditorWidgets", // Accessing the menu "WorkspaceMenuStructure", // Details/Property editor "DetailCustomizations", "PropertyEditor", // Used for the Blueprint Nodes "BlueprintGraph", "Kismet", "KismetCompiler", "KismetWidgets", // graph stuff "GraphEditor", "ContentBrowser", // e.g. FPlatformApplicationMisc::ClipboardCopy "ApplicationCore", }); #if UE_4_24_OR_LATER PrivateDependencyModuleNames.Add("ToolMenus"); #endif #if UE_4_26_OR_LATER PrivateDependencyModuleNames.Add("ContentBrowserData"); #endif #if UE_5_0_OR_LATER PrivateDependencyModuleNames.Add("EditorFramework"); #endif PrivateIncludePathModuleNames.AddRange( new string[] { "AssetRegistry", "AssetTools", }); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... }); }
public NavigationSystem(ReadOnlyTargetRules Target) : base(Target) { PublicIncludePaths.AddRange( new string[] { "Runtime/NavigationSystem/Public", } ); PrivateIncludePaths.AddRange( new string[] { "Runtime/NavigationSystem/Private", "Runtime/Engine/Private", "Developer/DerivedDataCache/Public", } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", } ); PrivateDependencyModuleNames.AddRange( new string[] { "RHI", "RenderCore", "ShaderCore", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "TargetPlatform", } ); if (!Target.bBuildRequiresCookedData && Target.bCompileAgainstEngine) { DynamicallyLoadedModuleNames.Add("DerivedDataCache"); } SetupModulePhysXAPEXSupport(Target); 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.bBuildEditor == true) { // @todo api: Only public because of WITH_EDITOR and UNREALED_API PublicDependencyModuleNames.Add("UnrealEd"); CircularlyReferencedDependentModules.Add("UnrealEd"); } }
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", "MeshSolverUtilities", "ModelingComponents", "ModelingOperators", "ModelingOperatorsEditorOnly", "ProxyLODMeshReduction", // currently required to be public due to IVoxelBasedCSG API // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "RenderCore", "RHI", "InputCore", "MeshUtilities", // temp for saving mesh asset "UnrealEd", "MeshBuilder", "MeshDescriptionOperations", "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 FPS_project(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "AIModule", "GameplayTasks" }); }
public Kismet(ReadOnlyTargetRules Target) : base(Target) { PrivateIncludePaths.Add("Editor/Kismet/Private"); PrivateIncludePathModuleNames.AddRange( new string[] { "AssetRegistry", "AssetTools", "BlueprintRuntime", "ClassViewer", "Analytics", "DerivedDataCache", "LevelEditor", "GameProjectGeneration", "SourceCodeAccess", } ); PrivateDependencyModuleNames.AddRange( new string[] { "AppFramework", "Core", "CoreUObject", "ApplicationCore", "Slate", "SlateCore", "EditorStyle", "EditorWidgets", "Engine", "Json", "Merge", "MessageLog", "UnrealEd", "GraphEditor", "KismetWidgets", "KismetCompiler", "BlueprintGraph", "AnimGraph", "PropertyEditor", "SourceControl", "SharedSettingsWidgets", "InputCore", "EngineSettings", "Projects", "JsonUtilities", "DerivedDataCache", "DesktopPlatform", "HotReload", "BlueprintNativeCodeGen", "UMGEditor", "UMG", // for SBlueprintDiff "WorkspaceMenuStructure", "ToolMenus", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "BlueprintRuntime", "ClassViewer", "Documentation", "GameProjectGeneration", "BlueprintCompilerCppBackend", } ); // Circular references that need to be cleaned up CircularlyReferencedDependentModules.AddRange( new string[] { "BlueprintGraph", "BlueprintNativeCodeGen", "UMGEditor", "Merge" } ); }
public Engine(ReadOnlyTargetRules Target) : base(Target) { PrivateIncludePaths.Add("../Shaders/Shared"); PrivatePCHHeaderFile = "Private/EnginePrivatePCH.h"; SharedPCHHeaderFile = "Public/EngineSharedPCH.h"; PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "AudioMixer", "AudioMixerCore", "AnimationCore" }); PrivateIncludePaths.AddRange( new string[] { "Developer/DerivedDataCache/Public", "Runtime/SynthBenchmark/Public", "Runtime/Engine/Private", "Runtime/Net/Core/Private/Net/Core/PushModel/Types" } ); PrivateIncludePathModuleNames.AddRange( new string[] { "TargetPlatform", "ImageWrapper", "ImageWriteQueue", "HeadMountedDisplay", "EyeTracker", "MRMesh", "Advertising", "MovieSceneCapture", "AutomationWorker", "MovieSceneCapture", "DesktopPlatform" } ); if (Target.Configuration != UnrealTargetConfiguration.Shipping) { PrivateIncludePathModuleNames.AddRange( new string[] { "TaskGraph", "SlateReflector", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "SlateReflector", } ); PrivateDependencyModuleNames.AddRange( new string[] { "EditorAnalyticsSession", } ); } PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "NetCore", "ApplicationCore", "Json", "SlateCore", "Slate", "InputCore", "Messaging", "MessagingCommon", "RenderCore", "AnalyticsET", "RHI", "Sockets", "AssetRegistry", // Here until FAssetData is moved to engine "EngineMessages", "EngineSettings", "SynthBenchmark", "GameplayTags", "PacketHandler", "AudioPlatformConfiguration", "MeshDescription", "StaticMeshDescription", "PakFile", "NetworkReplayStreaming", "PhysicsCore", "SignalProcessing", "AudioExtensions" } ); PrivateDependencyModuleNames.AddRange( new string[] { "AppFramework", "Networking", "Landscape", "UMG", "Projects", "MaterialShaderQualitySettings", "CinematicCamera", "Analytics", "AudioMixer", "AudioMixerCore", "SignalProcessing", "CrunchCompression", "IntelISPC", "TraceLog", } ); // Cross platform Audio Codecs: AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile", "libOpus" ); DynamicallyLoadedModuleNames.Add("EyeTracker"); if (Target.bUseXGEController && Target.Type == TargetType.Editor && (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)) { PrivateDependencyModuleNames.Add("XGEController"); } if (Target.Configuration != UnrealTargetConfiguration.Shipping) { PrivateIncludePathModuleNames.Add("Localization"); DynamicallyLoadedModuleNames.Add("Localization"); } // to prevent "causes WARNING: Non-editor build cannot depend on non-redistributable modules." if (Target.Type == TargetType.Editor) { // for now we depend on this PrivateDependencyModuleNames.Add("RawMesh"); } bool bVariadicTemplatesSupported = true; if (Target.Platform == UnrealTargetPlatform.XboxOne) { // Use reflection to allow type not to exist if console code is not present System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool"); if (XboxOnePlatformType != null) { System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null); if (VersionName.ToString().Equals("2012")) { bVariadicTemplatesSupported = false; } } } if (bVariadicTemplatesSupported) { PrivateIncludePathModuleNames.AddRange( new string[] { "MessagingRpc", "PortalRpc", "PortalServices", } ); if (Target.Type == TargetType.Editor) { // these modules require variadic templates PrivateDependencyModuleNames.AddRange( new string[] { "MessagingRpc", "PortalRpc", "PortalServices", } ); } } CircularlyReferencedDependentModules.Add("GameplayTags"); CircularlyReferencedDependentModules.Add("Landscape"); CircularlyReferencedDependentModules.Add("UMG"); CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings"); CircularlyReferencedDependentModules.Add("CinematicCamera"); CircularlyReferencedDependentModules.Add("AudioMixer"); if (Target.Type == TargetType.Editor) { PrivateIncludePathModuleNames.Add("Foliage"); } // The AnimGraphRuntime module is not needed by Engine proper, but it is loaded in LaunchEngineLoop.cpp, // and needs to be listed in an always-included module in order to be compiled into standalone games DynamicallyLoadedModuleNames.Add("AnimGraphRuntime"); DynamicallyLoadedModuleNames.AddRange( new string[] { "MovieScene", "MovieSceneCapture", "MovieSceneTracks", "LevelSequence", "HeadMountedDisplay", "MRMesh", "StreamingPauseRendering", } ); if (Target.Type != TargetType.Server) { PrivateIncludePathModuleNames.AddRange( new string[] { "Media", "SlateNullRenderer", "SlateRHIRenderer" } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "Media", "SlateNullRenderer", "SlateRHIRenderer" } ); } if (Target.Type == TargetType.Server || Target.Type == TargetType.Editor) { PrivateDependencyModuleNames.Add("PerfCounters"); } if (Target.Type == TargetType.Editor) { PrivateIncludePathModuleNames.Add("MeshUtilities"); PrivateIncludePathModuleNames.Add("MeshUtilitiesCommon"); DynamicallyLoadedModuleNames.Add("MeshUtilities"); PrivateDependencyModuleNames.AddRange( new string[] { "ImageCore", "RawMesh" } ); PrivateDependencyModuleNames.Add("CollisionAnalyzer"); CircularlyReferencedDependentModules.Add("CollisionAnalyzer"); PrivateDependencyModuleNames.Add("LogVisualizer"); CircularlyReferencedDependentModules.Add("LogVisualizer"); if (Target.Platform == UnrealTargetPlatform.Win64) { DynamicallyLoadedModuleNames.AddRange( new string[] { "WindowsTargetPlatform", "WindowsNoEditorTargetPlatform", "WindowsServerTargetPlatform", "WindowsClientTargetPlatform", "AllDesktopTargetPlatform", "WindowsPlatformEditor", } ); } else if (Target.Platform == UnrealTargetPlatform.Mac) { DynamicallyLoadedModuleNames.AddRange( new string[] { "MacTargetPlatform", "MacNoEditorTargetPlatform", "MacServerTargetPlatform", "MacClientTargetPlatform", "AllDesktopTargetPlatform", "MacPlatformEditor", } ); } else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix)) { DynamicallyLoadedModuleNames.AddRange( new string[] { "LinuxTargetPlatform", "LinuxNoEditorTargetPlatform", "LinuxAArch64NoEditorTargetPlatform", "LinuxServerTargetPlatform", "LinuxAArch64ServerTargetPlatform", "LinuxClientTargetPlatform", "LinuxAArch64ClientTargetPlatform", "AllDesktopTargetPlatform", "LinuxPlatformEditor", } ); } } DynamicallyLoadedModuleNames.AddRange( new string[] { "NullNetworkReplayStreaming", "LocalFileNetworkReplayStreaming", "HttpNetworkReplayStreaming", "Advertising" } ); if (Target.bWithLiveCoding) { DynamicallyLoadedModuleNames.Add("LiveCoding"); } if (Target.Type != TargetType.Server) { DynamicallyLoadedModuleNames.AddRange( new string[] { "ImageWrapper" } ); } WhitelistRestrictedFolders.Add("Private/NotForLicensees"); if (!Target.bBuildRequiresCookedData && Target.bCompileAgainstEngine) { DynamicallyLoadedModuleNames.AddRange( new string[] { "DerivedDataCache", "TargetPlatform", "DesktopPlatform" } ); } if (Target.bBuildEditor == true) { PublicDependencyModuleNames.AddRange( new string[] { "UnrealEd", "Kismet" } ); // @todo api: Only public because of WITH_EDITOR and UNREALED_API CircularlyReferencedDependentModules.AddRange( new string[] { "UnrealEd", "Kismet" } ); PrivateIncludePathModuleNames.Add("TextureCompressor"); PrivateIncludePaths.Add("Developer/TextureCompressor/Public"); PrivateIncludePathModuleNames.Add("HierarchicalLODUtilities"); DynamicallyLoadedModuleNames.Add("HierarchicalLODUtilities"); DynamicallyLoadedModuleNames.Add("AnimationModifiers"); PrivateIncludePathModuleNames.Add("AssetTools"); DynamicallyLoadedModuleNames.Add("AssetTools"); PrivateIncludePathModuleNames.Add("PIEPreviewDeviceProfileSelector"); } SetupModulePhysicsSupport(Target); if (Target.bCompilePhysX && (Target.bBuildEditor || Target.bCompileAPEX)) { DynamicallyLoadedModuleNames.Add("PhysXCooking"); } PublicDependencyModuleNames.AddRange( new string[] { "PhysicsSQ", "ChaosSolvers" } ); // Engine public headers need to know about some types (enums etc.) PublicIncludePathModuleNames.Add("ClothingSystemRuntimeInterface"); PublicDependencyModuleNames.Add("ClothingSystemRuntimeInterface"); if (Target.bBuildEditor) { PrivateDependencyModuleNames.Add("ClothingSystemEditorInterface"); PrivateIncludePathModuleNames.Add("ClothingSystemEditorInterface"); } if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { // Head Mounted Display support // PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" }); // DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" }); } if (Target.Platform == UnrealTargetPlatform.Mac) { PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" }); } if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android)) { AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile" ); PrivateDependencyModuleNames.Add("AndroidRuntimeSettings"); } if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS) { PrivateDependencyModuleNames.Add("IOSRuntimeSettings"); } if (Target.Platform == UnrealTargetPlatform.Switch) { PrivateDependencyModuleNames.Add("SwitchRuntimeSettings"); } if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix)) { AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile", "libOpus" ); } PublicDefinitions.Add("GPUPARTICLE_LOCAL_VF_ONLY=0"); // Add a reference to the stats HTML files referenced by UEngine::DumpFPSChartToHTML. Previously staged by CopyBuildToStagingDirectory. if (Target.bBuildEditor || Target.Configuration != UnrealTargetConfiguration.Shipping) { RuntimeDependencies.Add("$(EngineDir)/Content/Stats/...", StagedFileType.UFS); } }
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 platform = Target.Platform == UnrealTargetPlatform.Win64 ? "Windows-x64" : "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, lib + debugPostfix + ".lib"); 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, lib + postfix + ".lib"))); 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" // ... 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; }
public murphys(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "OnlineSubsystem", "OnlineSubsystemUtils", "OnlineSubsystemSteam", "Slate", "SlateCore", "MoviePlayer" }); }
public AudioMixer(ReadOnlyTargetRules Target) : base(Target) { OptimizeCode = CodeOptimization.Always; PrivateIncludePathModuleNames.Add("TargetPlatform"); PrivateIncludePaths.AddRange( new string[] { "Runtime/AudioMixer/Private", } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", } ); if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { PublicIncludePathModuleNames.Add("UELibSampleRate"); AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile", "libOpus", "UELibSampleRate" ); } // TODO test this for HTML5 ! //if (Target.Platform == UnrealTargetPlatform.HTML5) //{ // AddEngineThirdPartyPrivateStaticDependencies(Target, // "UEOgg", // "Vorbis", // "VorbisFile" // ); //} if (Target.Platform == UnrealTargetPlatform.Mac) { AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "libOpus" ); PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" }); } if (Target.Platform == UnrealTargetPlatform.Android) { AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile" ); } if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix)) { AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile", "libOpus" ); } if (Target.Platform == UnrealTargetPlatform.XboxOne) { AddEngineThirdPartyPrivateStaticDependencies(Target, "libOpus" ); } }
public HarfBuzz(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; // Can't be used without our dependencies if (!Target.bCompileFreeType || !Target.bCompileICU) { PublicDefinitions.Add("WITH_HARFBUZZ=0"); return; } if (HarfBuzzVersion == "harfbuzz-2.4.0") { PublicDefinitions.Add("WITH_HARFBUZZ_V24=1"); // TODO: Remove this once everything is using HarfBuzz 2.4.0 PublicDefinitions.Add("WITH_HARFBUZZ=1"); } else { PublicDefinitions.Add("WITH_HARFBUZZ=0"); } string HarfBuzzLibPath = Path.Combine(LibHarfBuzzRootPath, Target.Platform.ToString()); string BuildTypeFolderName = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ? "Debug" : "Release"; string LibPath; // Includes PublicSystemIncludePaths.Add(IncHarfBuzzRootPath); // Libs if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32) { string VSVersionFolderName = "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(); //BuildTypeFolderName = "RelWithDebInfo"; PublicAdditionalLibraries.Add(Path.Combine(HarfBuzzLibPath, VSVersionFolderName, BuildTypeFolderName, "harfbuzz.lib")); } else if (Target.Platform == UnrealTargetPlatform.Mac) { LibPath = Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT ? "libharfbuzzd.a" : "libharfbuzz.a"; PublicAdditionalLibraries.Add(Path.Combine(HarfBuzzLibPath, LibPath)); } else if (Target.Platform == UnrealTargetPlatform.IOS) { PublicAdditionalLibraries.Add(Path.Combine(HarfBuzzLibPath, BuildTypeFolderName, "libharfbuzz.a")); } else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android)) { // filtered out in the toolchain LibPath = Path.Combine(BuildTypeFolderName, "libharfbuzz.a"); PublicAdditionalLibraries.Add(Path.Combine(LibHarfBuzzRootPath, "Android", "ARMv7", LibPath)); PublicAdditionalLibraries.Add(Path.Combine(LibHarfBuzzRootPath, "Android", "ARM64", LibPath)); PublicAdditionalLibraries.Add(Path.Combine(LibHarfBuzzRootPath, "Android", "x86", LibPath)); PublicAdditionalLibraries.Add(Path.Combine(LibHarfBuzzRootPath, "Android", "x64", LibPath)); } else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix)) { if (Target.Type == TargetType.Server) { 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); throw new BuildException(Err); } LibPath = Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT ? "libharfbuzzd_fPIC.a" : "libharfbuzz_fPIC.a"; PublicAdditionalLibraries.Add(Path.Combine(LibHarfBuzzRootPath, "Linux", Target.Architecture, LibPath)); } else if (Target.Platform == UnrealTargetPlatform.PS4) { PublicAdditionalLibraries.Add(Path.Combine(HarfBuzzLibPath, BuildTypeFolderName, "libharfbuzz.a")); } else if (Target.Platform == UnrealTargetPlatform.XboxOne) { // Use reflection to allow type not to exist if console code is not present System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool"); if (XboxOnePlatformType != null) { System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null); string VSVersionFolderName = "VS" + VersionName.ToString(); PublicAdditionalLibraries.Add(Path.Combine(HarfBuzzLibPath, VSVersionFolderName, BuildTypeFolderName, "harfbuzz.lib")); } } }
public BalancedFPSLevelGenerator(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; PublicIncludePaths.AddRange( new string[] { "BalancedFPSLevelGenerator/Public" // ... add public include paths required here ... } ); PrivateIncludePaths.AddRange( new string[] { "BalancedFPSLevelGenerator/Private", // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "Slate", "AssetTools", "UnrealEd", } ); PrivateDependencyModuleNames.AddRange( new string[] { "Projects", "InputCore", "SlateCore", "LevelEditor", "PropertyEditor", "KismetWidgets", "KismetCompiler", "BlueprintGraph", "GraphEditor", "Kismet", "EditorStyle", "Slate", "Sequencer", "DetailCustomizations", "Settings", "RenderCore", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); }
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", "ApplicationCore", "DesktopWidgets", "Engine", "Landscape", "InputCore", "Slate", "SlateCore", "EditorStyle", "UnrealEd", "EditorWidgets", "KismetWidgets", "MovieSceneCapture", "MovieSceneTools", "MovieSceneTracks", "Sequencer", "MovieScene", "TimeManagement", "SharedSettingsWidgets", "ContentBrowser", "BlueprintGraph", "GraphEditor", "AnimGraph", "PropertyEditor", "LevelEditor", "DesktopPlatform", "ClassViewer", "TargetPlatform", "ExternalImagePicker", "MoviePlayer", "SourceControl", "InternationalizationSettings", "SourceCodeAccess", "RHI", "HardwareTargeting", "NavigationSystem", "AIModule", "ConfigEditor", "Persona", "CinematicCamera", "ComponentVisualizers", "SkeletonEditor", "LevelSequence", "AdvancedPreviewScene", "AudioSettingsEditor", "HeadMountedDisplay", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "Engine", "Media", "Landscape", "LandscapeEditor", "PropertyEditor", "GameProjectGeneration", "ComponentVisualizers", "GraphEditor", "MeshMergeUtilities", "MeshReductionInterface", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "Layers", "GameProjectGeneration", "MeshMergeUtilities", "MeshReductionInterface", } ); // @third party code - BEGIN HairWorks AddEngineThirdPartyPrivateStaticDependencies(Target, "HairWorks"); // @third party code - END HairWorks }
public PuzzlePlatforms(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "UMG", "SlateCore" }); }
public NiagaraEditor(ReadOnlyTargetRules Target) : base(Target) { PrivateIncludePaths.AddRange(new string[] { "NiagaraEditor/Private", "NiagaraEditor/Private/Toolkits", "NiagaraEditor/Private/Widgets", "NiagaraEditor/Private/Sequencer/NiagaraSequence", "NiagaraEditor/Private/ViewModels", "NiagaraEditor/Private/TypeEditorUtilities" }); PrivateDependencyModuleNames.AddRange( new string[] { "Engine", "RHI", "Core", "CoreUObject", "CurveEditor", "ApplicationCore", "InputCore", "RenderCore", "Slate", "SlateCore", "Kismet", "EditorStyle", "UnrealEd", "VectorVM", "NiagaraCore", "Niagara", "NiagaraShader", "MovieScene", "Sequencer", "TimeManagement", "PropertyEditor", "GraphEditor", "ShaderFormatVectorVM", "TargetPlatform", "DesktopPlatform", "AppFramework", "MovieSceneTools", "MovieSceneTracks", "AdvancedPreviewScene", "Projects", "MainFrame", "ToolMenus", "Renderer", "EditorWidgets", "DeveloperSettings" } ); PrivateIncludePathModuleNames.AddRange( new string[] { "Engine", "Messaging", "LevelEditor", "AssetTools", "ContentBrowser", "DerivedDataCache", } ); PublicDependencyModuleNames.AddRange( new string[] { "NiagaraCore", "NiagaraShader", "Engine", "NiagaraCore", "Niagara", "UnrealEd", } ); PublicIncludePathModuleNames.AddRange( new string[] { "Engine", "Niagara" } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "WorkspaceMenuStructure", } ); }
public Slate(ReadOnlyTargetRules Target) : base(Target) { SharedPCHHeaderFile = "Public/SlateSharedPCH.h"; PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "ApplicationCore", "InputCore", "Json", "SlateCore", "ImageWrapper" }); PrivateIncludePaths.AddRange( new string[] { "Runtime/Slate/Private", "Runtime/Slate/Private/Framework", "Runtime/Slate/Private/Framework/Application", "Runtime/Slate/Private/Framework/Commands", "Runtime/Slate/Private/Framework/Docking", "Runtime/Slate/Private/Framework/Layout", "Runtime/Slate/Private/Framework/MultiBox", "Runtime/Slate/Private/Framework/Notifications", "Runtime/Slate/Private/Framework/Styling", "Runtime/Slate/Private/Framework/Text", "Runtime/Slate/Private/Framework/Text/IOS", "Runtime/Slate/Private/Widgets/Colors", "Runtime/Slate/Private/Widgets/Docking", "Runtime/Slate/Private/Widgets/Images", "Runtime/Slate/Private/Widgets/Input", "Runtime/Slate/Private/Widgets/Layout", "Runtime/Slate/Private/Widgets/Notifications", "Runtime/Slate/Private/Widgets/Text", "Runtime/Slate/Private/Widgets/Views", "Runtime/Toolbox/Public/" }); if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { AddEngineThirdPartyPrivateStaticDependencies(Target, "XInput"); } else if (Target.Platform == UnrealTargetPlatform.Linux) { AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2"); } // Add slate runtime dependencies if (Target.bUsesSlate) { RuntimeDependencies.Add("$(EngineDir)/Content/Slate/...", StagedFileType.UFS); RuntimeDependencies.Add("$(EngineDir)/Content/SlateDebug/...", StagedFileType.UFS); if (Target.ProjectFile != null) { RuntimeDependencies.Add("$(ProjectDir)/Content/Slate/...", StagedFileType.UFS); RuntimeDependencies.Add("$(ProjectDir)/Content/SlateDebug/...", StagedFileType.UFS); } } }
public depsFsound(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; SetupThirdPartyLibs(); }
public TreeMap(ReadOnlyTargetRules Target) : base(Target) { PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "SlateCore" }); PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "InputCore", "XmlParser" }); }
public libstrophe(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; string StrophePackagePath = Path.Combine(Target.UEThirdPartySourceDirectory, "libstrophe", "libstrophe-0.9.1"); bool bIsSupported = Target.Platform == UnrealTargetPlatform.XboxOne || Target.Platform == UnrealTargetPlatform.Android || Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.PS4 || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Switch; if (bIsSupported) { PrivateDefinitions.Add("XML_STATIC"); PublicSystemIncludePaths.Add(StrophePackagePath); string ConfigName = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ? "Debug" : "Release"; AddEngineThirdPartyPrivateStaticDependencies(Target, "Expat"); if (Target.Platform == UnrealTargetPlatform.XboxOne) { // Use reflection to allow type not to exist if console code is not present string ToolchainName = "VS"; System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool"); if (XboxOnePlatformType != null) { System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null); ToolchainName += VersionName.ToString(); } string LibraryPath = Path.Combine(StrophePackagePath, "XboxOne", ToolchainName, ConfigName); PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, "strophe.lib")); } else if (Target.Platform == UnrealTargetPlatform.Android) { string LibraryPath = Path.Combine(StrophePackagePath, "Android", ConfigName); PublicLibraryPaths.Add(Path.Combine(LibraryPath, "armv7")); PublicLibraryPaths.Add(Path.Combine(LibraryPath, "arm64")); PublicAdditionalLibraries.Add("strophe"); } else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.Mac) { PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, Target.Platform.ToString(), ConfigName, "libstrophe.a")); PublicAdditionalLibraries.Add("resolv"); } else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { PublicLibraryPaths.Add(Path.Combine(StrophePackagePath, Target.Platform.ToString(), "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(), ConfigName)); PublicAdditionalLibraries.Add("strophe.lib"); } else if (Target.Platform == UnrealTargetPlatform.PS4) { PublicLibraryPaths.Add(Path.Combine(StrophePackagePath, Target.Platform.ToString(), ConfigName)); PublicAdditionalLibraries.Add("strophe"); } else if (Target.Platform == UnrealTargetPlatform.Switch) { PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, Target.Platform.ToString(), ConfigName, "libstrophe.a")); } } }
public AgoraSignal(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; PublicIncludePaths.AddRange( new string[] { "AgoraSignal/Public" // ... add public include paths required here ... } ); PrivateIncludePaths.AddRange( new string[] { "AgoraSignal/Private", // ... add other private include paths required here ... } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "Networking", "Sockets", "Json", "JsonUtilities" // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "Slate", "SlateCore", //"OnlineSubsystem", // ... 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 || Target.Platform == UnrealTargetPlatform.Win64) { string OSVersion = (Target.Platform == UnrealTargetPlatform.Win32) ? "x86" : "x64"; PublicIncludePaths.Add(Path.Combine(AgoraLibrary, OSVersion, "include")); string LibPath = Path.Combine(AgoraLibrary, OSVersion, "lib"); System.Console.WriteLine("LibPath------" + LibPath); string DllPath = Path.Combine(AgoraLibrary, OSVersion, "dll"); System.Console.WriteLine("DllPth ----" + DllPath); PublicLibraryPaths.Add(LibPath); PublicAdditionalLibraries.Add("agora_sig_sdk.lib"); PublicDelayLoadDLLs.Add(Path.Combine(DllPath, "agora_sig_sdk.dll")); RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(DllPath, "agora_sig_sdk.dll"))); string binariesDir = Path.Combine(ModuleDirectory, "../../Binaries", Target.Platform.ToString()); string projectBinaries = Path.Combine(ModuleDirectory, "../../../../Binaries", Target.Platform.ToString()); if (!Directory.Exists(binariesDir)) { Directory.CreateDirectory(binariesDir); } if (!Directory.Exists(projectBinaries)) { Directory.CreateDirectory(projectBinaries); } try { string dll = Path.Combine(DllPath, "agora_sig_sdk.dll"); File.Copy(Path.Combine(DllPath, "agora_sig_sdk.dll"), Path.Combine(projectBinaries, "agora_sig_sdk.dll")); File.Copy(Path.Combine(DllPath, "agora_sig_sdk.dll"), Path.Combine(binariesDir, "agora_sig_sdk.dll")); } catch (Exception e) { System.Console.WriteLine("copy TextChatdll exception,maybe have exists,err=", e.ToString()); } } }
public LevelEditor(ReadOnlyTargetRules Target) : base(Target) { PrivateIncludePathModuleNames.AddRange( new string[] { "AssetTools", "ClassViewer", "MainFrame", "PlacementMode", "SlateReflector", "IntroTutorials", "AppFramework", "PortalServices", "Persona", } ); PublicIncludePathModuleNames.AddRange( new string[] { "Settings", "IntroTutorials", "HeadMountedDisplay", "UnrealEd", "VREditor", "CommonMenuExtensions" } ); 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", "Kismet", "KismetWidgets", "Sequencer", "Foliage", "HierarchicalLODOutliner", "HierarchicalLODUtilities", "MaterialShaderQualitySettings", "PixelInspectorModule", "CommonMenuExtensions", "ToolMenus", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "MainFrame", "ClassViewer", "DeviceManager", "SettingsEditor", "SessionFrontend", "SlateReflector", "AutomationWindow", "Layers", "WorldBrowser", "EditorWidgets", "AssetTools", "WorkspaceMenuStructure", "NewLevelDialog", "DeviceProfileEditor", "PlacementMode", "IntroTutorials", "HeadMountedDisplay", "VREditor", "Persona", } ); if (Target.bWithLiveCoding) { PrivateIncludePathModuleNames.Add("LiveCoding"); } }
public TP_ThirdPersonMono(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay" }); }
public EOSSDK(ReadOnlyTargetRules Target) : base(Target)
public Orexis(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs; PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" }); }
public UnrealFrontend(ReadOnlyTargetRules Target) : base(Target) { PublicIncludePaths.AddRange( new string[] { "Runtime/Launch/Public", } ); PrivateIncludePaths.AddRange( new string[] { "Programs/UnrealFrontend/Private", "Programs/UnrealFrontend/Private/Commands", "Runtime/Launch/Private", // for LaunchEngineLoop.cpp include } ); PrivateDependencyModuleNames.AddRange( new string[] { "AutomationController", "Core", "ApplicationCore", "CoreUObject", "DeviceManager", "LauncherServices", "Messaging", "OutputLog", "Profiler", "ProfilerClient", "ProjectLauncher", "Projects", "SessionFrontend", "SessionServices", "Slate", "SlateCore", "SourceCodeAccess", "StandaloneRenderer", "TargetDeviceServices", "TargetPlatform", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "SlateReflector", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "SlateReflector" } ); if (Target.Platform == UnrealTargetPlatform.Mac) { PrivateDependencyModuleNames.Add("XCodeSourceCodeAccess"); } else if (Target.Platform == UnrealTargetPlatform.Win64) { PrivateDependencyModuleNames.Add("VisualStudioSourceCodeAccess"); } else if (Target.Platform == UnrealTargetPlatform.Linux) { PrivateDependencyModuleNames.AddRange( new string[] { "UnixCommonStartup" } ); } // @todo: allow for better plug-in support in standalone Slate apps PrivateDependencyModuleNames.AddRange( new string[] { "Networking", "Sockets", "UdpMessaging", "TcpMessaging", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "Messaging", } ); }