public SteamAudio(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"SteamAudio/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"AudioMixer",
"InputCore",
"RenderCore",
"RHI"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Projects",
"AudioMixer"
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
PrivateDependencyModuleNames.Add("Landscape");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "libPhonon");
switch (Target.Platform)
{
case UnrealTargetPlatform.Win32:
PrivateDependencyModuleNames.Add("XAudio2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11Audio");
break;
case UnrealTargetPlatform.Win64:
PrivateDependencyModuleNames.Add("XAudio2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11Audio");
PublicDelayLoadDLLs.Add("GPUUtilities.dll");
PublicDelayLoadDLLs.Add("tanrt64.dll");
break;
case UnrealTargetPlatform.Android:
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "SteamAudio_APL.xml"));
break;
default:
break;
}
}
public DevToDev(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
var ModulePath = ModuleDirectory;
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalFrameworks.Add(
new Framework(
"devtodev",
"../../ThirdParty/iOS/devtodev.embeddedframework.zip"
)
);
PublicFrameworks.AddRange(
new string[] {
"UIKit",
"Foundation",
"AdSupport",
"StoreKit",
"CoreGraphics",
"Security",
"SystemConfiguration",
"UserNotifications"
}
);
PublicAdditionalLibraries.AddRange(
new string[] {
"z",
"c++"
});
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("Launch");
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private/Android"));
}
else
{
// 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",
"Engine"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"Analytics",
"AnalyticsBlueprintLibrary",
"Engine"
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(ModuleDirectory, "../DTDAnalytics_APL.xml"));
}
}
public GoogleARCoreBase(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[]
{
"GoogleARCoreBase/Private",
}
);
PublicIncludePathModuleNames.Add("TargetPlatform");
PublicDependencyModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay",
"AugmentedReality",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"EngineSettings",
"Slate",
"SlateCore",
"RHI",
"RenderCore",
"AndroidPermission",
"GoogleARCoreRendering",
"GoogleARCoreSDK",
"OpenGL",
"UElibPNG",
"zlib"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"Settings" // For editor settings panel.
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
// Additional dependencies on android...
PrivateDependencyModuleNames.Add("Launch");
// Register Plugin Language
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(ModuleDirectory, "GoogleARCoreBase_APL.xml"));
}
if (Target.bBuildEditor)
{
string ExecName = "";
if (Target.Platform == UnrealTargetPlatform.Win64)
{
ExecName = "Windows/arcoreimg.exe";
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
ExecName = "Linux/arcoreimg";
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
ExecName = "Mac/ptdbtool_macos_lipobin";
}
if (ExecName.Length > 0)
{
RuntimeDependencies.Add("$(EngineDir)/Plugins/Runtime/AR/Google/GoogleARCore/Binaries/ThirdParty/Google/ARCoreImg/" + ExecName);
}
}
bFasterWithoutUnity = false;
}
public Everyplay(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Developer/Everyplay/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"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 ...
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Settings",
"Launch",
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.AddRange(
new string[]
{
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, BuildConfiguration.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "Everyplay_APL.xml")));
}
}
public SnapdragonVRHMD(ReadOnlyTargetRules Target) : base(Target)
{
//Debug.Print("Build the SnapdragonVRHMD Plugin");
var EngineDir = Path.GetFullPath(Target.RelativeEnginePath);
var rendererPrivatePath = Path.Combine(EngineDir, @"Source/Runtime/Renderer/Private");
var corePrivatePath = Path.Combine(EngineDir, "Source/Runtime/Core/Private");
var launchPrivatePath = Path.Combine(EngineDir, "Source/Runtime/Launch/Private");
var openglDrvPrivatePath = Path.Combine(EngineDir, @"Source/Runtime/OpenGLDrv/Private");
var openglPath = Path.Combine(EngineDir, @"Source\ThirdParty\OpenGL");
PrivateIncludePaths.AddRange(
new string[] {
"SnapdragonVRHMD/Private",
rendererPrivatePath,
corePrivatePath,
openglDrvPrivatePath,
openglPath
//"../../../../../Source/Runtime/Renderer/Private",
//"../../../../../Source/Runtime/Core/Private"
// ... add other private include paths required here ...
}
);
PublicIncludePaths.AddRange(
new string[] {
"SnapdragonVRHMD/Public",
// ... add public include paths required here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"RHI",
"RenderCore",
"Renderer",
"ShaderCore",
"HeadMountedDisplay",
"OpenGLDrv",
"Slate",
"SlateCore",
"LibSvrApi",
"NoloVR"
}
);
PrivateIncludePathModuleNames.AddRange(new string[]
{
"NoloVR"
});
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("Launch");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
// PrivateIncludePaths.AddRange(
// new string[] {
// openglDrvPrivatePath
// //"../../../../../Source/Runtime/OpenGLDrv/Private",
// // ... add other private include paths required here ...
// }
// );
if (Target.Platform == UnrealTargetPlatform.Android)
{
//PrivateDependencyModuleNames.AddRange(new string[] { "LibSvrApi" });
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "SnapdragonVRHMD_APL.xml"));
}
}
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");
}
}
public IJKPlayerUE(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
PublicIncludePaths.AddRange(
new string[] {
//"IJKPlayerUE/Public",
Path.GetFullPath(Path.Combine(ModuleDirectory, "Public"))
}
);
PrivateIncludePaths.AddRange(
new string[] {
"IJKPlayerUE/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Json",
"JsonUtilities"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.AddRange(new string[] { "Launch" });
string ArchDir = "armeabi-v7a";
string LibDir = Path.GetFullPath(Path.Combine(ModuleDirectory, "../ThirdParty/IJKPlayerUELibrary/IJKPlayerLib/Android"));
string LibPath = Path.Combine(LibDir, ArchDir);
System.Console.WriteLine("--------------Android LibPath = " + LibPath);
PublicSystemLibraryPaths.Add(LibPath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "IJKPlayerUE_APL.xml"));
}
}
public OculusHMD(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
// Relative to Engine\Plugins\Runtime\Oculus\OculusVR\Source
"../../../../../Source/Runtime/Renderer/Private",
"../../../../../Source/Runtime/OpenGLDrv/Private",
"../../../../../Source/Runtime/VulkanRHI/Private",
"../../../../../Source/Runtime/Engine/Classes/Components",
"../../../../../Source/Runtime/Engine/Classes/Kismet",
});
PublicIncludePathModuleNames.AddRange(
new string[] {
"Launch",
"ProceduralMeshComponent",
});
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateIncludePaths.Add("../../../../../Source/Runtime/VulkanRHI/Private/Windows");
}
else
{
PrivateIncludePaths.Add("../../../../../Source/Runtime/VulkanRHI/Private/" + Target.Platform);
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"RHI",
"RenderCore",
"Renderer",
"Slate",
"SlateCore",
"ImageWrapper",
"MediaAssets",
"Analytics",
"UtilityShaders",
"OpenGLDrv",
"VulkanRHI",
"OVRPlugin",
"ProceduralMeshComponent",
"Projects",
});
PublicDependencyModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay",
});
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
// D3D
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"D3D11RHI",
"D3D12RHI",
});
PrivateIncludePaths.AddRange(
new string[]
{
"OculusMR/Public",
"../../../../../Source/Runtime/Windows/D3D11RHI/Private",
"../../../../../Source/Runtime/Windows/D3D11RHI/Private/Windows",
"../../../../../Source/Runtime/D3D12RHI/Private",
"../../../../../Source/Runtime/D3D12RHI/Private/Windows",
});
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX12");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAPI");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11Audio");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectSound");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAftermath");
AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelMetricsDiscovery");
}
// Vulkan
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
}
// OVRPlugin
{
PublicDelayLoadDLLs.Add("OVRPlugin.dll");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Oculus/OVRPlugin/OVRPlugin/" + Target.Platform.ToString() + "/OVRPlugin.dll");
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
// We are not currently supporting Mixed Reality on Android, but we need to include IOculusMRModule.h for OCULUS_MR_SUPPORTED_PLATFORMS definition
PrivateIncludePaths.AddRange(
new string[]
{
"OculusMR/Public"
});
// Vulkan
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
}
// AndroidPlugin
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "GearVR_APL.xml"));
}
}
}
public ARX(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"ARX/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"ARX/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
string LibraryPath = Path.Combine(ThirdPartyPath, "lib", Target.Platform.ToString(), Target.Architecture);
string IncludePath = Path.Combine(ThirdPartyPath, "include", Target.Platform.ToString(), Target.Architecture);
Console.WriteLine("includepath: " + IncludePath);
if (Target.Platform == UnrealTargetPlatform.Linux)
{
PublicIncludePaths.AddRange(new string[] {
Path.Combine(IncludePath),
});
PublicAdditionalLibraries.AddRange(new string[] {
Path.Combine(LibraryPath, "ARX"),
});
RuntimeDependencies.Add(Path.Combine(LibraryPath, "libARX.so"));
}
else if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
PublicIncludePaths.AddRange(new string[] {
Path.Combine(IncludePath),
});
RuntimeDependencies.Add(Path.Combine(LibraryPath, "ARX.dll"));
PublicDelayLoadDLLs.Add("ARX.dll");
Console.WriteLine("Attempting to include lib: " + Path.Combine(LibraryPath, "ARX.lib"));
PublicAdditionalLibraries.AddRange(new string[] {
Path.Combine(LibraryPath, "AR.lib"),
Path.Combine(LibraryPath, "AR2.lib"),
Path.Combine(LibraryPath, "ARG.lib"),
Path.Combine(LibraryPath, "ARUtil.lib"),
Path.Combine(LibraryPath, "ARVideo.lib"),
Path.Combine(LibraryPath, "OCVT.lib"),
Path.Combine(LibraryPath, "Eden.lib"),
Path.Combine(LibraryPath, "libjpeg.lib"),
Path.Combine(LibraryPath, "zlibstatic.lib"),
Path.Combine(LibraryPath, "KPM.lib"),
Path.Combine(LibraryPath, "pthreadVC2static.lib")
});
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string[] archs = new string[] { /*"arm64-v8a",*/ "armeabi-v7a" /*, "x86","x86_64"*/ };
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include"));
foreach (string arch in archs)
{
// Target.Architecture does not seem to work in Android
IncludePath = Path.Combine(ThirdPartyPath, "include", Target.Platform.ToString(), arch);
LibraryPath = Path.Combine(ThirdPartyPath, "lib", Target.Platform.ToString(), arch);
PublicIncludePaths.Add(IncludePath);
PublicLibraryPaths.Add(LibraryPath);
RuntimeDependencies.Add(Path.Combine(LibraryPath, "libARX.so"));
PublicAdditionalLibraries.AddRange(new string[] {
Path.Combine("ARX")
});
}
DynamicallyLoadedModuleNames.Add("ARX");
// this is the preferred way to include shared libraries to APK.
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "ARX_APL.xml"));
}
}
public NibiruHMD(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
//Unreal engine install path
string ue4_include_path = Path.GetFullPath(Path.Combine(Target.RelativeEnginePath, "Source/Runtime/Renderer/Private"));
string ue4_include_path2 = Path.GetFullPath(Path.Combine(Target.RelativeEnginePath, "Source/Runtime/Core/Private"));
string ue4_include_path3 = Path.GetFullPath(Path.Combine(Target.RelativeEnginePath, "Source/Runtime/Launch/Private"));
string ue4_include_path4 = Path.GetFullPath(Path.Combine(Target.RelativeEnginePath, "Source/Runtime/OpenGLDrv/Private"));
string ue4_include_path5 = Path.GetFullPath(Path.Combine(Target.RelativeEnginePath, "Source/Runtime/ApplicationCore/Private"));
PrivateIncludePaths.AddRange(
new string[] {
// ... add other private include paths required here ...
"NibiruHMD/Private",
ue4_include_path,
ue4_include_path2,
ue4_include_path3,
ue4_include_path4,
ue4_include_path5
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RHI",
"RenderCore",
"Renderer",
"HeadMountedDisplay",
"InputCore"
// ... add private dependencies that you statically link with here ...
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("Launch");
}
PrivateDependencyModuleNames.Add("OpenGLDrv");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
if (Target.bBuildEditor == true)
{
System.Console.WriteLine("RUN-------is BuildEditor");
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd"
});
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"NibiruVR"
});
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "NibiruVRHMD_APL.xml"));
}
}
public bool LoadFFmpeg(ReadOnlyTargetRules Target)
{
bool isLibrarySupported = false;
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
isLibrarySupported = true;
string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64" : "Win32";
string LibrariesPath = Path.Combine(Path.Combine(Path.Combine(ThirdPartyPath, "ffmpeg", "lib"), "vs"), PlatformString);
System.Console.WriteLine("... LibrariesPath -> " + LibrariesPath);
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);
foreach (string dll in dlls)
{
PublicDelayLoadDLLs.Add(dll);
//CopyToBinaries(Path.Combine(BinariesPath, dll), Target);
RuntimeDependencies.Add(Path.Combine(BinariesPath, dll), StagedFileType.NonUFS);
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
isLibrarySupported = true;
//string LibrariesPath = Path.Combine(Path.Combine(ThirdPartyPath, "ffmpeg", "lib"), "osx");
string LibrariesPath = "/usr/local/lib";
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));
//PublicDelayLoadDLLs.Add(Path.Combine(LibrariesPath, lib));
//CopyToBinaries(Path.Combine(LibrariesPath, lib), Target);
//RuntimeDependencies.Add(Path.Combine(LibrariesPath, lib), StagedFileType.NonUFS);
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
isLibrarySupported = true;
string LibrariesPath = Path.Combine(Path.Combine(ThirdPartyPath, "ffmpeg", "lib"), "android");
string[] Platforms = { "armeabi-v7a", "arm64-v8a", "x86", "x86_64" };
string[] libs = { "libavcodec.so", "libavdevice.so", "libavfilter.so", "libavformat.so", "libavutil.so", "libswresample.so", "libswscale.so" };
System.Console.WriteLine("Architecture: " + Target);
foreach (string platform in Platforms)
{
foreach (string lib in libs)
{
PublicAdditionalLibraries.Add(Path.Combine(Path.Combine(LibrariesPath, platform), lib));
}
}
string finalPath = Path.Combine(ModulePath, "FFMPEGMedia_APL.xml");
System.Console.WriteLine("... APL Path -> " + finalPath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", finalPath));
}
if (isLibrarySupported)
{
// Include path
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "ffmpeg", "include"));
}
return(isLibrarySupported);
}
public AdMob(ReadOnlyTargetRules Target) : base(Target)
{
string strEngineDir = GetEngineDirectory();
string strEngineVersion = ReadEngineVersion(strEngineDir);
System.Console.WriteLine("version:" + strEngineVersion);
/*Definitions.Add( string.Format("ENGINE_VERSION={0}", strEngineVersion) );
* Definitions.Add(string.Format("ENGINE_MAJOR_VERSION={0}", EngineMajorVersion));
* Definitions.Add(string.Format("ENGINE_MINOR_VERSION={0}", EngineMinorVersion));
* Definitions.Add(string.Format("ENGINE_PATCH_VERSION={0}", EnginePatchVersion));*/
PublicIncludePaths.AddRange(
new string[] {
"AdMob/Public"
// ... add public include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"AdCollection",
// ... 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)
{
PrivateIncludePaths.Add("Private/IOS");
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"GoogleMobileAds", // Framework name
"../ThirdParty/ThirdPartyFrameworks/GoogleMobileAds.embeddedframework.zip")
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"AdsUtil", // Framework name
"../ThirdParty/ThirdPartyFrameworks/AdsUtil.embeddedframework.zip")
);
PublicFrameworks.AddRange(
new string[]
{
"EventKit",
"MediaPlayer",
"AdSupport",
"CoreLocation",
"SystemConfiguration",
"MessageUI",
"Security",
"CoreTelephony"
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateIncludePaths.Add("Private/Android");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Launch",
}
);
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
if (EngineMinorVersion == "18")
{
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "AdMob418_UPL.xml")));
}
else
{
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "AdMob_UPL.xml")));
}
}
else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateIncludePaths.Add("Private/Windows");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PrivateIncludePaths.Add("Private/Mac");
}
else
{
PrecompileForTargets = PrecompileTargetsType.None;
}
}
public Voice(ReadOnlyTargetRules Target) : base(Target)
{
PublicDefinitions.Add("VOICE_PACKAGE=1");
bool bDontNeedCapture = (Target.Type == TargetType.Server);
if (bDontNeedCapture)
{
PublicDefinitions.Add("VOICE_MODULE_WITH_CAPTURE=0");
}
else
{
PublicDefinitions.Add("VOICE_MODULE_WITH_CAPTURE=1");
}
PublicIncludePathModuleNames.AddRange(
new string[] {
"AndroidPermission"
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Engine",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Online/Voice/Private",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"AudioMixer",
"SignalProcessing"
}
);
if (Target.Platform.IsInGroup(UnrealPlatformGroup.Windows))
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectSound");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.AddRange(new string[] { "CoreAudio", "AudioUnit", "AudioToolbox" });
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Linux) && !bDontNeedCapture)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "libOpus");
if (Target.Platform == UnrealTargetPlatform.Android)
{
string ModulePath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(ModulePath, "AndroidVoiceImpl_UPL.xml"));
}
}
public FireBase(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string strEngineDir = GetEngineDirectory();
string strEngineVersion = ReadEngineVersion(strEngineDir);
System.Console.WriteLine("version:" + strEngineVersion);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateIncludePaths.Add("FireBase/ThirdParty/FireBaseCpp/include");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Launch",
}
);
PublicLibraryPaths.Add(Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/FireBaseCpp/libs/android/armeabi")));
PublicLibraryPaths.Add(Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/FireBaseCpp/libs/android/armeabi-v7a")));
//PublicLibraryPaths.Add(Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/FireBaseCpp/libs/android/arm64-v8a")));
string[] StaticLibrariesAndroid = new string[] {
"app",
"database",
};
foreach (string Lib in StaticLibrariesAndroid)
{
PublicAdditionalLibraries.Add(Lib);
}
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "FireBase_UPL.xml"));
}
else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateIncludePaths.Add("FireBase/Private/Common");
PrivateIncludePaths.Add("FireBase/Private/Windows");
PrivateIncludePaths.Add("FireBase/ThirdParty/FireBaseCpp/include");
PublicLibraryPaths.Add(Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/FireBaseCpp/libs/windows")));
}
/*else if(Target.Platform == UnrealTargetPlatform.UWP64 || Target.Platform == UnrealTargetPlatform.UWP32)
* {
* PrivateIncludePaths.Add("FireBase/Private/Common");
* PrivateIncludePaths.Add("FireBase/Private/Windows");
* PrivateIncludePaths.Add("FireBase/ThirdParty/FireBaseCpp/include");
*
* PublicLibraryPaths.Add(Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/FireBaseCpp/libs/windows")));
* }*/
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateIncludePaths.Add("FireBase/Private/Common");
PrivateIncludePaths.Add("FireBase/Private/Windows");
PrivateIncludePaths.Add("FireBase/ThirdParty/FireBaseCpp/include");
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PrivateIncludePaths.Add("FireBase/Private/Common");
PrivateIncludePaths.Add("FireBase/Private/Windows");
PrivateIncludePaths.Add("FireBase/ThirdParty/FireBaseCpp/include");
}
}
public OnlineSubsystemGoogle(ReadOnlyTargetRules Target) : base(Target)
{
Definitions.Add("ONLINESUBSYSTEMGOOGLE_PACKAGE=1");
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PrivateIncludePaths.Add("Private");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"HTTP",
"ImageCore",
"Json",
"Sockets",
"OnlineSubsystem",
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
Definitions.Add("WITH_GOOGLE=1");
Definitions.Add("UE4_GOOGLE_VER=4.0.1");
PrivateIncludePaths.Add("Private/IOS");
// These are iOS system libraries that Google depends on
PublicFrameworks.AddRange(
new string[] {
"SafariServices",
"SystemConfiguration"
});
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"GoogleSignIn",
"ThirdParty/IOS/GoogleSignInSDK/GoogleSignIn.embeddedframework.zip",
"GoogleSignIn.bundle"
)
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"GoogleAppUtilities",
"ThirdParty/IOS/GoogleSignInSDK/GoogleAppUtilities.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"GoogleSignInDependencies",
"ThirdParty/IOS/GoogleSignInSDK/GoogleSignInDependencies.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"GoogleSymbolUtilities",
"ThirdParty/IOS/GoogleSignInSDK/GoogleSymbolUtilities.embeddedframework.zip"
)
);
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Launch",
}
);
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "OnlineSubsystemGoogle_UPL.xml")));
PrivateIncludePaths.Add("Private/Android");
}
else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateIncludePaths.Add("Private/Windows");
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PrivateIncludePaths.Add("Private/XboxOne");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PrivateIncludePaths.Add("Private/PS4");
}
else
{
PrecompileForTargets = PrecompileTargetsType.None;
}
}
public GoogleVRTransition2D(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
"Runtime/Launch/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"GoogleVRTransition2D/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
// ... 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.Android)
{
PrivateDependencyModuleNames.AddRange(new string[] { "GoogleVRTransition2D" });
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "GoogleVRTransition2D_APL.xml"));
}
if (Target.Platform == UnrealTargetPlatform.Lumin)
{
PrecompileForTargets = PrecompileTargetsType.None;
}
}
public GoogleVRController(ReadOnlyTargetRules Target) : base(Target)
{
bFasterWithoutUnity = true;
string GoogleVRSDKDir = Target.UEThirdPartySourceDirectory + "GoogleVR/";
PrivateIncludePaths.AddRange(
new string[] {
"GoogleVRController/Private",
"GoogleVRController/Private/ArmModel",
// ... add other private include paths required here ...
GoogleVRSDKDir + "include",
GoogleVRSDKDir + "include/vr/gvr/capi/include",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"ApplicationCore",
"Engine",
"InputCore",
"InputDevice",
"HeadMountedDisplay",
"GoogleVRHMD",
"UMG",
"Slate",
"SlateCore"
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("Launch");
}
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PublicIncludePaths.Add("Developer/Android/AndroidDeviceDetection/Public");
PublicIncludePaths.Add("Developer/Android/AndroidDeviceDetection/Public/Interfaces");
PrivateDependencyModuleNames.AddRange(
new string[]
{
"GoogleVR",
"GoogleInstantPreview",
});
}
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.AddRange(new string[] { "GoogleVR" });
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "GoogleVRController_APL.xml"));
}
}
//=====Подключить библиотеки в зависимости от платформы/Enable libraries depending on the platform================
public void LoadLib(ReadOnlyTargetRules Target)
{
//----------Если платформа Windows/If the Windows platform-----------------------------------------------------------------------------------
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
//Add Include path /Добавить видиомсть папки include
PublicIncludePaths.Add(Path.Combine(PathThirdPartyWindows, "include"));
string[] Libs =
{
/*"example.lib",
* "example2.lib"*/
};
string[] DLLs =
{
/*"example.dll",
* "example2.dll"*/
};
//Add Static Libraries/Добавление Статических Библиотек
foreach (string Lib in Libs)
{
PublicAdditionalLibraries.Add(Path.Combine(PathThirdPartyWindows, "lib", Lib));
}
//Add Dynamic Libraries/Добавление Динамических Библиоте
foreach (string DLL in DLLs)
{
PublicDelayLoadDLLs.Add(Path.Combine(PathThirdPartyWindows, "lib", DLL));
}
}
//----------Если платформа Android/If the Android platform-------------------------------------------------------------------------------------
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string ArchArmV7a = "armeabi-v7a";
string ArchArmV8a = "arm64-v8a";
PrivateDependencyModuleNames.AddRange(new string[]
{
"Launch"
}
);
//------------------- .h--------------------
PrivateIncludePaths.AddRange(new string[] { Path.Combine(ModuleDirectory, "Private", "Android") });
//-------------------- .so ------------------
string[] Libs =
{
#if UE_4_25_OR_LATER
#else
"libc++_shared.so",
#endif
//"Example.so",
//"Example2.so"
};
foreach (string Lib in Libs)
{
PublicAdditionalLibraries.Add(Path.Combine(PathThirdPartyAndroid, ArchArmV7a, "lib", Lib));
PublicAdditionalLibraries.Add(Path.Combine(PathThirdPartyAndroid, ArchArmV8a, "lib", Lib));
}
//----------------------------XML---------------------------------------
#if UE_4_25_OR_LATER
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PathThirdPartyAndroid, "AndroidV25.xml"));
#else
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PathThirdPartyAndroid, "AndroidV24.xml"));
#endif
}
//----------Если платформа IOS/If the IOS platform-------------------------------------------------------------------------------------------
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PrivateDependencyModuleNames.AddRange(new string[]
{
"Launch"
}
);
//----------------- p-list ------------------
AdditionalPropertiesForReceipt.Add("IOSPlugin", Path.Combine(ModuleDirectory, "Private", "IOS", "plist.xml"));
//------------------- .h--------------------
PrivateIncludePaths.AddRange(new string[] { Path.Combine(ModuleDirectory, "Private", "IOS") });
PublicIncludePaths.Add(Path.Combine(PathThirdPartyIOS, "include"));
//------------------- Public framework------------------------------------
PublicFrameworks.AddRange(
new string[]
{
"CoreTelephony",
"SystemConfiguration",
"UIKit",
"Foundation",
"CoreGraphics",
"MobileCoreServices",
"StoreKit",
"CFNetwork",
"CoreData",
"Security",
"CoreLocation",
"WatchConnectivity",
"MediaPlayer",
"CoreFoundation"
}
);
//------------------- Private framework---------------------------------------
string[] frameworks =
{
/*"example", //example.framework
* "example2" //example2.framework*/
};
foreach (string l_Framework in frameworks)
{
PublicAdditionalFrameworks.Add(
new Framework(l_Framework,
Path.Combine(PathThirdPartyIOS, "frameworks", "example.framework.zip"), "" //example.framework.zip
)
);
}
}
//----------Неподдерживаемая платформа/Unsupported platform--------------------------
else
{
string Err = string.Format("{0} dedicated server is made to depend on {1}. We want to avoid this, please correct module dependencies.", Target.Platform.ToString(), this.ToString()); System.Console.WriteLine(Err);
}
}
public FMODStudio(TargetInfo Target)
#endif
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = "Private/FMODStudioPrivatePCH.h";
bFasterWithoutUnity = true;
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public/FMOD"));
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Classes"));
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Media",
"Projects"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneTracks"
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("AssetRegistry");
PrivateDependencyModuleNames.Add("UnrealEd");
}
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 platformName = Target.Platform.ToString();
string platformMidName = "";
string linkExtension = "";
string dllExtension = "";
string libPrefix = "";
// ModuleDirectory points to FMODStudio\source\FMODStudio, need to get back to binaries directory for our libs
string BasePath = System.IO.Path.Combine(ModuleDirectory, "../../Binaries", platformName);
// Collapse the directory path, otherwise OSX is having issues with plugin paths.
BasePath = Utils.CleanDirectorySeparators(BasePath);
string copyThirdPartyPath = "";
bool bAddRuntimeDependencies = true;
bool bAddDelayLoad = false;
bool bShortLinkNames = false;
bool bLinkFromBinaries = true;
// Minimum UE version for Switch 4.15
System.Console.WriteLine("Target Platform -- " + Target.Platform.ToString());
if (Target.Platform.ToString() == "Switch")
{
linkExtension = ".a";
dllExtension = ".a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
}
else if (Target.Platform.ToString() == "UWP64")
{
platformMidName = "_X64";
linkExtension = ".lib";
dllExtension = ".dll";
bAddDelayLoad = true;
}
else
{
switch (Target.Platform)
{
case UnrealTargetPlatform.Win32:
linkExtension = "_vc.lib";
dllExtension = ".dll";
bAddDelayLoad = true;
break;
case UnrealTargetPlatform.Win64:
platformMidName = "64";
linkExtension = "_vc.lib";
dllExtension = ".dll";
bAddDelayLoad = true;
break;
case UnrealTargetPlatform.Mac:
linkExtension = dllExtension = ".dylib";
libPrefix = "lib";
bLinkFromBinaries = false;
break;
case UnrealTargetPlatform.XboxOne:
linkExtension = "_vc.lib";
dllExtension = ".dll";
copyThirdPartyPath = "../XBoxOne"; // XBoxOne still doesn't seem to support plugins with .dlls
bAddDelayLoad = false;
break;
case UnrealTargetPlatform.PS4:
linkExtension = "_stub.a";
dllExtension = ".prx";
libPrefix = "lib";
bAddDelayLoad = true;
break;
case UnrealTargetPlatform.Android:
// Don't use an explicit path with the .so, let the architecture dirs be filtered by UBT
PublicLibraryPaths.Add(System.IO.Path.Combine(BasePath, "armeabi-v7a"));
PublicLibraryPaths.Add(System.IO.Path.Combine(BasePath, "arm64-v8a"));
PublicLibraryPaths.Add(System.IO.Path.Combine(BasePath, "x86"));
bAddRuntimeDependencies = false; // Don't use this system
bShortLinkNames = true; // strip off lib and .so
linkExtension = dllExtension = ".so";
libPrefix = "lib";
break;
case UnrealTargetPlatform.IOS:
linkExtension = "_iphoneos.a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
break;
case UnrealTargetPlatform.Linux:
BasePath = System.IO.Path.Combine(BasePath, "x86_64");
linkExtension = ".so";
dllExtension = ".so";
libPrefix = "lib";
break;
default:
//extName = ".a";
throw new System.Exception(System.String.Format("Unsupported platform {0}", Target.Platform.ToString()));
//break;
}
}
//System.Console.WriteLine("FMOD Current path: " + System.IO.Path.GetFullPath("."));
//System.Console.WriteLine("FMOD Base path: " + BasePath);
PublicLibraryPaths.Add(BasePath);
string fmodLibName = System.String.Format("{0}fmod{1}{2}{3}", libPrefix, configName, platformMidName, linkExtension);
string fmodStudioLibName = System.String.Format("{0}fmodstudio{1}{2}{3}", libPrefix, configName, platformMidName, linkExtension);
string fmodDllName = System.String.Format("{0}fmod{1}{2}{3}", libPrefix, configName, platformMidName, dllExtension);
string fmodStudioDllName = System.String.Format("{0}fmodstudio{1}{2}{3}", libPrefix, configName, platformMidName, dllExtension);
string fmodLibPath = System.IO.Path.Combine(BasePath, fmodLibName);
string fmodStudioLibPath = System.IO.Path.Combine(BasePath, fmodStudioLibName);
string fmodDllPath = System.IO.Path.Combine(BasePath, fmodDllName);
string fmodStudioDllPath = System.IO.Path.Combine(BasePath, fmodStudioDllName);
System.Collections.Generic.List <string> plugins = GetPlugins(BasePath);
if (bShortLinkNames)
{
// For android we have provided the paths to all architectures above
// Just provide the name without "lib" and without extension
PublicAdditionalLibraries.Add(System.String.Format("fmod{0}{1}", configName, platformMidName));
PublicAdditionalLibraries.Add(System.String.Format("fmodstudio{0}{1}", configName, platformMidName));
}
else if (bLinkFromBinaries)
{
PublicAdditionalLibraries.Add(fmodLibPath);
PublicAdditionalLibraries.Add(fmodStudioLibPath);
}
else
{
string LibPath = System.IO.Path.Combine(ModuleDirectory, "../../Libs/Mac/");
PublicAdditionalLibraries.Add(System.String.Format("{0}libfmod{1}.dylib", LibPath, configName));
PublicAdditionalLibraries.Add(System.String.Format("{0}libfmodStudio{1}.dylib", LibPath, configName));
}
if (bAddRuntimeDependencies)
{
RuntimeDependencies.Add(fmodDllPath);
RuntimeDependencies.Add(fmodStudioDllPath);
foreach (string plugin in plugins)
{
string pluginPath = System.IO.Path.Combine(BasePath, plugin + dllExtension);
System.Console.WriteLine("Adding reference to FMOD plugin: " + pluginPath);
RuntimeDependencies.Add(pluginPath);
}
}
if (copyThirdPartyPath.Length != 0)
{
string destPath = System.IO.Path.Combine(Target.UEThirdPartyBinariesDirectory, copyThirdPartyPath);
System.IO.Directory.CreateDirectory(destPath);
string fmodDllDest = System.IO.Path.Combine(destPath, fmodDllName);
string fmodStudioDllDest = System.IO.Path.Combine(destPath, fmodStudioDllName);
CopyFile(fmodDllPath, fmodDllDest);
CopyFile(fmodStudioDllPath, fmodStudioDllDest);
}
if (bAddDelayLoad)
{
PublicDelayLoadDLLs.AddRange(
new string[] {
fmodDllName,
fmodStudioDllName
}
);
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
string APLName = System.String.Format("FMODStudio{0}_APL.xml", configName);
string RelAPLPath = Utils.MakePathRelativeTo(System.IO.Path.Combine(ModuleDirectory, APLName), Target.RelativeEnginePath);
System.Console.WriteLine("Adding {0}", RelAPLPath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", RelAPLPath);
foreach (string PluginName in System.IO.Directory.GetFiles(BasePath))
{
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 Vungle(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
"Vungle/Public"
// ... add public include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"AdCollection",
// ... 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.Android)
{
PrivateIncludePaths.Add("Private/Android");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Launch",
}
);
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "Vungle_UPL.xml")));
}
else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateIncludePaths.Add("Private/Windows");
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PrivateIncludePaths.Add("Private/IOS");
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"VungleSDK", // Framework name
"../ThirdParty/ThirdPartyFrameworks/VungleSDK.embeddedframework.zip")
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"AdsUtil", // Framework name
"../ThirdParty/ThirdPartyFrameworks/AdsUtil.embeddedframework.zip")
);
PublicFrameworks.AddRange(
new string[]
{
"EventKit",
"MediaPlayer",
"AdSupport",
"CoreLocation",
"SystemConfiguration",
"MessageUI",
"Security",
"CoreTelephony"
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PrivateIncludePaths.Add("Private/Mac");
}
else
{
PrecompileForTargets = PrecompileTargetsType.None;
}
}
public WebSocket(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Public/WebSocket.h";
string strEngineDir = GetEngineDirectory();
string strEngineVersion = ReadEngineVersion(strEngineDir);
System.Console.WriteLine("version:" + strEngineVersion);
PrivateIncludePaths.AddRange(
new string[] {
"WebSocket/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Json",
"JsonUtilities",
"Sockets",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"Json",
"JsonUtilities",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (int.Parse(EngineMinorVersion) > 23)
{
PublicDefinitions.Add("PLATFORM_HTML5=0");
}
// This file is changed from the official version.
// It is assumes that we have a libwebsocket_static422.lib which has been compiled against the 4.22
// version of the openssl third party libs.
// should we use ue4 provided lws and openssl?
bool UseDefaultLibs = false;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicDefinitions.Add("PLATFORM_UWP=0");
PrivateDependencyModuleNames.Add("zlib");
// OpenSSL versions provided with UE4 for windows
// We have compiled the libwebsockets libs to use the same as the engine uses.
// for 4.22+
// 4.24 1.1.1c
// 4.22+ 1.1.1
// 4.14+ 1.0.2h
// kards change, also 22, 23, 24
if (Int32.Parse(EngineMinorVersion) >= 20)
{
PrivateDependencyModuleNames.Add("OpenSSL");
}
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Win64");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Win64/"));
string[] StaticLibrariesX64 = new string[] {
#if UE_4_22_OR_LATER
// use this library, compatible with the OpenSSL module in the engine.
"websockets_static422.lib",
#else
"websockets_static.lib",
#endif
};
foreach (string Lib in StaticLibrariesX64)
{
PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib));
}
}
if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicDefinitions.Add("PLATFORM_UWP=0");
PrivateDependencyModuleNames.Add("zlib");
PrivateDependencyModuleNames.Add("OpenSSL");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Win32");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Win32/"));
string[] StaticLibrariesX32 = new string[] {
#if UE_4_22_OR_LATER
"websockets_static422.lib",
//"libcrypto.lib",
//"libssl.lib",#else
#else
"websockets_static.lib",
//"libcrypto.lib",
//"libssl.lib",
#endif
};
foreach (string Lib in StaticLibrariesX32)
{
PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib));
}
}
/*else if(Target.Platform == UnrealTargetPlatform.HTML5)
* {
* PublicDefinitions.Add("PLATFORM_UWP=0");
* string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/HTML5/"));
* PublicLibraryPaths.Add(strStaticPath);
*
* string[] StaticLibrariesHTML5 = new string[] {
* "WebSocket.js",
* };
*
* foreach (string Lib in StaticLibrariesHTML5)
* {
* PublicAdditionalLibraries.Add(strStaticPath + Lib);
* }
* }*/
#if false // use engine websocket libs for these platforms
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicDefinitions.Add("PLATFORM_UWP=0");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Mac");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Mac/"));
//PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesMac = new string[] {
"libwebsockets.a",
"libssl.a",
"libcrypto.a"
};
foreach (string Lib in StaticLibrariesMac)
{
PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib));
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PublicDefinitions.Add("PLATFORM_UWP=0");
PrivateDependencyModuleNames.Add("OpenSSL");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Linux");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Linux/"));
string[] StaticLibrariesLinux = null;
if (int.Parse(EngineMinorVersion) >= 24)
{
StaticLibrariesLinux = new string[] {
"libwebsockets424.a",
};
}
else
{
StaticLibrariesLinux = new string[] {
"libwebsockets.a",
};
}
foreach (string Lib in StaticLibrariesLinux)
{
PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib));
}
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicDefinitions.Add("PLATFORM_UWP=0");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/IOS");
PrivateDependencyModuleNames.Add("OpenSSL");
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath + "/Source/");
PluginPath = PluginPath.Replace("\\", "/");
string strStaticPath = PluginPath + "/ThirdParty/lib/IOS/";// Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/IOS/"));
//PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesIOS = new string[] {
"websockets",
//"ssl",
//"crypto"
};
foreach (string Lib in StaticLibrariesIOS)
{
PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib));
// warning CS0618: 'UnrealBuildTool.ModuleRules.PublicAdditionalShadowFiles' is obsolete: 'To specify files to be transferred to a remote Mac for compilation, create a [Project]/Build/Rsync/RsyncProject.txt file. See https://linux.die.net/man/1/rsync for more information about Rsync filter rules.'
//PublicAdditionalShadowFiles.Add(Path.Combine(strStaticPath, "lib" + Lib + ".a") );
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicDefinitions.Add("PLATFORM_UWP=0");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Android");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Android/armeabi-v7a"));
string strStaticArm64Path = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Android/arm64-v8a"));
// openssl provided by ue4 for android:
// 4.23 1.0.1s, part of libcurl
// Android apps are statically linked so we cannot have different versions of libraries
// in the modules. openssl is already linked in as part of libcurl.
// We therefore cannot use the newer 1.1.1 series in this plugin.
PrivateDependencyModuleNames.Add("OpenSSL");
string[] StaticLibrariesAndroid = new string[] {
"websockets",
// "ssl",
// "crypto"
};
foreach (string Lib in StaticLibrariesAndroid)
{
PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib));
PublicAdditionalLibraries.Add(Path.Combine(strStaticArm64Path, Lib));
}
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "WebSocket_UPL.xml"));
}
#endif
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "WebSocket_UPL.xml"));
UseDefaultLibs = true;
}
else
{
// all other platforms just use the ue4 provided libs
UseDefaultLibs = true;
}
if (UseDefaultLibs)
{
// compile and link with the static versions of
// libWebSockets that are provided with UE4.
// This is at least version 3.0.0 of lws.
// That version is quite sufficient for our purposes
// but contains a bug that can cause problems on
// windows. Fixed in 1485db1805ffa175df5d1568f6d568822fc4fd4c
// (and 16e31d4fd6fa7c437bbcd013f99fcacb3bf536d7)
PublicDefinitions.Add("PLATFORM_UWP=0");
// libwebsockets and openssl are provided by ue4
// UE4.23-4.25:
// lws: 3.0.0 all platforms
// openssl:
// android, lumin: 1.0.1s
// ps4: 1.0.2g
// mac, IOS, windows, hololens: 1.1.1
// unix: 1.1.1c
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"libWebSockets",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "libWebSockets");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenSSL");
}
}
public OculusHMD(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
// Relative to Engine\Plugins\Runtime\Oculus\OculusVR\Source
"../../../../../Source/Runtime/Renderer/Private",
"../../../../../Source/Runtime/OpenGLDrv/Private",
"../../../../../Source/Runtime/VulkanRHI/Private",
"../../../../../Source/Runtime/Engine/Classes/Components",
});
PublicIncludePathModuleNames.Add("Launch");
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"RHI",
"RenderCore",
"Renderer",
"ShaderCore",
"HeadMountedDisplay",
"Slate",
"SlateCore",
"ImageWrapper",
"MediaAssets",
"Analytics",
"UtilityShaders",
"OpenGLDrv",
"VulkanRHI",
"OVRPlugin",
});
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
// D3D
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"D3D11RHI",
"D3D12RHI",
});
PrivateIncludePaths.AddRange(
new string[]
{
"../../../../../Source/Runtime/Windows/D3D11RHI/Private",
"../../../../../Source/Runtime/Windows/D3D11RHI/Private/Windows",
"../../../../../Source/Runtime/D3D12RHI/Private",
"../../../../../Source/Runtime/D3D12RHI/Private/Windows",
});
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX12");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAPI");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11Audio");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectSound");
}
// Vulkan
{
string VulkanSDKPath = Environment.GetEnvironmentVariable("VULKAN_SDK");
if (!String.IsNullOrEmpty(VulkanSDKPath))
{
// If the user has an installed SDK, use that instead
PrivateIncludePaths.Add(VulkanSDKPath + "/Include");
// Older SDKs have an extra subfolder
PrivateIncludePaths.Add(VulkanSDKPath + "/Include/vulkan");
if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicLibraryPaths.Add(VulkanSDKPath + "/Source/lib32");
}
else
{
PublicLibraryPaths.Add(VulkanSDKPath + "/Source/lib");
}
PublicAdditionalLibraries.Add("vulkan-1.lib");
PublicAdditionalLibraries.Add("vkstatic.1.lib");
}
else
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
}
}
// OVRPlugin
{
PublicDelayLoadDLLs.Add("OVRPlugin.dll");
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/ThirdParty/Oculus/OVRPlugin/OVRPlugin/" + Target.Platform.ToString() + "/OVRPlugin.dll"));
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
// Vulkan
{
string NDKPath = Environment.GetEnvironmentVariable("NDKROOT");
// Note: header is the same for all architectures so just use arch-arm
string NDKVulkanIncludePath = NDKPath + "/platforms/android-24/arch-arm/usr/include/vulkan";
if (File.Exists(NDKVulkanIncludePath + "/vulkan.h"))
{
// Use NDK Vulkan header if discovered
PrivateIncludePaths.Add(NDKVulkanIncludePath);
}
else
{
string VulkanSDKPath = Environment.GetEnvironmentVariable("VULKAN_SDK");
if (!String.IsNullOrEmpty(VulkanSDKPath))
{
// If the user has an installed SDK, use that instead
PrivateIncludePaths.Add(VulkanSDKPath + "/Include/vulkan");
}
else
{
// Fall back to the Windows Vulkan SDK (the headers are the same)
PrivateIncludePaths.Add(Target.UEThirdPartySourceDirectory + "Vulkan/Windows/Include/vulkan");
}
}
}
// AndroidPlugin
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "GearVR_APL.xml")));
}
}
}
public AocePlugins(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core", "CoreUObject", "Projects", "Engine", "RHI", "RenderCore", "UMG", "SlateCore", "OpenGLDrv", "Json", "JsonUtilities",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
CppStandard = CppStandardVersion.Cpp14;
// 头文件
PublicIncludePaths.AddRange(new string[] { Path.Combine(ThirdPartyPath, "Aoce/win/include") });
if (Target.Platform == UnrealTargetPlatform.Win64)
{
Definitions.Add("__ANDROID__=0");
Definitions.Add("WIN32=1");
string aocePath = Path.Combine(ThirdPartyPath, "Aoce/win");
string libPath = Path.Combine(aocePath, "lib");
string binPath = Path.Combine(aocePath, "bin");
// 链接库
PublicLibraryPaths.Add(libPath);
PublicAdditionalLibraries.Add("aoce.lib");
// 需要延迟加载的dll,不加的话,需把相应dll拷贝到工程的Binaries,否则编辑器到75%就因加载不了dll crash.
PublicDelayLoadDLLs.Add("aoce.dll");
// PublicDelayLoadDLLs.Add("aoce_agora.dll");
// PublicDelayLoadDLLs.Add("agora_rtc_sdk.dll");
// RuntimeDependencies.Add(Path.Combine(binPath, "aoce.dll"));
foreach (string path in Directory.GetFiles(binPath, "*.*", SearchOption.AllDirectories))
{
RuntimeDependencies.Add(path);
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
// PublicDependencyModuleNames.Add("OpenGLDrv");
suffix = ".so";
Definitions.Add("__ANDROID__=1");
Definitions.Add("WIN32=0");
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(ModuleDirectory, "AocePlugins_APL.xml"));
string aocePath = Path.Combine(ThirdPartyPath, "Aoce/android");
string libPath = Path.Combine(aocePath, "armeabi-v7a");
// 链接库
PublicAdditionalLibraries.Add(Path.Combine(libPath, "libaoce.so"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "libffmpeg.so"));
// PublicAdditionalLibraries.Add(Path.Combine(libPath, "libagora-rtc-sdk-jni.so"));
}
}
private void SetupManagedPaths()
{
// Target the game project directory
string projectFile = Target.ProjectFile.FullName;
if (File.Exists(projectFile) && Path.GetExtension(projectFile) == ".uproject" && Directory.Exists(ModuleDirectory))
{
// USharp paths (engine plugins folder)
string pluginManagedBinDir = GetPluginManagedBinDir();
string pluginShippingManagedBinDir = Path.Combine(pluginManagedBinDir, "Shipping");
// Game project paths
string projectDir = Path.GetDirectoryName(projectFile);
string managedBinDir = Path.Combine(projectDir, "Binaries", "Managed");
outputRelativeDir = new Uri(Path.GetFullPath(Path.Combine(projectDir, "Binaries")), UriKind.Absolute);
if (!Directory.Exists(managedBinDir))
{
// This might not be a USharp enabled project?
return;
}
// Add CoreCLR/Mono folders to RuntimeDependencies (if they exists)
//
// NOTE: We need to copy the folders locally rather than directly referencing the folders in the engine
// plugins folder as RuntimeDependencies depends on paths being within the game project folder.
string sourceCoreCLRDir = GetCoreCLRDir(pluginManagedBinDir, true);
string sourceMonoDir = GetMonoDir(pluginManagedBinDir, true);
string sourceRuntimesFile = GetDotNetRuntimesFile(pluginManagedBinDir);
string destCoreCLRDir = GetCoreCLRDir(managedBinDir, false);
string destMonoDir = GetMonoDir(managedBinDir, false);
string destRuntimesFile = GetDotNetRuntimesFile(managedBinDir);
bool copyCoreCLR = false;
bool copyMono = false;
bool cleanRuntimeFolders = false;// If true delete the contents of the target runtime folders before copying
if (File.Exists(sourceRuntimesFile))
{
foreach (string str in File.ReadAllLines(sourceRuntimesFile))
{
string line = str.Trim().ToLower();
const string packagePrefix = "package:";
if (line.StartsWith(packagePrefix))
{
line = line.Substring(packagePrefix.Length).Trim();
switch (line.ToLower())
{
case "mono":
copyMono = true;
break;
case "coreclr":
copyCoreCLR = true;
break;
case "clean":
cleanRuntimeFolders = true;
break;
}
}
}
}
switch (Target.Platform)
{
case UnrealTargetPlatform.Android:
// Mono is currently the only supported runtime on Android. Ensure that it gets packaged.
copyMono = true;
copyCoreCLR = false;
break;
}
if (copyMono && !Directory.Exists(sourceMonoDir))
{
copyMono = false;
}
if (copyCoreCLR && !Directory.Exists(sourceCoreCLRDir))
{
copyCoreCLR = false;
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
// We need to store a file list somewhere as there are issues with traversing the folder hierarchy
// (both the .obb file structure and the .apk file structure have issues with traversal)
// NOTE: There is currently a crash loading files outside of the obb (FFileHelper::LoadFileToStringArray / FFileHelper::LoadFileToArray)
bool storeInObb = true;
StringBuilder fileListStr = new StringBuilder();
Uri rootRelativeDir = new Uri(Path.GetFullPath(Path.Combine(projectDir, "Binaries", "Managed", "_")), UriKind.Absolute);
foreach (string file in GetAllFiles(new DirectoryInfo(managedBinDir), "Runtimes"))
{
string relativePath = rootRelativeDir.MakeRelativeUri(new Uri(file, UriKind.Absolute)).ToString();
fileListStr.Append(relativePath + "\n");
}
// Not needed until .NET Core is supported
/*if ((copyMono || copyCoreCLR) && File.Exists(sourceRuntimesFile))
* {
* string relativePath = rootRelativeDir.MakeRelativeUri(new Uri(sourceRuntimesFile, UriKind.Absolute)).ToString();
* fileListStr.Append(relativePath + "\n");
* }*/
if (copyMono)
{
Uri monoRelativeDir = new Uri(Path.GetFullPath(Path.Combine(sourceMonoDir, "_")), UriKind.Absolute);
foreach (string file in Directory.GetFiles(sourceMonoDir, "*.*", SearchOption.AllDirectories))
{
string relativePath = monoRelativeDir.MakeRelativeUri(new Uri(file, UriKind.Absolute)).ToString();
fileListStr.Append("Runtimes/Mono/Android/" + relativePath + "\n");
}
}
if (copyCoreCLR)
{
Uri coreClrRelativeDir = new Uri(Path.GetFullPath(Path.Combine(sourceCoreCLRDir, "_")), UriKind.Absolute);
foreach (string file in Directory.GetFiles(sourceCoreCLRDir, "*.*", SearchOption.AllDirectories))
{
string relativePath = coreClrRelativeDir.MakeRelativeUri(new Uri(file, UriKind.Absolute)).ToString();
fileListStr.Append("Runtimes/CoreCLR/Android/" + relativePath + "\n");
}
}
string androidFileListFile = Path.Combine(managedBinDir, "AndroidFileList.txt");
try
{
File.WriteAllText(androidFileListFile, fileListStr.ToString());
}
catch
{
}
if (storeInObb)
{
// Store USharp files in the .obb
AddFileToRuntimeDependencies(androidFileListFile);
}
else
{
// Store USharp files in the .apk under /assets/
string pluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(pluginPath, "USharp_APL.xml"));
return;
}
}
// Copy the shipping build version of UnrealEngine.Runtime.dll to /ProjectName/Binaries/Managed
string shippingRuntimeDllPath = Path.Combine(pluginShippingManagedBinDir, "UnrealEngine.Runtime.dll");
if (File.Exists(shippingRuntimeDllPath))
{
File.Copy(shippingRuntimeDllPath, Path.Combine(managedBinDir, "UnrealEngine.Runtime.dll"), true);
}
// Add "ProjectName/Binaries/Managed/" to the RuntimeDependencies
AddToRuntimeDependenciesRecursively(new DirectoryInfo(managedBinDir), "Runtimes");
if (copyCoreCLR || copyMono)
{
// Copy the runtimes text file to the output directory
FileInfo destRuntimesFileInfo = new FileInfo(destRuntimesFile);
if (!destRuntimesFileInfo.Directory.Exists)
{
Directory.CreateDirectory(destRuntimesFileInfo.DirectoryName);
}
CopyFile(sourceRuntimesFile, destRuntimesFile, true);
if (copyCoreCLR)
{
if (cleanRuntimeFolders)
{
CleanFolder(destCoreCLRDir);
}
// Copy the CoreCLR folder into the project binaries folder
CopyFilesRecursive(new DirectoryInfo(sourceCoreCLRDir), new DirectoryInfo(destCoreCLRDir), true);
}
if (copyMono)
{
if (cleanRuntimeFolders)
{
CleanFolder(destMonoDir);
}
// Copy the Mono folder into the project binaries folder
CopyFilesRecursive(new DirectoryInfo(sourceMonoDir), new DirectoryInfo(destMonoDir), true);
}
}
}
}
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[] {
"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",
"AIModule"
// ... add private dependencies that you statically link with here ...
}
);
#if WITH_FORWARDED_MODULE_RULES_CTOR
BuildVersion Version;
if (BuildVersion.TryRead(BuildVersion.GetDefaultFileName(), out Version))
{
if (Version.MinorVersion >= 18)
{
PrivateDependencyModuleNames.Add("ApplicationCore");
}
}
#endif
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
#if WITH_FORWARDED_MODULE_RULES_CTOR
if (Target.bBuildEditor)
#else
if (UEBuildConfiguration.bBuildEditor)
#endif
{
PrivateDependencyModuleNames.AddRange(new string[] {
"UnrealEd",
"LevelEditor",
"BlueprintGraph",
"Projects",
"Sequencer",
"SequencerWidgets",
"AssetTools",
"LevelSequenceEditor",
"MovieSceneTools",
"MovieSceneTracks",
"CinematicCamera",
"EditorStyle",
"GraphEditor",
"UMGEditor",
"AIGraph",
"RawMesh",
"DesktopWidgets",
"EditorWidgets",
"FBX",
"Persona",
"PropertyEditor",
"LandscapeEditor",
"MaterialEditor"
});
}
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(windowsKnownPaths, "Win64");
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetWindowsPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicAdditionalLibraries.Add(libPath);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(macKnownPaths, "Mac");
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetMacPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicDelayLoadDLLs.Add(libPath);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (pythonHome == "")
{
string includesPath = DiscoverLinuxPythonIncludesPath();
if (includesPath == null)
{
throw new System.Exception("Unable to find Python includes, please add a search path to linuxKnownIncludesPaths");
}
string libsPath = DiscoverLinuxPythonLibsPath();
if (libsPath == null)
{
throw new System.Exception("Unable to find Python libs, please add a search path to linuxKnownLibsPaths");
}
PublicIncludePaths.Add(includesPath);
PublicAdditionalLibraries.Add(libsPath);
}
else
{
string[] items = pythonHome.Split(';');
PublicIncludePaths.Add(items[0]);
PublicAdditionalLibraries.Add(items[1]);
}
}
#if WITH_FORWARDED_MODULE_RULES_CTOR
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicDefinitions.Add("UEPY_THREADING");
System.Console.WriteLine("*** Enabled Python Threads support ***");
PublicIncludePaths.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/python35/include"));
PublicLibraryPaths.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/armeabi-v7a"));
PublicAdditionalLibraries.Add("python3.5m");
string APLName = "UnrealEnginePython_APL.xml";
string RelAPLPath = Utils.MakePathRelativeTo(System.IO.Path.Combine(ModuleDirectory, APLName), Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", RelAPLPath));
}
#endif
}
public OneStore(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[]
{
// PublicIncludePath
}
);
PrivateIncludePaths.AddRange(
new string[]
{
// PrivateIncludePath
"OneStore/Private"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
// PublicDependencyModule
"Core",
"CoreUObject",
"Engine",
"OnlineSubsystem",
"OnlineSubsystemUtils"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
// PrivateDependencyModule
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// DynamicallyLoadedModule
}
);
PublicIncludePathModuleNames.AddRange(
new string[]
{
"Launch"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
// PrivateIncludePathModule
"Settings"
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, BuildConfiguration.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "OneStore_APL.xml")));
}
}
public FMODStudio(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = "Private/FMODStudioPrivatePCH.h";
bUseUnity = false;
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public/FMOD"));
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Classes"));
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Media",
"Projects"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneTracks"
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("AssetRegistry");
PrivateDependencyModuleNames.Add("UnrealEd");
PrivateDependencyModuleNames.Add("Settings");
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
string configName = "";
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
configName = "L";
PublicDefinitions.Add("FMODSTUDIO_LINK_LOGGING=1");
}
else
{
configName = "";
PublicDefinitions.Add("FMODSTUDIO_LINK_RELEASE=1");
}
string linkExtension = "";
string dllExtension = "";
string libPrefix = "";
string libPath = FMODLibDir;
bool bCopyToOutput = false;
bool bAddRuntimeDependencies = true;
bool bAddDelayLoad = false;
bool bLinkDebugFiles = false;
if (libPath == null)
{
string platformName = Target.Platform.ToString();
libPath = System.IO.Path.Combine(LibRootDirectory, platformName);
// Minimum UE version for Switch 4.15
System.Console.WriteLine("Target Platform -- " + Target.Platform.ToString());
if (Target.Platform == UnrealTargetPlatform.Switch)
{
linkExtension = ".a";
dllExtension = ".a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
}
else if (Target.Platform.ToString() == "UWP64")
{
linkExtension = ".lib";
dllExtension = ".dll";
bAddDelayLoad = true;
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Windows))
{
linkExtension = "_vc.lib";
dllExtension = ".dll";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
linkExtension = dllExtension = ".dylib";
libPrefix = "lib";
libPath = System.IO.Path.Combine(ModuleDirectory, "../../Libs/Mac/");
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
linkExtension = "_vc.lib";
dllExtension = ".dll";
bCopyToOutput = true;
bAddRuntimeDependencies = false;
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
linkExtension = "_stub.a";
dllExtension = ".prx";
libPrefix = "lib";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
bAddRuntimeDependencies = false; // Don't use this system
linkExtension = dllExtension = ".so";
libPrefix = "lib";
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
linkExtension = "_iphoneos.a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
}
else if (Target.Platform == UnrealTargetPlatform.TVOS)
{
linkExtension = "_appletvos.a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
libPath = System.IO.Path.Combine(libPath, "x86_64");
linkExtension = ".so";
dllExtension = ".so";
libPrefix = "lib";
}
}
else
{
linkExtension = ConsoleLinkExt;
dllExtension = ConsoleDllExt;
libPrefix = ConsoleLibPrefix;
bAddRuntimeDependencies = ConsoleRuntimeDependencies;
bAddDelayLoad = ConsoleDelayLoad;
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[] { "armeabi-v7a", "arm64-v8a", "x86_64" };
foreach (string arch in archs)
{
string LibPath = System.IO.Path.Combine(libPath, arch);
PublicAdditionalLibraries.Add(System.String.Format("{0}/{1}", LibPath, fmodLibName));
PublicAdditionalLibraries.Add(System.String.Format("{0}/{1}", LibPath, fmodStudioLibName));
}
}
else
{
PublicAdditionalLibraries.Add(fmodLibPath);
PublicAdditionalLibraries.Add(fmodStudioLibPath);
}
if (bCopyToOutput)
{
RuntimeDependencies.Add("$(TargetOutputDir)/" + fmodDllName, fmodDllPath);
RuntimeDependencies.Add("$(TargetOutputDir)/" + fmodStudioDllName, fmodStudioDllPath);
}
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 PrFirebase(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
ConfigHierarchy EngineConfig = ConfigCache.ReadHierarchy(ConfigHierarchyType.Engine, DirectoryReference.FromFile(Target.ProjectFile), Target.Platform);
bool bFirebaseLoggingInShipping = false;
EngineConfig.TryGetValue("/Script/PrFirebase.PrFirebaseSettings", "bFirebaseLoggingInShipping", out bFirebaseLoggingInShipping);
bool bFirebaseEnable = false;
bool bFirebaseCrashlyticsEnable = false;
bool bFirebaseRemoteConfigEnable = false;
bool bFirebaseAuthEnable = false;
bool bFirebasePerformanceEnable = false;
bool bFirebaseAppDistributionEnable = false;
EngineConfig.TryGetValue("/Script/PrFirebase.PrFirebaseSettings", "bFirebaseEnable", out bFirebaseEnable);
EngineConfig.TryGetValue("/Script/PrFirebase.PrFirebaseSettings", "bFirebaseCrashlyticsEnable", out bFirebaseCrashlyticsEnable);
EngineConfig.TryGetValue("/Script/PrFirebase.PrFirebaseSettings", "bFirebaseRemoteConfigEnable", out bFirebaseRemoteConfigEnable);
EngineConfig.TryGetValue("/Script/PrFirebase.PrFirebaseSettings", "bFirebaseAuthEnable", out bFirebaseAuthEnable);
EngineConfig.TryGetValue("/Script/PrFirebase.PrFirebaseSettings", "bFirebasePerformanceEnable", out bFirebasePerformanceEnable);
EngineConfig.TryGetValue("/Script/PrFirebase.PrFirebaseSettings", "bFirebaseAppDistributionEnable", out bFirebaseAppDistributionEnable);
PrivateIncludePaths.AddRange(
new string[] {
"PrFirebase/Private"
});
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"RHI"
});
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Settings",
}
);
bool bSymbolsWarning = false;
if (bFirebaseEnable)
{
if (Target.Platform == UnrealTargetPlatform.IOS)
{
bool bGeneratedSYMBundle = false;
bool bGeneratedSYMFile = false;
EngineConfig.TryGetValue("/Script/IOSRuntimeSettings.IOSRuntimeSettings", "bGeneratedSYMBundle", out bGeneratedSYMBundle);
EngineConfig.TryGetValue("/Script/IOSRuntimeSettings.IOSRuntimeSettings", "bGeneratedSYMFile", out bGeneratedSYMFile);
if ((!bGeneratedSYMBundle || !bGeneratedSYMFile) && bFirebaseCrashlyticsEnable)
{
bSymbolsWarning = true;
}
/* Firebase / Firebase Analytics */
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseAnalytics",
"../../ThirdParty/iOS/FirebaseAnalytics.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseCore",
"../../ThirdParty/iOS/FirebaseCore.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseCoreDiagnostics",
"../../ThirdParty/iOS/FirebaseCoreDiagnostics.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseInstallations",
"../../ThirdParty/iOS/FirebaseInstallations.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleAppMeasurement",
"../../ThirdParty/iOS/GoogleAppMeasurement.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleDataTransport",
"../../ThirdParty/iOS/GoogleDataTransport.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleUtilities",
"../../ThirdParty/iOS/GoogleUtilities.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"nanopb",
"../../ThirdParty/iOS/nanopb.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"PromisesObjC",
"../../ThirdParty/iOS/PromisesObjC.embeddedframework.zip"
)
);
/* Crashlytics */
if (bFirebaseCrashlyticsEnable)
{
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseCrashlytics",
"../../ThirdParty/iOS/FirebaseCrashlytics.embeddedframework.zip"
)
);
}
/* Remote Config */
if (bFirebaseRemoteConfigEnable)
{
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseABTesting",
"../../ThirdParty/iOS/FirebaseABTesting.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseRemoteConfig",
"../../ThirdParty/iOS/FirebaseRemoteConfig.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"Protobuf",
"../../ThirdParty/iOS/Protobuf.embeddedframework.zip"
)
);
}
/* Performance */
if (bFirebasePerformanceEnable)
{
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseABTesting",
"../../ThirdParty/iOS/FirebaseABTesting.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebasePerformance",
"../../ThirdParty/iOS/FirebasePerformance.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseRemoteConfig",
"../../ThirdParty/iOS/FirebaseRemoteConfig.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"Protobuf",
"../../ThirdParty/iOS/Protobuf.embeddedframework.zip"
)
);
}
/* Auth */
if (bFirebaseAuthEnable)
{
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseAuth",
"../../ThirdParty/iOS/FirebaseAuth.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GTMSessionFetcher",
"../../ThirdParty/iOS/GTMSessionFetcher.embeddedframework.zip"
)
);
}
if (bFirebaseAppDistributionEnable)
{
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseAppDistribution",
"../../ThirdParty/iOS/FirebaseAppDistribution.embeddedframework.zip"
)
);
}
PublicSystemLibraries.Add("sqlite3");
PrivateIncludePaths.Add("PrFirebase/External/iOS");
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("IOSPlugin", Path.Combine(PluginPath, "PrFirebase_UPL_IOS.xml"));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Launch"
});
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "PrFirebase_UPL_Android.xml"));
}
else
{
bFirebaseEnable = false;
}
}
PublicDefinitions.Add("WITH_FIREBASE=" + (bFirebaseEnable ? "1" : "0"));
PublicDefinitions.Add("WITH_FIREBASE_CRASHLYTICS=" + (bFirebaseEnable && bFirebaseCrashlyticsEnable ? "1" : "0"));
PublicDefinitions.Add("WITH_FIREBASE_REMOTECONFIG=" + (bFirebaseEnable && bFirebaseRemoteConfigEnable ? "1" : "0"));
PublicDefinitions.Add("WITH_FIREBASE_AUTH=" + (bFirebaseEnable && bFirebaseAuthEnable ? "1" : "0"));
PublicDefinitions.Add("WITH_FIREBASE_PERFORMANCE=" + (bFirebaseEnable && bFirebasePerformanceEnable ? "1" : "0"));
PublicDefinitions.Add("WITH_FIREBASE_SYMBOLS_WARNING=" + (bFirebaseEnable && bSymbolsWarning ? "1" : "0"));
PublicDefinitions.Add("WITH_FIREBASE_APPDISTRIBUTION=" + (bFirebaseEnable && bFirebaseAppDistributionEnable ? "1" : "0"));
PublicDefinitions.Add("FIREBASE_LOGGING=" + (bFirebaseLoggingInShipping ? "1" : "0"));
}
public WebSocket(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
"WebSocket/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"WebSocket/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Json",
"JsonUtilities",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"Json",
"JsonUtilities",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.Add("zlib");
PrivateDependencyModuleNames.Add("OpenSSL");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Win64");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Win64/"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesX64 = new string[] {
"websockets_static.lib",
//"libcrypto.lib",
//"libssl.lib",
};
foreach (string Lib in StaticLibrariesX64)
{
PublicAdditionalLibraries.Add(Lib);
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Mac");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Mac/"));
//PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesMac = new string[] {
"libwebsockets.a",
"libssl.a",
"libcrypto.a"
};
foreach (string Lib in StaticLibrariesMac)
{
PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib));
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateDependencyModuleNames.Add("OpenSSL");
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Linux");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Linux/"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesMac = new string[] {
"libwebsockets.a",
//"libssl.a",
//"libcrypto.a"
};
foreach (string Lib in StaticLibrariesMac)
{
PublicAdditionalLibraries.Add(Path.Combine(strStaticPath, Lib));
}
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/IOS");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/IOS/"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesIOS = new string[] {
"websockets",
"ssl",
"crypto"
};
foreach (string Lib in StaticLibrariesIOS)
{
PublicAdditionalLibraries.Add(Lib);
PublicAdditionalShadowFiles.Add(Path.Combine(strStaticPath, "lib" + Lib + ".a"));
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateIncludePaths.Add("WebSocket/ThirdParty/include/Android");
string strStaticPath = Path.GetFullPath(Path.Combine(ModulePath, "ThirdParty/lib/Android/armeabi-v7a"));
PublicLibraryPaths.Add(strStaticPath);
string[] StaticLibrariesAndroid = new string[] {
"websockets",
//"ssl",
//"crypto"
};
foreach (string Lib in StaticLibrariesAndroid)
{
PublicAdditionalLibraries.Add(Lib);
}
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "WebSocket_UPL.xml")));
}
}
public PsIronSource(ReadOnlyTargetRules Target) : base(Target)
{
const bool bEnableIronSource = true;
PublicDefinitions.Add("WITH_IRONSOURCE=" + (bEnableIronSource ? "1" : "0"));
PrivateIncludePaths.AddRange(
new string[] {
"PsIronSource/Private",
});
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
});
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Settings",
}
);
if (bEnableIronSource)
{
if (Target.Platform == UnrealTargetPlatform.IOS)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("IOSPlugin", Path.Combine(PluginPath, "PsIronSource_UPL_IOS.xml"));
PublicAdditionalFrameworks.Add(
new Framework(
"IronSource",
"../../ThirdParty/iOS/IronSource.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"ISFacebookAdapter",
"../../ThirdParty/iOS/ISFacebookAdapter.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"ISUnityAdsAdapter",
"../../ThirdParty/iOS/ISUnityAdsAdapter.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"ISAdMobAdapter",
"../../ThirdParty/iOS/ISAdMobAdapter.embeddedframework.zip"
)
);
// Dependence for ISAdMobAdapter
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleAppMeasurement",
"../../ThirdParty/iOS/GoogleAppMeasurement_is.embeddedframework.zip"
)
);
// Dependence for ISAdMobAdapter
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleMobileAds",
"../../ThirdParty/iOS/GoogleMobileAds.embeddedframework.zip"
)
);
// Dependence for ISAdMobAdapter
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleUtilities",
"../../ThirdParty/iOS/GoogleUtilities_is.embeddedframework.zip"
)
);
// Dependence for ISAdMobAdapter
PublicAdditionalFrameworks.Add(
new Framework(
"nanopb",
"../../ThirdParty/iOS/nanopb_is.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"ISAppLovinAdapter",
"../../ThirdParty/iOS/ISAppLovinAdapter.embeddedframework.zip"
)
);
// Dependence for ISAppLovinAdapter
PublicAdditionalFrameworks.Add(
new Framework(
"AppLovinSDK",
"../../ThirdParty/iOS/AppLovinSDK.embeddedframework.zip",
"AppLovinSDKResources.bundle"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"ISVungleAdapter",
"../../ThirdParty/iOS/ISVungleAdapter.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"ISAdColonyAdapter",
"../../ThirdParty/iOS/ISAdColonyAdapter.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"ISTapjoyAdapter",
"../../ThirdParty/iOS/ISTapjoyAdapter.embeddedframework.zip",
"TapjoyResources.bundle"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"ISInMobiAdapter",
"../../ThirdParty/iOS/ISInMobiAdapter.embeddedframework.zip"
)
);
PublicAdditionalLibraries.Add("xml2");
PublicAdditionalLibraries.Add("sqlite3");
PublicAdditionalFrameworks.Add(
new Framework(
"ISTikTokAdapter",
"../../ThirdParty/iOS/ISTikTokAdapter.embeddedframework.zip",
"BUAdSDK.bundle"
)
);
PublicAdditionalLibraries.Add("resolv");
PublicAdditionalFrameworks.Add(
new Framework(
"ISChartboostAdapter",
"../../ThirdParty/iOS/ISChartboostAdapter.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"ISMintegralAdapter",
"../../ThirdParty/iOS/ISMintegralAdapter.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"ISMyTargetAdapter",
"../../ThirdParty/iOS/ISMyTargetAdapter.embeddedframework.zip"
)
);
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "PsIronSource_UPL_Android.xml"));
}
}
}
