public ESLibrary(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
"ESLibrary/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"ESLibrary/Private"
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"ProceduralMeshComponent",
"InputCore",
"UMG",
"Paper2D",
"MariaDBConnectorLibs",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"HTTP",
"NetworkReplayStreaming",
"ImageWrapper",
"RenderCore",
"AIModule",
"NavigationSystem",
"ApplicationCore",
"RHI",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
PublicDefinitions.Add("WITH_OGGVORBIS");
}
public LuaPluginRuntime(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
bFasterWithoutUnity = true;
PublicIncludePaths.Add("LuaPluginRuntime/Public");
PrivateIncludePaths.Add("LuaPluginRuntime/Private");
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine" });
PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore", "UMG", "AssetRegistry" });
// PublicDefinitions.Add("LuaDebug");
PublicDefinitions.Add("STRONG_CHECK_GC_REF");
if (Target.Type == TargetType.Editor)
{
PrivateDependencyModuleNames.AddRange(new string[] { "VarWatcher", "UnrealEd", "Slate" });
}
PublicIncludePaths.Add(Path.Combine(LuaLibPath, "Include"));
// use 5.3 or 5.1
bool IsUseLua53 = false;
bool IsUseLua51 = true;
if (IsUseLua53)
{
PublicDependencyModuleNames.Add("Lua53");
PublicDefinitions.Add("USE_LUA53");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicDefinitions.Add("LUA_BUILD_AS_DLL");
// Definitions.Add("USE_LUASOURCE");
}
}
else if (IsUseLua51)
{
PublicDependencyModuleNames.Add("Lua51");
PublicDefinitions.Add("USE_LUA51");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicDefinitions.Add("LUA_BUILD_AS_DLL");
// Definitions.Add("USE_LUASOURCE");
}
}
else
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// Definitions.Add("USE_LUASOURCE");
PublicAdditionalLibraries.Add(Path.Combine(LuaLibPath, "Lib", "Win64", "Debug", "lua.lib"));
// PublicAdditionalLibraries.Add(Path.Combine(LuaLibPath, "Lib", "Win64", "Release", "lua.lib"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(Path.Combine(LuaLibPath, "Lib", "Mac", "Release", "lua.a"));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicAdditionalLibraries.Add(Path.Combine(LuaLibPath, "Lib", "Android", "Release", "lua.a"));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalLibraries.Add(Path.Combine(LuaLibPath, "Lib", "Ios", "Release", "lua.a"));
}
}
}
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",
"GraphColor",
"MeshBuilder",
"MeshUtilitiesCommon",
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"MeshMergeUtilities"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MeshMergeUtilities",
"MaterialBaking",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MeshMergeUtilities",
"MaterialBaking",
}
);
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 (Target.bCompileSimplygon == true)
{
AddEngineThirdPartyPrivateDynamicDependencies(Target, "SimplygonMeshReduction");
if (Target.bCompileSimplygonSSF == true)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SimplygonSwarm"
}
);
}
}
// EMBREE
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string SDKDir = Target.UEThirdPartySourceDirectory + "IntelEmbree/Embree2140/Win64/";
PublicIncludePaths.Add(SDKDir + "include");
PublicLibraryPaths.Add(SDKDir + "lib");
PublicAdditionalLibraries.Add("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", SDKDir + "lib/tbb.dll");
RuntimeDependencies.Add("$(TargetOutputDir)/tbbmalloc.dll", SDKDir + "lib/tbbmalloc.dll");
PublicDefinitions.Add("USE_EMBREE=1");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string SDKDir = Target.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");
PublicDefinitions.Add("USE_EMBREE=1");
}
else
{
PublicDefinitions.Add("USE_EMBREE=0");
}
}
public FMODStudio(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = "Private/FMODStudioPrivatePCH.h";
bUseUnity = false;
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public/FMOD"));
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Classes"));
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Media",
"Projects"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneTracks"
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("AssetRegistry");
PrivateDependencyModuleNames.Add("UnrealEd");
PrivateDependencyModuleNames.Add("Settings");
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
string configName = "";
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
configName = "L";
PublicDefinitions.Add("FMODSTUDIO_LINK_LOGGING=1");
}
else
{
configName = "";
PublicDefinitions.Add("FMODSTUDIO_LINK_RELEASE=1");
}
string linkExtension = "";
string dllExtension = "";
string libPrefix = "";
string libPath = FMODLibDir;
bool bAddRuntimeDependencies = true;
bool bAddDelayLoad = false;
if (libPath == null)
{
string platformName = Target.Platform.ToString();
libPath = System.IO.Path.Combine(LibRootDirectory, platformName);
// Minimum UE version for Switch 4.15
System.Console.WriteLine("Target Platform -- " + Target.Platform.ToString());
if (Target.Platform == UnrealTargetPlatform.Switch)
{
linkExtension = ".a";
dllExtension = ".a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
}
else if (Target.Platform.ToString() == "UWP64")
{
linkExtension = ".lib";
dllExtension = ".dll";
bAddDelayLoad = true;
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Windows))
{
linkExtension = "_vc.lib";
dllExtension = ".dll";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
linkExtension = dllExtension = ".dylib";
libPrefix = "lib";
libPath = System.IO.Path.Combine(ModuleDirectory, "../../Libs/Mac/");
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
linkExtension = "_vc.lib";
dllExtension = ".dll";
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
linkExtension = "_stub.a";
dllExtension = ".prx";
libPrefix = "lib";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
bAddRuntimeDependencies = false; // Don't use this system
linkExtension = dllExtension = ".so";
libPrefix = "lib";
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
linkExtension = "_iphoneos.a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
}
else if (Target.Platform == UnrealTargetPlatform.TVOS)
{
linkExtension = "_appletvos.a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
libPath = System.IO.Path.Combine(libPath, "x86_64");
linkExtension = ".so";
dllExtension = ".so";
libPrefix = "lib";
}
}
else
{
linkExtension = ConsoleLinkExt;
dllExtension = ConsoleDllExt;
libPrefix = ConsoleLibPrefix;
bAddRuntimeDependencies = ConsoleRuntimeDependencies;
bAddDelayLoad = ConsoleDelayLoad;
}
// Collapse the directory path, otherwise MacOS has issues with plugin paths.
libPath = Utils.CleanDirectorySeparators(libPath);
string fmodLibName = System.String.Format("{0}fmod{1}{2}", libPrefix, configName, linkExtension);
string fmodStudioLibName = System.String.Format("{0}fmodstudio{1}{2}", libPrefix, configName, linkExtension);
string fmodDllName = System.String.Format("{0}fmod{1}{2}", libPrefix, configName, dllExtension);
string fmodStudioDllName = System.String.Format("{0}fmodstudio{1}{2}", libPrefix, configName, dllExtension);
string fmodLibPath = System.IO.Path.Combine(libPath, fmodLibName);
string fmodStudioLibPath = System.IO.Path.Combine(libPath, fmodStudioLibName);
string fmodDllPath = System.IO.Path.Combine(libPath, fmodDllName);
string fmodStudioDllPath = System.IO.Path.Combine(libPath, fmodStudioDllName);
System.Collections.Generic.List <string> plugins = GetPlugins(libPath);
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
string[] archs = new string[] { "armeabi-v7a", "arm64-v8a", "x86_64" };
foreach (string arch in archs)
{
string LibPath = System.IO.Path.Combine(libPath, arch);
PublicAdditionalLibraries.Add(System.String.Format("{0}/{1}", LibPath, fmodLibName));
PublicAdditionalLibraries.Add(System.String.Format("{0}/{1}", LibPath, fmodStudioLibName));
}
}
else
{
PublicAdditionalLibraries.Add(fmodLibPath);
PublicAdditionalLibraries.Add(fmodStudioLibPath);
}
if (bAddRuntimeDependencies)
{
RuntimeDependencies.Add(fmodDllPath);
RuntimeDependencies.Add(fmodStudioDllPath);
foreach (string plugin in plugins)
{
string pluginPath = System.IO.Path.Combine(libPath, plugin + dllExtension);
System.Console.WriteLine("Adding reference to FMOD plugin: " + pluginPath);
RuntimeDependencies.Add(pluginPath);
}
}
if (CopyThirdPartyPath != null)
{
string destPath = System.IO.Path.Combine(Target.UEThirdPartyBinariesDirectory, CopyThirdPartyPath);
System.IO.Directory.CreateDirectory(destPath);
string fmodDllDest = System.IO.Path.Combine(destPath, fmodDllName);
string fmodStudioDllDest = System.IO.Path.Combine(destPath, fmodStudioDllName);
CopyFile(fmodDllPath, fmodDllDest);
CopyFile(fmodStudioDllPath, fmodStudioDllDest);
}
if (bAddDelayLoad)
{
PublicDelayLoadDLLs.AddRange(
new string[] {
fmodDllName,
fmodStudioDllName
}
);
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
string APLName = System.String.Format("FMODStudio{0}_APL.xml", configName);
string RelAPLPath = Utils.MakePathRelativeTo(System.IO.Path.Combine(ModuleDirectory, APLName), Target.RelativeEnginePath);
System.Console.WriteLine("Adding {0}", RelAPLPath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", RelAPLPath);
foreach (string PluginName in System.IO.Directory.GetFiles(libPath))
{
if (PluginName.EndsWith("_APL.xml", System.StringComparison.OrdinalIgnoreCase))
{
string RelPluginPath = Utils.MakePathRelativeTo(PluginName, Target.RelativeEnginePath);
System.Console.WriteLine("Adding {0}", RelPluginPath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", RelPluginPath);
}
}
}
}
public HoudiniEngineEditor(ReadOnlyTargetRules Target) : base(Target)
{
bPrecompile = true;
PCHUsage = PCHUsageMode.NoSharedPCHs;
PrivatePCHHeaderFile = "Private/HoudiniEngineEditorPrivatePCH.h";
// Check if we are compiling on unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac &&
Target.Platform != UnrealTargetPlatform.Linux)
{
string Err = string.Format("Houdini Engine Editor: Compiling for unsupported platform.");
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
// Find HFS
string HFSPath = GetHFSPath();
HFSPath = HFSPath.Replace("\\", "/");
if (HFSPath != "")
{
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))
{
// 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[] {
Path.Combine(ModuleDirectory, "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",
"TargetPlatform",
"UnrealEd",
"ApplicationCore",
"CurveEditor",
"Json",
"SceneOutliner"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"PlacementMode",
}
);
}
public Launch(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Runtime/Launch/Private");
PrivateIncludePathModuleNames.AddRange(new string[] {
"AutomationController",
"TaskGraph",
});
PrivateDependencyModuleNames.AddRange(new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"MoviePlayer",
"Networking",
"PakFile",
"Projects",
"RenderCore",
"RHI",
"SandboxFile",
"Serialization",
"ApplicationCore",
"Slate",
"SlateCore",
"Sockets",
"TraceLog",
"Overlay",
"PreLoadScreen",
"InstallBundleManager"
});
// Set a macro allowing us to switch between debuggame/development configuration
if (Target.Configuration == UnrealTargetConfiguration.DebugGame)
{
PrivateDefinitions.Add("UE_BUILD_DEVELOPMENT_WITH_DEBUGGAME=1");
}
else
{
PrivateDefinitions.Add("UE_BUILD_DEVELOPMENT_WITH_DEBUGGAME=0");
}
// Enable the LauncherCheck module to be used for platforms that support the Launcher.
// Projects should set Target.bUseLauncherChecks in their Target.cs to enable the functionality.
if (Target.bUseLauncherChecks &&
((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Mac)))
{
PrivateDependencyModuleNames.Add("LauncherCheck");
PublicDefinitions.Add("WITH_LAUNCHERCHECK=1");
}
else
{
PublicDefinitions.Add("WITH_LAUNCHERCHECK=0");
}
if (Target.Type != TargetType.Server)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"HeadMountedDisplay",
"MediaUtils",
"MRMesh",
});
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
DynamicallyLoadedModuleNames.AddRange(new string[] {
"WindowsPlatformFeatures",
});
}
if (Target.Platform.IsInGroup(UnrealPlatformGroup.Windows))
{
DynamicallyLoadedModuleNames.AddRange(new string[] {
"AudioMixerXAudio2",
"XAudio2",
});
}
else if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
DynamicallyLoadedModuleNames.Add("D3D11RHI");
DynamicallyLoadedModuleNames.Add("XAudio2");
DynamicallyLoadedModuleNames.Add("AudioMixerXAudio2");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(new string[] {
"AudioMixerCoreAudio",
"CoreAudio",
});
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
DynamicallyLoadedModuleNames.Add("AudioMixerSDL");
PrivateDependencyModuleNames.Add("Json");
}
PrivateIncludePathModuleNames.AddRange(new string[] {
"Media",
"SlateNullRenderer",
"SlateRHIRenderer",
});
DynamicallyLoadedModuleNames.AddRange(new string[] {
"Media",
"SlateNullRenderer",
"SlateRHIRenderer",
});
}
// UFS clients are not available in shipping builds
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"NetworkFile",
"StreamingFile",
"CookedIterativeFile",
"AutomationWorker"
});
}
DynamicallyLoadedModuleNames.AddRange(new string[] {
"Renderer",
});
if (Target.bCompileAgainstEngine)
{
PrivateIncludePathModuleNames.AddRange(new string[] {
"MessagingCommon",
});
PublicDependencyModuleNames.Add("SessionServices");
PrivateIncludePaths.Add("Developer/DerivedDataCache/Public");
// LaunchEngineLoop.cpp will still attempt to load XMPP but not all projects require it so it will silently fail unless referenced by the project's build.cs file.
// DynamicallyLoadedModuleNames.Add("XMPP");
DynamicallyLoadedModuleNames.AddRange(new string[] {
"HTTP",
"MediaAssets",
});
PrivateDependencyModuleNames.AddRange(new string[] {
"ClothingSystemRuntimeNv",
"ClothingSystemRuntimeInterface"
});
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"FunctionalTesting"
});
}
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PublicIncludePathModuleNames.Add("ProfilerService");
DynamicallyLoadedModuleNames.AddRange(new string[] {
"TaskGraph",
"RealtimeProfiler",
"ProfilerService"
});
}
// The engine can use AutomationController in any connfiguration besides shipping. This module is loaded
// dynamically in LaunchEngineLoop.cpp in non-shipping configurations
if (Target.bCompileAgainstEngine && Target.Configuration != UnrealTargetConfiguration.Shipping)
{
DynamicallyLoadedModuleNames.AddRange(new string[] { "AutomationController" });
}
if (Target.bBuildEditor == true)
{
PublicIncludePathModuleNames.Add("ProfilerClient");
PrivateDependencyModuleNames.AddRange(new string[] {
"SourceControl",
"UnrealEd",
"DesktopPlatform",
"PIEPreviewDeviceProfileSelector",
});
// ExtraModules that are loaded when WITH_EDITOR=1 is true
DynamicallyLoadedModuleNames.AddRange(new string[] {
"AutomationWindow",
"ProfilerClient",
"Toolbox",
"GammaUI",
"ModuleUI",
"OutputLog",
"TextureCompressor",
"MeshUtilities",
"SourceCodeAccess"
});
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"MainFrame",
"Settings",
});
}
else
{
DynamicallyLoadedModuleNames.Add("MainFrame");
}
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
PrivateDependencyModuleNames.Add("OpenGLDrv");
if (Target.Platform != UnrealTargetPlatform.Lumin)
{
PrivateDependencyModuleNames.Add("AndroidAudio");
PrivateDependencyModuleNames.Add("AudioMixerAndroid");
}
// these are, for now, only for basic android
if (Target.Platform == UnrealTargetPlatform.Android)
{
DynamicallyLoadedModuleNames.Add("AndroidRuntimeSettings");
DynamicallyLoadedModuleNames.Add("AndroidLocalNotification");
}
else if (Target.Platform == UnrealTargetPlatform.Lumin)
{
DynamicallyLoadedModuleNames.Add("LuminRuntimeSettings");
}
}
if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"AudioMixerAudioUnit",
"IOSAudio",
"LaunchDaemonMessages",
});
DynamicallyLoadedModuleNames.AddRange(new string[] {
"IOSLocalNotification",
"IOSRuntimeSettings",
});
// needed for Metal layer
PublicFrameworks.Add("QuartzCore");
}
if ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.IsInPlatformGroup(UnrealPlatformGroup.Linux) && Target.Type != TargetType.Server))
{
// TODO: re-enable after implementing resource tables for OpenGL.
DynamicallyLoadedModuleNames.Add("OpenGLDrv");
}
// @todo ps4 clang bug: this works around a PS4/clang compiler bug (optimizations)
if (Target.Platform == UnrealTargetPlatform.PS4)
{
bUseUnity = true;
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
// Clang 9.0.1 lld seems to end up having issues with resolving EditorStyle
// when dealing with circular dependencies on SourceControl module
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("EditorStyle");
}
PrivateDependencyModuleNames.Add("UnixCommonStartup");
}
if (Target.LinkType == TargetLinkType.Monolithic && !Target.bFormalBuild)
{
PrivateDefinitions.Add(string.Format("COMPILED_IN_CL={0}", Target.Version.Changelist));
PrivateDefinitions.Add(string.Format("COMPILED_IN_COMPATIBLE_CL={0}", Target.Version.EffectiveCompatibleChangelist));
PrivateDefinitions.Add(string.Format("COMPILED_IN_BRANCH_NAME={0}", (Target.Version.BranchName == null || Target.Version.BranchName.Length == 0)? "UE4" : Target.Version.BranchName));
}
}
public UnrealEnginePython(TargetInfo Target)
#endif
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDefinitions.Add("WITH_UNREALENGINEPYTHON=1"); // fixed
string enableUnityBuild = System.Environment.GetEnvironmentVariable("UEP_ENABLE_UNITY_BUILD");
bUseUnity = string.IsNullOrEmpty(enableUnityBuild);
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "Public"),
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "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",
"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 (UseThirdPartyPython)
{
PythonHome = ThirdPartyPythonHome;
System.Console.WriteLine("Using Embedded 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);
string dllPath = Path.Combine(BinariesPath, "Win64", string.Format("{0}.dll", PythonType.ToLower()));
RuntimeDependencies.Add(dllPath);
AddRuntimeDependenciesForCopying(Target);
}
else 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);
}
}
//other platforms
else
{
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);
PublicAdditionalLibraries.Add(Path.Combine(PythonHome, "Lib", string.Format("{0}.lib", PythonType)));
}
System.Console.WriteLine("Using Python at: " + PythonHome);
PublicIncludePaths.Add(PythonHome);
string libPath = GetMacPythonLibFile(PythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicDelayLoadDLLs.Add(libPath);
}
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"));
PublicAdditionalLibraries.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/armeabi-v7a"));
PublicAdditionalLibraries.Add("python3.5m");
string APLName = "UnrealEnginePython_APL.xml";
string RelAPLPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(RelAPLPath, APLName));
}
#endif
}
public Noesis(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string NoesisBasePath = ModuleDirectory + "/NoesisSDK/";
string NoesisIncludePath = NoesisBasePath + "Include/";
string NoesisInteractivityIncludePath = NoesisBasePath + "Src/Packages/App/Interactivity/Include/";
PublicIncludePaths.Add(ModuleDirectory);
PublicIncludePaths.Add(NoesisIncludePath);
PublicIncludePaths.Add(NoesisInteractivityIncludePath);
// Let's try to make sure the right version of the SDK is in the right place.
const string RequiredRevision = "(r8047)";
const string RequiredVersionName = "2.2.2";
PublicDefinitions.Add("NOESIS_VERSION_NAME=\"" + RequiredVersionName + "\"");
if (!Directory.Exists(NoesisBasePath))
{
throw new BuildException("Could not find NoesisGUI SDK in " + NoesisBasePath + ". Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Bin"))
{
throw new BuildException("Could not find NoesisGUI SDK Bin directory in " + NoesisBasePath + "Bin. Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Include"))
{
throw new BuildException("Could not find NoesisGUI SDK Include directory in " + NoesisBasePath + "Include. Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Lib"))
{
throw new BuildException("Could not find NoesisGUI SDK Lib directory in " + NoesisBasePath + "Lib. Minimum required version is " + RequiredVersionName);
}
string NoesisSdkVersionInfo;
try
{
NoesisSdkVersionInfo = File.ReadAllText(NoesisBasePath + "version.txt");
}
catch (Exception)
{
throw new BuildException("Could not find NoesisGUI SDK version.txt in " + NoesisBasePath + "version.txt. Minimum required version is " + RequiredVersionName);
}
string[] SplitVersion = NoesisSdkVersionInfo.Split(' ');
if (String.Compare(SplitVersion[SplitVersion.Length - 1], RequiredRevision) < 0)
{
throw new BuildException("Wrong version of the NoesisGUI SDK installed in " + NoesisBasePath + ". Minimum required version is " + RequiredVersionName);
}
PublicSystemIncludePaths.Add(NoesisIncludePath);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string NoesisLibPath = NoesisBasePath + "Lib/windows_x86_64/";
PublicLibraryPaths.Add(NoesisLibPath);
PublicAdditionalLibraries.Add("Noesis.lib");
string NoesisDllPath = "/NoesisSDK/Bin/windows_x86_64/Noesis.dll";
string NoesisDllTargetPath = "/Binaries/Win64/Noesis.dll";
if (Target.ProjectFile != null)
{
CopyNoesisDll(ModuleDirectory + NoesisDllPath, DirectoryReference.FromFile(Target.ProjectFile).ToString() + NoesisDllTargetPath);
}
CopyNoesisDll(ModuleDirectory + NoesisDllPath, ModuleDirectory + "/../.." + NoesisDllTargetPath);
if (System.IO.File.Exists(Target.RelativeEnginePath + NoesisDllTargetPath))
{
System.IO.File.Delete(Target.RelativeEnginePath + NoesisDllTargetPath);
}
if (Target.LinkType == TargetLinkType.Monolithic)
{
RuntimeDependencies.Add("$(ProjectDir)" + NoesisDllTargetPath);
}
else
{
RuntimeDependencies.Add("$(EngineDir)" + NoesisDllTargetPath);
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string NoesisLibPath = NoesisBasePath + "Bin/osx/";
PublicLibraryPaths.Add(NoesisLibPath);
PublicAdditionalLibraries.Add(NoesisLibPath + "Noesis.dylib");
string NoesisDylibPath = "/NoesisSDK/Bin/osx/Noesis.dylib";
RuntimeDependencies.Add(ModuleDirectory + NoesisDylibPath);
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
string NoesisLibPath = NoesisBasePath + "Lib/ios/";
PublicLibraryPaths.Add(NoesisLibPath);
PublicAdditionalLibraries.Add("Noesis");
PublicFrameworks.Add("CoreText");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string NoesisLibPath = NoesisBasePath + "Bin/android_arm/";
PublicLibraryPaths.Add(NoesisLibPath);
string NoesisLib64Path = NoesisBasePath + "Bin/android_arm64/";
PublicLibraryPaths.Add(NoesisLib64Path);
PublicAdditionalLibraries.Add("Noesis");
string NoesisAplPath = "/Noesis_APL.xml";
AdditionalPropertiesForReceipt.Add("AndroidPlugin", ModuleDirectory + NoesisAplPath);
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
string NoesisLibPath = NoesisBasePath + "Lib/ps4/";
PublicAdditionalLibraries.Add(NoesisLibPath + "Noesis.a");
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
string NoesisLibPath = NoesisBasePath + "Bin/xbox_one/";
PublicLibraryPaths.Add(NoesisLibPath);
PublicAdditionalLibraries.Add("Noesis.lib");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
string NoesisLibPath = NoesisBasePath + "Bin/wasm/";
PublicAdditionalLibraries.Add(NoesisLibPath + "Noesis.bc");
}
}
public GameLiftServerSDK(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Projects"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
// This is required to fix a warning for Unreal Engine 4.21 and later
PrivatePCHHeaderFile = "Private/GameLiftServerSDKPrivatePCH.h";
bEnableExceptions = true;
string BaseDirectory = System.IO.Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", ".."));
string SDKDirectory = System.IO.Path.Combine(BaseDirectory, "ThirdParty", "GameLiftServerSDK", Target.Platform.ToString());
bool bHasGameLiftSDK = System.IO.Directory.Exists(SDKDirectory);
if (bHasGameLiftSDK)
{
if (Target.Type == TargetRules.TargetType.Server)
{
PublicDefinitions.Add("WITH_GAMELIFT=1");
if (Target.Platform == UnrealTargetPlatform.Linux)
{
SDKDirectory = System.IO.Path.Combine(SDKDirectory, "x86_64-unknown-linux-gnu");
string SDKLib = System.IO.Path.Combine(SDKDirectory, "libaws-cpp-sdk-gamelift-server.so");
PublicSystemLibraryPaths.Add(SDKDirectory);
PublicAdditionalLibraries.Add(SDKLib);
RuntimeDependencies.Add(SDKLib);
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicSystemLibraryPaths.Add(SDKDirectory);
PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-gamelift-server.lib"));
PublicDelayLoadDLLs.Add("aws-cpp-sdk-gamelift-server.dll");
string SDKLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-gamelift-server.dll");
RuntimeDependencies.Add(SDKLibWindows);
}
}
else
{
PublicDefinitions.Add("WITH_GAMELIFT=0");
}
}
else
{
PublicDefinitions.Add("WITH_GAMELIFT=0");
}
}
public Vorbis(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string VorbisPath = Target.UEThirdPartySourceDirectory + "Vorbis/libvorbis-1.3.2/";
PublicIncludePaths.Add(VorbisPath + "include");
PublicDefinitions.Add("WITH_OGGVORBIS=1");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string VorbisLibPath = VorbisPath + "Lib/win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName() + "/";
PublicLibraryPaths.Add(VorbisLibPath);
PublicAdditionalLibraries.Add("libvorbis_64.lib");
PublicDelayLoadDLLs.Add("libvorbis_64.dll");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Vorbis/Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName() + "/libvorbis_64.dll");
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
string VorbisLibPath = VorbisPath + "Lib/win32/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName() + "/";
PublicLibraryPaths.Add(VorbisLibPath);
PublicAdditionalLibraries.Add("libvorbis.lib");
PublicDelayLoadDLLs.Add("libvorbis.dll");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Vorbis/Win32/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName() + "/libvorbis.dll");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.AddRange(
new string[] {
VorbisPath + "macosx/libvorbis.dylib",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
string VorbisLibPath = VorbisPath + "lib/HTML5/";
PublicLibraryPaths.Add(VorbisLibPath);
string OpimizationSuffix = "";
if (Target.bCompileForSize)
{
OpimizationSuffix = "_Oz";
}
else
{
if (Target.Configuration == UnrealTargetConfiguration.Development)
{
OpimizationSuffix = "_O2";
}
else if (Target.Configuration == UnrealTargetConfiguration.Shipping)
{
OpimizationSuffix = "_O3";
}
}
PublicAdditionalLibraries.Add(VorbisLibPath + "libvorbis" + OpimizationSuffix + ".bc");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
// toolchain will filter
PublicLibraryPaths.Add(VorbisPath + "lib/Android/ARMv7");
PublicLibraryPaths.Add(VorbisPath + "lib/Android/ARM64");
PublicLibraryPaths.Add(VorbisPath + "lib/Android/x86");
PublicLibraryPaths.Add(VorbisPath + "lib/Android/x64");
PublicAdditionalLibraries.Add("vorbis");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PublicAdditionalLibraries.Add(VorbisPath + "lib/Linux/" + Target.Architecture + "/libvorbis.a");
}
else 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);
PublicLibraryPaths.Add(VorbisPath + "lib/XboxOne/VS" + VersionName.ToString());
PublicAdditionalLibraries.Add("libvorbis_static.lib");
}
}
}
public HoudiniEngineRuntime(ReadOnlyTargetRules Target) : base(Target)
{
bPrecompile = true;
PCHUsage = PCHUsageMode.UseSharedPCHs;
PrivatePCHHeaderFile = "Private/HoudiniEngineRuntimePrivatePCH.h";
// Check if we are compiling for unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac &&
Target.Platform != UnrealTargetPlatform.Linux &&
Target.Platform != UnrealTargetPlatform.Switch)
{
System.Console.WriteLine(string.Format("Houdini Engine: Compiling for untested target platform. Please let us know how it goes!"));
}
// Find HFS
string HFSPath = GetHFSPath();
HFSPath = HFSPath.Replace("\\", "/");
if (HFSPath != "")
{
string Log = string.Format("Houdini Engine: Found Houdini in {0}", HFSPath);
System.Console.WriteLine(Log);
PlatformID buildPlatformId = Environment.OSVersion.Platform;
if (buildPlatformId == PlatformID.Win32NT)
{
PublicDefinitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath);
}
}
// Find the HAPI include directory
string HAPIIncludePath = HFSPath + "/toolkit/include/HAPI";
if (!Directory.Exists(HAPIIncludePath))
{
// Add the custom include path as well in case the toolkit path doesn't exist yet.
HAPIIncludePath = HFSPath + "/custom/houdini/include/HAPI";
if (!Directory.Exists(HAPIIncludePath))
{
System.Console.WriteLine(string.Format("Couldn't find the HAPI include folder!"));
HAPIIncludePath = "";
}
}
if (HAPIIncludePath != "")
{
PublicIncludePaths.Add(HAPIIncludePath);
}
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "Public/HAPI"),
Path.Combine(ModuleDirectory, "Public")
}
);
PrivateIncludePaths.AddRange(
new string[] {
"HoudiniEngineRuntime/Private"
}
);
// Add common dependencies.
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"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",
"Landscape",
"LandscapeEditor"
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public VRExpansionPlugin(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
//bEnforceIWYU = true;
PublicDefinitions.Add("WITH_VR_EXPANSION=1");
// To detect VR Preview, not built out in packaged builds
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"UnrealEd"
}
);
}
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Settings"
}
);
PublicIncludePaths.AddRange(
new string[] {
//"VRExpansionPlugin/Public",
//"VRExpansionPlugin/Public/SimpleChar",
//"HeadMountedDisplay/Public",
//"Runtime/Engine/Private/PhysicsEngine"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
//"VRExpansionPlugin/Private",
//"VRExpansionPlugin/Private/SimpleChar",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
// "InputCore",
"PhysicsCore",
//"FLEX", remove comment if building in the NVIDIA flex branch - NOTE when put in place FLEX only listed win32 and win64 at compatible platforms
"HeadMountedDisplay",
// "RHI",
//"RenderCore",
//"ShaderCore",
//"NetworkReplayStreaming",
//"AIModule",
"UMG",
"NavigationSystem",
"AIModule",
//"Renderer",
//"UtilityShaders"
});
if (Target.bCompilePhysX)
{
PublicDependencyModuleNames.Add("PhysX");
}
if (Target.bUseChaos)
{
PublicDependencyModuleNames.Add("Chaos");
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
// "Core",
// "CoreUObject",
//"Engine",
"InputCore",
// "PhysX",
//"FLEX", remove comment if building in the NVIDIA flex branch - NOTE when put in place FLEX only listed win32 and win64 at compatible platforms
//"HeadMountedDisplay",
"RHI",
"RenderCore",
// "ShaderCore",
"NetworkReplayStreaming",
"AIModule",
"UMG",
"GameplayTags"
//"Renderer",
// "UtilityShaders"
});
if (Target.bCompilePhysX)
{
PublicDependencyModuleNames.Add("PhysXVehicles");
}
if (Target.bUseChaos)
{
//PublicDependencyModuleNames.Add("ChaosVehiclesPlugin");
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
//"CoreUObject",
//"Engine",
"Slate",
"SlateCore"
// ... add private dependencies that you statically link with here ...
}
);
// Don't load APEX on incompatible platforms
/* if (
* Target.Platform != UnrealTargetPlatform.IOS &&
* Target.Platform != UnrealTargetPlatform.TVOS &&
* Target.Platform != UnrealTargetPlatform.Android &&
* Target.Platform != UnrealTargetPlatform.HTML5)
* {
* PublicDependencyModuleNames.AddRange(
* new string[]
* {
* "APEX"
* });
* }*/
// Allow gameplay debugger on editor builds
if (Target.bBuildDeveloperTools || (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test))
{
PrivateDependencyModuleNames.Add("GameplayDebugger");
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=1"); // Already in AI Module, but gameplay abilities and other modules also duplicate the definition
}
else
{
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=0");
}
}
public VRExpansionPlugin(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
//bEnforceIWYU = true;
PublicDefinitions.Add("WITH_VR_EXPANSION=1");
// To detect VR Preview, not built out in packaged builds
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"UnrealEd"
}
);
}
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Settings"
}
);
PublicIncludePaths.AddRange(
new string[] {
//"VRExpansionPlugin/Public",
//"VRExpansionPlugin/Public/SimpleChar",
//"HeadMountedDisplay/Public",
"Runtime/Engine/Private/PhysicsEngine"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
//"VRExpansionPlugin/Private",
//"VRExpansionPlugin/Private/SimpleChar",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
// "InputCore",
"PhysX",
//"FLEX", remove comment if building in the NVIDIA flex branch - NOTE when put in place FLEX only listed win32 and win64 at compatible platforms
"HeadMountedDisplay",
// "RHI",
//"RenderCore",
//"ShaderCore",
//"NetworkReplayStreaming",
//"AIModule",
"UMG",
"NavigationSystem",
"AIModule",
//"Renderer",
//"UtilityShaders"
});
PrivateDependencyModuleNames.AddRange(
new string[]
{
// "Core",
// "CoreUObject",
//"Engine",
"InputCore",
// "PhysX",
//"FLEX", remove comment if building in the NVIDIA flex branch - NOTE when put in place FLEX only listed win32 and win64 at compatible platforms
//"HeadMountedDisplay",
"RHI",
"RenderCore",
"ShaderCore",
"NetworkReplayStreaming",
"AIModule",
"UMG",
"GameplayTags",
"PhysXVehicles"
//"Renderer",
// "UtilityShaders"
});
PrivateDependencyModuleNames.AddRange(
new string[]
{
//"CoreUObject",
//"Engine",
"Slate",
"SlateCore"
// ... add private dependencies that you statically link with here ...
}
);
// Don't load APEX on incompatible platforms
if (
Target.Platform != UnrealTargetPlatform.IOS &&
Target.Platform != UnrealTargetPlatform.TVOS &&
Target.Platform != UnrealTargetPlatform.Android &&
Target.Platform != UnrealTargetPlatform.HTML5)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"APEX"
});
}
}
public NvFlow(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"NvFlow/Private",
"../../../../Source/Runtime/Engine/Private",
"../../../../Source/Runtime/Renderer/Private",
"../Include/include",
// ... add other private include paths required here ...
}
);
PublicIncludePaths.AddRange(
new string[] {
"NvFlow/Public",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RHI",
"RenderCore",
"Renderer",
"ShaderCore",
"XmlParser",
// "UnrealEd",
// "AssetTools",
// "ContentBrowser",
// "EditorStyle"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"RenderCore",
"Renderer"
}
);
// PrivateIncludePathModuleNames.AddRange(
// new string[] {
// "AssetTools",
// "AssetRegistry"
// });
//
// DynamicallyLoadedModuleNames.AddRange(
// new string[] {
// "AssetTools",
// "AssetRegistry"
// });
PublicDefinitions.Add("WITH_NVFLOW=1");
string libbase = Target.UEThirdPartySourceDirectory + "../../Plugins/GameWorks/NvFlow/Include";
if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicLibraryPaths.Add(libbase + "/win32/");
PublicAdditionalLibraries.Add("NvFlowLibRelease_win32.lib");
PublicDelayLoadDLLs.Add("NvFlowLibRelease_win32.dll");
RuntimeDependencies.Add("$(EngineDir)/Plugins/GameWorks/NvFlow/Libraries/win32/NvFlowLibRelease_win32.dll");
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicLibraryPaths.Add(libbase + "/win64/");
PublicAdditionalLibraries.Add("NvFlowLibRelease_win64.lib");
PublicDelayLoadDLLs.Add("NvFlowLibRelease_win64.dll");
RuntimeDependencies.Add("$(EngineDir)/Plugins/GameWorks/NvFlow/Libraries/win64/NvFlowLibRelease_win64.dll");
}
// Add direct rendering dependencies on a per-platform basis
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.AddRange(new string[] { "DX11", "DX12" });
PrivateIncludePaths.AddRange(
new string[] {
// ... add other private include paths required here ...
}
);
}
SetupModulePhysXAPEXSupport(Target);
}
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[] { });
#if UE_4_24_OR_LATER
DefaultBuildSettings = BuildSettingsVersion.V2;
#endif
LoadModio(Target);
// @todo: Can we disable exceptions again?
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 ...
}
);
}
public APEX(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
// Determine which kind of libraries to link against
APEXLibraryMode LibraryMode = GetAPEXLibraryMode(Target.Configuration);
string LibrarySuffix = GetAPEXLibrarySuffix(LibraryMode);
string ApexVersion = "APEX_1.4";
string APEXDir = Target.UEThirdPartySourceDirectory + "PhysX3/" + ApexVersion + "/";
string APEXLibDir = Target.UEThirdPartySourceDirectory + "PhysX3/Lib";
PublicSystemIncludePaths.AddRange(
new string[] {
APEXDir + "include",
APEXDir + "include/clothing",
APEXDir + "include/nvparameterized",
APEXDir + "include/legacy",
APEXDir + "include/PhysX3",
APEXDir + "common/include",
APEXDir + "common/include/autogen",
APEXDir + "framework/include",
APEXDir + "framework/include/autogen",
APEXDir + "shared/general/RenderDebug/public",
APEXDir + "shared/general/PairFilter/include",
APEXDir + "shared/internal/include",
}
);
// List of default library names (unused unless LibraryFormatString is non-null)
List <string> ApexLibraries = new List <string>();
ApexLibraries.AddRange(
new string[]
{
"ApexCommon{0}",
"ApexFramework{0}",
"ApexShared{0}",
"APEX_Clothing{0}",
});
string LibraryFormatString = null;
bool bIsApexStaticallyLinked = false;
bool bHasApexLegacy = true;
// Libraries and DLLs for windows platform
if (Target.Platform == UnrealTargetPlatform.Win64)
{
APEXLibDir += "/Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
PublicLibraryPaths.Add(APEXLibDir);
PublicAdditionalLibraries.Add(String.Format("APEXFramework{0}_x64.lib", LibrarySuffix));
PublicDelayLoadDLLs.Add(String.Format("APEXFramework{0}_x64.dll", LibrarySuffix));
string[] RuntimeDependenciesX64 =
{
"APEX_Clothing{0}_x64.dll",
"APEX_Legacy{0}_x64.dll",
"ApexFramework{0}_x64.dll",
};
string ApexBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX3/Win64/VS{0}/", Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
foreach (string RuntimeDependency in RuntimeDependenciesX64)
{
string FileName = ApexBinariesDir + String.Format(RuntimeDependency, LibrarySuffix);
RuntimeDependencies.Add(FileName, StagedFileType.NonUFS);
RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS);
}
if (LibrarySuffix != "")
{
PublicDefinitions.Add("UE_APEX_SUFFIX=" + LibrarySuffix);
}
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
APEXLibDir += "/Win32/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
PublicLibraryPaths.Add(APEXLibDir);
PublicAdditionalLibraries.Add(String.Format("APEXFramework{0}_x86.lib", LibrarySuffix));
PublicDelayLoadDLLs.Add(String.Format("APEXFramework{0}_x86.dll", LibrarySuffix));
string[] RuntimeDependenciesX86 =
{
"APEX_Clothing{0}_x86.dll",
"APEX_Legacy{0}_x86.dll",
"ApexFramework{0}_x86.dll",
};
string ApexBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX3/Win32/VS{0}/", Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
foreach (string RuntimeDependency in RuntimeDependenciesX86)
{
string FileName = ApexBinariesDir + String.Format(RuntimeDependency, LibrarySuffix);
RuntimeDependencies.Add(FileName, StagedFileType.NonUFS);
RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS);
}
if (LibrarySuffix != "")
{
PublicDefinitions.Add("UE_APEX_SUFFIX=" + LibrarySuffix);
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
APEXLibDir += "/Mac";
ApexLibraries.Clear();
ApexLibraries.AddRange(
new string[]
{
"ApexCommon{0}",
"ApexShared{0}",
});
LibraryFormatString = APEXLibDir + "/lib{0}" + ".a";
string[] DynamicLibrariesMac = new string[] {
"/libAPEX_Clothing{0}.dylib",
"/libAPEX_Legacy{0}.dylib",
"/libApexFramework{0}.dylib"
};
string PhysXBinariesDir = Target.UEThirdPartyBinariesDirectory + "PhysX3/Mac";
foreach (string Lib in DynamicLibrariesMac)
{
string LibraryPath = PhysXBinariesDir + String.Format(Lib, LibrarySuffix);
PublicDelayLoadDLLs.Add(LibraryPath);
RuntimeDependencies.Add(LibraryPath);
}
if (LibrarySuffix != "")
{
PublicDefinitions.Add("UE_APEX_SUFFIX=" + LibrarySuffix);
}
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
if (Target.Architecture.StartsWith("x86_64"))
{
ApexLibraries.Clear();
string PhysXBinariesDir = Target.UEThirdPartyBinariesDirectory + "PhysX3/Linux/" + Target.Architecture;
string[] DynamicLibrariesLinux =
{
"/libApexCommon{0}.so",
"/libApexFramework{0}.so",
"/libApexShared{0}.so",
"/libAPEX_Legacy{0}.so",
"/libAPEX_Clothing{0}.so",
"/libNvParameterized{0}.so",
"/libRenderDebug{0}.so"
};
foreach (string RuntimeDependency in DynamicLibrariesLinux)
{
string LibraryPath = PhysXBinariesDir + String.Format(RuntimeDependency, LibrarySuffix);
PublicAdditionalLibraries.Add(LibraryPath);
RuntimeDependencies.Add(LibraryPath);
}
}
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
bIsApexStaticallyLinked = true;
bHasApexLegacy = false;
APEXLibDir += "/PS4";
PublicLibraryPaths.Add(APEXLibDir);
ApexLibraries.Add("NvParameterized{0}");
ApexLibraries.Add("RenderDebug{0}");
LibraryFormatString = "{0}";
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
bIsApexStaticallyLinked = true;
bHasApexLegacy = false;
PublicDefinitions.Add("_XBOX_ONE=1");
// This MUST be defined for XboxOne!
PublicDefinitions.Add("PX_HAS_SECURE_STRCPY=1");
APEXLibDir += "/XboxOne/VS2015";
PublicLibraryPaths.Add(APEXLibDir);
ApexLibraries.Add("NvParameterized{0}");
ApexLibraries.Add("RenderDebug{0}");
LibraryFormatString = "{0}.lib";
}
else if (Target.Platform == UnrealTargetPlatform.Switch)
{
bIsApexStaticallyLinked = true;
bHasApexLegacy = false;
APEXLibDir += "/Switch";
PublicLibraryPaths.Add(APEXLibDir);
ApexLibraries.Add("NvParameterized{0}");
ApexLibraries.Add("RenderDebug{0}");
LibraryFormatString = "{0}";
}
PublicDefinitions.Add("APEX_UE4=1");
PublicDefinitions.Add(string.Format("APEX_STATICALLY_LINKED={0}", bIsApexStaticallyLinked ? 1 : 0));
PublicDefinitions.Add(string.Format("WITH_APEX_LEGACY={0}", bHasApexLegacy ? 1 : 0));
// Add the libraries needed (used for all platforms except Windows)
if (LibraryFormatString != null)
{
foreach (string Lib in ApexLibraries)
{
string ConfiguredLib = String.Format(Lib, LibrarySuffix);
string FinalLib = String.Format(LibraryFormatString, ConfiguredLib);
PublicAdditionalLibraries.Add(FinalLib);
}
}
}
public bool LoadModio(ReadOnlyTargetRules Target)
{
bool isLibrarySupported = false;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicDefinitions.Add("MODIO_UE4_WINDOWS_BUILD");
isLibrarySupported = true;
string LibrariesPath = Path.Combine(ThirdPartyPath, modio_directory, "lib", "msvc", "x64");
string DLLPath = Path.Combine(ThirdPartyPath, modio_directory, "bin", "msvc", "x64");
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "modio.lib"));
RuntimeDependencies.Add(Path.Combine(DLLPath, "modio.dll"));
string ProjectBinariesDirectory = Path.Combine(ProjectPath, "Binaries", "Win64");
if (!Directory.Exists(ProjectBinariesDirectory))
{
System.IO.Directory.CreateDirectory(ProjectBinariesDirectory);
}
string ModioDLLDestination = System.IO.Path.Combine(ProjectBinariesDirectory, "modio.dll");
CopyFile(Path.Combine(DLLPath, "modio.dll"), ModioDLLDestination);
PublicDelayLoadDLLs.AddRange(new string[] { "modio.dll" });
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
PublicDefinitions.Add("MODIO_UE4_LINUX_BUILD");
isLibrarySupported = true;
string LibrariesPath = Path.Combine(ThirdPartyPath, modio_directory, "lib", "linux", "x64");
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libmodio.so"));
RuntimeDependencies.Add(Path.Combine(LibrariesPath, "libmodio.so"));
string ProjectBinariesDirectory = Path.Combine(ProjectPath, "Binaries", "Linux");
if (!Directory.Exists(ProjectBinariesDirectory))
{
System.IO.Directory.CreateDirectory(ProjectBinariesDirectory);
}
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicDefinitions.Add("MODIO_UE4_MAC_BUILD");
isLibrarySupported = true;
string LibrariesPath = Path.Combine(ThirdPartyPath, modio_directory, "lib", "macOS", "x64");
string OrigPath = Path.Combine(LibrariesPath, "libmodio.dylib");
string DylibPath = "Binaries/Mac/libmodio.dylib";
PublicAdditionalLibraries.Add(Path.Combine(ProjectPath, DylibPath));
RuntimeDependencies.Add("$(BinaryOutputDir)/libmodio.dylib", OrigPath);
string ProjectBinariesDirectory = Path.Combine(ProjectPath, "Binaries", "Mac");
if (!Directory.Exists(ProjectBinariesDirectory))
{
System.IO.Directory.CreateDirectory(ProjectBinariesDirectory);
}
CopyFile(OrigPath, Path.Combine(ProjectPath, "Binaries/Mac/libmodio.dylib"));
}
if (isLibrarySupported)
{
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, modio_directory, "include"));
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, modio_directory, "additional_dependencies"));
}
return(isLibrarySupported);
}
public CGAL(ReadOnlyTargetRules Target) : base(Target)
{
bEnableUndefinedIdentifierWarnings = false;
PublicDefinitions.Add("WIN32");
PublicDefinitions.Add("_WINDOWS");
PublicDefinitions.Add("_CRT_SECURE_NO_DEPRECATE");
PublicDefinitions.Add("_SCL_SECURE_NO_DEPRECATE");
PublicDefinitions.Add("_CRT_SECURE_NO_WARNINGS");
PublicDefinitions.Add("_SCL_SECURE_NO_WARNINGS");
PublicDefinitions.Add("CGAL_USE_MPFR");
PublicDefinitions.Add("CGAL_USE_GMP");
// Startard Module Dependencies
PublicDependencyModuleNames.AddRange(new string[] { "Core" });
PrivateDependencyModuleNames.AddRange(new string[] { "CoreUObject", "Engine", "Slate", "SlateCore" });
// Start CGAL linking here!
bool isLibrarySupported = false;
// Create CGAL Path
string CGALPath = Path.Combine(ThirdPartyPath, "CGAL");
// Get Library Path
string LibPath = "";
bool isdebug = Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
LibPath = Path.Combine(CGALPath, "libraries", "Win64");
isLibrarySupported = true;
}
else
{
string Err = string.Format("{0} dedicated server is made to depend on {1}. We want to avoid this, please correct module dependencies.", Target.Platform.ToString(), this.ToString()); System.Console.WriteLine(Err);
}
if (isLibrarySupported)
{
//Add Include path
PublicIncludePaths.AddRange(new string[] { Path.Combine(CGALPath, "includes") });
PublicIncludePaths.AddRange(new string[] { Path.Combine(CGALPath, "includes", "GMP") });//Dependencie
// Add Library Path
PublicLibraryPaths.Add(LibPath);
// Add Dependencies
if (!isdebug)
{
//Add Static Libraries
PublicAdditionalLibraries.Add(Path.Combine("libgmp-10.lib"));
PublicAdditionalLibraries.Add(Path.Combine("libmpfr-4.lib"));
PublicAdditionalLibraries.Add(Path.Combine("libCGAL-vc140-mt-4.9.lib"));
PublicAdditionalLibraries.Add(Path.Combine("libCGAL_Core-vc140-mt-4.9.lib"));
}
else
{
//Add Static Libraries (Debug Version)
PublicAdditionalLibraries.Add(Path.Combine("libgmp-10.lib"));
PublicAdditionalLibraries.Add(Path.Combine("libmpfr-4.lib"));
PublicAdditionalLibraries.Add(Path.Combine("libCGAL-vc140-mt-gd-4.9.lib"));
PublicAdditionalLibraries.Add(Path.Combine("libCGAL_Core-vc140-mt-gd-4.9.lib"));
}
}
PublicDefinitions.Add(string.Format("WITH_CGAL_BINDING={0}", isLibrarySupported ? 1 : 0));
}
public SlateCore(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"InputCore",
"ApplicationCore",
"Json",
});
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/SlateCore/Private",
"Runtime/SlateCore/Private/Animation",
"Runtime/SlateCore/Private/Application",
"Runtime/SlateCore/Private/Brushes",
"Runtime/SlateCore/Private/Fonts",
"Runtime/SlateCore/Private/Input",
"Runtime/SlateCore/Private/Layout",
"Runtime/SlateCore/Private/Logging",
"Runtime/SlateCore/Private/Rendering",
"Runtime/SlateCore/Private/Sound",
"Runtime/SlateCore/Private/Styling",
"Runtime/SlateCore/Private/Textures",
"Runtime/SlateCore/Private/Types",
"Runtime/SlateCore/Private/Widgets",
});
PublicDefinitions.Add("SLATE_PARENT_POINTERS=1");
if (Target.Type != TargetType.Server)
{
if (Target.bCompileFreeType)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "FreeType2");
PublicDefinitions.Add("WITH_FREETYPE=1");
}
else
{
PublicDefinitions.Add("WITH_FREETYPE=0");
}
if (Target.bCompileICU)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "ICU");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "HarfBuzz");
}
else
{
PublicDefinitions.Add("WITH_FREETYPE=0");
PublicDefinitions.Add("WITH_HARFBUZZ=0");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "XInput");
}
}
public Core(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/CorePrivatePCH.h";
SharedPCHHeaderFile = "Public/CoreSharedPCH.h";
PublicDependencyModuleNames.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)
{
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",
"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");
}
WhitelistRestrictedFolders.Add("Private/NoRedist");
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 libgltf_ue4(TargetInfo Target)
{
Type = ModuleType.External;
string glTFPath = System.IO.Path.Combine(ModuleDirectory, "libgltf-0.1.6");
string IncludePath = System.IO.Path.Combine(glTFPath, "include");
List <string> LibPaths = new List <string>();
string LibFilePath = "";
if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
{
string PlatformName = "";
switch (Target.Platform)
{
case UnrealTargetPlatform.Win32:
PlatformName = "win32";
break;
case UnrealTargetPlatform.Win64:
PlatformName = "win64";
break;
}
string TargetConfiguration = "Release";
string TargetPostfix = "";
if (Target.Configuration == UnrealTargetConfiguration.Debug)
{
TargetConfiguration = "Debug";
TargetPostfix = "d";
}
LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", PlatformName, "vs2019", TargetConfiguration));
LibFilePath = "libgltf" + TargetPostfix + ".lib";
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "linux"));
LibFilePath = "libgltf.a";
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "macos"));
LibFilePath = "libgltf.a";
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "android", "armeabi-v7a"));
LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "android", "armeabi-v7a-with-neon"));
LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "android", "arm64-v8a"));
LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "android", "x86"));
LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "android", "x86_64"));
LibFilePath = "libgltf.a";
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "ios", "os"));
LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "ios", "simulator"));
LibPaths.Add(System.IO.Path.Combine(glTFPath, "lib", "ios", "watchos"));
LibFilePath = "libgltf.a";
}
PublicIncludePaths.Add(IncludePath);
PublicLibraryPaths.AddRange(LibPaths);
PublicAdditionalLibraries.Add(LibFilePath);
PublicDefinitions.Add("LIBGLTF_CHARACTOR_ENCODING_IS_UTF8");
}
public ICU(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
bool bNeedsDlls = false;
string ICUVersion = "icu4c-53_1";
string ICURootPath = Target.UEThirdPartySourceDirectory + "ICU/" + ICUVersion + "/";
// Includes
PublicSystemIncludePaths.Add(ICURootPath + "include" + "/");
string PlatformFolderName = Target.Platform.ToString();
string TargetSpecificPath = ICURootPath + PlatformFolderName + "/";
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
TargetSpecificPath = ICURootPath + "Linux/";
}
// make all Androids use the Android directory
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
TargetSpecificPath = ICURootPath + "Android/";
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.HoloLens))
{
string VSVersionFolderName = "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
TargetSpecificPath += VSVersionFolderName + "/";
if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
TargetSpecificPath += Target.WindowsPlatform.GetArchitectureSubpath() + "/";
}
string[] LibraryNameStems =
{
"dt", // Data
"uc", // Unicode Common
"in", // Internationalization
"le", // Layout Engine
"lx", // Layout Extensions
"io" // Input/Output
};
string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ?
"d" : string.Empty;
// Library Paths
PublicLibraryPaths.Add(TargetSpecificPath + "lib" + "/");
EICULinkType ICULinkType = (Target.LinkType == TargetLinkType.Monolithic)? EICULinkType.Static : EICULinkType.Dynamic;
switch (ICULinkType)
{
case EICULinkType.Static:
foreach (string Stem in LibraryNameStems)
{
string LibraryName = "sicu" + Stem + LibraryNamePostfix + "." + "lib";
PublicAdditionalLibraries.Add(LibraryName);
}
break;
case EICULinkType.Dynamic:
foreach (string Stem in LibraryNameStems)
{
string LibraryName = "icu" + Stem + LibraryNamePostfix + "." + "lib";
PublicAdditionalLibraries.Add(LibraryName);
}
foreach (string Stem in LibraryNameStems)
{
string LibraryName = "icu" + Stem + LibraryNamePostfix + "53" + "." + "dll";
PublicDelayLoadDLLs.Add(LibraryName);
}
if (Target.Platform == UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealTargetPlatform.Win32)
{
string BinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/ICU/{0}/{1}/VS{2}/", ICUVersion, Target.Platform.ToString(), Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
foreach (string Stem in LibraryNameStems)
{
string LibraryName = BinariesDir + String.Format("icu{0}{1}53.dll", Stem, LibraryNamePostfix);
RuntimeDependencies.Add(LibraryName);
}
}
else if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
string BinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/ICU/{0}/{1}/VS{2}/", ICUVersion, PlatformFolderName, Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
BinariesDir += Target.WindowsPlatform.GetArchitectureSubpath() + "/";
}
foreach (string Stem in LibraryNameStems)
{
string LibraryName = BinariesDir + String.Format("icu{0}{1}53.dll", Stem, LibraryNamePostfix);
RuntimeDependencies.Add(LibraryName);
}
}
bNeedsDlls = true;
break;
}
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix) ||
Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
string StaticLibraryExtension = "a";
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
TargetSpecificPath += Target.Architecture + "/";
}
else
{
PublicLibraryPaths.Add(TargetSpecificPath + "ARMv7/lib");
PublicLibraryPaths.Add(TargetSpecificPath + "ARM64/lib");
PublicLibraryPaths.Add(TargetSpecificPath + "x86/lib");
PublicLibraryPaths.Add(TargetSpecificPath + "x64/lib");
}
string[] LibraryNameStems =
{
"data", // Data
"uc", // Unicode Common
"i18n", // Internationalization
"le", // Layout Engine
"lx", // Layout Extensions
"io" // Input/Output
};
string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ?
"d" : string.Empty;
// Library Paths
// Temporarily? only link statically on Linux too
//EICULinkType ICULinkType = (Target.Platform == UnrealTargetPlatform.Android || Target.IsMonolithic) ? EICULinkType.Static : EICULinkType.Dynamic;
EICULinkType ICULinkType = EICULinkType.Static;
switch (ICULinkType)
{
case EICULinkType.Static:
foreach (string Stem in LibraryNameStems)
{
string LibraryName = "icu" + Stem + LibraryNamePostfix;
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
// Linux needs the path, not just the filename, to avoid linking to system lib instead of a bundled one.
PublicAdditionalLibraries.Add(TargetSpecificPath + "lib/" + "lib" + LibraryName + "." + StaticLibraryExtension);
}
else
{
// other platforms will just use the library name
PublicAdditionalLibraries.Add(LibraryName);
}
}
break;
case EICULinkType.Dynamic:
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
string PathToBinary = String.Format("$(EngineDir)/Binaries/ThirdParty/ICU/{0}/{1}/{2}/", ICUVersion, Target.Platform.ToString(),
Target.Architecture);
foreach (string Stem in LibraryNameStems)
{
string LibraryName = "icu" + Stem + LibraryNamePostfix;
string LibraryPath = Target.UEThirdPartyBinariesDirectory + "ICU/icu4c-53_1/Linux/" + Target.Architecture + "/";
PublicLibraryPaths.Add(LibraryPath);
PublicAdditionalLibraries.Add(LibraryName);
// add runtime dependencies (for staging)
RuntimeDependencies.Add(PathToBinary + "lib" + LibraryName + ".so");
RuntimeDependencies.Add(PathToBinary + "lib" + LibraryName + ".so.53"); // version-dependent
}
}
break;
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
string StaticLibraryExtension = "a";
string DynamicLibraryExtension = "dylib";
string[] LibraryNameStems =
{
"data", // Data
"uc", // Unicode Common
"i18n", // Internationalization
"le", // Layout Engine
"lx", // Layout Extensions
"io" // Input/Output
};
string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ?
"d" : string.Empty;
EICULinkType ICULinkType = (Target.Platform == UnrealTargetPlatform.IOS || (Target.LinkType == TargetLinkType.Monolithic)) ? EICULinkType.Static : EICULinkType.Dynamic;
// Library Paths
switch (ICULinkType)
{
case EICULinkType.Static:
foreach (string Stem in LibraryNameStems)
{
string LibraryName = "libicu" + Stem + LibraryNamePostfix + "." + StaticLibraryExtension;
PublicAdditionalLibraries.Add(TargetSpecificPath + "lib/" + LibraryName);
}
break;
case EICULinkType.Dynamic:
foreach (string Stem in LibraryNameStems)
{
if (Target.Platform == UnrealTargetPlatform.Mac)
{
string LibraryName = "libicu" + Stem + ".53.1" + LibraryNamePostfix + "." + DynamicLibraryExtension;
string LibraryPath = Target.UEThirdPartyBinariesDirectory + "ICU/icu4c-53_1/Mac/" + LibraryName;
PublicDelayLoadDLLs.Add(LibraryPath);
RuntimeDependencies.Add(LibraryPath);
}
}
bNeedsDlls = true;
break;
}
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
// we don't bother with debug libraries on HTML5. Mainly because debugging isn't viable on html5 currently
string StaticLibraryExtension = "bc";
string[] LibraryNameStems =
{
"data", // Data
"uc", // Unicode Common
"i18n", // Internationalization
"le", // Layout Engine
"lx", // Layout Extensions
"io" // Input/Output
};
string OpimizationSuffix = "";
if (Target.bCompileForSize)
{
OpimizationSuffix = "_Oz";
}
else
{
if (Target.Configuration == UnrealTargetConfiguration.Development)
{
OpimizationSuffix = "_O2";
}
else if (Target.Configuration == UnrealTargetConfiguration.Shipping)
{
OpimizationSuffix = "_O3";
}
}
foreach (string Stem in LibraryNameStems)
{
string LibraryName = "libicu" + Stem + OpimizationSuffix + "." + StaticLibraryExtension;
PublicAdditionalLibraries.Add(TargetSpecificPath + LibraryName);
}
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
string LibraryNamePrefix = "sicu";
string[] LibraryNameStems =
{
"dt", // Data
"uc", // Unicode Common
"in", // Internationalization
"le", // Layout Engine
"lx", // Layout Extensions
"io" // Input/Output
};
string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug) ?
"d" : string.Empty;
string LibraryExtension = "lib";
foreach (string Stem in LibraryNameStems)
{
string LibraryName = ICURootPath + "PS4/lib/" + LibraryNamePrefix + Stem + LibraryNamePostfix + "." + LibraryExtension;
PublicAdditionalLibraries.Add(LibraryName);
}
}
else if (Target.Platform == UnrealTargetPlatform.Switch)
{
string LibraryNamePrefix = "sicu";
string[] LibraryNameStems =
{
"dt", // Data
"uc", // Unicode Common
"in", // Internationalization
"le", // Layout Engine
"lx", // Layout Extensions
"io" // Input/Output
};
string LibraryNamePostfix = ""; //(Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ? "d" : string.Empty;
string LibraryExtension = "a";
foreach (string Stem in LibraryNameStems)
{
string LibraryName = ICURootPath + "Switch/lib/" + LibraryNamePrefix + Stem + LibraryNamePostfix + "." + LibraryExtension;
PublicAdditionalLibraries.Add(LibraryName);
}
}
else 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)
{
string LibraryNamePrefix = "sicu";
string[] LibraryNameStems =
{
"dt", // Data
"uc", // Unicode Common
"in", // Internationalization
"le", // Layout Engine
"lx", // Layout Extensions
"io" // Input/Output
};
string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ?
"d" : string.Empty;
string LibraryExtension = "lib";
foreach (string Stem in LibraryNameStems)
{
System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
string LibraryName = ICURootPath + "XboxOne/VS" + VersionName.ToString() + "/lib/" + LibraryNamePrefix + Stem + LibraryNamePostfix + "." + LibraryExtension;
PublicAdditionalLibraries.Add(LibraryName);
}
}
}
// common defines (this used to be inside an if TargetPlatform == ___ block that looked to include every platform known to man, so just removed the if)
// Definitions
PublicDefinitions.Add("U_USING_ICU_NAMESPACE=0"); // Disables a using declaration for namespace "icu".
PublicDefinitions.Add("U_STATIC_IMPLEMENTATION"); // Necessary for linking to ICU statically.
PublicDefinitions.Add("UNISTR_FROM_CHAR_EXPLICIT=explicit"); // Makes UnicodeString constructors for ICU character types explicit.
PublicDefinitions.Add("UNISTR_FROM_STRING_EXPLICIT=explicit"); // Makes UnicodeString constructors for "char"/ICU string types explicit.
PublicDefinitions.Add("UCONFIG_NO_TRANSLITERATION=1"); // Disables declarations and compilation of unused ICU transliteration functionality.
if (Target.Platform == UnrealTargetPlatform.PS4)
{
// Definitions
PublicDefinitions.Add("ICU_NO_USER_DATA_OVERRIDE=1");
PublicDefinitions.Add("U_PLATFORM=U_PF_ORBIS");
}
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Definitions
PublicDefinitions.Add("ICU_NO_USER_DATA_OVERRIDE=1");
PublicDefinitions.Add("U_PLATFORM=U_PF_DURANGO");
}
PublicDefinitions.Add("NEEDS_ICU_DLLS=" + (bNeedsDlls ? "1" : "0"));
}
public CognitoIdentity(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private"));
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public"));
PublicDependencyModuleNames.AddRange(new string[] { "Engine", "Core", "CoreUObject", "InputCore", "Projects" });
// This is required to fix a warning for Unreal Engine 4.21 and later
PrivatePCHHeaderFile = "Private/CognitoIdentityPrivatePCH.h";
string BaseDirectory = System.IO.Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", ".."));
string ThirdPartyPath = System.IO.Path.Combine(BaseDirectory, "ThirdParty", "GameLiftClientSDK", Target.Platform.ToString());
bool bIsThirdPartyPathValid = System.IO.Directory.Exists(ThirdPartyPath);
if (bIsThirdPartyPathValid)
{
if (Target.Type == TargetRules.TargetType.Client)
{
PublicDefinitions.Add("WITH_COGNITOIDENTITY=1");
//PublicLibraryPaths.Add(ThirdPartyPath);
if (Target.Platform == UnrealTargetPlatform.Linux)
{
// cognito identity
string CognitoSoFile = System.IO.Path.Combine(ThirdPartyPath, "libaws-cpp-sdk-cognito-identity.so");
if (File.Exists(CognitoSoFile))
{
PublicAdditionalLibraries.Add(CognitoSoFile);
RuntimeDependencies.Add(CognitoSoFile);
}
else
{
throw new BuildException("libaws-cpp-sdk-cognito-identity.so not found. Expected in this location: " + CognitoSoFile);
}
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
// cognito identity
string CognitoLibFile = System.IO.Path.Combine(ThirdPartyPath, "aws-cpp-sdk-cognito-identity.lib");
if (File.Exists(CognitoLibFile))
{
PublicAdditionalLibraries.Add(CognitoLibFile);
}
else
{
throw new BuildException("aws-cpp-sdk-cognito-identity.lib not found. Expected in this location: " + CognitoLibFile);
}
string CognitoDLLFile = System.IO.Path.Combine(ThirdPartyPath, "aws-cpp-sdk-cognito-identity.dll");
if (File.Exists(CognitoDLLFile))
{
PublicDelayLoadDLLs.Add("aws-cpp-sdk-cognito-identity.dll");
RuntimeDependencies.Add(CognitoDLLFile);
}
else
{
throw new BuildException("aws-cpp-sdk-cognito-identity.dll not found. Expected in this location: " + CognitoDLLFile);
}
}
}
else
{
PublicDefinitions.Add("WITH_COGNITOIDENTITY=0");
}
}
else
{
PublicDefinitions.Add("WITH_COGNITOIDENTITY=0");
}
}
public HotPatcherEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
bLegacyPublicIncludePaths = false;
OptimizeCode = CodeOptimization.InShippingBuildsOnly;
if (Target.Version.MajorVersion < 5 && Target.Version.MinorVersion <= 21)
{
bUseRTTI = true;
}
PublicIncludePaths.AddRange(new string[] { });
PrivateIncludePaths.AddRange(new string[] {});
PublicDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd",
"UMG",
"UMGEditor",
"Core",
"Json",
"ContentBrowser",
"SandboxFile",
"JsonUtilities",
"TargetPlatform",
"DesktopPlatform",
"Projects",
"Settings",
"HTTP",
"RHI",
"EngineSettings",
"AssetRegistry",
"PakFileUtilities",
"HotPatcherRuntime",
"BinariesPatchFeature",
"HotPatcherCore"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"UnrealEd",
"Projects",
"DesktopPlatform",
"InputCore",
"EditorStyle",
"LevelEditor",
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"RenderCore"
// ... add private dependencies that you statically link with here ...
}
);
if (Target.Version.MajorVersion > 4 || Target.Version.MinorVersion > 23)
{
PublicDependencyModuleNames.AddRange(new string[] {
"ToolMenus",
"TraceLog"
});
}
System.Func <string, bool, bool> AddPublicDefinitions = (string MacroName, bool bEnable) =>
{
PublicDefinitions.Add(string.Format("{0}={1}", MacroName, bEnable ? 1 : 0));
return(true);
};
AddPublicDefinitions("ENABLE_COOK_ENGINE_MAP", false);
AddPublicDefinitions("ENABLE_COOK_PLUGIN_MAP", false);
BuildVersion Version;
BuildVersion.TryRead(BuildVersion.GetDefaultFileName(), out Version);
AddPublicDefinitions("WITH_EDITOR_SECTION", Version.MajorVersion > 4 || Version.MinorVersion > 24);
// Game feature
bool bEnableGameFeature = false;
AddPublicDefinitions("ENGINE_GAME_FEATURE", bEnableGameFeature || (Target.Version.MajorVersion > 4 || Target.Version.MinorVersion > 26));
System.Console.WriteLine("MajorVersion {0} MinorVersion: {1} PatchVersion {2}", Target.Version.MajorVersion, Target.Version.MinorVersion, Target.Version.PatchVersion);
PublicDefinitions.AddRange(new string[]
{
"ENABLE_UPDATER_CHECK=1",
"ENABLE_MULTI_COOKER=0",
"TOOL_NAME=\"HotPatcher\"",
"CURRENT_VERSION_ID=75",
"CURRENT_PATCH_ID=2",
"REMOTE_VERSION_FILE=\"https://imzlp.com/opensource/version.json\""
});
bool bEnablePackageContext = true;
AddPublicDefinitions("WITH_PACKAGE_CONTEXT", (Version.MajorVersion > 4 || Version.MinorVersion > 23) && bEnablePackageContext);
if (Version.MajorVersion > 4 || Version.MajorVersion > 26)
{
PublicDependencyModuleNames.AddRange(new string[]
{
"IoStoreUtilities",
"UnrealEd"
});
}
}
public OodleHandlerComponent(ReadOnlyTargetRules Target) : base(Target)
{
ShortName = "OodleHC";
BinariesSubFolder = "NotForLicensees";
PrivateIncludePaths.Add("OodleHandlerComponent/Private");
PublicDependencyModuleNames.AddRange(
new string[]
{
"PacketHandler",
"Core",
"CoreUObject",
"Engine",
"Analytics"
});
bool bHaveOodleSDK = false;
string OodleNotForLicenseesLibDir = "";
// Check the NotForLicensees folder first
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "win", "lib");
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "Linux", "lib");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "ps4", "lib");
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "XboxOne", "lib");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "Mac", "lib");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "Android", "lib");
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "IOS", "lib");
}
else if (Target.Platform == UnrealTargetPlatform.Switch)
{
OodleNotForLicenseesLibDir = System.IO.Path.Combine(Target.UEThirdPartySourceDirectory, "..", "..",
"Plugins", "Runtime", "PacketHandlers", "CompressionComponents", "Oodle", "Source", "ThirdParty", "NotForLicensees",
"Oodle", "255", "Switch", "lib");
}
if (OodleNotForLicenseesLibDir.Length > 0)
{
try
{
bHaveOodleSDK = System.IO.Directory.Exists(OodleNotForLicenseesLibDir);
}
catch (System.Exception)
{
}
}
if (bHaveOodleSDK)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Oodle");
PublicIncludePathModuleNames.Add("Oodle");
PublicDefinitions.Add("HAS_OODLE_SDK=1");
}
else
{
PublicDefinitions.Add("HAS_OODLE_SDK=0");
}
}
public NodeGraphAssistant(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string enginePath = Path.GetFullPath(Target.RelativeEnginePath);
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
enginePath + "Source/Runtime/Core/Public",
enginePath + "Source/Runtime/Projects/Public",
enginePath + "Source/Runtime/Projects/Public/Interfaces",
enginePath + "Source/Runtime/Engine/Classes",
enginePath + "Source/Runtime/Engine/Public",
enginePath + "Source/Runtime/SlateCore/Public/Styling",
enginePath + "Source/Runtime/Slate/Public/Framework/Application",
enginePath + "Source/Runtime/Slate/Public/Framework",
enginePath + "Source/Runtime/SlateCore/Public",
enginePath + "Source/Editor/UnrealEd/Public",
enginePath + "Source/Editor/UnrealEd/Classes",
enginePath + "Source/Editor/GraphEditor/Public",
enginePath + "Source/Editor/EditorStyle/Public",
enginePath + "Source/Editor/MaterialEditor/Public",
enginePath + "Source/Editor/AnimationBlueprintEditor/Public",
enginePath + "Source/Editor/Kismet/Public",
enginePath + "Source/Editor/BlueprintGraph/Classes",
enginePath + "Source/Editor/KismetWidgets/Public",
//enginePath+"Source/Editor/PropertyEditor/Public",
}
);
PrivateIncludePaths.Add(enginePath + "Source/Editor/GraphEditor/Private");
PrivateIncludePaths.Add(enginePath + "Source/Runtime/Launch/Resources");
PrivateIncludePaths.Add(enginePath + "Source/Runtime/Engine/Classes/EdGraph");
PrivateIncludePaths.Add(enginePath + "Source/Editor/AnimationBlueprintEditor/Private");
PrivateIncludePaths.Add(enginePath + "Source/Editor/AudioEditor/Private");
PrivateIncludePaths.Add(enginePath + "Source/Editor/UnrealEd/Private");
//PrivateIncludePaths.Add(enginePath + "Plugins/FX/Niagara/Source/NiagaraEditor/Public");
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core", "CoreUObject", "Slate", "SlateCore", "UnrealEd", "GraphEditor",
"InputCore", "EditorStyle", "Engine", "AnimGraph", "Projects",
"MaterialEditor", "BlueprintGraph", "AnimationBlueprintEditor", "AudioEditor", "KismetWidgets"
//"PropertyEditor","AppFramework","NiagaraEditor",
// ... add private dependencies that you statically link with here ...
}
);
#if UE_4_17_OR_LATER
PrivateDependencyModuleNames.Add("ApplicationCore");
#endif
//some classes is not exported from engine, so when build with release engine it can not find the implementation.
if (File.Exists(enginePath + "Source/Editor/GraphEditor/Private/DragConnection.cpp"))
{
#if UE_4_17_OR_LATER
PublicDefinitions.Add("NGA_WITH_ENGINE_CPP");
#else
Definitions.Add("NGA_WITH_ENGINE_CPP");
#endif
}
else
{
Log.TraceInformation("one or more engine cpp files not found.");
Log.TraceInformation("will use pre-copied source files inside plugin source folder.");
Log.TraceInformation("turn on \"download source code\" option when installing engine if problem occured.");
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public NuGetModule(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
}
);
// WinRT with Nuget support
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens)
{
// these parameters mandatory for winrt support
bEnableExceptions = true;
bUseUnity = false;
CppStandard = CppStandardVersion.Cpp17;
PublicSystemLibraries.AddRange(new string [] { "shlwapi.lib", "runtimeobject.lib" });
// prepare everything for nuget
string MyModuleName = GetType().Name;
string NugetFolder = Path.Combine(PluginDirectory, "Intermediate", "Nuget", MyModuleName);
Directory.CreateDirectory(NugetFolder);
string BinariesSubFolder = Path.Combine("Binaries", "ThirdParty", Target.Type.ToString(), Target.Platform.ToString(), Target.Architecture);
PublicDefinitions.Add(string.Format("THIRDPARTY_BINARY_SUBFOLDER=\"{0}\"", BinariesSubFolder.Replace(@"\", @"\\")));
string BinariesFolder = Path.Combine(PluginDirectory, BinariesSubFolder);
Directory.CreateDirectory(BinariesFolder);
ExternalDependencies.Add("packages.config");
// download nuget
string NugetExe = Path.Combine(NugetFolder, "nuget.exe");
if (!File.Exists(NugetExe))
{
using (System.Net.WebClient myWebClient = new System.Net.WebClient())
{
// we aren't focusing on a specific nuget version, we can use any of them but the latest one is preferable
myWebClient.DownloadFile(@"https://dist.nuget.org/win-x86-commandline/latest/nuget.exe", NugetExe);
}
}
// run nuget to update the packages
{
var StartInfo = new System.Diagnostics.ProcessStartInfo(NugetExe, string.Format("install \"{0}\" -OutputDirectory \"{1}\"", Path.Combine(ModuleDirectory, "packages.config"), NugetFolder));
StartInfo.UseShellExecute = false;
StartInfo.CreateNoWindow = true;
var ExitCode = Utils.RunLocalProcessAndPrintfOutput(StartInfo);
if (ExitCode < 0)
{
throw new BuildException("Failed to get nuget packages. See log for details.");
}
}
// get list of the installed packages, that's needed because the code should get particular versions of the installed packages
string[] InstalledPackages = Utils.RunLocalProcessAndReturnStdOut(NugetExe, string.Format("list -Source \"{0}\"", NugetFolder)).Split(new char[] { '\r', '\n' });
// winmd files of the packages
List <string> WinMDFiles = new List <string>();
// WinRT lib for some job
string QRPackage = InstalledPackages.FirstOrDefault(x => x.StartsWith("Microsoft.MixedReality.QR"));
if (!string.IsNullOrEmpty(QRPackage))
{
string QRFolderName = QRPackage.Replace(" ", ".");
// copying dll and winmd binaries to our local binaries folder
// !!!!! please make sure that you use the path of file! Unreal can't do it for you !!!!!
string WinMDFile = Path.Combine(NugetFolder, QRFolderName, @"lib\uap10.0.18362\Microsoft.MixedReality.QR.winmd");
SafeCopy(WinMDFile, Path.Combine(BinariesFolder, "Microsoft.MixedReality.QR.winmd"));
SafeCopy(Path.Combine(NugetFolder, QRFolderName, string.Format(@"runtimes\win10-{0}\native\Microsoft.MixedReality.QR.dll", Target.WindowsPlatform.Architecture.ToString())),
Path.Combine(BinariesFolder, "Microsoft.MixedReality.QR.dll"));
// also both both binaries must be in RuntimeDependencies, unless you get failures in Hololens platform
RuntimeDependencies.Add(Path.Combine(BinariesFolder, "Microsoft.MixedReality.QR.dll"));
RuntimeDependencies.Add(Path.Combine(BinariesFolder, "Microsoft.MixedReality.QR.winmd"));
//add winmd file to the list for further processing using cppwinrt.exe
WinMDFiles.Add(WinMDFile);
}
string ASAPackage = InstalledPackages.FirstOrDefault(x => x.StartsWith("Microsoft.Azure.SpatialAnchors.WinRT"));
if (!string.IsNullOrEmpty(ASAPackage))
{
string ASAFolderName = ASAPackage.Replace(" ", ".");
// copying dll and winmd binaries to our local binaries folder
// !!!!! please make sure that you use the path of file! Unreal can't do it for you !!!!!
string WinMDFile = Path.Combine(NugetFolder, ASAFolderName, @"lib\uap10.0\Microsoft.Azure.SpatialAnchors.winmd");
SafeCopy(WinMDFile, Path.Combine(BinariesFolder, "Microsoft.Azure.SpatialAnchors.winmd"));
SafeCopy(Path.Combine(NugetFolder, ASAFolderName, string.Format(@"runtimes\win10-{0}\native\Microsoft.Azure.SpatialAnchors.dll", Target.WindowsPlatform.Architecture.ToString())),
Path.Combine(BinariesFolder, "Microsoft.Azure.SpatialAnchors.dll"));
SafeCopy(Path.Combine(NugetFolder, ASAFolderName, string.Format(@"runtimes\win10-{0}\native\CoarseRelocUW.dll", Target.WindowsPlatform.Architecture.ToString())),
Path.Combine(BinariesFolder, "CoarseRelocUW.dll"));
// also all binaries must be in RuntimeDependencies
RuntimeDependencies.Add(Path.Combine(BinariesFolder, "Microsoft.Azure.SpatialAnchors.dll"));
RuntimeDependencies.Add(Path.Combine(BinariesFolder, "Microsoft.Azure.SpatialAnchors.winmd"));
RuntimeDependencies.Add(Path.Combine(BinariesFolder, "CoarseRelocUW.dll"));
// add winmd file to the list for further processing using cppwinrt.exe
WinMDFiles.Add(WinMDFile);
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// Microsoft.VCRTForwarders.140 is needed to run WinRT dlls in Win64 platforms
string VCRTForwardersPackage = InstalledPackages.FirstOrDefault(x => x.StartsWith("Microsoft.VCRTForwarders.140"));
if (!string.IsNullOrEmpty(VCRTForwardersPackage))
{
string VCRTForwardersName = VCRTForwardersPackage.Replace(" ", ".");
foreach (var Dll in Directory.EnumerateFiles(Path.Combine(NugetFolder, VCRTForwardersName, "runtimes/win10-x64/native/release"), "*_app.dll"))
{
string newDll = Path.Combine(BinariesFolder, Path.GetFileName(Dll));
SafeCopy(Dll, newDll);
RuntimeDependencies.Add(newDll);
}
}
string RemotingPackage = InstalledPackages.FirstOrDefault(x => x.StartsWith("Microsoft.Holographic.Remoting.OpenXr"));
if (!string.IsNullOrEmpty(RemotingPackage))
{
string RemotingFolderName = RemotingPackage.Replace(" ", ".");
SafeCopy(Path.Combine(NugetFolder, RemotingFolderName, @"build\native\bin\x64\Desktop\Microsoft.Holographic.AppRemoting.OpenXr.dll"),
Path.Combine(BinariesFolder, "Microsoft.Holographic.AppRemoting.OpenXr.dll"));
SafeCopy(Path.Combine(NugetFolder, RemotingFolderName, @"build\native\bin\x64\Desktop\RemotingXR.json"),
Path.Combine(BinariesFolder, "RemotingXR.json"));
PublicIncludePaths.Add(Path.Combine(NugetFolder, RemotingFolderName, @"build\native\include\openxr"));
RuntimeDependencies.Add(Path.Combine(BinariesFolder, "Microsoft.Holographic.AppRemoting.OpenXr.dll"));
RuntimeDependencies.Add(Path.Combine(BinariesFolder, "RemotingXR.json"));
}
}
// get WinRT package
string CppWinRTPackage = InstalledPackages.FirstOrDefault(x => x.StartsWith("Microsoft.Windows.CppWinRT"));
if (!string.IsNullOrEmpty(CppWinRTPackage))
{
string CppWinRTName = CppWinRTPackage.Replace(" ", ".");
string CppWinRTExe = Path.Combine(NugetFolder, CppWinRTName, "bin", "cppwinrt.exe");
string CppWinRTFolder = Path.Combine(PluginDirectory, "Intermediate", CppWinRTName, MyModuleName);
Directory.CreateDirectory(CppWinRTFolder);
// all downloaded winmd file with WinSDK to be processed by cppwinrt.exe
var WinMDFilesStringbuilder = new System.Text.StringBuilder();
foreach (var winmd in WinMDFiles)
{
WinMDFilesStringbuilder.Append(" -input \"");
WinMDFilesStringbuilder.Append(winmd);
WinMDFilesStringbuilder.Append("\"");
}
// generate winrt headers and add them into include paths
var StartInfo = new System.Diagnostics.ProcessStartInfo(CppWinRTExe, string.Format("{0} -input \"{1}\" -output \"{2}\"", WinMDFilesStringbuilder, Target.WindowsPlatform.WindowsSdkVersion, CppWinRTFolder));
StartInfo.UseShellExecute = false;
StartInfo.CreateNoWindow = true;
var ExitCode = Utils.RunLocalProcessAndPrintfOutput(StartInfo);
if (ExitCode < 0)
{
throw new BuildException("Failed to get generate WinRT headers. See log for details.");
}
PublicIncludePaths.Add(CppWinRTFolder);
}
else
{
// fall back to default WinSDK headers if no winrt package in our list
PublicIncludePaths.Add(Path.Combine(Target.WindowsPlatform.WindowsSdkDir, "Include", Target.WindowsPlatform.WindowsSdkVersion, "cppwinrt"));
}
}
}
public Core(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/CorePrivatePCH.h";
SharedPCHHeaderFile = "Public/CoreSharedPCH.h";
bAddDefaultIncludePaths = false;
PublicIncludePaths.AddRange(
new string[] {
"Runtime/Core/Public",
"Runtime/Core/Public/Internationalization",
"Runtime/Core/Public/Async",
"Runtime/Core/Public/Concurrency",
"Runtime/Core/Public/Containers",
"Runtime/Core/Public/Delegates",
"Runtime/Core/Public/GenericPlatform",
"Runtime/Core/Public/HAL",
"Runtime/Core/Public/Logging",
"Runtime/Core/Public/Math",
"Runtime/Core/Public/Misc",
"Runtime/Core/Public/Modules",
"Runtime/Core/Public/Modules/Boilerplate",
"Runtime/Core/Public/ProfilingDebugging",
"Runtime/Core/Public/Serialization",
"Runtime/Core/Public/Serialization/Csv",
"Runtime/Core/Public/Stats",
"Runtime/Core/Public/Templates",
"Runtime/Core/Public/UObject",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Core/Private",
"Runtime/Core/Private/Misc",
"Runtime/Core/Private/Serialization/Json",
"Runtime/Core/Private/Internationalization",
"Runtime/Core/Private/Internationalization/Cultures",
"Runtime/Analytics/Public",
"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))
{
PublicIncludePaths.Add("Runtime/Core/Public/Windows");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"IntelVTune"
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicIncludePaths.AddRange(new string[] { "Runtime/Core/Public/Apple", "Runtime/Core/Public/Mac" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"zlib",
"PLCrashReporter"
);
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)
{
PublicIncludePaths.AddRange(new string[] { "Runtime/Core/Public/Apple", "Runtime/Core/Public/IOS" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib"
);
PublicFrameworks.AddRange(new string[] { "UIKit", "Foundation", "AudioToolbox", "AVFoundation", "GameKit", "StoreKit", "CoreVideo", "CoreMedia", "CoreGraphics", "GameController", "SystemConfiguration" });
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.AddRange(new string[] { "CoreMotion", "AdSupport" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"PLCrashReporter"
);
}
PrivateIncludePathModuleNames.Add("ApplicationCore");
bool bSupportAdvertising = Target.Platform == UnrealTargetPlatform.IOS;
if (bSupportAdvertising)
{
PublicFrameworks.AddRange(new string[] { "iAD" });
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicIncludePaths.Add("Runtime/Core/Public/Android");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"cxademangle",
"zlib"
);
}
else if ((Target.Platform == UnrealTargetPlatform.Linux))
{
PublicIncludePaths.Add("Runtime/Core/Public/Linux");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"zlib",
"jemalloc",
"elftoolchain"
);
// 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");
}
// NVCHANGE_BEGIN: Add VXGI
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDependencyModuleNames.Add("VXGI");
}
// NVCHANGE_END: Add VXGI
}
public PhysX(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
// Determine which kind of libraries to link against
PhysXLibraryMode LibraryMode = GetPhysXLibraryMode(Target.Configuration);
string LibrarySuffix = GetPhysXLibrarySuffix(LibraryMode);
if (LibraryMode == PhysXLibraryMode.Shipping)
{
PublicDefinitions.Add("WITH_PHYSX_RELEASE=1");
}
else
{
PublicDefinitions.Add("WITH_PHYSX_RELEASE=0");
}
string PhysXVersion = "PhysX_3.4";
string PxSharedVersion = "PxShared";
string PhysXDir = Target.UEThirdPartySourceDirectory + "PhysX3/" + PhysXVersion + "/";
string PxSharedDir = Target.UEThirdPartySourceDirectory + "PhysX3/" + PxSharedVersion + "/";
string PhysXLibDir = Target.UEThirdPartySourceDirectory + "PhysX3/Lib/";
string PxSharedLibDir = Target.UEThirdPartySourceDirectory + "PhysX3/Lib/";
string PhysXIncludeDir = PhysXDir + "Include/";
string PxSharedIncludeDir = PxSharedDir + "include/";
PublicSystemIncludePaths.AddRange(
new string[] {
PxSharedIncludeDir,
PxSharedIncludeDir + "cudamanager",
PxSharedIncludeDir + "filebuf",
PxSharedIncludeDir + "foundation",
PxSharedIncludeDir + "pvd",
PxSharedIncludeDir + "task",
PhysXIncludeDir,
PhysXIncludeDir + "cooking",
PhysXIncludeDir + "common",
PhysXIncludeDir + "extensions",
PhysXIncludeDir + "geometry"
}
);
// Libraries and DLLs for windows platform
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PhysXLibDir += "Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
PxSharedLibDir += "Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
PublicLibraryPaths.Add(PhysXLibDir);
PublicLibraryPaths.Add(PxSharedLibDir);
string[] StaticLibrariesX64 = new string[] {
"PhysX3{0}_x64.lib",
"PhysX3Extensions{0}_x64.lib",
"PhysX3Cooking{0}_x64.lib",
"PhysX3Common{0}_x64.lib",
"PsFastXml{0}_x64.lib",
"PxFoundation{0}_x64.lib",
"PxPvdSDK{0}_x64.lib",
"PxTask{0}_x64.lib",
};
string[] DelayLoadDLLsX64 = new string[] {
"PxFoundation{0}_x64.dll",
"PxPvdSDK{0}_x64.dll",
"PhysX3{0}_x64.dll",
"PhysX3Cooking{0}_x64.dll",
"PhysX3Common{0}_x64.dll",
};
string[] PxSharedRuntimeDependenciesX64 = new string[] {
"PxFoundation{0}_x64.dll",
"PxPvdSDK{0}_x64.dll",
};
foreach (string Lib in StaticLibrariesX64)
{
PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
}
foreach (string DLL in DelayLoadDLLsX64)
{
PublicDelayLoadDLLs.Add(String.Format(DLL, LibrarySuffix));
}
string PhysXBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX3/Win64/VS{0}/", Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
foreach (string DLL in DelayLoadDLLsX64)
{
string FileName = PhysXBinariesDir + String.Format(DLL, LibrarySuffix);
RuntimeDependencies.Add(FileName, StagedFileType.NonUFS);
RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS);
}
if (LibrarySuffix != "")
{
PublicDefinitions.Add("UE_PHYSX_SUFFIX=" + LibrarySuffix);
}
string PxSharedBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX3/Win64/VS{0}/", Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
foreach (string DLL in PxSharedRuntimeDependenciesX64)
{
RuntimeDependencies.Add(PxSharedBinariesDir + String.Format(DLL, LibrarySuffix));
}
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PhysXLibDir += "Win32/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
PxSharedLibDir += "Win32/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
PublicLibraryPaths.Add(PhysXLibDir);
PublicLibraryPaths.Add(PxSharedLibDir);
string[] StaticLibrariesX86 = new string[] {
"PhysX3{0}_x86.lib",
"PhysX3Extensions{0}_x86.lib",
"PhysX3Cooking{0}_x86.lib",
"PhysX3Common{0}_x86.lib",
"PsFastXml{0}_x86.lib",
"PxFoundation{0}_x86.lib",
"PxPvdSDK{0}_x86.lib",
"PxTask{0}_x86.lib",
};
string[] DelayLoadDLLsX86 = new string[] {
"PxFoundation{0}_x86.dll",
"PxPvdSDK{0}_x86.dll",
"PhysX3{0}_x86.dll",
"PhysX3Cooking{0}_x86.dll",
"PhysX3Common{0}_x86.dll"
};
foreach (string Lib in StaticLibrariesX86)
{
PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
}
foreach (string DLL in DelayLoadDLLsX86)
{
PublicDelayLoadDLLs.Add(String.Format(DLL, LibrarySuffix));
}
string PhysXBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX3/Win32/VS{0}/", Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
foreach (string DLL in DelayLoadDLLsX86)
{
string FileName = PhysXBinariesDir + String.Format(DLL, LibrarySuffix);
RuntimeDependencies.Add(FileName, StagedFileType.NonUFS);
RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS);
}
if (LibrarySuffix != "")
{
PublicDefinitions.Add("UE_PHYSX_SUFFIX=" + LibrarySuffix);
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PhysXLibDir += "Mac";
PxSharedLibDir += "Mac";
PublicLibraryPaths.Add(PhysXLibDir);
PublicLibraryPaths.Add(PxSharedLibDir);
string[] StaticLibrariesMac = new string[] {
PhysXLibDir + "/libLowLevel{0}.a",
PhysXLibDir + "/libLowLevelCloth{0}.a",
PhysXLibDir + "/libPhysX3Extensions{0}.a",
PhysXLibDir + "/libSceneQuery{0}.a",
PhysXLibDir + "/libSimulationController{0}.a",
PxSharedLibDir + "/libPxTask{0}.a",
PxSharedLibDir + "/libPsFastXml{0}.a"
};
foreach (string Lib in StaticLibrariesMac)
{
PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
}
string[] DynamicLibrariesMac = new string[] {
"/libPhysX3{0}.dylib",
"/libPhysX3Cooking{0}.dylib",
"/libPhysX3Common{0}.dylib",
"/libPxFoundation{0}.dylib",
"/libPxPvdSDK{0}.dylib",
};
string PhysXBinariesDir = Target.UEThirdPartyBinariesDirectory + "PhysX3/Mac";
foreach (string Lib in DynamicLibrariesMac)
{
string LibraryPath = PhysXBinariesDir + String.Format(Lib, LibrarySuffix);
PublicDelayLoadDLLs.Add(LibraryPath);
RuntimeDependencies.Add(LibraryPath);
}
if (LibrarySuffix != "")
{
PublicDefinitions.Add("UE_PHYSX_SUFFIX=" + LibrarySuffix);
}
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
PublicLibraryPaths.Add(PhysXLibDir + "Android/ARMv7");
PublicLibraryPaths.Add(PhysXLibDir + "Android/x86");
PublicLibraryPaths.Add(PhysXLibDir + "Android/ARM64");
PublicLibraryPaths.Add(PhysXLibDir + "Android/x64");
PublicLibraryPaths.Add(PxSharedLibDir + "Android/ARMv7");
PublicLibraryPaths.Add(PxSharedLibDir + "Android/x86");
PublicLibraryPaths.Add(PxSharedLibDir + "Android/arm64");
PublicLibraryPaths.Add(PxSharedLibDir + "Android/x64");
string[] StaticLibrariesAndroid = new string[] {
"PhysX3{0}",
"PhysX3Extensions{0}",
"PhysX3Cooking{0}", // not needed until Apex
"PhysX3Common{0}",
//"PhysXVisualDebuggerSDK{0}",
"PxFoundation{0}",
"PxPvdSDK{0}",
"PsFastXml{0}"
};
//if you are shipping, and you actually want the shipping libs, you do not need this lib
if (!(LibraryMode == PhysXLibraryMode.Shipping && Target.bUseShippingPhysXLibraries))
{
// PublicAdditionalLibraries.Add("nvToolsExt");
}
foreach (string Lib in StaticLibrariesAndroid)
{
PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
}
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PhysXLibDir += "/Linux/" + Target.Architecture;
PxSharedLibDir += "/Linux/" + Target.Architecture;
PublicLibraryPaths.Add(PhysXLibDir);
PublicLibraryPaths.Add(PxSharedLibDir);
string[] StaticLibrariesPhysXLinux = new string[] {
"rt",
"PhysX3{0}",
"PhysX3Extensions{0}",
"PhysX3Cooking{0}",
"PhysX3Common{0}",
"PxFoundation{0}",
"PxPvdSDK{0}",
"PsFastXml{0}"
};
foreach (string Lib in StaticLibrariesPhysXLinux)
{
PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
}
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PhysXLibDir = Path.Combine(PhysXLibDir, "IOS/");
PxSharedLibDir = Path.Combine(PxSharedLibDir, "IOS/");
PublicLibraryPaths.Add(PhysXLibDir);
PublicLibraryPaths.Add(PxSharedLibDir);
string[] PhysXLibs = new string[]
{
"LowLevel",
"LowLevelAABB",
"LowLevelCloth",
"LowLevelDynamics",
"LowLevelParticles",
"PhysX3",
"PhysX3Common",
// "PhysX3Cooking", // not needed until Apex
"PhysX3Extensions",
"SceneQuery",
"SimulationController",
"PxFoundation",
"PxTask",
"PxPvdSDK",
"PsFastXml"
};
foreach (string PhysXLib in PhysXLibs)
{
PublicAdditionalLibraries.Add(PhysXLib + LibrarySuffix);
}
}
else if (Target.Platform == UnrealTargetPlatform.TVOS)
{
PhysXLibDir = Path.Combine(PhysXLibDir, "TVOS/");
PxSharedLibDir = Path.Combine(PxSharedLibDir, "TVOS/");
PublicLibraryPaths.Add(PhysXLibDir);
PublicLibraryPaths.Add(PxSharedLibDir);
string[] PhysXLibs = new string[]
{
"LowLevel",
"LowLevelAABB",
"LowLevelCloth",
"LowLevelDynamics",
"LowLevelParticles",
"PhysX3",
"PhysX3Common",
// "PhysX3Cooking", // not needed until Apex
"PhysX3Extensions",
"SceneQuery",
"SimulationController",
"PxFoundation",
"PxTask",
"PxPvdSDK",
"PsFastXml"
};
foreach (string PhysXLib in PhysXLibs)
{
PublicAdditionalLibraries.Add(PhysXLib + LibrarySuffix);
}
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PhysXLibDir = Path.Combine(PhysXLibDir, "HTML5/");
PxSharedLibDir = Path.Combine(PxSharedLibDir, "HTML5/");
string[] PhysXLibs = new string[]
{
"LowLevel",
"LowLevelAABB",
"LowLevelCloth",
"LowLevelDynamics",
"LowLevelParticles",
"PhysX3",
"PhysX3CharacterKinematic",
"PhysX3Common",
"PhysX3Cooking",
"PhysX3Extensions",
//"PhysXVisualDebuggerSDK",
"SceneQuery",
"SimulationController",
"PxFoundation",
"PxTask",
"PxPvdSDK",
"PsFastXml"
};
string OpimizationSuffix = "";
if (Target.bCompileForSize)
{
OpimizationSuffix = "_Oz";
}
else
{
if (Target.Configuration == UnrealTargetConfiguration.Development)
{
OpimizationSuffix = "_O2";
}
else if (Target.Configuration == UnrealTargetConfiguration.Shipping)
{
OpimizationSuffix = "_O3";
}
}
foreach (var lib in PhysXLibs)
{
PublicAdditionalLibraries.Add(PhysXLibDir + lib + OpimizationSuffix + ".bc");
}
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicLibraryPaths.Add(PhysXLibDir + "PS4");
string[] StaticLibrariesPS4 = new string[] {
"PhysX3{0}",
"PhysX3Extensions{0}",
"PhysX3Cooking{0}",
"PhysX3Common{0}",
"LowLevel{0}",
"LowLevelAABB{0}",
"LowLevelCloth{0}",
"LowLevelDynamics{0}",
"LowLevelParticles{0}",
"SceneQuery{0}",
"SimulationController{0}",
"PxFoundation{0}",
"PxTask{0}",
"PxPvdSDK{0}",
"PsFastXml{0}"
};
foreach (string Lib in StaticLibrariesPS4)
{
PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
}
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PublicDefinitions.Add("PX_PHYSX_STATIC_LIB=1");
PublicDefinitions.Add("_XBOX_ONE=1");
PublicLibraryPaths.Add(Path.Combine(PhysXLibDir, "XboxOne\\VS2015"));
string[] StaticLibrariesXB1 = new string[] {
"PhysX3{0}.lib",
"PhysX3Extensions{0}.lib",
"PhysX3Cooking{0}.lib",
"PhysX3Common{0}.lib",
"LowLevel{0}.lib",
"LowLevelAABB{0}.lib",
"LowLevelCloth{0}.lib",
"LowLevelDynamics{0}.lib",
"LowLevelParticles{0}.lib",
"SceneQuery{0}.lib",
"SimulationController{0}.lib",
"PxFoundation{0}.lib",
"PxTask{0}.lib",
"PxPvdSDK{0}.lib",
"PsFastXml{0}.lib"
};
foreach (string Lib in StaticLibrariesXB1)
{
PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix));
}
}
else if (Target.Platform == UnrealTargetPlatform.Switch)
{
PublicLibraryPaths.Add(PhysXLibDir + "Switch");
PublicLibraryPaths.Add(PxSharedLibDir + "Switch");
string[] StaticLibrariesSwitch = new string[] {
"LowLevel",
"LowLevelAABB",
"LowLevelCloth",
"LowLevelDynamics",
"LowLevelParticles",
"PhysX3",
"PhysX3Common",
"PhysX3Cooking",
"PhysX3Extensions",
"SceneQuery",
"SimulationController",
"PxFoundation",
"PxTask",
"PxPvdSDK",
"PsFastXml"
};
foreach (string Lib in StaticLibrariesSwitch)
{
PublicAdditionalLibraries.Add(Lib + LibrarySuffix);
}
}
}
public Voxel(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
bEnforceIWYU = true;
bLegacyPublicIncludePaths = false;
#if UE_4_24_OR_LATER
#else
#endif
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public"));
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private"));
// For raytracing
PrivateIncludePaths.Add(EngineDirectory + "/Shaders/Shared");
// For HLSL translator
PrivateIncludePaths.Add(EngineDirectory + "/Source/Runtime/Engine/Private");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Networking",
"Sockets",
"RHI",
#if UE_4_23_OR_LATER
"PhysicsCore",
#endif
"RenderCore",
"Landscape",
"PhysX",
#if UE_4_26_OR_LATER
"DeveloperSettings",
"TraceLog",
#endif
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"nvTessLib",
"HTTP",
"Projects",
"Slate",
"SlateCore",
//"VHACD", // Not used, too slow
}
);
SetupModulePhysicsSupport(Target);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.Add("ForsythTriOptimizer");
}
PrivateDependencyModuleNames.Add("zlib");
if (Target.Configuration == UnrealTargetConfiguration.DebugGame ||
Target.Configuration == UnrealTargetConfiguration.Debug)
{
PublicDefinitions.Add("VOXEL_DEBUG=1");
}
PublicDefinitions.Add("VOXEL_PLUGIN_NAME=TEXT(\"VoxelFree\")");
}
