public AppleARKit(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"../../../../Source/Runtime/Renderer/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[]
{
"CoreUObject",
"Slate",
"SlateCore",
"RHI",
"Renderer",
"RenderCore",
"ShaderCore",
"HeadMountedDisplay",
"IOSRuntimeSettings",
"AugmentedReality",
"ProceduralMeshComponent",
"LiveLink",
"LiveLinkInterface",
// "OnlineSubsystem",
"Sockets"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicDefinitions.Add("ARKIT_SUPPORT=1");
PublicFrameworks.Add("ARKit");
}
else
{
PublicDefinitions.Add("ARKIT_SUPPORT=0");
}
}
public AzureSpatialAnchorsForARKit(ReadOnlyTargetRules Target) : base(Target)
{
bEnableExceptions = true;
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"AugmentedReality"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"AzureSpatialAnchors",
"AppleARKit"
}
);
PublicFrameworks.Add("ARKit");
PublicAdditionalFrameworks.Add(
new Framework(
"AzureSpatialAnchors",
"ThirdParty/AzureSpatialAnchors.embeddedframework.zip",
null,
true)
);
}
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 nativeTest(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "AppleARKit", "HeadMountedDisplay",
"AugmentedReality",
"AppleImageUtils" });
PrivateDependencyModuleNames.AddRange(new string[] { });
// Uncomment if you are using Slate UI
// PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" });
// Uncomment if you are using online features
// PrivateDependencyModuleNames.Add("OnlineSubsystem");
// To include OnlineSubsystemSteam, add it to the plugins section in your uproject file with the Enabled attribute set to true
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PrivateDependencyModuleNames.Add("IOSRuntimeSettings");
PublicFrameworks.Add("ARKit");
}
}
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 WebAuth(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Engine"
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
// << Add these lines to your project's build.cs when building for iOS 12+
PublicFrameworks.Add("AuthenticationServices");
// << Also add these lines to your project's build.cs when building for iOS 13+
// PublicDefinitions.Add("WEBAUTH_PLATFORM_IOS_13");
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("Launch");
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "WebAuth_UPL.xml"));
}
}
public MetalRHI(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"ApplicationCore",
"Engine",
"RHI",
"RenderCore",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target,
"MTLPP"
);
PublicWeakFrameworks.Add("Metal");
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("QuartzCore");
}
var StatsModule = "../Plugins/NotForLicensees/MetalStatistics/MetalStatistics.uplugin";
bool bMetalStats = System.IO.File.Exists(StatsModule);
if (bMetalStats && Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PublicDefinitions.Add("METAL_STATISTICS=1");
WhitelistRestrictedFolders.Add("Public/NotForLicensees");
}
}
public Facebook(TargetInfo Target)
{
Type = ModuleType.External;
Definitions.Add("WITH_FACEBOOK=1");
string FacebookPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "Facebook/";
if (Target.Platform == UnrealTargetPlatform.IOS)
{
string FacebookVersion = "3.16";
if (FacebookVersion == "3.16")
{
Definitions.Add("FACEBOOK_VER_3_16=1");
}
FacebookPath += ("Facebook-IOS-" + FacebookVersion + "/");
PublicIncludePaths.Add(FacebookPath + "Include");
string LibDir = FacebookPath + "Lib/Release" + Target.Architecture;
PublicLibraryPaths.Add(LibDir);
PublicAdditionalLibraries.Add("Facebook-IOS-" + FacebookVersion);
PublicAdditionalShadowFiles.Add(LibDir + "/libFacebook-IOS-" + FacebookVersion + ".a");
AddThirdPartyPrivateStaticDependencies(Target, "Bolts");
// Needed for the facebook sdk to link.
PublicFrameworks.Add("CoreGraphics");
}
}
public AppleARKit(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(new string[]
{
"../../../../../../Source/Runtime/Renderer/Private",
});
PublicDependencyModuleNames.AddRange(new string[]
{
"Core",
"Engine",
"MRMesh",
"EyeTracker",
});
PrivateDependencyModuleNames.AddRange(new string[]
{
"CoreUObject",
"Slate",
"SlateCore",
"RHI",
"Renderer",
"RenderCore",
"HeadMountedDisplay",
"AugmentedReality",
"AppleImageUtils",
"Projects",
"ARUtilities",
});
DynamicallyLoadedModuleNames.AddRange(new string[]
{
});
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PrivateDependencyModuleNames.Add("IOSRuntimeSettings");
PublicFrameworks.AddRange(new string[]
{
"ARKit",
"MetalPerformanceShaders",
"CoreLocation",
});
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("IOSPlugin", Path.Combine(PluginPath, "AppleARKit_IOS_UPL.xml"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("MetalPerformanceShaders");
}
}
public AppleARKit(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"../../../../../../Source/Runtime/Renderer/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[]
{
"CoreUObject",
"Slate",
"SlateCore",
"RHI",
"Renderer",
"RenderCore",
"HeadMountedDisplay",
"AugmentedReality",
"AppleImageUtils",
"MRMesh"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PrivateDependencyModuleNames.Add("IOSRuntimeSettings");
PublicFrameworks.Add("ARKit");
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("IOSPlugin", Path.Combine(PluginPath, "AppleARKit_IOS_UPL.xml"));
}
PublicDefinitions.Add("MATERIAL_CAMERAIMAGE_CONVERSION=1");
}
public HTTP(TargetInfo Target)
{
Definitions.Add("HTTP_PACKAGE=1");
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Online/HTTP/Private",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
}
);
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "WinInet");
AddEngineThirdPartyPrivateStaticDependencies(Target, "WinHttp");
AddEngineThirdPartyPrivateStaticDependencies(Target, "libcurl");
PrivateDependencyModuleNames.Add("SSL");
}
else if (Target.Platform == UnrealTargetPlatform.Linux ||
Target.Platform == UnrealTargetPlatform.Android ||
Target.Platform == UnrealTargetPlatform.Switch)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "libcurl");
PrivateDependencyModuleNames.Add("SSL");
}
else
{
Definitions.Add("WITH_SSL=0");
Definitions.Add("WITH_LIBCURL=0");
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
if (Target.Architecture == "-win32")
{
PrivateDependencyModuleNames.Add("HTML5Win32");
}
else
{
PrivateDependencyModuleNames.Add("HTML5JS");
}
}
if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS || Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("Security");
}
}
public AppleARKit(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"../../../../Source/Runtime/Renderer/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[]
{
"CoreUObject",
"Slate",
"SlateCore",
"RHI",
"Renderer",
"RenderCore",
"ShaderCore",
"HeadMountedDisplay",
"AugmentedReality",
"AppleImageUtils"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PrivateDependencyModuleNames.Add("IOSRuntimeSettings");
PublicFrameworks.Add("ARKit");
}
}
public AppleARKitFaceSupport(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"../../../../../../Plugins/Runtime/AR/AppleAR/AppleARKit/Source/AppleARKit/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[]
{
"CoreUObject",
"HeadMountedDisplay",
"AugmentedReality",
"ProceduralMeshComponent",
"LiveLink",
"LiveLinkInterface",
// "OnlineSubsystem",
"Sockets",
"AppleARKit",
"AppleImageUtils"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.Add("ARKit");
}
}
public AudioMixerCoreAudio(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("TargetPlatform");
PublicIncludePaths.Add("Runtime/AudioMixer/Public");
PrivateIncludePaths.Add("Runtime/AudioMixer/Private");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"AudioMixerCore",
}
);
PrecompileForTargets = PrecompileTargetsType.None;
if (Target.bCompileAgainstEngine)
{
// Engine module is required for CompressedAudioInfo implementations.
PrivateDependencyModuleNames.Add("Engine");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
PublicFrameworks.AddRange(new string[]
{
"AudioToolbox",
"CoreAudio"
});
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("AudioUnit");
}
PublicDefinitions.Add("WITH_OGGVORBIS=1");
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PrecompileForTargets = PrecompileTargetsType.Any;
}
}
public AppleARKitPoseTrackingLiveLink(ReadOnlyTargetRules Target) : base(Target)
{
//OptimizeCode = CodeOptimization.Never;
PrivateIncludePaths.AddRange(
new string[] {
"../../../../../../Plugins/Runtime/AR/Apple/AppleARKit/Source/AppleARKit/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[]
{
"CoreUObject",
"HeadMountedDisplay",
// "AugmentedReality",
"LiveLink",
"LiveLinkInterface",
"AppleARKit",
"AppleImageUtils"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.Add("ARKit");
}
}
public MetalRHI(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"ApplicationCore",
"Engine",
"RHI",
"RenderCore",
"ShaderCore",
"UtilityShaders"
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target,
"MTLPP"
);
PublicWeakFrameworks.Add("Metal");
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("QuartzCore");
string UseMetalStats = System.Environment.GetEnvironmentVariable("ENABLE_METAL_STATISTICS");
var StatsModule = System.IO.Path.Combine("Runtime", "NotForLicensees", "Mac", "MetalStatistics", "MetalStatistics.Build.cs");
bool bMetalStats = (UseMetalStats == "1") && System.IO.File.Exists(StatsModule);
if (bMetalStats)
{
PublicDefinitions.Add("METAL_STATISTICS=1");
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MetalStatistics",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MetalStatistics",
}
);
}
}
}
public AudioMixerAudioUnit(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.Add("TargetPlatform");
PublicIncludePaths.Add("Runtime/AudioMixer/Public");
PrivateIncludePaths.Add("Runtime/AudioMixer/Private");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
}
);
PrecompileForTargets = PrecompileTargetsType.None;
PrivateDependencyModuleNames.Add("AudioMixer");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
PublicFrameworks.AddRange(new string[]
{
"AudioToolbox",
"CoreAudio"
});
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.Add("AVFoundation");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("AudioUnit");
}
PublicDefinitions.Add("WITH_OGGVORBIS=1");
if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PrecompileForTargets = PrecompileTargetsType.Any;
}
}
public Agora(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// Add the import library
PublicSystemLibraryPaths.Add(Path.Combine(ModuleDirectory, "x64", "Release"));
PublicAdditionalLibraries.Add(Path.Combine(ModuleDirectory, "x64", "Release", "agora_rtc_sdk.lib"));
// Delay-load the DLL, so we can load it from the right place first
PublicDelayLoadDLLs.Add("agora_rtc_sdk.dll");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add(Path.Combine(ModuleDirectory, "Mac", "Release", "AgoraRtcEngineKit.framework"));
}
}
public BuglySDK(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalFrameworks.Add(new UEBuildFramework("Bugly", "iOS/Bugly.embeddedframework.zip"));
PublicFrameworks.Add("SystemConfiguration");
PublicFrameworks.Add("Security");
PublicAdditionalLibraries.Add("z");
PublicAdditionalLibraries.Add("c++");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "BuglySDK_UPL.xml")));
}
}
public Agora(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// Add the import library
PublicSystemLibraryPaths.Add(Path.Combine(ModuleDirectory, "x64", "Release"));
PublicAdditionalLibraries.Add(Path.Combine(ModuleDirectory, "x64", "Release", "agora_rtc_sdk.lib"));
// Delay-load the DLL, so we can load it from the right place first
PublicDelayLoadDLLs.Add("agora_rtc_sdk.dll");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add(Path.Combine(ModuleDirectory, "Mac", "Release", "AgoraRtcKit.framework"));
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AgoraPlugin", Path.Combine(ModuleDirectory, "copy.xml")));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalLibraries.Add(Path.Combine(ModuleDirectory, "iOS", "libcrypto.a"));
PublicAdditionalFrameworks.Add(new Framework("AgoraRtcKit", Path.Combine(ModuleDirectory, "iOS", "AgoraRtcKit.framework.zip"), ""));
PublicAdditionalFrameworks.Add(new Framework("AgoraRtcCryptoLoader", Path.Combine(ModuleDirectory, "iOS", "AgoraRtcCryptoLoader.framework.zip"), ""));
PublicAdditionalLibraries.Add("resolv");
PublicFrameworks.AddRange(
new string[] {
"CoreML",
"VideoToolbox",
"Accelerate",
"CFNetwork",
"OpenGLES",
"CoreTelephony"
}
);
}
}
public StandaloneRenderer(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Developer/StandaloneRenderer/Private");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"ImageWrapper",
"InputCore",
"SlateCore",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
// @todo: This should be private? Not sure!!
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("QuartzCore");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PublicFrameworks.AddRange(new string[] { "OpenGLES", "GLKit" });
// weak for IOS8 support since CAMetalLayer is in QuartzCore
PublicWeakFrameworks.AddRange(new string[] { "QuartzCore" });
}
RuntimeDependencies.Add("$(EngineDir)/Shaders/StandaloneRenderer/...", StagedFileType.UFS);
}
public MetalRHI(TargetInfo Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"Engine",
"RHI",
"RenderCore",
"ShaderCore",
"UtilityShaders"
}
);
PublicWeakFrameworks.Add("Metal");
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("QuartzCore");
bool bMetalStats = false;
if (bMetalStats)
{
Definitions.Add("METAL_STATISTICS=1");
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MetalStatistics",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MetalStatistics",
}
);
}
}
}
// https://docs.unrealengine.com/4.26/en-US/ProductionPipelines/BuildTools/UnrealBuildTool/ThirdPartyLibraries/
public PopH264(ReadOnlyTargetRules Target) : base(Target)
{
// tell UE there's no source to compile
Type = ModuleType.External;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// this will make it static link
PublicAdditionalLibraries.Add(Path.Combine(ModuleDirectory, "windows", "Release_x64", "PopH264.lib"));
// Delay-load the DLL, so we can load it from the right place first
// gr: without this, editor will fail if it doesnt find dll at bootup
// but if it doesnt find DLL, we'll get an exception as we have missing symbols
PublicDelayLoadDLLs.Add("PopH264.dll");
// Ensure that the DLL is staged along with the executable
var OutputPath = "$(TargetOutputDir)/PopH264.dll";
//var SourcePath = Path.Combine(ModuleDirectory, "windows", "Release_x64", "PopH264.dll");
//var SourcePath = "$(PluginDir)/Source/ThirdParty/PopH264/windows/Release_x64/PopH264.dll";
var SourcePath = Path.Combine(ModuleDirectory, "windows", "Release_x64", "PopH264.dll");
//RuntimeDependencies.Add("$(TargetOutputDir)/Foo.dll", Path.Combine(PluginDirectory, "Source/ThirdParty/bin/Foo.dll"));
//RuntimeDependencies.Add(OutputPath, SourcePath);
RuntimeDependencies.Add(SourcePath);
RuntimeDependencies.Add("$(PluginDir)/Source/ThirdParty/PopH264/windows/Release_x64/PopH264.dll");
Tools.DotNETCommon.Log.TraceInformation("Path");
Tools.DotNETCommon.Log.TraceInformation(SourcePath);
//RuntimeDependencies.Add("$(PluginDir)/Binaries/ThirdParty/PopH264/windows/Release_x64/PopH264.dll");
//RuntimeDependencies.Add("$(PluginDir)/Source/ThirdParty/PopH264/windows/Release_x64/PopH264.dll");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
// https://www.parallelcube.com/2018/03/01/using-thirdparty-libraries-in-our-ue4-mobile-project/
// linked & loaded
// gr: NO trailing slash or linker won't find it
PublicFrameworks.Add("$(PluginDir)/Source/ThirdParty/PopH264/PopH264.xcframework/macos-x86_64/PopH264_Osx.framework");
}
}
public AppleARKitPoseTrackingLiveLink(ReadOnlyTargetRules Target) : base(Target)
{
//OptimizeCode = CodeOptimization.Never;
PrivateIncludePaths.AddRange(new string[]
{
"../../../../../../Plugins/Runtime/AR/AppleAR/AppleARKit/Source/AppleARKit/Private",
});
PublicDependencyModuleNames.AddRange(new string[]
{
"Core",
"Engine",
});
PrivateDependencyModuleNames.AddRange(new string[]
{
"CoreUObject",
"HeadMountedDisplay",
"LiveLink",
"LiveLinkInterface",
"AppleARKit",
"AppleImageUtils",
"ARUtilities",
});
DynamicallyLoadedModuleNames.AddRange(new string[]
{
});
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.Add("ARKit");
}
}
public MetalRHI(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"ApplicationCore",
"Engine",
"RHI",
"RenderCore",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target,
"MTLPP"
);
PublicWeakFrameworks.Add("Metal");
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("QuartzCore");
}
}
public StandaloneRenderer(TargetInfo Target)
{
PrivateIncludePaths.Add("Developer/StandaloneRenderer/Private");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ImageWrapper",
"InputCore",
"SlateCore",
}
);
AddThirdPartyPrivateStaticDependencies(Target, "OpenGL");
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
// @todo: This should be private? Not sure!!
AddThirdPartyPrivateStaticDependencies(Target, "DX11");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("QuartzCore");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PublicFrameworks.AddRange(new string[] { "OpenGLES", "GLKit" });
// weak for IOS8 support since CAMetalLayer is in QuartzCore
PublicWeakFrameworks.AddRange(new string[] { "QuartzCore" });
}
}
public PopH264(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.Add(Path.Combine(ModuleDirectory, "windows", "Release_x64", "PopH264.lib"));
// Delay-load the DLL, so we can load it from the right place first
PublicDelayLoadDLLs.Add("PopH264.dll");
// Ensure that the DLL is staged along with the executable
// gr: can we use ModuleDirectory here to not require this dir to be "PopH264" ?
RuntimeDependencies.Add("$(PluginDir)/Binaries/ThirdParty/PopH264/windows/Release_x64/PopH264.dll");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
// https://www.parallelcube.com/2018/03/01/using-thirdparty-libraries-in-our-ue4-mobile-project/
// gr: can we use ModuleDirectory here to not require this dir to be "PopH264" ?
// linked & loaded
// gr: NO trailing slash or linker won't find it
PublicFrameworks.Add("$(PluginDir)/Source/ThirdParty/PopH264/PopH264.xcframework/macos-x86_64/PopH264_Osx.framework");
}
}
public Launch(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.Add("Runtime/Launch/Private");
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AutomationController",
"Media",
"MediaUtils",
"TaskGraph",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"MoviePlayer",
"Networking",
"PakFile",
"Projects",
"RenderCore",
"RHI",
"SandboxFile",
"Serialization",
"ShaderCore",
"ApplicationCore",
"Slate",
"SlateCore",
"Sockets",
"Overlay",
"UtilityShaders",
}
);
// Enable the LauncherCheck module to be used for platforms that support the Launcher.
// Projects should set Target.bUseLauncherChecks in their Target.cs to enable the functionality.
if (Target.bUseLauncherChecks &&
((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Mac)))
{
PrivateDependencyModuleNames.Add("LauncherCheck");
Definitions.Add("WITH_LAUNCHERCHECK=1");
}
else
{
Definitions.Add("WITH_LAUNCHERCHECK=0");
}
if (Target.Type != TargetType.Server)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"HeadMountedDisplay",
"MRMesh",
}
);
if ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64))
{
DynamicallyLoadedModuleNames.Add("D3D12RHI");
DynamicallyLoadedModuleNames.Add("D3D11RHI");
DynamicallyLoadedModuleNames.Add("XAudio2");
DynamicallyLoadedModuleNames.Add("AudioMixerXAudio2");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.Add("CoreAudio");
DynamicallyLoadedModuleNames.Add("AudioMixerAudioUnit");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.Add("AudioMixerSDL");
PrivateDependencyModuleNames.Add("Json");
}
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
// UFS clients are not available in shipping builds
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"NetworkFile",
"StreamingFile",
"CookedIterativeFile",
"AutomationWorker",
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
"Renderer",
}
);
if (Target.bCompileAgainstEngine)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MessagingCommon",
"MediaAssets"
}
);
PublicDependencyModuleNames.Add("SessionServices");
PrivateIncludePaths.Add("Developer/DerivedDataCache/Public");
// LaunchEngineLoop.cpp will still attempt to load XMPP but not all projects require it so it will silently fail unless referenced by the project's build.cs file.
// DynamicallyLoadedModuleNames.Add("XMPP");
DynamicallyLoadedModuleNames.Add("HTTP");
PrivateDependencyModuleNames.Add("ClothingSystemRuntimeInterface");
PrivateDependencyModuleNames.Add("ClothingSystemRuntime");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PublicIncludePathModuleNames.Add("ProfilerService");
DynamicallyLoadedModuleNames.AddRange(new string[] { "TaskGraph", "RealtimeProfiler", "ProfilerService" });
}
// The engine can use AutomationController in any connfiguration besides shipping. This module is loaded
// dynamically in LaunchEngineLoop.cpp in non-shipping configurations
if (Target.bCompileAgainstEngine && Target.Configuration != UnrealTargetConfiguration.Shipping)
{
DynamicallyLoadedModuleNames.AddRange(new string[] { "AutomationController" });
}
if (Target.bBuildEditor == true)
{
PublicIncludePathModuleNames.Add("ProfilerClient");
PrivateDependencyModuleNames.AddRange(
new string[] {
"SourceControl",
"UnrealEd",
"DesktopPlatform",
"PIEPreviewDeviceProfileSelector",
}
);
// ExtraModules that are loaded when WITH_EDITOR=1 is true
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AutomationWindow",
"ProfilerClient",
"Toolbox",
"GammaUI",
"ModuleUI",
"OutputLog",
"TextureCompressor",
"MeshUtilities",
"SourceCodeAccess"
}
);
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PrivateDependencyModuleNames.Add("MainFrame");
PrivateDependencyModuleNames.Add("Settings");
}
else
{
DynamicallyLoadedModuleNames.Add("MainFrame");
}
}
if (Target.Platform == UnrealTargetPlatform.IOS ||
Target.Platform == UnrealTargetPlatform.TVOS)
{
PrivateDependencyModuleNames.Add("OpenGLDrv");
PrivateDependencyModuleNames.Add("IOSAudio");
PrivateDependencyModuleNames.Add("AudioMixerAudioUnit");
DynamicallyLoadedModuleNames.Add("IOSRuntimeSettings");
DynamicallyLoadedModuleNames.Add("IOSLocalNotification");
PublicFrameworks.Add("OpenGLES");
// this is weak for IOS8 support for CAMetalLayer that is in QuartzCore
PublicWeakFrameworks.Add("QuartzCore");
PrivateDependencyModuleNames.Add("LaunchDaemonMessages");
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("OpenGLDrv");
PrivateDependencyModuleNames.Add("AndroidAudio");
PrivateDependencyModuleNames.Add("AudioMixerAndroid");
DynamicallyLoadedModuleNames.Add("AndroidRuntimeSettings");
DynamicallyLoadedModuleNames.Add("AndroidLocalNotification");
}
if ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Linux && Target.Type != TargetType.Server))
{
// TODO: re-enable after implementing resource tables for OpenGL.
DynamicallyLoadedModuleNames.Add("OpenGLDrv");
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PrivateDependencyModuleNames.Add("ALAudio");
PrivateDependencyModuleNames.Add("AudioMixerSDL");
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
// @todo ps4 clang bug: this works around a PS4/clang compiler bug (optimizations)
if (Target.Platform == UnrealTargetPlatform.PS4)
{
bFasterWithoutUnity = true;
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"LinuxCommonStartup"
}
);
}
}
public Blu(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"RenderCore",
"RHI",
"Slate",
"SlateCore",
"UMG",
"Json"
});
PrivateIncludePaths.AddRange(
new string[] {
"Blu/Private",
});
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "cef/Win/lib", "libcef.lib"));
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "cef/Win/lib", "libcef_dll_wrapper.lib"));
PublicDelayLoadDLLs.Add("d3dcompiler_43.dll");
PublicDelayLoadDLLs.Add("d3dcompiler_47.dll");
PublicDelayLoadDLLs.Add("ffmpegsumo.dll");
PublicDelayLoadDLLs.Add("libcef.dll");
PublicDelayLoadDLLs.Add("libEGL.dll");
PublicDelayLoadDLLs.Add("libGLESv2.dll");
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ThirdPartyPath, "cef/Win")
});
// Add our runtime dependencies
var filesToStage = Directory.GetFiles(Path.Combine(ThirdPartyPath, "cef/Win/shipping"), "*", SearchOption.AllDirectories);
stageFiles(filesToStage);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "cef/Linux/lib", "libcef.so"));
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "cef/Linux/lib", "libcef_dll_wrapper.a"));
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ThirdPartyPath, "cef/Linux")
});
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
var frameworkPath = Path.Combine(ThirdPartyPath, "cef/Mac/lib", "Chromium Embedded Framework.framework");
PublicFrameworks.Add(frameworkPath);
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "cef/Mac/lib", "libcef_dll_wrapper.a"));
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ThirdPartyPath, "cef", "Mac")
});
var filesToStage = Directory.GetFiles(Path.Combine(ThirdPartyPath, "cef/Mac/shipping"), "*", SearchOption.AllDirectories);
stageFiles(filesToStage);
filesToStage = Directory.GetFiles(Path.Combine(ThirdPartyPath, "cef/Mac/lib"), "*", SearchOption.AllDirectories);
stageFiles(filesToStage);
if (!UEBuildConfiguration.bBuildEditor)
{
AdditionalBundleResources.Add(new UEBuildBundleResource(Path.Combine(frameworkPath, "Chromium Embedded Framework"), "MacOS", false));
}
}
else
{
throw new BuildException("BLUI: Platform not supported");
}
}
public Noesis(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string NoesisBasePath = ModuleDirectory + "/NoesisSDK/";
string NoesisIncludePath = NoesisBasePath + "Include/";
string NoesisInteractivityIncludePath = NoesisBasePath + "Src/Packages/App/Interactivity/Include/";
PublicIncludePaths.Add(ModuleDirectory);
PublicIncludePaths.Add(NoesisIncludePath);
PublicIncludePaths.Add(NoesisInteractivityIncludePath);
// Let's try to make sure the right version of the SDK is in the right place.
const string RequiredRevision = "(r7619)";
const string RequiredVersionName = "2.2.0b5";
if (!Directory.Exists(NoesisBasePath))
{
throw new BuildException("Could not find NoesisGUI SDK in " + NoesisBasePath + ". Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Bin"))
{
throw new BuildException("Could not find NoesisGUI SDK Bin directory in " + NoesisBasePath + "Bin. Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Include"))
{
throw new BuildException("Could not find NoesisGUI SDK Include directory in " + NoesisBasePath + "Include. Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Lib"))
{
throw new BuildException("Could not find NoesisGUI SDK Lib directory in " + NoesisBasePath + "Lib. Minimum required version is " + RequiredVersionName);
}
string NoesisSdkVersionInfo;
try
{
NoesisSdkVersionInfo = File.ReadAllText(NoesisBasePath + "version.txt");
}
catch (Exception)
{
throw new BuildException("Could not find NoesisGUI SDK version.txt in " + NoesisBasePath + "version.txt. Minimum required version is " + RequiredVersionName);
}
string[] SplitVersion = NoesisSdkVersionInfo.Split(' ');
if (String.Compare(SplitVersion[SplitVersion.Length - 1], RequiredRevision) < 0)
{
throw new BuildException("Wrong version of the NoesisGUI SDK installed in " + NoesisBasePath + ". Minimum required version is " + RequiredVersionName);
}
PublicSystemIncludePaths.Add(NoesisIncludePath);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string NoesisLibPath = NoesisBasePath + "Lib/windows_x86_64/";
PublicLibraryPaths.Add(NoesisLibPath);
PublicAdditionalLibraries.Add("Noesis.lib");
PublicFrameworks.Add("CoreText");
string BaseTargetPath = "";
if (Target.LinkType == TargetLinkType.Monolithic)
{
if (Target.ProjectFile != null)
{
BaseTargetPath = DirectoryReference.FromFile(Target.ProjectFile).ToString();
}
}
else
{
BaseTargetPath = Target.RelativeEnginePath;
}
string NoesisDllPath = "/NoesisSDK/Bin/windows_x86_64/Noesis.dll";
string NoesisDllTargetPath = "/Binaries/Win64/Noesis.dll";
if (Target.LinkType == TargetLinkType.Monolithic)
{
RuntimeDependencies.Add("$(ProjectDir)" + NoesisDllTargetPath);
}
else
{
RuntimeDependencies.Add("$(EngineDir)" + NoesisDllTargetPath);
}
if (BaseTargetPath != "")
{
try
{
if (!System.IO.Directory.Exists(BaseTargetPath + "/Binaries/Win64"))
{
System.IO.Directory.CreateDirectory(BaseTargetPath + "/Binaries/Win64");
}
System.IO.File.Copy(ModuleDirectory + NoesisDllPath, BaseTargetPath + NoesisDllTargetPath, true);
}
catch (IOException Exception)
{
if (Exception.HResult != -2147024864) // 0x80070020: The process cannot access the file ... because it is being used by another process.
{
throw;
}
}
}
}
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");
if (Target.Version.MinorVersion <= 21)
{
PublicAdditionalShadowFiles.Add(Path.Combine(NoesisLibPath, "libNoesis.a"));
}
}
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");
}
}
