public HAPMedia(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"Projects",
"WmfMediaFactory",
"WmfMedia",
});
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"HAPLib",
"SnappyLib",
});
PublicDelayLoadDLLs.Add("mf.dll");
PublicDelayLoadDLLs.Add("mfplat.dll");
PublicDelayLoadDLLs.Add("mfplay.dll");
PublicDelayLoadDLLs.Add("shlwapi.dll");
PublicSystemLibraries.Add("mf.lib");
PublicSystemLibraries.Add("mfplat.lib");
PublicSystemLibraries.Add("mfuuid.lib");
PublicSystemLibraries.Add("shlwapi.lib");
PublicSystemLibraries.Add("d3d11.lib");
PublicSystemLibraries.Add("d3dcompiler.lib");
}
}
public GameplayMediaEncoder(ReadOnlyTargetRules Target) : base(Target)
{
// NOTE: General rule is not to access the private folder of another module,
// but to use the ISubmixBufferListener interface, we need to include some private headers
PrivateIncludePaths.Add(System.IO.Path.Combine(Directory.GetCurrentDirectory(), "./Runtime/AudioMixer/Private"));
PrivateDependencyModuleNames.AddRange(new string[]
{
"Core",
"Engine",
"CoreUObject",
"ApplicationCore",
"RenderCore",
"RHI",
"SlateCore",
"Slate",
"HTTP",
"Json",
//"IBMRTMPIngest"
});
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.AddRange(new string[]
{
"D3D11RHI"
});
PublicDelayLoadDLLs.Add("mfplat.dll");
PublicDelayLoadDLLs.Add("mfuuid.dll");
PublicDelayLoadDLLs.Add("Mfreadwrite.dll");
PublicSystemLibraries.Add("d3d11.lib");
}
}
public SoundVisualizations(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("SoundVisualizations/Private");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
// VS2015 updated some of the CRT definitions but not all of the Windows SDK has been updated to match.
// Microsoft provides this shim library to enable building with VS2015 until they fix everything up.
//@todo: remove when no longer neeeded (no other code changes should be necessary).
if (Target.WindowsPlatform.bNeedsLegacyStdioDefinitionsLib)
{
PublicSystemLibraries.Add("legacy_stdio_definitions.lib");
}
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "Kiss_FFT");
if (Target.Platform == UnrealTargetPlatform.LinuxAArch64)
{
PrecompileForTargets = PrecompileTargetsType.None;
}
}
public VivoxCoreSDK(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string VivoxSDKPath = ModuleDirectory;
string PlatformSubdir = Target.Platform.ToString();
string VivoxLibPath = Path.Combine(VivoxSDKPath, "Lib", PlatformSubdir) + "/";
string VivoxIncludePath = Path.Combine(VivoxSDKPath, "Include");
PublicIncludePaths.Add(VivoxIncludePath);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.Add(VivoxLibPath + "vivoxsdk_x64.lib");
PublicDelayLoadDLLs.Add("ortp_x64.dll");
PublicDelayLoadDLLs.Add("vivoxsdk_x64.dll");
RuntimeDependencies.Add(Path.Combine("$(TargetOutputDir)", "ortp_x64.dll"), Path.Combine(VivoxLibPath, "ortp_x64.dll"));
RuntimeDependencies.Add(Path.Combine("$(TargetOutputDir)", "vivoxsdk_x64.dll"), Path.Combine(VivoxLibPath, "vivoxsdk_x64.dll"));
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicAdditionalLibraries.Add(VivoxLibPath + "vivoxsdk.lib");
PublicDelayLoadDLLs.Add("ortp.dll");
PublicDelayLoadDLLs.Add("vivoxsdk.dll");
RuntimeDependencies.Add(Path.Combine("$(TargetOutputDir)", "ortp.dll"), Path.Combine(VivoxLibPath, "ortp.dll"));
RuntimeDependencies.Add(Path.Combine("$(TargetOutputDir)", "vivoxsdk.dll"), Path.Combine(VivoxLibPath, "vivoxsdk.dll"));
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PublicAdditionalLibraries.Add(VivoxLibPath + "vivoxsdk.lib");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicAdditionalLibraries.Add(VivoxLibPath + "libvivoxsdk.a");
PublicSystemLibraries.Add("SceSha1");
PublicSystemLibraries.Add("SceAudioIn_stub_weak");
PublicSystemLibraries.Add("SceHmac");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string TargetDir = Path.Combine(Target.UEThirdPartyBinariesDirectory, "Vivox", "Mac");
PublicDelayLoadDLLs.Add(Path.Combine(TargetDir, "libortp.dylib"));
PublicDelayLoadDLLs.Add(Path.Combine(TargetDir, "libvivoxsdk.dylib"));
RuntimeDependencies.Add(Path.Combine(TargetDir, "libortp.dylib"));
RuntimeDependencies.Add(Path.Combine(TargetDir, "libvivoxsdk.dylib"));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalLibraries.Add(VivoxLibPath + "libvivoxsdk.a");
PublicFrameworks.Add("CFNetwork");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicAdditionalLibraries.Add(Path.Combine(VivoxLibPath, "armeabi-v7a", "libvivox-sdk.so"));
PublicAdditionalLibraries.Add(Path.Combine(VivoxLibPath, "arm64-v8a", "libvivox-sdk.so"));
string PluginPath = Utils.MakePathRelativeTo(VivoxSDKPath, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "VivoxCoreSDK_UPL.xml"));
}
}
public AVEncoder(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(new string[]
{
"Core",
"Engine",
"RHI",
"RenderCore",
});
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.AddRange(new string[]
{
"D3D11RHI"
});
PublicDelayLoadDLLs.Add("mfplat.dll");
PublicDelayLoadDLLs.Add("mfuuid.dll");
PublicDelayLoadDLLs.Add("Mfreadwrite.dll");
PublicSystemLibraries.Add("d3d11.lib");
PublicSystemLibraries.Add("DXGI.lib");
}
}
public AVEncoder(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(new string[]
{
"Core",
"Engine",
"RHI",
"RenderCore",
});
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PublicDefinitions.Add("AVENCODER_SUPPORTED_MICROSOFT_PLATFORM=1");
PrivateDependencyModuleNames.AddRange(new string[]
{
"D3D11RHI"
});
PublicDelayLoadDLLs.Add("mfplat.dll");
PublicDelayLoadDLLs.Add("mfuuid.dll");
PublicDelayLoadDLLs.Add("Mfreadwrite.dll");
PublicSystemLibraries.Add("d3d11.lib");
PublicSystemLibraries.Add("DXGI.lib");
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PublicDefinitions.Add("AVENCODER_SUPPORTED_MICROSOFT_PLATFORM=1");
}
}
public SoundMod(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
}
);
PublicDefinitions.AddRange(
new string[] {
"BUILDING_STATIC"
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
// VS2015 updated some of the CRT definitions but not all of the Windows SDK has been updated to match.
// Microsoft provides this shim library to enable building with VS2015 until they fix everything up.
//@todo: remove when no longer neeeded (no other code changes should be necessary).
if (Target.WindowsPlatform.bNeedsLegacyStdioDefinitionsLib)
{
PublicSystemLibraries.Add("legacy_stdio_definitions.lib");
}
}
// Link with managed Perforce wrapper assemblies
AddEngineThirdPartyPrivateStaticDependencies(Target, "coremod");
}
public BuglySDK(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
PublicDefinitions.Add("WITH_BUGLY=1");
if (Target.Platform == UnrealTargetPlatform.IOS)
{
string BuglyFrameworkPath = Path.Combine(ModuleDirectory, "iOS/Bugly.embeddedframework.zip");
PublicAdditionalFrameworks.Add(new Framework("Bugly", BuglyFrameworkPath));
Log.TraceInformation("Add bugly framework: {0}", BuglyFrameworkPath);
PublicFrameworks.Add("SystemConfiguration");
PublicFrameworks.Add("Security");
PublicSystemLibraries.Add("c++");
PublicSystemLibraries.Add("z");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "BuglySDK_UPL.xml"));
}
}
public SSL(ReadOnlyTargetRules Target) : base(Target)
{
PublicDefinitions.Add("SSL_PACKAGE=1");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
}
);
if (bPlatformSupportsSSL)
{
PublicDefinitions.Add("WITH_SSL=1");
PrivateDefinitions.Add("USE_DEFAULT_SSLCERT=" + (bUseDefaultSSLCert ? "1" : "0"));
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Online/SSL/Private",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenSSL");
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
PublicSystemLibraries.Add("crypt32.lib");
}
}
else
{
PublicDefinitions.Add("WITH_SSL=0");
}
}
public HoloLensPlatformEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Settings",
"TargetPlatform",
"DesktopPlatform",
"Slate",
"SlateCore",
"EditorStyle",
"PropertyEditor",
"SharedSettingsWidgets",
"AppFramework",
"DesktopWidgets",
"UnrealEd",
"SourceControl",
"WindowsTargetPlatform", // For ECompilerVersion
"EngineSettings",
"Projects",
"gltfToolkit",
"AudioSettingsEditor",
}
);
PublicSystemLibraries.Add("crypt32.lib");
}
public HoloLensTargetPlatform(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Settings",
"EngineSettings",
"TargetPlatform",
"DesktopPlatform",
"HoloLensDeviceDetector",
"HTTP",
"HoloLensPlatformEditor"
}
);
PrivateIncludePathModuleNames.Add("Settings");
// compile withEngine
if (Target.bCompileAgainstEngine)
{
PrivateDependencyModuleNames.Add("Engine");
PrivateIncludePathModuleNames.Add("TextureCompressor");
}
PublicSystemLibraries.Add("shlwapi.lib");
string LibrariesPath = Path.Combine(ThirdPartyPath, "Lib", Target.WindowsPlatform.GetArchitectureSubpath());
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "HoloLensBuildLib.lib"));
PrivateIncludePaths.Add(Path.Combine(ThirdPartyPath, "Include/"));
}
public FreeImage(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
PublicSystemIncludePaths.Add(Path.Combine(ModuleDirectory, "Source"));
string BinaryLibraryFolder = Path.Combine(Target.UEThirdPartyBinariesDirectory, "FreeImage", Target.Platform.ToString());
string LibraryFileName = "";
bool bWithFreeImage = false;
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
LibraryFileName = "FreeImage.dll";
string DynLibPath = Path.Combine(BinaryLibraryFolder, LibraryFileName);
string LibPath = Path.Combine(ModuleDirectory, "lib", Target.Platform.ToString());
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "FreeImage.lib"));
PublicDelayLoadDLLs.Add(LibraryFileName);
RuntimeDependencies.Add(DynLibPath);
bWithFreeImage = true;
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
LibraryFileName = "libfreeimage-3.18.0.so";
string DynLibPath = Path.Combine(BinaryLibraryFolder, LibraryFileName);
PublicRuntimeLibraryPaths.Add(BinaryLibraryFolder);
PublicAdditionalLibraries.Add(DynLibPath);
PublicDelayLoadDLLs.Add(LibraryFileName);
RuntimeDependencies.Add(DynLibPath);
PublicSystemLibraries.Add("stdc++");
bWithFreeImage = true;
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
LibraryFileName = "libfreeimage-3.18.0.dylib";
string DynLibPath = Path.Combine(BinaryLibraryFolder, LibraryFileName);
PublicRuntimeLibraryPaths.Add(BinaryLibraryFolder);
PublicAdditionalLibraries.Add(DynLibPath);
PublicDelayLoadDLLs.Add(DynLibPath);
RuntimeDependencies.Add(DynLibPath);
PublicSystemLibraries.Add("stdc++");
bWithFreeImage = true;
}
PublicDefinitions.Add("WITH_FREEIMAGE_LIB=" + (bWithFreeImage ? '1' : '0'));
if (LibraryFileName != "")
{
PublicDefinitions.Add("FREEIMAGE_LIB_FILENAME=\"" + LibraryFileName + "\"");
}
}
public libstrophe(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
PrivateDefinitions.Add("XML_STATIC");
PublicSystemIncludePaths.Add(Path.Combine(ModuleDirectory, StropheVersion));
if (bRequireExpat)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Expat");
}
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Use reflection to allow type not to exist if console code is not present
string ToolchainName = "VS";
System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool");
if (XboxOnePlatformType != null)
{
System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
ToolchainName += VersionName.ToString();
}
string LibraryPath = Path.Combine(StrophePackagePath, "XboxOne", ToolchainName, ConfigName);
PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, "strophe.lib"));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, "Android", ConfigName, "arm64", "libstrophe.a"));
PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, "Android", ConfigName, "armv7", "libstrophe.a"));
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, Target.Platform.ToString(), ConfigName, "libstrophe.a"));
PublicSystemLibraries.Add("resolv");
}
else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
string LibrayPath = Path.Combine(StrophePackagePath, Target.Platform.ToString(), "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(), ConfigName) + "/";
PublicAdditionalLibraries.Add(LibrayPath + "strophe.lib");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
string LibrayPath = Path.Combine(StrophePackagePath, Target.Platform.ToString(), ConfigName) + "/";
PublicSystemLibraries.Add(LibrayPath + "libstrophe.a");
}
else if (Target.Platform == UnrealTargetPlatform.Switch)
{
PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, Target.Platform.ToString(), ConfigName, "libstrophe.a"));
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
PublicAdditionalLibraries.Add(Path.Combine(StrophePackagePath, "Linux", Target.Architecture.ToString(), ConfigName, "libstrophe" + ((Target.LinkType != TargetLinkType.Monolithic) ? "_fPIC" : "") + ".a"));
PublicSystemLibraries.Add("resolv");
}
}
public renderTarget(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core", "CoreUObject", "Engine"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Engine",
"ApplicationCore",
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"RHI",
"D3D11RHI",
"MediaAssets",
"DeveloperSettings",
"ShadersSendSomething",
}
);
PrivateIncludePaths.AddRange(new string[]
{
"ShadersSendSomething/Private"
});
DynamicallyLoadedModuleNames.AddRange(new string[]
{
"Media",
});
PrivateIncludePathModuleNames.AddRange(new string[]
{
"Media",
});
var EngineDir = Path.GetFullPath(Target.RelativeEnginePath);
PrivateDependencyModuleNames.Add("WmfMedia");
PrivateIncludePaths.Add(Path.Combine(EngineDir, "Plugins/Media/WmfMedia/Source/WmfMedia/Private/"));
PrivateIncludePaths.Add(Path.Combine(EngineDir, "Plugins/Media/WmfMedia/Source/WmfMedia/Private/Wmf/"));
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX9");
PublicSystemLibraries.Add("mfplat.lib");
}
public WinInet(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
PublicSystemLibraries.Add("wininet.lib");
}
}
public TraceLog(ReadOnlyTargetRules Target) : base(Target)
{
bRequiresImplementModule = false;
PublicIncludePathModuleNames.Add("Core");
if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicSystemLibraries.Add("SceNet_stub_weak");
}
}
private void HandleAndroid(ReadOnlyTargetRules Target)
{
string libsPath = Path.Combine(CommonSharedLibsPath, "android");
PublicSystemLibraryPaths.Add(Path.Combine(libsPath, "arm64-v8a"));
PublicSystemLibraryPaths.Add(Path.Combine(libsPath, "armeabi-v7a"));
PublicSystemLibraryPaths.Add(Path.Combine(libsPath, "x86"));
PublicSystemLibraryPaths.Add(Path.Combine(libsPath, "x86_64"));
PublicSystemLibraries.Add("nakama-cpp");
string relAPLPath = Utils.MakePathRelativeTo(Path.Combine(ModulePath, "Nakama_APL.xml"), Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", relAPLPath);
}
public PS5ControllerCrash(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "WebRTC", "OpenSSL" });
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Windows))
{
PublicSystemLibraries.Add("msdmo.lib");
PublicSystemLibraries.Add("dmoguids.lib");
PublicSystemLibraries.Add("wmcodecdspuuid.lib");
PublicSystemLibraries.Add("winmm.lib");
PublicSystemLibraries.Add("strmiids.lib");
}
}
public GoogleARCoreSDK(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string ARCoreSDKDir = Target.UEThirdPartySourceDirectory + "GoogleARCore/";
PublicSystemIncludePaths.AddRange(
new string[] {
ARCoreSDKDir + "include/",
}
);
string ARCoreSDKBaseLibPath = ARCoreSDKDir + "lib/";
if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicAdditionalLibraries.Add(ARCoreSDKBaseLibPath + "armeabi-v7a/libarcore_sdk_c.so");
PublicAdditionalLibraries.Add(ARCoreSDKBaseLibPath + "arm64-v8a/libarcore_sdk_c.so");
PublicAdditionalLibraries.Add(ARCoreSDKBaseLibPath + "x86/libarcore_sdk_c.so");
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
string ARCoreSDKiOSLibPath = ARCoreSDKBaseLibPath + "ios/";
PublicAdditionalLibraries.Add(ARCoreSDKiOSLibPath + "libGTMSessionFetcher.a");
PublicAdditionalLibraries.Add(ARCoreSDKiOSLibPath + "libGoogleToolboxForMac.a");
PublicAdditionalLibraries.Add(ARCoreSDKiOSLibPath + "libProtobuf.a");
PublicSystemLibraries.Add("c++");
PublicSystemLibraries.Add("sqlite3");
PublicSystemLibraries.Add("z");
PublicAdditionalFrameworks.Add(new Framework("ARKit"));
PublicAdditionalFrameworks.Add(new Framework("AVFoundation"));
PublicAdditionalFrameworks.Add(new Framework("CoreGraphics"));
PublicAdditionalFrameworks.Add(new Framework("CoreImage"));
PublicAdditionalFrameworks.Add(new Framework("CoreMotion"));
PublicAdditionalFrameworks.Add(new Framework("CoreMedia"));
PublicAdditionalFrameworks.Add(new Framework("CoreVideo"));
PublicAdditionalFrameworks.Add(new Framework("Foundation"));
PublicAdditionalFrameworks.Add(new Framework("ImageIO"));
PublicAdditionalFrameworks.Add(new Framework("QuartzCore"));
PublicAdditionalFrameworks.Add(new Framework("Security"));
PublicAdditionalFrameworks.Add(new Framework("UIKit"));
PublicAdditionalFrameworks.Add(new Framework("VideoToolbox"));
PublicAdditionalFrameworks.Add(new Framework("ARCore", "lib/ios/ARCore.embeddedframework.zip", "ARCore.framework/Resources/ARCoreResources.bundle"));
}
}
public zmqLibrary(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// Add the import library
String LibName = "libzmq-mt-4_3_1";
PublicAdditionalLibraries.Add(Path.Combine(ModuleDirectory, "x64", "Release",LibName+".lib"));
// Delay-load the DLL, so we can load it from the right place first
PublicDelayLoadDLLs.Add(LibName+".dll");
RuntimeDependencies.Add("$(TargetOutputDir)/"+LibName+".dll",Path.Combine(ModuleDirectory,"x64","Release",LibName+".dll"));
}
else if(Target.Platform == UnrealTargetPlatform.Linux){
PublicSystemLibraries.Add("zmq");
PublicSystemLibraryPaths.Add("/usr/lib/x86_64-linux-gnu/");
}
}
public void LoadEngine(ReadOnlyTargetRules Target)
{
var BuildName = "rwdi";
var EnginePath = Path.Combine(ThirdPartyPath, "Engine");
var DotSwPath = Path.Combine(EnginePath, ".sw");
var JsonProgPath = Path.Combine(DotSwPath, "out", BuildName, "");
var JsonPath = Path.Combine(DotSwPath, "g", "swbdesc", BuildName + ".json");
var DefsFile = Path.Combine(DotSwPath, "defs.txt");
var IdirsFile = Path.Combine(DotSwPath, "idirs.txt");
var LibsFile = Path.Combine(DotSwPath, "libs.txt");
if (!File.Exists(DefsFile) ||
!File.Exists(IdirsFile) ||
!File.Exists(LibsFile))
{
bool r =
RunSwCommand("sw", "-static -config rwdi build", EnginePath) &&
RunSwCommand("sw", "-static -config rwdi -build-name " + BuildName + " generate -g swbdesc", EnginePath) &&
RunSwCommand("sw", "run Polygon4.Engine.tools.prepare_sw_info-0.0.1 \"" + DotSwPath + "\" \"" + JsonPath + "\" Polygon4.Engine-master", EnginePath)
;
if (!r)
{
throw new Exception("Engine build failed");
}
}
PublicIncludePaths.Add(ModuleDirectory);
// read & set defs, idirs, libs
foreach (var s in File.ReadLines(DefsFile))
{
PublicDefinitions.Add(s);
}
foreach (var s in File.ReadLines(IdirsFile))
{
PublicIncludePaths.Add(s);
}
foreach (var s in File.ReadLines(LibsFile))
{
PublicSystemLibraries.Add(s);
}
}
public HoloLensTargetPlatform(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Settings",
"EngineSettings",
"TargetPlatform",
"DesktopPlatform",
"HTTP",
"Json",
"HoloLensPlatformEditor",
}
);
PrivateIncludePathModuleNames.Add("Settings");
int Win10Build = 0;
Version ver = null;
if (Version.TryParse(Target.WindowsPlatform.WindowsSdkVersion, out ver))
{
Win10Build = ver.Build;
}
//there is a WinSDK bug that prevented to include the file into this version
if (Win10Build != 0 && Win10Build != 16299)
{
PrivateDefinitions.Add("APPXPACKAGING_ENABLE=1");
}
else
{
PrivateDefinitions.Add("APPXPACKAGING_ENABLE=0");
}
// compile withEngine
if (Target.bCompileAgainstEngine)
{
PrivateDependencyModuleNames.Add("Engine");
PrivateIncludePathModuleNames.Add("TextureCompressor");
}
PublicSystemLibraries.Add("shlwapi.lib");
PublicSystemLibraries.Add("runtimeobject.lib");
}
public MfMedia(ReadOnlyTargetRules Target) : base(Target)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"MediaUtils",
"RenderCore",
});
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Media",
});
PrivateIncludePaths.AddRange(
new string[] {
"MfMedia/Private",
"MfMedia/Private/Mf",
"MfMedia/Private/Player",
});
if (Target.Type != TargetType.Server)
{
if ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64))
{
PublicDelayLoadDLLs.Add("mf.dll");
PublicDelayLoadDLLs.Add("mfplat.dll");
PublicDelayLoadDLLs.Add("mfreadwrite.dll");
PublicDelayLoadDLLs.Add("mfuuid.dll");
PublicDelayLoadDLLs.Add("propsys.dll");
PublicDelayLoadDLLs.Add("shlwapi.dll");
}
else
{
PublicSystemLibraries.Add("mfplat.lib");
PublicSystemLibraries.Add("mfreadwrite.lib");
PublicSystemLibraries.Add("mfuuid.lib");
}
}
}
private void AddOSLibDependencies(ReadOnlyTargetRules Target)
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// for SHGetFolderPath.
//PublicAdditionalLibraries.Add("Shell32.lib");
//for joystick support
PublicSystemLibraries.Add("dinput8.lib");
PublicSystemLibraries.Add("dxguid.lib");
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
// needed when packaging
PublicSystemLibraries.Add("stdc++");
PublicSystemLibraries.Add("supc++");
}
}
public OpenGL(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
PublicIncludePaths.Add(ModuleDirectory);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
PublicSystemLibraries.Add("opengl32.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalFrameworks.Add(new Framework("OpenGL"));
PublicAdditionalFrameworks.Add(new Framework("QuartzCore"));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalFrameworks.Add(new Framework("OpenGLES"));
}
}
public AppleProResMedia(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"ProResLib",
"ProResToolbox",
"WmfMediaFactory",
"WmfMedia",
"ImageWriteQueue",
"MovieRenderPipelineCore",
});
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"MovieSceneCapture",
"Projects",
"WmfMediaFactory",
"WmfMedia"
}
);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicDelayLoadDLLs.Add("mf.dll");
PublicDelayLoadDLLs.Add("mfplat.dll");
PublicDelayLoadDLLs.Add("mfplay.dll");
PublicDelayLoadDLLs.Add("shlwapi.dll");
PublicSystemLibraries.Add("mf.lib");
PublicSystemLibraries.Add("mfplat.lib");
PublicSystemLibraries.Add("mfuuid.lib");
PublicSystemLibraries.Add("shlwapi.lib");
PublicSystemLibraries.Add("d3d11.lib");
}
}
public XAudio2(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("TargetPlatform");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"AudioMixerCore" // for AudioPlatformSettings::GetPlatformSettings() in AudioMixerTypes.h.
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.HoloLens)
{
// VS2015 updated some of the CRT definitions but not all of the Windows SDK has been updated to match.
// Microsoft provides this shim library to enable building with VS2015 until they fix everything up.
//@todo: remove when no longer neeeded (no other code changes should be necessary).
if (Target.WindowsPlatform.bNeedsLegacyStdioDefinitionsLib)
{
PublicSystemLibraries.Add("legacy_stdio_definitions.lib");
}
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PrivateDependencyModuleNames.Add("XMA2");
}
AddEngineThirdPartyPrivateStaticDependencies(Target,
"DX11Audio",
"UEOgg",
"Vorbis",
"VorbisFile"
);
PublicDefinitions.Add("WITH_OGGVORBIS=1");
}
public XInput(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string DirectXSDKDir = "";
if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
DirectXSDKDir = Target.WindowsPlatform.bUseWindowsSDK10 ?
Target.UEThirdPartySourceDirectory + "Windows/DirectXLegacy" :
Target.UEThirdPartySourceDirectory + "Windows/DirectX";
}
else
{
DirectXSDKDir = Target.UEThirdPartySourceDirectory + "Windows/DirectX";
}
// Ensure correct include and link paths for xinput so the correct dll is loaded (xinput1_3.dll)
if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
PublicSystemLibraries.Add("xinputuap.lib");
PublicSystemIncludePaths.Add(DirectXSDKDir + "/include");
}
else
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.Add(DirectXSDKDir + "/Lib/x64/XInput.lib");
PublicSystemIncludePaths.Add(DirectXSDKDir + "/include");
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicAdditionalLibraries.Add(DirectXSDKDir + "/Lib/x86/XInput.lib");
PublicSystemIncludePaths.Add(DirectXSDKDir + "/include");
}
}
}
public HLMedia(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
});
PublicDependencyModuleNames.AddRange(
new string[] {
"HLMediaFactory",
"MediaAssets",
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Projects",
"RenderCore",
"RHI",
"MediaUtils",
});
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Media",
});
PrivateIncludePaths.AddRange(
new string[] {
"HLMedia/Private",
});
var EngineDir = Path.GetFullPath(Target.RelativeEnginePath);
if (Target.Platform == UnrealTargetPlatform.Win32
||
Target.Platform == UnrealTargetPlatform.Win64
||
Target.Platform == UnrealTargetPlatform.HoloLens)
{
PrivateDependencyModuleNames.AddRange(new string[]
{
"HLMediaLibrary",
"D3D11RHI"
});
PrivateIncludePaths.AddRange(new string[]
{
Path.Combine(EngineDir, "Source/ThirdParty/HLMediaLibrary/inc"),
Path.Combine(EngineDir, "Source/Runtime/Windows/D3D11RHI/Private"),
});
// required by D3D11RHI to compile
AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelMetricsDiscovery");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAftermath");
AddEngineThirdPartyPrivateStaticDependencies(Target, "HLMediaLibrary");
PublicSystemLibraries.Add("mfplat.lib");
PublicSystemLibraries.Add("mfreadwrite.lib");
PublicSystemLibraries.Add("mfuuid.lib");
}
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateIncludePaths.Add(Path.Combine(EngineDir, "Source/Runtime/Windows/D3D11RHI/Private/Windows"));
}
else if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
PrivateIncludePaths.Add(Path.Combine(EngineDir, "Source/Runtime/Windows/D3D11RHI/Private/HoloLens"));
}
}
public BootstrapPackagedGame(ReadOnlyTargetRules Target) : base(Target)
{
PublicSystemLibraries.Add("shlwapi.lib");
bEnableUndefinedIdentifierWarnings = false;
}