module-navigation-tool/Editor/Toolbar/Tools/ToolScenePicker.cs

using System.Collections.Generic;
using System.IO;
using JetBrains.Annotations;
using UnityEditor;
using UnityEditor.AddressableAssets;
using UnityEditor.AddressableAssets.Settings;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace Module.NavigationTool.Editor.Tools
{
    [UsedImplicitly]
    internal sealed class ToolScenePicker : AbstractToolbarDrawer
    {
        public override bool Enabled => !EditorApplication.isPlaying && !EditorApplication.isPlayingOrWillChangePlaymode;
        public override EToolbarPlacement Placement => EToolbarPlacement.Right;

        private static bool IS_DIRTY = true;
        private static int SELECTED_INDEX = -1;
        private static string[] OPTIONS = new string[0];
        private static string[] PATHS = new string[0];
        
        private static void Initialize()
        {
            if (!IS_DIRTY)
                return;

            EditorBuildSettingsScene[] scenes = EditorBuildSettings.scenes;
            var listNames = new List<string>();
            var listPaths = new List<string>();
            
            InitializeBuildSettingsScenes(listNames, listPaths);
            InitializeAssetBundleScenes(listNames, listPaths);
            InitializeAddressableScenes(listNames, listPaths);
            InitializeRemainingScenes(listNames, listPaths);

            OPTIONS = listNames.ToArray();
            PATHS = listPaths.ToArray();

            Scene activeScene = SceneManager.GetActiveScene();
            SELECTED_INDEX = listPaths.IndexOf(activeScene.path);
            IS_DIRTY = false;
        }

        private static void InitializeBuildSettingsScenes(List<string> listNames, List<string> listPaths)
        {
            EditorBuildSettingsScene[] scenes = EditorBuildSettings.scenes;

            for (var i = 0; i < scenes.Length; i++)
            {
                if (string.IsNullOrEmpty(scenes[i].path))
                    continue;

                listNames.Add($"{Path.GetFileNameWithoutExtension(scenes[i].path)} \tBuild settings");
                listPaths.Add(scenes[i].path);
            }
        }

        private static void InitializeAssetBundleScenes(List<string> listNames, List<string> listPaths)
        {
            string[] bundleNames = AssetDatabase.GetAllAssetBundleNames();
            int startIndex = listNames.Count;

            for (var i = 0; i < bundleNames.Length; i++)
            {
                string[] assetPaths = AssetDatabase.GetAssetPathsFromAssetBundle(bundleNames[i]);

                for (var j = 0; j < assetPaths.Length; j++)
                {
                    string path = assetPaths[j];
                
                    if (listPaths.Contains(path))
                        continue;
                
                    var scene = AssetDatabase.LoadAssetAtPath<SceneAsset>(path);

                    if (scene == null)
                        continue;

                    listNames.Add($"{Path.GetFileNameWithoutExtension(path)} \tAsset bundle");
                    listPaths.Add(path);
                }
            }
            
            if (startIndex >= listNames.Count)
                return;
            
            listNames.Insert(startIndex, string.Empty);
            listPaths.Insert(startIndex, string.Empty);
        }
        
        private static void InitializeAddressableScenes(List<string> listNames, List<string> listPaths)
        {
            var assets = new List<AddressableAssetEntry>();
            AddressableAssetSettingsDefaultObject.Settings.GetAllAssets(assets, false);
            int startIndex = listNames.Count;

            for (var i = 0; i < assets.Count; i++)
            {
                if (!(assets[i].MainAsset is SceneAsset))
                    continue;

                string path = assets[i].AssetPath;
                listNames.Add($"{Path.GetFileNameWithoutExtension(path)} \tAddressable");
                listPaths.Add(path);
            }
            
            if (startIndex >= listNames.Count)
                return;
            
            listNames.Insert(startIndex, string.Empty);
            listPaths.Insert(startIndex, string.Empty);
        }

        private static void InitializeRemainingScenes(List<string> listNames, List<string> listPaths)
        {
            string[] guids = AssetDatabase.FindAssets("t:scene");
            int startIndex = listNames.Count;

            for (var i = 0; i < guids.Length; i++)
            {
                string path = AssetDatabase.GUIDToAssetPath(guids[i]);
                
                if (listPaths.Contains(path))
                    continue;
                
                var scene = AssetDatabase.LoadAssetAtPath<SceneAsset>(path);

                if (scene == null)
                    continue;

                listNames.Add(path.Substring(7, path.Length - 13).Replace('/', '\\'));
                listPaths.Add(path);
            }

            if (startIndex >= listNames.Count)
                return;
            
            listNames.Insert(startIndex, string.Empty);
            listPaths.Insert(startIndex, string.Empty);
        }
        
        public override void Update()
        {
            Initialize();
        }

        protected override void Draw(Rect rect)
        {
            Initialize();
            int temp = EditorGUI.Popup(rect, SELECTED_INDEX, OPTIONS, styles.popup);
            
            if (temp > -1 && temp != SELECTED_INDEX && OPTIONS.Length != 0)
            {
                string path = PATHS[temp];

                if (string.IsNullOrEmpty(path))
                    return;
                
                SELECTED_INDEX = temp;
                EditorSceneManager.OpenScene(PATHS[SELECTED_INDEX], OpenSceneMode.Single);
            }
        }
        
        public override float CalculateWidth()
        {
            return 100.0f;
        }

        public static void SetAsDirty()
        {
            IS_DIRTY = true;
        }
    }
}