public FroxPlugin(ReadOnlyTargetRules Target) : base(Target)
{
/*
* if (Target.Platform == UnrealTargetPlatform.Win64)
* {
* PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "../ThirdParty/Frox/", "Frox"));
*
* // Add the import library
* string BinariesPath = Path.Combine(ModuleDirectory, "../ThirdParty/Frox/", "x64", "Release");
* PublicLibraryPaths.Add(BinariesPath);
* PublicAdditionalLibraries.Add("Frox.lib");
*
* // Delay-load the DLL, so we can load it from the right place first
* PublicDelayLoadDLLs.Add("Frox.dll");
*
* string PlatformString = Target.Platform.ToString();
* string ProjectPath = Path.Combine(ModuleDirectory, "../..");
* string ProjectBinariesPath = Path.Combine(ProjectPath, "Binaries/", PlatformString);
* CopyFile(Path.Combine(BinariesPath, "Frox.dll"), ProjectBinariesPath);
* }
* else if (Target.Platform == UnrealTargetPlatform.Mac)
* {
* PublicDelayLoadDLLs.Add(Path.Combine(ModuleDirectory, "Mac", "Release", "libFrox.dylib"));
* }
*/
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",
"CoreUObject",
"Engine",
"InputCore",
"ImageWrapper",
"FroxPluginLibrary",
"Projects"
// ... 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 HoudiniEngineEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseSharedPCHs;
bool bIsRelease = true;
string HFSPath = "";
string HoudiniVersion = "16.5.505";
// 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"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"PlacementMode"
}
);
// Add common dependencies.
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"HoudiniEngineRuntime",
"Slate",
"SlateCore",
"Landscape"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AppFramework",
"AssetTools",
"ContentBrowser",
"DesktopWidgets",
"EditorStyle",
"EditorWidgets",
"Engine",
"InputCore",
"LevelEditor",
"MainFrame",
"Projects",
"PropertyEditor",
"RHI",
"RawMesh",
"RenderCore",
"ShaderCore",
"TargetPlatform",
"UnrealEd",
"ApplicationCore",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"PlacementMode",
}
);
}
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"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
Console.WriteLine("Using macOS BSON files");
PublicAdditionalLibraries.Add(Path.Combine(BSONPath, "lib", "libbson-static-1.0.a"));
PublicIncludePaths.Add(Path.Combine(BSONPath, "include", "mac"));
}
}
public HotPatcherEditor(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",
"Json",
"ContentBrowser",
"SandboxFile",
"JsonUtilities",
"TargetPlatform",
"PropertyEditor",
"Settings",
"AssetManagerEx",
"PakFileUtilities",
"HotPatcherRuntime"
// ... add other public dependencies that you statically link with here ...
}
);
if (Target.Version.MinorVersion > 23)
{
PublicDependencyModuleNames.Add("ToolMenus");
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Projects",
"DesktopPlatform",
"InputCore",
"UnrealEd",
"EditorStyle",
"LevelEditor",
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"RenderCore"
// ... add private dependencies that you statically link with here ...
}
);
switch (Target.Configuration)
{
case UnrealTargetConfiguration.DebugGame:
{
PublicDefinitions.Add("WITH_HOTPATCHER_DEBUGGAME");
break;
}
case UnrealTargetConfiguration.Development:
{
PublicDefinitions.Add("WITH_HOTPATCHER_DEVELOPMENT");
break;
}
}
;
PublicDefinitions.AddRange(new string[]
{
"ENABLE_COOK_ENGINE_MAP=0",
"ENABLE_COOK_PLUGIN_MAP=0"
});
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Version.MinorVersion <= 21)
{
bUseRTTI = true;
}
System.Console.WriteLine("MajorVersion {0} MinorVersion: {1} PatchVersion {2}", Target.Version.MajorVersion, Target.Version.MinorVersion, Target.Version.PatchVersion);
bLegacyPublicIncludePaths = false;
OptimizeCode = CodeOptimization.InShippingBuildsOnly;
}
public HoudiniEngineEditor(TargetInfo Target)
{
string HFSPath = "";
string HoudiniVersion = "14.0.376";
// Check if we are compiling on unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac)
{
string Err = string.Format("Houdini Engine Runtime: Compiling on unsupported platform.");
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
if (HFSPath == "")
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// We first check if Houdini Engine is installed.
HFSPath = "C:/Program Files/Side Effects Software/Houdini Engine " + HoudiniVersion;
if (!Directory.Exists(HFSPath))
{
// If Houdini Engine is not installed, we check for Houdini installation.
HFSPath = "C:/Program Files/Side Effects Software/Houdini " + HoudiniVersion;
if (!Directory.Exists(HFSPath))
{
string Err = string.Format("Houdini Engine Runtime: Please install Houdini or Houdini Engine {0}", HoudiniVersion);
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
HFSPath = "/Library/Frameworks/Houdini.framework/Versions/" + HoudiniVersion + "/Resources";
if (!Directory.Exists(HFSPath))
{
string Err = string.Format("Houdini Engine Runtime: Please install Houdini {0}", HoudiniVersion);
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
}
}
string HAPIIncludePath = HFSPath + "/toolkit/include/HAPI";
if (HFSPath != "")
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
Definitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath);
}
}
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
HAPIIncludePath,
"HoudiniEngineRuntime/Public",
"HoudiniEngineEditor/Public"
}
);
PrivateIncludePaths.AddRange(
new string[] {
"HoudiniEngineEditor/Private",
"HoudiniEngineRuntime/Private"
// ... add other private include paths required here ...
}
);
// Add common dependencies.
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"ShaderCore",
"InputCore",
"RHI",
"AssetTools",
"UnrealEd",
"Slate",
"SlateCore",
"Projects",
"PropertyEditor",
"ContentBrowser",
"RawMesh",
"TargetPlatform",
"LevelEditor",
"MainFrame",
"EditorStyle",
"EditorWidgets",
"AppFramework",
"HoudiniEngineRuntime"
}
);
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 SlateReflector(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"CoreUObject",
"ApplicationCore",
"InputCore",
"Slate",
"SlateCore",
"EditorStyle",
"Json",
"AssetRegistry",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Messaging",
"MessagingCommon",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Messaging",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Developer/SlateReflector/Private",
"Developer/SlateReflector/Private/Models",
"Developer/SlateReflector/Private/Widgets",
}
);
// Editor builds include SessionServices to populate the remote target drop-down for remote widget snapshots
if (Target.Type == TargetType.Editor)
{
PublicDefinitions.Add("SLATE_REFLECTOR_HAS_SESSION_SERVICES=1");
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SessionServices",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SessionServices",
}
);
}
else
{
PublicDefinitions.Add("SLATE_REFLECTOR_HAS_SESSION_SERVICES=0");
}
// DesktopPlatform is only available for Editor and Program targets (running on a desktop platform)
bool IsDesktopPlatformType = Target.Platform == UnrealBuildTool.UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealBuildTool.UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealBuildTool.UnrealTargetPlatform.Mac ||
Target.Platform == UnrealBuildTool.UnrealTargetPlatform.Linux;
if (Target.Type == TargetType.Editor || (Target.Type == TargetType.Program && IsDesktopPlatformType))
{
PublicDefinitions.Add("SLATE_REFLECTOR_HAS_DESKTOP_PLATFORM=1");
PrivateDependencyModuleNames.AddRange(
new string[] {
"DesktopPlatform",
}
);
}
else
{
PublicDefinitions.Add("SLATE_REFLECTOR_HAS_DESKTOP_PLATFORM=0");
}
}
public DemoPlugin(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"DemoPlugin/Private"
// ... add other private include paths required here ...
}
);
PrivateIncludePathModuleNames.AddRange(new string[] { "Settings" });
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "Projects"
// ... 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 ...
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PrivateIncludePaths.Add("DemoPlugin/Private/IOS");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateIncludePaths.Add("DemoPlugin/Private/Android");
}
// Additional Frameworks and Libraries for IOS
if (Target.Platform == UnrealTargetPlatform.IOS)
{
/*
* YOU MUST USE MAC OSX TO BUILD IOS IPA IF YOU NEED FCM PUSH NOTIFICATION
* DO NOT USE REMOTE BUILD FROM PC
*
* Two methods to copy RAW files to iOS ipa
* 1) Use Build/IOS/Cloud, UE 4.23 onward, ONLY works on Mac
* 2) Use RemapDirectories in DefaultGame.ini, works on both PC and Mac
*/
//1)
//copy raw files to Build/IOS/Cloud folder
//Unreal engine build script would copy files from /Cloud directly into App folder
/*
* string cloudPath = ModuleDirectory+"/../../../../Build/IOS/Cloud";
* string rawPath = Path.Combine(ModuleDirectory, "Raw");
* //Log.TraceInformation("cloudPath:"+cloudPath);
* if(Directory.Exists(cloudPath)==false){
* Directory.CreateDirectory(cloudPath);
* }
* File.Delete(cloudPath+"/GoogleService-Info.plist");
* File.Copy(rawPath +"/GoogleService-Info.plist",cloudPath+"/GoogleService-Info.plist");
*/
//2)
//use DefaultGame.ini method by adding staging line in DefaultGame.ini file
//like:
//[Staging]
//+RemapDirectories=(From="UnrealPluginDemo/Plugins/DemoPlugin/Source/DemoPlugin/Raw", To="Raw")
//this will endup files under "Raw" Folder in ipa
RuntimeDependencies.Add(Path.Combine(ModuleDirectory, "Raw/GoogleService-Info.plist"), StagedFileType.SystemNonUFS);
// Add any import libraries or static libraries
PublicAdditionalLibraries.Add(Path.Combine(ModuleDirectory, "../Libs/iOS/libFirebaseUnrealWrapper.a"));
//Firebase
addFirebase();
//FCM
addFCM();
//optional flag seems not supported here
PublicFrameworks.AddRange(
new string[]
{
"iAd",
"AdSupport"
}
);
//UPL
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("IOSPlugin", Path.Combine(PluginPath, "DemoPlugin_UPL_IOS.xml"));
}
// Additional Frameworks and Libraries for Android
else if (Target.Platform == UnrealTargetPlatform.Android)
{
//android copy files in UPL xml
//JNI
PrivateDependencyModuleNames.AddRange(new string[] { "Launch" });
//UPL
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "DemoPlugin_UPL_Android.xml"));
}
}
public ExodusImport(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/JsonImportPrivatePCH.h";
PCHUsage = PCHUsageMode.UseSharedPCHs;
bEnforceIWYU = true;
PublicIncludePaths.AddRange(
new string[] {
"ExodusImport/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"ExodusImport/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[]
{
"Projects",
"InputCore",
"UnrealEd",
"LevelEditor",
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"Json",
"Landscape", "Foliage",
"DesktopPlatform",
"RenderCore",
"RawMesh",
"MaterialEditor",
"AssetTools"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public VaRestEditorPlugin(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
"VaRestPlugin",
"VaRestPlugin/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"VaRestEditorPlugin/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"VaRestPlugin"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"InputCore",
"AssetTools",
"UnrealEd", // for FAssetEditorManager
"KismetWidgets",
"KismetCompiler",
"BlueprintGraph",
"GraphEditor",
"Kismet", // for FWorkflowCentricApplication
"PropertyEditor",
"EditorStyle",
"Sequencer",
"DetailCustomizations",
"Settings",
"RenderCore"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public LevelEditor(TargetInfo Target)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetTools",
"ClassViewer",
"MainFrame",
"PlacementMode",
"ReferenceViewer",
"SizeMap",
"SlateReflector",
"IntroTutorials",
"AppFramework",
"PortalServices"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"Settings",
"UserFeedback",
"IntroTutorials",
"HeadMountedDisplay",
"VREditor"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"LevelSequence",
"Analytics",
"Core",
"CoreUObject",
"DesktopPlatform",
"InputCore",
"Slate",
"SlateCore",
"EditorStyle",
"Engine",
"MessageLog",
"SourceControl",
"SourceControlWindows",
"StatsViewer",
"UnrealEd",
"RenderCore",
"DeviceProfileServices",
"ContentBrowser",
"SceneOutliner",
"ActorPickerMode",
"RHI",
"Projects",
"TargetPlatform",
"EngineSettings",
"PropertyEditor",
"WebBrowser",
"Persona",
"Kismet",
"KismetWidgets",
"Sequencer",
"Foliage",
"HierarchicalLODOutliner",
"HierarchicalLODUtilities",
"MaterialShaderQualitySettings",
"PixelInspectorModule",
"FunctionalTesting"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MainFrame",
"ClassViewer",
"DeviceManager",
"SettingsEditor",
"SessionFrontend",
"SlateReflector",
"AutomationWindow",
"Layers",
"WorldBrowser",
"EditorWidgets",
"AssetTools",
"WorkspaceMenuStructure",
"NewLevelDialog",
"DeviceProfileEditor",
"PlacementMode",
"UserFeedback",
"ReferenceViewer",
"SizeMap",
"IntroTutorials",
"HeadMountedDisplay",
"VREditor"
}
);
}
public WeiXinSDK(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",
"CoreUObject",
"Engine",
"Projects",
"ApplicationCore"
// ... 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 ...
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.AddRange(new string[]
{
"Launch"
});
}
if (Target.Platform == UnrealTargetPlatform.IOS)
{
var LibDir = Path.Combine(ModuleDirectory, "..", "..", "lib", "IOS");
PrivateIncludePaths.Add(LibDir);
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "..", "ThirdParty", "IOS"));
PublicAdditionalLibraries.Add(Path.Combine(LibDir, "libWeChatSDK.a"));
PublicFrameworks.AddRange(
new string[]
{
"SystemConfiguration",
"CoreTelephony",
"CFNetwork"
}
);
// libz.tdb
PublicAdditionalLibraries.Add("z");
// libsqlite3.0.tdb
PublicAdditionalLibraries.Add("sqlite3.0");
// libc++.tdb
PublicAdditionalLibraries.Add("c++");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "WeiXinSDK_APL.xml"));
}
}
public VRExpansionPlugin(TargetInfo Target)
{
/* if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
* {
* AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenVR");
* // PrivateDependencyModuleNames.AddRange(new string[] { "D3D11RHI" }); //@todo steamvr: multiplatform
* }*/
PublicIncludePaths.AddRange(
new string[] {
"VRExpansionPlugin/Public",
"HeadMountedDisplay/Public",
"Runtime/Engine/Classes/Kismet",
"Runtime/Engine/Private/PhysicsEngine",
"../Plugins/Runtime/Steam/SteamVR/Source/SteamVR/Private" // This is dumb but it isn't very open
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"VRExpansionPlugin/Private"
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"PhysX",
"APEX",
"HeadMountedDisplay",
"SteamVR",
"OpenVR",
"SteamVRController",
"ProceduralMeshComponent",
"RHI",
"RenderCore",
"ShaderCore",
"NetworkReplayStreaming"
});
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 ...
}
);
}
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",
"DesktopPlatform",
// ... 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",
"OPTICK_UE4=1",
}
);
if (Target.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"MainFrame",
"GameProjectGeneration",
"Projects",
"InputCore",
"LevelEditor",
}
);
}
//PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
}
public NiagaraEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(new string[] {
"NiagaraEditor/Private",
"NiagaraEditor/Private/Toolkits",
"NiagaraEditor/Private/Widgets",
"NiagaraEditor/Private/Sequencer/NiagaraSequence",
"NiagaraEditor/Private/Sequencer/LevelSequence",
"NiagaraEditor/Private/ViewModels",
"NiagaraEditor/Private/TypeEditorUtilities"
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"Engine",
"RHI",
"Core",
"CoreUObject",
"ApplicationCore",
"InputCore",
"RenderCore",
"Slate",
"SlateCore",
"Kismet",
"EditorStyle",
"UnrealEd",
"VectorVM",
"Niagara",
"NiagaraShader",
"MovieScene",
"Sequencer",
"PropertyEditor",
"GraphEditor",
"ShaderFormatVectorVM",
"TargetPlatform",
"AppFramework",
"MovieSceneTools",
"MovieSceneTracks",
"AdvancedPreviewScene",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Engine",
"Messaging",
"LevelEditor",
"AssetTools",
"ContentBrowser",
"DerivedDataCache",
"ShaderCore",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"NiagaraShader",
"Engine",
"Niagara",
"UnrealEd",
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"Engine",
"Niagara"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WorkspaceMenuStructure",
}
);
}
public SpoutPlugin(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
"SpoutPlugin/Public",
Path.Combine(ThirdPartyPath, "Spout/include")
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"SpoutPlugin/Private",
// ... add other private include paths required here ...
}
);
//AddThirdPartyPrivateStaticDependencies(Target, "Spout");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RHI",
"RenderCore"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Slate", "SlateCore"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
/*Type = ModuleType.External;
*
* if (Target.Platform == UnrealTargetPlatform.Win64)
* {
* // Add the import library
* PublicLibraryPaths.Add(Path.Combine(ModuleDirectory, "x64", "Release"));
* PublicAdditionalLibraries.Add("ExampleLibrary.lib");
*
* // Delay-load the DLL, so we can load it from the right place first
* PublicDelayLoadDLLs.Add("ExampleLibrary.dll");
* }
* else if (Target.Platform == UnrealTargetPlatform.Mac)
* {
* PublicDelayLoadDLLs.Add(Path.Combine(ModuleDirectory, "Mac", "Release", "libExampleLibrary.dylib"));
* }*/
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "amd64" : "x86";
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "Spout/lib", PlatformString, "Spout.lib"));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(ThirdPartyPath, "Spout/lib", PlatformString, "Spout.dll")));
// Delay-load the DLL, so we can load it from the right place first
//PublicDelayLoadDLLs.Add(Path.Combine(ThirdPartyPath, "Spout/lib", PlatformString, "Spout.dll"));
/*PublicIncludePaths.AddRange(
* new string[] {
* Path.Combine(ThirdPartyPath, "Spout/include")
* });*/
}
}
public Persona(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Editor/Persona/Private"); // For PCH includes (because they don't work with relative paths, yet)
PublicIncludePathModuleNames.AddRange(
new string[] {
"SkeletonEditor",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"AdvancedPreviewScene",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"MainFrame",
"DesktopPlatform",
"ContentBrowser",
"AssetTools",
"AnimationEditor",
"MeshReductionInterface"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"ApplicationCore",
"Slate",
"SlateCore",
"EditorStyle",
"Engine",
"UnrealEd",
"GraphEditor",
"InputCore",
"Kismet",
"KismetWidgets",
"AnimGraph",
"PropertyEditor",
"EditorWidgets",
"BlueprintGraph",
"RHI",
"Json",
"JsonUtilities",
"ClothingSystemRuntime",
"ClothingSystemEditorInterface",
"ClothingSystemRuntimeInterface",
"AnimGraphRuntime",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ContentBrowser",
"Documentation",
"MainFrame",
"DesktopPlatform",
"SkeletonEditor",
"AssetTools",
"AnimationEditor",
"MeshReductionInterface"
}
);
}
public Core(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/CorePrivatePCH.h";
SharedPCHHeaderFile = "Public/CoreSharedPCH.h";
PrivateDependencyModuleNames.Add("BuildSettings");
PublicDependencyModuleNames.Add("TraceLog");
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Core/Private",
"Runtime/Core/Private/Misc",
"Runtime/Core/Private/Internationalization",
"Runtime/Core/Private/Internationalization/Cultures",
"Runtime/Engine/Public",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"DerivedDataCache",
"InputDevice",
"Analytics",
"RHI"
}
);
if (Target.bBuildEditor == true)
{
DynamicallyLoadedModuleNames.Add("SourceCodeAccess");
PrivateIncludePathModuleNames.Add("DirectoryWatcher");
DynamicallyLoadedModuleNames.Add("DirectoryWatcher");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"IntelVTune"
);
if (Target.Platform == UnrealTargetPlatform.Win64 && Target.WindowsPlatform.bUseBundledDbgHelp)
{
PublicDelayLoadDLLs.Add("DBGHELP.DLL");
PrivateDefinitions.Add("USE_BUNDLED_DBGHELP=1");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/DbgHelp/dbghelp.dll");
}
else
{
PrivateDefinitions.Add("USE_BUNDLED_DBGHELP=0");
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"zlib",
"PLCrashReporter",
"rd_route"
);
PublicFrameworks.AddRange(new string[] { "Cocoa", "Carbon", "IOKit", "Security" });
if (Target.bBuildEditor == true)
{
PublicAdditionalLibraries.Add("/System/Library/PrivateFrameworks/MultitouchSupport.framework/Versions/Current/MultitouchSupport");
}
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib"
);
PublicFrameworks.AddRange(new string[] { "UIKit", "Foundation", "AudioToolbox", "AVFoundation", "GameKit", "StoreKit", "CoreVideo", "CoreMedia", "CoreGraphics", "GameController", "SystemConfiguration", "DeviceCheck", "UserNotifications" });
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.AddRange(new string[] { "CoreMotion", "AdSupport", "WebKit" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"PLCrashReporter"
);
}
PrivateIncludePathModuleNames.Add("ApplicationCore");
bool bSupportAdvertising = Target.Platform == UnrealTargetPlatform.IOS;
if (bSupportAdvertising)
{
PublicFrameworks.AddRange(new string[] { "iAD" });
}
// export Core symbols for embedded Dlls
ModuleSymbolVisibility = ModuleRules.SymbolVisibility.VisibileForDll;
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"cxademangle",
"zlib"
);
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PublicIncludePaths.Add(string.Format("Runtime/Core/Public/{0}", Target.Platform.ToString()));
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib",
"jemalloc"
);
// Core uses dlopen()
PublicAdditionalLibraries.Add("dl");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PrivateDependencyModuleNames.Add("HTML5JS");
PrivateDependencyModuleNames.Add("MapPakDownloader");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicAdditionalLibraries.Add("SceRtc_stub_weak"); //ORBIS SDK rtc.h, used in PS4Time.cpp
}
if (Target.bCompileICU == true)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "ICU");
}
PublicDefinitions.Add("UE_ENABLE_ICU=" + (Target.bCompileICU ? "1" : "0")); // Enable/disable (=1/=0) ICU usage in the codebase. NOTE: This flag is for use while integrating ICU and will be removed afterward.
// If we're compiling with the engine, then add Core's engine dependencies
if (Target.bCompileAgainstEngine == true)
{
if (!Target.bBuildRequiresCookedData)
{
DynamicallyLoadedModuleNames.AddRange(new string[] { "DerivedDataCache" });
}
}
// On Windows platform, VSPerfExternalProfiler.cpp needs access to "VSPerf.h". This header is included with Visual Studio, but it's not in a standard include path.
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
var VisualStudioVersionNumber = "11.0";
var SubFolderName = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64/PerfSDK" : "PerfSDK";
string PerfIncludeDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), String.Format("Microsoft Visual Studio {0}/Team Tools/Performance Tools/{1}", VisualStudioVersionNumber, SubFolderName));
if (File.Exists(Path.Combine(PerfIncludeDirectory, "VSPerf.h")))
{
PrivateIncludePaths.Add(PerfIncludeDirectory);
PublicDefinitions.Add("WITH_VS_PERF_PROFILER=1");
}
else
{
PublicDefinitions.Add("WITH_VS_PERF_PROFILER=0");
}
}
WhitelistRestrictedFolders.Add("Private/NoRedist");
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PublicDefinitions.Add("WITH_DIRECTXMATH=1");
}
else if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
// To enable this requires Win8 SDK
PublicDefinitions.Add("WITH_DIRECTXMATH=0"); // Enable to test on Win64/32.
//PublicDependencyModuleNames.AddRange( // Enable to test on Win64/32.
// new string[] {
// "DirectXMath"
//});
}
else
{
PublicDefinitions.Add("WITH_DIRECTXMATH=0");
}
// Decide if validating memory allocator (aka MallocStomp) can be used on the current platform.
// Run-time validation must be enabled through '-stompmalloc' command line argument.
bool bWithMallocStomp = false;
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux || Target.Platform == UnrealTargetPlatform.Win64)
// Target.Platform == UnrealTargetPlatform.Win32: // 32-bit windows can technically be supported, but will likely run out of virtual memory space quickly
// Target.Platform == UnrealTargetPlatform.XboxOne: // XboxOne could be supported, as it's similar enough to Win64
{
bWithMallocStomp = true;
}
}
PublicDefinitions.Add("WITH_MALLOC_STOMP=" + (bWithMallocStomp ? "1" : "0"));
PrivateDefinitions.Add("PLATFORM_COMPILER_OPTIMIZATION_LTCG=" + (Target.bAllowLTCG ? "1" : "0"));
PrivateDefinitions.Add("PLATFORM_COMPILER_OPTIMIZATION_PG=" + (Target.bPGOOptimize ? "1" : "0"));
PrivateDefinitions.Add("PLATFORM_COMPILER_OPTIMIZATION_PG_PROFILING=" + (Target.bPGOProfile ? "1" : "0"));
}
// UE does not copy third party dlls to the output directory automatically.
// Link statically so you don't have to do it manually.
// to be delete private bool LinkThirdPartyStaticallyOnWindows = false;
//private string ModulePath
//{
// get { return ModuleDirectory; }
// }
// private string ThirdPartyPath
//{
// get { return Path.GetFullPath(Path.Combine(ModulePath, "../../ThirdParty/")); }
//}
//private string BinariesPath
//{
// get { return Path.GetFullPath(Path.Combine(ModulePath, "../../Binaries/")); }
//}
public JoystickPlugin(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
// ... add other public dependencies that you statically link with here ...
"SDL2_208"
});
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"InputDevice",
});
if (Target.Type == TargetRules.TargetType.Editor)
{
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"PropertyEditor",
"ActorPickerMode",
"DetailCustomizations",
});
PrivateDependencyModuleNames.AddRange(
new string[]
{
"PropertyEditor",
"DetailCustomizations",
// ... 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)
//{
// string SDL2Path = ThirdPartyPath + "sdl2_x64-windows/";
// string SDL2binPath = SDL2Path + "bin/";
// string SDL2LibPath = SDL2Path + "lib/";
// string SDL2LibManualPath = SDL2Path + "lib/manual - link/";
// PublicIncludePaths.Add(Path.Combine(SDL2Path, "include/SDL2"));
// if (LinkThirdPartyStaticallyOnWindows) {
// PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2-static.lib"));
// PublicAdditionalLibraries.Add(Path.Combine(SDL2LibManualPath, "SDL2main.lib"));
// } else
// {
// PublicAdditionalLibraries.Add(Path.Combine(SDL2binPath, "SDL2.dll"));
// PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2.lib"));
// }
// PublicAdditionalLibraries.Add("Version.lib");
// }
// if (Target.Platform == UnrealTargetPlatform.Win32)
// {
// string SDL2Path = ThirdPartyPath + "sdl2_x86-windows/";
// string SDL2LibPath = SDL2Path + "Lib/";
// PublicIncludePaths.Add(Path.Combine(SDL2Path, "include/SDL2"));
// if (LinkThirdPartyStaticallyOnWindows)
// {
// PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2-static.lib"));
// PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2main.lib"));
// }
// else
// {
// PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2.lib"));
// }
// PublicAdditionalLibraries.Add("Version.lib");
// }
// else if (Target.Platform == UnrealTargetPlatform.Mac) // NEVER TESTED
//{
// string SDL2Path = ThirdPartyPath + "SDL2/SDL/";
// PublicIncludePaths.Add(Path.Combine(SDL2Path, "include/"));
// PrivateIncludePaths.Add(Path.Combine(SDL2Path, "include/"));
// PublicFrameworks.Add("/Library/Frameworks/SDL2.framework");
//}
//else if (Target.Platform == UnrealTargetPlatform.Linux) // NEVER TESTED
// {
// string SDL2Path = ThirdPartyPath + "SDL2/SDL/";
// PublicIncludePaths.Add(Path.Combine(SDL2Path, "include/"));
// PrivateIncludePaths.Add(Path.Combine(SDL2Path, "include/"));
// //AddThirdPartyPrivateStaticDependencies(Target, new string[]{"SDL2"});
// AddEngineThirdPartyPrivateStaticDependencies(Target, new string[]{"SDL2"});
//}
}
public CloudPlugin(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
"CloudPlugin/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"CloudPlugin/Private",
"CloudPlugin/Private/ThirdParty",
// ... 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 ...
}
);
string BaseDirectory = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", ".."));
Log.TraceError("BaseDir: " + BaseDirectory);
string CurlDirectory = Path.Combine(BaseDirectory, "ThirdParty", "libcurl", Target.Platform.ToString());
Log.TraceError("CurlDir: " + CurlDirectory);
// Add library definitions for non-Mac platforms ... can be done a little later :)
if ((Target.Platform == UnrealTargetPlatform.Win64))
{
string full_library_path_curl = Path.Combine(CurlDirectory, "MyLibcurlBuild64Bit.lib");
PublicAdditionalLibraries.Add(full_library_path_curl);
//RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(CurlDirectory, "MyLibcurlBuild64Bit.dll")));
// Copy the dell into the plugins binary directory so it is correctly resolved at runtime
//PublicDelayLoadDLLs.Add(Path.Combine(CurlDirectory, "MyLibcurlBuild64Bit.dll"));
System.IO.File.Copy(Path.Combine(CurlDirectory, "MyLibcurlBuild64Bit.dll"), Path.Combine(BaseDirectory, "Binaries", Target.Platform.ToString(), "MyLibcurlBuild64Bit.dll"), true);
}
else
{
string full_library_path_curl = Path.Combine(CurlDirectory, "libcurlwrapper.dylib");
PublicAdditionalLibraries.Add(full_library_path_curl);
}
}
public DBSupport(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
"DBSupport/Public",
"ThirdPart/Public",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"DBSupport/Private",
"ThirdPart/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",
"Slate",
"SlateCore",
"Projects"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
/****************************************/
// If you update this path, ensure the DLL runtime delay load path in FOptitrackNatnetModule::StartupModule stays in sync.
string DBPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty", "MySql"));
string DBPath86 = System.IO.Path.Combine(DBPath, "x86");
string DBPath64 = System.IO.Path.Combine(DBPath, "x64");
PublicSystemIncludePaths.Add(System.IO.Path.Combine(DBPath86, "include"));
PublicSystemIncludePaths.Add(System.IO.Path.Combine(DBPath64, "include"));
if (Target.Platform == UnrealTargetPlatform.Win32)
{
string DBLibBinPath = Path.Combine(DBPath86, "lib");
PublicLibraryPaths.Add(DBLibBinPath);
PublicAdditionalLibraries.Add("libmysql.lib");
PublicDelayLoadDLLs.Add("libmysql.dll");
//RuntimeDependencies.Add( new RuntimeDependency( Path.Combine( DBLibBinPath, "libmysql.dll" ) ) );
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
string DBLibBinPath = Path.Combine(DBPath64, "lib");
PublicLibraryPaths.Add(DBLibBinPath);
PublicAdditionalLibraries.Add("libmysql.lib");
PublicDelayLoadDLLs.Add("libmysql.dll");
//RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(DBLibBinPath, "libmysql.dll")));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
}
}
public StateSequenceEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"StateSequenceEditor/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"Sequencer",
"EditorStyle",
"InputCore",
"Kismet",
"UnrealEd",
"ActorSequence",
"ActorSequenceEditor",
"StateSequence",
"MovieScene",
"MovieSceneTools",
"MovieSceneTracks",
"LevelEditor",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetTools",
"MovieSceneTools",
"Settings",
"MovieSceneCaptureDialog",
}
);
}
public FMODStudioEditor(TargetInfo Target)
#endif
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = "Private/FMODStudioEditorPrivatePCH.h";
bFasterWithoutUnity = true;
PublicIncludePaths.AddRange(
new string[] {
}
);
PrivateIncludePaths.AddRange(
new string[] {
"FMODStudioEditor/Private",
"FMODStudio/Private",
"Editor/MovieSceneTools/Private",
"Editor/MovieSceneTools/Private/CurveKeyEditors",
"Editor/MovieSceneTools/Private/TrackEditors",
"Editor/MovieSceneTools/Private/TrackEditors/PropertyTrackEditors",
"Editor/MovieSceneTools/Private/TrackEditorThumbnail",
"Editor/MovieSceneTools/Private/Sections"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"FMODStudio",
"InputCore",
"UnrealEd",
"Sequencer"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Slate",
"SlateCore",
"Settings",
"EditorStyle",
"LevelEditor",
"AssetTools",
"AssetRegistry",
"PropertyEditor",
"WorkspaceMenuStructure",
"Sockets",
"LevelSequence",
"MovieScene",
"MovieSceneTracks",
"MovieSceneTools"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
}
public WmfMedia(ReadOnlyTargetRules Target) : base(Target)
{
bEnableExceptions = true;
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
});
PublicDependencyModuleNames.AddRange(
new string[] {
"WmfMediaFactory"
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"MediaUtils",
"Projects",
"RenderCore",
"RHI",
"WmfMediaFactory"
});
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"D3D12RHI",
});
PrivateIncludePaths.AddRange(
new string[] {
"../../../../Platforms/XboxCommon/Source/Runtime/D3D12RHI/Private",
"../../../../Source/Runtime/D3D12RHI/Private",
});
}
else
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"D3D11RHI",
});
}
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Media",
});
PrivateIncludePaths.AddRange(
new string[] {
"WmfMedia/Private",
"WmfMedia/Private/Player",
"WmfMedia/Private/Wmf",
"../../../../Source/Runtime/Windows/D3D11RHI/Private",
"../../../../Source/Runtime/Windows/D3D11RHI/Private/Windows",
});
AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelMetricsDiscovery");
AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelExtensionsFramework");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAftermath");
if (Target.bCompileAgainstEngine)
{
PrivateDependencyModuleNames.Add("Engine");
PrivateDependencyModuleNames.Add("HeadMountedDisplay");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDelayLoadDLLs.Add("mf.dll");
PublicDelayLoadDLLs.Add("mfplat.dll");
PublicDelayLoadDLLs.Add("mfplay.dll");
PublicDelayLoadDLLs.Add("shlwapi.dll");
}
}
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",
"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
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"BlueprintRuntime",
"ClassViewer",
"Documentation",
"GameProjectGeneration",
"BlueprintCompilerCppBackend",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"BlueprintGraph",
"UMGEditor",
}
);
}
public SourceControl(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Developer/SourceControl/Private");
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"InputCore",
}
);
if (Target.Platform == UnrealTargetPlatform.Linux && Target.Type == TargetType.Program)
{
PublicDefinitions.Add("SOURCE_CONTROL_WITH_SLATE=0");
}
else
{
PublicDefinitions.Add("SOURCE_CONTROL_WITH_SLATE=1");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Slate",
"SlateCore",
"EditorStyle"
}
);
}
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Engine",
"UnrealEd",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetTools"
}
);
CircularlyReferencedDependentModules.Add("UnrealEd");
}
if (Target.bBuildDeveloperTools)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessageLog",
}
);
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrecompileForTargets = PrecompileTargetsType.Any;
}
}
public Sdkbox(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
// PrivateIncludePaths.AddRange(
// new string[] {
// "Developer/SdkboxIAP/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)
{
PublicAdditionalLibraries.Add(Path.Combine(ModulePath, "../../lib/iOS/sdkbox.a"));
PublicFrameworks.AddRange(
new string[]
{
"SystemConfiguration",
"Security"
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicAdditionalLibraries.Add(Path.Combine(ModulePath, "../../lib/Android/sdkbox.a"));
PrivateDependencyModuleNames.AddRange(new string[] { "Launch" });
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(ModulePath, "Sdkbox.xml")));
}
}
public MeshUtilities(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"MaterialUtilities",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"RawMesh",
"RenderCore", // For FPackedNormal
"SlateCore",
"Slate",
"MaterialUtilities",
"MeshBoneReduction",
"UnrealEd",
"RHI",
"HierarchicalLODUtilities",
"Landscape",
"LevelEditor",
"AnimationBlueprintEditor",
"AnimationEditor",
"SkeletalMeshEditor",
"SkeletonEditor",
"PropertyEditor",
"EditorStyle",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "nvTriStrip");
AddEngineThirdPartyPrivateStaticDependencies(Target, "ForsythTriOptimizer");
AddEngineThirdPartyPrivateStaticDependencies(Target, "QuadricMeshReduction");
AddEngineThirdPartyPrivateStaticDependencies(Target, "MikkTSpace");
AddEngineThirdPartyPrivateStaticDependencies(Target, "nvTessLib");
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX9");
}
if (UEBuildConfiguration.bCompileSimplygon == true)
{
AddEngineThirdPartyPrivateDynamicDependencies(Target, "SimplygonMeshReduction");
if (UEBuildConfiguration.bCompileSimplygonSSF == true)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SimplygonSwarm"
}
);
}
}
// EMBREE
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string SDKDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelEmbree/Embree2140/Win64/";
PublicIncludePaths.Add(SDKDir + "include");
PublicLibraryPaths.Add(SDKDir + "lib");
PublicAdditionalLibraries.Add("embree.2.14.0.lib");
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Win64/embree.2.14.0.dll"));
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Win64/tbb.dll"));
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Win64/tbbmalloc.dll"));
Definitions.Add("USE_EMBREE=1");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string SDKDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelEmbree/Embree2140/MacOSX/";
PublicIncludePaths.Add(SDKDir + "include");
PublicAdditionalLibraries.Add(SDKDir + "lib/libembree.2.14.0.dylib");
PublicAdditionalLibraries.Add(SDKDir + "lib/libtbb.dylib");
PublicAdditionalLibraries.Add(SDKDir + "lib/libtbbmalloc.dylib");
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Mac/libembree.2.14.0.dylib"));
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Mac/libtbb.dylib"));
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Mac/libtbbmalloc.dylib"));
Definitions.Add("USE_EMBREE=1");
}
else
{
Definitions.Add("USE_EMBREE=0");
}
}
public UnrealEnginePython(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
"UnrealEnginePython/Public",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"UnrealEnginePython/Private",
PythonHome,
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Sockets",
"Networking",
"Projects"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"MovieScene",
"LevelSequence",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (UEBuildConfiguration.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"UnrealEd",
"LevelEditor",
"BlueprintGraph",
"Projects",
"Sequencer",
"SequencerWidgets",
"AssetTools",
"LevelSequenceEditor",
"MovieSceneTools",
"MovieSceneTracks",
"CinematicCamera",
"EditorStyle",
"GraphEditor",
"UMGEditor",
"AIGraph",
});
}
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
if (UseThirdPartyPython)
{
PythonHome = ThirdPartyPythonHome;
System.Console.WriteLine("Using Python at: " + PythonHome);
PublicIncludePaths.Add(PythonHome);
string libPath = Path.Combine(PythonHome, "Lib", string.Format("{0}.lib", PythonType.ToLower()));
System.Console.WriteLine("full lib path: " + libPath);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicAdditionalLibraries.Add(libPath);
}
else if (PythonHome == "")
{
PythonHome = DiscoverPythonPath(windowsKnownPaths);
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);
}
}
//other platforms
else
{
if (PythonHome == "")
{
PythonHome = DiscoverPythonPath(macKnownPaths);
if (PythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
System.Console.WriteLine("Using Python at: " + PythonHome);
PublicIncludePaths.Add(PythonHome);
PublicAdditionalLibraries.Add(Path.Combine(PythonHome, "Lib", string.Format("{0}.lib", PythonType)));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (PythonType == "Python35")
{
string mac_python = "/Library/Frameworks/Python.framework/Versions/3.5/";
PublicIncludePaths.Add(Path.Combine(mac_python, "include"));
PublicAdditionalLibraries.Add(Path.Combine(mac_python, "lib", "libpython3.5m.dylib"));
Definitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_MAC=3"));
}
else if (PythonType == "Python27")
{
string mac_python = "/Library/Frameworks/Python.framework/Versions/2.7/";
PublicIncludePaths.Add(Path.Combine(mac_python, "include"));
PublicAdditionalLibraries.Add(Path.Combine(mac_python, "lib", "libpython2.7.dylib"));
Definitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_MAC=2"));
}
System.Console.WriteLine("Using Python at: " + PythonHome);
PublicIncludePaths.Add(PythonHome);
string libPath = GetMacPythonLibFile(PythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicDelayLoadDLLs.Add(libPath);
Definitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_MAC"));
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (PythonType == "Python35")
{
PublicIncludePaths.Add("/usr/include/python3.5m");
PublicAdditionalLibraries.Add("/usr/lib/python3.5/config-3.5m-x86_64-linux-gnu/libpython3.5.so");
}
else if (PythonType == "Python27")
{
PublicIncludePaths.Add("/usr/include/python2.7");
PublicAdditionalLibraries.Add("/usr/lib/python2.7/config-x86_64-linux-gnu/libpython2.7.so");
}
Definitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_LINUX"));
}
}
}
public JoystickPlugin(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
// ... add other public dependencies that you statically link with here ...
});
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"InputDevice",
});
if (Target.Type == TargetRules.TargetType.Editor)
{
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"PropertyEditor",
"ActorPickerMode",
"DetailCustomizations",
});
PrivateDependencyModuleNames.AddRange(
new string[]
{
"PropertyEditor",
"DetailCustomizations",
// ... 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 || Target.Platform == UnrealTargetPlatform.Win32)
{
string SDL2Path = ThirdPartyPath + "SDL2/SDL/";
string SDL2LibPath = SDL2Path + "Lib/";
PublicIncludePaths.Add(Path.Combine(SDL2Path, "include/"));
if (LinkThirdPartyStaticallyOnWindows)
{
PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2-static.lib"));
PublicAdditionalLibraries.Add("Version.lib");
}
else
{
PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2.lib"));
PublicAdditionalLibraries.Add("Version.lib");
}
//PublicAdditionalLibraries.Add("msvcrt.lib");
//PublicAdditionalLibraries.Add("ucrt.lib");
//PublicAdditionalLibraries.Add("vcruntime.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("/Library/Frameworks/SDL2.framework");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
}
public modio(ReadOnlyTargetRules Target) : base(Target)
{
PublicDefinitions.Add("JSON_NOEXCEPTION");
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
// For beeing able to declare something public inside of the module, but private to outsiders
PrivateDefinitions.Add("MODIO_PACKAGE=1");
PrivateDependencyModuleNames.AddRange(new string[] { });
LoadModio(Target);
bEnableExceptions = true;
// Made sure to disable unity builds, as exclusion of some files causes the project to explode
// this was we atleast get deterministic builds even if they are slower
MinSourceFilesForUnityBuildOverride = 256;
PublicIncludePaths.AddRange(
new string[] {
//"modio/Public"
/*,
* "Runtime/Core/Public/Modules/",
* "Editor/UnrealEd/Classes/Factories",
* "Editor/UnrealEd/Classes",
* "C:/Users/antar/Documents/Unreal Projects/ModioContainer21/Plugins/modio/Intermediate/Build/Win64/UE4Editor/Inc/modio",
* "C:/Program Files/Epic Games/UE_4.21/Engine/Intermediate/Build/Win64/UE4Editor/Inc/UnrealEd"
*/
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
//"modio/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Projects",
"Int64"
// ... 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 ...
}
);
}