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