Sujith :) ->

1. Made unified settings for Project Data Export

Assets/AssetBank/Assets.meta

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

Assets/AssetBank/Assets/ProjectExporterSettings.asset

@@ -0,0 +1,21 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: e9378e9b5e63d41a4873d9f290c74043, type: 3}
+  m_Name: ProjectExporterSettings
+  m_EditorClassIdentifier: 
+  m_FoldersToIgnore:
+  - Assets/AssetBank
+  - Assets/IntelligentProjectAnalyzer
+  - Assets/LLM
+  - Assets/Packages
+  m_FileExtensionsToIgnore: []
+  m_UnityTypesToIgnore: []

Assets/AssetBank/Assets/ProjectExporterSettings.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b0cc6e54588154602840be3c5c3c100e
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AssetBank/Editor/ProjectExporter/Editor.meta

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

Assets/AssetBank/Editor/ProjectExporter/Editor/IgnoredUnityTypeDrawer.cs

@@ -0,0 +1,33 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace AssetBank.Editor.ProjectExporter.Editor
+{
+    [CustomPropertyDrawer(typeof(IgnoredUnityType))]
+    public class IgnoredUnityTypeDrawer : PropertyDrawer
+    {
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            EditorGUI.BeginProperty(position, label, property);
+
+            position = EditorGUI.PrefixLabel(position, GUIUtility.GetControlID(FocusType.Passive), label);
+
+            var indent = EditorGUI.indentLevel;
+            EditorGUI.indentLevel = 0;
+
+            var assetTypeRect = new Rect(position.x, position.y, position.width * 0.5f, position.height);
+            var customTypeRect = new Rect(position.x + position.width * 0.5f + 5, position.y, position.width * 0.5f - 5, position.height);
+
+            var assetTypeProp = property.FindPropertyRelative("assetType");
+            EditorGUI.PropertyField(assetTypeRect, assetTypeProp, GUIContent.none);
+
+            if ((UnityAssetType)assetTypeProp.enumValueIndex == UnityAssetType.Custom)
+            {
+                EditorGUI.PropertyField(customTypeRect, property.FindPropertyRelative("customType"), GUIContent.none);
+            }
+
+            EditorGUI.indentLevel = indent;
+            EditorGUI.EndProperty();
+        }
+    }
+}

Assets/AssetBank/Editor/ProjectExporter/Editor/IgnoredUnityTypeDrawer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 16b3c8fcc15b2488aa9cd19cbeb448f1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AssetBank/Editor/ProjectExporter/Editor/ProjectExporterSettingsProvider.cs

@@ -0,0 +1,63 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace AssetBank.Editor.ProjectExporter.Editor
+{
+    class ProjectExporterSettingsProvider : SettingsProvider
+    {
+        private SerializedObject m_Settings;
+        private SerializedProperty m_FoldersToIgnore;
+        private SerializedProperty m_FileExtensionsToIgnore;
+        private SerializedProperty m_UnityTypesToIgnore;
+
+        const string k_SettingsPath = "Project/Project AssetDatabase";
+
+        public ProjectExporterSettingsProvider(string path, SettingsScope scope = SettingsScope.Project)
+            : base(path, scope) {}
+
+        public override void OnActivate(string searchContext, UnityEngine.UIElements.VisualElement rootElement)
+        {
+            m_Settings = ProjectExporterSettings.GetSerializedSettings();
+            m_FoldersToIgnore = m_Settings.FindProperty("m_FoldersToIgnore");
+            m_FileExtensionsToIgnore = m_Settings.FindProperty("m_FileExtensionsToIgnore");
+            m_UnityTypesToIgnore = m_Settings.FindProperty("m_UnityTypesToIgnore");
+        }
+
+        public override void OnGUI(string searchContext)
+        {
+            if (m_Settings == null || m_Settings.targetObject == null)
+            {
+                EditorGUILayout.HelpBox("Settings asset not found. It will be created automatically.", MessageType.Info);
+                m_Settings = ProjectExporterSettings.GetSerializedSettings();
+                return;
+            }
+            
+            m_Settings.Update();
+
+            EditorGUILayout.PropertyField(m_FoldersToIgnore, new GUIContent("Folders to Ignore"), true);
+            EditorGUILayout.PropertyField(m_FileExtensionsToIgnore, new GUIContent("File Extensions to Ignore"), true);
+            EditorGUILayout.PropertyField(m_UnityTypesToIgnore, new GUIContent("Unity Types to Ignore"), true);
+
+            if (m_Settings.hasModifiedProperties)
+            {
+                m_Settings.ApplyModifiedProperties();
+            }
+        }
+
+        [SettingsProvider]
+        public static SettingsProvider CreateSettingsProvider()
+        {
+            var provider = new ProjectExporterSettingsProvider(k_SettingsPath, SettingsScope.Project);
+            provider.keywords = GetSearchKeywordsFromGUIContentProperties<Styles>();
+            return provider;
+        }
+
+        private class Styles
+        {
+            public static GUIContent foldersToIgnore = new GUIContent("Folders to Ignore");
+            public static GUIContent fileExtensionsToIgnore = new GUIContent("File Extensions to Ignore");
+            public static GUIContent unityTypesToIgnore = new GUIContent("Unity Types to Ignore");
+        }
+    }
+}

Assets/AssetBank/Editor/ProjectExporter/Editor/ProjectExporterSettingsProvider.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 63778c98085740f684f2b6437d79b40a
+timeCreated: 1753082814

Assets/AssetBank/Editor/ProjectExporter/ProjectExporterController.cs

@@ -4,12 +4,23 @@ using System.IO;
 using System.Linq;
 using UnityEditor;
 using UnityEngine;
+using AssetBank.Editor.ProjectExporter;
+using System;
+using UnityEditor.Animations;
+using UnityEngine.Audio;
+using UnityEngine.Video;
 
 namespace ProjectExporter
 {
     public class ProjectExporterController
     {
         private static readonly string ProjectRoot = Path.GetDirectoryName(Application.dataPath);
+        private readonly ProjectExporterSettings _settings;
+
+        public ProjectExporterController()
+        {
+            _settings = ProjectExporterSettings.GetOrCreateSettings();
+        }
 
         // Finds assets based on a search filter (e.g., "t:Scene") and builds a hierarchical model.
         public AssetModel GetAssets(string filter)
@@ -129,21 +140,23 @@ namespace ProjectExporter
             var assetsToExport = new List<string>();
             CollectSelectedAssets(rootNode, assetsToExport);
             
+            var filteredAssets = FilterAssets(assetsToExport);
+            
             var pythonExecutable = FindPythonExecutable();
             var conversionScript = GetConversionScriptPath();
             if (string.IsNullOrEmpty(conversionScript)) return;
 
-            var outputDirectory = Path.Combine(ProjectRoot, "Library", exportType);
+            var outputDirectory = Path.Combine(ProjectRoot, "Library", "ProjectDataExport");
             Directory.CreateDirectory(outputDirectory);
 
             EditorUtility.DisplayProgressBar("Exporting...", "Starting export process...", 0f);
 
             try
             {
-                for (int i = 0; i < assetsToExport.Count; i++)
+                for (int i = 0; i < filteredAssets.Count; i++)
                 {
-                    var relativeAssetPath = assetsToExport[i];
-                    var progress = (float)i / assetsToExport.Count;
+                    var relativeAssetPath = filteredAssets[i];
+                    var progress = (float)i / filteredAssets.Count;
                     EditorUtility.DisplayProgressBar("Exporting...", $"Processing {Path.GetFileName(relativeAssetPath)}", progress);
 
                     var absoluteAssetPath = Path.Combine(ProjectRoot, relativeAssetPath);
@@ -189,6 +202,94 @@ namespace ProjectExporter
             }
         }
 
+        private List<string> FilterAssets(List<string> assetPaths)
+        {
+            if (_settings == null)
+            {
+                UnityEngine.Debug.LogWarning("ProjectExporterSettings not found. Skipping filtering.");
+                return assetPaths;
+            }
+
+            var ignoredFolders = _settings.FoldersToIgnore;
+            var ignoredExtensions = _settings.FileExtensionsToIgnore.Select(ext => ext.StartsWith(".") ? ext : "." + ext).ToList();
+            var ignoredUnityTypes = _settings.UnityTypesToIgnore;
+
+            var filteredList = new List<string>();
+
+            foreach (var path in assetPaths)
+            {
+                if (ignoredFolders.Any(folder => path.StartsWith(folder, StringComparison.OrdinalIgnoreCase)))
+                {
+                    continue;
+                }
+
+                var extension = Path.GetExtension(path);
+                if (ignoredExtensions.Contains(extension, StringComparer.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                var assetPathForTypeCheck = path.EndsWith(".meta") ? path[..^5] : path;
+                var assetType = AssetDatabase.GetMainAssetTypeAtPath(assetPathForTypeCheck);
+                if (assetType != null && IsTypeIgnored(assetType, ignoredUnityTypes))
+                {
+                    continue;
+                }
+
+                filteredList.Add(path);
+            }
+
+            return filteredList;
+        }
+
+        private bool IsTypeIgnored(Type assetType, List<IgnoredUnityType> ignoredTypes)
+        {
+            foreach (var ignoredType in ignoredTypes)
+            {
+                if (ignoredType.assetType == UnityAssetType.Custom)
+                {
+                    if (!string.IsNullOrEmpty(ignoredType.customType) && assetType.Name.Equals(ignoredType.customType, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return true;
+                    }
+                }
+                else if (GetSystemTypeForEnum(ignoredType.assetType) == assetType)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private Type GetSystemTypeForEnum(UnityAssetType unityAssetType)
+        {
+            switch (unityAssetType)
+            {
+                case UnityAssetType.Animation: return typeof(AnimationClip);
+                case UnityAssetType.AnimatorController: return typeof(AnimatorController);
+                case UnityAssetType.AnimatorOverrideController: return typeof(AnimatorOverrideController);
+                case UnityAssetType.AudioClip: return typeof(AudioClip);
+                case UnityAssetType.AudioMixer: return typeof(AudioMixer);
+                case UnityAssetType.ComputeShader: return typeof(ComputeShader);
+                case UnityAssetType.Font: return typeof(Font);
+                case UnityAssetType.GUISkin: return typeof(GUISkin);
+                case UnityAssetType.Material: return typeof(Material);
+                case UnityAssetType.Mesh: return typeof(Mesh);
+                case UnityAssetType.Model: return typeof(GameObject);
+                case UnityAssetType.PhysicMaterial: return typeof(PhysicMaterial);
+                case UnityAssetType.Prefab: return typeof(GameObject);
+                case UnityAssetType.Scene: return typeof(SceneAsset);
+                case UnityAssetType.Script: return typeof(MonoScript);
+                case UnityAssetType.Shader: return typeof(Shader);
+                case UnityAssetType.Sprite: return typeof(Sprite);
+                case UnityAssetType.Texture: return typeof(Texture2D);
+                case UnityAssetType.VideoClip: return typeof(VideoClip);
+                case UnityAssetType.RenderTexture: return typeof(RenderTexture);
+                case UnityAssetType.LightmapParameters: return typeof(LightmapParameters);
+                default: return null;
+            }
+        }
+
         // Recursively collects the paths of all selected assets.
         private void CollectSelectedAssets(AssetModel node, List<string> selectedPaths)
         {

Assets/AssetBank/Editor/ProjectExporter/ProjectExporterSettings.cs

@@ -0,0 +1,81 @@
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace AssetBank.Editor.ProjectExporter
+{
+    public enum UnityAssetType
+    {
+        Animation,
+        AnimatorController,
+        AnimatorOverrideController,
+        AudioClip,
+        AudioMixer,
+        ComputeShader,
+        Font,
+        GUISkin,
+        Material,
+        Mesh,
+        Model,
+        PhysicMaterial,
+        Prefab,
+        Scene,
+        Script,
+        Shader,
+        Sprite,
+        Texture,
+        VideoClip,
+        TimelineAsset,
+        RenderTexture,
+        LightmapParameters,
+        Custom
+    }
+
+    [System.Serializable]
+    public class IgnoredUnityType
+    {
+        public UnityAssetType assetType = UnityAssetType.Texture;
+        public string customType = "";
+    }
+
+    public class ProjectExporterSettings : ScriptableObject
+    {
+        private const string k_SettingsPath = "Assets/AssetBank/Assets/ProjectExporterSettings.asset";
+
+        [SerializeField]
+        private List<string> m_FoldersToIgnore = new List<string>();
+        public List<string> FoldersToIgnore => m_FoldersToIgnore;
+
+        [SerializeField]
+        private List<string> m_FileExtensionsToIgnore = new List<string>();
+        public List<string> FileExtensionsToIgnore => m_FileExtensionsToIgnore;
+
+        [SerializeField]
+        private List<IgnoredUnityType> m_UnityTypesToIgnore = new List<IgnoredUnityType>();
+        public List<IgnoredUnityType> UnityTypesToIgnore => m_UnityTypesToIgnore;
+
+
+        internal static ProjectExporterSettings GetOrCreateSettings()
+        {
+            var settings = AssetDatabase.LoadAssetAtPath<ProjectExporterSettings>(k_SettingsPath);
+            if (settings == null)
+            {
+                settings = CreateInstance<ProjectExporterSettings>();
+                var directory = Path.GetDirectoryName(k_SettingsPath);
+                if (!Directory.Exists(directory))
+                {
+                    Directory.CreateDirectory(directory);
+                }
+                AssetDatabase.CreateAsset(settings, k_SettingsPath);
+                AssetDatabase.SaveAssets();
+            }
+            return settings;
+        }
+
+        internal static SerializedObject GetSerializedSettings()
+        {
+            return new SerializedObject(GetOrCreateSettings());
+        }
+    }
+}

Assets/AssetBank/Editor/ProjectExporter/ProjectExporterSettings.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e9378e9b5e63d41a4873d9f290c74043
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AssetBank/Editor/ProjectExporter/ProjectExporterUI.cs

@@ -70,12 +70,27 @@ namespace ProjectExporter
             return toggle;
         }
 
+        // Overload for creating a Toggle with an initial value and a callback.
+        public static Toggle CreateToggle(string label, bool value, System.Action<ChangeEvent<bool>> callback)
+        {
+            var toggle = new Toggle(label)
+            {
+                value = value,
+                style =
+                {
+                    marginTop = 2
+                }
+            };
+            toggle.RegisterValueChangedCallback(evt => callback(evt));
+            return toggle;
+        }
+
         // Creates the "Generate" button.
-        public static Button CreateGenerateButton()
+        public static Button CreateGenerateButton(bool showGenerateAll = false)
         {
             var button = new Button
             {
-                text = "Generate",
+                text = showGenerateAll ? "Generate All" : "Generate",
                 style =
                 {
                     height = 30,

Assets/AssetBank/Editor/ProjectExporter/ProjectExporterWindow.cs

@@ -12,12 +12,20 @@ namespace ProjectExporter
         private VisualElement _rootElement;
         private VisualElement _contentContainer;
         private Dictionary<string, AssetModel> _assetTrees;
-        private string _currentTab = "Scenes";
+        private string _currentTab = "General"; // Default to General tab
+
+        // Checkbox states for the General tab
+        private bool _exportScenes = true;
+        private bool _exportPrefabs = true;
+        private bool _exportScriptableObjects = true;
+        private bool _exportMetaFiles = true;
+        private bool _exportSettings = true;
 
         [MenuItem("Tools/Project Exporter")]
         public static void ShowWindow()
         {
-            ProjectExporterWindow wnd = GetWindow<ProjectExporterWindow>(true, "Project Exporter");
+            var wnd = GetWindow<ProjectExporterWindow>();
+            wnd.titleContent = new GUIContent("Project Exporter", EditorGUIUtility.IconContent("d_Profiler.GlobalIllumination").image);
             wnd.minSize = new Vector2(400, 300);
         }
 
@@ -26,11 +34,8 @@ namespace ProjectExporter
             _controller = new ProjectExporterController();
             _assetTrees = new Dictionary<string, AssetModel>();
             _rootElement = rootVisualElement;
-
-            // Build the UI frame without loading asset data initially
-            BuildUI();
             
-            // Trigger the first content refresh
+            BuildUI();
             RefreshContent(_currentTab);
         }
 
@@ -39,6 +44,7 @@ namespace ProjectExporter
             _rootElement.Clear();
 
             var tabContainer = new VisualElement { style = { flexDirection = FlexDirection.Row } };
+            tabContainer.Add(ProjectExporterUI.CreateTab("General")); // New General tab
             tabContainer.Add(ProjectExporterUI.CreateTab("Scenes"));
             tabContainer.Add(ProjectExporterUI.CreateTab("Prefabs"));
             tabContainer.Add(ProjectExporterUI.CreateTab("Scriptable Objects"));
@@ -46,23 +52,34 @@ namespace ProjectExporter
             tabContainer.Add(ProjectExporterUI.CreateTab("Settings"));
             _rootElement.Add(tabContainer);
 
-            // Create a scrollable container for the main content
             var scrollView = new ScrollView(ScrollViewMode.Vertical);
             _rootElement.Add(scrollView);
 
             _contentContainer = ProjectExporterUI.CreateMainContainer();
             scrollView.Add(_contentContainer);
 
-            var generateButton = ProjectExporterUI.CreateGenerateButton();
+            var generateButton = ProjectExporterUI.CreateGenerateButton(_currentTab == "General");
             _rootElement.Add(generateButton);
-            generateButton.clicked += () => _controller.ExportAssets(_assetTrees[_currentTab], _currentTab);
+            
+            // The button's action will depend on the current tab
+            generateButton.clicked += () => {
+                if (_currentTab == "General")
+                {
+                    PerformBulkExport();
+                }
+                else if (_assetTrees.ContainsKey(_currentTab))
+                {
+                    _controller.ExportAssets(_assetTrees[_currentTab], _currentTab);
+                }
+            };
 
             var tabs = tabContainer.Query<Button>().ToList();
-            tabs[0].clicked += () => RefreshContent("Scenes");
-            tabs[1].clicked += () => RefreshContent("Prefabs");
-            tabs[2].clicked += () => RefreshContent("Scriptable Objects");
-            tabs[3].clicked += () => RefreshContent("Meta Files");
-            tabs[4].clicked += () => RefreshContent("Settings");
+            tabs[0].clicked += () => RefreshContent("General");
+            tabs[1].clicked += () => RefreshContent("Scenes");
+            tabs[2].clicked += () => RefreshContent("Prefabs");
+            tabs[3].clicked += () => RefreshContent("Scriptable Objects");
+            tabs[4].clicked += () => RefreshContent("Meta Files");
+            tabs[5].clicked += () => RefreshContent("Settings");
         }
 
         private void RefreshContent(string tabName)
@@ -70,35 +87,15 @@ namespace ProjectExporter
             _currentTab = tabName;
             _contentContainer.Clear();
 
-            // Load data on demand if it hasn't been loaded yet
+            if (tabName == "General")
+            {
+                DrawGeneralTab();
+                return;
+            }
+
             if (!_assetTrees.ContainsKey(tabName))
             {
-                EditorUtility.DisplayProgressBar("Loading...", $"Fetching {tabName}...", 0.5f);
-                try
-                {
-                    switch (tabName)
-                    {
-                        case "Scenes":
-                            _assetTrees[tabName] = _controller.GetAssets("t:Scene");
-                            break;
-                        case "Prefabs":
-                            _assetTrees[tabName] = _controller.GetAssets("t:Prefab");
-                            break;
-                        case "Scriptable Objects":
-                            _assetTrees[tabName] = _controller.GetAssets("t:ScriptableObject");
-                            break;
-                        case "Meta Files":
-                            _assetTrees[tabName] = _controller.GetAllMetaFiles();
-                            break;
-                        case "Settings":
-                            _assetTrees[tabName] = _controller.GetProjectSettingsFiles();
-                            break;
-                    }
-                }
-                finally
-                {
-                    EditorUtility.ClearProgressBar();
-                }
+                LoadAssetTree(tabName);
             }
 
             var rootModel = _assetTrees[tabName];
@@ -111,6 +108,80 @@ namespace ProjectExporter
             }
         }
 
+        private void DrawGeneralTab()
+        {
+            var title = new Label("Select Export Types") { style = { unityFontStyleAndWeight = FontStyle.Bold } };
+            _contentContainer.Add(title);
+
+            var scenesToggle = ProjectExporterUI.CreateToggle("Export Scenes", _exportScenes, evt => _exportScenes = evt.newValue);
+            var prefabsToggle = ProjectExporterUI.CreateToggle("Export Prefabs", _exportPrefabs, evt => _exportPrefabs = evt.newValue);
+            var soToggle = ProjectExporterUI.CreateToggle("Export Scriptable Objects", _exportScriptableObjects, evt => _exportScriptableObjects = evt.newValue);
+            var metaToggle = ProjectExporterUI.CreateToggle("Export Meta Files", _exportMetaFiles, evt => _exportMetaFiles = evt.newValue);
+            var settingsToggle = ProjectExporterUI.CreateToggle("Export Settings", _exportSettings, evt => _exportSettings = evt.newValue);
+
+            _contentContainer.Add(scenesToggle);
+            _contentContainer.Add(prefabsToggle);
+            _contentContainer.Add(soToggle);
+            _contentContainer.Add(metaToggle);
+            _contentContainer.Add(settingsToggle);
+        }
+
+        private void PerformBulkExport()
+        {
+            if (_exportScenes) ExportAllOfType("Scenes");
+            if (_exportPrefabs) ExportAllOfType("Prefabs");
+            if (_exportScriptableObjects) ExportAllOfType("Scriptable Objects");
+            if (_exportMetaFiles) ExportAllOfType("Meta Files");
+            if (_exportSettings) ExportAllOfType("Settings");
+            
+            EditorUtility.DisplayDialog("Bulk Export", "Bulk export process finished.", "OK");
+        }
+
+        private void ExportAllOfType(string type)
+        {
+            if (!_assetTrees.ContainsKey(type))
+            {
+                LoadAssetTree(type);
+            }
+            
+            var rootModel = _assetTrees[type];
+            if (rootModel != null)
+            {
+                SetChildrenSelection(rootModel, true); // Select all assets
+                _controller.ExportAssets(rootModel, type);
+            }
+        }
+
+        private void LoadAssetTree(string tabName)
+        {
+            EditorUtility.DisplayProgressBar("Loading...", $"Fetching {tabName}...", 0.5f);
+            try
+            {
+                switch (tabName)
+                {
+                    case "Scenes":
+                        _assetTrees[tabName] = _controller.GetAssets("t:Scene");
+                        break;
+                    case "Prefabs":
+                        _assetTrees[tabName] = _controller.GetAssets("t:Prefab");
+                        break;
+                    case "Scriptable Objects":
+                        _assetTrees[tabName] = _controller.GetAssets("t:ScriptableObject");
+                        break;
+                    case "Meta Files":
+                        _assetTrees[tabName] = _controller.GetAllMetaFiles();
+                        break;
+                    case "Settings":
+                        _assetTrees[tabName] = _controller.GetProjectSettingsFiles();
+                        break;
+                }
+            }
+            finally
+            {
+                EditorUtility.ClearProgressBar();
+            }
+        }
+
         private VisualElement CreateAssetView(AssetModel model, int indentLevel)
         {
             const int indentWidth = 20;