Ejemplo n.º 1
0
        private static void DeferredUpdate()
        {
            EditorApplication.update -= DeferredUpdate;

            if (ModuleManager.CURRENT_MANIFEST == null)
            {
                return;
            }
            ModuleManifest manifest    = ModuleManager.CURRENT_MANIFEST;
            AssetModule    assetModule = ModuleManager.PROJECT_ASSET_MODULES[manifest.module.moduleID];

            if (!ModuleManager.DependenciesResolved(manifest.module))
            {
                EditorUtility.DisplayDialog(MSG_UPDATE_DEPS_TITLE, MSG_UPDATE_DEPS_INFO, "Ok");
                return;
            }

            if (assetModule.module.includesData)
            {
                bool accept = EditorUtility.DisplayDialog(MSG_UPDATE_DATA_TITLE, MSG_UPDATE_DATA_INFO, "Yes", "Cancel");
                if (!accept)
                {
                    return;
                }
            }

            ModuleManager.DeleteModuleContent(manifest.module, false);
            ModuleManager.ImportModuleContent(assetModule, CallbackUpdateComplete, CallbackUpdateFailed);
        }
Ejemplo n.º 2
0
        private void PaintContent()
        {
            this.PaintToolbar();
            this.contentScroll = EditorGUILayout.BeginScrollView(
                this.contentScroll,
                GUIStyle.none,
                GUI.skin.verticalScrollbar
                );

            EditorGUILayout.Space();

            ModuleManifest[] manifests = ModuleManager.GetProjectManifests();
            if (this.sidebarIndex < 0 || this.sidebarIndex >= manifests.Length)
            {
                ModuleManagerContent.PaintContentMessage();
            }
            else
            {
                ModuleManifest manifest = manifests[this.sidebarIndex];
                ModuleManagerContent.PaintProjectModule(manifest);
            }

            EditorGUILayout.Space();
            EditorGUILayout.EndScrollView();
        }
Ejemplo n.º 3
0
        public static Texture2D GetModuleIcon(string moduleID)
        {
            if (LOAD_DATA)
            {
                ModuleManager.InitializeData();
            }
            if (ModuleManager.PROJECT_MODULES.ContainsKey(moduleID))
            {
                ModuleManifest manifest    = ModuleManager.PROJECT_MODULES[moduleID];
                AssetModule    assetModule = null;
                if (ModuleManager.PROJECT_ASSET_MODULES.ContainsKey(moduleID))
                {
                    assetModule = ModuleManager.PROJECT_ASSET_MODULES[moduleID];
                }

                if (ModuleManager.IsEnabled(manifest.module))
                {
                    if (assetModule != null && assetModule.module.version.Higher(manifest.module.version))
                    {
                        return(GetTextureModuleUpdate());
                    }

                    return(GetTextureModuleEnabled());
                }

                return(GetTextureModuleInstalled());
            }

            return(GetTextureModuleUnknown());
        }
Ejemplo n.º 4
0
 public static void Remove(ModuleManifest manifest)
 {
     if (LOAD_DATA)
     {
         ModuleManager.InitializeData();
     }
     CURRENT_MANIFEST          = manifest;
     EditorApplication.update += ModuleManager.DeferredRemove;
 }
Ejemplo n.º 5
0
        private void PaintContent()
        {
            this.PaintToolbar();
            this.contentScroll = EditorGUILayout.BeginScrollView(
                this.contentScroll,
                GUIStyle.none,
                GUI.skin.verticalScrollbar
                );

            EditorGUILayout.Space();
            switch (this.toolbarOptionsIndex)
            {
            case 0:
                ModuleManifest[] manifests = ModuleManager.GetProjectManifests();
                if (this.sidebarIndex < 0 || this.sidebarIndex >= manifests.Length)
                {
                    ModuleManagerContent.PaintContentMessage();
                }
                else
                {
                    ModuleManifest manifest = manifests[this.sidebarIndex];
                    ModuleManagerContent.PaintProjectModule(manifest);
                }
                break;

            case 1:
                if (ModuleManagerStore.REQUEST_STATUS == ModuleManagerStore.StoreRequestStatus.Error)
                {
                    ModuleManagerContent.PaintContentMessage(ModuleManagerStore.REQUEST_DATA.error);
                    break;
                }
                else if (ModuleManagerStore.REQUEST_STATUS == ModuleManagerStore.StoreRequestStatus.Requesting)
                {
                    ModuleManagerContent.PaintContentMessage("Loading...");
                    break;
                }

                Module[] modules = ModuleManager.GetStoreModules();
                if (this.sidebarIndex < 0 || this.sidebarIndex >= modules.Length)
                {
                    ModuleManagerContent.PaintContentMessage();
                }
                else
                {
                    Module module = modules[this.sidebarIndex];
                    ModuleManagerContent.PaintStoreModule(module);
                }
                break;
            }

            EditorGUILayout.Space();
            EditorGUILayout.EndScrollView();
        }
Ejemplo n.º 6
0
        private static void DeferredDisable()
        {
            EditorApplication.update -= DeferredDisable;

            if (ModuleManager.CURRENT_MANIFEST == null)
            {
                return;
            }
            ModuleManifest manifest = ModuleManager.CURRENT_MANIFEST;

            ModuleManifest[] allManifests  = ModuleManager.GetProjectManifests();
            bool             hasDependency = false;

            for (int i = 0; !hasDependency && i < allManifests.Length; ++i)
            {
                if (allManifests[i].module.moduleID == manifest.module.moduleID)
                {
                    continue;
                }
                if (!ModuleManager.IsEnabled(allManifests[i].module))
                {
                    continue;
                }

                for (int j = 0; !hasDependency && j < allManifests[i].module.dependencies.Length; ++j)
                {
                    if (allManifests[i].module.dependencies[j].moduleID == manifest.module.moduleID)
                    {
                        hasDependency = true;
                    }
                }
            }

            if (hasDependency)
            {
                if (EditorUtility.DisplayDialog(MSG_DISABLE_DEPS_TITLE, MSG_DISABLE_DEPS_INFO, "Ok"))
                {
                    return;
                }
            }

            if (EditorUtility.DisplayDialog(
                    MSG_DISABLE_CONFIRM_TITLE,
                    MSG_DISABLE_CONFIRM_INFO,
                    "Yes",
                    "Cancel"))
            {
                ModuleManager.RemoveManifest(manifest.module);
                ModuleManager.DeleteModuleContent(manifest.module, true);
                ModuleManager.SetDirty();
            }
        }
Ejemplo n.º 7
0
        private static void PaintDependencies(string title, Dependency[] dependencies)
        {
            EditorGUILayout.LabelField(
                string.Format(title, dependencies.Length),
                EditorStyles.boldLabel
                );

            if (dependencies.Length > 0)
            {
                EditorGUILayout.BeginVertical(EditorStyles.helpBox);
                for (int i = 0; i < dependencies.Length; ++i)
                {
                    ModuleManifest depManifest = ModuleManager.GetModuleManifest(
                        dependencies[i].moduleID
                        );

                    Texture2D dot = ModuleManagerContent.GetDotG();
                    if (depManifest == null)
                    {
                        dot = ModuleManagerContent.GetDotR();
                    }
                    else if (depManifest.module.version.Higher(dependencies[i].version) ||
                             !ModuleManager.IsEnabled(depManifest.module))
                    {
                        dot = ModuleManagerContent.GetDotO();
                    }

                    string depName = string.Format(
                        " {0} - {1}",
                        dependencies[i].moduleID,
                        dependencies[i].version
                        );

                    GUIContent depContent = new GUIContent(depName, dot);
                    EditorGUILayout.LabelField(depContent);

                    Rect depRect = GUILayoutUtility.GetLastRect();
                    EditorGUIUtility.AddCursorRect(depRect, MouseCursor.Link);
                    if (UnityEngine.Event.current.type == EventType.MouseUp &&
                        depRect.Contains(UnityEngine.Event.current.mousePosition))
                    {
                        Application.OpenURL(string.Format(
                                                "https://store.gamecreator.io/?search={0}",
                                                dependencies[i].moduleID
                                                ));
                    }
                }
                EditorGUILayout.EndVertical();
            }
        }
Ejemplo n.º 8
0
        public static bool IsUpdateAvailable(ModuleManifest manifest)
        {
            if (LOAD_DATA)
            {
                ModuleManager.InitializeData();
            }
            string moduleID = manifest.module.moduleID;

            if (ModuleManager.PROJECT_ASSET_MODULES.ContainsKey(moduleID))
            {
                Version manifestVersion = manifest.module.version;
                Version assetVersion    = ModuleManager.PROJECT_ASSET_MODULES[moduleID].module.version;
                return(assetVersion.Higher(manifestVersion));
            }

            return(false);
        }
Ejemplo n.º 9
0
        private static void DeferredEnable()
        {
            EditorApplication.update -= DeferredEnable;

            if (ModuleManager.CURRENT_MANIFEST == null)
            {
                return;
            }
            ModuleManifest manifest = ModuleManager.CURRENT_MANIFEST;

            if (!ModuleManager.AssetModuleExists(manifest.module))
            {
                int option = EditorUtility.DisplayDialogComplex(
                    string.Format(MSG_MISSING_ASSETMODULE_TITLE, manifest.module.moduleID),
                    MSG_MISSING_ASSETMODULE_INFO,
                    "Download",
                    "Clean Manifest",
                    "Cancel"
                    );

                switch (option)
                {
                case 0:
                    Application.OpenURL(string.Format(STORE_MODULE_URI, manifest.module.moduleID));
                    break;

                case 1:
                    ModuleManager.RemoveManifest(manifest.module);
                    ModuleManager.SetDirty();
                    break;
                }

                return;
            }

            AssetModule assetModule = ModuleManager.PROJECT_ASSET_MODULES[manifest.module.moduleID];

            if (!ModuleManager.DependenciesResolved(assetModule.module))
            {
                EditorUtility.DisplayDialog(MSG_ENABLE_DEPS_TITLE, MSG_ENABLE_DEPS_INFO, "Ok");
                return;
            }

            ModuleManager.ImportModuleContent(assetModule, CallbackEnableComplete, CallbackEnableFailed);
        }
Ejemplo n.º 10
0
        private static void DeferredRemove()
        {
            EditorApplication.update -= DeferredRemove;

            if (ModuleManager.CURRENT_MANIFEST == null)
            {
                return;
            }
            ModuleManifest manifest = ModuleManager.CURRENT_MANIFEST;

            if (!ModuleManager.PROJECT_ASSET_MODULES.ContainsKey(manifest.module.moduleID))
            {
                return;
            }
            AssetModule assetModule = ModuleManager.PROJECT_ASSET_MODULES[manifest.module.moduleID];

            ModuleManager.RemoveManifest(manifest.module);
            ModuleManager.DeleteModuleAsset(assetModule);
            ModuleManager.SetDirty();
        }
Ejemplo n.º 11
0
        private static void DeferredBackup()
        {
            EditorApplication.update -= DeferredBackup;

            if (ModuleManager.CURRENT_MANIFEST == null)
            {
                return;
            }
            ModuleManifest manifest = ModuleManager.CURRENT_MANIFEST;

            List <string> assetsPath = new List <string>(manifest.module.codePaths);

            assetsPath.AddRange(manifest.module.dataPaths);
            for (int i = 0; i < assetsPath.Count; ++i)
            {
                assetsPath[i] = Path.GetDirectoryName(assetsPath[i]);
            }

            string backuppath = string.Format(BACKUP_FILEPATH, DateTime.Now.ToString("yyyy-MM-dd"));
            string filepath   = Path.Combine(ModuleManager.GetProjectPath(), backuppath);

            if (!Directory.Exists(filepath))
            {
                Directory.CreateDirectory(filepath);
            }

            string filename = string.Format(
                BACKUP_FILENAME,
                manifest.module.moduleID,
                manifest.module.version.ToStringWithDash()
                );

            AssetDatabase.ExportPackage(
                assetsPath.ToArray(),
                Path.Combine(filepath, filename),
                ExportPackageOptions.Recurse
                );

            EditorUtility.DisplayDialog(MSG_BACKUP_TITLE, MSG_BACKUP_INFO, "Ok");
        }
Ejemplo n.º 12
0
        // PAINT METHODS: -------------------------------------------------------------------------

        public static void PaintProjectModule(ModuleManifest manifest)
        {
            if (CURRENT_MODULE_ID != manifest.module.moduleID)
            {
                ModuleManagerContent.InitializeModule(manifest);
                CURRENT_MODULE_ID = manifest.module.moduleID;
            }

            bool        isEnabled         = ModuleManager.IsEnabled(manifest.module);
            bool        updateAvail       = ModuleManager.IsUpdateAvailable(manifest);
            bool        assetModuleExists = ModuleManager.AssetModuleExists(manifest.module);
            AssetModule assetModule       = ModuleManager.GetAssetModule(manifest.module.moduleID);

            ModuleManagerContent.PaintTitle(manifest.module);

            EditorGUILayout.BeginHorizontal(ModuleManagerContent.GetPanelStyle());
            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Backup", ModuleManagerContent.GetLargeButtonStyle()))
            {
                ModuleManager.Backup(manifest);
            }

            EditorGUILayout.Space();
            EditorGUI.BeginDisabledGroup(!isEnabled || !updateAvail);
            if (GUILayout.Button("Update", ModuleManagerContent.GetLargeButtonLeft()))
            {
                ModuleManager.Update(manifest);
            }
            EditorGUI.EndDisabledGroup();

            if (!isEnabled && GUILayout.Button("Enable", ModuleManagerContent.GetLargeButtonMid()))
            {
                ModuleManager.Enable(manifest);
            }

            if (isEnabled && GUILayout.Button("Disable", ModuleManagerContent.GetLargeButtonMid()))
            {
                ModuleManager.Disable(manifest);
            }

            EditorGUI.BeginDisabledGroup(!assetModuleExists || isEnabled);
            if (GUILayout.Button("Remove", ModuleManagerContent.GetLargeButtonRight()))
            {
                ModuleManager.Remove(manifest);
            }
            EditorGUI.EndDisabledGroup();

            GUILayout.FlexibleSpace();
            EditorGUILayout.EndHorizontal();

            ModuleManagerContent.PaintModule(manifest.module);

            EditorGUILayout.Space();
            ModuleManagerContent.PaintDependencies(
                "Dependencies ({0})",
                manifest.module.dependencies
                );

            if (updateAvail && assetModule != null)
            {
                EditorGUILayout.Space();
                ModuleManagerContent.PaintDependencies(
                    "Update Dependencies ({0})",
                    assetModule.module.dependencies
                    );
            }
        }
Ejemplo n.º 13
0
        // PRIVATE METHODS: -----------------------------------------------------------------------

        private static void InitializeModule(ModuleManifest manifest)
        {
            ANIMBOOL_UPDATE       = new AnimBool(false, ModuleManagerContent.RepaintModuleManager);
            ANIMBOOL_UPDATE.speed = 3.0f;
        }