Unity - 搬砖日志 - CustomExportPackage - 自定义的资源导出导入工具 - AssetDatabase.ExportPackage

目的

主要用途是便于美术工程中，将零零散散的资源一次导出到 unitypackage，再导入到程序工程的一个工具

没那么美观的功能

// jave.lin 2021/04/07

using System;
using System.Collections.Generic;
using System.IO;
using UnityEditor;
using UnityEngine;

public class FileOptInfo
{
    public bool export;
    public string path;
}

public class CustomExportPackageWindow : EditorWindow
{
    private static string[] lineSpliter = new string[] { "\n" };

    private Vector2 fileOptScrollPos;
    private Vector2 selectFileDependentsScrollPos;
    private Vector2 allExportFilesPos;

    private List fileOptInfoList = new List();

    private FileOptInfo selectFileOpt;
    private FileOptInfo lastFileOpt;

    private string[] lastFileOptDepsList;

    private string ignorePrefixStr = "https://192.168.1.x:xxx/svn/xxx/x/xxx/xxx/";

    private List allExportFileOptList = new List();

    [MenuItem("Tools/CustomExportPackageWindow")]
    public static void _Show()
    {
        var win = EditorWindow.GetWindow();
        win.Show();
    }
    private void OnGUI()
    {
        EditorGUILayout.BeginVertical();

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.LabelField("Ignore Prefix : ", GUILayout.Width(100));
        ignorePrefixStr = EditorGUILayout.TextField(ignorePrefixStr);
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.BeginHorizontal();
        
        // File Opt
        
        fileOptScrollPos = EditorGUILayout.BeginScrollView(fileOptScrollPos, GUILayout.Width(600), GUILayout.Height(300));
        EditorGUILayout.BeginVertical();

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.LabelField("File Opt", GUILayout.Width(100));
        if (GUILayout.Button("Refresh From Clipboard Text"))
        {
            selectFileOpt = null;
            fileOptInfoList.Clear();

            var cbBufStr = GUIUtility.systemCopyBuffer;
            if (!string.IsNullOrEmpty(cbBufStr))
            {
                var lines = cbBufStr.Split(lineSpliter, StringSplitOptions.RemoveEmptyEntries);
                if (lines != null && lines.Length > 0)
                {
                    foreach (var line in lines)
                    {
                        var newLine = line.Replace(ignorePrefixStr, "");
                        fileOptInfoList.Add(new FileOptInfo
                        {
                            export = true,
                            path = newLine,
                        });
                    }
                }
            }
        }
        EditorGUILayout.EndHorizontal();

        if (fileOptInfoList.Count == 0)
        {
            EditorGUILayout.LabelField("[EMPTY]");
        }
        else
        {
            foreach (var opt in fileOptInfoList)
            {
                EditorGUILayout.BeginHorizontal();
                opt.export = EditorGUILayout.Toggle(opt.export, GUILayout.Width(20));
                if (GUILayout.Button("ShowDeps", GUILayout.Width(80)))
                {
                    selectFileOpt = opt;
                }
                EditorGUILayout.TextField(opt.path);
                EditorGUILayout.EndHorizontal();
            }
        }
        
        EditorGUILayout.EndVertical();
        EditorGUILayout.EndScrollView();

        
        // Select File Dependents
        
        selectFileDependentsScrollPos = EditorGUILayout.BeginScrollView(selectFileDependentsScrollPos/*, GUILayout.Width(300), GUILayout.Width(300)*/);
        EditorGUILayout.BeginVertical();
        EditorGUILayout.LabelField("Select File Dependents");

        if (selectFileOpt != null)
        {
            if (lastFileOpt != selectFileOpt)
            {
                lastFileOpt = selectFileOpt;
                lastFileOptDepsList = AssetDatabase.GetDependencies(selectFileOpt.path.Trim());
            }
        }
        
        if (lastFileOptDepsList != null && lastFileOptDepsList.Length > 0)
        {
            foreach (var deps in lastFileOptDepsList)
            {
                EditorGUILayout.TextField(deps);
            }
        }

        EditorGUILayout.EndVertical();
        EditorGUILayout.EndScrollView();

        EditorGUILayout.EndHorizontal();


        
        // All Export Files
        
        allExportFilesPos = EditorGUILayout.BeginScrollView(allExportFilesPos/*, GUILayout.Width(300), GUILayout.Width(300)*/);
        EditorGUILayout.BeginVertical();

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.LabelField("All Export Files");
        if (GUILayout.Button("Refresh", GUILayout.Width(100)))
        {
            HashSet distincSet = new HashSet();
            foreach (var opt in fileOptInfoList)
            {
                if (!opt.export) continue;

                var deps = AssetDatabase.GetDependencies(opt.path.Trim());

                foreach (var dep in deps)
                {
                    if (!distincSet.Contains(dep))
                    {
                        distincSet.Add(dep);
                    }
                }
            }

            var depArr = new string[distincSet.Count];
            distincSet.CopyTo(depArr);

            Array.Sort(depArr);

            allExportFileOptList.Clear();
            foreach (var dep in depArr)
            {
                allExportFileOptList.Add(new FileOptInfo { export = true, path = dep });
            }
        }
        if (GUILayout.Button("Export", GUILayout.Width(100)))
        {
            if (allExportFileOptList.Count > 0)
            {
                var exportCount = 0;
                foreach (var opt in allExportFileOptList)
                {
                    if (opt.export) exportCount++;
                }
                if (exportCount > 0)
                {
                    var title = "Save Export Unity Package";
                    var now = DateTime.Now;
                    var defaultName = $"{now.Year}_{now.Month}_{now.Day}_{now.Hour}_{now.Minute}_{now.Second}_ToPGUnityPackage";
                    var extension = "unitypackage";
                    var savePath = EditorUtility.SaveFilePanel(title, Application.dataPath, defaultName, extension);
                    var dirPath = Path.GetDirectoryName(savePath);
                    if (!string.IsNullOrEmpty(savePath) && Directory.Exists(dirPath))
                    {
                        var exports = new string[exportCount];
                        var idx = 0;
                        foreach (var opt in allExportFileOptList)
                        {
                            if (opt.export)
                            {
                                exports[idx++] = opt.path.Trim();
                            }
                        }
                        AssetDatabase.ExportPackage(exports, savePath, ExportPackageOptions.Default);
                        System.Diagnostics.Process.Start("explorer.exe", dirPath);
                        //System.Diagnostics.Process.Start("explorer.exe", $"{dirPath} /select {savePath}");
                    }
                }
            }
        }
        EditorGUILayout.EndHorizontal();

        if (allExportFileOptList.Count > 0)
        {
            foreach (var opt in allExportFileOptList)
            {
                EditorGUILayout.BeginHorizontal();
                opt.export = EditorGUILayout.Toggle(opt.export, GUILayout.Width(20));
                EditorGUILayout.TextField(opt.path);
                EditorGUILayout.EndHorizontal();
            }
        }

        EditorGUILayout.EndVertical();
        EditorGUILayout.EndScrollView();


        EditorGUILayout.EndVertical();
    }
}

使用 先打开 SVN log

选中你想导出的 svn url

• CTRL + C
• 或是右键 Copy to clipboard/Urls, URLs with revision, Paths relative to root, Filenames，如下图

Git 中同样可以 copy submits option url 的方式

Git 的当时没截图，现在就不放上来了

到工具面板

1,2,3 步骤

选中导出 unitypackage 文件目录

将导出的 unitypackage 拖拽入 程序工程即可

可以看到，和 unity 自带的 Export Package… 再 Import Package… 时的方式是一致的

但是导入的时候，我们可以高度自由的添加，删除不需要的导出内容

此工具缺点

如果你选中的一些 svn commit 上的记录文件，在后续的 svn update 中有 Remove 的话

那么 copy 到的 svn url 将不会导入、导出

稍微美观一些的工具（主要使用拖拽）

// jave.lin 2021/04/07

using System;
using System.Collections.Generic;
using System.IO;
using UnityEditor;
using UnityEngine;

public class FileOptInfo
{
	public bool export;
	public string path;
	public UnityEngine.Object obj;
}

public class ClipboardImportInfo
{
	public bool import;
	public string path;
}

public class CustomExportPackageClipboardDialog : EditorWindow
{
    private string ignorePrefixStr = "https://192.168.x.x:xxx/xx/xxx/xxx/xxx/xxx/";
	private string lastIgnorePrefixStr;
	private Vector2 scrollViewPos;

	private string clipboardStr;
	private List srcLines = new List();
	private List filterImportInfoList = new List();
	private List filterLines = new List();

	public static List ShowDialog(EditorWindow parent)
    {
#if UNITY_2019_4_OR_NEWER

		var win = EditorWindow.GetWindow();
		var w = parent.position.width * 0.5f;
		var h = parent.position.height * 0.5f;
		var x = parent.position.x + (w) * 0.5f;
		var y = parent.position.y + (h) * 0.5f;
		var rect = new Rect(x, y, w, h);
		//var win = EditorWindow.GetWindowWithRect(
		//	typeof(CustomExportPackageClipboardDialog), 
		//	rect, false, "Filter Clipboard Data")
		//	as CustomExportPackageClipboardDialog; // rect 参数这是没有效果

		win.clipboardStr = GUIUtility.systemCopyBuffer;
		var lines = win.clipboardStr.Split(new string[] { "\n\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
        foreach (var line in lines)
        {
			var tempLine = line.Trim();
			if (string.IsNullOrEmpty(tempLine))
			{
				continue;
			}
			win.srcLines.Add(line);
        }

		win.position = rect; // 上面的 GetWindowWithRect 中的 rect 参数没有效果，只能在 EditorWindow.position 上设置才有效果
		win.titleContent = new GUIContent("过滤剪贴板内容");
		win.ShowModal();
		return win.GetFilterPaths();
#else
		return new List();
#endif
	}

	public List GetFilterPaths()
    {
		filterLines.Clear();
        foreach (var info in filterImportInfoList)
        {
			if (info.import) filterLines.Add(info.path);
        }
		return filterLines;
    }

    private void OnGUI()
    {
		//if (GUILayout.Button("OK"))
		//{
		//	this.Close();
		//	return;
		//}

		EditorGUILayout.BeginHorizontal();
		EditorGUILayout.LabelField("Ignore Prefix : ", GUILayout.Width(100));
		ignorePrefixStr = EditorGUILayout.TextField(ignorePrefixStr);
		EditorGUILayout.EndHorizontal();

		scrollViewPos = EditorGUILayout.BeginScrollView(scrollViewPos);

		if (lastIgnorePrefixStr != ignorePrefixStr)
		{
			lastIgnorePrefixStr = ignorePrefixStr;
			filterLines.Clear();

			foreach (var line in srcLines)
			{
				var newLineContent = line;
				if (!string.IsNullOrEmpty(ignorePrefixStr) && line.StartsWith(ignorePrefixStr))
				{
					newLineContent = line.Substring(ignorePrefixStr.Length);
				}
				newLineContent = newLineContent.Trim();
				if (!string.IsNullOrEmpty(newLineContent))
				{
					filterLines.Add(newLineContent);
				}
			}
			if (filterImportInfoList.Count == 0)
			{
				foreach (var line in filterLines)
				{
					filterImportInfoList.Add(new ClipboardImportInfo { import = true, path = line });
				}
			}
			else
			{
				for (int i = 0; i  0)
        {
			var havePushSuccess = false;
            foreach (var path in pushList)
            {
				var tempPath = path.Trim();
				if (string.IsNullOrEmpty(tempPath))
                {
					continue;
                }
				if (AddPath(path))
                {
					havePushSuccess = true;
				}
			}
			pushList.Clear();

			if (havePushSuccess) OnRefreshDepsEvent?.Invoke();
		}
    }

	private void OnGUI()
    {
		///
		/// Handle Push List
		///
		HandlePushList();

		///
		/// Handle Clipboard Data
		///
		HandleClipboardData();

		///
		/// Drag and Drop
		///
		DragDrop();

		EditorGUILayout.BeginHorizontal();
		///
		/// Display Files
		///
		DisplayFileOptList();

		///
		/// Display All Dependencies
		///
		DisplayAllDependencies();
		EditorGUILayout.EndHorizontal();
	}

	private void HandleClipboardData()
    {
		if (Event.current.control && Event.current.type == EventType.KeyDown && Event.current.keyCode == KeyCode.V)
        {
			if (!string.IsNullOrEmpty(GUIUtility.systemCopyBuffer))
			{
				var paths = CustomExportPackageClipboardDialog.ShowDialog(this);
				if (paths != null && paths.Count > 0)
                {
                    foreach (var path in paths)
                    {
						pushList.Add(path);
					}
				}
			}
		}
	}

	public void RefreshDeps()
    {
		HashSet distincSet = new HashSet();
		foreach (var opt in fileOptInfoList)
		{
			if (!opt.export) continue;

			var deps = AssetDatabase.GetDependencies(opt.path.Trim());

			foreach (var dep in deps)
			{
				if (!distincSet.Contains(dep))
				{
					distincSet.Add(dep);
				}
			}
		}

		var depArr = new string[distincSet.Count];
		distincSet.CopyTo(depArr);

		Array.Sort(depArr);

		// Record src export value
		Dictionary srcExportDict = new Dictionary();
        foreach (var opt in allExportFileOptList)
        {
			srcExportDict[opt.path] = opt.export;
        }

		allExportFileOptList.Clear();
		foreach (var dep in depArr)
		{
			// Try recovery src export value
			if (!srcExportDict.TryGetValue(dep, out bool srcExportValue))
            {
				// If not found, default export value EQUALS : true
				srcExportValue = true;
			}
			allExportFileOptList.Add(new FileOptInfo { export = srcExportValue, path = dep });
		}
	}

	private void DisplayFileOptList()
    {
		EditorGUILayout.BeginVertical();

		EditorGUILayout.BeginHorizontal();
		if (GUILayout.Button("Clear"))
		{
			fileOptInfoList.Clear();
			allExportFileOptList.Clear();
		}
		if (GUILayout.Button("Refresh Deps"))
		{
			OnRefreshDepsEvent?.Invoke();
		}
		EditorGUILayout.EndHorizontal();

		EditorGUILayout.LabelField("DragDrop Files:");

		dragDropFileScrollViewPos = EditorGUILayout.BeginScrollView(dragDropFileScrollViewPos/*, GUILayout.Width(300), GUILayout.Width(300)*/);

		var refreshDepsEventFire = false;
		for (int i = 0; i  0)
        {
            var exportCount = 0;
            foreach (var opt in allExportFileOptList)
            {
                if (opt.export) exportCount++;
            }
            if (exportCount > 0)
            {
                var title = "Save Export Unity Package";
                var now = DateTime.Now;
                var defaultName = $"{now.Year}_{now.Month}_{now.Day}_{now.Hour}_{now.Minute}_{now.Second}_ToPGUnityPackage";
                var extension = "unitypackage";
				string savePath;
				if (useDefaultExportPath)
                {
					savePath = defaultExportPath;
				}
				else
                {
					savePath = EditorUtility.SaveFilePanel(title, Application.dataPath, defaultName, extension);
				}
				if (!string.IsNullOrEmpty(savePath))
                {
                    var dirPath = Path.GetDirectoryName(savePath);
					if (!Directory.Exists(dirPath))
                    {
						Directory.CreateDirectory(dirPath);
					}
                    var exports = new string[exportCount];
                    var idx = 0;
                    foreach (var opt in allExportFileOptList)
                    {
                        if (opt.export)
                        {
                            exports[idx++] = opt.path.Trim();
                        }
                    }
                    AssetDatabase.ExportPackage(exports, savePath, ExportPackageOptions.Default);
                    //System.Diagnostics.Process.Start("explorer.exe", dirPath);

					// 打开并选中对应的文件
                    //Debug.LogError($"dirPath : {dirPath}");
                    var selectPath = savePath.Replace("/", "\\");
                    //Debug.LogError($"select : {selectPath}");
                    System.Diagnostics.Process.Start("explorer.exe", $"/select,{selectPath}");
                }
            }
        }
    }

    private void DragDrop()
	{
		Event evt = Event.current;
		switch (evt.type)
		{
			case EventType.DragUpdated:
			case EventType.DragPerform:

			DragAndDrop.visualMode = DragAndDropVisualMode.Link;

			if (evt.type == EventType.DragPerform)
			{
				 method 1: handle by objs
				//var objList = new List();
				//GetObjsOnDragDrops(DragAndDrop.objectReferences, objList);

				//foreach (UnityEngine.Object draggedObj in objList)
				//{
				//	DoDropObj(draggedObj);
				//}

				// method 2 : handle by obj paths
				var projectViewSelectedObjsPaths = new List();
				TransToPath(DragAndDrop.objectReferences, projectViewSelectedObjsPaths);

				var allProjectViewSelectedObjPaths = new List();
				GetAllObjPathsWithPaths(projectViewSelectedObjsPaths, allProjectViewSelectedObjPaths);

				pushList.AddRange(allProjectViewSelectedObjPaths);
			}
			break;
		}
	}

	private void GetObjsOnDragDrops(UnityEngine.Object[] objs, List ret)
    {
		foreach (UnityEngine.Object obj in objs)
		{
			var assetPath = AssetDatabase.GetAssetPath(obj);
			if (JudgeIsAFolder(assetPath))
			{
				var objGUIDs = AssetDatabase.FindAssets("t:Object", new string[] { assetPath });
				var newObjs = new UnityEngine.Object[objGUIDs.Length];
                for (int i = 0; i