public UT_Framework(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[]
{
ModuleDirectory + "/Public",
ModuleDirectory + "/Public/Blueprint",
ModuleDirectory + "/Public/Blueprint/StateMachine",
ModuleDirectory + "/Public/Component",
ModuleDirectory + "/Public/Component/LookAt",
ModuleDirectory + "/Public/Component/Pool",
ModuleDirectory + "/Public/Component/StateMachine",
ModuleDirectory + "/Public/Library",
ModuleDirectory + "/Public/Manager",
ModuleDirectory + "/Public/Manager/Pool",
ModuleDirectory + "/Public/Object",
ModuleDirectory + "/Public/Object/LoadSystem",
ModuleDirectory + "/Public/Object/Pool",
ModuleDirectory + "/Public/Object/StateMachine",
ModuleDirectory + "/Public/Object/StateMachine/State",
ModuleDirectory + "/Public/Object/StateMachine/Transition",
ModuleDirectory + "/Public/Sequencer",
ModuleDirectory + "/Public/Sequencer/Evaluation",
ModuleDirectory + "/Public/Sequencer/Section",
ModuleDirectory + "/Public/Sequencer/Track",
ModuleDirectory + "/Public/Utility",
ModuleDirectory + "/Public/Widget",
ModuleDirectory + "/Public/Widget/Component",
ModuleDirectory + "/Public/Widget/Navigation",
});
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"InputCore",
"Engine",
"Slate",
"SlateCore",
"UMG",
"AIModule",
"Paper2D",
"MovieScene",
"MovieSceneTracks",
"GameplayTasks",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public WmfMedia(ReadOnlyTargetRules Target) : base(Target)
{
bEnableExceptions = true;
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"MediaUtils",
"Projects",
"RenderCore",
"RHI",
"UtilityShaders",
"WmfMediaFactory",
});
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"HAPLib",
"SnappyLib",
});
PrivateDefinitions.Add("HAP_SUPPORTED=1");
}
else
{
PrivateDefinitions.Add("HAP_SUPPORTED=0");
}
if (Target.Platform != UnrealTargetPlatform.XboxOne)
{
PrivateDependencyModuleNames.Add("D3D11RHI");
}
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Media",
});
PrivateIncludePaths.AddRange(
new string[] {
"WmfMedia/Private",
"WmfMedia/Private/Player",
"WmfMedia/Private/Wmf",
"WmfMedia/Private/HAPDecoder",
"../../../../Source/Runtime/Windows/D3D11RHI/Private",
"../../../../Source/Runtime/Windows/D3D11RHI/Private/Windows",
});
AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelMetricsDiscovery");
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");
PublicAdditionalLibraries.Add("d3dcompiler.lib");
}
}
public ShooterGame(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Public/ShooterGame.h";
PrivateIncludePaths.AddRange(
new string[] {
"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",
"NavigationSystem",
"AIModule",
"GameplayTasks",
"Gauntlet",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"InputCore",
"Slate",
"SlateCore",
"ShooterGameLoadingScreen",
"Json",
"ApplicationCore",
"ReplicationGraph",
"PakFile",
"Http",
"FunapiDedicatedServer"
}
);
if (Target.Type != TargetRules.TargetType.Server && Target.Platform != UnrealTargetPlatform.Linux)
{
PrivateDependencyModuleNames.Add("Funapi");
}
else
{
PublicDefinitions.Add("WITH_FUNAPI=0");
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"OnlineSubsystemNull",
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"LocalFileNetworkReplayStreaming"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"NetworkReplayStreaming"
}
);
if (Target.bBuildDeveloperTools || (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test))
{
PrivateDependencyModuleNames.Add("GameplayDebugger");
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=1");
}
else
{
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=0");
}
}
public DetailCustomizations(ReadOnlyTargetRules Target) : base(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",
"MovieSceneTracks",
"MovieScene",
"SharedSettingsWidgets",
"ContentBrowser",
"BlueprintGraph",
"AnimGraph",
"PropertyEditor",
"LevelEditor",
"DesktopPlatform",
"ClassViewer",
"TargetPlatform",
"ExternalImagePicker",
"MoviePlayer",
"SourceControl",
"InternationalizationSettings",
"SourceCodeAccess",
"RHI",
"HardwareTargeting",
"SharedSettingsWidgets",
"AIModule",
"MeshUtilities",
"ConfigEditor",
"Persona",
"CinematicCamera",
"ComponentVisualizers",
"SkeletonEditor",
"LevelSequence",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Engine",
"Media",
"Landscape",
"LandscapeEditor",
"PropertyEditor",
"GameProjectGeneration",
"ComponentVisualizers",
"GraphEditor"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Layers",
"GameProjectGeneration",
}
);
}
public AIModule(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
"Runtime/NavigationSystem/Public",
"Runtime/AIModule/Public",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/AIModule/Private",
"Runtime/Engine/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"GameplayTags",
"GameplayTasks",
"NavigationSystem",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"RHI",
"RenderCore",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
PrivateDependencyModuleNames.Add("AITestSuite");
CircularlyReferencedDependentModules.Add("AITestSuite");
}
if (Target.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
PublicDefinitions.Add("WITH_RECAST=1");
}
else
{
// Because we test WITH_RECAST in public Engine header files, we need to make sure that modules
// that import us also have this definition set appropriately. Recast is a private dependency
// module, so it's definitions won't propagate to modules that import Engine.
PublicDefinitions.Add("WITH_RECAST=0");
}
if (Target.bBuildDeveloperTools || (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test))
{
PrivateDependencyModuleNames.Add("GameplayDebugger");
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=1");
}
else
{
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=0");
}
}
public HoudiniEngineRuntime(ReadOnlyTargetRules Target) : base(Target)
{
bPrecompile = true;
PCHUsage = PCHUsageMode.UseSharedPCHs;
// Check if we are compiling for unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac &&
Target.Platform != UnrealTargetPlatform.Linux &&
Target.Platform != UnrealTargetPlatform.Switch)
{
System.Console.WriteLine(string.Format("Houdini Engine: Compiling for untested target platform. Please let us know how it goes!"));
}
// Find HFS
string HFSPath = GetHFSPath();
HFSPath = HFSPath.Replace("\\", "/");
if (HFSPath != "")
{
string Log = string.Format("Houdini Engine: Found Houdini in {0}", HFSPath);
System.Console.WriteLine(Log);
PlatformID buildPlatformId = Environment.OSVersion.Platform;
if (buildPlatformId == PlatformID.Win32NT)
{
PublicDefinitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath);
}
}
// Find the HAPI include directory
string HAPIIncludePath = HFSPath + "/toolkit/include/HAPI";
if (!Directory.Exists(HAPIIncludePath))
{
// Add the custom include path as well in case the toolkit path doesn't exist yet.
HAPIIncludePath = HFSPath + "/custom/houdini/include/HAPI";
if (!Directory.Exists(HAPIIncludePath))
{
System.Console.WriteLine(string.Format("Couldn't find the HAPI include folder!"));
HAPIIncludePath = "";
}
}
if (HAPIIncludePath != "")
{
PublicIncludePaths.Add(HAPIIncludePath);
}
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "Public/HAPI"),
Path.Combine(ModuleDirectory, "Public")
}
);
PrivateIncludePaths.AddRange(
new string[] {
"HoudiniEngineRuntime/Private"
}
);
// Add common dependencies.
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"ShaderCore",
"InputCore",
"RHI",
"Foliage",
"Landscape"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
// ... add private dependencies that you statically link with here ...
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AppFramework",
"AssetTools",
"EditorStyle",
"EditorWidgets",
"LevelEditor",
"MainFrame",
"MeshPaint",
"Projects",
"PropertyEditor",
"RawMesh",
"Settings",
"Slate",
"SlateCore",
"TargetPlatform",
"UnrealEd",
"ApplicationCore",
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public Core(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/CorePrivatePCH.h";
SharedPCHHeaderFile = "Public/CoreSharedPCH.h";
PrivateDependencyModuleNames.Add("BuildSettings");
PublicDependencyModuleNames.Add("TraceLog");
PublicIncludePaths.Add("Runtime/TraceLog/Public");
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.IsInGroup(UnrealPlatformGroup.Windows))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"IntelVTune"
);
AddEngineThirdPartyPrivateStaticDependencies(Target,
"mimalloc");
if (Target.Platform != UnrealTargetPlatform.Win32 && 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");
}
PrivateDefinitions.Add("YIELD_BETWEEN_TASKS=1");
}
else if ((Target.Platform == UnrealTargetPlatform.HoloLens))
{
PublicIncludePaths.Add("Runtime/Core/Public/HoloLens");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"XInput"
);
}
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)
{
string SDKROOT = Utils.RunLocalProcessAndReturnStdOut("/usr/bin/xcrun", "--sdk macosx --show-sdk-path");
PublicAdditionalLibraries.Add(SDKROOT + "/System/Library/PrivateFrameworks/MultitouchSupport.framework/Versions/Current/MultitouchSupport.tbd");
}
}
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",
"libunwind"
);
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib",
"jemalloc"
);
// Core uses dlopen()
PublicSystemLibraries.Add("dl");
}
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.IsInGroup(UnrealPlatformGroup.Windows))
{
var VisualStudioVersionNumber = "11.0";
var SubFolderName = (Target.Platform == UnrealTargetPlatform.Win32) ? "PerfSDK" : "x64/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");
}
}
if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
PublicDefinitions.Add("WITH_VS_PERF_PROFILER=0");
}
if (Target.bWithDirectXMath && (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDefinitions.Add("WITH_DIRECTXMATH=1");
}
else
{
PublicDefinitions.Add("WITH_DIRECTXMATH=0");
}
// Set a macro to allow FApp::GetBuildTargetType() to detect client targts
if (Target.Type == TargetRules.TargetType.Client)
{
PrivateDefinitions.Add("IS_CLIENT_TARGET=1");
}
else
{
PrivateDefinitions.Add("IS_CLIENT_TARGET=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.LinuxAArch64 ||
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"));
UnsafeTypeCastWarningLevel = WarningLevel.Warning;
}
public LevelEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetTools",
"ClassViewer",
"MainFrame",
"PlacementMode",
"SlateReflector",
"IntroTutorials",
"AppFramework",
"PortalServices"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"Settings",
"IntroTutorials",
"HeadMountedDisplay",
"VREditor"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"LevelSequence",
"Analytics",
"Core",
"CoreUObject",
"LauncherPlatform",
"InputCore",
"Slate",
"SlateCore",
"EditorStyle",
"Engine",
"MessageLog",
"SourceControl",
"SourceControlWindows",
"StatsViewer",
"UnrealEd",
"RenderCore",
"DeviceProfileServices",
"ContentBrowser",
"SceneOutliner",
"ActorPickerMode",
"RHI",
"Projects",
"TargetPlatform",
"EngineSettings",
"PropertyEditor",
"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",
"IntroTutorials",
"HeadMountedDisplay",
"VREditor"
}
);
}
public WebSocket(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"WebSocket/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Json",
"JsonUtilities",
"Sockets",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"Json",
"JsonUtilities",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
Definitions.Add("PLATFORM_UWP=0");
PrivateDependencyModuleNames.Add("zlib");
PrivateDependencyModuleNames.Add("OpenSSL");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Win64");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Win64/"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesX64 = new string[] {
"websockets_static.lib",
//"libcrypto.lib",
//"libssl.lib",
};
foreach (string Lib in StaticLibrariesX64)
{
PublicAdditionalLibraries.Add(Lib);
}
}
if (Target.Platform == UnrealTargetPlatform.Win32)
{
Definitions.Add("PLATFORM_UWP=0");
PrivateDependencyModuleNames.Add("zlib");
PrivateDependencyModuleNames.Add("OpenSSL");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Win32");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Win32/"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesX32 = new string[] {
"websockets_static.lib",
//"libcrypto.lib",
//"libssl.lib",
};
foreach (string Lib in StaticLibrariesX32)
{
PublicAdditionalLibraries.Add(Lib);
}
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
Definitions.Add("PLATFORM_UWP=0");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/HTML5/"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesHTML5 = new string[] {
"WebSocket.js",
};
foreach (string Lib in StaticLibrariesHTML5)
{
PublicAdditionalLibraries.Add(strStaticPath + Lib);
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
Definitions.Add("PLATFORM_UWP=0");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Mac");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Mac/"));
//PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesMac = new string[] {
"libwebsockets.a",
"libssl.a",
"libcrypto.a"
};
foreach (string Lib in StaticLibrariesMac)
{
PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib));
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
Definitions.Add("PLATFORM_UWP=0");
PrivateDependencyModuleNames.Add("OpenSSL");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Linux");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Linux/"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesMac = new string[] {
"libwebsockets.a",
//"libssl.a",
//"libcrypto.a"
};
foreach (string Lib in StaticLibrariesMac)
{
PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib));
}
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
Definitions.Add("PLATFORM_UWP=0");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/IOS");
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath + "/Source/");
PluginPath = PluginPath.Replace("\\", "/");
string strStaticPath = PluginPath + "/ThirdParty/lib/IOS/";// Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/IOS/"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesIOS = new string[] {
"websockets",
"ssl",
"crypto"
};
foreach (string Lib in StaticLibrariesIOS)
{
PublicAdditionalLibraries.Add(Lib);
PublicAdditionalShadowFiles.Add(Path.Combine(strStaticPath, "lib" + Lib + ".a"));
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
Definitions.Add("PLATFORM_UWP=0");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Android");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Android/armeabi-v7a"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesAndroid = new string[] {
"websockets",
//"ssl",
//"crypto"
};
foreach (string Lib in StaticLibrariesAndroid)
{
PublicAdditionalLibraries.Add(Lib);
}
}
}
public HoudiniPlusEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseSharedPCHs;
// Check if we are compiling on unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac &&
Target.Platform != UnrealTargetPlatform.Linux &&
Target.Platform != UnrealTargetPlatform.Switch)
{
Console.WriteLine(string.Format("Houdini Engine : Compiling on untested platform. Please let us know how it goes!"));
}
// Find HFS
var HFSPath = GetHFSPath();
HFSPath = HFSPath.Replace("\\", "/");
if (!string.IsNullOrEmpty(HFSPath))
{
var Log = string.Format("Houdini Engine : Found Houdini in {0}", HFSPath);
Console.WriteLine(Log);
var BuildPlatformId = Environment.OSVersion.Platform;
if (BuildPlatformId == PlatformID.Win32NT)
{
PublicDefinitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath);
}
}
// Find the HAPI include directory
var HAPIIncludePath = HFSPath + "/toolkit/include";
if (!Directory.Exists(HAPIIncludePath))
{
// Add the custom include path as well in case the toolkit path doesn't exist yet.
HAPIIncludePath = HFSPath + "/custom/houdini/include";
if (!Directory.Exists(HAPIIncludePath))
{
throw new Exception(string.Format("Couldn't find the HAPI include folder!"));
HAPIIncludePath = string.Empty;
}
}
if (!string.IsNullOrEmpty(HAPIIncludePath))
{
PublicIncludePaths.Add(HAPIIncludePath);
}
// Get the plugin path
var PluginPath = Path.Combine(ModuleDirectory, "../../");
PluginPath = Utils.MakePathRelativeTo(PluginPath, Target.RelativeEnginePath);
PublicIncludePaths.AddRange(
new string[] {
"HoudiniPlusEditor/Public"
});
PrivateIncludePaths.AddRange(
new string[] {
"HoudiniPlusEditor/Private",
});
PrivateIncludePathModuleNames.AddRange(
new string[] {
"PlacementMode"
});
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Foliage",
"InputCore",
"Landscape",
"RenderCore",
"RHI",
"ShaderCore",
"Slate",
"SlateCore",
"Happy"
});
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AppFramework",
"ApplicationCore",
"AssetTools",
"ContentBrowser",
"DesktopWidgets",
"EditorStyle",
"EditorWidgets",
"LevelEditor",
"MainFrame",
"Projects",
"PropertyEditor",
"RawMesh",
"Settings",
"Slate",
"SlateCore",
"TargetPlatform",
"UnrealEd",
});
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"PlacementMode"
});
var HAPILibPath = Path.Combine(HFSPath, GetLibFolder(), GetLibName());
HAPILibPath = HAPILibPath.Replace("\\", "/");
if (!File.Exists(HAPILibPath))
{
throw new Exception(string.Format("Couldn't find the HAPI lib!"));
}
else
{
PublicDelayLoadDLLs.Add(GetLibName());
RuntimeDependencies.Add(HAPILibPath);
}
}
public CesiumEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "../ThirdParty/include")
}
);
string libPrefix;
string libPostfix;
string platform;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
platform = "Windows-x64";
libPostfix = ".lib";
libPrefix = "";
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
platform = "Darwin-x64";
libPostfix = ".a";
libPrefix = "lib";
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
platform = "Android-xaarch64";
libPostfix = ".a";
libPrefix = "lib";
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
platform = "Linux-x64";
libPostfix = ".a";
libPrefix = "lib";
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
platform = "iOS-xarm64";
libPostfix = ".a";
libPrefix = "lib";
}
else
{
platform = "Unknown";
libPostfix = ".Unknown";
libPrefix = "Unknown";
}
string libPath = Path.Combine(ModuleDirectory, "../ThirdParty/lib/" + platform);
string releasePostfix = "";
string debugPostfix = "d";
bool preferDebug = (Target.Configuration == UnrealTargetConfiguration.Debug || Target.Configuration == UnrealTargetConfiguration.DebugGame);
string postfix = preferDebug ? debugPostfix : releasePostfix;
string[] libs = new string[]
{
"CesiumIonClient",
"csprng"
};
if (preferDebug)
{
// We prefer Debug, but might still use Release if that's all that's available.
foreach (string lib in libs)
{
string debugPath = Path.Combine(libPath, libPrefix + lib + debugPostfix + libPostfix);
if (!File.Exists(debugPath))
{
Console.WriteLine("Using release build of cesium-native because a debug build is not available.");
preferDebug = false;
postfix = releasePostfix;
break;
}
}
}
PublicAdditionalLibraries.AddRange(libs.Select(lib => Path.Combine(libPath, libPrefix + lib + postfix + libPostfix)));
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"UnrealEd",
"CesiumRuntime"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"ApplicationCore",
"Slate",
"SlateCore",
"MeshDescription",
"StaticMeshDescription",
"HTTP",
"MikkTSpace",
"Chaos",
"Projects",
"InputCore",
"PropertyEditor",
"DeveloperSettings",
"EditorStyle"
// ... add private dependencies that you statically link with here ...
}
);
PublicDefinitions.AddRange(
new string[]
{
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = "Private/PCH.h";
CppStandard = CppStandardVersion.Cpp17;
if (Target.Platform == UnrealTargetPlatform.IOS ||
(Target.Platform == UnrealTargetPlatform.Android &&
Target.Version.MajorVersion == 4 &&
Target.Version.MinorVersion == 26 &&
Target.Version.PatchVersion < 2))
{
// In UE versions prior to 4.26.2, the Unreal Build Tool on Android
// (AndroidToolChain.cs) ignores the CppStandard property and just
// always uses C++14. Our plugin can't be compiled with C++14.
//
// So this hack uses reflection to add an additional argument to
// the compiler command-line to force C++17 mode. Clang ignores all
// but the last `-std=` argument, so the `-std=c++14` added by the
// UBT is ignored.
//
// This is also needed for iOS builds on all engine versions as Unreal
// defaults to c++14 regardless of the CppStandard setting
Type type = Target.GetType();
FieldInfo innerField = type.GetField("Inner", BindingFlags.Instance | BindingFlags.NonPublic);
TargetRules inner = (TargetRules)innerField.GetValue(Target);
inner.AdditionalCompilerArguments += " -std=c++17";
}
}
public VictoryBPLibrary(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/VictoryBPLibraryPrivatePCH.h";
//4.15 Include What You Use
bEnforceIWYU = false;
PublicIncludePaths.AddRange(
new string[] {
"VictoryBPLibrary/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"VictoryBPLibrary/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"RHI",
"RenderCore",
"HTTP",
"UMG", "Slate", "SlateCore",
"ImageWrapper",
"PhysX",
"HeadMountedDisplay",
"AIModule",
"NavigationSystem",
"Vorbis",
//FPlatformApplicationMisc
"ApplicationCore"
}
);
//APEX EXCLUSIONS
if (Target.Platform != UnrealTargetPlatform.Android && Target.Platform != UnrealTargetPlatform.HTML5 && Target.Platform != UnrealTargetPlatform.IOS)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"APEX"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"ApexDestruction"
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public UnrealEnginePython(TargetInfo Target)
#endif
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string enableUnityBuild = System.Environment.GetEnvironmentVariable("UEP_ENABLE_UNITY_BUILD");
bFasterWithoutUnity = string.IsNullOrEmpty(enableUnityBuild);
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Sockets",
"Networking"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"MovieScene",
"LevelSequence",
"HTTP",
"UMG",
"AppFramework",
"RHI",
"Voice",
"RenderCore",
"MovieSceneCapture",
"Landscape",
"Foliage",
"AIModule"
// ... add private dependencies that you statically link with here ...
}
);
#if WITH_FORWARDED_MODULE_RULES_CTOR
BuildVersion Version;
if (BuildVersion.TryRead(BuildVersion.GetDefaultFileName(), out Version))
{
if (Version.MinorVersion >= 18)
{
PrivateDependencyModuleNames.Add("ApplicationCore");
}
}
#endif
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
#if WITH_FORWARDED_MODULE_RULES_CTOR
if (Target.bBuildEditor)
#else
if (UEBuildConfiguration.bBuildEditor)
#endif
{
PrivateDependencyModuleNames.AddRange(new string[] {
"UnrealEd",
"LevelEditor",
"BlueprintGraph",
"Projects",
"Sequencer",
"SequencerWidgets",
"AssetTools",
"LevelSequenceEditor",
"MovieSceneTools",
"MovieSceneTracks",
"CinematicCamera",
"EditorStyle",
"GraphEditor",
"UMGEditor",
"AIGraph",
"RawMesh",
"DesktopWidgets",
"EditorWidgets",
"FBX",
"Persona",
"PropertyEditor",
"LandscapeEditor",
"MaterialEditor"
});
}
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(windowsKnownPaths, "Win64");
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetWindowsPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicAdditionalLibraries.Add(libPath);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(macKnownPaths, "Mac");
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetMacPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicDelayLoadDLLs.Add(libPath);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (pythonHome == "")
{
string includesPath = DiscoverLinuxPythonIncludesPath();
if (includesPath == null)
{
throw new System.Exception("Unable to find Python includes, please add a search path to linuxKnownIncludesPaths");
}
string libsPath = DiscoverLinuxPythonLibsPath();
if (libsPath == null)
{
throw new System.Exception("Unable to find Python libs, please add a search path to linuxKnownLibsPaths");
}
PublicIncludePaths.Add(includesPath);
PublicAdditionalLibraries.Add(libsPath);
}
else
{
string[] items = pythonHome.Split(';');
PublicIncludePaths.Add(items[0]);
PublicAdditionalLibraries.Add(items[1]);
}
}
#if WITH_FORWARDED_MODULE_RULES_CTOR
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicIncludePaths.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/python35/include"));
PublicLibraryPaths.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/armeabi-v7a"));
PublicAdditionalLibraries.Add("python3.5m");
string APLName = "UnrealEnginePython_APL.xml";
string RelAPLPath = Utils.MakePathRelativeTo(System.IO.Path.Combine(ModuleDirectory, APLName), Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", RelAPLPath));
}
#endif
}
public IOToolkit(TargetInfo Target)
#endif
{
// uncomment code below to package project without rebuild this module
//bUsePrecompiled = true;
//PrecompileForTargets = PrecompileTargetsType.None;
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(pluginDir, "Source/IOToolkit/Public"),
Path.Combine(pluginDir, "ThirdParty/IOToolkit/include")
// ... add public include paths required here ...
}
);
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string _ioModuleDir = Path.Combine(pluginDir, "ThirdParty/IOToolkit");
if (!Directory.Exists(_ioModuleDir))
{
Console.WriteLine("[Error]: Can not find IOToolkit module which should be located at: "
+ Path.GetFullPath(_ioModuleDir));
}
string _platform = Target.Platform == UnrealTargetPlatform.Win32 ? "Win32" : "Win64";
CopyAll(
new DirectoryInfo(Path.Combine(pluginDir, "ThirdParty/IOToolkit/binaries", _platform)),
new DirectoryInfo(Path.Combine(pluginDir, "Binaries", _platform))
);
PrivateIncludePaths.AddRange(
new string[] {
"IOToolkit/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Projects"
// ... add other public dependencies that you statically link with here ...
}
);
PublicAdditionalLibraries.Add(Path.Combine(pluginDir, "Binaries", _platform, "IODevice.lib"));
// Delay-load the DLL, so we can load it from the right place first
PublicDelayLoadDLLs.Add("IODevice.dll");
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 ...
}
);
RuntimeDependencies.Add(Path.Combine("$(PluginDir)/Binaries", _platform, "..."), StagedFileType.NonUFS);
}
public FliteTTSPlugin(ReadOnlyTargetRules Target) : base(Target)
{
bEnableUndefinedIdentifierWarnings = false;
PublicIncludePaths.AddRange(
new string[] {
"FliteTTSPlugin/Private",
"FliteTTSPlugin/Public",
"FliteTTSPlugin/ThirdParty/flite/include", // ... 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",
// ... 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.Win32)
{
string FliteDirectory = Path.Combine(BaseDirectory, "ThirdParty", "flite", "lib");
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(FliteDirectory, "fliteDll.dll")));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(FliteDirectory, "cmu_us_rms.dll")));
// RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(FliteDirectory, "cmu_us_slt.dll")));
PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "flite.lib"));
PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "libflite-cmulex.lib"));
PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "libflite-usenglish.lib"));
PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "cmu_us_rms.lib"));
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
string FliteDirectory = Path.Combine(BaseDirectory, "ThirdParty", "flite", "lib");
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(FliteDirectory, "fliteDll.dll")));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(FliteDirectory, "cmu_us_rms.dll")));
// RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(FliteDirectory, "cmu_us_slt.dll")));
PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "flite.lib"));
PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "libflite-cmulex.lib"));
PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "libflite-usenglish.lib"));;
PublicAdditionalLibraries.Add(Path.Combine(FliteDirectory, "cmu_us_rms.lib"));
}
else
{
// Linux, Mac, WinRT: not supported
}
}
public RuntimeMeshComponent(ReadOnlyTargetRules rules) : base(rules)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"RuntimeMeshComponent/Public",
// ... add public include paths required here ...
//"RuntimeMeshComponent/Public/RuntimeDestructibleActor"
}
);
PrivateIncludePaths.AddRange(
new string[] {
"RuntimeMeshComponent/Private",
// ... add other private include paths required here ...
//"RuntimeMeshComponent/Private/RuntimeDestructibleActor"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
//"PhysX", "APEX","ApexDestruction"
}
);
string ApexVersion = "APEX_1.4";
string APEXDir = rules.UEThirdPartySourceDirectory + "PhysX3/" + ApexVersion + "/";
string APEXLibDir = rules.UEThirdPartySourceDirectory + "PhysX3/Lib";
string PxSharedVersion = "PxShared";
string PxSharedDir = rules.UEThirdPartySourceDirectory + "PhysX3/" + PxSharedVersion + "/";
string PxSharedIncludeDir = PxSharedDir + "include/";
//string PxSourceVersion = "Source/PhysX";
//string PxSourceDir = rules.UEThirdPartySourceDirectory + "PhysX3/" + PxSourceVersion + "/";
PublicSystemIncludePaths.AddRange(
new string[] {
PxSharedDir + "src/foundation/include", //PsArray.h
APEXDir + "nvparameterized/include", //"NvParametersTypes.h"
//APEXDir + "include/destructible",//DestructibleActorJoint.h
APEXDir + "module/destructible/include/", //DestructibleScene.h, DestructibleActorImpl.h
//APEXDir + "module/destructible/src/",// DestructibleActorImpl.cpp
//PxSourceDir + "src",
//PxSourceDir + "src/buffering"
}
);
//To fix issues with Atomic.h
PublicDependencyModuleNames.AddRange(new string[] { "ApplicationCore" });
PrivateDependencyModuleNames.AddRange(new string[] { "PhysX", "APEX" }); //PhysX
PrivateDependencyModuleNames.AddRange(new string[] { "RMC_ApexDestruction" });
if (rules.Type == TargetRules.TargetType.Editor)
{
PublicDependencyModuleNames.AddRange(new string[] { "MeshBuilder" });
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
// ... add private dependencies that you statically link with here ...
"RenderCore",
"ShaderCore",
"RHI",
//"MeshBuilder",//BuildSkeletalAdjacencyIndexBuffer()
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public MotionMatchingEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"MotionMatchingEditor/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"MotionMatchingEditor/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[]
{
"Core",
"CoreUObject",
"Json",
"Slate",
"SlateCore",
"Engine",
"InputCore",
"UnrealEd", // for FAssetEditorManager
"KismetWidgets",
"Kismet", // for FWorkflowCentricApplication
"PropertyEditor",
"RenderCore",
"ContentBrowser",
"WorkspaceMenuStructure",
"EditorStyle",
"MeshPaint",
"EditorWidgets",
"Projects",
"MotionMatching",
"AnimGraph",
"BlueprintGraph",
"AssetRegistry",
"AdvancedPreviewScene",
// ... add private dependencies that you statically link with here ...
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Settings",
"IntroTutorials",
"AssetTools",
"LevelEditor"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetTools"
}
);
}
public FLKinectPlugin(TargetInfo Target)
{
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"));
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Developer/FLKinectPlugin/Private",
ThirdPartyKinectIncludePath
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Engine",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public HoudiniEngineEditor(TargetInfo Target)
{
string HFSPath = "";
string HoudiniVersion = "14.0.374";
// 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 Engine(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/EnginePrivatePCH.h";
SharedPCHHeaderFile = "Public/EngineSharedPCH.h";
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "NetworkReplayStreaming", "AudioMixer", "AnimationCore" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"ImageWrapper",
"HeadMountedDisplay",
"EyeTracker",
"MRMesh",
"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",
"ApplicationCore",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"MessagingCommon",
"RenderCore",
"RHI",
"ShaderCore",
"UtilityShaders",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"GameplayTags",
"DatabaseSupport",
"PacketHandler",
"AudioPlatformConfiguration",
"MeshDescription",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Sockets",
"Landscape",
"UMG",
"Projects",
"MaterialShaderQualitySettings",
"CinematicCamera",
"Analytics",
"AnalyticsET",
}
);
DynamicallyLoadedModuleNames.Add("EyeTracker");
if (Target.bUseXGEController &&
Target.Type == TargetType.Editor &&
(Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32))
{
PrivateDependencyModuleNames.Add("XGEController");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.Add("Localization");
DynamicallyLoadedModuleNames.Add("Localization");
}
// to prevent "causes WARNING: Non-editor build cannot depend on non-redistributable modules."
if (Target.Type == TargetType.Editor)
{
// for now we depend on this
PrivateDependencyModuleNames.Add("RawMesh");
PrivateDependencyModuleNames.Add("MeshDescriptionOperations");
}
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;
}
}
AddEngineThirdPartyPrivateStaticDependencies(Target,
"libOpus"
);
}
if (bVariadicTemplatesSupported)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
if (Target.Type == TargetType.Editor)
{
// these modules require variadic templates
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
}
}
CircularlyReferencedDependentModules.Add("GameplayTags");
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");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneCapture",
"MovieSceneTracks",
"HeadMountedDisplay",
"MRMesh",
"StreamingPauseRendering",
}
);
if (Target.Type != TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Media",
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
if (Target.Type == TargetType.Server || Target.Type == TargetType.Editor)
{
PrivateDependencyModuleNames.Add("PerfCounters");
}
if (Target.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 != 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 != 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",
"WindowsPlatformEditor",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform",
"AllDesktopTargetPlatform",
"MacPlatformEditor",
}
);
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"LinuxClientTargetPlatform",
"AllDesktopTargetPlatform",
"LinuxPlatformEditor",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"Advertising"
}
);
if (Target.Type != TargetType.Server)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ImageWrapper"
}
);
}
WhitelistRestrictedFolders.Add("Private/NotForLicensees");
if (!Target.bBuildRequiresCookedData && Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"DerivedDataCache",
"TargetPlatform",
"DesktopPlatform"
}
);
}
if (Target.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");
DynamicallyLoadedModuleNames.Add("AnimationModifiers");
PrivateIncludePathModuleNames.Add("AssetTools");
DynamicallyLoadedModuleNames.Add("AssetTools");
PrivateIncludePathModuleNames.Add("PIEPreviewDeviceProfileSelector");
}
SetupModulePhysXAPEXSupport(Target);
if (Target.bCompilePhysX && (Target.bBuildEditor || Target.bCompileAPEX))
{
DynamicallyLoadedModuleNames.Add("PhysXCooking");
}
// Engine public headers need to know about some types (enums etc.)
PublicIncludePathModuleNames.Add("ClothingSystemRuntimeInterface");
PublicDependencyModuleNames.Add("ClothingSystemRuntimeInterface");
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.Add("ClothingSystemEditorInterface");
PrivateIncludePathModuleNames.Add("ClothingSystemEditorInterface");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
// Head Mounted Display support
// PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
// DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
// TODO test this for HTML5 !
//AddEngineThirdPartyPrivateStaticDependencies(Target,
// "UEOgg",
// "Vorbis",
// "VorbisFile"
// );
PublicDependencyModuleNames.Add("HTML5JS");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"libOpus"
);
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
PrivateDependencyModuleNames.Add("AndroidRuntimeSettings");
}
if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PrivateDependencyModuleNames.Add("IOSRuntimeSettings");
}
if (Target.Platform == UnrealTargetPlatform.Switch)
{
PrivateDependencyModuleNames.Add("SwitchRuntimeSettings");
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
PublicDefinitions.Add("GPUPARTICLE_LOCAL_VF_ONLY=0");
// Add a reference to the stats HTML files referenced by UEngine::DumpFPSChartToHTML. Previously staged by CopyBuildToStagingDirectory.
if (Target.bBuildEditor || Target.Configuration != UnrealTargetConfiguration.Shipping)
{
RuntimeDependencies.Add("$(EngineDir)/Content/Stats/...", StagedFileType.UFS);
}
}
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");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrecompileForTargets = PrecompileTargetsType.Any;
}
}
public VictoryBPLibrary(ReadOnlyTargetRules Target) : base(Target)
{
//Get rid of debug commandline length compile error
//https://developercommunity.visualstudio.com/content/problem/668411/command-line-error-d8049-still-happening.html
bLegacyPublicIncludePaths = false;
PrivatePCHHeaderFile = "Private/VictoryBPLibraryPrivatePCH.h";
//4.15 Include What You Use
bEnforceIWYU = false;
PublicIncludePaths.AddRange(
new string[] {
"VictoryBPLibrary/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"VictoryBPLibrary/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"RHI",
"RenderCore",
"HTTP",
"UMG", "Slate", "SlateCore",
"ImageWrapper",
"PhysicsCore",
"PhysX",
"HeadMountedDisplay",
"AIModule",
"NavigationSystem",
"Vorbis",
//FPlatformApplicationMisc
"ApplicationCore"
}
);
//APEX EXCLUSIONS
if (Target.Platform != UnrealTargetPlatform.Android && Target.Platform != UnrealTargetPlatform.IOS)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"APEX"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"ApexDestruction"
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public WebSocket(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Public/WebSocket.h";
string strEngineDir = GetEngineDirectory();
string strEngineVersion = ReadEngineVersion(strEngineDir);
System.Console.WriteLine("version:" + strEngineVersion);
PrivateIncludePaths.AddRange(
new string[] {
"WebSocket/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Json",
"JsonUtilities",
"Sockets",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"Json",
"JsonUtilities",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicDefinitions.Add("PLATFORM_UWP=0");
PrivateDependencyModuleNames.Add("zlib");
if (EngineMinorVersion == "21" || EngineMinorVersion == "20")
{
PrivateDependencyModuleNames.Add("OpenSSL");
}
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Win64");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Win64/"));
//PublicLibraryPaths.Add(strStaticPath);
// for 4.21
if (EngineMinorVersion == "21" || EngineMinorVersion == "20")
{
string[] StaticLibrariesX64 = new string[] {
"websockets_static.lib",
};
foreach (string Lib in StaticLibrariesX64)
{
PublicAdditionalLibraries.Add(strStaticPath + Lib);
}
}
else
{
// for 4.22 and beyond
if (Target.Type == TargetType.Editor)
{
PublicAdditionalLibraries.Add(strStaticPath + "websockets_static422.lib");
PublicAdditionalLibraries.Add(strStaticPath + "libeay32.lib");
PublicAdditionalLibraries.Add(strStaticPath + "ssleay32.lib");
}
else
{
PublicAdditionalLibraries.Add(strStaticPath + "websockets_game_static422.lib");
}
}
}
if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicDefinitions.Add("PLATFORM_UWP=0");
PrivateDependencyModuleNames.Add("zlib");
PrivateDependencyModuleNames.Add("OpenSSL");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Win32");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Win32/"));
PublicLibraryPaths.Add(strStaticPath);
// 4.22 and 4.21
if (EngineMinorVersion == "21" || EngineMinorVersion == "20")
{
string[] StaticLibrariesX32 = new string[] {
"websockets_static.lib",
//"libcrypto.lib",
//"libssl.lib",
};
foreach (string Lib in StaticLibrariesX32)
{
PublicAdditionalLibraries.Add(Lib);
}
}
else if (EngineMinorVersion == "22")
{
string[] StaticLibrariesX32 = new string[] {
"websockets_static422.lib",
//"libcrypto.lib",
//"libssl.lib",
};
foreach (string Lib in StaticLibrariesX32)
{
PublicAdditionalLibraries.Add(Lib);
}
}
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PublicDefinitions.Add("PLATFORM_UWP=0");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/HTML5/"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesHTML5 = new string[] {
"WebSocket.js",
};
foreach (string Lib in StaticLibrariesHTML5)
{
PublicAdditionalLibraries.Add(strStaticPath + Lib);
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicDefinitions.Add("PLATFORM_UWP=0");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Mac");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Mac/"));
//PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesMac = new string[] {
"libwebsockets.a",
"libssl.a",
"libcrypto.a"
};
foreach (string Lib in StaticLibrariesMac)
{
PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib));
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PublicDefinitions.Add("PLATFORM_UWP=0");
PrivateDependencyModuleNames.Add("OpenSSL");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Linux");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Linux/"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesMac = new string[] {
"libwebsockets.a",
//"libssl.a",
//"libcrypto.a"
};
foreach (string Lib in StaticLibrariesMac)
{
PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib));
}
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicDefinitions.Add("PLATFORM_UWP=0");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/IOS");
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath + "/Source/");
PluginPath = PluginPath.Replace("\\", "/");
string strStaticPath = PluginPath + "/ThirdParty/lib/IOS/";// Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/IOS/"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesIOS = new string[] {
"websockets",
"ssl",
"crypto"
};
foreach (string Lib in StaticLibrariesIOS)
{
PublicAdditionalLibraries.Add(Lib);
PublicAdditionalShadowFiles.Add(Path.Combine(strStaticPath, "lib" + Lib + ".a"));
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicDefinitions.Add("PLATFORM_UWP=0");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Android");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Android/armeabi-v7a"));
PublicLibraryPaths.Add(strStaticPath);
string strStaticArm64Path = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Android/arm64-v8a"));
PublicLibraryPaths.Add(strStaticArm64Path);
string[] StaticLibrariesAndroid = new string[] {
"websockets",
"ssl",
"crypto"
};
foreach (string Lib in StaticLibrariesAndroid)
{
PublicAdditionalLibraries.Add(Lib);
}
}
}
public SequenceRecorder(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Editor/SequenceRecorder/Private",
"Editor/SequenceRecorder/Private/Sections",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"TimeManagement",
"SerializedRecorderInterface",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"SlateCore",
"Slate",
"InputCore",
"Engine",
"UnrealEd",
"EditorStyle",
"Projects",
"LevelEditor",
"Persona",
"WorkspaceMenuStructure",
"PropertyEditor",
"MovieScene",
"MovieSceneTracks",
"LevelSequence",
"NetworkReplayStreaming",
"AssetRegistry",
"CinematicCamera",
"EditorWidgets",
"Kismet",
"LiveLinkInterface",
"SerializedRecorderInterface",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
// Add __WINDOWS_WASAPI__ so that RtAudio compiles with WASAPI
PublicDefinitions.Add("__WINDOWS_WASAPI__");
}
}
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",
"PropertyEditor",
"EditorStyle",
"GraphColor",
"MeshBuilderCommon",
"MeshUtilitiesCommon",
"MeshDescription",
"StaticMeshDescription",
"ToolMenus",
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"MeshMergeUtilities"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AnimationBlueprintEditor",
"AnimationEditor",
"MeshMergeUtilities",
"MaterialBaking",
"Persona",
"SkeletalMeshEditor",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AnimationBlueprintEditor",
"AnimationEditor",
"MeshMergeUtilities",
"MaterialBaking",
"SkeletalMeshEditor",
}
);
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");
}
// Always use the official version of IntelTBB
string IntelTBBLibs = Target.UEThirdPartySourceDirectory + "Intel/TBB/IntelTBB-2019u8/lib/";
// EMBREE
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string SDKDir = Target.UEThirdPartySourceDirectory + "Intel/Embree/Embree2140/Win64/";
PublicIncludePaths.Add(SDKDir + "include");
PublicAdditionalLibraries.Add(SDKDir + "lib/embree.2.14.0.lib");
RuntimeDependencies.Add("$(TargetOutputDir)/embree.2.14.0.dll", SDKDir + "lib/embree.2.14.0.dll");
RuntimeDependencies.Add("$(TargetOutputDir)/tbb.dll", IntelTBBLibs + "Win64/vc14/tbb.dll");
RuntimeDependencies.Add("$(TargetOutputDir)/tbbmalloc.dll", IntelTBBLibs + "Win64/vc14/tbbmalloc.dll");
PublicDefinitions.Add("USE_EMBREE=1");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string SDKDir = Target.UEThirdPartySourceDirectory + "Intel/Embree/Embree2140/MacOSX/";
PublicIncludePaths.Add(SDKDir + "include");
PublicAdditionalLibraries.Add(SDKDir + "lib/libembree.2.14.0.dylib");
PublicAdditionalLibraries.Add(IntelTBBLibs + "Mac/libtbb.dylib");
PublicAdditionalLibraries.Add(IntelTBBLibs + "Mac/libtbbmalloc.dylib");
RuntimeDependencies.Add("$(TargetOutputDir)/libembree.2.14.0.dylib", SDKDir + "lib/libembree.2.14.0.dylib");
RuntimeDependencies.Add("$(TargetOutputDir)/libtbb.dylib", IntelTBBLibs + "Mac/libtbb.dylib");
RuntimeDependencies.Add("$(TargetOutputDir)/libtbbmalloc.dylib", IntelTBBLibs + "Mac/libtbbmalloc.dylib");
PublicDefinitions.Add("USE_EMBREE=1");
}
else
{
PublicDefinitions.Add("USE_EMBREE=0");
}
}
public SimpleUnrealPakView(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Projects",
"InputCore",
"CoreUObject",
"Engine",
"SimpleUnrealPak",
"ProceduralMeshComponent"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd",
"LevelEditor",
"Slate",
"SlateCore",
"PropertyEditor",
"AdvancedPreviewScene",
"EditorStyle",
// ... add private dependencies that you statically link with here ...
}
);
}
}
public MovieSceneTools(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/MovieSceneTools/Private",
"Editor/MovieSceneTools/Private/CurveKeyEditors",
"Editor/MovieSceneTools/Private/TrackEditors",
"Editor/MovieSceneTools/Private/TrackEditors/PropertyTrackEditors",
"Editor/MovieSceneTools/Private/TrackEditorThumbnail",
"Editor/MovieSceneTools/Private/Sections",
"Editor/UnrealEd/Private", //compatibility for FBX importer
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"UnrealEd",
"Sequencer"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"ActorPickerMode",
"CinematicCamera",
"DesktopPlatform",
"LevelSequence",
"MovieScene",
"MovieSceneCapture",
"MovieSceneTracks",
"BlueprintGraph",
"KismetCompiler",
"GraphEditor",
"ContentBrowser",
"Slate",
"SlateCore",
"EditorStyle",
"EditorWidgets",
"PropertyEditor",
"MaterialEditor",
"RenderCore",
"RHI",
"ShaderCore",
"SequenceRecorder",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"Sequencer",
"Settings",
"SceneOutliner",
"MainFrame",
"UnrealEd",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"SceneOutliner",
"MainFrame",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"Sequencer",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "FBX");
}
public JoystickPlugin(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
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 (UEBuildConfiguration.bBuildEditor == true)
{
LinkThirdPartyStaticallyOnWindows = false;
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string SDL2Path = ThirdPartyPath + "SDL2/SDL/";
string SDL2LibPath = SDL2Path + "Lib/";
PublicIncludePaths.Add(Path.Combine(SDL2Path, "include/"));
PrivateIncludePaths.Add(Path.Combine(SDL2Path, "include/")); // Public || Private !? is there documentation ?
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");
}
if (Target.Platform == UnrealTargetPlatform.Win32)
{
string SDL2Path = ThirdPartyPath + "SDL2/SDL/";
string SDL2LibPath = SDL2Path + "Lib32/";
PublicIncludePaths.Add(Path.Combine(SDL2Path, "include/"));
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)
{
PublicFrameworks.Add("/Library/Frameworks/SDL2.framework");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
//AddThirdPartyPrivateStaticDependencies(Target, "SDL2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
}
public UnrealEd(TargetInfo Target)
{
SharedPCHHeaderFile = "Editor/UnrealEd/Public/UnrealEd.h";
PrivateIncludePaths.AddRange(
new string[]
{
"Editor/UnrealEd/Private",
"Editor/UnrealEd/Private/Settings",
"Editor/PackagesDialog/Public",
"Developer/DerivedDataCache/Public",
"Developer/TargetPlatform/Public",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"AssetRegistry",
"AssetTools",
"BehaviorTreeEditor",
"ClassViewer",
"ContentBrowser",
"CrashTracker",
"DerivedDataCache",
"DesktopPlatform",
"EnvironmentQueryEditor",
"GameProjectGeneration",
"ProjectTargetPlatformEditor",
"ImageWrapper",
"MainFrame",
"MaterialEditor",
"MergeActors",
"MeshUtilities",
"Messaging",
"MovieSceneCapture",
"NiagaraEditor",
"PlacementMode",
"Settings",
"SettingsEditor",
"SuperSearch",
"SoundClassEditor",
"ViewportSnapping",
"SourceCodeAccess",
"ReferenceViewer",
"IntroTutorials",
"OutputLog",
"Landscape",
"Niagara",
"SizeMap",
"LocalizationService",
"HierarchicalLODUtilities",
"MessagingRpc",
"PortalRpc",
"PortalServices",
"BlueprintNativeCodeGen",
"ViewportInteraction",
"VREditor",
"Persona",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"BspMode",
"Core",
"CoreUObject",
"DirectoryWatcher",
"Documentation",
"Engine",
"Json",
"Projects",
"SandboxFile",
"Slate",
"SlateCore",
"EditorStyle",
"SourceControl",
"UnrealEdMessages",
"AIModule",
"GameplayDebugger",
"BlueprintGraph",
"Http",
"UnrealAudio",
"FunctionalTesting",
"AutomationController",
"Internationalization",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"LevelSequence",
"AnimGraph",
"AppFramework",
"BlueprintGraph",
"CinematicCamera",
"DesktopPlatform",
"EditorStyle",
"EngineSettings",
"InputCore",
"InputBindingEditor",
"LauncherServices",
"MaterialEditor",
"MessageLog",
"NetworkFileSystem",
"PakFile",
"PropertyEditor",
"Projects",
"RawMesh",
"RenderCore",
"RHI",
"ShaderCore",
"Sockets",
"SoundClassEditor",
"SoundCueEditor",
"SourceControlWindows",
"StatsViewer",
"SwarmInterface",
"TargetPlatform",
"TargetDeviceServices",
"EditorWidgets",
"GraphEditor",
"Kismet",
"InternationalizationSettings",
"JsonUtilities",
"Landscape",
"HeadMountedDisplay",
"MeshPaint",
"Foliage",
"VectorVM",
"TreeMap",
"MaterialUtilities",
"LocalizationService",
"AddContentDialog",
"GameProjectGeneration",
"HierarchicalLODUtilities",
"Analytics",
"AnalyticsET",
"PluginWarden",
"PixelInspectorModule",
"MovieScene",
"MovieSceneTracks",
"ViewportInteraction",
"VREditor"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"CrashTracker",
"FontEditor",
"StaticMeshEditor",
"TextureEditor",
"Cascade",
"UMGEditor",
"Matinee",
"AssetRegistry",
"AssetTools",
"ClassViewer",
"CollectionManager",
"ContentBrowser",
"CurveTableEditor",
"DataTableEditor",
"DestructibleMeshEditor",
"EditorSettingsViewer",
"LandscapeEditor",
"KismetCompiler",
"DetailCustomizations",
"ComponentVisualizers",
"MainFrame",
"LevelEditor",
"PackagesDialog",
"Persona",
"PhAT",
"ProjectLauncher",
"DeviceManager",
"SettingsEditor",
"SessionFrontend",
"Sequencer",
"SuperSearch",
"GeometryMode",
"TextureAlignMode",
"FoliageEdit",
"PackageDependencyInfo",
"ImageWrapper",
"Blutility",
"IntroTutorials",
"WorkspaceMenuStructure",
"PlacementMode",
"NiagaraEditor",
"MeshUtilities",
"MergeActors",
"ProjectSettingsViewer",
"ProjectTargetPlatformEditor",
"PListEditor",
"BehaviorTreeEditor",
"EnvironmentQueryEditor",
"ViewportSnapping",
"UserFeedback",
"GameplayTagsEditor",
"GameplayTasksEditor",
"GameplayAbilitiesEditor",
"UndoHistory",
"SourceCodeAccess",
"ReferenceViewer",
"EditorLiveStreaming",
"HotReload",
"IOSPlatformEditor",
"HTML5PlatformEditor",
"SizeMap",
"PortalProxies",
"PortalServices",
"GeometryCacheEd",
"BlueprintNativeCodeGen"
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.Add("AndroidPlatformEditor");
}
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"GraphEditor",
"Kismet",
}
);
// Add include directory for Lightmass
PublicIncludePaths.Add("Programs/UnrealLightmass/Public");
PublicIncludePathModuleNames.AddRange(
new string[] {
"UserFeedback",
"CollectionManager",
"BlueprintGraph",
"AddContentDialog",
"MeshUtilities"
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDependencyModuleNames.Add("XAudio2");
PublicDependencyModuleNames.Add("AudioMixerXAudio2");
PublicDependencyModuleNames.Add("UnrealAudioXAudio2");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"DX11Audio"
);
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicDependencyModuleNames.Add("UnrealAudioCoreAudio");
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PublicDependencyModuleNames.Add("ALAudio");
}
AddEngineThirdPartyPrivateStaticDependencies(Target,
"HACD",
"VHACD",
"FBX",
"FreeType2"
);
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
Definitions.Add("WITH_RECAST=1");
}
else
{
Definitions.Add("WITH_RECAST=0");
}
}
public HoudiniEngineEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseSharedPCHs;
// 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);
}
// Find HFS
string HFSPath = GetHFSPath();
if (HFSPath != "")
{
PlatformID buildPlatformId = Environment.OSVersion.Platform;
if (buildPlatformId == PlatformID.Win32NT)
{
Definitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath);
}
}
// Find the HAPI include directory
string HAPIIncludePath = HFSPath + "/toolkit/include/HAPI";
if (!Directory.Exists(HAPIIncludePath))
{
// Try the custom include path as well in case the toolkit path doesn't exist yet.
HAPIIncludePath = HFSPath + "/custom/houdini/include/HAPI";
if (!Directory.Exists(HAPIIncludePath))
{
System.Console.WriteLine(string.Format("Couldnt find the HAPI include folder!"));
HAPIIncludePath = "";
}
}
if (HAPIIncludePath != "")
{
PublicIncludePaths.Add(HAPIIncludePath);
}
// Get the plugin path
string PluginPath = Path.Combine(ModuleDirectory, "../../");
PluginPath = Utils.MakePathRelativeTo(PluginPath, Target.RelativeEnginePath);
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",
}
);
}