Sujith :) ->

1. Refactored slight a bit few scripts
2. Created a unified editor

Assets/AssetBank/Editor/DockableWindow/ProjectExporterController.cs

@@ -23,7 +23,7 @@ namespace AssetBank.DockableWindow
         }
 
         // Finds assets based on a search filter (e.g., "t:Scene") and builds a hierarchical model.
-        public AssetModel GetAssets(string filter)
+        public static AssetModel GetAssets(string filter)
         {
             var root = new AssetModel("Assets", "Assets");
             var assetGuids = AssetDatabase.FindAssets(filter, new[] { "Assets" });
@@ -135,7 +135,7 @@ namespace AssetBank.DockableWindow
         }
 
         // Executes the Python conversion script for the selected assets.
-        public void ExportAssets(AssetModel rootNode, string exportType)
+        public void ExportAssets(AssetModel rootNode, string customExportPath = null)
         {
             var assetsToExport = new List<string>();
             CollectSelectedAssets(rootNode, assetsToExport);
@@ -146,7 +146,7 @@ namespace AssetBank.DockableWindow
             var conversionScript = GetConversionScriptPath();
             if (string.IsNullOrEmpty(conversionScript)) return;
 
-            var outputDirectory = Path.Combine(ProjectRoot, "Library", "ProjectDataExport");
+            var outputDirectory = customExportPath ?? Path.Combine(ProjectRoot, "Library", "ProjectDataExport");
             Directory.CreateDirectory(outputDirectory);
 
             EditorUtility.DisplayProgressBar("Exporting...", "Starting export process...", 0f);

Assets/AssetBank/Editor/DockableWindow/ProjectExporterDataHelper.cs

@@ -0,0 +1,54 @@
+using UnityEditor;
+using AssetBank.DockableWindow;
+using System.Collections.Generic;
+
+namespace AssetBank.Editor.DockableWindow
+{
+    public class ProjectExporterDataHelper
+    {
+        public static void LoadAssetTree(Dictionary<string, AssetModel> assetTrees, ProjectExporterController controller, string tabName, bool showProgress = true)
+        {
+            if (showProgress)
+            {
+                EditorUtility.DisplayProgressBar("Loading...", $"Fetching {tabName}...", 0.5f);   
+            }
+            try
+            {
+                switch (tabName)
+                {
+                    case "Scenes":
+                        assetTrees[tabName] = ProjectExporterController.GetAssets("t:Scene");
+                        break;
+                    case "Prefabs":
+                        assetTrees[tabName] = ProjectExporterController.GetAssets("t:Prefab");
+                        break;
+                    case "Scriptable Objects":
+                        assetTrees[tabName] = ProjectExporterController.GetAssets("t:ScriptableObject");
+                        break;
+                    case "Meta Files":
+                        assetTrees[tabName] = controller.GetAllMetaFiles();
+                        break;
+                    case "Settings":
+                        assetTrees[tabName] = controller.GetProjectSettingsFiles();
+                        break;
+                }
+            }
+            finally
+            {
+                if (showProgress)
+                {
+                    EditorUtility.ClearProgressBar();
+                }
+            }
+        }
+        
+        public static void SetChildrenSelection(AssetModel parent, bool isSelected)
+        {
+            parent.IsSelected = isSelected;
+            foreach (var child in parent.Children)
+            {
+                SetChildrenSelection(child, isSelected);
+            }
+        }
+    }
+}

Assets/AssetBank/Editor/DockableWindow/ProjectExporterDataHelper.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8698bdc55b9544ac93c3e70898d83633
+timeCreated: 1753186696

Assets/AssetBank/Editor/DockableWindow/ProjectExporterWindow.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using AssetBank.DockableWindow.UIHelper;
+using AssetBank.Editor.DockableWindow;
 using UnityEditor;
 using UnityEngine;
 using UnityEngine.UIElements;
@@ -69,7 +70,7 @@ namespace AssetBank.DockableWindow
                 }
                 else if (_assetTrees.ContainsKey(_currentTab))
                 {
-                    _controller.ExportAssets(_assetTrees[_currentTab], _currentTab);
+                    _controller.ExportAssets(_assetTrees[_currentTab]);
                 }
             };
 
@@ -95,7 +96,7 @@ namespace AssetBank.DockableWindow
 
             if (!_assetTrees.ContainsKey(tabName))
             {
-                LoadAssetTree(tabName);
+                ProjectExporterDataHelper.LoadAssetTree(_assetTrees, _controller, tabName);
             }
 
             var rootModel = _assetTrees[tabName];
@@ -141,44 +142,14 @@ namespace AssetBank.DockableWindow
         {
             if (!_assetTrees.ContainsKey(type))
             {
-                LoadAssetTree(type);
+                ProjectExporterDataHelper.LoadAssetTree(_assetTrees, _controller, 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();
+                ProjectExporterDataHelper.SetChildrenSelection(rootModel, true); // Select all assets
+                _controller.ExportAssets(rootModel);
             }
         }
 
@@ -195,7 +166,7 @@ namespace AssetBank.DockableWindow
                 
                 toggle.RegisterValueChangedCallback(evt => {
                     model.IsSelected = evt.newValue;
-                    SetChildrenSelection(model, evt.newValue);
+                    ProjectExporterDataHelper.SetChildrenSelection(model, evt.newValue);
                     UpdateChildTogglesUI(foldout, evt.newValue);
                 });
 
@@ -224,14 +195,5 @@ namespace AssetBank.DockableWindow
                 childToggle.SetValueWithoutNotify(isSelected);
             });
         }
-
-        private void SetChildrenSelection(AssetModel parent, bool isSelected)
-        {
-            parent.IsSelected = isSelected;
-            foreach (var child in parent.Children)
-            {
-                SetChildrenSelection(child, isSelected);
-            }
-        }
     }
 }

Assets/AssetBank/Editor/DockableWindow/UIHelper/ProjectExporterUI.cs

@@ -98,5 +98,21 @@ namespace AssetBank.DockableWindow.UIHelper
             };
             return button;
         }
+        
+        // Creates a separator line.
+        public static VisualElement CreateSeparator()
+        {
+            return new VisualElement
+            {
+                style =
+                {
+                    flexDirection = FlexDirection.Row, alignItems = Align.Center,
+                    marginTop = 10,
+                    marginBottom = 10,
+                    height = 1,
+                    backgroundColor = new Color(0.5f, 0.5f, 0.5f)
+                }
+            };
+        }
     }
 }

Assets/AssetBank/Editor/Tools/GuidMapperExporter.cs

@@ -11,7 +11,7 @@ namespace AssetBank.Editor.Tools
 {
     public static class GuidMapperExporter
     {
-        private enum ExportFor
+        public enum ExportFor
         {
             Script,
             Scene,
@@ -106,7 +106,7 @@ namespace AssetBank.Editor.Tools
             BulkExport();
         }
 
-        private static void BulkExport()
+        public static void BulkExport(string savePath = null)
         {
             var typeToGuidMapper = new Dictionary<Type, List<GuidMapper>>();
             
@@ -158,18 +158,21 @@ namespace AssetBank.Editor.Tools
                 typeToGuidMapper[type].Add(guidMapper);
             }
             
-            var savePath = EditorUtility.SaveFilePanel("Save GUID Mappers", Application.dataPath, "guidMappers", "json");
-            if (!string.IsNullOrEmpty(savePath))
+            savePath ??= EditorUtility.SaveFilePanel("Save GUID Mappers", Application.dataPath, "guidMappers", "json");
+            if (string.IsNullOrEmpty(savePath))
             {
-                foreach (var (type, guidMappers) in typeToGuidMapper)
-                {
-                    var friendlyName = type.Name.Split('.').Last();
-                    var fileName = $"{friendlyName} - guidMapper.json";
-                    var filePath = Path.Combine(Path.GetDirectoryName(savePath) ?? Application.dataPath, fileName);
-                    JsonFileSystem.Write(guidMappers, filePath);
-                }
+                Debug.LogWarning("GUID Mappers not exported");
+                return;
             }
             
+            foreach (var (type, guidMappers) in typeToGuidMapper)
+            {
+                var friendlyName = type.Name.Split('.').Last();
+                var fileName = $"{friendlyName} - guidMapper.json";
+                var dirName = Path.HasExtension(savePath) ? Path.GetDirectoryName(savePath) : savePath;
+                var filePath = Path.Combine(dirName ?? Application.dataPath, fileName);
+                JsonFileSystem.Write(guidMappers, filePath);
+            }
             Debug.Log($"Exported {typeToGuidMapper.Count} GUID Mappers");
         }
         

Assets/AssetBank/Editor/Tools/ScriptExporter.cs

@@ -12,6 +12,11 @@ namespace AssetBank.Editor.Tools
     {
         [MenuItem("Tools/Script Exporter/Export Scripts")]
         public static void ExportScripts()
+        {
+            ProcessAndCopyScripts();
+        }
+
+        public static void ProcessAndCopyScripts(string destinationPath = null)
         {
             var settings = ProjectExporterSettings.GetOrCreateSettings();
             var foldersToIgnore = settings.FoldersToIgnore;
@@ -28,12 +33,12 @@ namespace AssetBank.Editor.Tools
                 filteredScriptPaths.Add(path);
             }
             
-            var savePath = EditorUtility.SaveFolderPanel("Choose destination to copy scripts into", Application.dataPath, "");
-            if (string.IsNullOrEmpty(savePath)) return;
+            destinationPath ??= EditorUtility.SaveFolderPanel("Choose destination to copy scripts into", Application.dataPath, "");
+            if (string.IsNullOrEmpty(destinationPath)) return;
 
             foreach (var scriptPath in filteredScriptPaths)
             {
-                CopyFile(scriptPath, savePath);
+                CopyFile(scriptPath, destinationPath);
             }
         }
 

Assets/AssetBank/Editor/Tools/UnifiedExporter.cs

@@ -0,0 +1,132 @@
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+using AssetBank.DockableWindow;
+using System.Collections.Generic;
+using AssetBank.Editor.DockableWindow;
+using AssetBank.DockableWindow.UIHelper;
+
+namespace AssetBank.Editor.Tools
+{
+    public class UnifiedExporter : EditorWindow
+    {
+        private VisualElement _rootElement;
+        private VisualElement _contentContainer;
+        private ProjectExporterController _controller;
+        private GuidMapperExporter.ExportFor _exportFor;
+        private Dictionary<string, AssetModel> _assetTrees;
+        
+        private bool _exportScenes = true;
+        private bool _exportPrefabs = true;
+        private bool _exportScriptableObjects = true;
+        private bool _exportMetaFiles = true;
+        private bool _exportSettings = true;
+        private bool _exportScriptsIndependently;
+        private bool _copyScripts = true;
+        private bool _exportAllGuidMappers = true;
+        
+        [MenuItem("Tools/Unified Exporter")]
+        public static void ShowWindow()
+        {
+            var wnd = GetWindow<UnifiedExporter>(true);
+            wnd.titleContent = new GUIContent("Unified Exporter", EditorGUIUtility.IconContent("d_Profiler.GlobalIllumination").image);
+            wnd.minSize = new Vector2(400, 300);
+        }
+
+        private void OnEnable()
+        {
+            _assetTrees = new Dictionary<string, AssetModel>();
+            _controller = new ProjectExporterController();
+            _rootElement = rootVisualElement;
+            BuildUI();
+        }
+
+        private void BuildUI()
+        {
+            var scrollView = new ScrollView(ScrollViewMode.Vertical);
+            _rootElement.Add(scrollView);
+            _contentContainer = ProjectExporterUI.CreateMainContainer();
+            scrollView.Add(_contentContainer);
+            DrawToggles();
+            
+            var generateButton = ProjectExporterUI.CreateGenerateButton();
+            _rootElement.Add(generateButton);
+            generateButton.clicked += PerformExportOperation;
+        }
+
+        private void DrawToggles()
+        {
+            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);
+            var exportScriptsToggle = ProjectExporterUI.CreateToggle("Export Scripts Separately", _exportScriptsIndependently, evt => _exportScriptsIndependently = evt.newValue);
+            var copyScriptsToggle = ProjectExporterUI.CreateToggle("Copy Scripts", _copyScripts, evt => _copyScripts = evt.newValue);
+            var exportAllGuidMappersToggle = ProjectExporterUI.CreateToggle("Export All Guid Mappers", _exportAllGuidMappers, evt => _exportAllGuidMappers = evt.newValue);
+            _contentContainer.Add(scenesToggle);
+            _contentContainer.Add(prefabsToggle);
+            _contentContainer.Add(soToggle);
+            _contentContainer.Add(metaToggle);
+            _contentContainer.Add(settingsToggle);
+            
+            var separator = ProjectExporterUI.CreateSeparator();
+            _contentContainer.Add(separator);
+            _contentContainer.Add(exportScriptsToggle);
+            _contentContainer.Add(copyScriptsToggle);
+            
+            var separator2 = ProjectExporterUI.CreateSeparator();
+            _contentContainer.Add(separator2);
+            _contentContainer.Add(exportAllGuidMappersToggle);
+        }
+
+        private void PerformExportOperation()
+        {
+            var savePath = EditorUtility.SaveFolderPanel("Choose export destination", Application.dataPath, "");
+            if (string.IsNullOrEmpty(savePath)) return;
+            
+            ExportAssetData(savePath);
+            CopyScripts(savePath);
+            ExportGuidMappers(savePath);
+            
+            EditorUtility.DisplayDialog("Bulk Export", "Bulk export process finished.", "OK");
+        }
+
+        private void ExportAssetData(string savePath)
+        {
+            if (_exportScenes) ExportAllOfType("Scenes", savePath);
+            if (_exportPrefabs) ExportAllOfType("Prefabs", savePath);
+            if (_exportScriptableObjects) ExportAllOfType("Scriptable Objects", savePath);
+            if (_exportMetaFiles) ExportAllOfType("Meta Files", savePath);
+            if (_exportSettings) ExportAllOfType("Settings", savePath);
+        }
+
+        private void CopyScripts(string savePath)
+        {
+            var exportPath = _exportScriptsIndependently ? Path.Combine(savePath, "Scripts") : Path.Combine(savePath, "Assets");
+            ScriptExporter.ProcessAndCopyScripts(exportPath);
+        }
+        
+        private void ExportGuidMappers(string savePath)
+        {
+            var exportPath = Path.Combine(savePath, "GuidMappers");
+            if (_exportAllGuidMappers) GuidMapperExporter.BulkExport(exportPath);
+        }
+
+        private void ExportAllOfType(string type, string savePath)
+        {
+            if (!_assetTrees.ContainsKey(type))
+            {
+                ProjectExporterDataHelper.LoadAssetTree(_assetTrees, _controller, type);
+            }
+            
+            var rootModel = _assetTrees[type];
+            if (rootModel != null)
+            {
+                ProjectExporterDataHelper.SetChildrenSelection(rootModel, true);
+                _controller.ExportAssets(rootModel, savePath);
+            }
+        }
+    }
+}

Assets/AssetBank/Editor/Tools/UnifiedExporter.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f1c292dd4fbb468daafd9f36fabf58e9
+timeCreated: 1753185588