public BatteryCollector(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "UMG", "Slate", "SlateCore" });
}
public GetOUT(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "AIModule", "GameplayTasks" });
}
public WebSocket(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"WebSocket/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Json",
"JsonUtilities",
"Sockets",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"Json",
"JsonUtilities",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
string ThirdPartyDir = Path.GetFullPath(Path.Combine(ModuleDirectory, "../", "../", "ThirdParty"));
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.Add("zlib");
PrivateDependencyModuleNames.Add("OpenSSL");
PrivateIncludePaths.Add(Path.Combine(ThirdPartyDir, "include", "Win64"));
string strStaticPath = Path.GetFullPath(Path.Combine(ThirdPartyDir, "lib", "Win64"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesX64 = new string[] {
"websockets_static.lib",
//"libcrypto.lib",
//"libssl.lib",
};
foreach (string Lib in StaticLibrariesX64)
{
PublicAdditionalLibraries.Add(Lib);
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PrivateIncludePaths.Add(Path.Combine(ThirdPartyDir, "include", "Mac"));
string strStaticPath = Path.GetFullPath(Path.Combine(ThirdPartyDir, "lib", "Mac"));
//PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesMac = new string[] {
"libwebsockets.a",
"libssl.a",
"libcrypto.a"
};
foreach (string Lib in StaticLibrariesMac)
{
PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib));
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateDependencyModuleNames.Add("OpenSSL");
PrivateIncludePaths.Add(Path.Combine(ThirdPartyDir, "include", "Linux"));
string strStaticPath = Path.GetFullPath(Path.Combine(ThirdPartyDir, "lib", "Linux"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesLinux = new string[] {
"libwebsockets.a",
//"libssl.a",
//"libcrypto.a"
};
foreach (string Lib in StaticLibrariesLinux)
{
PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib));
}
}
}
public ProxyLODMeshReduction(ReadOnlyTargetRules Target) : base(Target)
{
// For boost:: and TBB:: code
bUseRTTI = true;
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[]
{
"UVAtlas",
"DirectXMesh",
"OpenVDB",
"UEOpenExr",
"Core",
"CoreUObject",
"Engine",
"InputCore",
"UnrealEd",
"RawMesh",
"MeshDescription",
"MeshUtilities",
"MaterialUtilities",
"PropertyEditor",
"SlateCore",
"Slate",
"EditorStyle",
"RenderCore",
"RHI",
"QuadricMeshReduction"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"UnrealEd",
"MeshDescriptionOperations"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public MagicLeap(ReadOnlyTargetRules Target)
: base(Target)
{
// @todo implement in a better way.
string EngineSourceDirectory = Path.Combine(ModuleDirectory, "../../../../../Source"); //Path.Combine(BuildConfiguration.RelativeEnginePath, "Source");
PrivateIncludePaths.AddRange(
new string[]
{
"MagicLeap/Private",
Path.Combine(EngineSourceDirectory, "Runtime/Renderer/Private")
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay",
"InputDevice",
"LuminRuntimeSettings",
"AugmentedReality",
"MLSDK",
"MagicLeapPrivileges"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"EngineSettings",
"InputCore",
"RHI",
"RenderCore",
"Renderer",
"Slate",
"SlateCore",
"MRMesh",
"MagicLeapHelperOpenGL",
// Public headers of MagicLeapHelperVulkan are protected against Mac so this is fine here.
"MagicLeapHelperVulkan",
"MagicLeapSecureStorage",
}
);
if (Target.Platform != UnrealTargetPlatform.Mac)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"VulkanRHI"
}
);
PrivateDefinitions.Add("MLSDK_API_USE_VULKAN=1");
}
else
{
PrivateDependencyModuleNames.Add("MetalRHI");
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(EngineSourceDirectory, "Runtime/Apple/MetalRHI/Private"),
});
AddEngineThirdPartyPrivateStaticDependencies(Target, "MTLPP");
}
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
}
// Add direct rendering dependencies on a per-platform basis
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.AddRange(new string[] { "D3D11RHI" });
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(EngineSourceDirectory, "Runtime/Windows/D3D11RHI/Private"),
Path.Combine(EngineSourceDirectory, "Runtime/Windows/D3D11RHI/Private/Windows"),
}
);
// TODO: refactor MagicLeap.Build.cs!!! Too much duplicate code.
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(EngineSourceDirectory, "Runtime/VulkanRHI/Private"),
Path.Combine(EngineSourceDirectory, "Runtime/VulkanRHI/Private/Windows")
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(EngineSourceDirectory, "ThirdParty/SDL2/SDL-gui-backend/include"),
}
);
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(EngineSourceDirectory, "Runtime/VulkanRHI/Private"),
Path.Combine(EngineSourceDirectory, "Runtime/VulkanRHI/Private/Linux")
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
// HACK This is a workaround for a bug introduced in Unreal 4.13 which should be
// removed if all SensoryWare libs are compiled with libc++ instead of libstdc++
// https://udn.unrealengine.com/questions/305445/ue-33584-linux-build.html
PublicAdditionalLibraries.Add("stdc++");
}
else if (Target.Platform == UnrealTargetPlatform.Lumin)
{
PrivateDependencyModuleNames.AddRange(new string[] { "VulkanRHI" });
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(EngineSourceDirectory, "Runtime/VulkanRHI/Private"),
Path.Combine(EngineSourceDirectory, "Runtime/VulkanRHI/Private", ((Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) ? "Windows" : Target.Platform.ToString()))
// ... add other private include paths required here ...
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
}
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Linux || Target.Platform == UnrealTargetPlatform.Lumin)
{
PrivateDependencyModuleNames.AddRange(new string[] { "OpenGLDrv" });
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(EngineSourceDirectory, "Runtime/OpenGLDrv/Private"),
// ... add other private include paths required here ...
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
}
}
public UnrealEnginePython(TargetInfo Target)
#endif
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string enableUnityBuild = System.Environment.GetEnvironmentVariable("UEP_ENABLE_UNITY_BUILD");
bFasterWithoutUnity = string.IsNullOrEmpty(enableUnityBuild);
PublicIncludePaths.AddRange(
new string[] {
"UnrealEnginePython/Public",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"UnrealEnginePython/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Sockets",
"Networking"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"MovieScene",
"LevelSequence",
"HTTP",
"UMG",
"AppFramework",
"RHI",
"Voice",
"RenderCore",
"MovieSceneCapture",
"Landscape",
"Foliage",
"AIModule"
// ... add private dependencies that you statically link with here ...
}
);
#if WITH_FORWARDED_MODULE_RULES_CTOR
BuildVersion Version;
if (BuildVersion.TryRead(BuildVersion.GetDefaultFileName(), out Version))
{
if (Version.MinorVersion >= 18)
{
PrivateDependencyModuleNames.Add("ApplicationCore");
}
}
#endif
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
#if WITH_FORWARDED_MODULE_RULES_CTOR
if (Target.bBuildEditor)
#else
if (UEBuildConfiguration.bBuildEditor)
#endif
{
PrivateDependencyModuleNames.AddRange(new string[] {
"UnrealEd",
"LevelEditor",
"BlueprintGraph",
"Projects",
"Sequencer",
"SequencerWidgets",
"AssetTools",
"LevelSequenceEditor",
"MovieSceneTools",
"MovieSceneTracks",
"CinematicCamera",
"EditorStyle",
"GraphEditor",
"UMGEditor",
"AIGraph",
"RawMesh",
"DesktopWidgets",
"EditorWidgets",
"FBX",
"Persona",
"PropertyEditor",
"LandscapeEditor",
"MaterialEditor"
});
}
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(windowsKnownPaths, "Win64");
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetWindowsPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicAdditionalLibraries.Add(libPath);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(macKnownPaths, "Mac");
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetMacPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicDelayLoadDLLs.Add(libPath);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (pythonHome == "")
{
string includesPath = DiscoverLinuxPythonIncludesPath();
if (includesPath == null)
{
throw new System.Exception("Unable to find Python includes, please add a search path to linuxKnownIncludesPaths");
}
string libsPath = DiscoverLinuxPythonLibsPath();
if (libsPath == null)
{
throw new System.Exception("Unable to find Python libs, please add a search path to linuxKnownLibsPaths");
}
PublicIncludePaths.Add(includesPath);
PublicAdditionalLibraries.Add(libsPath);
}
else
{
string[] items = pythonHome.Split(';');
PublicIncludePaths.Add(items[0]);
PublicAdditionalLibraries.Add(items[1]);
}
}
#if WITH_FORWARDED_MODULE_RULES_CTOR
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicIncludePaths.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/python35/include"));
PublicLibraryPaths.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/armeabi-v7a"));
PublicAdditionalLibraries.Add("python3.5m");
string APLName = "UnrealEnginePython_APL.xml";
string RelAPLPath = Utils.MakePathRelativeTo(System.IO.Path.Combine(ModuleDirectory, APLName), Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", RelAPLPath));
}
#endif
}
public Protobuf(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",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
PublicSystemIncludePaths.AddRange(
new string[]
{
Path.Combine(ThridPartyPath, "protobuf/Include")
}
);
PublicAdditionalLibraries.AddRange(
new string[]
{
Path.Combine(ThridPartyPath, "protobuf/lib/Win64/MD/Release", "libprotobuf.lib"),
Path.Combine(ThridPartyPath, "protobuf/lib/Win64/MD/Release", "libprotobuf-lite.lib"),
Path.Combine(ThridPartyPath, "protobuf/lib/Win64/MD/Release", "libprotoc.lib"),
}
);
bEnableUndefinedIdentifierWarnings = false;
bUseRTTI = true;
bEnableExceptions = true;
}
public Carla(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Carla.h";
if (IsWindows(Target))
{
bEnableExceptions = true;
}
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",
"RenderCore",
"RHI"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AIModule",
"AssetRegistry",
"CoreUObject",
"Engine",
"Foliage",
"ImageWriteQueue",
"Json",
"JsonUtilities",
"Landscape",
"PhysX",
"PhysXVehicles",
"PhysXVehicleLib",
"Slate",
"SlateCore"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
AddCarlaServerDependency(Target);
}
public NetGameCPP(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
}
public TheEternalTower(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "UMG", "Slate", "SlateCore" });
}
public DataStreamCore(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "ViconDataStreamSDK" });
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
}
public AppleARKit(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
"AppleARKit/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"AppleARKit/Private",
"../../../../Source/Runtime/Renderer/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Engine",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Slate",
"SlateCore",
"RHI",
"Renderer",
"RenderCore",
"ShaderCore",
"HeadMountedDisplay",
"IOSRuntimeSettings",
"AugmentedReality",
"ProceduralMeshComponent",
"LiveLink",
"LiveLinkInterface",
// "OnlineSubsystem",
"Sockets"
// ... 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.IOS)
{
PublicDefinitions.Add("ARKIT_SUPPORT=1");
PublicFrameworks.Add("ARKit");
}
else
{
PublicDefinitions.Add("ARKIT_SUPPORT=0");
}
}
public UC_TestingGrounds(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay" });
}
public ComputeShaderPlugin(ReadOnlyTargetRules Target) : base(Target)
{
//Our PrivatePCH that we want to globally #include
PrivatePCHHeaderFile = "Private/PrivatePCH.h";
// Make sure UBT reminds us of how to keep the project IWYU compliant
bEnforceIWYU = true;
//Enable IWYU but keep our PrivatePCH in use
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 ...
"Private",
"Private/WeatherActor",
"Private/Module_ShaderTools",
"Private/ShaderDebugUtils"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"RHI"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"Projects", //<-Needed for IPluginManager, so we can get the shader directory in our plugin // Might not be needed anymore 4.21+?
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public ADIG(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
}
public SeqExEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
PublicIncludePaths.AddRange(new string[]
{
"SeqExEditor/Public"
});
PrivateIncludePaths.AddRange(new string[]
{
"SeqExEditor/Private"
});
PublicDependencyModuleNames.AddRange(new string[]
{
"Core",
"CoreUObject",
"Engine",
"Slate",
"AnimGraphRuntime",
"BlueprintGraph",
});
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(new string[]
{
"UnrealEd",
"GraphEditor",
"SeqEx",
"Sequencer",
"MovieScene",
});
}
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Persona",
"SkeletonEditor",
"AdvancedPreviewScene",
}
);
PrivateDependencyModuleNames.AddRange(new string[]
{
"InputCore",
"SlateCore",
"UnrealEd",
"GraphEditor",
"PropertyEditor",
"ContentBrowser",
"AnimGraph",
"ToolMenus",
"LevelSequence",
"ActorSequence",
"MovieScene",
});
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(new string[]
{
//"EditorStyle",
});
}
//PrivateDependencyModuleNames.AddRange(new string[] { "UnrealEd" });
PrivateIncludePathModuleNames.AddRange(new string[] { });
DynamicallyLoadedModuleNames.AddRange(new string[] { });
}
public TreeArchitectEditor(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"TreeArchitectEditor/Private",
"TreeArchitectRuntime/Private",
// ... add other private include paths required here ...
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Settings",
"IntroTutorials",
"AssetTools"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Slate",
"EditorStyle",
"UnrealEd",
"KismetWidgets",
"GraphEditor",
"RHI",
"RenderCore",
"ShaderCore",
"Landscape",
"Kismet", // for FWorkflowCentricApplication
"Projects",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"InputCore",
"SlateCore",
"RenderCore",
"PropertyEditor",
"WorkspaceMenuStructure",
"LevelEditor",
"EditorStyle",
"ContentBrowser",
"TreeArchitectRuntime",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public VictoryBPLibrary(ReadOnlyTargetRules Target) : base(Target)
{
//Get rid of debug commandline length compile error
//https://developercommunity.visualstudio.com/content/problem/668411/command-line-error-d8049-still-happening.html
bLegacyPublicIncludePaths = false;
PrivatePCHHeaderFile = "Private/VictoryBPLibraryPrivatePCH.h";
//4.15 Include What You Use
bEnforceIWYU = false;
PublicIncludePaths.AddRange(
new string[] {
"VictoryBPLibrary/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"VictoryBPLibrary/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"RHI",
"RenderCore",
"HTTP",
"UMG", "Slate", "SlateCore",
"ImageWrapper",
"PhysicsCore",
"PhysX",
"HeadMountedDisplay",
"AIModule",
"NavigationSystem",
"Vorbis",
//FPlatformApplicationMisc
"ApplicationCore",
//For UDeveloperSettings, FYI <3 Rama
"DeveloperSettings"
}
);
//APEX EXCLUSIONS
if (Target.Platform != UnrealTargetPlatform.Android && Target.Platform != UnrealTargetPlatform.IOS)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"APEX"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"ApexDestruction"
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public Udemy5TestingGrounds(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "AIModule", "GameplayTasks", "NavigationSystem" });
}
public Endless(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
MinFilesUsingPrecompiledHeaderOverride = 1;
bFasterWithoutUnity = true;
}
public Blast(ReadOnlyTargetRules Target)
: base(Target)
{
Type = ModuleType.External;
// Determine which kind of libraries to link against
BlastLibraryMode LibraryMode = GetBlastLibraryMode(Target.Configuration);
string LibConfiguration = GetBlastLibraryConfiguration(LibraryMode);
string BlastDir = ModuleDirectory;
PublicIncludePaths.AddRange(
new string[] {
BlastDir + "/common",
BlastDir + "/lowlevel/include",
BlastDir + "/globals/include",
BlastDir + "/extensions/physx/include",
BlastDir + "/extensions/authoring/include",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"PhysX",
});
List < string> BlastLibraries = new List<string>();
BlastLibraries.AddRange(
new string[]
{
"NvBlast",
"NvBlastGlobals",
"NvBlastExtAuthoring"
});
string LibSuffix = null;
string DllSuffix = null;
// Libraries for windows platform
if (Target.Platform == UnrealTargetPlatform.Win64)
{
LibSuffix = "_x64.lib";
DllSuffix = "_x64.dll";
string BlastLibDirFullPath = BlastDir + "/Lib/Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
PublicLibraryPaths.Add(BlastLibDirFullPath);
}
// TODO: Other configurations?
if(LibSuffix != null)
{
foreach (string Lib in BlastLibraries)
{
string LibName = String.Format("{0}{1}{2}", Lib, LibConfiguration, LibSuffix);
PublicAdditionalLibraries.Add(LibName);
string BlastDllDirFullPath = PluginDirectory + "/Binaries/Win64/";
string DllName = String.Format("{0}{1}{2}", Lib, LibConfiguration, DllSuffix);
RuntimeDependencies.Add(Path.Combine(BlastDllDirFullPath, DllName));
}
}
}
public ProjectPassionFruit(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "CableComponent" });
}
public slua_unreal(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
// enable exception
bEnableExceptions = true;
bEnforceIWYU = false;
bEnableUndefinedIdentifierWarnings = false;
var externalSource = Path.Combine(ModuleDirectory, "../../External");
var externalLib = Path.Combine(ModuleDirectory, "../../Library");
PublicIncludePaths.AddRange(
new string[] {
externalSource,
Path.Combine(externalSource, "lua"),
// ... add public include paths required here ...
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalLibraries.Add(Path.Combine(externalLib, "iOS/liblua.a"));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
#if UE_4_24_OR_LATER
PublicAdditionalLibraries.Add(Path.Combine(externalLib, "Android/armeabi-arm64/liblua.a"));
PublicAdditionalLibraries.Add(Path.Combine(externalLib, "Android/armeabi-v7a/liblua.a"));
PublicAdditionalLibraries.Add(Path.Combine(externalLib, "Android/x86/liblua.a"));
#else
PublicLibraryPaths.Add(Path.Combine(externalLib, "Android/armeabi-arm64"));
PublicLibraryPaths.Add(Path.Combine(externalLib, "Android/armeabi-v7a"));
PublicLibraryPaths.Add(Path.Combine(externalLib, "Android/x86"));
PublicAdditionalLibraries.Add("lua");
#endif
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicAdditionalLibraries.Add(Path.Combine(externalLib, "Win32/lua.lib"));
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.Add(Path.Combine(externalLib, "Win64/lua.lib"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(Path.Combine(externalLib, "Mac/liblua.a"));
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PublicAdditionalLibraries.Add(Path.Combine(externalLib, "Linux/liblua.a"));
}
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"UMG",
// ... add other public dependencies that you statically link with here ...
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
PrivateDependencyModuleNames.Add("UnrealEd");
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"UMG",
// ... add private dependencies that you statically link with here ...
}
);
#if UE_4_21_OR_LATER
PublicDefinitions.Add("ENABLE_PROFILER");
#else
Definitions.Add("ENABLE_PROFILER");
#endif
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public TP_SideScroller(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
}
public HoudiniEngineRuntime(ReadOnlyTargetRules Target) : base(Target)
{
bPrecompile = true;
PCHUsage = PCHUsageMode.UseSharedPCHs;
PrivatePCHHeaderFile = "Private/HoudiniEngineRuntimePrivatePCH.h";
// Check if we are compiling for unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac &&
Target.Platform != UnrealTargetPlatform.Linux &&
Target.Platform != UnrealTargetPlatform.Switch)
{
System.Console.WriteLine(string.Format("Houdini Engine: Compiling for untested target platform. Please let us know how it goes!"));
}
// Find HFS
string HFSPath = GetHFSPath();
HFSPath = HFSPath.Replace("\\", "/");
if (HFSPath != "")
{
string Log = string.Format("Houdini Engine: Found Houdini in {0}", HFSPath);
System.Console.WriteLine(Log);
PlatformID buildPlatformId = Environment.OSVersion.Platform;
if (buildPlatformId == PlatformID.Win32NT)
{
PublicDefinitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath);
}
}
// Find the HAPI include directory
string HAPIIncludePath = HFSPath + "/toolkit/include/HAPI";
if (!Directory.Exists(HAPIIncludePath))
{
// Add the custom include path as well in case the toolkit path doesn't exist yet.
HAPIIncludePath = HFSPath + "/custom/houdini/include/HAPI";
if (!Directory.Exists(HAPIIncludePath))
{
System.Console.WriteLine(string.Format("Couldn't find the HAPI include folder!"));
HAPIIncludePath = "";
}
}
if (HAPIIncludePath != "")
{
PublicIncludePaths.Add(HAPIIncludePath);
}
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "Public/HAPI"),
Path.Combine(ModuleDirectory, "Public")
}
);
PrivateIncludePaths.AddRange(
new string[] {
"HoudiniEngineRuntime/Private"
}
);
// Add common dependencies.
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"ShaderCore",
"InputCore",
"RHI",
"Foliage",
"Landscape"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
// ... add private dependencies that you statically link with here ...
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AppFramework",
"AssetTools",
"EditorStyle",
"EditorWidgets",
"LevelEditor",
"MainFrame",
"MeshPaint",
"Projects",
"PropertyEditor",
"RawMesh",
"Settings",
"Slate",
"SlateCore",
"TargetPlatform",
"UnrealEd",
"ApplicationCore",
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public UMGEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/UMGEditor/Private", // For PCH includes (because they don't work with relative paths, yet)
"Editor/UMGEditor/Private/Templates",
"Editor/UMGEditor/Private/Extensions",
"Editor/UMGEditor/Private/Customizations",
"Editor/UMGEditor/Private/BlueprintModes",
"Editor/UMGEditor/Private/TabFactory",
"Editor/UMGEditor/Private/Designer",
"Editor/UMGEditor/Private/Hierarchy",
"Editor/UMGEditor/Private/Palette",
"Editor/UMGEditor/Private/Details",
"Editor/UMGEditor/Private/DragDrop",
"Editor/UMGEditor/Private/Utility",
});
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetTools",
"UMG",
});
PublicDependencyModuleNames.AddRange(
new string[]
{
"Sequencer",
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"InputCore",
"Engine",
"AssetTools",
"UnrealEd", // for FAssetEditorManager
"KismetWidgets",
"KismetCompiler",
"BlueprintGraph",
"GraphEditor",
"Kismet", // for FWorkflowCentricApplication
"PropertyPath",
"PropertyEditor",
"UMG",
"EditorStyle",
"Slate",
"SlateCore",
"MessageLog",
"MovieScene",
"MovieSceneTools",
"MovieSceneTracks",
"DetailCustomizations",
"Settings",
"RenderCore",
"TargetPlatform",
"TimeManagement",
"GameProjectGeneration",
"PropertyPath",
"ToolMenus",
}
);
}
public PropertyEditor(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"ActorPickerMode",
"SceneDepthPickerMode",
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"IntroTutorials"
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Editor/PropertyEditor/Private",
"Editor/PropertyEditor/Private/Presentation",
"Editor/PropertyEditor/Private/Presentation/PropertyTable",
"Editor/PropertyEditor/Private/Presentation/PropertyEditor",
"Editor/PropertyEditor/Private/Presentation/PropertyDetails",
"Editor/PropertyEditor/Private/UserInterface",
"Editor/PropertyEditor/Private/UserInterface/PropertyTable",
"Editor/PropertyEditor/Private/UserInterface/PropertyEditor",
"Editor/PropertyEditor/Private/UserInterface/PropertyTree",
"Editor/PropertyEditor/Private/UserInterface/PropertyDetails",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MainFrame",
"AssetRegistry",
"AssetTools",
"ClassViewer",
"ContentBrowser",
"ConfigEditor",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"EditorStyle",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"EditorWidgets",
"Documentation",
"RHI",
"ConfigEditor",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"ClassViewer",
"ContentBrowser",
"MainFrame",
}
);
}
public UrbanTraffic(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",
"PhysXVehicles"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
PublicDefinitions.Add("IA_MOVE_FORWARD=\"MoveForward\"");
PublicDefinitions.Add("IA_MOVE_RIGHT=\"MoveRight\"");
PublicDefinitions.Add("IA_MOVE_BRAKE=\"Brake\"");
PublicDefinitions.Add("IA_INTERACTIVE=\"Interactive\"");
PublicDefinitions.Add("IA_AUTONOMOUS=\"Autonomous\"");
PublicDefinitions.Add("IA_FLASHLIGHT=\"Flashlight\"");
PublicDefinitions.Add("IA_SIDELIGHT_L=\"SideLeft\"");
PublicDefinitions.Add("IA_SIDELIGHT_R=\"SideRight\"");
PublicDefinitions.Add("IA_SIDELIGHT_O=\"SideNone\"");
PublicDefinitions.Add("IA_CAMERA_SWITCH=\"SwitchCamera\"");
PublicDefinitions.Add("IA_CAMERA_ZOOM=\"ZoomCamera\"");
PublicDefinitions.Add("IA_CAMERA_UP=\"LookUp\"");
PublicDefinitions.Add("IA_CAMERA_RIGHT=\"LookRight\"");
}
public UMG(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/UMG/Private" // For PCH includes (because they don't work with relative paths, yet)
})
;
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"ShaderCore",
"RenderCore",
"RHI",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"HTTP",
"MovieScene",
"MovieSceneTracks",
"PropertyPath",
"TimeManagement"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"ImageWrapper",
"TargetPlatform",
}
);
if (Target.Type != TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateRHIRenderer",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ImageWrapper",
"SlateRHIRenderer",
}
);
}
if (Target.Type == TargetType.Editor)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
}
);
}
}
public CashUI(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "UMG", "Slate", "SlateCore" });
}
