예제 #1
0
        public override void PostBuild(NativePlugin plugin, NativeBuildOptions buildOptions)
        {
            base.PostBuild(plugin, buildOptions);

            string assetFile = CombinePath(
                AssetDatabase.GetAssetPath(plugin.pluginBinaryFolder),
                "WebGL",
                string.Format("{0}.bc", plugin.Name));

            PluginImporter pluginImporter = PluginImporter.GetAtPath((assetFile)) as PluginImporter;

            if (pluginImporter != null)
            {
                SetPluginBaseInfo(plugin, buildOptions, pluginImporter);

                pluginImporter.SaveAndReimport();
            }
        }
예제 #2
0
 private static void ToggleAssemblies(string path, string[] assemblies, bool enable)
 {
     foreach (var file in assemblies)
     {
         var            filepath = path + file;
         PluginImporter importer = AssetImporter.GetAtPath(filepath) as PluginImporter;
         if (importer == null)
         {
             Debug.LogFormat("GitHub for Unity: Could not find importer for {0}. Some functionality may fail.", filepath);
             continue;
         }
         if (importer.GetCompatibleWithEditor() != enable)
         {
             importer.SetCompatibleWithEditor(enable);
             importer.SaveAndReimport();
         }
     }
 }
예제 #3
0
        private static bool SetDLLCompatibility(string pathToDLL, BuildTarget[] supportedBuildTargets, bool isCompatibleWithEditor)
        {
            if (HasCompatibility(pathToDLL, supportedBuildTargets, isCompatibleWithEditor))
            {
                return(false);
            }

            PluginImporter pluginImporter = (PluginImporter)AssetImporter.GetAtPath(pathToDLL);

            pluginImporter.SetCompatibleWithAnyPlatform(false);
            pluginImporter.SetCompatibleWithEditor(isCompatibleWithEditor);
            foreach (BuildTarget buildTarget in supportedBuildTargets)
            {
                pluginImporter.SetCompatibleWithPlatform(buildTarget, true);
            }

            pluginImporter.SaveAndReimport();

            return(true);
        }
예제 #4
0
        public override void PostBuild(NativePlugin plugin, NativeBuildOptions buildOptions)
        {
            base.PostBuild(plugin, buildOptions);

            string assetFile = CombinePath(
                AssetDatabase.GetAssetPath(plugin.pluginBinaryFolder),
                "iOS",
                string.Format("lib{0}.a", plugin.Name));

            PluginImporter pluginImporter = PluginImporter.GetAtPath((assetFile)) as PluginImporter;

            if (pluginImporter != null)
            {
                SetPluginBaseInfo(plugin, buildOptions, pluginImporter);

                pluginImporter.SetCompatibleWithAnyPlatform(false);
                pluginImporter.SetCompatibleWithPlatform(BuildTarget.iOS, true);

                pluginImporter.SaveAndReimport();
            }
        }
    static void Update()
    {
        EditorApplication.update -= Update;

        IAPChecker.CheckItNow();

        if (Directory.Exists("Assets/EasyMobile"))
        {
            AddDefine("EASY_MOBILE_LITE", BuildTargetGroup.Android);
            AddDefine("EASY_MOBILE_LITE", BuildTargetGroup.iOS);
        }

        PluginImporter importer = AssetImporter.GetAtPath("Assets/EasyMobile/Plugins/iOS/libEasyMobileLite.a") as PluginImporter;

        if (importer != null)
        {
            importer.SetCompatibleWithAnyPlatform(false);
            importer.SetCompatibleWithPlatform(BuildTarget.iOS, true);
            importer.SaveAndReimport();
        }
    }
예제 #6
0
    private static void CheckDynamicFrameworkSetting(string searchPath = "Assets/Plugins/IOS")
    {
        string[] keys = { "MoPub" };
        foreach (string filePath in Directory.GetDirectories(searchPath, "*.framework", searchOption: SearchOption.AllDirectories))
        {
            bool isContainKeyWorld = false;
            foreach (string key in keys)
            {
                if (filePath.Contains(key))
                {
                    isContainKeyWorld = true;
                    break;
                }
            }
            if (!isContainKeyWorld)
            {
                continue;
            }

            PluginImporter importer = AssetImporter.GetAtPath(filePath) as PluginImporter;
            if (importer == null)
            {
                Debug.LogError("PluginImporter not found" + filePath);
                throw new System.Exception("PluginImporter not found");
            }

            string oldValue = importer.GetPlatformData(BuildTarget.iOS, "AddToEmbeddedBinaries");
            if (oldValue != "true")
            {
                Debug.Log("begin set AddToEmbeddedBinaries in: " + filePath);

                importer.SetPlatformData(BuildTarget.iOS, "AddToEmbeddedBinaries", "true");
                importer.SaveAndReimport();
            }
            else
            {
                Debug.LogFormat("{0} already set AddToEmbeddedBinaries.", filePath);
            }
        }
    }
예제 #7
0
        public override void PostBuild(NativePlugin plugin, NativeBuildOptions buildOptions)
        {
            base.PostBuild(plugin, buildOptions);

            string assetFile = CombinePath(
                AssetDatabase.GetAssetPath(plugin.pluginBinaryFolder),
                "WSA",
                buildOptions.Architecture.ToString(),
                string.Format("{0}.dll", plugin.Name));

            PluginImporter pluginImporter = PluginImporter.GetAtPath((assetFile)) as PluginImporter;

            if (pluginImporter != null)
            {
                SetPluginBaseInfo(plugin, buildOptions, pluginImporter);

                pluginImporter.SetCompatibleWithAnyPlatform(false);
                pluginImporter.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, true);
                pluginImporter.SetPlatformData(BuildTarget.WSAPlayer, "CPU", buildOptions.Architecture.ToString());

                pluginImporter.SaveAndReimport();
            }
        }
    /// <summary>
    /// Sets the plugins.
    /// </summary>
    /// <param name="files">Files.</param>
    /// <param name="editorSettings">Editor settings.</param>
    /// <param name="settings">Settings.</param>
    static void SetPlugins(string[] files, Dictionary<string,string> editorSettings, Dictionary<BuildTarget,Dictionary<string,string>> settings)
    {
        foreach (string item in files) {

                        PluginImporter pluginImporter = PluginImporter.GetAtPath (item) as PluginImporter;

                        if (pluginImporter != null) {

                                pluginImporter.SetCompatibleWithAnyPlatform (false);
                                pluginImporter.SetCompatibleWithEditor (false);

                                if (editorSettings != null) {
                                        pluginImporter.SetCompatibleWithEditor (true);

                                        foreach (KeyValuePair<string, string> pair in editorSettings) {
                                                pluginImporter.SetEditorData (pair.Key, pair.Value);
                                        }
                                }

                                foreach (KeyValuePair<BuildTarget, Dictionary<string,string>> settingPair in settings) {

                                        pluginImporter.SetCompatibleWithPlatform (settingPair.Key, true);
                                        if (settingPair.Value != null) {
                                                foreach (KeyValuePair<string, string> pair in settingPair.Value) {
                                                        pluginImporter.SetPlatformData (settingPair.Key, pair.Key, pair.Value);
                                                }
                                        }
                                }

                                pluginImporter.SaveAndReimport ();

                                Debug.Log ("SetPluginImportSettings Success :" + item);
                        } else {
                                Debug.LogError ("SetPluginImportSettings Faild :" + item);
                        }
                }
    }
예제 #9
0
    static void SetDLLPlatforms(string dllName, bool active)
    {
        string[] assetGuids = AssetDatabase.FindAssets(dllName);

        foreach (string guid in assetGuids)
        {
            string dllPath = AssetDatabase.GUIDToAssetPath(guid);
            if (string.IsNullOrEmpty(dllPath) || dllPath.ToLower().EndsWith(".dll") == false)
            {
                return;
            }

            PluginImporter importer = AssetImporter.GetAtPath(dllPath) as PluginImporter;

            bool allCorrect = true;
            if (importer.GetCompatibleWithAnyPlatform() != active)
            {
                allCorrect = false;
            }
            else
            {
                if (importer.GetCompatibleWithAnyPlatform())
                {
                    if (importer.GetExcludeEditorFromAnyPlatform() != !active ||
                        importer.GetExcludeFromAnyPlatform(BuildTarget.StandaloneWindows) != !active)
                    {
                        allCorrect = false;
                    }
                }
                else
                {
                    if (importer.GetCompatibleWithEditor() != active ||
                        importer.GetCompatibleWithPlatform(BuildTarget.StandaloneWindows) != active)
                    {
                        allCorrect = false;
                    }
                }
            }

            if (allCorrect == false)
            {
                if (active)
                {
                    importer.SetCompatibleWithAnyPlatform(true);
                    importer.SetExcludeEditorFromAnyPlatform(false);
                    importer.SetExcludeFromAnyPlatform(BuildTarget.Android, false);
                    importer.SetExcludeFromAnyPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetExcludeFromAnyPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetExcludeFromAnyPlatform(BuildTarget.StandaloneLinux64, false);
                }
                else
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                }
                importer.SaveAndReimport();
            }
        }
    }
예제 #10
0
        private static void OnScriptsReloaded()
        {
            if (EditorPrefs.GetBool("RTSL_BuildAll"))
            {
                EditorPrefs.SetBool("RTSL_BuildAll", false);
                try
                {
                    AssetDatabase.StartAssetEditing();

                    CreateAssetLibraryForActiveScene();
                    Debug.Log("Asset Libraries Updated");

                    CreateAssetLibrariesList();
                    Debug.Log("Asset Libraries List Updated");

                    CreateShaderProfiles();
                    Debug.Log("Shader Profiles Updated");
                }
                catch (Exception e)
                {
                    Debug.LogError(e);
                }
                finally
                {
                    AssetDatabase.StopAssetEditing();
                }

                try
                {
                    AssetDatabase.StartAssetEditing();
                    BuildTypeModel();
                    EditorUtility.DisplayProgressBar("Build All", "Updating type model import settings", 0.99f);
                }
                catch (Exception e)
                {
                    Debug.LogError(e);
                    EditorUtility.ClearProgressBar();
                }
                finally
                {
                    AssetDatabase.StopAssetEditing();
                }
            }

            if (EditorPrefs.GetInt("RTSL_UpdateTypeModelImportSettings") > 0)
            {
                try
                {
                    string         path           = RTSLPath.UserRoot + "/" + TypeModelDll;
                    AssetImporter  assetImporter  = AssetImporter.GetAtPath(path);
                    PluginImporter pluginImporter = assetImporter as PluginImporter;
                    if (pluginImporter == null)
                    {
                        int attemptsRemaining = EditorPrefs.GetInt("RTSL_UpdateTypeModelImportSettings");
                        if (attemptsRemaining == 2)
                        {
                            AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
                        }
                        else if (attemptsRemaining == 1)
                        {
                            Debug.LogWarning("Unable to set " + path + " compatible with " + EditorUserBuildSettings.activeBuildTarget + " platform. Please do it manually");
                        }
                        EditorPrefs.SetInt("RTSL_UpdateTypeModelImportSettings", attemptsRemaining - 1);
                    }
                    else
                    {
                        EditorPrefs.SetInt("RTSL_UpdateTypeModelImportSettings", 0);
                        pluginImporter.SetCompatibleWithAnyPlatform(false);
                        pluginImporter.SetCompatibleWithPlatform(EditorUserBuildSettings.activeBuildTarget, true);
                        pluginImporter.SaveAndReimport();
                    }
                }
                finally
                {
                    EditorUtility.ClearProgressBar();
                }
            }
        }
예제 #11
0
 static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
 {
     // Fix for wrong tvOS platform imports
     {
         PluginImporter importer = AssetImporter.GetAtPath("Assets/Plugins/tvOS/GameAnalyticsTVOS.h") as PluginImporter;
         if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.tvOS) || importer.GetCompatibleWithPlatform(BuildTarget.iOS)))
         {
             importer.SetCompatibleWithAnyPlatform(false);
             importer.SetCompatibleWithEditor(false);
             importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
             importer.SetCompatibleWithPlatform(BuildTarget.WebPlayer, false);
             importer.SetCompatibleWithPlatform(BuildTarget.WebPlayerStreamed, false);
             importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
             importer.SetCompatibleWithPlatform(BuildTarget.tvOS, true);
             importer.SaveAndReimport();
         }
     }
     {
         PluginImporter importer = AssetImporter.GetAtPath("Assets/Plugins/tvOS/GameAnalyticsTVOSUnity.m") as PluginImporter;
         if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.tvOS) || importer.GetCompatibleWithPlatform(BuildTarget.iOS)))
         {
             importer.SetCompatibleWithAnyPlatform(false);
             importer.SetCompatibleWithEditor(false);
             importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
             importer.SetCompatibleWithPlatform(BuildTarget.WebPlayer, false);
             importer.SetCompatibleWithPlatform(BuildTarget.WebPlayerStreamed, false);
             importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
             importer.SetCompatibleWithPlatform(BuildTarget.tvOS, true);
             importer.SaveAndReimport();
         }
     }
     {
         PluginImporter importer = AssetImporter.GetAtPath("Assets/Plugins/tvOS/libGameAnalyticsTVOS.a") as PluginImporter;
         if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.tvOS) || importer.GetCompatibleWithPlatform(BuildTarget.iOS)))
         {
             importer.SetCompatibleWithAnyPlatform(false);
             importer.SetCompatibleWithEditor(false);
             importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
             importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
             importer.SetCompatibleWithPlatform(BuildTarget.WebPlayer, false);
             importer.SetCompatibleWithPlatform(BuildTarget.WebPlayerStreamed, false);
             importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
             importer.SetCompatibleWithPlatform(BuildTarget.tvOS, true);
             importer.SaveAndReimport();
         }
     }
 }
    public static void EnableNativeVideoPlayer()
    {
        // rename NativeJavaPlayer.java.DISABLED to NativeJavaPlayer.java
        if (File.Exists(disabledPlayerFileName))
        {
            File.Move(disabledPlayerFileName, videoPlayerFileName);
            File.Move(disabledPlayerFileName + ".meta", videoPlayerFileName + ".meta");
        }

        AssetDatabase.ImportAsset(videoPlayerFileName);
        AssetDatabase.DeleteAsset(disabledPlayerFileName);

        // Enable audio plugins
        PluginImporter audio360      = (PluginImporter)AssetImporter.GetAtPath(audio360PluginPath);
        PluginImporter audio360exo29 = (PluginImporter)AssetImporter.GetAtPath(audio360Exo29PluginPath);

        if (audio360 != null && audio360exo29 != null)
        {
            audio360.SetCompatibleWithPlatform(BuildTarget.Android, true);
            audio360exo29.SetCompatibleWithPlatform(BuildTarget.Android, true);
            audio360.SaveAndReimport();
            audio360exo29.SaveAndReimport();
        }

        // Enable gradle build with exoplayer
        EditorUserBuildSettings.androidBuildSystem = AndroidBuildSystem.Gradle;

        // create android plugins directory if it doesn't exist
        if (!Directory.Exists(androidPluginsFolder))
        {
            Directory.CreateDirectory(androidPluginsFolder);
        }

        if (!File.Exists(gradleTemplatePath))
        {
            if (File.Exists(gradleTemplatePath + ".DISABLED"))
            {
                File.Move(disabledGradleTemplatePath, gradleTemplatePath);
                File.Move(disabledGradleTemplatePath + ".meta", gradleTemplatePath + ".meta");
            }
            else
            {
                File.Copy(internalGradleTemplatePath, gradleTemplatePath);
            }
            AssetDatabase.ImportAsset(gradleTemplatePath);
        }

        // parse the gradle file to check the current version:
        string currentFile = File.ReadAllText(gradleTemplatePath);

        List <string> lines = new List <string>(currentFile.Split('\n'));

        var gradleVersion = new System.Text.RegularExpressions.Regex("com.android.tools.build:gradle:([0-9]+\\.[0-9]+\\.[0-9]+)").Match(currentFile).Groups[1].Value;

        if (gradleVersion == "2.3.0")
        {
            // add google() to buildscript/repositories
            int buildscriptRepositories = GoToSection("buildscript.repositories", lines);

            if (FindInScope("google\\(\\)", buildscriptRepositories + 1, lines) == -1)
            {
                lines.Insert(GetScopeEnd(buildscriptRepositories + 1, lines), "\t\tgoogle()");
            }

            // add google() and jcenter() to allprojects/repositories
            int allprojectsRepositories = GoToSection("allprojects.repositories", lines);

            if (FindInScope("google\\(\\)", allprojectsRepositories + 1, lines) == -1)
            {
                lines.Insert(GetScopeEnd(allprojectsRepositories + 1, lines), "\t\tgoogle()");
            }
            if (FindInScope("jcenter\\(\\)", allprojectsRepositories + 1, lines) == -1)
            {
                lines.Insert(GetScopeEnd(allprojectsRepositories + 1, lines), "\t\tjcenter()");
            }
        }

        // add "compile 'com.google.android.exoplayer:exoplayer:2.9.5'" to dependencies
        int dependencies = GoToSection("dependencies", lines);

        if (FindInScope("com\\.google\\.android\\.exoplayer:exoplayer", dependencies + 1, lines) == -1)
        {
            lines.Insert(GetScopeEnd(dependencies + 1, lines), "\tcompile 'com.google.android.exoplayer:exoplayer:2.9.5'");
        }

        int android = GoToSection("android", lines);

        // add compileOptions to add Java 1.8 compatibility
        if (FindInScope("compileOptions", android + 1, lines) == -1)
        {
            int compileOptionsIndex = GetScopeEnd(android + 1, lines);
            lines.Insert(compileOptionsIndex, "\t}");
            lines.Insert(compileOptionsIndex, "\t\ttargetCompatibility JavaVersion.VERSION_1_8");
            lines.Insert(compileOptionsIndex, "\t\tsourceCompatibility JavaVersion.VERSION_1_8");
            lines.Insert(compileOptionsIndex, "\tcompileOptions {");
        }

        // add sourceSets if Version < 2018.2
#if !UNITY_2018_2_OR_NEWER
        if (FindInScope("sourceSets\\.main\\.java\\.srcDir", android + 1, lines) == -1)
        {
            lines.Insert(GetScopeEnd(android + 1, lines), "\tsourceSets.main.java.srcDir \"" + gradleSourceSetPath + "\"");
        }
#endif

        File.WriteAllText(gradleTemplatePath, string.Join("\n", lines.ToArray()));
    }
예제 #13
0
        static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
        {
            #region iOS and tvOS
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/tvOS/GameAnalyticsTVOS.h") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.tvOS) || importer.GetCompatibleWithPlatform(BuildTarget.iOS)))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, false);
                    importer.SaveAndReimport();
                }
            }
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/tvOS/GameAnalyticsTVOSUnity.m") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.tvOS) || importer.GetCompatibleWithPlatform(BuildTarget.iOS)))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, false);
                    importer.SaveAndReimport();
                }
            }
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/tvOS/libGameAnalyticsTVOS.a") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.tvOS) || importer.GetCompatibleWithPlatform(BuildTarget.iOS)))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, false);
                    importer.SaveAndReimport();
                }
            }
            #endregion // iOS and tvOS
            #region General
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/GameAnalytics.dll") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.StandaloneLinux) ||
                                         !importer.GetCompatibleWithPlatform(BuildTarget.StandaloneLinux64) ||
                                         !importer.GetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal) ||
#if UNITY_2017_3_OR_NEWER
                                         !importer.GetCompatibleWithPlatform(BuildTarget.StandaloneOSX) ||
#else
                                         !importer.GetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel) ||
                                         !importer.GetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64) ||
                                         !importer.GetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal) ||
#endif
                                         !importer.GetCompatibleWithPlatform(BuildTarget.StandaloneWindows) ||
                                         !importer.GetCompatibleWithPlatform(BuildTarget.StandaloneWindows64) ||
                                         !importer.GetCompatibleWithPlatform(BuildTarget.WSAPlayer) ||
                                         !importer.GetPlatformData(BuildTarget.WSAPlayer, "SDK").Equals("UWP") ||
                                         !importer.GetPlatformData(BuildTarget.WSAPlayer, "ScriptingBackend").Equals("Il2Cpp")))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, true);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, true);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, true);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Tizen, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, true);
                    importer.SetPlatformData(BuildTarget.WSAPlayer, "SDK", "UWP");
                    importer.SetPlatformData(BuildTarget.WSAPlayer, "ScriptingBackend", "Il2Cpp");
                    importer.SaveAndReimport();
                }
            }
            #endregion // General
            #region Standalone
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/Windows/x86/sqlite3.dll") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.StandaloneWindows)))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, false);
                    importer.SaveAndReimport();
                }
            }
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/Windows/x64/sqlite3.dll") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.StandaloneWindows64)))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, false);
                    importer.SaveAndReimport();
                }
            }
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/Linux/sqlite3.so") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.StandaloneLinux) ||
                                         !importer.GetCompatibleWithPlatform(BuildTarget.StandaloneLinux64) ||
                                         !importer.GetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal)))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, true);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, false);
                    importer.SaveAndReimport();
                }
            }
            #endregion // Standalone
            #region WebGL
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/WebGL/GameAnalytics.WebGL.dll") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.WebGL)))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, false);
                    importer.SaveAndReimport();
                }
            }
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/WebGL/HandleIO.jslib") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.WebGL)))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, false);
                    importer.SaveAndReimport();
                }
            }
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/WebGL/Mono.Data.Sqlite.dll") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.WebGL)))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, false);
                    importer.SaveAndReimport();
                }
            }
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/WebGL/sqlite.c") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.WebGL)))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, false);
                    importer.SaveAndReimport();
                }
            }
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/WebGL/sqlite.h") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.WebGL)))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, true);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, false);
                    importer.SaveAndReimport();
                }
            }
            #endregion // WebGL
            #region WSA
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/WSA/GameAnalytics.UWP.dll") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.WSAPlayer) ||
                                         !importer.GetPlatformData(BuildTarget.WSAPlayer, "SDK").Equals("UWP") ||
                                         !importer.GetPlatformData(BuildTarget.WSAPlayer, "ScriptingBackend").Equals("DotNet")))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, true);
                    importer.SetPlatformData(BuildTarget.WSAPlayer, "SDK", "UWP");
                    importer.SetPlatformData(BuildTarget.WSAPlayer, "ScriptingBackend", "DotNet");
                    importer.SaveAndReimport();
                }
            }
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/WSA/Microsoft.Data.Sqlite.dll") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.WSAPlayer) ||
                                         !importer.GetPlatformData(BuildTarget.WSAPlayer, "SDK").Equals("UWP")))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, true);
                    importer.SetPlatformData(BuildTarget.WSAPlayer, "SDK", "UWP");
                    importer.SaveAndReimport();
                }
            }
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/WSA/MetroLog.dll") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.WSAPlayer) ||
                                         !importer.GetPlatformData(BuildTarget.WSAPlayer, "SDK").Equals("AnySDK")))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, true);
                    importer.SetPlatformData(BuildTarget.WSAPlayer, "SDK", "AnySDK");
                    importer.SaveAndReimport();
                }
            }
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/WSA/x86/sqlite3.dll") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.WSAPlayer) ||
                                         !importer.GetPlatformData(BuildTarget.WSAPlayer, "SDK").Equals("UWP") ||
                                         !importer.GetPlatformData(BuildTarget.WSAPlayer, "CPU").Equals("X86")))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, true);
                    importer.SetPlatformData(BuildTarget.WSAPlayer, "SDK", "UWP");
                    importer.SetPlatformData(BuildTarget.WSAPlayer, "CPU", "X86");
                    importer.SaveAndReimport();
                }
            }
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/WSA/x64/sqlite3.dll") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.WSAPlayer) ||
                                         !importer.GetPlatformData(BuildTarget.WSAPlayer, "SDK").Equals("UWP") ||
                                         !importer.GetPlatformData(BuildTarget.WSAPlayer, "CPU").Equals("X64")))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, true);
                    importer.SetPlatformData(BuildTarget.WSAPlayer, "SDK", "UWP");
                    importer.SetPlatformData(BuildTarget.WSAPlayer, "CPU", "X64");
                    importer.SaveAndReimport();
                }
            }
            {
                PluginImporter importer = AssetImporter.GetAtPath("Assets/GameAnalytics/Plugins/WSA/ARM/sqlite3.dll") as PluginImporter;
                if (importer != null && (importer.GetCompatibleWithAnyPlatform() || !importer.GetCompatibleWithPlatform(BuildTarget.WSAPlayer) ||
                                         !importer.GetPlatformData(BuildTarget.WSAPlayer, "SDK").Equals("UWP") ||
                                         !importer.GetPlatformData(BuildTarget.WSAPlayer, "CPU").Equals("ARM")))
                {
                    importer.SetCompatibleWithAnyPlatform(false);
                    importer.SetCompatibleWithEditor(false);
                    importer.SetCompatibleWithPlatform(BuildTarget.Android, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinux64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneLinuxUniversal, false);
#if UNITY_2017_3_OR_NEWER
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSX, false);
#else
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXIntel64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneOSXUniversal, false);
#endif
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.StandaloneWindows64, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.iOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.tvOS, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WebGL, false);
                    importer.SetCompatibleWithPlatform(BuildTarget.WSAPlayer, true);
                    importer.SetPlatformData(BuildTarget.WSAPlayer, "SDK", "UWP");
                    importer.SetPlatformData(BuildTarget.WSAPlayer, "CPU", "ARM");
                    importer.SaveAndReimport();
                }
            }
            #endregion // WSA
        }
        static void SetCompatibility(string guid, PlatformSupport[] platformSupport)
        {
            string pluginPath = AssetDatabase.GUIDToAssetPath(guid);

            PluginImporter plugin = AssetImporter.GetAtPath(pluginPath) as PluginImporter;

            if (plugin == null)
            {
                return;
            }

            bool updateRequired = false;

            if (platformSupport.Length == 0)
            {
                // Just set every platform to disabled before enabling the correct ones
                foreach (BuildTarget bt in Enum.GetValues(typeof(BuildTarget)))
                {
                    // If the build target is obsolete
                    if (bt < 0)
                    {
                        continue;
                    }

                    // Use a string here to handle issue where a platform dependency may not be installed
                    // within the current Unity Editor install
                    if (plugin.GetCompatibleWithPlatform(bt.ToString()))
                    {
                        updateRequired = true;
                    }
                }
            }
            else
            {
                foreach (PlatformSupport s in platformSupport)
                {
                    if (!plugin.GetCompatibleWithPlatform(s.platformName))
                    {
                        updateRequired = true;
                    }

                    if (plugin.GetCompatibleWithEditor() != s.editorSupport)
                    {
                        updateRequired = true;
                    }

                    if (s.editorSupport)
                    {
                        if (plugin.GetEditorData("OS") != s.editorOS ||
                            plugin.GetEditorData("CPU") != s.editorCPU)
                        {
                            updateRequired = true;
                        }
                    }
                }
            }

            if (updateRequired)
            {
#if UNITY_5_5_OR_NEWER
                plugin.ClearSettings();
#endif
                plugin.SetCompatibleWithEditor(false);
                plugin.SetCompatibleWithAnyPlatform(false);

                // Just set every platform to disabled before enabling the correct ones
                foreach (BuildTarget bt in Enum.GetValues(typeof(BuildTarget)))
                {
                    // If the build target is obsolete
                    if (bt < 0)
                    {
                        continue;
                    }

                    // Use a string here to handle issue where a platform dependency may not be installed
                    // within the current Unity Editor install
                    plugin.SetCompatibleWithPlatform(bt.ToString(), false);
                }

                foreach (PlatformSupport s in platformSupport)
                {
                    plugin.SetCompatibleWithPlatform(s.platformName, s.platformSupport);

                    plugin.SetPlatformData("Any", "Exclude Editor", (s.editorSupport ? 0 : 1).ToString());
                    plugin.SetPlatformData("Any", "Exclude " + s.platformName, (s.platformSupport ? 0 : 1).ToString());

                    if (!string.IsNullOrEmpty(s.platformCPU))
                    {
                        plugin.SetPlatformData(s.platformName, "CPU", s.platformCPU);
                    }

                    plugin.SetCompatibleWithEditor(s.editorSupport);

                    if (s.editorSupport)
                    {
                        plugin.SetEditorData("OS", s.editorOS);
                        plugin.SetEditorData("CPU", s.editorCPU);
                    }
                }

                plugin.SaveAndReimport();
            }
        }
    private static void ConfigureLibraries()
    {
        PluginImporter windows32 = AssetImporter.GetAtPath("Assets/PygmyMonkey/FileBrowser/Plugins/Windows/x86/NativeFileBrowser.dll") as PluginImporter;

        SetCompatibleWithEditor(windows32, true);
        SetCompatibleWithAnyPlatform(windows32, false);
        SetCompatibleWithPlatform(windows32, BuildTarget.StandaloneWindows, true);
        SetCompatibleWithPlatform(windows32, BuildTarget.StandaloneWindows64, false);
        SetExcludeEditorFromAnyPlatform(windows32, false);
        SetExcludeFromAnyPlatform(windows32, BuildTarget.StandaloneWindows, false);
        SetExcludeFromAnyPlatform(windows32, BuildTarget.StandaloneWindows64, true);
        SetEditorData(windows32, "x86", "Windows");

        PluginImporter windows64 = AssetImporter.GetAtPath("Assets/PygmyMonkey/FileBrowser/Plugins/Windows/x86_64/NativeFileBrowser.dll") as PluginImporter;

        SetCompatibleWithEditor(windows64, true);
        SetCompatibleWithAnyPlatform(windows64, false);
        SetCompatibleWithPlatform(windows64, BuildTarget.StandaloneWindows, false);
        SetCompatibleWithPlatform(windows64, BuildTarget.StandaloneWindows64, true);
        SetExcludeEditorFromAnyPlatform(windows64, false);
        SetExcludeFromAnyPlatform(windows64, BuildTarget.StandaloneWindows, true);
        SetExcludeFromAnyPlatform(windows64, BuildTarget.StandaloneWindows64, false);
        SetEditorData(windows64, "x86_64", "Windows");

        PluginImporter osx32 = AssetImporter.GetAtPath("Assets/PygmyMonkey/FileBrowser/Plugins/MacOS/x86/NativeFileBrowser.bundle") as PluginImporter;

        SetCompatibleWithEditor(osx32, true);
        SetCompatibleWithAnyPlatform(osx32, false);
        #if UNITY_2017_3_OR_NEWER
        SetCompatibleWithPlatform(osx32, BuildTarget.StandaloneOSX, false);
        #else
        SetCompatibleWithPlatform(osx32, BuildTarget.StandaloneOSXUniversal, false);
        SetCompatibleWithPlatform(osx32, BuildTarget.StandaloneOSXIntel, true);
        SetCompatibleWithPlatform(osx32, BuildTarget.StandaloneOSXIntel64, false);
        #endif
        SetExcludeEditorFromAnyPlatform(osx32, false);
        #if UNITY_2017_3_OR_NEWER
        SetExcludeFromAnyPlatform(osx32, BuildTarget.StandaloneOSX, true);
        #else
        SetExcludeFromAnyPlatform(osx32, BuildTarget.StandaloneOSXUniversal, true);
        SetExcludeFromAnyPlatform(osx32, BuildTarget.StandaloneOSXIntel, false);
        SetExcludeFromAnyPlatform(osx32, BuildTarget.StandaloneOSXIntel64, true);
        #endif
        SetEditorData(osx32, "x86", "OSX");

        PluginImporter osx64 = AssetImporter.GetAtPath("Assets/PygmyMonkey/FileBrowser/Plugins/MacOS/x86_64/NativeFileBrowser.bundle") as PluginImporter;
        SetCompatibleWithEditor(osx64, true);
        SetCompatibleWithAnyPlatform(osx64, false);
        #if UNITY_2017_3_OR_NEWER
        SetCompatibleWithPlatform(osx64, BuildTarget.StandaloneOSX, true);
        #else
        SetCompatibleWithPlatform(osx64, BuildTarget.StandaloneOSXUniversal, false);
        SetCompatibleWithPlatform(osx64, BuildTarget.StandaloneOSXIntel, false);
        SetCompatibleWithPlatform(osx64, BuildTarget.StandaloneOSXIntel64, true);
        #endif
        SetExcludeEditorFromAnyPlatform(osx64, false);
        #if UNITY_2017_3_OR_NEWER
        SetExcludeFromAnyPlatform(osx64, BuildTarget.StandaloneOSX, false);
        #else
        SetExcludeFromAnyPlatform(osx64, BuildTarget.StandaloneOSXUniversal, true);
        SetExcludeFromAnyPlatform(osx64, BuildTarget.StandaloneOSXIntel, true);
        SetExcludeFromAnyPlatform(osx64, BuildTarget.StandaloneOSXIntel64, false);
        #endif
        SetEditorData(osx64, "x86_64", "OSX");

        if (mHasAtLeastOneLibraryBeenModified)
        {
            windows32.SaveAndReimport();
            windows64.SaveAndReimport();
            osx32.SaveAndReimport();
            osx64.SaveAndReimport();
        }
    }
예제 #16
0
        /// <summary>
        /// 拷贝plugins资源,可通用(拷贝前会先清除)
        /// </summary>
        private static void CopyAndroidPlugins(BuildPlatformConfig config, string platformName, string packMode)
        {
            string pluginPath = config.pluginPath;

            // clear plugin dir
            {
                string platfromDataPath = string.Format(Directory.GetParent(UnityEngine.Application.dataPath) + "/PlatformData/{0}/android/{1}", platformName, packMode);
                if (Directory.Exists(pluginPath))
                {
                    Directory.Delete(pluginPath, true);
                    Directory.CreateDirectory(pluginPath);
                }
                AssetBuilderCtrl.CopyDirectory(platfromDataPath, pluginPath);
                AssetDatabase.Refresh();
            }

            // copy android data
            string resPath = string.Format(Directory.GetParent(UnityEngine.Application.dataPath) + "/PlatformData/{0}/android/res", platformName);

            if (Directory.Exists(resPath))
            {
                string resSavePath = pluginPath + "res";
                Directory.CreateDirectory(resSavePath);
                AssetBuilderCtrl.CopyDirectory(resPath, resSavePath);
                AssetDatabase.Refresh();
            }

            {
                string binSavePath = pluginPath + "bin";
                Directory.CreateDirectory(binSavePath);

                string binPath = string.Format(Directory.GetParent(UnityEngine.Application.dataPath) + "/PlatformData/{0}/android/bin", platformName);
                if (Directory.Exists(binPath))
                {
                    AssetBuilderCtrl.CopyDirectory(binPath, binSavePath);
                    AssetDatabase.Refresh();

                    DirectoryInfo dir = new DirectoryInfo(binSavePath);
                    foreach (FileInfo item in dir.GetFiles())
                    {
                        if (item.Extension == ".jar")
                        {
                            string         jarPath  = binSavePath + "/" + item.Name;
                            PluginImporter importer = AssetImporter.GetAtPath(jarPath) as PluginImporter;
                            importer.SetCompatibleWithPlatform(BuildTarget.Android, true);
                            importer.SaveAndReimport();
                        }
                    }
                    AssetDatabase.Refresh();
                }
            }

            {
                string libsSavePath = pluginPath + "libs";
                Directory.CreateDirectory(libsSavePath);

                string libsPath = string.Format(Directory.GetParent(UnityEngine.Application.dataPath) + "/PlatformData/{0}/android/libs", platformName);
                if (Directory.Exists(libsPath))
                {
                    AssetBuilderCtrl.CopyDirectory(libsPath, libsSavePath);
                    AssetDatabase.Refresh();

                    DirectoryInfo dir = new DirectoryInfo(libsSavePath);
                    foreach (DirectoryInfo item in dir.GetDirectories())
                    {
                        foreach (var soFile in item.GetFiles())
                        {
                            if (soFile.Extension == ".so")
                            {
                                string         soPath   = libsSavePath + "/" + item.Name + "/" + soFile.Name;
                                PluginImporter importer = AssetImporter.GetAtPath(soPath) as PluginImporter;
                                importer.SetCompatibleWithPlatform(BuildTarget.Android, true);
                                //importer.SetPlatformData(BuildTarget.Android, "CPU", "x86");
                                importer.SaveAndReimport();
                            }
                        }
                    }
                    AssetDatabase.Refresh();
                }
            }
            {
                string         jarPath  = pluginPath + "bin/androidu3d.jar";
                PluginImporter importer = AssetImporter.GetAtPath(jarPath) as PluginImporter;
                importer.SetCompatibleWithPlatform(BuildTarget.Android, true);
                importer.SaveAndReimport();
                AssetDatabase.Refresh();
            }
        }