[Add] VFavorites2

Assets/vFavorites.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d454140e53231466b8d485f9ff487b2e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/vFavorites/Manual.pdf.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 842468ccf23564770b4b1cb9f7eca30e
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 263643
+  packageName: vFavorites 2
+  packageVersion: 2.0.14
+  assetPath: Assets/vFavorites/Manual.pdf
+  uploadId: 874224

Assets/vFavorites/VFavorites.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "VFavorites",
+    "rootNamespace": "",
+    "references": [],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Assets/vFavorites/VFavorites.asmdef.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: d8266c7db84a045d3b706b23e60aa197
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 263643
+  packageName: vFavorites 2
+  packageVersion: 2.0.14
+  assetPath: Assets/vFavorites/VFavorites.asmdef
+  uploadId: 874224

Assets/vFavorites/VFavorites.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 6651039474d594cdd91489768cf293f6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 263643
+  packageName: vFavorites 2
+  packageVersion: 2.0.14
+  assetPath: Assets/vFavorites/VFavorites.cs
+  uploadId: 874224

Assets/vFavorites/VFavoritesData.cs

@@ -0,0 +1,225 @@
+#if UNITY_EDITOR
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Serialization;
+using UnityEditor;
+using UnityEditor.ShortcutManagement;
+using System.Reflection;
+using System.Linq;
+using UnityEngine.UIElements;
+using UnityEngine.SceneManagement;
+using UnityEditor.SceneManagement;
+using Type = System.Type;
+using static VFavorites.VFavoritesState;
+using static VFavorites.Libs.VUtils;
+using static VFavorites.Libs.VGUI;
+
+
+
+namespace VFavorites
+{
+    public class VFavoritesData : ScriptableObject
+    {
+        public List<Page> pages = new List<Page>();
+
+        public Page curPage
+        {
+            get
+            {
+                while (curPageIndex >= pages.Count - 1)
+                    pages.Add(new Page("Page " + (pages.Count + 1)));
+
+                return pages[curPageIndex];
+
+            }
+        }
+
+        public int curPageIndex { get => VFavoritesState.instance.curPageIndex; set => VFavoritesState.instance.curPageIndex = value; }
+
+        public float rowScale = 1;
+
+
+        [System.Serializable]
+        public class Page
+        {
+            public List<Item> items = new List<Item>();
+
+            public string name = "";
+
+            public Page(string name) => this.name = name;
+
+
+
+
+            [System.NonSerialized]
+            public List<float> _rowGaps = new List<float>();
+            public List<float> rowGaps
+            {
+                get
+                {
+                    if (_rowGaps == null)
+                        _rowGaps = new List<float>();
+
+                    while (_rowGaps.Count < items.Count + 1) _rowGaps.Add(0);
+                    while (_rowGaps.Count > items.Count + 1) _rowGaps.RemoveLast();
+
+                    return _rowGaps;
+
+                }
+            }
+
+
+            public float scrollPos { get => state.scrollPos; set => state.scrollPos = value; }
+
+            public long lastItemSelectTime_ticks { get => state.lastItemSelectTime_ticks; set => state.lastItemSelectTime_ticks = value; }
+            public long lastItemDragTime_ticks { get => state.lastItemDragTime_ticks; set => state.lastItemDragTime_ticks = value; }
+
+
+            public PageState state
+            {
+                get
+                {
+                    if (!VFavoritesState.instance.pageStates_byPageId.ContainsKey(id))
+                        VFavoritesState.instance.pageStates_byPageId[id] = new PageState();
+
+                    return VFavoritesState.instance.pageStates_byPageId[id];
+
+                }
+            }
+
+            public int id
+            {
+                get
+                {
+                    if (_id == 0)
+                        _id = Random.value.GetHashCode();
+
+                    return _id;
+
+                }
+            }
+            public int _id = 0;
+
+        }
+
+        [System.Serializable]
+        public class Item
+        {
+            public GlobalID globalId;
+
+
+            public Type type => Type.GetType(_typeString) ?? typeof(DefaultAsset);
+            public string _typeString;
+
+            public Object obj => _obj != null ? _obj : (_obj = globalId.GetObject());
+            public Object _obj;
+
+
+            public bool isSceneGameObject;
+            public bool isFolder;
+            public bool isAsset;
+
+
+            public bool isLoadable => obj != null;
+
+            public bool isDeleted
+            {
+                get
+                {
+                    if (!isSceneGameObject)
+                        return !isLoadable;
+
+                    if (isLoadable)
+                        return false;
+
+                    if (!AssetDatabase.LoadAssetAtPath<SceneAsset>(globalId.guid.ToPath()))
+                        return true;
+
+                    for (int i = 0; i < EditorSceneManager.sceneCount; i++)
+                        if (EditorSceneManager.GetSceneAt(i).path == globalId.guid.ToPath())
+                            return true;
+
+                    return false;
+
+                }
+            }
+
+            public string assetPath => globalId.guid.ToPath();
+
+
+            public Item(Object o)
+            {
+                globalId = o.GetGlobalID();
+
+
+                isSceneGameObject = o is GameObject go && go.scene.rootCount != 0;
+                isFolder = AssetDatabase.IsValidFolder(o.GetPath());
+                isAsset = !isSceneGameObject && !isFolder;
+
+                _typeString = o.GetType().AssemblyQualifiedName;
+
+                _name = o.name;
+
+            }
+
+
+
+
+
+            public string name
+            {
+                get
+                {
+                    if (!isLoadable) return _name;
+
+                    if (assetPath.GetExtension() == ".cs")
+                        _name = obj.name.Decamelcase();
+                    else
+                        _name = obj.name;
+
+                    return _name;
+
+                }
+            }
+            public string _name { get => state._name; set => state._name = value; }
+
+            public string sceneGameObjectIconName { get => state.sceneGameObjectIconName; set => state.sceneGameObjectIconName = value; }
+
+            public long lastSelectTime_ticks { get => state.lastSelectTime_ticks; set => state.lastSelectTime_ticks = value; }
+            public bool isSelected { get => state.isSelected; set => state.isSelected = value; }
+
+
+
+            public ItemState state
+            {
+                get
+                {
+                    if (!VFavoritesState.instance.itemStates_byItemId.ContainsKey(id))
+                        VFavoritesState.instance.itemStates_byItemId[id] = new ItemState();
+
+                    return VFavoritesState.instance.itemStates_byItemId[id];
+
+                }
+            }
+
+            public int id
+            {
+                get
+                {
+                    if (_id == 0)
+                        _id = Random.value.GetHashCode();
+
+                    return _id;
+
+                }
+            }
+            public int _id = 0;
+
+
+        }
+
+
+    }
+}
+#endif

Assets/vFavorites/VFavoritesData.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 066cf82f8f80d408c856e48fc8f1127b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 263643
+  packageName: vFavorites 2
+  packageVersion: 2.0.14
+  assetPath: Assets/vFavorites/VFavoritesData.cs
+  uploadId: 874224

Assets/vFavorites/VFavoritesLibs.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 38092f82a4c054086826261d88277942
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 263643
+  packageName: vFavorites 2
+  packageVersion: 2.0.14
+  assetPath: Assets/vFavorites/VFavoritesLibs.cs
+  uploadId: 874224

Assets/vFavorites/VFavoritesMenu.cs

@@ -0,0 +1,140 @@
+#if UNITY_EDITOR
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEditor;
+using static VFavorites.Libs.VUtils;
+using static VFavorites.Libs.VGUI;
+
+
+
+namespace VFavorites
+{
+    public class VFavoritesMenu
+    {
+
+        public static bool pageScrollEnabled { get => EditorPrefsCached.GetBool("vFavorites-pageScrollEnabled", true); set => EditorPrefsCached.SetBool("vFavorites-pageScrollEnabled", value); }
+        public static bool numberKeysEnabled { get => EditorPrefsCached.GetBool("vFavorites-numberKeysEnabled", true); set => EditorPrefsCached.SetBool("vFavorites-numberKeysEnabled", value); }
+        public static bool arrowKeysEnabled { get => EditorPrefsCached.GetBool("vFavorites-arrowKeysEnabled", true); set => EditorPrefsCached.SetBool("vFavorites-arrowKeysEnabled", value); }
+
+        public static bool fadeAnimationsEnabled { get => EditorPrefsCached.GetBool("vFavorites-fadeAnimationsEnabled", true); set => EditorPrefsCached.SetBool("vFavorites-fadeAnimationsEnabled", value); }
+        public static bool pageScrollAnimationEnabled { get => EditorPrefsCached.GetBool("vFavorites-pageScrollAnimationEnabled", true); set => EditorPrefsCached.SetBool("vFavorites-pageScrollAnimationEnabled", value); }
+
+        public static int activeOnKeyCombination { get => EditorPrefsCached.GetInt("vFavorites-activeOnKeyCombination", 0); set => EditorPrefsCached.SetInt("vFavorites-activeOnKeyCombination", value); }
+        public static bool activeOnAltEnabled { get => activeOnKeyCombination == 0; set => activeOnKeyCombination = 0; }
+        public static bool activeOnAltShiftEnabled { get => activeOnKeyCombination == 1; set => activeOnKeyCombination = 1; }
+        public static bool activeOnCtrlAltEnabled { get => activeOnKeyCombination == 2; set => activeOnKeyCombination = 2; }
+
+        public static bool pluginDisabled { get => EditorPrefsCached.GetBool("vFavorites-pluginDisabled", false); set => EditorPrefsCached.SetBool("vFavorites-pluginDisabled", value); }
+
+
+
+
+        const string dir = "Tools/vFavorites/";
+
+        const string pageScroll = dir + "Scroll to change page";
+        const string numberKeys = dir + "1-9 keys to change page";
+        const string arrowKeys = dir + "Arrow keys to change page or selection ";
+
+        const string fadeAnimations = dir + "Fade animations";
+        const string pageScrollAnimation = dir + "Page scroll animation";
+
+        const string activeOnAlt = dir + "Holding Alt";
+        const string activeOnAltShift = dir + "Holding Alt and Shift";
+#if UNITY_EDITOR_OSX
+        const string activeOnCtrlAlt = dir + "Holding Cmd and Alt";
+#else
+        const string activeOnCtrlAlt = dir + "Holding Ctrl and Alt";
+
+#endif
+
+        const string disablePlugin = dir + "Disable vFavorites";
+
+
+
+
+
+
+        [MenuItem(dir + "Shortcuts", false, 1)] static void dadsas() { }
+        [MenuItem(dir + "Shortcuts", true, 1)] static bool dadsas123() => false;
+
+        [MenuItem(pageScroll, false, 2)] static void dadsadasadsdadsas() => pageScrollEnabled = !pageScrollEnabled;
+        [MenuItem(pageScroll, true, 2)] static bool dadsadasdadsdasadsas() { Menu.SetChecked(pageScroll, pageScrollEnabled); return !pluginDisabled; }
+
+        [MenuItem(numberKeys, false, 4)] static void dadsadadsas() => numberKeysEnabled = !numberKeysEnabled;
+        [MenuItem(numberKeys, true, 4)] static bool dadsaddasadsas() { Menu.SetChecked(numberKeys, numberKeysEnabled); return !pluginDisabled; }
+
+        [MenuItem(arrowKeys, false, 5)] static void dadsadaddassas() => arrowKeysEnabled = !arrowKeysEnabled;
+        [MenuItem(arrowKeys, true, 5)] static bool dadadssaddasadsas() { Menu.SetChecked(arrowKeys, arrowKeysEnabled); return !pluginDisabled; }
+
+
+
+
+
+        [MenuItem(dir + "Animations", false, 101)] static void dadsadsas() { }
+        [MenuItem(dir + "Animations", true, 101)] static bool dadadssas123() => false;
+
+        [MenuItem(fadeAnimations, false, 102)] static void dadsdasadadsas() => fadeAnimationsEnabled = !fadeAnimationsEnabled;
+        [MenuItem(fadeAnimations, true, 102)] static bool dadsadadsadsdasadsas() { Menu.SetChecked(fadeAnimations, fadeAnimationsEnabled); return !pluginDisabled; }
+
+        [MenuItem(pageScrollAnimation, false, 103)] static void dadsdasdasadadsas() => pageScrollAnimationEnabled = !pageScrollAnimationEnabled;
+        [MenuItem(pageScrollAnimation, true, 103)] static bool dadsadaddassadsdasadsas() { Menu.SetChecked(pageScrollAnimation, pageScrollAnimationEnabled); return !pluginDisabled; }
+
+
+
+
+        [MenuItem(dir + "Open when", false, 1001)] static void dadsaddssas() { }
+        [MenuItem(dir + "Open when", true, 1001)] static bool dadadsssas123() => false;
+
+        [MenuItem(activeOnAlt, false, 1002)] static void dadsdasasdadsas() => activeOnAltEnabled = !activeOnAltEnabled;
+        [MenuItem(activeOnAlt, true, 1002)] static bool dadsadadssdadsdasadsas() { Menu.SetChecked(activeOnAlt, activeOnAltEnabled); return !pluginDisabled; }
+
+        [MenuItem(activeOnAltShift, false, 1003)] static void dadsdasasdadsadsas() => activeOnAltShiftEnabled = !activeOnAltShiftEnabled;
+        [MenuItem(activeOnAltShift, true, 1003)] static bool dadsadadssdasdadsdasadsas() { Menu.SetChecked(activeOnAltShift, activeOnAltShiftEnabled); return !pluginDisabled; }
+
+        [MenuItem(activeOnCtrlAlt, false, 1004)] static void dadsdasadasadssdadsas() => activeOnCtrlAltEnabled = !activeOnCtrlAltEnabled;
+        [MenuItem(activeOnCtrlAlt, true, 1004)] static bool dadsadadsadssdadsdasadsas() { Menu.SetChecked(activeOnCtrlAlt, activeOnCtrlAltEnabled); return !pluginDisabled; }
+
+
+
+
+
+        [MenuItem(dir + "More", false, 10001)] static void daasadsddsas() { }
+        [MenuItem(dir + "More", true, 10001)] static bool dadsadsdasas123() => false;
+
+        // [MenuItem(dir + "Open manual", false, 10002)]
+        // static void dadadssadsas() => AssetDatabase.OpenAsset(AssetDatabase.LoadAssetAtPath<Object>(GetScriptPath("VFavorites").GetParentPath().CombinePath("Manual.pdf")));
+
+        [MenuItem(dir + "Join our Discord", false, 10002)]
+        static void dadasdsas() => Application.OpenURL("https://discord.gg/pUektnZeJT");
+
+
+
+
+
+        [MenuItem(dir + "Deals ending soon/Get vHierarchy 2 at 60% off", false, 10003)]
+        static void dadadssadasdsas() => Application.OpenURL("https://assetstore.unity.com/packages/slug/253397?aid=1100lGLBn&pubref=deal60menuvfav");
+
+        [MenuItem(dir + "Deals ending soon/Get vFolders 2 at 60% off", false, 10004)]
+        static void dadadssasddsas() => Application.OpenURL("https://assetstore.unity.com/packages/slug/255470?aid=1100lGLBn&pubref=deal60menuvfav");
+
+        [MenuItem(dir + "Deals ending soon/Get vInspector 2 at 60% off", false, 10005)]
+        static void dadadadsssadsas() => Application.OpenURL("https://assetstore.unity.com/packages/slug/252297?aid=1100lGLBn&pubref=deal60menuvfav");
+
+        [MenuItem(dir + "Deals ending soon/Get vTabs 2 at 60% off", false, 10006)]
+        static void dadadadsssadsadsas() => Application.OpenURL("https://assetstore.unity.com/packages/slug/253396?aid=1100lGLBn&pubref=deal60menuvfav");
+
+
+
+
+
+
+
+
+        [MenuItem(disablePlugin, false, 100001)] static void dadsadsdasadasdasdsadadsas() { pluginDisabled = !pluginDisabled; UnityEditor.Compilation.CompilationPipeline.RequestScriptCompilation(); }
+        [MenuItem(disablePlugin, true, 100001)] static bool dadsaddssdaasadsadadsdasadsas() { Menu.SetChecked(disablePlugin, pluginDisabled); return true; }
+
+    }
+}
+#endif

Assets/vFavorites/VFavoritesMenu.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 65f8f6586ea4740238f667f8337cf6fb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 263643
+  packageName: vFavorites 2
+  packageVersion: 2.0.14
+  assetPath: Assets/vFavorites/VFavoritesMenu.cs
+  uploadId: 874224

Assets/vFavorites/VFavoritesMenuItems.cs

@@ -0,0 +1,6 @@
+
+
+// this file was present in a previus version and is supposed to be deleted now
+// but asset store update delivery system doesn't allow deleting files
+// so instead this file is now emptied
+// feel free to delete it if you want 

Assets/vFavorites/VFavoritesMenuItems.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: e1b1b30cd63e14da9a295742be768842
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 263643
+  packageName: vFavorites 2
+  packageVersion: 2.0.14
+  assetPath: Assets/vFavorites/VFavoritesMenuItems.cs
+  uploadId: 874224

Assets/vFavorites/VFavoritesState.cs

@@ -0,0 +1,57 @@
+#if UNITY_EDITOR
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Serialization;
+using UnityEditor;
+using UnityEditor.ShortcutManagement;
+using System.Reflection;
+using System.Linq;
+using UnityEngine.UIElements;
+using UnityEngine.SceneManagement;
+using UnityEditor.SceneManagement;
+using Type = System.Type;
+using static VFavorites.Libs.VUtils;
+using static VFavorites.Libs.VGUI;
+
+
+namespace VFavorites
+{
+    [FilePath("Library/vFavorites State.asset", FilePathAttribute.Location.ProjectFolder)]
+    public class VFavoritesState : ScriptableSingleton<VFavoritesState>
+    {
+        public int curPageIndex;
+
+        public SerializableDictionary<int, PageState> pageStates_byPageId = new SerializableDictionary<int, PageState>();
+
+        public SerializableDictionary<int, ItemState> itemStates_byItemId = new SerializableDictionary<int, ItemState>();
+
+
+        [System.Serializable]
+        public class PageState
+        {
+            public long lastItemSelectTime_ticks;
+            public long lastItemDragTime_ticks;
+
+            public float scrollPos;
+
+        }
+
+        [System.Serializable]
+        public class ItemState
+        {
+            public string _name;
+
+            public string sceneGameObjectIconName;
+
+            public long lastSelectTime_ticks;
+            public bool isSelected;
+
+        }
+
+
+        public static void Save() => instance.Save(true);
+
+    }
+}
+#endif

Assets/vFavorites/VFavoritesState.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 362e220c378db4e97ae41fa35a6fb58f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 263643
+  packageName: vFavorites 2
+  packageVersion: 2.0.14
+  assetPath: Assets/vFavorites/VFavoritesState.cs
+  uploadId: 874224