public UnrealEnginePython(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
"UnrealEnginePython/Public",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"UnrealEnginePython/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Sockets",
"Networking"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"MovieScene",
"LevelSequence",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (UEBuildConfiguration.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"UnrealEd",
"LevelEditor",
"BlueprintGraph",
"Projects"
});
}
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(windowsKnownPaths);
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetWindowsPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicAdditionalLibraries.Add(libPath);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(macKnownPaths);
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetMacPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicDelayLoadDLLs.Add(libPath);
Definitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_MAC"));
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (pythonHome == "python35")
{
PublicIncludePaths.Add("/usr/include/python3.5m");
PublicAdditionalLibraries.Add("/usr/lib/python3.5/config-3.5m-x86_64-linux-gnu/libpython3.5.so");
}
else if (pythonHome == "python27")
{
PublicIncludePaths.Add("/usr/include/python2.7");
PublicAdditionalLibraries.Add("/usr/lib/python2.7/config-x86_64-linux-gnu/libpython2.7.so");
}
Definitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_LINUX"));
}
}
public UFFmpeg(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64" : "Win32";
string LibrariesPath = Path.Combine(Path.Combine(Path.Combine(ThirdPartyPath, "ffmpeg", "lib"), "vs"), PlatformString);
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "avcodec.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "avdevice.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "avfilter.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "avformat.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "avutil.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "swresample.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "swscale.lib"));
string[] dlls = { "avcodec-58.dll", "avdevice-58.dll", "avfilter-7.dll", "avformat-58.dll", "avutil-56.dll", "swresample-3.dll", "swscale-5.dll", "postproc-55.dll" };
string BinariesPath = Path.Combine(Path.Combine(Path.Combine(ThirdPartyPath, "ffmpeg", "bin"), "vs"), PlatformString);
System.Console.WriteLine("... LibrariesPath -> " + BinariesPath);
foreach (string dll in dlls)
{
PublicDelayLoadDLLs.Add(dll);
RuntimeDependencies.Add(Path.Combine(BinariesPath, dll), StagedFileType.NonUFS);
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string LibrariesPath = Path.Combine(Path.Combine(ThirdPartyPath, "ffmpeg", "lib"), "osx");
System.Console.WriteLine("... LibrariesPath -> " + LibrariesPath);
string[] libs = { "libavcodec.58.dylib", "libavdevice.58.dylib", "libavfilter.7.dylib", "libavformat.58.dylib", "libavutil.56.dylib", "libswresample.3.dylib", "libswscale.5.dylib", "libpostproc.55.dylib" };
foreach (string lib in libs)
{
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, lib));
RuntimeDependencies.Add(Path.Combine(LibrariesPath, lib), StagedFileType.NonUFS);
}
}
// Include path
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "ffmpeg", "include"));
PublicIncludePaths.Add(Path.Combine(Directory.GetCurrentDirectory(), "Runtime", "AudioMixer", "Private"));
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"AudioMixer",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"Projects",
"Engine",
"RHI",
"UnrealEd",
"RenderCore"
// ... add private dependencies that you statically link with here ...
}
);
OptimizeCode = CodeOptimization.InShippingBuildsOnly;
//bEnableUndefinedIdentifierWarnings = false;
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
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 RequiredVersionName = "2.2.5";
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[] LineSplit = NoesisSdkVersionInfo.Split('\n');
string[] SplitVersion = LineSplit[1].Split(' ');
Version InstalledVersion = new Version(SplitVersion[0]);
Version RequiredVersion = new Version(RequiredVersionName);
if (InstalledVersion != RequiredVersion)
{
throw new BuildException("Wrong version of the NoesisGUI SDK installed in " + NoesisBasePath + ". 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 AlembicLib(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux)
{
bool bDebug = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT);
string LibDir = ModuleDirectory + "/AlembicDeploy/";
string Platform;
bool bAllowDynamicLibs = true;
switch (Target.Platform)
{
case UnrealTargetPlatform.Win64:
Platform = "x64";
LibDir += "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName() + "/";
break;
case UnrealTargetPlatform.Mac:
Platform = "Mac";
bAllowDynamicLibs = false;
break;
case UnrealTargetPlatform.Linux:
Platform = "Linux";
bAllowDynamicLibs = false;
break;
default:
return;
}
LibDir = LibDir + "/" + Platform + "/lib/";
PublicLibraryPaths.Add(LibDir);
string LibPostFix = bDebug && bAllowDynamicLibs ? "d" : "";
string LibExtension = (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux) ? ".a" : ".lib";
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicDefinitions.Add("H5_BUILT_AS_DYNAMIC_LIB");
PublicDefinitions.Add("OPENEXR_DLL");
List <string> ReqLibraryNames = new List <string>();
ReqLibraryNames.AddRange
(
new string[] {
"Half",
"Iex",
"IlmThread",
"Imath",
"IexMath",
(bDebug && bAllowDynamicLibs) ? "hdf5_" : "hdf5",
"Alembic"
});
foreach (string LibraryName in ReqLibraryNames)
{
PublicAdditionalLibraries.Add(LibraryName + LibPostFix + LibExtension);
}
if (Target.bDebugBuildsActuallyUseDebugCRT && bDebug)
{
RuntimeDependencies.Add("$(EngineDir)/Plugins/Experimental/AlembicImporter/Binaries/Win64/zlibd1.dll");
RuntimeDependencies.Add("$(EngineDir)/Plugins/Experimental/AlembicImporter/Binaries/Win64/hdf5_D.dll");
}
else
{
RuntimeDependencies.Add("$(EngineDir)/Plugins/Experimental/AlembicImporter/Binaries/Win64/hdf5.dll");
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
List <string> ReqLibraryNames = new List <string>();
ReqLibraryNames.AddRange
(
new string[] {
"libHalf",
"libIex",
"libIlmThread",
"libImath",
(bDebug && bAllowDynamicLibs) ? "hdf5_" : "hdf5",
"libAlembic"
});
foreach (string LibraryName in ReqLibraryNames)
{
PublicAdditionalLibraries.Add(LibDir + LibraryName + LibPostFix + LibExtension);
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
List <string> ReqLibraryNames = new List <string>();
ReqLibraryNames.AddRange
(
new string[] {
"libHalf",
"libIex",
"libIlmThread",
"libImath",
"hdf5",
"libAlembic"
});
foreach (string LibraryName in ReqLibraryNames)
{
PublicAdditionalLibraries.Add(LibDir + Target.Architecture + "/" + LibraryName + LibExtension);
}
}
PublicIncludePaths.Add(ModuleDirectory + "/AlembicDeploy/include/");
PublicIncludePaths.Add(ModuleDirectory + "/AlembicDeploy/include/OpenEXR/");
}
}
public AgoraSignal(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"AgoraSignal/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"AgoraSignal/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Networking",
"Sockets",
"Json",
"JsonUtilities"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
//"OnlineSubsystem",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
string OSVersion = (Target.Platform == UnrealTargetPlatform.Win32) ? "x86" : "x64";
PublicIncludePaths.Add(Path.Combine(AgoraLibrary, OSVersion, "include"));
string LibPath = Path.Combine(AgoraLibrary, OSVersion, "lib");
System.Console.WriteLine("LibPath------" + LibPath);
string DllPath = Path.Combine(AgoraLibrary, OSVersion, "dll");
System.Console.WriteLine("DllPth ----" + DllPath);
PublicLibraryPaths.Add(LibPath);
PublicAdditionalLibraries.Add("agora_sig_sdk.lib");
PublicDelayLoadDLLs.Add(Path.Combine(DllPath, "agora_sig_sdk.dll"));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(DllPath, "agora_sig_sdk.dll")));
string binariesDir = Path.Combine(ModuleDirectory, "../../Binaries", Target.Platform.ToString());
string projectBinaries = Path.Combine(ModuleDirectory, "../../../../Binaries", Target.Platform.ToString());
if (!Directory.Exists(binariesDir))
{
Directory.CreateDirectory(binariesDir);
}
if (!Directory.Exists(projectBinaries))
{
Directory.CreateDirectory(projectBinaries);
}
try {
string dll = Path.Combine(DllPath, "agora_sig_sdk.dll");
File.Copy(Path.Combine(DllPath, "agora_sig_sdk.dll"), Path.Combine(projectBinaries, "agora_sig_sdk.dll"));
File.Copy(Path.Combine(DllPath, "agora_sig_sdk.dll"), Path.Combine(binariesDir, "agora_sig_sdk.dll"));
}
catch (Exception e) {
System.Console.WriteLine("copy TextChatdll exception,maybe have exists,err=", e.ToString());
}
}
}
public UnrealEnginePython(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
"UnrealEnginePython/Public",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"UnrealEnginePython/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Sockets",
"Networking"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"MovieScene",
"LevelSequence",
"HTTP",
"UMG",
"AppFramework"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (UEBuildConfiguration.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"UnrealEd",
"LevelEditor",
"BlueprintGraph",
"Projects",
"Sequencer",
"SequencerWidgets",
"AssetTools",
"LevelSequenceEditor",
"MovieSceneTools",
"MovieSceneTracks",
"CinematicCamera",
"EditorStyle",
"GraphEditor",
"UMGEditor",
"AIGraph",
"RawMesh",
"DesktopWidgets",
"EditorWidgets"
});
}
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(windowsKnownPaths);
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetWindowsPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicAdditionalLibraries.Add(libPath);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(macKnownPaths);
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetMacPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicDelayLoadDLLs.Add(libPath);
Definitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_MAC"));
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (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]);
}
Definitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_LINUX"));
}
}
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)
{
PublicDependencyModuleNames.Add("DeveloperToolSettings");
PrivateDependencyModuleNames.Add("AssetRegistry");
PrivateDependencyModuleNames.Add("Settings");
PrivateDependencyModuleNames.Add("UnrealEd");
}
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;
bool bLinkDebugFiles = false;
if (libPath == null)
{
string platformName = Target.Platform.ToString();
libPath = System.IO.Path.Combine(LibRootDirectory, platformName);
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.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;
bLinkDebugFiles = LinkDebugFiles;
}
// 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[] { "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 (CopyLibs)
{
RuntimeDependencies.Add("$(TargetOutputDir)/" + fmodDllName, fmodDllPath);
RuntimeDependencies.Add("$(TargetOutputDir)/" + fmodStudioDllName, 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("$(TargetOutputDir)/" + plugin + dllExtension, pluginPath);
}
}
else 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 (bLinkDebugFiles)
{
RuntimeDependencies.Add(fmodDllPath + ".debug", StagedFileType.DebugNonUFS);
RuntimeDependencies.Add(fmodStudioDllPath + ".debug", StagedFileType.DebugNonUFS);
}
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 VoxelEditor(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"));
PrivateIncludePaths.Add(Path.Combine(EngineDirectory, "Source/Editor/PropertyEditor/Private"));
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"VoxelGraphEditor",
"AssetRegistry",
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Voxel",
"VoxelGraph",
"VoxelEditorDefault",
"Engine",
"Landscape",
"LandscapeEditor",
"PlacementMode",
"AdvancedPreviewScene",
"DesktopPlatform",
"UnrealEd",
"InputCore",
"ImageWrapper",
"Slate",
"SlateCore",
"PropertyEditor",
"EditorStyle",
"Projects",
"RHI",
"MessageLog",
"RawMesh",
"DetailCustomizations",
"WorkspaceMenuStructure",
"BlueprintGraph",
"KismetCompiler",
"ApplicationCore",
"EngineSettings",
"ToolMenus",
#if UE_4_26_OR_LATER
"DeveloperSettings",
#endif
});
PrivateIncludePathModuleNames.AddRange(
new string[] {
"VoxelGraphEditor"
});
}
public HoudiniEngineRuntime(TargetInfo Target)
{
bool bIsRelease = true;
string HFSPath = "";
string HoudiniVersion = "15.5.579";
// 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 : Compiling on unsupported platform.");
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
if (bIsRelease)
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// We first check if Houdini Engine is installed.
string HPath = "C:/Program Files/Side Effects Software/Houdini Engine " + HoudiniVersion;
if (!Directory.Exists(HPath))
{
// If Houdini Engine is not installed, we check for Houdini installation.
HPath = "C:/Program Files/Side Effects Software/Houdini " + HoudiniVersion;
if (!Directory.Exists(HPath))
{
if (!Directory.Exists(HFSPath))
{
string Err = string.Format("Houdini Engine : Please install Houdini or Houdini Engine {0}", HoudiniVersion);
System.Console.WriteLine(Err);
}
}
else
{
HFSPath = HPath;
}
}
else
{
HFSPath = HPath;
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string HPath = "/Library/Frameworks/Houdini.framework/Versions/" + HoudiniVersion + "/Resources";
if (!Directory.Exists(HPath))
{
if (!Directory.Exists(HFSPath))
{
string Err = string.Format("Houdini Engine : Please install Houdini {0}", HoudiniVersion);
System.Console.WriteLine(Err);
}
}
else
{
HFSPath = HPath;
}
}
else
{
HFSPath = System.Environment.GetEnvironmentVariable("HFS");
System.Console.WriteLine("Linux - found HFS:" + HFSPath);
}
}
string HAPIIncludePath = "";
if (HFSPath != "")
{
HAPIIncludePath = HFSPath + "/toolkit/include/HAPI";
if (Target.Platform == UnrealTargetPlatform.Win64)
{
Definitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath);
}
}
if (HAPIIncludePath != "")
{
PublicIncludePaths.Add(HAPIIncludePath);
// Add the custom include path as well in case the toolkit path doesn't exist yet.
PublicIncludePaths.Add(HFSPath + "/custom/houdini/include/HAPI");
}
PublicIncludePaths.AddRange(
new string[] {
"HoudiniEngineRuntime/Public/HAPI",
"HoudiniEngineRuntime/Public"
}
);
PrivateIncludePaths.AddRange(
new string[] {
"HoudiniEngineRuntime/Private"
}
);
// Add common dependencies.
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"ShaderCore",
"InputCore",
"RHI",
"Settings",
"Foliage",
"Landscape"
}
);
if (UEBuildConfiguration.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"AssetTools",
"UnrealEd",
"Slate",
"SlateCore",
"Projects",
"PropertyEditor",
"ContentBrowser",
"LevelEditor",
"MainFrame",
"EditorStyle",
"EditorWidgets",
"AppFramework",
"TargetPlatform",
"RawMesh",
"DesktopWidgets"
}
);
}
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 UnrealEnginePython(TargetInfo Target)
#endif
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string enableUnityBuild = System.Environment.GetEnvironmentVariable("UEP_ENABLE_UNITY_BUILD");
bFasterWithoutUnity = string.IsNullOrEmpty(enableUnityBuild);
PublicIncludePaths.AddRange(
new string[] {
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"));
PublicLibraryPaths.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/armeabi-v7a"));
PublicAdditionalLibraries.Add("python3.5m");
string APLName = "UnrealEnginePython_APL.xml";
string RelAPLPath = Utils.MakePathRelativeTo(System.IO.Path.Combine(ModuleDirectory, APLName), Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", RelAPLPath);
}
#endif
}
public GameAnalytics(TargetInfo Target)
#endif
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
var GameAnalyticsPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "../ThirdParty/"));
var libPath = Path.Combine(GameAnalyticsPath, "lib");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win64", "GameAnalytics.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win64", "Sqlite.lib"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win32", "GameAnalytics.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win32", "Sqlite.lib"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("Launch");
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private/Android"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "osx", "libGameAnalytics.a"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "osx", "libSqlite.a"));
PublicAdditionalLibraries.Add("curl");
PublicFrameworks.AddRange(
new string[] {
"CoreFoundation",
"Foundation",
"CoreServices"
}
);
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL" });
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "linux", "libGameAnalytics.a"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "linux", "libSqlite.a"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "ios", "libGameAnalytics.a"));
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private/IOS"));
PublicFrameworks.AddRange(
new string[] {
"AdSupport",
"SystemConfiguration",
"AppTrackingTransparency"
}
);
PublicAdditionalLibraries.AddRange(
new string[] {
"sqlite3",
"z",
"c++"
});
}
/*else if(Target.Platform == UnrealTargetPlatform.HTML5)
* {
* if (Target.Architecture != "-win32")
* {
* PublicAdditionalLibraries.Add(Path.Combine(libPath, "html5", "GameAnalytics.jspre"));
* PublicAdditionalLibraries.Add(Path.Combine(libPath, "html5", "GameAnalyticsUnreal.js"));
* }
* }*/
else
{
throw new NotImplementedException("This target platform is not configured for GameAnalytics SDK: " + Target.Platform.ToString());
}
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Private")));
PrivateIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Public")));
PublicIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Public")));
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Analytics",
"Engine"
}
);
/*if (Target.Platform == UnrealTargetPlatform.HTML5)
* {
* PrivateDependencyModuleNames.AddRange(
* new string[]
* {
* "Json"
* }
* );
*
* PublicIncludePathModuleNames.AddRange(
* new string[]
* {
* "Json"
* }
* );
* }*/
PublicIncludePathModuleNames.AddRange(
new string[]
{
"Analytics",
"Engine"
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "GameAnalytics_APL.xml"));
}
}
public libWebSockets(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string WebsocketPath = Path.Combine(Target.UEThirdPartySourceDirectory, "libWebSockets", "libwebsockets");
string PlatformSubdir = Target.Platform.ToString();
bool bUseDebugBuild = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT);
string ConfigurationSubdir = bUseDebugBuild ? "Debug" : "Release";
switch (Target.Platform)
{
case UnrealTargetPlatform.HTML5:
return;
case UnrealTargetPlatform.Win64:
case UnrealTargetPlatform.Win32:
PlatformSubdir = Path.Combine(PlatformSubdir, "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName());
PublicAdditionalLibraries.Add("websockets_static.lib");
break;
case UnrealTargetPlatform.Mac:
case UnrealTargetPlatform.IOS:
PublicAdditionalLibraries.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), ConfigurationSubdir, "libwebsockets.a"));
break;
case UnrealTargetPlatform.PS4:
PublicAdditionalLibraries.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), ConfigurationSubdir, "libwebsockets.a"));
break;
case UnrealTargetPlatform.Switch:
PublicAdditionalLibraries.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), ConfigurationSubdir, "libwebsockets.a"));
break;
case UnrealTargetPlatform.Android:
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir, "ARMv7"));
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), "ARMv7", ConfigurationSubdir));
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir, "ARM64"));
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), "ARM64", ConfigurationSubdir));
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir, "x86"));
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), "x86", ConfigurationSubdir));
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir, "x64"));
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", Target.Platform.ToString(), "x64", ConfigurationSubdir));
PublicAdditionalLibraries.Add("websockets");
break;
default:
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PlatformSubdir = "Linux/" + Target.Architecture;
PublicAdditionalLibraries.Add(Path.Combine(WebsocketPath, "lib", PlatformSubdir, ConfigurationSubdir, "libwebsockets.a"));
break;
}
return;
}
if (Target.Platform != UnrealTargetPlatform.Android)
{
PublicLibraryPaths.Add(Path.Combine(WebsocketPath, "lib", PlatformSubdir, ConfigurationSubdir));
}
PublicIncludePaths.Add(Path.Combine(WebsocketPath, "include", PlatformSubdir));
if (Target.Platform != UnrealTargetPlatform.Switch)
{
PublicDependencyModuleNames.Add("OpenSSL");
}
}
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");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Networking",
"Sockets",
"RHI",
#if UE_4_23_OR_LATER
"PhysicsCore",
#endif
"RenderCore",
"Landscape",
"PhysX",
}
);
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\")");
}
public AkAudio(TargetInfo Target)
{
PrivateIncludePathModuleNames.Add("Settings");
PrivateIncludePaths.AddRange(
new string[] {
"AkAudio/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine"
});
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"SlateCore",
"NetworkReplayStreaming"
});
string akDir = Path.GetFullPath(Path.Combine(ModuleDirectory, "../../ThirdParty"));
string akPlatformLibDir = "";
Definitions.Add("USE_AKAUDIO");
PublicIncludePaths.AddRange(
new string[] {
// SDK includes
Path.Combine(akDir, "include"),
Path.Combine(akDir, "samples" + Path.DirectorySeparatorChar + "SoundEngine" + Path.DirectorySeparatorChar + "Common"),
Path.Combine(akDir, "samples" + Path.DirectorySeparatorChar + "SoundEngine")
}
);
// Uncomment this line to use the UE4 I/O system
Definitions.Add("AK_USE_UNREAL_IO");
// These definitions can be set as platform-specific.
Definitions.Add("AK_UNREAL_MAX_CONCURRENT_IO=8");
Definitions.Add("AK_UNREAL_IO_GRANULARITY=32768");
string samplesSoundEngineBasePath = Path.Combine(akDir, "samples" + Path.DirectorySeparatorChar + "SoundEngine");
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
string VSVersion;
switch (WindowsPlatform.Compiler)
{
case WindowsCompiler.VisualStudio2012:
VSVersion = "vc110";
break;
case WindowsCompiler.VisualStudio2013:
VSVersion = "vc120";
break;
case WindowsCompiler.VisualStudio2015:
default:
VSVersion = "vc140";
break;
}
akPlatformLibDir = (Target.Platform == UnrealTargetPlatform.Win32) ? "Win32_" : "x64_";
akPlatformLibDir += VSVersion;
string LibFolder = (Target.Platform == UnrealTargetPlatform.Win32) ? "x86" : "x64";
PublicLibraryPaths.Add("$(DXSDK_DIR)" + Path.DirectorySeparatorChar + "Lib" + Path.DirectorySeparatorChar + LibFolder);
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "Win32"));
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
string VSVersion = "vc140";
// Use reflection because the GitHub version of UE is missing things.
Type XboxOnePlatformType = System.Type.GetType("XboxOnePlatform", false);
if (XboxOnePlatformType != null)
{
System.Reflection.FieldInfo XboxOneCompilerField = XboxOnePlatformType.GetField("Compiler");
if (XboxOneCompilerField != null)
{
var XboxOneCompilerValue = XboxOneCompilerField.GetValue(null);
if (XboxOneCompilerValue.ToString() == "VisualStudio2012")
{
VSVersion = "vc110";
}
}
}
akPlatformLibDir = "XboxOne_" + VSVersion;
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "Win32"));
Definitions.Add("_XBOX_ONE");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
akPlatformLibDir = "Linux_x64";
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "POSIX"));
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "Common"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
akPlatformLibDir = "Mac";
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "POSIX"));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
akPlatformLibDir = "iOS";
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "POSIX"));
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
akPlatformLibDir = "PS4";
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "PS4"));
Definitions.Add("__ORBIS__");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
akPlatformLibDir = "android-9_armeabi-v7a";
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "Android"));
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "POSIX"));
Definitions.Add("__ANDROID__");
}
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
if (UEBuildConfiguration.bBuildEditor == true)
{
// Sound frame is required for enabling communication between Wwise Application and the unreal editor.
// Not to be defined in shipping mode.
Definitions.Add("AK_SOUNDFRAME");
}
PublicAdditionalLibraries.Add("dsound.lib");
PublicAdditionalLibraries.Add("dxguid.lib");
PublicAdditionalLibraries.Add("AkMP3Source.lib");
PublicAdditionalLibraries.Add("Msacm32.lib");
PublicAdditionalLibraries.Add("XInput.lib");
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PublicAdditionalLibraries.Add("AcpHal.lib");
PublicAdditionalLibraries.Add("MMDevApi.lib");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicAdditionalLibraries.Add("SceAjm_stub_weak");
PublicAdditionalLibraries.Add("SceAudio3d_stub_weak");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
// We don't seem to need more libs for Android...
}
if (Target.Configuration == UnrealTargetConfiguration.Shipping)
{
Definitions.Add("AK_OPTIMIZED");
}
string akConfigurationDir;
if (Target.Configuration == UnrealTargetConfiguration.Debug)
{
// change bDebugBuildsActuallyUseDebugCRT to true in BuildConfiguration.cs to actually link debug binaries
if (!BuildConfiguration.bDebugBuildsActuallyUseDebugCRT)
{
akConfigurationDir = "Profile";
}
else
{
akConfigurationDir = "Debug";
}
}
else if (Target.Configuration == UnrealTargetConfiguration.Development ||
Target.Configuration == UnrealTargetConfiguration.Test ||
Target.Configuration == UnrealTargetConfiguration.DebugGame)
{
akConfigurationDir = "Profile";
}
else // if (Target.Configuration == UnrealTargetConfiguration.Shipping)
{
akConfigurationDir = "Release";
}
if (Target.Platform == UnrealTargetPlatform.IOS)
{
akConfigurationDir += "-iphoneos";
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
// No profiler support in the cross-compile toolchain.
akConfigurationDir = "Release";
}
akLibPath = Path.Combine(Path.Combine(Path.Combine(akDir, akPlatformLibDir), akConfigurationDir), "lib");
PublicLibraryPaths.Add(akLibPath);
if (Target.Platform == UnrealTargetPlatform.Android)
{
// Toolchain will filter properly, add other Android arches here
PublicLibraryPaths.Add(Path.Combine(Path.Combine(akDir, "android-9_x86"), akConfigurationDir));
}
AddWwiseLib(Target, "AkSoundEngine");
AddWwiseLib(Target, "AkMemoryMgr");
AddWwiseLib(Target, "AkStreamMgr");
AddWwiseLib(Target, "AkMusicEngine");
AddWwiseLib(Target, "AkVorbisDecoder");
AddWwiseLib(Target, "AkSilenceSource");
AddWwiseLib(Target, "AkSineSource");
AddWwiseLib(Target, "AkToneSource");
AddWwiseLib(Target, "AkPeakLimiterFX");
AddWwiseLib(Target, "AkMatrixReverbFX");
AddWwiseLib(Target, "AkParametricEQFX");
AddWwiseLib(Target, "AkDelayFX");
AddWwiseLib(Target, "AkExpanderFX");
AddWwiseLib(Target, "AkFlangerFX");
AddWwiseLib(Target, "AkCompressorFX");
AddWwiseLib(Target, "AkGainFX");
AddWwiseLib(Target, "AkHarmonizerFX");
AddWwiseLib(Target, "AkTimeStretchFX");
AddWwiseLib(Target, "AkPitchShifterFX");
AddWwiseLib(Target, "AkStereoDelayFX");
AddWwiseLib(Target, "AkMeterFX");
AddWwiseLib(Target, "AkGuitarDistortionFX");
AddWwiseLib(Target, "AkTremoloFX");
AddWwiseLib(Target, "AkRoomVerbFX");
AddWwiseLib(Target, "AkAudioInputSource");
AddWwiseLib(Target, "AkSynthOne");
AddWwiseLib(Target, "AkConvolutionReverbFX");
if ((Target.Platform != UnrealTargetPlatform.Android) && (Target.Platform != UnrealTargetPlatform.Linux) && (Target.Platform != UnrealTargetPlatform.Mac) && (Target.Platform != UnrealTargetPlatform.IOS))
{
AddWwiseLib(Target, "AkMotionGenerator");
AddWwiseLib(Target, "AkRumble");
}
if (Target.Platform == UnrealTargetPlatform.PS4)
{
AddWwiseLib(Target, "SceAudio3dEngine");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalFrameworks.Add(new UEBuildFramework("AudioUnit"));
PublicAdditionalFrameworks.Add(new UEBuildFramework("AudioToolbox"));
PublicAdditionalFrameworks.Add(new UEBuildFramework("CoreAudio"));
AddWwiseLib(Target, "AkAACDecoder");
}
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalFrameworks.Add(new UEBuildFramework("AudioToolbox"));
PublicAdditionalFrameworks.Add(new UEBuildFramework("CoreAudio"));
AddWwiseLib(Target, "AkAACDecoder");
}
if (Definitions.Contains("AK_OPTIMIZED") == false && Target.Platform != UnrealTargetPlatform.Linux)
{
AddWwiseLib(Target, "CommunicationCentral");
}
// SoundFrame libs
if (Definitions.Contains("AK_SOUNDFRAME") == true)
{
PublicAdditionalLibraries.Add("SFLib.lib");
}
// If AK_SOUNDFRAME is defined, make UnrealEd a dependency
if (UEBuildConfiguration.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("SlateCore");
PrivateDependencyModuleNames.Add("Slate");
PrivateDependencyModuleNames.Add("UnrealEd");
}
}
public Core(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/CorePrivatePCH.h";
SharedPCHHeaderFile = "Public/CoreSharedPCH.h";
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 (UEBuildConfiguration.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",
"XInput"
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicIncludePaths.AddRange(new string[] { "Runtime/Core/Public/Apple", "Runtime/Core/Public/Mac" });
AddEngineThirdPartyPrivateStaticDependencies(Target,
"IntelTBB",
"zlib",
"OpenGL",
"PLCrashReporter"
);
PublicFrameworks.AddRange(new string[] { "Cocoa", "Carbon", "IOKit", "Security" });
if (UEBuildConfiguration.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" });
}
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",
"SDL2"
);
// Core uses dlopen()
PublicAdditionalLibraries.Add("dl");
// We need FreeType2 and GL for the Splash, but only in the Editor
if (Target.Type == TargetType.Editor)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "FreeType2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
PrivateIncludePathModuleNames.Add("ImageWrapper");
}
}
else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
PublicIncludePaths.Add("Runtime/Core/Public/HTML5");
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenAL");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
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 (UEBuildConfiguration.bCompileICU == true)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "ICU");
}
Definitions.Add("UE_ENABLE_ICU=" + (UEBuildConfiguration.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 (UEBuildConfiguration.bCompileAgainstEngine == true)
{
if (!UEBuildConfiguration.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);
Definitions.Add("WITH_VS_PERF_PROFILER=1");
}
else
{
Definitions.Add("WITH_VS_PERF_PROFILER=0");
}
}
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
WhitelistRestrictedFolders.Add("Private/Windows/NoRedist");
}
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
Definitions.Add("WITH_DIRECTXMATH=1");
}
else if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
// To enable this requires Win8 SDK
Definitions.Add("WITH_DIRECTXMATH=0"); // Enable to test on Win64/32.
//PublicDependencyModuleNames.AddRange( // Enable to test on Win64/32.
// new string[] {
// "DirectXMath"
//});
}
else
{
Definitions.Add("WITH_DIRECTXMATH=0");
}
}
public DevToDev(ReadOnlyTargetRules Target) : base(Target)
{
var ModulePath = ModuleDirectory;
switch (Target.Platform)
{
case UnrealTargetPlatform.IOS:
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"devtodev",
"../../ThirdParty/iOS/devtodev.embeddedframework.zip"
)
);
PublicFrameworks.AddRange(
new string[] {
"UIKit",
"Foundation",
"AdSupport",
"StoreKit",
"CoreGraphics",
"Security",
"SystemConfiguration",
"UserNotifications"
}
);
PublicAdditionalLibraries.AddRange(
new string[] {
"z",
"c++"
});
break;
case UnrealTargetPlatform.Android:
case UnrealTargetPlatform.XboxOne:
case UnrealTargetPlatform.PS4:
case UnrealTargetPlatform.HTML5:
case UnrealTargetPlatform.Linux:
case UnrealTargetPlatform.Win64:
case UnrealTargetPlatform.Win32:
case UnrealTargetPlatform.Mac:
default:
break;
// throw new NotImplementedException("This target platform is not supported for devtodev SDK: " + Target.Platform.ToString());
}
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine"
}
);
PrivateIncludePaths.Add(Path.GetFullPath(Path.Combine(ModulePath, "Private")));
PrivateIncludePaths.Add(Path.GetFullPath(Path.Combine(ModulePath, "Public")));
PublicIncludePaths.Add(Path.GetFullPath(Path.Combine(ModulePath, "Public")));
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Analytics",
"AnalyticsBlueprintLibrary"
}
);
PublicIncludePathModuleNames.AddRange(
new string[]
{
"Analytics",
"AnalyticsBlueprintLibrary"
}
);
}
public UnrealFrontend(TargetInfo Target)
{
PublicIncludePaths.Add("Runtime/Launch/Public");
PrivateIncludePaths.AddRange(
new string[] {
"Programs/UnrealFrontend/Private",
"Programs/UnrealFrontend/Private/Commands",
"Runtime/Launch/Private", // for LaunchEngineLoop.cpp include
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AutomationController",
"Core",
"CoreUObject",
"DeviceManager",
"LauncherServices",
"Messaging",
"Profiler",
"ProfilerClient",
"ProjectLauncher",
"Projects",
"SessionFrontend",
"SessionServices",
"Slate",
"SlateCore",
"SourceCodeAccess",
"StandaloneRenderer",
"TargetDeviceServices",
"TargetPlatform",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PrivateDependencyModuleNames.Add("XCodeSourceCodeAccess");
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.Add("VisualStudioSourceCodeAccess");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"LinuxCommonStartup"
}
);
}
// @todo: allow for better plug-in support in standalone Slate apps
PrivateDependencyModuleNames.AddRange(
new string[] {
"Networking",
"Sockets",
"UdpMessaging",
"TcpMessaging",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Messaging",
}
);
}
public SpeedTree(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
var bPlatformAllowed = ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Mac) || Target.IsInPlatformGroup(UnrealPlatformGroup.Unix));
if (bPlatformAllowed &&
Target.bCompileSpeedTree)
{
PublicDefinitions.Add("WITH_SPEEDTREE=1");
PublicDefinitions.Add("SPEEDTREE_KEY=INSERT_KEY_HERE");
string SpeedTreePath = Target.UEThirdPartySourceDirectory + "SpeedTree/SpeedTreeSDK-v7.0/";
PublicIncludePaths.Add(SpeedTreePath + "Include");
string SpeedTree8Path = Target.UEThirdPartySourceDirectory + "SpeedTree/SpeedTree8/";
PublicIncludePaths.Add(SpeedTree8Path);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
if (Target.WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2015 || Target.WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2017)
{
PublicLibraryPaths.Add(SpeedTreePath + "Lib/Windows/VC14.x64");
if (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT)
{
PublicAdditionalLibraries.Add("SpeedTreeCore_Windows_v7.0_VC14_MTDLL64_Static_d.lib");
}
else
{
PublicAdditionalLibraries.Add("SpeedTreeCore_Windows_v7.0_VC14_MTDLL64_Static.lib");
}
}
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
if (Target.WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2015 || Target.WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2017)
{
PublicLibraryPaths.Add(SpeedTreePath + "Lib/Windows/VC14");
if (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT)
{
PublicAdditionalLibraries.Add("SpeedTreeCore_Windows_v7.0_VC14_MTDLL_Static_d.lib");
}
else
{
PublicAdditionalLibraries.Add("SpeedTreeCore_Windows_v7.0_VC14_MTDLL_Static.lib");
}
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicLibraryPaths.Add(SpeedTreePath + "Lib/MacOSX");
if (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT)
{
PublicAdditionalLibraries.Add(SpeedTreePath + "Lib/MacOSX/Debug/libSpeedTreeCore.a");
}
else
{
PublicAdditionalLibraries.Add(SpeedTreePath + "Lib/MacOSX/Release/libSpeedTreeCore.a");
}
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
if (Target.LinkType == TargetLinkType.Monolithic)
{
PublicAdditionalLibraries.Add(SpeedTreePath + "Lib/Linux/" + Target.Architecture + "/Release/libSpeedTreeCore.a");
}
else
{
PublicAdditionalLibraries.Add(SpeedTreePath + "Lib/Linux/" + Target.Architecture + "/Release/libSpeedTreeCore_fPIC.a");
}
}
}
}
public Noesis(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string NoesisBasePath = Path.Combine(ModuleDirectory, "NoesisSDK");
string NoesisIncludePath = Path.Combine(NoesisBasePath, "Include");
string NoesisInteractivityIncludePath = Path.Combine(NoesisBasePath, "Src", "Packages", "App", "Interactivity", "Include");
string NoesisMediaElementIncludePath = Path.Combine(NoesisBasePath, "Src", "Packages", "App", "MediaElement", "Include");
// In monolithic builds we don't want the Interactivity and MediaElement functions
// dllexported or dllimported from any modules.
// That's why we use PublicDefinitions.
if (Target.LinkType == TargetLinkType.Monolithic)
{
PublicDefinitions.Add("NS_APP_INTERACTIVITY_API=");
PublicDefinitions.Add("NS_APP_MEDIAELEMENT_API=");
}
PublicIncludePaths.Add(ModuleDirectory);
PublicIncludePaths.Add(NoesisIncludePath);
PublicIncludePaths.Add(NoesisInteractivityIncludePath);
PublicIncludePaths.Add(NoesisMediaElementIncludePath);
if (!Directory.Exists(NoesisBasePath))
{
throw new BuildException("Could not find NoesisGUI SDK in " + NoesisBasePath + ".");
}
if (!Directory.Exists(NoesisIncludePath))
{
throw new BuildException("Could not find NoesisGUI SDK Include directory in " + NoesisIncludePath);
}
PublicSystemIncludePaths.Add(NoesisIncludePath);
UnrealTargetPlatform Platform;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Lib", "windows_x86_64", "Noesis.lib"));
string NoesisDllPath = Path.Combine(NoesisBasePath, "Bin", "windows_x86_64", "Noesis.dll");
string NoesisDllTargetPath = Path.Combine("$(BinaryOutputDir)", "Noesis.dll");
RuntimeDependencies.Add(NoesisDllTargetPath, NoesisDllPath, StagedFileType.NonUFS);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
string NoesisSoName = "libNoesis.so";
string NoesisSoPath = Path.Combine(NoesisBasePath, "Bin", "linux_x86_64", NoesisSoName);
PublicAdditionalLibraries.Add(NoesisSoPath);
string NoesisSoTargetPath = Path.Combine("$(BinaryOutputDir)", NoesisSoName);
RuntimeDependencies.Add(NoesisSoTargetPath, NoesisSoPath, StagedFileType.NonUFS);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Bin", "macos", "Noesis.dylib"));
string NoesisDylibPath = Path.Combine("NoesisSDK", "Bin", "macos", "Noesis.dylib");
RuntimeDependencies.Add(Path.Combine(ModuleDirectory, NoesisDylibPath));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicDefinitions.Add("NS_STATIC_LIBRARY");
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Lib", "ios", "libNoesis.a"));
PublicFrameworks.Add("CoreText");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Bin", "android_arm", "libNoesis.so"));
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Bin", "android_arm64", "libNoesis.so"));
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Bin", "android_x86", "libNoesis.so"));
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Bin", "android_x86_64", "libNoesis.so"));
string NoesisAplPath = "Noesis_APL.xml";
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(ModuleDirectory, NoesisAplPath));
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicDefinitions.Add("NS_STATIC_LIBRARY");
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Lib", "ps4", "Noesis.a"));
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Lib", "xbox_one", "Noesis.lib"));
string NoesisDllPath = Path.Combine(NoesisBasePath, "Bin", "xbox_one", "Noesis.dll");
string NoesisDllTargetPath = Path.Combine("$(BinaryOutputDir)", "Noesis.dll");
RuntimeDependencies.Add(NoesisDllTargetPath, NoesisDllPath, StagedFileType.NonUFS);
}
else if (UnrealTargetPlatform.TryParse("HTML5", out Platform) && Target.Platform == Platform)
{
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Bin", "wasm", "Noesis.bc"));
}
}
public glTFForUE4(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseSharedPCHs;
PrivateIncludePaths.AddRange(new [] {
"glTFForUE4/Private",
});
PublicDependencyModuleNames.AddRange(new [] {
"Core",
});
PrivateDependencyModuleNames.AddRange(new [] {
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"InputCore",
"AssetRegistry",
});
string ExtraPathRoot = System.IO.Path.Combine(ModuleDirectory, "..", "..", "Extras");
// libgltf
{
string glTFPath = System.IO.Path.Combine(ExtraPathRoot, "libgltf_ue4", "libgltf-0.1.3");
string IncludePath = System.IO.Path.Combine(glTFPath, "include");
string LibPath = "";
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 VSName = "vs" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
LibPath = System.IO.Path.Combine(glTFPath, "lib", PlatformName, VSName);
LibFilePath = System.IO.Path.Combine(LibPath, "libgltf.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
LibPath = System.IO.Path.Combine(glTFPath, "lib", "linux");
LibFilePath = System.IO.Path.Combine(LibPath, "libgltf.a");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
LibPath = System.IO.Path.Combine(glTFPath, "lib", "macos");
LibFilePath = System.IO.Path.Combine(LibPath, "libgltf.a");
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
LibPath = System.IO.Path.Combine(glTFPath, "lib", "ios");
LibFilePath = System.IO.Path.Combine(LibPath, "libgltf.a");
}
PublicIncludePaths.Add(IncludePath);
PublicLibraryPaths.Add(LibPath);
PublicAdditionalLibraries.Add(LibFilePath);
}
// libdraco
{
string DracoPath = System.IO.Path.Combine(ExtraPathRoot, "libdraco_ue4", "libdraco-1.2.5");
string IncludePath = System.IO.Path.Combine(DracoPath, "include");
string LibPath = "";
string LibFilePath1 = "";
string LibFilePath2 = "";
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 VSName = "vs" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
LibPath = System.IO.Path.Combine(DracoPath, "lib", PlatformName, VSName);
LibFilePath1 = System.IO.Path.Combine(LibPath, "dracodec.lib");
LibFilePath2 = System.IO.Path.Combine(LibPath, "dracoenc.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
LibPath = System.IO.Path.Combine(DracoPath, "lib", "linux");
LibFilePath1 = System.IO.Path.Combine(LibPath, "libdracodec.a");
LibFilePath2 = System.IO.Path.Combine(LibPath, "libdracoenc.a");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
LibPath = System.IO.Path.Combine(DracoPath, "lib", "macos");
LibFilePath1 = System.IO.Path.Combine(LibPath, "libdracodec.a");
LibFilePath2 = System.IO.Path.Combine(LibPath, "libdracoenc.a");
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
LibPath = System.IO.Path.Combine(DracoPath, "lib", "ios");
LibFilePath1 = System.IO.Path.Combine(LibPath, "libdracodec.a");
LibFilePath2 = System.IO.Path.Combine(LibPath, "libdracoenc.a");
}
PublicIncludePaths.Add(IncludePath);
PublicLibraryPaths.Add(LibPath);
PublicAdditionalLibraries.Add(LibFilePath1);
PublicAdditionalLibraries.Add(LibFilePath2);
}
}
public SmartsuitEditor(ReadOnlyTargetRules Target) : base(Target)
{
MinFilesUsingPrecompiledHeaderOverride = 1;
//bFasterWithoutUnity = true;
bUseUnity = false;
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public"));
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Private"));
// PublicIncludePaths.AddRange(
// new string[] {
// "SmartsuitEditor/Public",
// // ... add public include paths required here ...
//}
// );
// PrivateIncludePaths.AddRange(
// new string[] {
// "SmartsuitEditor/Private",
// // ... add other private include paths required here ...
//}
// );
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"AnimGraph",
"BlueprintGraph",
"AnimGraphRuntime",
"Smartsuit",
"LiveLinkInterface"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd",
"GraphEditor",
"SlateCore",
"Slate",
"LiveLinkInterface",
"ToolMenus"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public UElibPNG(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string libPNGPath = Target.UEThirdPartySourceDirectory + "libPNG/libPNG-1.5.2";
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string LibPath = libPNGPath + "/lib/Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
PublicLibraryPaths.Add(LibPath);
string LibFileName = "libpng" + (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT ? "d" : "") + "_64.lib";
PublicAdditionalLibraries.Add(LibFileName);
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
libPNGPath = libPNGPath + "/lib/Win32/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
PublicLibraryPaths.Add(libPNGPath);
string LibFileName = "libpng" + (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT ? "d" : "") + ".lib";
PublicAdditionalLibraries.Add(LibFileName);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(libPNGPath + "/lib/Mac/libpng.a");
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
if (Target.Architecture == "-simulator")
{
PublicLibraryPaths.Add(libPNGPath + "/lib/ios/Simulator");
PublicAdditionalShadowFiles.Add(Target.UEThirdPartySourceDirectory + "libPNG/libPNG-1.5.2/lib/ios/Simulator/libpng152.a");
}
else
{
PublicLibraryPaths.Add(libPNGPath + "/lib/ios/Device");
PublicAdditionalShadowFiles.Add(Target.UEThirdPartySourceDirectory + "libPNG/libPNG-1.5.2/lib/ios/Device/libpng152.a");
}
PublicAdditionalLibraries.Add("png152");
}
else if (Target.Platform == UnrealTargetPlatform.TVOS)
{
if (Target.Architecture == "-simulator")
{
PublicLibraryPaths.Add(libPNGPath + "/lib/TVOS/Simulator");
PublicAdditionalShadowFiles.Add(Target.UEThirdPartySourceDirectory + "libPNG/libPNG-1.5.2/lib/TVOS/Simulator/libpng152.a");
}
else
{
PublicLibraryPaths.Add(libPNGPath + "/lib/TVOS/Device");
PublicAdditionalShadowFiles.Add(Target.UEThirdPartySourceDirectory + "libPNG/libPNG-1.5.2/lib/TVOS/Device/libpng152.a");
}
PublicAdditionalLibraries.Add("png152");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
libPNGPath = Target.UEThirdPartySourceDirectory + "libPNG/libPNG-1.5.27";
PublicLibraryPaths.Add(libPNGPath + "/lib/Android/ARMv7");
PublicLibraryPaths.Add(libPNGPath + "/lib/Android/ARM64");
PublicLibraryPaths.Add(libPNGPath + "/lib/Android/x86");
PublicLibraryPaths.Add(libPNGPath + "/lib/Android/x64");
PublicAdditionalLibraries.Add("png");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
// migrate all architectures to the newer binary
if (Target.Architecture.StartsWith("aarch64") || Target.Architecture.StartsWith("i686"))
{
libPNGPath = Target.UEThirdPartySourceDirectory + "libPNG/libPNG-1.5.27";
}
PublicAdditionalLibraries.Add(libPNGPath + "/lib/Linux/" + Target.Architecture + "/libpng.a");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PublicLibraryPaths.Add(libPNGPath + "/lib/HTML5");
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(libPNGPath + "/lib/HTML5/libpng" + OpimizationSuffix + ".bc");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicLibraryPaths.Add(libPNGPath + "/lib/PS4");
PublicAdditionalLibraries.Add("png152");
}
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(libPNGPath + "/lib/XboxOne/VS" + VersionName.ToString());
PublicAdditionalLibraries.Add("libpng125_XboxOne.lib");
}
}
else if (Target.Platform == UnrealTargetPlatform.Switch)
{
PublicAdditionalLibraries.Add(System.IO.Path.Combine(libPNGPath, "lib/Switch/libPNG.a"));
}
PublicIncludePaths.Add(libPNGPath);
}
public zlib(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string zlibPath = Target.UEThirdPartySourceDirectory + "zlib/v1.2.8/";
// TODO: recompile for consoles and mobile platforms
string OldzlibPath = Target.UEThirdPartySourceDirectory + "zlib/zlib-1.2.5/";
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string platform = "/Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
PublicIncludePaths.Add(zlibPath + "include" + platform);
PublicLibraryPaths.Add(zlibPath + "lib" + platform);
PublicAdditionalLibraries.Add("zlibstatic.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
string platform = "/Win32/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
PublicIncludePaths.Add(zlibPath + "include" + platform);
PublicLibraryPaths.Add(zlibPath + "lib" + platform);
PublicAdditionalLibraries.Add("zlibstatic.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string platform = "/Mac/";
PublicIncludePaths.Add(zlibPath + "include" + platform);
// OSX needs full path
PublicAdditionalLibraries.Add(zlibPath + "lib" + platform + "libz.a");
}
else if (Target.Platform == UnrealTargetPlatform.IOS ||
Target.Platform == UnrealTargetPlatform.TVOS)
{
PublicIncludePaths.Add(OldzlibPath + "Inc");
PublicAdditionalLibraries.Add("z");
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
PublicIncludePaths.Add(OldzlibPath + "Inc");
PublicAdditionalLibraries.Add("z");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
string OpimizationSuffix = "";
if (Target.bCompileForSize)
{
OpimizationSuffix = "_Oz";
}
else
{
if (Target.Configuration == UnrealTargetConfiguration.Development)
{
OpimizationSuffix = "_O2";
}
else if (Target.Configuration == UnrealTargetConfiguration.Shipping)
{
OpimizationSuffix = "_O3";
}
}
PublicIncludePaths.Add(OldzlibPath + "Inc");
PublicAdditionalLibraries.Add(OldzlibPath + "Lib/HTML5/zlib" + OpimizationSuffix + ".bc");
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
string platform = "/Linux/" + Target.Architecture;
PublicIncludePaths.Add(zlibPath + "include" + platform);
PublicAdditionalLibraries.Add(zlibPath + "/lib/" + platform + ((Target.LinkType == TargetLinkType.Monolithic) ? "/libz" : "/libz_fPIC") + ".a");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicIncludePaths.Add(OldzlibPath + "Inc");
PublicLibraryPaths.Add(OldzlibPath + "Lib/PS4");
PublicAdditionalLibraries.Add("z");
}
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);
PublicIncludePaths.Add(OldzlibPath + "Inc");
PublicLibraryPaths.Add(OldzlibPath + "Lib/XboxOne/VS" + VersionName.ToString());
PublicAdditionalLibraries.Add("zlib125_XboxOne.lib");
}
}
else if (Target.Platform == UnrealTargetPlatform.Switch)
{
PublicIncludePaths.Add(OldzlibPath + "inc");
PublicAdditionalLibraries.Add(System.IO.Path.Combine(OldzlibPath, "Lib/Switch/libz.a"));
}
}
public UnrealEnginePython(TargetInfo Target)
#endif
{
PCHUsage = PCHUsageMode.NoSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"UnrealEnginePython/Public",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"UnrealEnginePython/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Sockets",
"Networking"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"MovieScene",
"LevelSequence",
"HTTP",
"UMG",
"AppFramework",
"RHI",
"Voice",
"RenderCore",
"MovieSceneCapture",
"Landscape",
"Foliage",
// ... add private dependencies that you statically link with here ...
}
);
#if WITH_FORWARDED_MODULE_RULES_CTOR
BuildVersion Version;
if (BuildVersion.TryRead(BuildVersion.GetDefaultFileName(), out Version))
{
if (Version.MinorVersion >= 18)
{
PrivateDependencyModuleNames.Add("ApplicationCore");
}
}
#endif
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
#if WITH_FORWARDED_MODULE_RULES_CTOR
if (Target.bBuildEditor)
#else
if (UEBuildConfiguration.bBuildEditor)
#endif
{
PrivateDependencyModuleNames.AddRange(new string[] {
"UnrealEd",
"LevelEditor",
"BlueprintGraph",
"Projects",
"Sequencer",
"SequencerWidgets",
"AssetTools",
"LevelSequenceEditor",
"MovieSceneTools",
"MovieSceneTracks",
"CinematicCamera",
"EditorStyle",
"GraphEditor",
"UMGEditor",
"AIGraph",
"RawMesh",
"DesktopWidgets",
"EditorWidgets",
"FBX",
"Persona",
"PropertyEditor",
"LandscapeEditor",
"MaterialEditor"
});
}
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(windowsKnownPaths);
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetWindowsPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicAdditionalLibraries.Add(libPath);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(macKnownPaths);
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetMacPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicDelayLoadDLLs.Add(libPath);
PublicDefinitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_MAC"));
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (pythonHome == "")
{
string includesPath = DiscoverLinuxPythonIncludesPath();
if (includesPath == null)
{
throw new System.Exception("Unable to find Python includes, please add a search path to linuxKnownIncludesPaths");
}
string libsPath = DiscoverLinuxPythonLibsPath();
if (libsPath == null)
{
throw new System.Exception("Unable to find Python libs, please add a search path to linuxKnownLibsPaths");
}
PublicIncludePaths.Add(includesPath);
PublicAdditionalLibraries.Add(libsPath);
}
else
{
string[] items = pythonHome.Split(';');
PublicIncludePaths.Add(items[0]);
PublicAdditionalLibraries.Add(items[1]);
}
PublicDefinitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_LINUX"));
}
string enableThreads = System.Environment.GetEnvironmentVariable("UEP_ENABLE_THREADS");
if (!string.IsNullOrEmpty(enableThreads))
{
PublicDefinitions.Add("UEPY_THREADING");
System.Console.WriteLine("*** Enabled Python Threads support ***");
}
}
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 AirSim(ReadOnlyTargetRules Target) : base(Target)
{
//bEnforceIWYU = true; //to support 4.16
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
bEnableExceptions = true;
bUseRTTI = true;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "ImageWrapper", "RenderCore", "RHI", "PhysXVehicles", "ProceduralMeshComponent", "Landscape", "XmlParser", "APEX", "PhysX", "PhysXVehicleLib", "Foliage" });
PrivateDependencyModuleNames.AddRange(new string[] { "ProceduralMeshComponent", "UMG", "Slate", "SlateCore", "PhysX", "PhysXVehicles", "PhysXVehicleLib", "ProceduralMeshComponent" });
//suppress VC++ proprietary warnings
Definitions.Add("_SCL_SECURE_NO_WARNINGS=1");
Definitions.Add("_CRT_SECURE_NO_WARNINGS=1");
Definitions.Add("HMD_MODULE_INCLUDED=0");
PublicIncludePaths.Add(Path.Combine(AirLibPath, "include"));
PublicIncludePaths.Add(Path.Combine(AirLibPath, "deps", "eigen3"));
AddOSLibDependencies(Target);
//Type = ModuleType.External;
string VHACDDirectory = Target.UEThirdPartySourceDirectory + "VHACD/";
string VHACDLibPath = VHACDDirectory;
PublicIncludePaths.Add(VHACDDirectory + "public");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
VHACDLibPath = VHACDLibPath + "lib/Win64/VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName() + "/";
PublicLibraryPaths.Add(VHACDLibPath);
if (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT)
{
PublicAdditionalLibraries.Add("VHACDd.lib");
}
else
{
PublicAdditionalLibraries.Add("VHACD.lib");
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string LibPath = VHACDDirectory + "Lib/Mac/";
if (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT)
{
PublicAdditionalLibraries.Add(LibPath + "libVHACD_LIBd.a");
}
else
{
PublicAdditionalLibraries.Add(LibPath + "libVHACD_LIB.a");
}
PublicFrameworks.AddRange(new string[] { "OpenCL" });
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (Target.LinkType == TargetLinkType.Monolithic)
{
PublicAdditionalLibraries.Add(VHACDDirectory + "Lib/Linux/" + Target.Architecture + "/libVHACD.a");
}
else
{
PublicAdditionalLibraries.Add(VHACDDirectory + "Lib/Linux/" + Target.Architecture + "/libVHACD_fPIC.a");
}
}
SetupCompileMode(CompileMode.CppCompileWithRpc, Target);
}
public AlembicLib(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac)
{
bool bDebug = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT);
string LibDir = ModuleDirectory + "/Deploy/lib/";
string Platform;
bool bAllowDynamicLibs = true;
switch (Target.Platform)
{
case UnrealTargetPlatform.Win64:
Platform = "x64";
LibDir += "VS" + WindowsPlatform.GetVisualStudioCompilerVersionName() + "/";
break;
case UnrealTargetPlatform.Win32:
Platform = "Win32";
LibDir += "VS" + WindowsPlatform.GetVisualStudioCompilerVersionName() + "/";
break;
case UnrealTargetPlatform.Mac:
Platform = "Mac";
bAllowDynamicLibs = false;
break;
default:
return;
}
LibDir = LibDir + "/" + Platform;
LibDir = LibDir + (BuildConfiguration.bDebugBuildsActuallyUseDebugCRT && bAllowDynamicLibs ? "/Dynamic" : "/Static") + (bDebug ? "Debug" : "Release");
PublicLibraryPaths.Add(LibDir);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.AddRange(
new string[] {
"Half.lib",
"Iex.lib",
"IlmThread.lib",
"Imath.lib",
"hdf5.lib",
"hdf5_hl.lib",
"AlembicAbc.lib",
"AlembicAbcCollection.lib",
"AlembicAbcCoreAbstract.lib",
"AlembicAbcCoreFactory.lib",
"AlembicAbcCoreHDF5.lib",
"AlembicAbcCoreOgawa.lib",
"AlembicAbcGeom.lib",
"AlembicAbcMaterial.lib",
"AlembicOgawa.lib",
"AlembicUtil.lib",
"zlib_64.lib"
}
);
if (BuildConfiguration.bDebugBuildsActuallyUseDebugCRT && bDebug)
{
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Plugins/Experimental/AlembicImporter/Binaries/ThirdParty/zlib/zlibd1.dll"));
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.AddRange(
new string[] {
LibDir + "/libilmbase.a",
LibDir + "/libhdf5.a",
LibDir + "/libhdf5_hl.a",
LibDir + "/libAlembicAbc.a",
LibDir + "/libAlembicAbcCollection.a",
LibDir + "/libAlembicAbcCoreAbstract.a",
LibDir + "/libAlembicAbcCoreFactory.a",
LibDir + "/libAlembicAbcCoreHDF5.a",
LibDir + "/libAlembicAbcCoreOgawa.a",
LibDir + "/libAlembicAbcGeom.a",
LibDir + "/libAlembicAbcMaterial.a",
LibDir + "/libAlembicOgawa.a",
LibDir + "/libAlembicUtil.a",
}
);
}
PublicIncludePaths.Add(ModuleDirectory + "/Deploy/include/");
}
}
public SpatialGDK(ReadOnlyTargetRules Target) : base(Target)
{
bLegacyPublicIncludePaths = false;
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
bUseUnity = false;
PrivateIncludePaths.Add("SpatialGDK/Private");
var WorkerSDKPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "Public", "WorkerSDK"));
PublicIncludePaths.Add(WorkerSDKPath); // Worker SDK uses a different include format <improbable/x.h>
PrivateIncludePaths.Add(WorkerSDKPath);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"EngineSettings",
"Http",
"InputCore",
"OnlineSubsystemUtils",
"Projects",
"ReplicationGraph",
"Sockets",
"Slate",
"UMG"
});
if (Target.bWithPushModel)
{
PublicDependencyModuleNames.Add("NetCore");
}
if (Target.bBuildDeveloperTools || (Target.Configuration != UnrealTargetConfiguration.Shipping &&
Target.Configuration != UnrealTargetConfiguration.Test))
{
PublicDependencyModuleNames.Add("GameplayDebugger");
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=1");
}
else
{
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=0");
}
if (Target.bBuildEditor)
{
PublicDependencyModuleNames.Add("UnrealEd");
PublicDependencyModuleNames.Add("SpatialGDKServices");
}
if (Target.bWithPerfCounters)
{
PublicDependencyModuleNames.Add("PerfCounters");
}
var WorkerLibraryDir = Path.Combine(ModuleDirectory, "..", "..", "Binaries", "ThirdParty", "Improbable", Target.Platform.ToString());
string LibPrefix = "libimprobable_";
string ImportLibSuffix = ".so";
string SharedLibSuffix = ".so";
bool bAddDelayLoad = false;
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
LibPrefix = "improbable_";
ImportLibSuffix = ".lib";
SharedLibSuffix = ".dll";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
ImportLibSuffix = SharedLibSuffix = ".dylib";
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
ImportLibSuffix = "_stub.a";
SharedLibSuffix = ".prx";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
LibPrefix = "improbable_";
ImportLibSuffix = ".lib";
SharedLibSuffix = ".dll";
// We don't set bAddDelayLoad = true here, because we get "unresolved external symbol __delayLoadHelper2".
// See: https://www.fmod.org/questions/question/deploy-issue-on-xboxone-with-unrealengine-4-14/
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
ImportLibSuffix = SharedLibSuffix = "_static.a";
}
else if (!(Target.Platform == UnrealTargetPlatform.Linux || Target.Platform == UnrealTargetPlatform.Android))
{
throw new System.Exception(System.String.Format("Unsupported platform {0}", Target.Platform.ToString()));
}
string WorkerImportLib = System.String.Format("{0}worker{1}", LibPrefix, ImportLibSuffix);
string WorkerSharedLib = System.String.Format("{0}worker{1}", LibPrefix, SharedLibSuffix);
if (Target.Platform != UnrealTargetPlatform.Android)
{
RuntimeDependencies.Add(Path.Combine(WorkerLibraryDir, WorkerSharedLib), StagedFileType.NonUFS);
if (bAddDelayLoad)
{
PublicDelayLoadDLLs.Add(WorkerSharedLib);
}
WorkerImportLib = Path.Combine(WorkerLibraryDir, WorkerImportLib);
PublicRuntimeLibraryPaths.Add(WorkerLibraryDir);
PublicAdditionalLibraries.Add(WorkerImportLib);
}
else
{
var WorkerLibraryPaths = new List <string>
{
Path.Combine(WorkerLibraryDir, "arm64-v8a"),
Path.Combine(WorkerLibraryDir, "armeabi-v7a"),
Path.Combine(WorkerLibraryDir, "x86_64"),
};
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "SpatialGDK_APL.xml"));
PublicRuntimeLibraryPaths.AddRange(WorkerLibraryPaths);
var WorkerLibraries = new List <string>
{
Path.Combine(WorkerLibraryDir, "arm64-v8a", WorkerSharedLib),
Path.Combine(WorkerLibraryDir, "armeabi-v7a", WorkerSharedLib),
Path.Combine(WorkerLibraryDir, "x86_64", WorkerSharedLib),
};
PublicAdditionalLibraries.AddRange(WorkerLibraries);
}
}
public Funapi(TargetInfo Target)
{
Definitions.Add("WITH_FUNAPI=1");
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
"Funapi/Pubilc",
"Funapi/Pubilc/funapi",
"Funapi/Pubilc/funapi/management",
"Funapi/Pubilc/funapi/network",
"Funapi/Pubilc/funapi/service",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Funapi/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Engine",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
// definitions
Definitions.Add("RAPIDJSON_HAS_STDSTRING=0");
// Third party library
var ThirdPartyPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty/"));
// include path
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include"));
// PublicIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "funapi")));
// library
var LibPath = ThirdPartyPath;
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include", "Mac"));
LibPath += "lib/Mac";
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcurl.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libz.a"));
// PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libprotobuf.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.a"));
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include", "Windows", "x86"));
LibPath += "lib/Windows/x86";
PublicLibraryPaths.Add(LibPath);
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcurl_a.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libeay32.lib"));
// PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libprotobuf.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.lib"));
Definitions.Add("CURL_STATICLIB=1");
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include", "Windows", "x64"));
LibPath += "lib/Windows/x64";
PublicLibraryPaths.Add(LibPath);
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcurl_a.lib"));
// PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libprotobuf.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.lib"));
Definitions.Add("CURL_STATICLIB=1");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
// toolchain will filter properly
PublicIncludePaths.Add(LibPath + "include/Android/ARMv7");
PublicLibraryPaths.Add(LibPath + "lib/Android/ARMv7");
//PublicIncludePaths.Add(LibPath + "include/Android/ARM64");
//PublicLibraryPaths.Add(LibPath + "lib/Android/ARM64");
//PublicIncludePaths.Add(LibPath + "include/Android/x86");
//PublicLibraryPaths.Add(LibPath + "lib/Android/x86");
//PublicIncludePaths.Add(LibPath + "include/Android/x64");
//PublicLibraryPaths.Add(LibPath + "lib/Android/x64");
LibPath += "lib/Android/ARMv7";
//PublicAdditionalLibraries.Add("curl");
//PublicAdditionalLibraries.Add("crypto");
//PublicAdditionalLibraries.Add("protobuf");
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcurl.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.a"));
// PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libprotobuf.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.a"));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include", "iOS"));
LibPath += "lib/iOS";
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcurl.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.a"));
// PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libprotobuf.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.a"));
}
}
public WorldBrowser(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.Add("Editor/WorldBrowser/Public");
PrivateIncludePaths.Add("Editor/WorldBrowser/Private"); // For PCH includes (because they don't work with relative paths, yet)
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"ContentBrowser",
"Landscape",
"MeshUtilities",
"MaterialUtilities",
"MeshMergeUtilities",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"RenderCore",
"ShaderCore",
"InputCore",
"Engine",
"Landscape",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"GraphEditor",
"LevelEditor",
"PropertyEditor",
"DesktopPlatform",
"MainFrame",
"SourceControl",
"SourceControlWindows",
"RawMesh",
"LandscapeEditor",
"FoliageEdit",
"ImageWrapper",
"Foliage",
"MaterialUtilities",
"RHI",
"Json",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"SceneOutliner",
"MeshUtilities",
"ContentBrowser",
"MeshMergeUtilities",
}
);
}