public Chartboost(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Developer/Chartboost/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"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 ...
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Settings"
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"Chartboost",
"../../lib/iOS/Chartboost.embeddedframework.zip"
)
);
PublicFrameworks.AddRange(
new string[]
{
"StoreKit",
"Foundation",
"CoreGraphics",
"UIKit"
}
);
}
}
public CognitiveVR(ReadOnlyTargetRules Target): base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePathModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Analytics"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"CognitiveVR/Private",
"CognitiveVR/Public",
"CognitiveVR/Private/util"
// ... add other private include paths required here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay",
"Slate",
"SlateCore"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"AnalyticsBlueprintLibrary",
"Analytics",
"AnalyticsVisualEditing",
"Projects",
"HTTP",
"Json",
"JsonUtilities",
"UMG"
}
);
var pluginsDirectory = System.IO.Path.Combine(Target.ProjectFile.Directory.ToString(),"Plugins");
//Varjo
if (System.IO.Directory.Exists(System.IO.Path.Combine(pluginsDirectory,"Varjo")))
{
System.Console.WriteLine("CognitiveVR.Build.cs found Varjo Plugin folder");
PublicDependencyModuleNames.Add("VarjoHMD");
PublicDependencyModuleNames.Add("VarjoEyeTracker");
}
//TobiiEyeTracking
if (System.IO.Directory.Exists(System.IO.Path.Combine(pluginsDirectory,"TobiiEyeTracking")))
{
System.Console.WriteLine("CognitiveVR.Build.cs found TobiiEyeTracking Plugin folder");
PrivateIncludePaths.AddRange(
new string[] {
"../../TobiiEyeTracking/Source/TobiiCore/Private",
"../../TobiiEyeTracking/Source/TobiiCore/Public"
});
PublicDependencyModuleNames.Add("TobiiCore");
}
//Vive Pro Eye (SRanipal)
if (System.IO.Directory.Exists(System.IO.Path.Combine(pluginsDirectory,"SRanipal")))
{
//ideally read the uplugin file as json and get the VersionName
//for now, just read the source directory layout
var sranipalPlugin = System.IO.Path.Combine(pluginsDirectory,"SRanipal");
var sranipalSource = System.IO.Path.Combine(sranipalPlugin,"Source");
string[] sourceModules = System.IO.Directory.GetDirectories(sranipalSource);
if (sourceModules.Length == 2)//1.1.0.1 and 1.2.0.1 only have eye and lip modules
{
Definitions.Add("SRANIPAL_1_2_API");
System.Console.WriteLine("CognitiveVR.Build.cs found SRanipal Plugin folder");
PrivateIncludePaths.AddRange(
new string[] {
"../../SRanipal/Source/SRanipal/Private",
"../../SRanipal/Source/SRanipal/Public"
});
PublicDependencyModuleNames.Add("SRanipal");
string BaseDirectory = System.IO.Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", "..", ".."));
string SRanipalDir = System.IO.Path.Combine(BaseDirectory,"SRanipal","Binaries",Target.Platform.ToString());
PublicAdditionalLibraries.Add(System.IO.Path.Combine(SRanipalDir,"SRanipal.lib"));
PublicDelayLoadDLLs.Add(System.IO.Path.Combine(SRanipalDir,"SRanipal.dll"));
}
else if (sourceModules.Length == 5)
{
Definitions.Add("SRANIPAL_1_3_API");
System.Console.WriteLine("CognitiveVR.Build.cs found SRanipal Plugin folder 1.3.0.9 or newer");
PrivateIncludePaths.AddRange(
new string[] {
"../../SRanipal/Source/SRanipal/Private",
"../../SRanipal/Source/SRanipal/Public",
"../../SRanipal/Source/SRanipalEye/Private",
"../../SRanipal/Source/SRanipalEye/Public",
"../../SRanipal/Source/SRanipalEyeTracker/Private",
"../../SRanipal/Source/SRanipalEyeTracker/Public"
});
PublicDependencyModuleNames.Add("SRanipal");
PublicDependencyModuleNames.Add("SRanipalEye");
PublicDependencyModuleNames.Add("SRanipalEyeTracker");
string BaseDirectory = System.IO.Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", "..", ".."));
string SRanipalDir = System.IO.Path.Combine(BaseDirectory,"SRanipal","Binaries",Target.Platform.ToString());
PublicAdditionalLibraries.Add(System.IO.Path.Combine(SRanipalDir,"SRanipal.lib"));
PublicDelayLoadDLLs.Add(System.IO.Path.Combine(SRanipalDir,"SRanipal.dll"));
}
}
//Pico Neo 2 Eye
if (System.IO.Directory.Exists(System.IO.Path.Combine(pluginsDirectory,"PicoMobile")))
{
System.Console.WriteLine("CognitiveVR.Build.cs found Pico Plugin folder");
PublicDependencyModuleNames.Add("PicoMobile");
}
//HP Omnicept
if (System.IO.Directory.Exists(System.IO.Path.Combine(pluginsDirectory, "HPGlia")))
{
System.Console.WriteLine("CognitiveVR.Build.cs found HP Glia Omnicept folder");
PublicDependencyModuleNames.Add("HPGlia");
}
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
// Add __WINDOWS_WASAPI__ so that RtAudio compiles with WASAPI
PublicDefinitions.Add("__WINDOWS_DS__");
// Allow us to use direct sound
AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectSound");
string DirectXSDKDir = Target.UEThirdPartySourceDirectory + "Windows/DirectX";
PublicSystemIncludePaths.Add( DirectXSDKDir + "/include");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicLibraryPaths.Add( DirectXSDKDir + "/Lib/x64");
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicLibraryPaths.Add( DirectXSDKDir + "/Lib/x86");
}
PublicAdditionalLibraries.AddRange(
new string[] {
"dxguid.lib",
"dsound.lib"
}
);
}
}
public DetailCustomizations(TargetInfo 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",
"DesktopWidgets",
"Engine",
"Landscape",
"InputCore",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"EditorWidgets",
"KismetWidgets",
"MovieSceneCapture",
"MovieSceneTools",
"SharedSettingsWidgets",
"ContentBrowser",
"BlueprintGraph",
"AnimGraph",
"PropertyEditor",
"LevelEditor",
"DesktopPlatform",
"ClassViewer",
"TargetPlatform",
"ExternalImagePicker",
"MoviePlayer",
"SourceControl",
"InternationalizationSettings",
"SourceCodeAccess",
"RHI",
"HardwareTargeting",
"SharedSettingsWidgets",
"AIModule",
"MeshUtilities",
"ConfigEditor",
"Persona",
"CinematicCamera",
"ComponentVisualizers",
"SkeletonEditor",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Engine",
"Media",
"Landscape",
"LandscapeEditor",
"PropertyEditor",
"GameProjectGeneration",
"ComponentVisualizers",
"GraphEditor"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Layers",
"GameProjectGeneration",
}
);
}
public HoudiniEngineEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseSharedPCHs;
bool bIsRelease = true;
string HFSPath = "";
string HoudiniVersion = "16.0.772";
// Check if we are compiling on unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac &&
Target.Platform != UnrealTargetPlatform.Linux)
{
string Err = string.Format("Houdini Engine Runtime: Compiling on unsupported platform.");
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
if (bIsRelease)
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// We first check if Houdini Engine is installed.
string HPath = "C:/Program Files/Side Effects Software/Houdini Engine " + HoudiniVersion;
if (!Directory.Exists(HPath))
{
// If Houdini Engine is not installed, we check for Houdini installation.
HPath = "C:/Program Files/Side Effects Software/Houdini " + HoudiniVersion;
if (!Directory.Exists(HPath))
{
if (!Directory.Exists(HFSPath))
{
string Err = string.Format("Houdini Engine : Please install Houdini or Houdini Engine {0}", HoudiniVersion);
System.Console.WriteLine(Err);
}
}
else
{
HFSPath = HPath;
}
}
else
{
HFSPath = HPath;
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string HPath = "/Applications/Houdini/Houdini" + HoudiniVersion + "/Frameworks/Houdini.framework/Versions/Current/Resources";
if (!Directory.Exists(HPath))
{
if (!Directory.Exists(HFSPath))
{
string Err = string.Format("Houdini Engine : Please install Houdini {0}", HoudiniVersion);
System.Console.WriteLine(Err);
}
}
else
{
HFSPath = HPath;
}
}
else
{
HFSPath = System.Environment.GetEnvironmentVariable("HFS");
System.Console.WriteLine("Linux - found HFS:" + HFSPath);
}
}
string HAPIIncludePath = "";
if (HFSPath != "")
{
HAPIIncludePath = HFSPath + "/toolkit/include/HAPI";
if (Target.Platform == UnrealTargetPlatform.Win64)
{
Definitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath);
}
}
if (HAPIIncludePath != "")
{
PublicIncludePaths.Add(HAPIIncludePath);
// Add the custom include path as well in case the toolkit path doesn't exist yet.
PublicIncludePaths.Add(HFSPath + "/custom/houdini/include/HAPI");
}
PublicIncludePaths.AddRange(
new string[] {
"HoudiniEngineRuntime/Public/HAPI",
"HoudiniEngineRuntime/Public",
"HoudiniEngineEditor/Public"
}
);
PrivateIncludePaths.AddRange(
new string[] {
"HoudiniEngineEditor/Private",
"HoudiniEngineRuntime/Private"
}
);
// Add common dependencies.
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"HoudiniEngineRuntime",
"Slate",
"SlateCore",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AppFramework",
"AssetTools",
"ContentBrowser",
"DesktopWidgets",
"EditorStyle",
"EditorWidgets",
"Engine",
"InputCore",
"LevelEditor",
"MainFrame",
"PlacementMode",
"Projects",
"PropertyEditor",
"RHI",
"RawMesh",
"RenderCore",
"ShaderCore",
"TargetPlatform",
"UnrealEd"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public KinectUnreal(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
//OptimizeCode = CodeOptimization.Never;
string KinectPathEnvVar = "%KINECTSDK20_DIR%";
string ExpandedKinectEnvVar = Environment.ExpandEnvironmentVariables(KinectPathEnvVar);
//NOTE (OS): Safety check for comptuers that don't have the kinect plugin
if (KinectPathEnvVar == ExpandedKinectEnvVar)
{
var err = "ERROR : Environment variable {0} does not exist in this Windows environment. Check if the Kinect for Windows 2.0 plugin is installed.";
Console.WriteLine(err, KinectPathEnvVar);
throw new Exception(err);
}
string ThirdPartyKinectIncludePath = Path.Combine(ExpandedKinectEnvVar, "inc");
string PlatformSpec = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64" : "x86";
string ThirdPartyKinectLibPath = Path.Combine(ExpandedKinectEnvVar, "Lib", PlatformSpec);
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyKinectLibPath, "Kinect20.lib"));
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyKinectLibPath, "Kinect20.Face.lib"));
string kinectFaceDll = Path.Combine(ExpandedKinectEnvVar, "bin", "Kinect20.Face.dll");
System.Console.WriteLine("Module Directory " + GetUProjectPath());
PublicDelayLoadDLLs.Add(kinectFaceDll);
//RuntimeDependencies.Add(kinectFaceDll, StagedFileType.NonUFS);
CopyToBinaries(kinectFaceDll, Target);
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"KinectUnreal/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"KinectUnreal/Private",
ThirdPartyKinectIncludePath
// ... 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",
"RHI",
"RenderCore"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public GameSystemEditor(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
"GameSystem",
"GameSystem/Public",
"GameSystemEditor",
"GameSystemEditor/Public",
"GameWeapons",
"GameWeapons/Public",
"GameWeaponsEditor",
"GameWeaponsEditor/Public",
"GameAbilities",
"GameAbilities/Public",
"GameAbilitiesEditor",
"GameAbilitiesEditor/Public",
"GameAttributes",
"GameAttributes/Effects",
"GameAttributes/Public",
"GameAttributesEditor",
"GameAttributesEditor/Public",
"GameInventorySystem",
"GameInventorySystem/Public",
"GameInventorySystemEditor",
"GameInventorySystemEditor/Public",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"GameSystem/Private",
"GameSystemEditor/Private",
"GameWeapons/Private",
"GameWeaponsEditor/Private",
"GameAbilities/Private",
"GameAbilitiesEditor/Private",
"GameAttributes/Private",
"GameAttributesEditor/Private",
"GameInventorySystem/Private",
"GameInventorySystemEditor/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Engine",
"CoreUObject",
"UnrealEd",
"BlueprintGraph",
"GraphEditor",
"PropertyEditor",
"SlateCore",
"Slate",
"EditorStyle",
"Kismet",
"KismetCompiler",
"AssetTools",
"MainFrame",
"InputCore",
"GameplayTasksEditor",
"GameSystem",
"GameAbilities",
"GameWeapons",
"GameWeaponsEditor",
"GameAttributes",
"GameInventorySystem",
"GameAbilitiesEditor",
"GameAttributesEditor",
"GameInventorySystemEditor"
// ... 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 ...
}
);
}
public VRM4U(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
//"VRM4U/Public",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
//"VRM4U/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RHI",
"RenderCore",
"AnimGraphRuntime",
"LiveLinkInterface",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Slate",
"SlateCore",
"Engine",
"AssetRegistry",
"CinematicCamera",
// ... add private dependencies that you statically link with here ...
}
);
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.Add("UnrealEd");
PrivateDependencyModuleNames.Add("LevelEditor");
PublicDependencyModuleNames.Add("LevelSequence");
PublicDependencyModuleNames.Add("LevelSequenceEditor");
PublicDependencyModuleNames.Add("Sequencer");
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
bool bUseQuestTracking = false; //(Target.Version.MinorVersion >= 25)
if (bUseQuestTracking)
{
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"OculusHMD",
"OVRPlugin",
});
PublicDelayLoadDLLs.Add("OVRPlugin.dll");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Oculus/OVRPlugin/OVRPlugin/" + Target.Platform.ToString() + "/OVRPlugin.dll");
PublicDefinitions.Add("WITH_VRM4U_HMD_TRACKER=1");
}
else
{
PublicDefinitions.Add("WITH_VRM4U_HMD_TRACKER=0");
}
}
else
{
PublicDefinitions.Add("WITH_VRM4U_HMD_TRACKER=0");
}
}
public LandscapeEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"Slate",
"SlateCore",
"EditorStyle",
"Engine",
"Landscape",
"LandscapeEditorUtilities",
"RenderCore",
"RHI",
"InputCore",
"UnrealEd",
"PropertyEditor",
"ImageWrapper",
"EditorWidgets",
"Foliage",
"ViewportInteraction",
"VREditor",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"ViewportInteraction",
"VREditor"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MainFrame",
"DesktopPlatform",
"ContentBrowser",
"AssetTools",
"LevelEditor"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MainFrame",
"DesktopPlatform",
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
// VS2015 updated some of the CRT definitions but not all of the Windows SDK has been updated to match.
// Microsoft provides this shim library to enable building with VS2015 until they fix everything up.
//@todo: remove when no longer neeeded (no other code changes should be necessary).
if (Target.WindowsPlatform.bNeedsLegacyStdioDefinitionsLib)
{
PublicSystemLibraries.Add("legacy_stdio_definitions.lib");
}
}
// KissFFT is used by the smooth tool.
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Kiss_FFT");
}
else
{
PublicDefinitions.Add("WITH_KISSFFT=0");
}
}
public USemLog(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
//PrivatePCHHeaderFile = "Public/USemLog.h";
//bEnforceIWYU = false;
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",
"MongoC", // SL_WITH_LIBMONGO_C
"UProtobuf", // SL_WITH_PROTO
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"Landscape",
"WebSockets",
"CinematicCamera",
//"Landscape", "AIModule", // whitelisted actors when setting the world to visual only
//"UConversions", // SL_WITH_ROS_CONVERSIONS
//"UMCGrasp", // SL_WITH_MC_GRASP
//"SRanipal", // SL_WITH_EYE_TRACKING
//"SlicingLogic", // SL_WITH_SLICING
//"MongoCxx", // SL_WITH_LIBMONGO_CXX
//"Boost", // SL_WITH_BOOST
// ... add private dependencies that you statically link with here ...
}
);
// Avoiding depending on the editor when packaging
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd",
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
// Enable/disable various debug functions throughout the code
PublicDefinitions.Add("SL_WITH_DEBUG=1");
// Check included dependencies and set preprocessor flags accordingly
SetDependencyPrepreocessorDefinition("UConversions", "SL_WITH_ROS_CONVERSIONS");
SetDependencyPrepreocessorDefinition("UMCGrasp", "SL_WITH_MC_GRASP");
SetDependencyPrepreocessorDefinition("MongoC", "SL_WITH_LIBMONGO_C");
SetDependencyPrepreocessorDefinition("MongoCxx", "SL_WITH_LIBMONGO_CXX");
SetDependencyPrepreocessorDefinition("SRanipal", "SL_WITH_EYE_TRACKING");
SetDependencyPrepreocessorDefinition("SlicingLogic", "SL_WITH_SLICING");
SetDependencyPrepreocessorDefinition("UProtobuf", "SL_WITH_PROTO");
SetDependencyPrepreocessorDefinition("UROSBridge", "SL_WITH_ROSBRIDGE");
string Json = PrivateDependencyModuleNames.Find(DependencyName => DependencyName.Equals("Json"));
string JsonUtil = PrivateDependencyModuleNames.Find(DependencyName => DependencyName.Equals("JsonUtilities"));
if (string.IsNullOrEmpty(Json) || string.IsNullOrEmpty(JsonUtil))
{
PublicDefinitions.Add("SL_WITH_JSON=0");
}
else
{
PublicDefinitions.Add("SL_WITH_JSON=1");
}
string UViz = PrivateDependencyModuleNames.Find(DependencyName => DependencyName.Equals("UViz"));
if (string.IsNullOrEmpty(UViz))
{
UViz = PublicDependencyModuleNames.Find(DependencyName => DependencyName.Equals("UViz"));
}
string UMongoQA = PrivateDependencyModuleNames.Find(DependencyName => DependencyName.Equals("UMongoQA"));
if (string.IsNullOrEmpty(UMongoQA))
{
UMongoQA = PublicDependencyModuleNames.Find(DependencyName => DependencyName.Equals("UMongoQA"));
}
if (string.IsNullOrEmpty(UViz) || string.IsNullOrEmpty(UMongoQA))
{
PublicDefinitions.Add("SL_WITH_DATA_VIS=0");
}
else
{
PublicDefinitions.Add("SL_WITH_DATA_VIS=1");
}
}
public ShooterGame(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"ShooterGame/Public",
"Plugins/ShooterGame/Source/ShooterGame/Public",
"ShooterGame/Public/Online",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"ShooterGame/Public/Online",
"ShooterGame/Classes/Player",
"ShooterGame/Private",
"ShooterGame/Private/UI",
"ShooterGame/Private/UI/Menu",
"ShooterGame/Private/UI/Style",
"ShooterGame/Private/UI/Widgets",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"OnlineSubsystem",
"OnlineSubsystemUtils",
"AssetRegistry",
"AIModule",
"GameplayTasks",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"InputCore",
"Slate",
"SlateCore",
"ShooterGameLoadingScreen",
"Json",
"ApplicationCore"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"OnlineSubsystemNull",
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"LocalFileNetworkReplayStreaming"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"NetworkReplayStreaming"
}
);
}
public SSCPlugins(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
//PublicIncludePaths.Add(ModuleDirectory);
//PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "CommandShop"));
//PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "MultiViewPort"));
//PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "SSCInventory"));
//PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "VisualCustomWidget"));
PublicIncludePaths.AddRange(
new string[] {
}
);
PrivateIncludePaths.AddRange(
new string[] {
"SSCPlugins",
"SSCPlugins/Private",
"SSCPlugins/Public",
"SSCPlugins/Public/SSCCommon",
"SSCPlugins/Private/SSCCommon",
"SSCPlugins/Public/SSCCore",
"SSCPlugins/Private/SSCCore",
"SSCPlugins/Public/SSCGame",
"SSCPlugins/Private/SSCGame",
"SSCPlugins/Public/SSCObject",
"SSCPlugins/Private/SSCObject",
"SSCPlugins/Public/SSCTest",
"SSCPlugins/Private/SSCTest",
"SSCPlugins/Public/SSCUI",
"SSCPlugins/Private/SSCUI",
"SSCPlugins/SSCInventory/Public",
"SSCPlugins/SSCInventory/Private",
"SSCPlugins/SimpleGizmo/Public",
"SSCPlugins/SimpleGizmo/Private",
"SSCPlugins/VisualCustomWidget/Public",
"SSCPlugins/VisualCustomWidget/Private",
"SSCPlugins/MultiViewPort/Public",
"SSCPlugins/MultiViewPort/Private",
"SSCPlugins/RunTimeCamera/Public",
"SSCPlugins/RunTimeCamera/Private",
"SSCPlugins/CommandShop/Public",
"SSCPlugins/CommandShop/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Projects",
"Slate",
"SlateCore"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"UMG",
"InputCore",
"XmlParser",
"Sockets",
"Json",
"Http",
"JsonUtilities",
"MoviePlayer",
"AIModule",
"GameplayTasks",
"HeadMountedDisplay",
"ProceduralMeshComponent",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public ROSIntegration(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string BSONPath = Path.Combine(ThirdPartyPath, "bson");
// Console.WriteLine("");
Console.WriteLine("BSONPath: " + BSONPath);
// Include std::string functions for rapidjson
#if UE_4_19_OR_LATER // works at least for 4.18.3, but not for 4.17.3 and below
PublicDefinitions.Add("RAPIDJSON_HAS_STDSTRING=1");
#else
Definitions.Add("RAPIDJSON_HAS_STDSTRING=1");
#endif
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"ROSIntegration/Private",
"ROSIntegration/Private/rosbridge2cpp"
// ... 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",
"Slate",
"SlateCore",
"Sockets",
"Networking"
// ... 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.Win64)
{
Console.WriteLine("Using Windows BSON files");
PublicAdditionalLibraries.Add(Path.Combine(BSONPath, "lib", "bson-static-1.0.lib"));
PublicIncludePaths.Add(Path.Combine(BSONPath, "include", "windows"));
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
Console.WriteLine("Using Linux BSON files");
PublicAdditionalLibraries.Add(Path.Combine(BSONPath, "lib", "libbson-1.0.a"));
PublicIncludePaths.Add(Path.Combine(BSONPath, "include", "linux"));
}
}
public PhononEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"PhononEditor/Private",
"Phonon/Private",
"Phonon/Public"
}
);
PublicIncludePaths.AddRange(
new string[] {
"Phonon/Public"
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"UnrealEd",
"LevelEditor",
"EditorStyle",
"RenderCore",
"ShaderCore",
"RHI",
"AudioEditor",
"AudioMixer",
"Phonon"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetTools",
"Landscape"
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"Slate",
"SlateCore",
"UnrealEd",
"AudioEditor",
"LevelEditor",
"Landscape",
"Core",
"CoreUObject",
"Engine",
"InputCore",
"PropertyEditor",
"Projects",
"EditorStyle",
"Phonon"
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "libPhonon");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11Audio");
}
public Vivox(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
string.Format("{0}/Public", ModuleDirectory),
}
);
PrivateIncludePaths.AddRange(
new string[] {
string.Format("{0}/Private", ModuleDirectory),
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"VivoxCoreLibrary",
"Projects",
"Engine",
"VivoxCore"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
// ... add private dependencies that you statically link with here ...
"VivoxCore"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
if (Target.Type != TargetRules.TargetType.Server)
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicDefinitions.Add("WITH_VIVOX=1");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicDefinitions.Add("WITH_VIVOX=1");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicDefinitions.Add("WITH_VIVOX=1");
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicDefinitions.Add("WITH_VIVOX=1");
}
else
{
PublicDefinitions.Add("WITH_VIVOX=0");
}
}
else
{
PublicDefinitions.Add("WITH_VIVOX=0");
}
// Build
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
}
public TextureFormatOodle(ReadOnlyTargetRules Target) : base(Target)
{
ShortName = "TextureFormatOodle";
PrivatePCHHeaderFile = "Private/TextureFormatOodlePCH.h";
PublicIncludePaths.Add(IncludeDirectory);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"TextureCompressor",
"Engine"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"Engine",
"ImageCore",
"ImageWrapper",
"RenderCore",
"AssetRegistry",
"InputCore",
"SlateCore"
}
);
string ReleaseLib = null;
string DebugLib = null;
string PlatformDir = Target.Platform.ToString();
// turn on bAllowDebugLibrary if you need to debug a problem with Oodle
bool bAllowDebugLibrary = false;
bool bUseDebugLibrary = bAllowDebugLibrary && Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT;
bool bSkipLibrarySetup = false;
if (Target.Platform == UnrealTargetPlatform.Win32)
{
ReleaseLib = "oo2tex_win32.lib";
DebugLib = "oo2tex_win32_debug.lib";
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Windows))
{
ReleaseLib = "oo2tex_win64.lib";
DebugLib = "oo2tex_win64_debug.lib";
PlatformDir = "Win64";
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
ReleaseLib = "liboo2texmac64.a";
DebugLib = "liboo2texmac64_dbg.a";
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
ReleaseLib = "liboo2texlinux64.a";
DebugLib = "liboo2texlinux64_dbg.a";
}
else if (Target.Platform == UnrealTargetPlatform.LinuxAArch64)
{
ReleaseLib = "liboo2texlinuxarm64.a";
DebugLib = "liboo2texlinuxarm64_dbg.a";
}
else
{
// the subclass will return the library names
ReleaseLib = ReleaseLibraryName;
DebugLib = DebugLibraryName;
// platform extensions don't need the Platform directory under lib
PlatformDir = "";
}
if (!bSkipLibrarySetup)
{
// combine everything and make sure it was set up properly
string LibraryToLink = bUseDebugLibrary ? DebugLib : ReleaseLib;
if (LibraryToLink == null)
{
throw new BuildException("Platform {0} doesn't have OodleData libraries properly set up.", Target.Platform);
}
PublicAdditionalLibraries.Add(Path.Combine(LibDirectory, PlatformDir, LibraryToLink));
}
}
public HoudiniEngineEditor(ReadOnlyTargetRules Target) : base(Target)
{
bPrecompile = true;
PCHUsage = PCHUsageMode.NoSharedPCHs;
PrivatePCHHeaderFile = "Private/HoudiniEngineEditorPrivatePCH.h";
// Check if we are compiling on unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac &&
Target.Platform != UnrealTargetPlatform.Linux)
{
string Err = string.Format("Houdini Engine Editor: Compiling for unsupported platform.");
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "Public")
}
);
PrivateIncludePaths.AddRange(
new string[] {
"HoudiniEngine/Private",
"HoudiniEngineRuntime/Private"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"PlacementMode"
}
);
// Add common dependencies.
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"HoudiniEngine",
"HoudiniEngineRuntime",
"Slate",
"SlateCore",
"Landscape",
"Foliage"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AppFramework",
"AssetTools",
"ContentBrowser",
"DesktopWidgets",
"EditorStyle",
"EditorWidgets",
"Engine",
"InputCore",
"LevelEditor",
"MainFrame",
"Projects",
"PropertyEditor",
"RHI",
"RawMesh",
"RenderCore",
"TargetPlatform",
"UnrealEd",
"ApplicationCore",
"CurveEditor",
"Json",
"SceneOutliner"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"PlacementMode",
}
);
}
public BatteryCollector(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "UMG" });
PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" });
}
public ImGui(TargetInfo Target)
#endif
{
#if WITH_FORWARDED_MODULE_RULES_CTOR
bool bBuildEditor = Target.bBuildEditor;
#else
bool bBuildEditor = (Target.Type == TargetRules.TargetType.Editor);
#endif
// Developer modules are automatically loaded only in editor builds but can be stripped out from other builds.
// Enable runtime loader, if you want this module to be automatically loaded in runtime builds (monolithic).
bool bEnableRuntimeLoader = true;
PCHUsage = PCHUsageMode.UseSharedPCHs;
#if UE_4_21_OR_LATER
PrivatePCHHeaderFile = "Private/ImGuiPrivatePCH.h";
#endif
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "../ThirdParty/ImGuiLibrary/Include")
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"ImGui/Private",
"ThirdParty/ImGuiLibrary/Private"
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Projects"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore"
// ... add private dependencies that you statically link with here ...
}
);
if (bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"EditorStyle",
"Settings",
"UnrealEd",
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
#if !UE_4_19_OR_LATER
List <string> PrivateDefinitions = Definitions;
#endif
PrivateDefinitions.Add(string.Format("RUNTIME_LOADER_ENABLED={0}", bEnableRuntimeLoader ? 1 : 0));
}
public Kick(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
PrivateDependencyModuleNames.AddRange(new string[] { });
}
public GameLiftServerSDK(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private"));
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public"));
PCHUsage = PCHUsageMode.UseSharedPCHs;
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Projects"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
// This is required to fix a warning for Unreal Engine 4.21 and later
PrivatePCHHeaderFile = "Private/GameLiftServerSDKPrivatePCH.h";
bEnableExceptions = true;
bEnforceIWYU = true;
string BaseDirectory = System.IO.Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", ".."));
string SDKDirectory = System.IO.Path.Combine(BaseDirectory, "ThirdParty", "GameLiftServerSDK", Target.Platform.ToString());
bool bHasGameLiftSDK = System.IO.Directory.Exists(SDKDirectory);
if (bHasGameLiftSDK)
{
if (Target.Type == TargetRules.TargetType.Server)
{
PublicDefinitions.Add("WITH_GAMELIFT=1");
if (Target.Platform == UnrealTargetPlatform.Linux)
{
SDKDirectory = System.IO.Path.Combine(SDKDirectory, "x86_64-unknown-linux-gnu");
string SDKLib = System.IO.Path.Combine(SDKDirectory, "libaws-cpp-sdk-gamelift-server.so");
PublicLibraryPaths.Add(SDKDirectory);
PublicAdditionalLibraries.Add(SDKLib);
RuntimeDependencies.Add(SDKLib);
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicLibraryPaths.Add(SDKDirectory);
PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-gamelift-server.lib"));
PublicDelayLoadDLLs.Add("aws-cpp-sdk-gamelift-server.dll");
string SDKLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-gamelift-server.dll");
RuntimeDependencies.Add(SDKLibWindows);
}
}
else
{
PublicDefinitions.Add("WITH_GAMELIFT=0");
}
}
else
{
PublicDefinitions.Add("WITH_GAMELIFT=0");
}
}
public NiagaraEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(new string[] {
"Editor/NiagaraEditor/Private",
"Editor/NiagaraEditor/Private/Toolkits",
"Editor/NiagaraEditor/Private/Widgets",
"Editor/NiagaraEditor/Private/Sequencer/NiagaraSequence",
"Editor/NiagaraEditor/Private/Sequencer/LevelSequence",
"Editor/NiagaraEditor/Private/ViewModels",
"Editor/NiagaraEditor/Private/TypeEditorUtilities"
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"Engine",
"RHI",
"Core",
"CoreUObject",
"InputCore",
"RenderCore",
"Slate",
"SlateCore",
"Kismet",
"EditorStyle",
"UnrealEd",
"VectorVM",
"Niagara",
"MovieScene",
"Sequencer",
"PropertyEditor",
"GraphEditor",
"ShaderFormatVectorVM",
"AppFramework",
"MovieSceneTools",
"MovieSceneTracks",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Engine",
"Messaging",
"LevelEditor",
"AssetTools",
"ContentBrowser",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Engine",
"Niagara",
"UnrealEd",
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"Engine",
"Niagara"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WorkspaceMenuStructure",
}
);
}
public Kismet(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Editor/Kismet/Private");
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"BlueprintRuntime",
"ClassViewer",
"Analytics",
"DerivedDataCache",
"LevelEditor",
"GameProjectGeneration",
"Sequencer",
}
);
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"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"BlueprintRuntime",
"ClassViewer",
"Documentation",
"GameProjectGeneration",
"BlueprintCompilerCppBackend",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"BlueprintGraph",
"UMGEditor",
}
);
}
public UnLua(ReadOnlyTargetRules Target) : base(Target)
{
bEnforceIWYU = false;
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
}
);
PrivateIncludePaths.AddRange(
new string[] {
"UnLua/Private",
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"ApplicationCore",
"Lua",
"LuaLibFeature"
}
);
PublicDependencyModuleNames.AddRange(new string[] {
"Lua"
});
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Slate",
"InputCore",
"Projects",
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
}
bool bAutoStartup = true;
if (bAutoStartup)
{
PublicDefinitions.Add("AUTO_UNLUA_STARTUP=1");
}
bool bWithUE4Namespace = false;
if (bWithUE4Namespace)
{
PublicDefinitions.Add("WITH_UE4_NAMESPACE=1");
}
bool bSupportsRpcCall = false;
if (bSupportsRpcCall)
{
PublicDefinitions.Add("SUPPORTS_RPC_CALL=1");
}
string[] EnableLibs =
{
"LibLuasocket",
"LuaPanda",
"LuaProtobuf",
"LibFmt"
};
// combine all enabled libs as LUA_LIBS macro
{
string EnabledLuaLibMacro = "LUA_LIBS=TEXT(\"";
foreach (var Lib in EnableLibs)
{
DynamicallyLoadedModuleNames.Add(Lib);
EnabledLuaLibMacro += Lib + ";";
}
EnabledLuaLibMacro += "\")";
PublicDefinitions.Add(EnabledLuaLibMacro);
}
bool EnableAllRegistedLuaLibs = false;
string EnableAllRegistedLualibsMacrro = "ENABLE_ALL_REGISTED_LUA_LIB=" + (EnableAllRegistedLuaLibs ? "1" : "0");
PublicDefinitions.Add(EnableAllRegistedLualibsMacrro);
OptimizeCode = CodeOptimization.InShippingBuildsOnly;
}
public Project_VoT(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "UMG", "AIModule" });
PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" });
}
public SteamVR(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"SteamVR/Private",
"../../../../../Source/Runtime/Renderer/Private",
"../../../../../Source/Runtime/VulkanRHI/Private",
// ... add other private include paths required here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RHI",
"RenderCore",
"UtilityShaders",
"Renderer",
"ShaderCore",
"InputCore",
"HeadMountedDisplay",
"Slate",
"SlateCore",
"ProceduralMeshComponent"
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
}
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenVR");
PrivateDependencyModuleNames.Add("D3D11RHI"); //@todo steamvr: multiplatform
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
PrivateDependencyModuleNames.Add("OpenGLDrv");
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
PrivateDependencyModuleNames.Add("VulkanRHI");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("IOSurface");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenVR");
PrivateDependencyModuleNames.AddRange(new string[] { "MetalRHI" });
}
else if (Target.Platform == UnrealTargetPlatform.Linux && Target.Architecture.StartsWith("x86_64"))
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenVR");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
PrivateDependencyModuleNames.Add("OpenGLDrv");
PrivateDependencyModuleNames.Add("VulkanRHI");
}
}
public AdvancePakEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
//"LauncherServices/Private",
}
);
PrivateIncludePaths.AddRange(
new string[] {
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"LauncherServices",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Projects",
"InputCore",
"UnrealEd",
"LevelEditor",
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"AdvancePak",
"UATHelper",
"EditorStyle",
"TargetPlatform",
"WorkspaceMenuStructure",
"PropertyEditor",
"Json",
"JsonUtilities"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public OptickPlugin(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Private",
"ThirdParty/Optick/src",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"EngineSettings",
"RenderCore",
"RHI",
// ... 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 ...
}
);
PublicDefinitions.AddRange(
new string[]
{
"OPTICK_ENABLE_GPU_VULKAN=0",
"OPTICK_ENABLE_GPU_D3D12=0",
"_CRT_SECURE_NO_WARNINGS",
"OPTICK_UE4=1",
}
);
/*
#if UE_4_24_OR_LATER
* PublicDefinitions.AddRange(
* new string[]
* {
* "OPTICK_UE4_GPU=1",
* }
* );
#endif
*/
if (Target.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"MainFrame",
"GameProjectGeneration",
"Projects",
"InputCore",
"LevelEditor",
"DesktopPlatform",
}
);
}
//PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
}
public BlueprintMaterialTextureNodes(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"BlueprintMaterialTextureNodes/Public",
"Runtime/Engine/Classes/Materials",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"BlueprintMaterialTextureNodes/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"AssetRegistry",
"AssetTools",
"RHI",
"StaticMeshEditor",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"UnrealEd",
"Engine",
"PropertyEditor",
"Slate",
"SlateCore",
// ... add private dependencies that you statically link with here ...
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"Settings",
"AssetTools",
"AssetRegistry",
//"StaticMeshEditor",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public Engine(TargetInfo Target)
{
PrivatePCHHeaderFile = "Private/EnginePrivatePCH.h";
SharedPCHHeaderFile = "Public/EngineSharedPCH.h";
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "NetworkReplayStreaming" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"ImageWrapper",
"HeadMountedDisplay",
"Advertising",
"NetworkReplayStreaming",
"MovieSceneCapture",
"AutomationWorker",
"MovieSceneCapture",
"DesktopPlatform",
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
}
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"RenderCore",
"RHI",
"ShaderCore",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"GameplayTags",
"AIModule",
"DatabaseSupport",
"PacketHandler",
"HardwareSurvey",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "CrashTracker" });
DynamicallyLoadedModuleNames.AddRange(new string[] { "CrashTracker" });
PublicDependencyModuleNames.AddRange(
new string[] {
}
);
}
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Sockets",
"Landscape",
"UMG",
"Projects",
"Internationalization",
"MaterialShaderQualitySettings",
"CinematicCamera",
"Analytics",
"AnalyticsET",
}
);
// to prevent "causes WARNING: Non-editor build cannot depend on non-redistributable modules."
if (Target.Type == TargetRules.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 == TargetRules.TargetType.Editor)
{
// these modules require variadic templates
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
}
}
CircularlyReferencedDependentModules.Add("GameplayTags");
CircularlyReferencedDependentModules.Add("AIModule");
CircularlyReferencedDependentModules.Add("Landscape");
CircularlyReferencedDependentModules.Add("UMG");
CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings");
CircularlyReferencedDependentModules.Add("CinematicCamera");
// 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");
// So does Geometry Cache
DynamicallyLoadedModuleNames.Add("GeometryCache");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"ActorSequence",
"MovieScene",
"MovieSceneCapture",
"MovieSceneTracks",
"HeadMountedDisplay",
"StreamingPauseRendering",
}
);
PrivateIncludePathModuleNames.Add("LightPropagationVolumeRuntime");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
if (Target.Type == TargetRules.TargetType.Server || Target.Type == TargetRules.TargetType.Editor)
{
PrivateDependencyModuleNames.Add("PerfCounters");
}
if (UEBuildConfiguration.bBuildDeveloperTools)
{
// Add "BlankModule" so that it gets compiled as an example and will be maintained and tested. This can be removed
// at any time if needed. The module isn't actually loaded by the engine so there is no runtime cost.
DynamicallyLoadedModuleNames.Add("BlankModule");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.Add("MeshUtilities");
DynamicallyLoadedModuleNames.Add("MeshUtilities");
PrivateDependencyModuleNames.AddRange(
new string[] {
"ImageCore",
"RawMesh"
});
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test && Target.Type != TargetRules.TargetType.Server)
{
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",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"LinuxClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"Advertising"
}
);
if (Target.Type.Value != TargetRules.TargetType.Server)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ImageWrapper",
"GameLiveStreaming"
}
);
}
if (!UEBuildConfiguration.bBuildRequiresCookedData && UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"DerivedDataCache",
"TargetPlatform",
"DesktopPlatform"
}
);
}
if (UEBuildConfiguration.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");
}
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompilePhysX && UEBuildConfiguration.bRuntimePhysicsCooking)
{
DynamicallyLoadedModuleNames.Add("PhysXFormats");
PrivateIncludePathModuleNames.Add("PhysXFormats");
}
SetupModuleBox2DSupport(Target);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus",
"OpenSubdiv"
);
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectShow");
}
// Head Mounted Display support
// PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
// DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32")
{
PublicDependencyModuleNames.Add("HTML5JS");
}
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.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
if (UEBuildConfiguration.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
Definitions.Add("WITH_RECAST=1");
}
else
{
// Because we test WITH_RECAST in public Engine header files, we need to make sure that modules
// that import this also have this definition set appropriately. Recast is a private dependency
// module, so it's definitions won't propagate to modules that import Engine.
Definitions.Add("WITH_RECAST=0");
}
// Add a reference to the stats HTML files referenced by UEngine::DumpFPSChartToHTML. Previously staged by CopyBuildToStagingDirectory.
if (UEBuildConfiguration.bBuildEditor || Target.Configuration != UnrealTargetConfiguration.Shipping)
{
RuntimeDependencies.Add("$(EngineDir)/Content/Stats/...", StagedFileType.UFS);
}
DynamicallyLoadedModuleNames.Add("Niagara");
// @third party code - BEGIN HairWorks
AddEngineThirdPartyPrivateStaticDependencies(Target, "HairWorks");
// @third party code - END HairWorks
}
public HTTP(ReadOnlyTargetRules Target) : base(Target)
{
PublicDefinitions.Add("HTTP_PACKAGE=1");
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Online/HTTP/Private",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"Sockets"
}
);
bool bWithCurl = false;
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "WinInet");
AddEngineThirdPartyPrivateStaticDependencies(Target, "WinHttp");
AddEngineThirdPartyPrivateStaticDependencies(Target, "libcurl");
bWithCurl = true;
PrivateDependencyModuleNames.Add("SSL");
}
else if (Target.Platform == UnrealTargetPlatform.Linux ||
Target.Platform == UnrealTargetPlatform.Android ||
Target.Platform == UnrealTargetPlatform.Switch)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "libcurl");
PrivateDependencyModuleNames.Add("SSL");
bWithCurl = true;
}
else
{
PublicDefinitions.Add("WITH_SSL=0");
PublicDefinitions.Add("WITH_LIBCURL=0");
}
if (bWithCurl)
{
PublicDefinitions.Add("CURL_ENABLE_DEBUG_CALLBACK=1");
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PublicDefinitions.Add("CURL_ENABLE_NO_TIMEOUTS_OPTION=1");
}
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PrivateDependencyModuleNames.Add("HTML5JS");
}
if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS || Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("Security");
}
}