Пример #1
0
        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")));
            }
        }
Пример #2
0
    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"));
        }
    }
Пример #3
0
    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");
        }
    }
Пример #4
0
        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);
                    }
                }
            }
        }
Пример #5
0
        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
    }
Пример #7
0
    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);
        }
    }
Пример #8
0
        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);
        }
Пример #9
0
        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"));
            }
        }
Пример #10
0
    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");
        }
    }
Пример #11
0
    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")));
        }
    }
Пример #13
0
        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")));
            }
        }
Пример #14
0
    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));
    }
Пример #15
0
        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");
        }
Пример #17
0
    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"));
        }
    }
Пример #18
0
        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);
                }
            }
        }
Пример #19
0
        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"));
            }
        }
Пример #20
0
    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"));
        }
    }
Пример #21
0
    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");
        }
    }
Пример #24
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")));
            }
        }
Пример #25
0
    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");
        }
    }
Пример #26
0
        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"));
                }
            }
        }
Пример #27
0
        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));
                    }
                }
            }
        }
Пример #28
0
    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;
        }
    }
Пример #29
0
    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;
        }
    }
Пример #30
0
    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
                    )
                );
        }
    }