public GameAnalytics(TargetInfo Target)
{
var GameAnalyticsPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "../ThirdParty/"));
var libPath = Path.Combine(GameAnalyticsPath, "lib");
switch (Target.Platform)
{
case UnrealTargetPlatform.Win64:
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win64", "GameAnalytics.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win64", "libboost_filesystem-vc140-mt-1_60.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win64", "libboost_system-vc140-mt-1_60.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win64", "libeay32MT.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win64", "ssleay32MT.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win64", "libcurl.lib"));
break;
case UnrealTargetPlatform.Win32:
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win32", "GameAnalytics.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win32", "libboost_filesystem-vc140-mt-1_60.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win32", "libboost_system-vc140-mt-1_60.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win32", "libeay32MT.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win32", "ssleay32MT.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win32", "libcurl.lib"));
break;
case UnrealTargetPlatform.Android:
PrivateDependencyModuleNames.Add("Launch");
break;
case UnrealTargetPlatform.Mac:
PublicAdditionalLibraries.Add(Path.Combine(libPath, "osx", "libGameAnalytics.a"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "osx", "libboost_filesystem-mt.a"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "osx", "libboost_system-mt.a"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "osx", "libcrypto.a"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "osx", "libssl.a"));
PublicAdditionalLibraries.Add("curl");
break;
case UnrealTargetPlatform.IOS:
PublicAdditionalLibraries.Add(Path.Combine(libPath, "ios", "libGameAnalytics.a"));
PublicFrameworks.AddRange(
new string[] {
"AdSupport",
"SystemConfiguration"
}
);
PublicAdditionalLibraries.AddRange(
new string[] {
"sqlite3",
"z",
"c++"
});
break;
case UnrealTargetPlatform.XboxOne:
case UnrealTargetPlatform.PS4:
case UnrealTargetPlatform.HTML5:
case UnrealTargetPlatform.Linux:
default:
throw new NotImplementedException("This target platform is not configured for GameAnalytics SDK: " + Target.Platform.ToString());
}
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
// ... add other public dependencies that you statically link with here ...
}
);
/*PrivateDependencyModuleNames.AddRange(
* new string[]
* {
* "Analytics",
* // ... add private dependencies that you statically link with here ...
* }
* );*/
PrivateIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Private")));
PrivateIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Public")));
PublicIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Public")));
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Analytics",
"Engine"
// ... add private dependencies that you statically link with here ...
}
);
PublicIncludePathModuleNames.AddRange(
new string[]
{
"Analytics",
"Engine"
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, BuildConfiguration.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "GameAnalytics_APL.xml")));
}
}
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 == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
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 PsMRGS(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[]
{
"PsMRGS/Private/"
// ... add other private include paths required here ...
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PrivateIncludePaths.Add("PsMRGS/Private/IOS/");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateIncludePaths.Add("PsMRGS/Private/Android/");
}
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
// ... 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)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "PsMRGS_APL.xml"));
/** Write settings from DefaultEngineIni of MRGS to MRGService.xml in Plugin dir */
string AndroidGATrackingId = null;
string AndroidAppsFlyerDevKey = null;
string AndroidFlurryApiKey = null;
string AndroidMyTargetShowcaseSlotId = null;
string AndroidMyTargetFullscreenSlotId = null;
string AndroidMyTrackerAppId = null;
/** Opens DefaultEngine.ini to read values for variables */
using (StreamReader sr = File.OpenText(ConfigPath))
{
string s = "";
while ((s = sr.ReadLine()) != null)
{
string[] tokens;
tokens = s.Split('=');
if (tokens.Length == 2)
{
if (tokens[0] == "AndroidGATrackingId")
{
AndroidGATrackingId = tokens[1];
}
else if (tokens[0] == "AndroidAppsFlyerDevKey")
{
AndroidAppsFlyerDevKey = tokens[1];
}
else if (tokens[0] == "AndroidFlurryApiKey")
{
AndroidFlurryApiKey = tokens[1];
}
else if (tokens[0] == "AndroidMyTargetShowcaseSlotId")
{
AndroidMyTargetShowcaseSlotId = tokens[1];
}
else if (tokens[0] == "AndroidMyTargetFullscreenSlotId")
{
AndroidMyTargetFullscreenSlotId = tokens[1];
}
else if (tokens[0] == "AndroidMyTrackerAppId")
{
AndroidMyTrackerAppId = tokens[1];
}
}
}
}
/** Saves temp contents of file separated to lines */
List <string> lines = new List <string>();
using (StreamReader sr = File.OpenText(PluginAndroidSettingsXml))
{
string s = "";
while ((s = sr.ReadLine()) != null)
{
lines.Add(s);
}
}
/** Clear MRGService.xml to empty state */
System.IO.File.WriteAllText(PluginAndroidSettingsXml, string.Empty);
for (int i = 0; i < lines.Count; i++)
{
string s = lines[i];
if (s.Contains("trackingId"))
{
lines[i] = "trackingId=" + '"' + AndroidGATrackingId + '"';
}
if (s.Contains("app_key"))
{
lines[i] = "app_key=" + '"' + AndroidAppsFlyerDevKey + '"';
}
if (s.Contains("applicationKey"))
{
lines[i] = "applicationKey=" + '"' + AndroidFlurryApiKey + '"';
}
if (s.Contains("slotId"))
{
lines[i] = "slotId=" + '"' + AndroidMyTargetShowcaseSlotId + '"';
}
if (s.Contains("fullscreenSlotId"))
{
lines[i] = "fullscreenSlotId=" + '"' + AndroidMyTargetFullscreenSlotId + '"';
}
if (s.Contains("appId"))
{
lines[i] = "appId=" + '"' + AndroidMyTrackerAppId + '"';
}
}
/** Saves edited MRGService.xml back with parsed values from config*/
TextWriter tw = new StreamWriter(PluginAndroidSettingsXml);
foreach (String s in lines)
{
tw.WriteLine(s);
}
tw.Close();
}
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.AddRange(
new string[]
{
"AdSupport",
"iAd",
"CoreTelephony",
"SystemConfiguration",
"UIKit",
"Foundation",
"CoreGraphics",
"MobileCoreServices",
"StoreKit",
"CFNetwork",
"CoreData",
"Security",
"CoreLocation",
"WatchConnectivity",
"MediaPlayer",
"CoreFoundation",
"UserNotifications",
"GameKit",
"SafariServices"
}
);
PublicAdditionalLibraries.AddRange(
new string[]
{
"sqlite3"
}
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"MRGService",
"../../ThirdParty/IOS/MRGService.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"AppsFlyerLib",
"../../ThirdParty/IOS/AppsFlyerLib.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"MyTargetSDK",
"../../ThirdParty/IOS/MyTargetSDK.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"MyTrackerSDK",
"../../ThirdParty/IOS/MyTrackerSDK.embeddedframework.zip"
)
);
string thirdPartyPath = ProjectRoot + "/ThirdParty/IOS/";
string tempPathPrefix = thirdPartyPath + "Flurry/";
//adding Flurry
PublicIncludePaths.Add(tempPathPrefix);
PublicAdditionalLibraries.Add(tempPathPrefix + "/libFlurry_9.0.0.a");
//adding GA
tempPathPrefix = thirdPartyPath + "GoogleAnalytics/";
PublicIncludePaths.Add(tempPathPrefix);
PublicAdditionalLibraries.Add(tempPathPrefix + "libAdIdAccess.a");
PublicAdditionalLibraries.Add(tempPathPrefix + "libGoogleAnalyticsServices.a");
}
}
public FMODStudio(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = "Private/FMODStudioPrivatePCH.h";
bUseUnity = false;
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public/FMOD"));
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Classes"));
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Media",
"Projects"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneTracks"
}
);
if (Target.bBuildEditor == true)
{
PublicDependencyModuleNames.Add("DeveloperToolSettings");
PrivateDependencyModuleNames.Add("AssetRegistry");
PrivateDependencyModuleNames.Add("Settings");
PrivateDependencyModuleNames.Add("UnrealEd");
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
string configName = "";
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
configName = "L";
PublicDefinitions.Add("FMODSTUDIO_LINK_LOGGING=1");
}
else
{
configName = "";
PublicDefinitions.Add("FMODSTUDIO_LINK_RELEASE=1");
}
string linkExtension = "";
string dllExtension = "";
string libPrefix = "";
string libPath = FMODLibDir;
bool bAddRuntimeDependencies = true;
bool bAddDelayLoad = false;
bool bLinkDebugFiles = false;
if (libPath == null)
{
string platformName = Target.Platform.ToString();
libPath = System.IO.Path.Combine(LibRootDirectory, platformName);
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Windows))
{
linkExtension = "_vc.lib";
dllExtension = ".dll";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
linkExtension = dllExtension = ".dylib";
libPrefix = "lib";
libPath = System.IO.Path.Combine(ModuleDirectory, "../../Libs/Mac/");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
bAddRuntimeDependencies = false; // Don't use this system
linkExtension = dllExtension = ".so";
libPrefix = "lib";
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
linkExtension = "_iphoneos.a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
}
else if (Target.Platform == UnrealTargetPlatform.TVOS)
{
linkExtension = "_appletvos.a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
libPath = System.IO.Path.Combine(libPath, "x86_64");
linkExtension = ".so";
dllExtension = ".so";
libPrefix = "lib";
}
}
else
{
linkExtension = ConsoleLinkExt;
dllExtension = ConsoleDllExt;
libPrefix = ConsoleLibPrefix;
bAddRuntimeDependencies = ConsoleRuntimeDependencies;
bAddDelayLoad = ConsoleDelayLoad;
bLinkDebugFiles = LinkDebugFiles;
}
// Collapse the directory path, otherwise MacOS has issues with plugin paths.
libPath = Utils.CleanDirectorySeparators(libPath);
string fmodLibName = System.String.Format("{0}fmod{1}{2}", libPrefix, configName, linkExtension);
string fmodStudioLibName = System.String.Format("{0}fmodstudio{1}{2}", libPrefix, configName, linkExtension);
string fmodDllName = System.String.Format("{0}fmod{1}{2}", libPrefix, configName, dllExtension);
string fmodStudioDllName = System.String.Format("{0}fmodstudio{1}{2}", libPrefix, configName, dllExtension);
string fmodLibPath = System.IO.Path.Combine(libPath, fmodLibName);
string fmodStudioLibPath = System.IO.Path.Combine(libPath, fmodStudioLibName);
string fmodDllPath = System.IO.Path.Combine(libPath, fmodDllName);
string fmodStudioDllPath = System.IO.Path.Combine(libPath, fmodStudioDllName);
System.Collections.Generic.List <string> plugins = GetPlugins(libPath);
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
string[] archs = new string[] { "arm64-v8a", "x86_64" };
foreach (string arch in archs)
{
string LibPath = System.IO.Path.Combine(libPath, arch);
PublicAdditionalLibraries.Add(System.String.Format("{0}/{1}", LibPath, fmodLibName));
PublicAdditionalLibraries.Add(System.String.Format("{0}/{1}", LibPath, fmodStudioLibName));
}
}
else
{
PublicAdditionalLibraries.Add(fmodLibPath);
PublicAdditionalLibraries.Add(fmodStudioLibPath);
}
if (CopyLibs)
{
RuntimeDependencies.Add("$(TargetOutputDir)/" + fmodDllName, fmodDllPath);
RuntimeDependencies.Add("$(TargetOutputDir)/" + fmodStudioDllName, fmodStudioDllPath);
foreach (string plugin in plugins)
{
string pluginPath = System.IO.Path.Combine(libPath, plugin + dllExtension);
System.Console.WriteLine("Adding reference to FMOD plugin: " + pluginPath);
RuntimeDependencies.Add("$(TargetOutputDir)/" + plugin + dllExtension, pluginPath);
}
}
else if (bAddRuntimeDependencies)
{
RuntimeDependencies.Add(fmodDllPath);
RuntimeDependencies.Add(fmodStudioDllPath);
foreach (string plugin in plugins)
{
string pluginPath = System.IO.Path.Combine(libPath, plugin + dllExtension);
System.Console.WriteLine("Adding reference to FMOD plugin: " + pluginPath);
RuntimeDependencies.Add(pluginPath);
}
}
if (bLinkDebugFiles)
{
RuntimeDependencies.Add(fmodDllPath + ".debug", StagedFileType.DebugNonUFS);
RuntimeDependencies.Add(fmodStudioDllPath + ".debug", StagedFileType.DebugNonUFS);
}
if (bAddDelayLoad)
{
PublicDelayLoadDLLs.AddRange(
new string[] {
fmodDllName,
fmodStudioDllName
}
);
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
string APLName = System.String.Format("FMODStudio{0}_APL.xml", configName);
string RelAPLPath = Utils.MakePathRelativeTo(System.IO.Path.Combine(ModuleDirectory, APLName), Target.RelativeEnginePath);
System.Console.WriteLine("Adding {0}", RelAPLPath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", RelAPLPath);
foreach (string PluginName in System.IO.Directory.GetFiles(libPath))
{
if (PluginName.EndsWith("_APL.xml", System.StringComparison.OrdinalIgnoreCase))
{
string RelPluginPath = Utils.MakePathRelativeTo(PluginName, Target.RelativeEnginePath);
System.Console.WriteLine("Adding {0}", RelPluginPath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", RelPluginPath);
}
}
}
}
public SdkboxFyber(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
// PrivateIncludePaths.AddRange(
// new string[] {
// "Developer/SdkboxIAP/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 ...
"Sdkbox"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Settings"
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalLibraries.Add(Path.Combine(ModulePath, "../../lib/iOS/PluginFyber.a"));
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"Fyber_UnityAds_1.5.5-r1", "../../lib/iOS/Fyber_UnityAds_1.5.5-r1.embeddedframework.zip", "Resources/UnityAds.bundle"
)
);
PublicFrameworks.AddRange(
new string[]
{
"SystemConfiguration",
"Security",
"AdSupport",
"CoreGraphics",
"CoreLocation",
"CoreTelephony",
"MediaPlayer",
"QuartzCore",
"StoreKit",
"SystemConfiguration",
"CFNetwork",
"GameController"
}
);
PrivateDependencyModuleNames.AddRange(new string[] { "Launch" });
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("IOSPlugin", Path.Combine(ModulePath, "SdkboxFyber_IPL.xml")));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicAdditionalLibraries.Add(Path.Combine(ModulePath, "../../lib/Android/PluginFyber.a"));
PrivateDependencyModuleNames.AddRange(new string[] { "Launch" });
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(ModulePath, "SdkboxFyber_APL.xml")));
}
}
public UnrealEnginePython(TargetInfo Target)
#endif
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string enableUnityBuild = System.Environment.GetEnvironmentVariable("UEP_ENABLE_UNITY_BUILD");
bFasterWithoutUnity = string.IsNullOrEmpty(enableUnityBuild);
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "Public"),
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "Private"),
PythonHome,
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Sockets",
"Networking",
"Projects"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"MovieScene",
"LevelSequence",
"HTTP",
"UMG",
"AppFramework",
"RHI",
"Voice",
"RenderCore",
"MovieSceneCapture",
"Landscape",
"Foliage",
"AIModule"
// ... add private dependencies that you statically link with here ...
}
);
#if WITH_FORWARDED_MODULE_RULES_CTOR
BuildVersion Version;
if (BuildVersion.TryRead(BuildVersion.GetDefaultFileName(), out Version))
{
if (Version.MinorVersion >= 18)
{
PrivateDependencyModuleNames.Add("ApplicationCore");
}
}
#endif
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
#if WITH_FORWARDED_MODULE_RULES_CTOR
if (Target.bBuildEditor)
#else
if (UEBuildConfiguration.bBuildEditor)
#endif
{
PrivateDependencyModuleNames.AddRange(new string[] {
"UnrealEd",
"LevelEditor",
"BlueprintGraph",
"Projects",
"Sequencer",
"SequencerWidgets",
"AssetTools",
"LevelSequenceEditor",
"MovieSceneTools",
"MovieSceneTracks",
"CinematicCamera",
"EditorStyle",
"GraphEditor",
"UMGEditor",
"AIGraph",
"RawMesh",
"DesktopWidgets",
"EditorWidgets",
"FBX",
"Persona",
"PropertyEditor",
"LandscapeEditor",
"MaterialEditor"
});
}
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
if (UseThirdPartyPython)
{
PythonHome = ThirdPartyPythonHome;
System.Console.WriteLine("Using Embedded Python at: " + PythonHome);
PublicIncludePaths.Add(PythonHome);
string libPath = Path.Combine(PythonHome, "Lib", string.Format("{0}.lib", PythonType.ToLower()));
System.Console.WriteLine("full lib path: " + libPath);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicAdditionalLibraries.Add(libPath);
string dllPath = Path.Combine(BinariesPath, "Win64", string.Format("{0}.dll", PythonType.ToLower()));
RuntimeDependencies.Add(dllPath);
AddRuntimeDependenciesForCopying(Target);
}
else if (PythonHome == "")
{
PythonHome = DiscoverPythonPath(windowsKnownPaths, "Win64");
if (PythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
System.Console.WriteLine("Using Python at: " + PythonHome);
PublicIncludePaths.Add(PythonHome);
string libPath = GetWindowsPythonLibFile(PythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicAdditionalLibraries.Add(libPath);
}
}
//other platforms
else
{
if (PythonHome == "")
{
PythonHome = DiscoverPythonPath(macKnownPaths, "Mac");
if (PythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
System.Console.WriteLine("Using Python at: " + PythonHome);
PublicIncludePaths.Add(PythonHome);
PublicAdditionalLibraries.Add(Path.Combine(PythonHome, "Lib", string.Format("{0}.lib", PythonType)));
}
System.Console.WriteLine("Using Python at: " + PythonHome);
PublicIncludePaths.Add(PythonHome);
string libPath = GetMacPythonLibFile(PythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicDelayLoadDLLs.Add(libPath);
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (PythonHome == "")
{
string includesPath = DiscoverLinuxPythonIncludesPath();
if (includesPath == null)
{
throw new System.Exception("Unable to find Python includes, please add a search path to linuxKnownIncludesPaths");
}
string libsPath = DiscoverLinuxPythonLibsPath();
if (libsPath == null)
{
throw new System.Exception("Unable to find Python libs, please add a search path to linuxKnownLibsPaths");
}
PublicIncludePaths.Add(includesPath);
PublicAdditionalLibraries.Add(libsPath);
}
else
{
string[] items = PythonHome.Split(';');
PublicIncludePaths.Add(items[0]);
PublicAdditionalLibraries.Add(items[1]);
}
}
#if WITH_FORWARDED_MODULE_RULES_CTOR
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicIncludePaths.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/python35/include"));
PublicLibraryPaths.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/armeabi-v7a"));
PublicAdditionalLibraries.Add("python3.5m");
string APLName = "UnrealEnginePython_APL.xml";
string RelAPLPath = Utils.MakePathRelativeTo(System.IO.Path.Combine(ModuleDirectory, APLName), Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", RelAPLPath);
}
#endif
}
public SpatialGDK(ReadOnlyTargetRules Target) : base(Target)
{
bLegacyPublicIncludePaths = false;
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
bUseUnity = false;
PrivateIncludePaths.Add("SpatialGDK/Private");
var WorkerSDKPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "Public", "WorkerSDK"));
PublicIncludePaths.Add(WorkerSDKPath); // Worker SDK uses a different include format <improbable/x.h>
PrivateIncludePaths.Add(WorkerSDKPath);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"EngineSettings",
"Http",
"InputCore",
"OnlineSubsystemUtils",
"Projects",
"ReplicationGraph",
"Sockets",
"Slate",
"UMG"
});
if (Target.bWithPushModel)
{
PublicDependencyModuleNames.Add("NetCore");
}
if (Target.bBuildDeveloperTools || (Target.Configuration != UnrealTargetConfiguration.Shipping &&
Target.Configuration != UnrealTargetConfiguration.Test))
{
PublicDependencyModuleNames.Add("GameplayDebugger");
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=1");
}
else
{
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=0");
}
if (Target.bBuildEditor)
{
PublicDependencyModuleNames.Add("UnrealEd");
PublicDependencyModuleNames.Add("SpatialGDKServices");
}
if (Target.bWithPerfCounters)
{
PublicDependencyModuleNames.Add("PerfCounters");
}
var WorkerLibraryDir = Path.Combine(ModuleDirectory, "..", "..", "Binaries", "ThirdParty", "Improbable", Target.Platform.ToString());
string LibPrefix = "libimprobable_";
string ImportLibSuffix = ".so";
string SharedLibSuffix = ".so";
bool bAddDelayLoad = false;
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
LibPrefix = "improbable_";
ImportLibSuffix = ".lib";
SharedLibSuffix = ".dll";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
ImportLibSuffix = SharedLibSuffix = ".dylib";
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
ImportLibSuffix = "_stub.a";
SharedLibSuffix = ".prx";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
LibPrefix = "improbable_";
ImportLibSuffix = ".lib";
SharedLibSuffix = ".dll";
// We don't set bAddDelayLoad = true here, because we get "unresolved external symbol __delayLoadHelper2".
// See: https://www.fmod.org/questions/question/deploy-issue-on-xboxone-with-unrealengine-4-14/
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
ImportLibSuffix = SharedLibSuffix = "_static.a";
}
else if (!(Target.Platform == UnrealTargetPlatform.Linux || Target.Platform == UnrealTargetPlatform.Android))
{
throw new System.Exception(System.String.Format("Unsupported platform {0}", Target.Platform.ToString()));
}
string WorkerImportLib = System.String.Format("{0}worker{1}", LibPrefix, ImportLibSuffix);
string WorkerSharedLib = System.String.Format("{0}worker{1}", LibPrefix, SharedLibSuffix);
if (Target.Platform != UnrealTargetPlatform.Android)
{
RuntimeDependencies.Add(Path.Combine(WorkerLibraryDir, WorkerSharedLib), StagedFileType.NonUFS);
if (bAddDelayLoad)
{
PublicDelayLoadDLLs.Add(WorkerSharedLib);
}
WorkerImportLib = Path.Combine(WorkerLibraryDir, WorkerImportLib);
PublicRuntimeLibraryPaths.Add(WorkerLibraryDir);
PublicAdditionalLibraries.Add(WorkerImportLib);
}
else
{
var WorkerLibraryPaths = new List <string>
{
Path.Combine(WorkerLibraryDir, "arm64-v8a"),
Path.Combine(WorkerLibraryDir, "armeabi-v7a"),
Path.Combine(WorkerLibraryDir, "x86_64"),
};
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "SpatialGDK_APL.xml"));
PublicRuntimeLibraryPaths.AddRange(WorkerLibraryPaths);
var WorkerLibraries = new List <string>
{
Path.Combine(WorkerLibraryDir, "arm64-v8a", WorkerSharedLib),
Path.Combine(WorkerLibraryDir, "armeabi-v7a", WorkerSharedLib),
Path.Combine(WorkerLibraryDir, "x86_64", WorkerSharedLib),
};
PublicAdditionalLibraries.AddRange(WorkerLibraries);
}
}
public bool LoadLeapLib(ReadOnlyTargetRules Target)
{
bool IsLibrarySupported = false;
if ((Target.Platform == UnrealTargetPlatform.Win64))
{
IsLibrarySupported = true;
string PlatformString = Target.Platform.ToString();
//Lib
PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, PlatformString, "LeapC.lib"));
//System.Console.WriteLine("plugin using lib at " + Path.Combine(LibraryPath, PlatformString, "LeapC.lib"));
if (IsEnginePlugin())
{
//string PluginDLLPath = Path.Combine(BinariesPath, PlatformString, "LeapC.dll");
//System.Console.WriteLine("Engine plugin detected, using dll at " + PluginDLLPath);
PublicDelayLoadDLLs.Add("LeapC.dll");
//RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/LeapMotion/" + PlatformString + "/LeapC.dll");
RuntimeDependencies.Add(Path.Combine(BinariesPath, PlatformString, "LeapC.dll"));
}
//Engine plugin, just add the dependency path
else
{
//DLL
string PluginDLLPath = Path.Combine(BinariesPath, PlatformString, "LeapC.dll");
System.Console.WriteLine("Project plugin detected, using dll at " + PluginDLLPath);
//For project plugins, copy the dll to the project if needed
CopyToProjectBinaries(PluginDLLPath, Target);
string DLLPath = Path.GetFullPath(Path.Combine(GetUProjectPath(), "Binaries", PlatformString, "LeapC.dll"));
RuntimeDependencies.Add(DLLPath);
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
IsLibrarySupported = false; //Not supported since Leap SDK 3.0
string PlatformString = "Mac";
PublicAdditionalLibraries.Add(Path.Combine(BinariesPath, PlatformString, "libLeap.dylib"));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
IsLibrarySupported = true;
System.Console.WriteLine(Target.Architecture); //doesn't work
string PlatformString = "Android";
//For now comment/uncomment platform architectures
//PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, PlatformString, "armeabi-v7a", "libLeapC.so"));
PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, PlatformString, "arm64-v8a", "libLeapC.so"));
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(ModulePath, "LeapMotion_APL.xml"));
}
return(IsLibrarySupported);
}
public GameAnalytics(TargetInfo Target)
#endif
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
var GameAnalyticsPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "../ThirdParty/"));
var libPath = Path.Combine(GameAnalyticsPath, "lib");
// Test plugin analytics in editor mode
PublicDefinitions.Add("TEST_NON_EDITOR_PLUGIN_ANALYTICS_MODE=0");
switch (Target.Platform)
{
case UnrealTargetPlatform.Win64:
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win64", "GameAnalytics.lib"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
break;
case UnrealTargetPlatform.Win32:
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win32", "GameAnalytics.lib"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
break;
case UnrealTargetPlatform.Android:
PrivateDependencyModuleNames.Add("Launch");
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private/Android"));
break;
case UnrealTargetPlatform.Mac:
PublicAdditionalLibraries.Add(Path.Combine(libPath, "osx", "libGameAnalytics.a"));
PublicAdditionalLibraries.Add("curl");
PublicFrameworks.AddRange(
new string[] {
"CoreFoundation",
"Foundation",
"CoreServices"
}
);
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL" });
break;
case UnrealTargetPlatform.Linux:
LoadLibrary(Path.Combine(libPath, "linux"), "libGameAnalytics.a");
//PublicAdditionalLibraries.Add(Path.Combine(libPath, "linux", "libGameAnalytics.a"));
//RuntimeDependencies.Add(Path.Combine(libPath, "linux", "libGameAnalytics.a"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
break;
case UnrealTargetPlatform.IOS:
PublicAdditionalLibraries.Add(Path.Combine(libPath, "ios", "libGameAnalytics.a"));
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private/IOS"));
PublicFrameworks.AddRange(
new string[] {
"AdSupport",
"SystemConfiguration"
}
);
PublicAdditionalLibraries.AddRange(
new string[] {
"sqlite3",
"z",
"c++"
});
break;
case UnrealTargetPlatform.HTML5:
if (Target.Architecture != "-win32")
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "html5", "GameAnalytics.jspre"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "html5", "GameAnalyticsUnreal.js"));
}
break;
case UnrealTargetPlatform.XboxOne:
case UnrealTargetPlatform.PS4:
default:
throw new NotImplementedException("This target platform is not configured for GameAnalytics SDK: " + Target.Platform.ToString());
}
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Private")));
PrivateIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Public")));
PublicIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Public")));
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Analytics",
"Engine"
}
);
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Json"
}
);
PublicIncludePathModuleNames.AddRange(
new string[]
{
"Json"
}
);
}
PublicIncludePathModuleNames.AddRange(
new string[]
{
"Analytics",
"Engine"
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(ModuleDirectory, "GameAnalytics_APL.xml"));
}
}
public Noesis(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string NoesisBasePath = ModuleDirectory + "/NoesisSDK/";
string NoesisIncludePath = NoesisBasePath + "Include/";
PublicIncludePaths.Add(ModuleDirectory);
PublicIncludePaths.Add(NoesisIncludePath);
// Let's try to make sure the right version of the SDK is in the right place.
const string RequiredRevision = "(r6972)";
const string RequiredVersionName = "2.1.0f1";
if (!Directory.Exists(NoesisBasePath))
{
throw new BuildException("Could not find NoesisGUI SDK in " + NoesisBasePath + ". Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Bin"))
{
throw new BuildException("Could not find NoesisGUI SDK Bin directory in " + NoesisBasePath + "Bin. Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Include"))
{
throw new BuildException("Could not find NoesisGUI SDK Include directory in " + NoesisBasePath + "Include. Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Lib"))
{
throw new BuildException("Could not find NoesisGUI SDK Lib directory in " + NoesisBasePath + "Lib. Minimum required version is " + RequiredVersionName);
}
string NoesisSdkVersionInfo;
try
{
NoesisSdkVersionInfo = File.ReadAllText(NoesisBasePath + "version.txt");
}
catch (Exception)
{
throw new BuildException("Could not find NoesisGUI SDK version.txt in " + NoesisBasePath + "version.txt. Minimum required version is " + RequiredVersionName);
}
string[] SplitVersion = NoesisSdkVersionInfo.Split(' ');
if (String.Compare(SplitVersion[SplitVersion.Length - 1], RequiredRevision) < 0)
{
throw new BuildException("Wrong version of the NoesisGUI SDK installed in " + NoesisBasePath + ". Minimum required version is " + RequiredVersionName);
}
PublicSystemIncludePaths.Add(NoesisIncludePath);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string NoesisLibPath = NoesisBasePath + "Lib/windows_x86_64/";
PublicLibraryPaths.Add(NoesisLibPath);
PublicAdditionalLibraries.Add("Noesis.lib");
string 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");
PublicAdditionalShadowFiles.Add(Path.Combine(NoesisLibPath, "libNoesis.a"));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string NoesisLibPath = NoesisBasePath + "Bin/android_arm/";
PublicLibraryPaths.Add(NoesisLibPath);
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");
}
}
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(new ReceiptProperty("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 SNSLibrary(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"SNSLibrary/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"SNSLibrary/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"HTTP",
// ... 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)
{
PublicDependencyModuleNames.AddRange(new string[] { "Launch" });
PrivateDependencyModuleNames.AddRange(new string[] { "Launch" });
string ProjectPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(ProjectPath, "SNSLibrary_UPL.xml")));
}
}
public GoogleVRHMD(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"GoogleVRHMD/Private",
"../../../../../Source/Runtime/Renderer/Private",
"../../../../../Source/Runtime/Core/Private",
"../../../../../Source/Runtime/ApplicationCore/Private"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RHI",
"RenderCore",
"Renderer",
"ShaderCore",
"HeadMountedDisplay",
"InputCore"
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("Launch");
}
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd",
"GoogleInstantPreview"
});
}
else if (Target.Platform != UnrealTargetPlatform.Mac)
{
PrivateDependencyModuleNames.AddRange(new string[] { "OpenGLDrv" });
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
PrivateIncludePaths.AddRange(
new string[] {
"../../../../../Source/Runtime/OpenGLDrv/Private",
// ... add other private include paths required here ...
}
);
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.AddRange(new string[] { "GoogleVR" });
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "GoogleVRHMD_APL.xml")));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PrivateDependencyModuleNames.AddRange(new string[] { "GoogleVR", "ApplicationCore" });
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("IOSPlugin", Path.Combine(PluginPath, "GoogleVRHMD_APL.xml")));
}
}
public AkAudio(ReadOnlyTargetRules Target) : base(Target)
{
string ThirdPartyFolder = Path.Combine(ModuleDirectory, "../../ThirdParty");
AkUEPlatformInstance = AkUEPlatform.GetAkUEPlatformInstance(Target, ThirdPartyFolder);
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivateIncludePathModuleNames.AddRange(new[] { "Settings", "UMG", "TargetPlatform" });
PublicDependencyModuleNames.AddRange(new[] { "UMG", "PhysX", "APEX" });
PrivateDependencyModuleNames.AddRange(new[]
{
"Core",
"CoreUObject",
"Engine",
"SlateCore",
"NetworkReplayStreaming",
"MovieScene",
"MovieSceneTracks",
"Projects",
"Json",
"Slate",
"InputCore",
"Projects"
});
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd",
"DesktopPlatform",
"TargetPlatform"
});
foreach (var Platform in GetAvailablePlatforms(ModuleDirectory))
{
PublicDefinitions.Add("AK_PLATFORM_" + Platform.ToUpper());
}
}
PrivateIncludePaths.Add("AkAudio/Private");
PublicIncludePaths.Add(Path.Combine(ThirdPartyFolder, "include"));
PublicDefinitions.Add("AK_UNREAL_MAX_CONCURRENT_IO=32");
PublicDefinitions.Add("AK_UNREAL_IO_GRANULARITY=32768");
if (Target.Configuration == UnrealTargetConfiguration.Shipping)
{
PublicDefinitions.Add("AK_OPTIMIZED");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && AkUEPlatformInstance.SupportsCommunication)
{
AkLibs.Add("CommunicationCentral");
PublicDefinitions.Add("AK_ENABLE_COMMUNICATION=1");
}
else
{
PublicDefinitions.Add("AK_ENABLE_COMMUNICATION=0");
}
if (AkUEPlatformInstance.SupportsAkAutobahn)
{
AkLibs.Add("AkAutobahn");
PublicDefinitions.Add("AK_SUPPORT_WAAPI=1");
}
else
{
PublicDefinitions.Add("AK_SUPPORT_WAAPI=0");
}
if (AkUEPlatformInstance.SupportsOpus)
{
AkLibs.Add("AkOpusDecoder");
PublicDefinitions.Add("AK_SUPPORT_OPUS=1");
}
else
{
PublicDefinitions.Add("AK_SUPPORT_OPUS=0");
}
if (AkUEPlatformInstance.SupportsDeviceMemory)
{
PublicDefinitions.Add("AK_SUPPORT_DEVICE_MEMORY=1");
}
else
{
PublicDefinitions.Add("AK_SUPPORT_DEVICE_MEMORY=0");
}
// Platform-specific dependencies
#if UE_4_24_OR_LATER
PublicSystemLibraries.AddRange(AkUEPlatformInstance.GetPublicSystemLibraries());
#else
PublicLibraryPaths.AddRange(AkUEPlatformInstance.GetPublicLibraryPaths());
PublicAdditionalLibraries.AddRange(AkUEPlatformInstance.GetPublicSystemLibraries());
#endif
AkLibs.AddRange(AkUEPlatformInstance.GetAdditionalWwiseLibs());
PublicDefinitions.AddRange(AkUEPlatformInstance.GetPublicDefinitions());
PublicDefinitions.Add(string.Format("AK_CONFIGURATION=\"{0}\"", AkUEPlatformInstance.akConfigurationDir));
var AdditionalProperty = AkUEPlatformInstance.GetAdditionalPropertyForReceipt(ModuleDirectory);
if (AdditionalProperty != null)
{
AdditionalPropertiesForReceipt.Add(AdditionalProperty.Item1, AdditionalProperty.Item2);
}
var Frameworks = AkUEPlatformInstance.GetPublicAdditionalFrameworks();
foreach (var fw in Frameworks)
{
#if UE_4_22_OR_LATER
PublicAdditionalFrameworks.Add(new ModuleRules.Framework(fw));
#else
PublicAdditionalFrameworks.Add(new UEBuildFramework(fw));
#endif
}
PublicAdditionalLibraries.AddRange(AkUEPlatformInstance.GetSanitizedAkLibList(AkLibs));
}
public AndroGallery(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 ...
//"Source/Runtime/Launch/Private",
"AndroGallery/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Engine",
// ... add other public dependencies that you statically link with here ...
"AndroidPermission",
}
);
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 ...
}
);
// For Android
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateIncludePaths.Add("AndroGallery/Private");
PrivateDependencyModuleNames.AddRange(new string[] { "Launch" });
string PluginRelativePath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginRelativePath, "AndroGalleryAPL.xml"));
}
}
public Firebase(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"Core",
"CoreUObject",
"Engine",
"Launch"
});
PublicDefinitions.Add("WITH_FIREBASE=1");
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("Launch");
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "Firebase.upl.xml"));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicDefinitions.Add("WITH_FIREBASE_IOS=1");
string FirebaseBaseIOSDir = Path.Combine(ModuleDirectory, "ThirdParty/IOS/");
PublicSystemIncludePaths.AddRange(
new string[] {
FirebaseBaseIOSDir + "include",
}
);
// Firebase frameworks for cloud messaging (notifications)
PublicAdditionalFrameworks.Add(
new Framework(
"FIRAnalyticsConnector",
Path.Combine(FirebaseBaseIOSDir, "FIRAnalyticsConnector.framework.zip"),
""
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseAnalytics",
Path.Combine(FirebaseBaseIOSDir, "FirebaseAnalytics.framework.zip"),
""
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseCore",
Path.Combine(FirebaseBaseIOSDir, "FirebaseCore.framework.zip"),
""
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseCoreDiagnostics",
Path.Combine(FirebaseBaseIOSDir, "FirebaseCoreDiagnostics.framework.zip"),
""
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseInstanceID",
Path.Combine(FirebaseBaseIOSDir, "FirebaseInstanceID.framework.zip"),
""
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseMessaging",
Path.Combine(FirebaseBaseIOSDir, "FirebaseMessaging.framework.zip"),
""
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleAppMeasurement",
Path.Combine(FirebaseBaseIOSDir, "GoogleAppMeasurement.framework.zip"),
""
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleUtilities",
Path.Combine(FirebaseBaseIOSDir, "GoogleUtilities.framework.zip"),
""
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"nanopb",
Path.Combine(FirebaseBaseIOSDir, "nanopb.framework.zip"),
""
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"Protobuf",
Path.Combine(FirebaseBaseIOSDir, "Protobuf.framework.zip"),
""
)
);
}
PublicIncludePathModuleNames.Add("Launch");
}
public RuntimeMeshLoader(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"RuntimeMeshLoader/Public",
Path.Combine(ThirdPartyPath, "assimp/include")
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"RuntimeMeshLoader/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"ProceduralMeshComponent",
"ImageCore",
"Json"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Slate",
"SlateCore",
"ImageWrapper"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64" : "x86";
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "assimp/lib", PlatformString, "assimp-vc140-mt.lib"));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(ThirdPartyPath, "assimp/bin", PlatformString, "assimp-vc140-mt.dll")));
string AssimpDll = ThirdPartyPath + "assimp/bin/" + PlatformString + "/assimp-vc140-mt.dll";
string thp = BinFolder(Target) + "assimp-vc140-mt.dll";
CopyFile(AssimpDll, thp);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
// PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "assimp/bin","Mac", "libassimp.4.1.0.dylib"));
// RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(ThirdPartyPath, "assimp/bin", "Mac", "libassimp.4.1.0.dylib")));
// string AssimpDll = ThirdPartyPath + "assimp/bin/" + "Mac" + "/libassimp.4.1.0.dylib";
// string thp = BinFolder(Target) + "libassimp.4.1.0.dylib";
// CopyFile(AssimpDll, thp);
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "assimp/lib", "iOS", "libassimp.a"));
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "assimp/lib", "iOS", "libIrrXML.a"));
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "assimp/lib", "iOS", "libzlibstatic.a"));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
//PrivateIncludePaths.Add(Path.Combine(ThirdPartyPath, "assimp.dir"));
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "assimp/lib", "Android", "libIrrXML.a"));
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "assimp/lib", "Android", "libzlibstatic.a"));
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "assimp/lib", "Android", "libassimp.a"));
PrivateDependencyModuleNames.AddRange(new string[] { "Launch" });
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(ModuleDirectory, "RuntimeMeshLoader._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",
"ProceduralMeshComponent",
"UElibPNG",
"zlib",
"MRMesh",
});
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"Settings" // For editor settings panel.
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
// Additional dependencies on android...
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Launch",
"OpenGLDrv"
}
);
// Register Plugin Language
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "GoogleARCoreBase_APL.xml"));
// Needed for including "AndroidEGL.h"
string EnginePath = Path.GetFullPath(Target.RelativeEnginePath);
PrivateIncludePaths.Add(Path.Combine(EnginePath, "Source/Runtime/OpenGLDrv/Private"));
}
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);
}
}
}
public GameAnalytics(TargetInfo Target)
#endif
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
var GameAnalyticsPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "../ThirdParty/"));
var libPath = Path.Combine(GameAnalyticsPath, "lib");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win64", "GameAnalytics.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win64", "Sqlite.lib"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win32", "GameAnalytics.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win32", "Sqlite.lib"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("Launch");
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private/Android"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "osx", "libGameAnalytics.a"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "osx", "libSqlite.a"));
PublicAdditionalLibraries.Add("curl");
PublicFrameworks.AddRange(
new string[] {
"CoreFoundation",
"Foundation",
"CoreServices"
}
);
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL" });
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "linux", "libGameAnalytics.a"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "linux", "libSqlite.a"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "ios", "libGameAnalytics.a"));
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private/IOS"));
PublicFrameworks.AddRange(
new string[] {
"AdSupport",
"SystemConfiguration",
"AppTrackingTransparency"
}
);
PublicAdditionalLibraries.AddRange(
new string[] {
"sqlite3",
"z",
"c++"
});
}
/*else if(Target.Platform == UnrealTargetPlatform.HTML5)
* {
* if (Target.Architecture != "-win32")
* {
* PublicAdditionalLibraries.Add(Path.Combine(libPath, "html5", "GameAnalytics.jspre"));
* PublicAdditionalLibraries.Add(Path.Combine(libPath, "html5", "GameAnalyticsUnreal.js"));
* }
* }*/
else
{
throw new NotImplementedException("This target platform is not configured for GameAnalytics SDK: " + Target.Platform.ToString());
}
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Private")));
PrivateIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Public")));
PublicIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Public")));
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Analytics",
"Engine"
}
);
/*if (Target.Platform == UnrealTargetPlatform.HTML5)
* {
* PrivateDependencyModuleNames.AddRange(
* new string[]
* {
* "Json"
* }
* );
*
* PublicIncludePathModuleNames.AddRange(
* new string[]
* {
* "Json"
* }
* );
* }*/
PublicIncludePathModuleNames.AddRange(
new string[]
{
"Analytics",
"Engine"
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "GameAnalytics_APL.xml"));
}
}
public EGSnsPlugin(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"EGSnsPlugin/Public",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"EGSnsPlugin/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)
* {
* PrivateIncludePaths.Add("EGSnsPlugin/Private/Android");
* }
* else
* {
* PrivateIncludePaths.Add("EGSnsPlugin/Private/GenericPlatform");
* }
*/
if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "EGSnsPlugin_UPL_Android.xml"));
}
}
public Noesis(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string NoesisBasePath = Path.Combine(ModuleDirectory, "NoesisSDK");
string NoesisIncludePath = Path.Combine(NoesisBasePath, "Include");
string NoesisInteractivityIncludePath = Path.Combine(NoesisBasePath, "Src", "Packages", "App", "Interactivity", "Include");
string NoesisMediaElementIncludePath = Path.Combine(NoesisBasePath, "Src", "Packages", "App", "MediaElement", "Include");
// In monolithic builds we don't want the Interactivity and MediaElement functions
// dllexported or dllimported from any modules.
// That's why we use PublicDefinitions.
if (Target.LinkType == TargetLinkType.Monolithic)
{
PublicDefinitions.Add("NS_APP_INTERACTIVITY_API=");
PublicDefinitions.Add("NS_APP_MEDIAELEMENT_API=");
}
PublicIncludePaths.Add(ModuleDirectory);
PublicIncludePaths.Add(NoesisIncludePath);
PublicIncludePaths.Add(NoesisInteractivityIncludePath);
PublicIncludePaths.Add(NoesisMediaElementIncludePath);
if (!Directory.Exists(NoesisBasePath))
{
throw new BuildException("Could not find NoesisGUI SDK in " + NoesisBasePath + ".");
}
if (!Directory.Exists(NoesisIncludePath))
{
throw new BuildException("Could not find NoesisGUI SDK Include directory in " + NoesisIncludePath);
}
PublicSystemIncludePaths.Add(NoesisIncludePath);
UnrealTargetPlatform Platform;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Lib", "windows_x86_64", "Noesis.lib"));
string NoesisDllPath = Path.Combine(NoesisBasePath, "Bin", "windows_x86_64", "Noesis.dll");
string NoesisDllTargetPath = Path.Combine("$(BinaryOutputDir)", "Noesis.dll");
RuntimeDependencies.Add(NoesisDllTargetPath, NoesisDllPath, StagedFileType.NonUFS);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
string NoesisSoName = "libNoesis.so";
string NoesisSoPath = Path.Combine(NoesisBasePath, "Bin", "linux_x86_64", NoesisSoName);
PublicAdditionalLibraries.Add(NoesisSoPath);
string NoesisSoTargetPath = Path.Combine("$(BinaryOutputDir)", NoesisSoName);
RuntimeDependencies.Add(NoesisSoTargetPath, NoesisSoPath, StagedFileType.NonUFS);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Bin", "macos", "Noesis.dylib"));
string NoesisDylibPath = Path.Combine("NoesisSDK", "Bin", "macos", "Noesis.dylib");
RuntimeDependencies.Add(Path.Combine(ModuleDirectory, NoesisDylibPath));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicDefinitions.Add("NS_STATIC_LIBRARY");
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Lib", "ios", "libNoesis.a"));
PublicFrameworks.Add("CoreText");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Bin", "android_arm", "libNoesis.so"));
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Bin", "android_arm64", "libNoesis.so"));
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Bin", "android_x86", "libNoesis.so"));
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Bin", "android_x86_64", "libNoesis.so"));
string NoesisAplPath = "Noesis_APL.xml";
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(ModuleDirectory, NoesisAplPath));
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicDefinitions.Add("NS_STATIC_LIBRARY");
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Lib", "ps4", "Noesis.a"));
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Lib", "xbox_one", "Noesis.lib"));
string NoesisDllPath = Path.Combine(NoesisBasePath, "Bin", "xbox_one", "Noesis.dll");
string NoesisDllTargetPath = Path.Combine("$(BinaryOutputDir)", "Noesis.dll");
RuntimeDependencies.Add(NoesisDllTargetPath, NoesisDllPath, StagedFileType.NonUFS);
}
else if (UnrealTargetPlatform.TryParse("HTML5", out Platform) && Target.Platform == Platform)
{
PublicAdditionalLibraries.Add(Path.Combine(NoesisBasePath, "Bin", "wasm", "Noesis.bc"));
}
}
public GoogleVRController(ReadOnlyTargetRules Target) : base(Target)
{
// 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.AddRange(
new string[]
{
"Launch",
"AndroidRuntimeSettings",
}
);
}
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"));
}
}
public OnlineSubsystemGoogle(ReadOnlyTargetRules Target) : base(Target)
{
bool bUsesRestfulImpl = false;
PrivateDefinitions.Add("ONLINESUBSYSTEMGOOGLE_PACKAGE=1");
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PrivateIncludePaths.Add("Private");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"HTTP",
"ImageCore",
"Json",
"Sockets",
"OnlineSubsystem",
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicDefinitions.Add("WITH_GOOGLE=1");
PublicDefinitions.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 Framework(
"GoogleSignIn",
"ThirdParty/IOS/GoogleSignInSDK/GoogleSignIn.embeddedframework.zip",
"GoogleSignIn.bundle"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleSignInDependencies",
"ThirdParty/IOS/GoogleSignInSDK/GoogleSignInDependencies.embeddedframework.zip"
)
);
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Launch",
}
);
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "OnlineSubsystemGoogle_UPL.xml"));
PrivateIncludePaths.Add("Private/Android");
}
else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
bUsesRestfulImpl = true;
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PrivateIncludePaths.Add("Private/XboxOne");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PrivateIncludePaths.Add("Private/PS4");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
bUsesRestfulImpl = true;
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
bUsesRestfulImpl = true;
}
else if (Target.Platform == UnrealTargetPlatform.Switch)
{
bUsesRestfulImpl = true;
}
else
{
PrecompileForTargets = PrecompileTargetsType.None;
}
if (bUsesRestfulImpl)
{
PublicDefinitions.Add("USES_RESTFUL_GOOGLE=1");
PrivateIncludePaths.Add("Private/Rest");
}
else
{
PublicDefinitions.Add("USES_RESTFUL_GOOGLE=0");
}
}
public Sharing(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Developer/Sharing/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[]
{
//"CoreUObject",
//"Engine",
//"InputCore",
//"RHI",
//"RenderCore",
//"HTTP",
//"UMG", "Slate", "SlateCore",
//"ImageWrapper",
// ... 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, "Sharing_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 RequiredVersionName = "2.2.5";
PublicDefinitions.Add("NOESIS_VERSION_NAME=\"" + RequiredVersionName + "\"");
if (!Directory.Exists(NoesisBasePath))
{
throw new BuildException("Could not find NoesisGUI SDK in " + NoesisBasePath + ". Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Bin"))
{
throw new BuildException("Could not find NoesisGUI SDK Bin directory in " + NoesisBasePath + "Bin. Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Include"))
{
throw new BuildException("Could not find NoesisGUI SDK Include directory in " + NoesisBasePath + "Include. Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Lib"))
{
throw new BuildException("Could not find NoesisGUI SDK Lib directory in " + NoesisBasePath + "Lib. Minimum required version is " + RequiredVersionName);
}
string NoesisSdkVersionInfo;
try
{
NoesisSdkVersionInfo = File.ReadAllText(NoesisBasePath + "version.txt");
}
catch (Exception)
{
throw new BuildException("Could not find NoesisGUI SDK version.txt in " + NoesisBasePath + "version.txt. Minimum required version is " + RequiredVersionName);
}
string[] LineSplit = NoesisSdkVersionInfo.Split('\n');
string[] SplitVersion = LineSplit[1].Split(' ');
Version InstalledVersion = new Version(SplitVersion[0]);
Version RequiredVersion = new Version(RequiredVersionName);
if (InstalledVersion != RequiredVersion)
{
throw new BuildException("Wrong version of the NoesisGUI SDK installed in " + NoesisBasePath + ". Required version is " + RequiredVersionName);
}
PublicSystemIncludePaths.Add(NoesisIncludePath);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string NoesisLibPath = NoesisBasePath + "Lib/windows_x86_64/";
PublicLibraryPaths.Add(NoesisLibPath);
PublicAdditionalLibraries.Add("Noesis.lib");
string NoesisDllPath = "/NoesisSDK/Bin/windows_x86_64/Noesis.dll";
string NoesisDllTargetPath = "/Binaries/Win64/Noesis.dll";
if (Target.ProjectFile != null)
{
CopyNoesisDll(ModuleDirectory + NoesisDllPath, DirectoryReference.FromFile(Target.ProjectFile).ToString() + NoesisDllTargetPath);
}
CopyNoesisDll(ModuleDirectory + NoesisDllPath, ModuleDirectory + "/../.." + NoesisDllTargetPath);
if (System.IO.File.Exists(Target.RelativeEnginePath + NoesisDllTargetPath))
{
System.IO.File.Delete(Target.RelativeEnginePath + NoesisDllTargetPath);
}
if (Target.LinkType == TargetLinkType.Monolithic)
{
RuntimeDependencies.Add("$(ProjectDir)" + NoesisDllTargetPath);
}
else
{
RuntimeDependencies.Add("$(EngineDir)" + NoesisDllTargetPath);
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string NoesisLibPath = NoesisBasePath + "Bin/osx/";
PublicLibraryPaths.Add(NoesisLibPath);
PublicAdditionalLibraries.Add(NoesisLibPath + "Noesis.dylib");
string NoesisDylibPath = "/NoesisSDK/Bin/osx/Noesis.dylib";
RuntimeDependencies.Add(ModuleDirectory + NoesisDylibPath);
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
string NoesisLibPath = NoesisBasePath + "Lib/ios/";
PublicLibraryPaths.Add(NoesisLibPath);
PublicAdditionalLibraries.Add("Noesis");
PublicFrameworks.Add("CoreText");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string NoesisLibPath = NoesisBasePath + "Bin/android_arm/";
PublicLibraryPaths.Add(NoesisLibPath);
string NoesisLib64Path = NoesisBasePath + "Bin/android_arm64/";
PublicLibraryPaths.Add(NoesisLib64Path);
PublicAdditionalLibraries.Add("Noesis");
string NoesisAplPath = "/Noesis_APL.xml";
AdditionalPropertiesForReceipt.Add("AndroidPlugin", ModuleDirectory + NoesisAplPath);
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
string NoesisLibPath = NoesisBasePath + "Lib/ps4/";
PublicAdditionalLibraries.Add(NoesisLibPath + "Noesis.a");
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
string NoesisLibPath = NoesisBasePath + "Bin/xbox_one/";
PublicLibraryPaths.Add(NoesisLibPath);
PublicAdditionalLibraries.Add("Noesis.lib");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
string NoesisLibPath = NoesisBasePath + "Bin/wasm/";
PublicAdditionalLibraries.Add(NoesisLibPath + "Noesis.bc");
}
}
public 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.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",
"ShaderCore",
"HeadMountedDisplay",
"Slate",
"SlateCore",
"ImageWrapper",
"MediaAssets",
"Analytics",
"UtilityShaders",
"OpenGLDrv",
"VulkanRHI",
"OVRPlugin",
"ProceduralMeshComponent",
});
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");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAftermath");
}
// 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)
{
// Vulkan
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
}
// AndroidPlugin
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "GearVR_APL.xml"));
}
}
}
public FMODStudio(TargetInfo Target)
{
bFasterWithoutUnity = true;
PublicIncludePaths.AddRange(
new string[] {
}
);
PrivateIncludePaths.AddRange(
new string[] {
"FMODStudio/Private",
"FMODStudio/Public/FMOD",
"FMODStudioOculus/Public",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Projects"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneTracks"
}
);
if (UEBuildConfiguration.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("AssetRegistry");
PrivateDependencyModuleNames.Add("UnrealEd");
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
string configName = "";
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
configName = "L";
Definitions.Add("FMODSTUDIO_LINK_LOGGING=1");
}
else
{
configName = "";
Definitions.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.
Utils.CollapseRelativeDirectories(ref 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
{
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(new RuntimeDependency(fmodDllPath));
RuntimeDependencies.Add(new RuntimeDependency(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(new RuntimeDependency(pluginPath));
}
}
if (copyThirdPartyPath.Length != 0)
{
string destPath = System.IO.Path.Combine(UEBuildConfiguration.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), BuildConfiguration.RelativeEnginePath);
System.Console.WriteLine("Adding {0}", RelAPLPath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", RelAPLPath));
foreach (string PluginName in System.IO.Directory.GetFiles(BasePath))
{
if (PluginName.EndsWith("_APL.xml", System.StringComparison.OrdinalIgnoreCase))
{
string RelPluginPath = Utils.MakePathRelativeTo(PluginName, BuildConfiguration.RelativeEnginePath);
System.Console.WriteLine("Adding {0}", RelPluginPath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", RelPluginPath));
}
}
}
}
public AdMob(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Public/AdMob.h";
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");
// admob
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"GoogleMobileAds", // Framework name
"../ThirdParty/ThirdPartyFrameworks/GoogleMobileAds.embeddedframework.zip")
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"GoogleAppMeasurement", // Framework name
"../ThirdParty/ThirdPartyFrameworks/GoogleAppMeasurement.embeddedframework.zip")
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"GoogleUtilities", // Framework name
"../ThirdParty/ThirdPartyFrameworks/GoogleUtilities.embeddedframework.zip")
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"nanopb", // Framework name
"../ThirdParty/ThirdPartyFrameworks/nanopb.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"
}
);
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("IOSPlugin", Path.Combine(PluginPath, "AdMob_IOS_UPL.xml"));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
//PrivateIncludePaths.Add("Private/Android");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Launch",
}
);
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("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 Vungle(TargetInfo 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, BuildConfiguration.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 Crasheye(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
// ... add other public dependencies that you statically link with here ...
//"UMG",
}
);
if (Target.Platform == UnrealTargetPlatform.IOS ||
Target.Platform == UnrealTargetPlatform.Mac)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
// ... add private dependencies that you statically link with here ...
}
);
}
else
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
// ... add private dependencies that you statically link with here ...
}
);
}
if (Target.Type == TargetRules.TargetType.Editor)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Settings",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Settings",
}
);
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.AddRange(new string[] { "Launch" });
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", System.IO.Path.Combine(PluginPath, "Android/Crasheye_APL.xml"));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"Crasheye",
"IOS/Crasheye.embeddedframework.zip" // Zip name
)
);
}
}
