public ChronoPhysics(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core" });
PrivateDependencyModuleNames.AddRange(new string[] { "CoreUObject", "Engine", "Slate", "SlateCore", "Projects", "RHI", "RenderCore", "ProceduralMeshComponent", "Json", "JsonUtilities" });
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Include"));
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Include", "chrono"));
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Include", "blaze-2.2"));
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Include", "boost_1_63_0"));
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Include", "chrono_parallel"));
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Include", "chrono", "collision", "bullet"));
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Include", "chrono", "collision", "gimpact"));
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Include", "chrono", "collision", "convexdecomposition", "HACD"));
PublicLibraryPaths.Add(Path.Combine(ModuleDirectory, "Lib"));
PublicAdditionalLibraries.Add("ChronoEngine.lib");
PublicAdditionalLibraries.Add("ChronoEngine_vehicle.lib");
PublicAdditionalLibraries.Add("ChronoEngine_parallel.lib");
PublicAdditionalLibraries.Add("vcomp.lib");
bUseRTTI = true;
bEnableExceptions = true;
PrivateDefinitions.Add("DEBUG_LOG");
PrivateDefinitions.Add("NOMINMAX");
}
public ConcertSyncClientLibrary(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
}
);
if (Target.bBuildDeveloperTools)
{
PrivateDefinitions.Add("WITH_CONCERT=1");
PrivateDependencyModuleNames.AddRange(
new string[]
{
"ConcertSyncClient",
"ConcertTransport",
}
);
}
else
{
PrivateDefinitions.Add("WITH_CONCERT=0");
}
}
public DatasmithDeltaGenTranslator(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"DatasmithCore",
"Engine",
"FBX",
"LevelSequence",
"MeshDescription",
"StaticMeshDescription",
"UnrealEd",
"XmlParser",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"DatasmithContent",
"DatasmithTranslator",
"DatasmithFBXTranslator"
}
);
//TODO: set this false by default and add option to turn this on for development
PrivateDefinitions.Add("WITH_DELTAGEN_DEBUG_CODE=1");
}
public RiderLink(ReadOnlyTargetRules Target) : base(Target)
{
#if UE_4_22_OR_LATER
PCHUsage = PCHUsageMode.NoPCHs;
#else
PCHUsage = PCHUsageMode.NoSharedPCHs;
#endif
bUseRTTI = true;
PublicDependencyModuleNames.Add("Core");
PublicDependencyModuleNames.Add("RD");
string[] Paths =
{
"Public/Model/Library",
"Public/Model/RdEditorProtocol",
};
PrivateDefinitions.Add("ENABLE_LOG_FILE=0");
foreach (var Item in Paths)
{
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, Item));
}
}
public SSL(ReadOnlyTargetRules Target) : base(Target)
{
PublicDefinitions.Add("SSL_PACKAGE=1");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
}
);
if (bPlatformSupportsSSL)
{
PublicDefinitions.Add("WITH_SSL=1");
PrivateDefinitions.Add("USE_DEFAULT_SSLCERT=" + (bUseDefaultSSLCert ? "1" : "0"));
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Online/SSL/Private",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenSSL");
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
PublicSystemLibraries.Add("crypt32.lib");
}
}
else
{
PublicDefinitions.Add("WITH_SSL=0");
}
}
private void LoadMixedReality(ReadOnlyTargetRules Target)
{
// Set a macro allowing us to switch between debuggame/development configuration
if (Target.Configuration == UnrealTargetConfiguration.Debug)
{
PrivateDefinitions.Add("WINDOWS_MIXED_REALITY_DEBUG_DLL=1");
}
else
{
PrivateDefinitions.Add("WINDOWS_MIXED_REALITY_DEBUG_DLL=0");
}
if (Target.Platform != UnrealTargetPlatform.Win32)
{
// HoloLens 2 Remoting
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Windows/x64/Microsoft.Holographic.AppRemoting.dll");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Windows/x64/PerceptionDevice.dll");
// HoloLens 1 Remoting
RuntimeDependencies.Add("$(EngineDir)/Binaries/Win64/HolographicStreamerDesktop.dll");
RuntimeDependencies.Add("$(EngineDir)/Binaries/Win64/Microsoft.Perception.Simulation.dll");
RuntimeDependencies.Add("$(EngineDir)/Binaries/Win64/PerceptionSimulationManager.dll");
}
PublicDefinitions.Add("WITH_WINDOWS_MIXED_REALITY=1");
}
void AddFFI(ReadOnlyTargetRules Target)
{
string HeaderPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty", "Include"));
string LibraryPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty", "Library"));
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "ffi", "Win64") });
PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, "ffi", "Win64", "ffi.lib"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "ffi", "macOS") });
PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, "ffi", "macOS", "libffi.a"));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "ffi", "iOS") });
PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, "ffi", "iOS", "libffi.a"));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "ffi", "Android") });
PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, "ffi", "Android", "armeabi-v7a", "libffi.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, "ffi", "Android", "arm64-v8a", "libffi.a"));
}
PrivateDefinitions.Add("WITH_FFI");
}
public Braze(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDefinitions.Add("BRAZE_PACKAGE=1");
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
PrivateDependencyModuleNames.AddRange(new string[] { });
// Android Specific
if (Target.Platform == UnrealTargetPlatform.Android)
{
// For AndroidJNI
PublicIncludePathModuleNames.Add("Launch");
PrivateDependencyModuleNames.AddRange(new string[] { "Launch", });
// Must be named AndroidPlugin
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "BrazeUPLAndroid.xml"));
}
// IOS specific
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.AddRange(new string[] { "AdSupport", "CoreTelephony" });
string FrameworkPath = Path.Combine(ModuleDirectory, "../ThirdParty/IOS/");
PublicAdditionalLibraries.Add(Path.Combine(FrameworkPath, "libBrazeIOS.a"));
// todo: Attempt a static framework, use the following:
// PublicAdditionalFrameworks.Add(new Framework("Appboy_IOS_SDK", Path.Combine(FrameworkPath, "Appboy_IOS_SDK.framework.zip")));
// RuntimeDependencies.Add(Path.Combine(FrameworkPath, "Appboy_IOS_SDK.framework.zip"));
}
}
public UXTools(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
// Required to avoid errors about undefined preprocessor macros (C4668) when building DirectXMath.h
bEnableUndefinedIdentifierWarnings = false;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "LiveLinkInterface" });
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.Add("UnrealEd");
}
// DirectXMath is not present by default in non-Windows platforms and doesn't build in Android
// when using gcc so we add a definition to disable code using it to avoid build breaks.
// See Task 218: Investigate building DirectXMath for Android and iOS.
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens)
{
PrivateDefinitions.Add("UXT_DIRECTXMATH_SUPPORTED=1");
}
else
{
PrivateDefinitions.Add("UXT_DIRECTXMATH_SUPPORTED=0");
}
}
public Lua(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core" });
bEnableUndefinedIdentifierWarnings = false;
ShadowVariableWarningLevel = WarningLevel.Off;
#if UE_5_0_OR_LATER
if (Target.Platform == UnrealTargetPlatform.Win64)
#else
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
#endif
{
PublicDefinitions.Add("_CRT_SECURE_NO_WARNINGS");
if (Target.bBuildEditor)
{
PrivateDefinitions.Add("LUA_BUILD_AS_DLL");
}
}
if (Target.Platform == UnrealTargetPlatform.Android || Target.Platform == UnrealTargetPlatform.Mac ||
Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateDefinitions.Add("LUA_BUILD_AS_DLL");
PrivateDefinitions.Add("LUA_USE_DLOPEN");
}
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "src"));
}
public Party(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDefinitions.Add("PARTY_PACKAGE=1");
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(
new string[] {
"OnlineSubsystem",
"OnlineSubsystemUtils",
}
);
PrivateIncludePaths.AddRange(
new string[] {
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
}
);
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
}
}
public WebSockets(ReadOnlyTargetRules Target) : base(Target)
{
PublicDefinitions.Add("WEBSOCKETS_PACKAGE=1");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"HTTP"
}
);
bool bPlatformSupportsLibWebsockets =
Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealTargetPlatform.Android ||
Target.Platform == UnrealTargetPlatform.Mac ||
Target.IsInPlatformGroup(UnrealPlatformGroup.Unix) ||
Target.Platform == UnrealTargetPlatform.IOS ||
Target.Platform == UnrealTargetPlatform.PS4 ||
Target.Platform == UnrealTargetPlatform.Switch;
bool bUsePlatformSSL = Target.Platform == UnrealTargetPlatform.Switch;
bool bPlatformSupportsXboxWebsockets = Target.Platform == UnrealTargetPlatform.XboxOne;
bool bShouldUseModule =
bPlatformSupportsLibWebsockets ||
bPlatformSupportsXboxWebsockets;
if (bShouldUseModule)
{
PublicDefinitions.Add("WITH_WEBSOCKETS=1");
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Online/WebSockets/Private",
}
);
if (bPlatformSupportsLibWebsockets)
{
PublicDefinitions.Add("WITH_LIBWEBSOCKETS=1");
if (bUsePlatformSSL)
{
PrivateDefinitions.Add("WITH_SSL=0");
AddEngineThirdPartyPrivateStaticDependencies(Target, "libWebSockets");
}
else
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenSSL", "libWebSockets", "zlib");
PrivateDependencyModuleNames.Add("SSL");
}
}
}
else
{
PublicDefinitions.Add("WITH_WEBSOCKETS=0");
}
}
public GeometryCollectionEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("GeometryCollectionEditor/Private");
PublicIncludePaths.Add(ModuleDirectory + "/Public");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Slate",
"SlateCore",
"Engine",
"UnrealEd",
"PropertyEditor",
"RenderCore",
"RHI",
"GeometryCollectionEngine",
"RawMesh",
"AssetTools",
"AssetRegistry",
"SceneOutliner",
"EditorStyle",
"ToolMenus",
"Chaos"
}
);
PrivateDefinitions.Add("CHAOS_INCLUDE_LEVEL_1=1");
}
public AndroidDeviceProfileSelector(ReadOnlyTargetRules Target) : base(Target)
{
ShortName = "AndroidDPS";
// get a value from .ini (ConfigFile attribute doesn't work in Build.cs files it seems)
ConfigHierarchy Ini = ConfigCache.ReadHierarchy(ConfigHierarchyType.Engine, Target.ProjectFile != null ? Target.ProjectFile.Directory : null, Target.Platform);
string SecretGuid;
Ini.GetString("AndroidDPSBuildSettings", "SecretGuid", out SecretGuid);
if (!string.IsNullOrEmpty(SecretGuid))
{
PrivateDefinitions.Add("HASH_PEPPER_SECRET_GUID=" + SecretGuid);
}
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
}
);
}
public OpenMesh(ReadOnlyTargetRules Target) : base(Target)
{
//Needed for Open Mesh Library
{
bEnableExceptions = true;
bUseRTTI = true; // Enable RuntimeTypeInformation
PublicDefinitions.Add("_USE_MATH_DEFINES");
PrivateDefinitions.Add("_CRT_SECURE_NO_WARNINGS"); // should disable warning warning C4996, but does not work
}
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string VersionFolder = "Version8_0";
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, VersionFolder, "Public"),
}
);
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, VersionFolder, "Private"),
// ... add other private include paths required here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"Projects"
});
}
public WindowsMixedRealitySpatialInput(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"TargetPlatform",
"InputDevice",
"HeadMountedDisplay",
"WindowsMixedRealityHMD"
});
PublicDependencyModuleNames.AddRange(
new string[]
{
"MixedRealityInteropLibrary",
"HeadMountedDisplay",
"ProceduralMeshComponent"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"HeadMountedDisplay",
"WindowsMixedRealityHMD",
"Slate",
"SlateCore",
});
AddEngineThirdPartyPrivateStaticDependencies(Target, "WindowsMixedRealityInterop");
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
}
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealTargetPlatform.HoloLens)
{
bEnableExceptions = true;
PCHUsage = PCHUsageMode.NoSharedPCHs;
PrivatePCHHeaderFile = "Private/WindowsMixedRealitySpatialInput.h";
}
if (Target.Platform == UnrealTargetPlatform.Win64 && Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("WindowsMixedRealityInputSimulation");
PrivateDefinitions.Add("WITH_INPUT_SIMULATION=1");
}
else
{
PrivateDefinitions.Add("WITH_INPUT_SIMULATION=0");
}
}
public OnlineSubsystemSteam(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDefinitions.Add("ONLINESUBSYSTEMSTEAM_PACKAGE=1");
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(
new string[] {
"OnlineSubsystemUtils"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"NetCore",
"Engine",
"Sockets",
"Voice",
"AudioMixer",
"OnlineSubsystem",
"Json",
"PacketHandler",
"Projects",
"SteamShared"
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "Steamworks");
}
public ACLPlugin(ReadOnlyTargetRules Target) : base(Target)
{
string ACLSDKDir = Path.GetFullPath(Path.Combine(ModuleDirectory, "../ThirdParty"));
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public"));
PublicIncludePaths.Add(Path.Combine(ACLSDKDir, "acl/includes"));
PublicIncludePaths.Add(Path.Combine(ACLSDKDir, "acl/external/rtm/includes"));
PrivateIncludePaths.Add("ACLPlugin/Private");
PublicDependencyModuleNames.Add("Core");
PublicDependencyModuleNames.Add("CoreUObject");
PublicDependencyModuleNames.Add("Engine");
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.Add("DesktopPlatform");
PrivateDependencyModuleNames.Add("UnrealEd");
PublicIncludePaths.Add(Path.Combine(ACLSDKDir, "acl/external/sjson-cpp/includes"));
}
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 ChaosCachingEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("ChaosCachingEditor/Private");
PublicIncludePaths.Add(ModuleDirectory + "/Public");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Slate",
"SlateCore",
"InputCore",
"Engine",
"UnrealEd",
"EditorStyle",
"PropertyEditor",
"BlueprintGraph",
"ToolMenus",
"PhysicsCore",
"ChaosCaching"
});
SetupModulePhysicsSupport(Target);
PrivateDefinitions.Add("CHAOS_INCLUDE_LEVEL_1=1");
}
public OnlineSubsystemEpic(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDefinitions.Add("ONLINESUBSYSTEMEPIC_PACKAGE=1");
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "..", "ThirdParty", "OnlineSubsystemEpicLibrary", "Include"));
PublicDependencyModuleNames.AddRange(
new string[] {
"OnlineSubsystemUtils"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"NetCore",
"CoreUObject",
"Engine",
"OnlineSubsystemEpicLibrary",
"OnlineSubsystem",
"Json",
"Sockets",
"Projects",
}
);
bEnforceIWYU = true;
}
void ThirdPartyNodejs(ReadOnlyTargetRules Target)
{
PrivateDefinitions.Add("WITHOUT_INSPECTOR");//node already had one
PrivateDefinitions.Add("WITH_NODEJS");
string HeaderPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty", "nodejs"));
PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "include") });
PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "deps", "v8", "include") });
PublicIncludePaths.AddRange(new string[] { Path.Combine(HeaderPath, "deps", "uv", "include") });
string LibraryPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty", "nodejs", "lib"));
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string V8LibraryPath = Path.Combine(LibraryPath, "Win64");
PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libnode.lib"));
RuntimeDependencies.Add("$(TargetOutputDir)/libnode.dll", Path.Combine(V8LibraryPath, "libnode.dll"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string V8LibraryPath = Path.Combine(LibraryPath, "macOS");
PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libnode.83.dylib"));
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
string V8LibraryPath = Path.Combine(LibraryPath, "Linux");
PublicAdditionalLibraries.Add(Path.Combine(V8LibraryPath, "libnode.so"));
}
}
public CISQLite3(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(new string[] { Path.Combine(ModuleDirectory, "Public") });
PrivateIncludePaths.AddRange(new string[] { Path.Combine(ModuleDirectory, "Private") });
PrivatePCHHeaderFile = "Private/CISQLite3PrivatePCH.h";
PublicDependencyModuleNames.AddRange(
new string[] {
"Engine",
"Core",
"CoreUObject"
}
);
PrivateDefinitions.Add("SQLITE_ENABLE_DESERIALIZE=1");
PrivateDependencyModuleNames.AddRange(
new string[] {}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {}
);
}
public OnlineSubsystemLLL(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDefinitions.Add("ONLINESUBSYSTEM_LLL_PACKAGE=1");
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PrivateIncludePaths.Add("Private");
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Sockets",
"Json",
"OnlineSubsystem",
"PacketHandler",
}
);
if (Target.bCompileAgainstEngine)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Engine",
"OnlineSubsystemUtils"
}
);
}
}
public ChaosVehiclesEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("ChaosVehiclesEditor/Private");
PublicIncludePaths.Add(ModuleDirectory + "/Public");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Slate",
"SlateCore",
"Engine",
"UnrealEd",
"PropertyEditor",
"AnimGraphRuntime",
"AnimGraph",
"BlueprintGraph",
"ToolMenus",
"PhysicsCore",
"ChaosVehiclesCore",
"ChaosVehiclesEngine",
"ChaosVehicles"
}
);
PrivateDefinitions.Add("CHAOS_INCLUDE_LEVEL_1=1");
}
public OnlineSubsystemTwitch(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/OnlineSubsystemTwitchPrivate.h";
PrivateDefinitions.Add("ONLINESUBSYSTEM_TWITCH_PACKAGE=1");
PCHUsage = ModuleRules.PCHUsageMode.UseSharedPCHs;
PrivateIncludePaths.Add("Private");
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Sockets",
"HTTP",
"Json",
"OnlineSubsystem"
}
);
if (Target.bCompileAgainstEngine)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Engine",
"OnlineSubsystemUtils"
}
);
}
}
public Text3D(ReadOnlyTargetRules Target) : base(Target)
{
bEnableExceptions = true;
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PrivateDefinitions.Add("TEXT3D_WITH_FREETYPE=1");
PrivateDefinitions.Add("TEXT3D_WITH_INTERSECTION=0");
PublicDependencyModuleNames.AddRange(new string[] {
"Core",
"CoreUObject",
"Engine",
});
PrivateDependencyModuleNames.AddRange(new string[] {
"SlateCore",
"RenderCore",
"RHI",
// 3rd party libraries
"FreeType2",
"OpenGL", // only for include purposes
"FTGL",
"HarfBuzz",
"GLUtesselator"
});
}
public OnlineSubsystemSteam(ReadOnlyTargetRules Target) : base(Target)
{
string SteamVersion = "Steamv142";
bool bSteamSDKFound = Directory.Exists(Target.UEThirdPartySourceDirectory + "Steamworks/" + SteamVersion) == true;
PublicDefinitions.Add("STEAMSDK_FOUND=" + (bSteamSDKFound ? "1" : "0"));
PublicDefinitions.Add("WITH_STEAMWORKS=" + (bSteamSDKFound ? "1" : "0"));
PrivateDefinitions.Add("ONLINESUBSYSTEMSTEAM_PACKAGE=1");
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(
new string[] {
"OnlineSubsystemUtils",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Sockets",
"Voice",
"AudioMixer",
"OnlineSubsystem",
"Json",
"PacketHandler"
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "Steamworks");
}
public AxCommon(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.Add("Core");
PublicDependencyModuleNames.Add("CoreUObject");
PublicDependencyModuleNames.Add("Engine");
PublicDependencyModuleNames.Add("GameplayAbilities");
PublicDependencyModuleNames.Add("GameplayTags");
PublicDependencyModuleNames.Add("GameplayTasks");
PublicDependencyModuleNames.Add("AIModule");
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
PrivateDependencyModuleNames.Add("Slate");
}
if (Target.bBuildDeveloperTools || IsDevBuild(Target))
{
PrivateDependencyModuleNames.Add("GameplayDebugger");
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=1");
}
else
{
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=0");
}
if (UseEnhancedInput)
{
PrivateDefinitions.Add("WITH_ENHANCED_INPUT=1");
PublicDependencyModuleNames.Add("EnhancedInput");
}
}
public CloudConnector(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/CloudConnectorPrivatePCH.h";
bEnableExceptions = true; // Google Cloud SDK only has exceptions, so we enable this
CppStandard = CppStandardVersion.Cpp17;
PrivateDefinitions.Add("_SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING");
PrivateDefinitions.Add("_SILENCE_CXX17_STRSTREAM_DEPRECATION_WARNING");
PublicDependencyModuleNames.AddRange(new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore"
});
PrivateDependencyModuleNames.AddRange(new string[] {
"AWS_SDK",
"GoogleCloud_SDK",
"HTTP",
"Json",
"JsonUtilities",
"Http"
});
}
public AndroidDeviceProfileSelector(ReadOnlyTargetRules Target) : base(Target)
{
ShortName = "AndroidDPS";
string SecretFile = Path.Combine(ModuleDirectory, "Private", "NoRedist", "AndroidDeviceProfileSelectorSecrets.h");
if (File.Exists(SecretFile))
{
PrivateDefinitions.Add("ANDROIDDEVICEPROFILESELECTORSECRETS_H=1");
}
else
{
PrivateDefinitions.Add("ANDROIDDEVICEPROFILESELECTORSECRETS_H=0");
}
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
}
);
}
