public Nakama(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ModulePath, "..", "ThirdParty")
});
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
//"Projects"
// ... add other public dependencies that you statically link with here ...
});
if (UnrealTargetPlatform.Win32 == Target.Platform || UnrealTargetPlatform.Win64 == Target.Platform)
{
HandleWindows(Target);
}
else if (UnrealTargetPlatform.Linux == Target.Platform)
{
HandleLinux(Target);
}
else if (UnrealTargetPlatform.Mac == Target.Platform)
{
HandleMac(Target);
}
else if (UnrealTargetPlatform.IOS == Target.Platform)
{
HandleIOS(Target);
}
else if (UnrealTargetPlatform.Android == Target.Platform)
{
HandleAndroid(Target);
}
else
{
throw new NotImplementedException("Nakama Unreal client does not currently support platform: " + Target.Platform.ToString());
}
PrivateDefinitions.Add("NAKAMA_SHARED_LIBRARY=1");
}
public SceneProtocol(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivateDefinitions.Add("__UNREAL__=1");
PrivateDefinitions.Add("ZMQ_STATIC=1");
PublicDependencyModuleNames.AddRange(new string[] {
"Engine",
"Core",
"CoreUObject",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"MainFrame",
"AssetRegistry",
"RawMesh",
"AssetTools",
"Settings",
"RenderCore",
"Projects"
});
PrivateDependencyModuleNames.AddRange(new string[] {
"Engine",
"Core",
"CoreUObject",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"MainFrame",
"AssetRegistry",
"RawMesh",
"AssetTools",
"Settings",
"Projects"
});
AddZeroMQ(Target);
AddMsgPack(Target);
AddBridgeProtocol(Target);
}
public UnrealPakViewer(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.Add(Path.Combine(EngineDirectory, "Source/Runtime/Launch/Public"));
PrivateIncludePaths.Add(Path.Combine(EngineDirectory, "Source/Runtime/Launch/Private")); // For LaunchEngineLoop.cpp include
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AppFramework",
"Core",
"ApplicationCore",
"Slate",
"SlateCore",
"StandaloneRenderer",
"DesktopPlatform",
"Projects",
"EditorStyle",
"PakAnalyzer",
"Json",
"ImageWrapper",
}
);
if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"UnixCommonStartup"
}
);
}
DirectoryReference EngineSourceProgramsDirectory = new DirectoryReference(Path.Combine(EngineDirectory, "Source", "Programs"));
FileReference CurrentModuleDirectory = new FileReference(ModuleDirectory);
if (!CurrentModuleDirectory.IsUnderDirectory(EngineSourceProgramsDirectory))
{
string ProjectName = Target.ProjectFile.GetFileNameWithoutExtension();
Log.TraceInformation("UnrealPakViewer is outside engine source directory, parent project is: {0}", ProjectName);
PrivateDefinitions.Add(string.Format("ParentProjectName=TEXT(\"{0}\")", ProjectName));
}
}
public Qos(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDefinitions.Add("QOS_PACKAGE=1");
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PrivateIncludePaths.AddRange(
new string[] {
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Json",
"Icmp",
"OnlineSubsystem",
"OnlineSubsystemUtils"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Analytics",
"AnalyticsET"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Analytics"
}
);
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
}
}
public MultiUserClientLibrary(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
}
);
if (Target.Type == TargetType.Editor || Target.Type == TargetType.Program)
{
PrivateDefinitions.Add("WITH_CONCERT=1");
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Concert"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"ConcertSyncCore",
"ConcertSyncClient",
"MultiUserClient",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"MultiUserClient",
}
);
}
else
{
PrivateDefinitions.Add("WITH_CONCERT=0");
}
}
public FieldSystemEngine(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.Add(ModuleDirectory + "/Public");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"RHI",
"Chaos",
"ChaosSolverEngine",
}
);
PrivateDefinitions.Add("CHAOS_INCLUDE_LEVEL_1=1");
}
public ChaosCloth(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Chaos/Private");
PublicIncludePaths.Add(ModuleDirectory + "/Public");
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ClothingSystemRuntimeCommon",
"ClothingSystemRuntimeInterface",
"Engine",
"Chaos"
}
);
SetupModulePhysicsSupport(Target);
PrivateDefinitions.Add("CHAOS_INCLUDE_LEVEL_1=1");
}
public LibLuasocket(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "LuaLibFeature" });
PrivateDependencyModuleNames.AddRange(new string[] { "Lua" });
bEnableShadowVariableWarnings = false;
bEnableUndefinedIdentifierWarnings = false;
PublicDefinitions.Add("WITH_LIBLUASOCKET=1");
if (Target.Configuration == UnrealTargetConfiguration.Debug ||
Target.Configuration == UnrealTargetConfiguration.DebugGame)
{
PrivateDefinitions.Add("LUASOCKET_DEBUG");
}
}
public RmlUI(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.CPlusPlus;
// Dependencies
PrivateDependencyModuleNames.AddRange(new string[]
{
"Core",
"UElibPNG", // depended by freetype
"zlib", // depended by freetype
"FreeType2", // use free type lib
});
// RML ui need RTTI
bUseRTTI = true;
// Disable IWYU
bEnforceIWYU = false;
// Disable pch to fix header error
PCHUsage = PCHUsageMode.NoPCHs;
// Add include path
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Include"));
// Add definition
PrivateDefinitions.AddRange(new string[]
{
"RmlCore_EXPORTS",
"RmlDebugger_EXPORTS",
"_CRT_SECURE_NO_WARNINGS", // Disable scanf warning
});
// Disable warning
UnsafeTypeCastWarningLevel = WarningLevel.Off;
ShadowVariableWarningLevel = WarningLevel.Off;
// Disable freetype(font)
// PrivateDefinitions.Add("RMLUI_NO_FONT_INTERFACE_DEFAULT");
// Enable lua
// PrivateDefinitions.Add("RMLUI_BUILD_LUA");
}
public BuildSettings(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("Core");
bRequiresImplementModule = false;
PrivateDefinitions.Add(string.Format("ENGINE_VERSION_MAJOR={0}", Target.Version.MajorVersion));
PrivateDefinitions.Add(string.Format("ENGINE_VERSION_MINOR={0}", Target.Version.MinorVersion));
PrivateDefinitions.Add(string.Format("ENGINE_VERSION_HOTFIX={0}", Target.Version.PatchVersion));
PrivateDefinitions.Add(string.Format("ENGINE_IS_LICENSEE_VERSION={0}", Target.Version.IsLicenseeVersion? "true" : "false"));
PrivateDefinitions.Add(string.Format("ENGINE_IS_PROMOTED_BUILD={0}", Target.Version.IsPromotedBuild? "true" : "false"));
PrivateDefinitions.Add(string.Format("CURRENT_CHANGELIST={0}", Target.Version.Changelist));
PrivateDefinitions.Add(string.Format("COMPATIBLE_CHANGELIST={0}", Target.Version.EffectiveCompatibleChangelist));
PrivateDefinitions.Add(string.Format("BRANCH_NAME=\"{0}\"", Target.Version.BranchName));
PrivateDefinitions.Add(string.Format("BUILD_VERSION=\"{0}\"", Target.BuildVersion));
}
public WebSockets(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"HTTP"
}
);
bool bWithWebSockets = false;
bool bWithLibWebSockets = false;
if (ShouldUseModule)
{
bWithWebSockets = true;
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Online/WebSockets/Private",
}
);
if (PlatformSupportsLibWebsockets)
{
bWithLibWebSockets = true;
if (UsePlatformSSL)
{
PrivateDefinitions.Add("WITH_SSL=0");
AddEngineThirdPartyPrivateStaticDependencies(Target, "libWebSockets");
}
else
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenSSL", "libWebSockets", "zlib");
PrivateDependencyModuleNames.Add("SSL");
}
}
}
PublicDefinitions.Add("WEBSOCKETS_PACKAGE=1");
PublicDefinitions.Add("WITH_WEBSOCKETS=" + (bWithWebSockets ? "1" : "0"));
PublicDefinitions.Add("WITH_LIBWEBSOCKETS=" + (bWithLibWebSockets ? "1" : "0"));
}
public PhysicsCore(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.Add("Runtime/PhysicsCore/Public");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject"
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"DeveloperSettings"
}
);
SetupModulePhysicsSupport(Target);
// SetupModulePhysicsSupport adds a dependency on PhysicsCore, but we are PhysicsCore!
PublicIncludePathModuleNames.Remove("PhysicsCore");
PublicDependencyModuleNames.Remove("PhysicsCore");
if (Target.bCompileChaos == false && Target.bUseChaos == false)
{
if (Target.bCompilePhysX)
{
// Not ideal but as this module publicly exposes PhysX types
// to other modules when PhysX is enabled it requires that its
// public files have access to PhysX includes
PublicDependencyModuleNames.Add("PhysX");
}
if (Target.bCompileAPEX)
{
PublicDependencyModuleNames.Add("APEX");
}
}
PrivateDefinitions.Add("CHAOS_INCLUDE_LEVEL_1=1");
}
public HideAndSeekWithAI(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] {
"AIModule",
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"UMG",
});
PrivateDependencyModuleNames.AddRange(new string[] { });
// Uncomment if you are using Slate UI
// PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" });
// Uncomment if you are using online features
// PrivateDependencyModuleNames.Add("OnlineSubsystem");
// To include OnlineSubsystemSteam, add it to the plugins section in your uproject file with the Enabled attribute set to true
bool bDebugBuild = Target.Configuration == UnrealTargetConfiguration.Debug ||
Target.Configuration == UnrealTargetConfiguration.DebugGame;
bool bShippingBuild = Target.Configuration == UnrealTargetConfiguration.Shipping;
bUseRTTI = false;
bEnableExceptions = false;
bUseAVX = true;
ShadowVariableWarningLevel = WarningLevel.Error;
bEnableUndefinedIdentifierWarnings = true;
bUseUnity = bDebugBuild;
OptimizeCode = bDebugBuild ? CodeOptimization.Never : CodeOptimization.Always;
if (!bShippingBuild)
{
PrivateDefinitions.Add("HIDEANDSEEKWITHAI_LOGGING");
}
}
public ACLPlugin(ReadOnlyTargetRules Target) : base(Target)
{
string ACLSDKDir = Path.GetFullPath(Path.Combine(ModuleDirectory, "../../ThirdParty"));
PublicIncludePaths.AddRange(
new string[]
{
Path.Combine(ACLSDKDir, "acl/includes"),
Path.Combine(ACLSDKDir, "acl/external/sjson-cpp/includes"),
}
);
PrivateIncludePaths.AddRange(
new string[]
{
"ACLPlugin/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
}
);
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.Add("UnrealEd");
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
// There appears to be a bug when cross-compiling Linux under Windows where the clang tool-chain used
// isn't fully C++11 compliant. The standard specifies that when the 'cinttypes' header is included
// the format macros are always defined unlike C which requires the following macro to be defined first.
// This fix should be required for UE 4.20 and earlier versions.
PrivateDefinitions.Add("__STDC_FORMAT_MACROS");
}
}
public Projects(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Json",
}
);
PrivateIncludePaths.AddRange(
new string[]
{
"Runtime/Projects/Private",
}
);
List <string> EnabledPluginStrings = new List <string>();
foreach (string EnablePlugin in Target.EnablePlugins)
{
EnabledPluginStrings.Add(String.Format("TEXT(\"{0}\")", EnablePlugin));
}
PrivateDefinitions.Add(String.Format("UBT_TARGET_ENABLED_PLUGINS={0}", String.Join(", ", EnabledPluginStrings)));
List <string> DisabledPluginStrings = new List <string>();
foreach (string DisablePlugin in Target.DisablePlugins)
{
DisabledPluginStrings.Add(String.Format("TEXT(\"{0}\")", DisablePlugin));
}
PrivateDefinitions.Add(String.Format("UBT_TARGET_DISABLED_PLUGINS={0}", String.Join(", ", DisabledPluginStrings)));
if (Target.bIncludePluginsForTargetPlatforms)
{
PublicDefinitions.Add("LOAD_PLUGINS_FOR_TARGET_PLATFORMS=1");
}
else
{
PublicDefinitions.Add("LOAD_PLUGINS_FOR_TARGET_PLATFORMS=0");
}
}
public GeometryCollectionEngine(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Runtime/Experimental/GeometryCollectionEngine/Private");
PublicIncludePaths.Add(ModuleDirectory + "/Public");
SetupModulePhysicsSupport(Target);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"RHI",
"PhysX",
"FieldSystemEngine",
"ChaosSolverEngine",
"NetCore",
"IntelISPC"
}
);
if (Target.bCompileAPEX)
{
PublicDependencyModuleNames.Add("APEX");
}
if (!Target.bBuildRequiresCookedData)
{
DynamicallyLoadedModuleNames.AddRange(new string[] { "DerivedDataCache" });
}
PrivateIncludePathModuleNames.Add("DerivedDataCache");
if (Target.bBuildEditor)
{
PublicDependencyModuleNames.Add("UnrealEd");
}
PrivateDefinitions.Add("CHAOS_INCLUDE_LEVEL_1=1");
}
public SQLiteCore(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
}
);
PrivateDefinitions.Add("SQLITE_OMIT_AUTOINIT"); // We call sqlite3_initialize ourselves during module init
// Use the math.h version of isnan rather than the SQLite version to avoid a -ffast-math error
PrivateDefinitions.Add("SQLITE_HAVE_ISNAN=1");
// Enable SQLite debug checks?
//PrivateDefinitions.Add("SQLITE_DEBUG");
// Enable FTS
PrivateDefinitions.Add("SQLITE_ENABLE_FTS4");
PrivateDefinitions.Add("SQLITE_ENABLE_FTS5");
// Use ICU with SQLite if it's available
if (Target.bCompileICU)
{
PrivateDefinitions.Add("SQLITE_ENABLE_ICU");
AddEngineThirdPartyPrivateStaticDependencies(Target, "ICU");
}
// Should we use the Unreal HAL rather than the SQLite platform implementations?
if (Target.bCompileCustomSQLitePlatform)
{
// Note: The Unreal HAL doesn't provide an implementation of shared memory (as not all platforms implement it),
// nor does it provide an implementation of granular file locks. These two things affect the concurrency of an
// SQLite database as only one FSQLiteDatabase can have the file open at the same time.
PrivateDefinitions.Add("SQLITE_OS_OTHER=1"); // We are a custom OS
PrivateDefinitions.Add("SQLITE_ZERO_MALLOC"); // We provide our own malloc implementation
PrivateDefinitions.Add("SQLITE_MUTEX_NOOP"); // We provide our own mutex implementation
PrivateDefinitions.Add("SQLITE_OMIT_LOAD_EXTENSION"); // We disable extension loading
}
bEnableUndefinedIdentifierWarnings = false; // The embedded SQLite implementation generates a lot of these warnings
bUseUnity = false; // Ensure the embedded SQLite implementation is always compiled in isolation
}
public MagicLeapHelperVulkan(ReadOnlyTargetRules Target) : base(Target)
{
// Include headers to be public to other modules.
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public"));
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"Engine",
"MLSDK",
"RHI",
"RenderCore",
"HeadMountedDisplay"
});
// TODO: Explore linking Unreal modules against a commong header and
// having a runtime dll linking against the library according to the platform.
if (Target.Platform != UnrealTargetPlatform.Mac && Target.Platform != UnrealTargetPlatform.IOS)
{
PrivateDependencyModuleNames.Add("VulkanRHI");
PrivateDefinitions.Add("MLSDK_API_USE_VULKAN=1");
string EngineSourceDirectory = "../../../../Source";
if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(EngineSourceDirectory, "ThirdParty/SDL2/SDL-gui-backend/include"),
}
);
}
PrivateIncludePaths.AddRange(
new string[] {
"MagicLeapHelperVulkan/Private",
Path.Combine(EngineSourceDirectory, "Runtime/VulkanRHI/Private"),
Path.Combine(EngineSourceDirectory, "Runtime/VulkanRHI/Private", ((Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) ? "Windows" : Target.Platform.ToString()))
});
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
}
}
public SilvervineUE4Lua(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = "SilvervineUE4LuaPCH.h";
bEnableUndefinedIdentifierWarnings = false; // fixed error C4668: '__cplusplus' is not defined as a preprocessor macro, replacing with '0' for '#if/#elif'
PublicIncludePaths.AddRange(new string[]
{
});
PrivateIncludePaths.AddRange(new string[]
{
"SilvervineUE4Lua/Public",
"SilvervineUE4Lua/ThirdParty/Lua/5.3.4/src",
});
PublicDependencyModuleNames.AddRange(new string[]
{
"Core",
"CoreUObject",
"Engine",
});
PrivateDependencyModuleNames.AddRange(new string[]
{
"InputCore",
"SlateCore",
"Slate",
"UMG",
"GameplayTags", // For StaticBinding
"MovieScene", // For StaticBinding
});
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.Add("DirectoryWatcher");
}
// 4.20 build error workaround
PrivateDefinitions.Add("WIN32_LEAN_AND_MEAN");
PrivateDefinitions.Add("__STDC_WANT_SECURE_LIB__");
}
public ChaosSolverEngine(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Runtime/Experimental/ChaosSolverEngine/Private");
PublicIncludePaths.Add(ModuleDirectory + "/Public");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"RHI",
"DeveloperSettings"
}
);
SetupModulePhysicsSupport(Target);
PrivateDefinitions.Add("CHAOS_INCLUDE_LEVEL_1=1");
}
public MyBlankProgram(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.Add(Path.Combine(EngineDirectory, "Source/Runtime/Launch/Public"));
PrivateIncludePaths.Add(Path.Combine(EngineDirectory, "Source/Runtime/Launch/Private")); // For LaunchEngineLoop.cpp include
PrivateDependencyModuleNames.Add("Core");
PrivateDependencyModuleNames.Add("Projects");
DirectoryReference EngineSourceProgramsDirectory = new DirectoryReference(Path.Combine(EngineDirectory, "Source", "Programs"));
FileReference CurrentModuleDirectory = new FileReference(ModuleDirectory);
if (!CurrentModuleDirectory.IsUnderDirectory(EngineSourceProgramsDirectory))
{
string ProjectName = Target.ProjectFile.GetFileNameWithoutExtension();
Log.TraceInformation("MyBlankProgram is outside engine source directory, parent project is: {0}", ProjectName);
PrivateDefinitions.Add(string.Format("ParentProjectName=TEXT(\"{0}\")", ProjectName));
}
}
public SteamShared(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PrivateDefinitions.Add("STEAMSHARED_PACKAGE=1");
// Check if the Steam SDK exists.
if (Directory.Exists(Target.UEThirdPartySourceDirectory + "Steamworks/"))
{
PublicDefinitions.Add("STEAM_SDK_INSTALLED");
}
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"Sockets"
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "Steamworks");
}
public UXToolsRuntimeSettings(ReadOnlyTargetRules Target) : base(Target)
{
/** Runtime settings are in a separate module so that both UXTools and input simulation can use settings
* without a direct dependency.
* The settings module should also be loaded at an early stage which is easier to ensure with a separate module.
*/
PCHUsage = PCHUsageMode.NoPCHs;
PublicIncludePathModuleNames.AddRange(
new string[]
{
"WindowsMixedRealityHandTracking"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"WindowsMixedRealityHMD"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine"
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 && Target.bBuildEditor == true)
{
PrivateDefinitions.Add("WITH_INPUT_SIMULATION=1");
}
else
{
PrivateDefinitions.Add("WITH_INPUT_SIMULATION=0");
}
}
public SilvervineUE4Lua(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = "SilvervineUE4LuaPCH.h";
PublicIncludePaths.AddRange(new string[]
{
});
PrivateIncludePaths.AddRange(new string[]
{
"SilvervineUE4Lua/Public",
"SilvervineUE4Lua/ThirdParty/Lua/5.3.4/src",
});
PublicDependencyModuleNames.AddRange(new string[]
{
"Core",
"CoreUObject",
"Engine",
});
PrivateDependencyModuleNames.AddRange(new string[]
{
"InputCore",
"SlateCore",
"Slate",
"UMG",
"GameplayTags", // For StaticBinding
"MovieScene", // For StaticBinding
});
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.Add("DirectoryWatcher");
}
// 4.20 build error workaround
PrivateDefinitions.Add("WIN32_LEAN_AND_MEAN");
PrivateDefinitions.Add("__STDC_WANT_SECURE_LIB__");
}
public RosUnreal(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
CppStandard = CppStandardVersion.Latest;
bUseRTTI = true;
bEnableExceptions = true;
PrivateDefinitions.AddRange(new string[] { "HAVE_EXECINFO_H=1", "HAVE_CXXABI_H=1", "HAVE_GLIBC_BACKTRACE" });
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
PrivateDependencyModuleNames.AddRange(new string[] { "Boost" });
var ros_folder = new DirectoryInfo(Path.Combine(ModuleDirectory, "ros"));
if (ros_folder.Exists)
{
foreach (var component_folder in ros_folder.GetDirectories())
{
PrivateIncludePaths.Add(Path.Combine(component_folder.ToString(), "include"));
}
}
}
public PythonScriptPluginPreload(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
}
);
if (Target.bBuildEditor)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Python",
}
);
}
else
{
PrivateDefinitions.Add("WITH_PYTHON=0");
}
}
public WindowsMixedRealityHandTracking(ReadOnlyTargetRules Target)
: base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"InputDevice",
"LiveLink",
"LiveLinkInterface"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"HeadMountedDisplay",
"SlateCore",
"LiveLink",
"LiveLinkInterface",
"WindowsMixedRealityHMD"
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 && Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("WindowsMixedRealityInputSimulation");
PrivateDefinitions.Add("WITH_INPUT_SIMULATION=1");
}
else
{
PrivateDefinitions.Add("WITH_INPUT_SIMULATION=0");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "WindowsMixedRealityInterop");
}
public SlateRemote(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Networking",
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"InputCore",
"Slate",
"SlateCore",
"Sockets",
});
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Messaging",
"Settings",
});
PrivateIncludePaths.AddRange(
new string[] {
"SlateRemote/Private",
"SlateRemote/Private/Server",
"SlateRemote/Private/Shared",
});
// Only valid in non-shipping builds
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateDefinitions.Add("WITH_SLATE_REMOTE_SERVER=1");
}
else
{
PrivateDefinitions.Add("WITH_SLATE_REMOTE_SERVER=0");
}
}
public MfMediaFactory(ReadOnlyTargetRules Target) : base(Target)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"MediaAssets",
});
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Media",
"MfMedia",
});
PrivateIncludePaths.AddRange(
new string[] {
"MfMediaFactory/Private",
});
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
DynamicallyLoadedModuleNames.Add("MfMedia");
}
if (DoAllowHTTPSPlayback())
{
PrivateDefinitions.Add("MFMEDIAFACTORY_ALLOW_HTTPS=1");
}
else
{
PrivateDefinitions.Add("MFMEDIAFACTORY_ALLOW_HTTPS=0");
}
}
public WfcppRuntime(ReadOnlyTargetRules target) : base(target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] {
});
PrivateDependencyModuleNames.AddRange(new string[] {
"Core", "CoreUObject",
"Engine", "InputCore"
});
PublicIncludePaths.AddRange(new [] {
"WfcppRuntime/Public"
});
PrivateIncludePaths.AddRange(new [] {
"WfcppRuntime/Private",
"../../WFC++",
"../../WFC++/Tiled3D"
});
PrivateDefinitions.Add("WFC_STATIC=1");
}
