791 lines
30 KiB
C#
791 lines
30 KiB
C#
using UnityEditor;
|
|
using UnityEngine;
|
|
using System;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Collections.Generic;
|
|
|
|
public class DependencyOrganizerWindow : EditorWindow
|
|
{
|
|
private List<UnityEngine.Object> draggedAssets = new List<UnityEngine.Object>();
|
|
private Vector2 prefabScroll;
|
|
private Vector2 depScroll;
|
|
|
|
private Dictionary<string, Dictionary<string, bool>> dependenciesByType = new Dictionary<string, Dictionary<string, bool>>();
|
|
private Dictionary<string, bool> typeToggle = new Dictionary<string, bool>();
|
|
private Dictionary<string, bool> typeFoldout = new Dictionary<string, bool>();
|
|
|
|
private Dictionary<string, bool> filterTypeToggle = new Dictionary<string, bool>();
|
|
|
|
// 贴图路径 -> HashSet<材质路径>
|
|
private Dictionary<string, HashSet<string>> textureUsedByMaterials = new Dictionary<string, HashSet<string>>();
|
|
|
|
private string targetRootFolder = string.Empty;
|
|
private string lastOrganizeAbsPath = string.Empty;
|
|
|
|
private SortedDictionary<long, string> undoManifests = new SortedDictionary<long, string>();
|
|
|
|
private const string UndoManifestDir = "Assets/Editor/DependencyOrganizerUndo";
|
|
private const string UndoManifestPrefix = "DependencyOrganizerWindow_undo_";
|
|
|
|
private Dictionary<string, bool> matsFoldout = new Dictionary<string, bool>();
|
|
|
|
[MenuItem("Tools/特效依赖整理工具")]
|
|
public static void ShowWindow()
|
|
{
|
|
var w = GetWindow<DependencyOrganizerWindow>("特效依赖整理工具-by很喜欢乱来");
|
|
w.minSize = new Vector2(700, 700);
|
|
}
|
|
|
|
private void OnEnable()
|
|
{
|
|
LoadUndoManifests();
|
|
InitFilterTypeToggle();
|
|
}
|
|
|
|
private void InitFilterTypeToggle()
|
|
{
|
|
string[] filterTypes = new string[] {
|
|
"Textures", "Materials", "Models", "Shaders", "Scripts",
|
|
"Prefabs", "Animations", "Animators", "Audio", "Physics", "Others"
|
|
};
|
|
foreach (var t in filterTypes)
|
|
{
|
|
if (!filterTypeToggle.ContainsKey(t))
|
|
filterTypeToggle[t] = true;
|
|
}
|
|
}
|
|
|
|
private void OnGUI()
|
|
{
|
|
GUILayout.Label("依赖整理工具-by很喜欢乱来", EditorStyles.boldLabel);
|
|
EditorGUILayout.HelpBox(
|
|
"1. 拖入Prefab/Scene/ScriptableObject等资源。\n" +
|
|
"2. 点击“收集依赖资源”，按类型和文件复选。\n" +
|
|
"3. 支持折叠、全选/反选。\n" +
|
|
"4. 选择目标根目录（支持拖入文件夹）。\n" +
|
|
"5. 点击“整理”移动资源，自动避免冲突重命名。\n" +
|
|
"6. 支持多版本撤销。\n" +
|
|
"7. 支持导出UnityPackage。\n" +
|
|
"8. 移动时显示进度条。\n" +
|
|
"9. 显示资源大小预估。\n" +
|
|
"10. 资源名点击定位，右键复制资源名。\n" +
|
|
"11. 贴图资源显示被哪些材质引用，材质路径列表可点击定位。\n",
|
|
MessageType.Info);
|
|
|
|
EditorGUILayout.Space();
|
|
|
|
DrawFilterTypeToggle();
|
|
|
|
EditorGUILayout.Space();
|
|
|
|
DrawDragArea();
|
|
DrawPrefabList();
|
|
|
|
EditorGUILayout.Space();
|
|
|
|
if (GUILayout.Button("收集依赖资源", GUILayout.Height(30)))
|
|
CollectDependencies();
|
|
|
|
EditorGUILayout.Space();
|
|
|
|
DrawDependenciesList();
|
|
|
|
EditorGUILayout.Space();
|
|
|
|
DrawSizeEstimate();
|
|
|
|
EditorGUILayout.Space();
|
|
|
|
DrawTargetFolderSelector();
|
|
|
|
EditorGUILayout.Space();
|
|
|
|
DrawActionButtons();
|
|
|
|
EditorGUILayout.Space();
|
|
|
|
DrawUndoHistory();
|
|
}
|
|
|
|
private void DrawFilterTypeToggle()
|
|
{
|
|
EditorGUILayout.BeginHorizontal();
|
|
foreach (var key in new List<string>(filterTypeToggle.Keys))
|
|
{
|
|
bool val = filterTypeToggle[key];
|
|
bool newVal = GUILayout.Toggle(val, key, "Button", GUILayout.Height(22));
|
|
if (newVal != val)
|
|
{
|
|
filterTypeToggle[key] = newVal;
|
|
}
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
|
|
private void DrawDragArea()
|
|
{
|
|
Rect dropArea = GUILayoutUtility.GetRect(0, 60, GUILayout.ExpandWidth(true));
|
|
GUI.Box(dropArea, "拖入Prefab/Scene/ScriptableObject/Hierarchy中的GameObject");
|
|
|
|
var evt = Event.current;
|
|
if ((evt.type == EventType.DragUpdated || evt.type == EventType.DragPerform) && dropArea.Contains(evt.mousePosition))
|
|
{
|
|
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
|
|
if (evt.type == EventType.DragPerform)
|
|
{
|
|
DragAndDrop.AcceptDrag();
|
|
foreach (var obj in DragAndDrop.objectReferences)
|
|
{
|
|
string path = AssetDatabase.GetAssetPath(obj);
|
|
|
|
if (obj is GameObject go)
|
|
{
|
|
bool isPrefab = !string.IsNullOrEmpty(path) && path.StartsWith("Assets");
|
|
if (isPrefab)
|
|
{
|
|
if (!draggedAssets.Contains(obj))
|
|
draggedAssets.Add(obj);
|
|
}
|
|
else
|
|
{
|
|
GameObject prefabRoot = PrefabUtility.GetCorrespondingObjectFromSource(go);
|
|
if (prefabRoot != null && !draggedAssets.Contains(prefabRoot))
|
|
draggedAssets.Add(prefabRoot);
|
|
else if (!draggedAssets.Contains(obj))
|
|
draggedAssets.Add(obj);
|
|
}
|
|
}
|
|
else if (IsSupportedAsset(obj, path))
|
|
{
|
|
if (!draggedAssets.Contains(obj))
|
|
draggedAssets.Add(obj);
|
|
}
|
|
}
|
|
}
|
|
evt.Use();
|
|
}
|
|
}
|
|
|
|
private bool IsSupportedAsset(UnityEngine.Object obj, string path)
|
|
{
|
|
if (obj == null || string.IsNullOrEmpty(path)) return false;
|
|
return (obj is GameObject && path.EndsWith(".prefab", StringComparison.OrdinalIgnoreCase))
|
|
|| path.EndsWith(".unity", StringComparison.OrdinalIgnoreCase)
|
|
|| obj is ScriptableObject;
|
|
}
|
|
|
|
private void DrawPrefabList()
|
|
{
|
|
EditorGUILayout.LabelField("已拖入资源：");
|
|
if (draggedAssets.Count > 0)
|
|
{
|
|
if (GUILayout.Button("清空列表", GUILayout.Width(80)))
|
|
{
|
|
draggedAssets.Clear();
|
|
dependenciesByType.Clear();
|
|
typeToggle.Clear();
|
|
typeFoldout.Clear();
|
|
textureUsedByMaterials.Clear();
|
|
matsFoldout.Clear();
|
|
}
|
|
}
|
|
prefabScroll = EditorGUILayout.BeginScrollView(prefabScroll, GUILayout.Height(100));
|
|
for (int i = draggedAssets.Count - 1; i >= 0; i--)
|
|
{
|
|
EditorGUILayout.BeginHorizontal();
|
|
draggedAssets[i] = EditorGUILayout.ObjectField(draggedAssets[i], typeof(UnityEngine.Object), false);
|
|
if (GUILayout.Button("移除", GUILayout.Width(60)))
|
|
draggedAssets.RemoveAt(i);
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
EditorGUILayout.EndScrollView();
|
|
}
|
|
|
|
private void CollectDependencies()
|
|
{
|
|
dependenciesByType.Clear();
|
|
typeToggle.Clear();
|
|
typeFoldout.Clear();
|
|
textureUsedByMaterials.Clear();
|
|
matsFoldout.Clear();
|
|
|
|
if (draggedAssets.Count == 0)
|
|
{
|
|
EditorUtility.DisplayDialog("提示", "请先拖入至少一个资源。", "确定");
|
|
return;
|
|
}
|
|
|
|
HashSet<string> allDeps = new HashSet<string>();
|
|
|
|
foreach (var obj in draggedAssets)
|
|
{
|
|
string origPath = AssetDatabase.GetAssetPath(obj);
|
|
var deps = AssetDatabase.GetDependencies(origPath, true);
|
|
foreach (var dep in deps)
|
|
{
|
|
if (!dep.StartsWith("Assets/") || dep.StartsWith("Assets/Editor/") || dep.Contains("Packages/"))
|
|
continue;
|
|
|
|
allDeps.Add(dep);
|
|
}
|
|
}
|
|
|
|
// 构建贴图->材质引用映射
|
|
foreach (var dep in allDeps)
|
|
{
|
|
Type type = AssetDatabase.GetMainAssetTypeAtPath(dep);
|
|
if (type == typeof(Material))
|
|
{
|
|
Material mat = AssetDatabase.LoadAssetAtPath<Material>(dep);
|
|
if (mat == null) continue;
|
|
|
|
Shader shader = mat.shader;
|
|
int propertyCount = ShaderUtil.GetPropertyCount(shader);
|
|
for (int i = 0; i < propertyCount; i++)
|
|
{
|
|
if (ShaderUtil.GetPropertyType(shader, i) == ShaderUtil.ShaderPropertyType.TexEnv)
|
|
{
|
|
string propName = ShaderUtil.GetPropertyName(shader, i);
|
|
Texture tex = mat.GetTexture(propName);
|
|
if (tex != null)
|
|
{
|
|
string texPath = AssetDatabase.GetAssetPath(tex);
|
|
if (!string.IsNullOrEmpty(texPath))
|
|
{
|
|
if (!textureUsedByMaterials.TryGetValue(texPath, out var mats))
|
|
{
|
|
mats = new HashSet<string>();
|
|
textureUsedByMaterials[texPath] = mats;
|
|
}
|
|
mats.Add(dep);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (var dep in allDeps)
|
|
{
|
|
Type type = AssetDatabase.GetMainAssetTypeAtPath(dep);
|
|
string folder = GetTargetFolder(type, dep);
|
|
|
|
if (!dependenciesByType.ContainsKey(folder))
|
|
dependenciesByType[folder] = new Dictionary<string, bool>();
|
|
|
|
if (!dependenciesByType[folder].ContainsKey(dep))
|
|
dependenciesByType[folder][dep] = true;
|
|
|
|
if (!typeToggle.ContainsKey(folder))
|
|
typeToggle[folder] = true;
|
|
|
|
if (!typeFoldout.ContainsKey(folder))
|
|
typeFoldout[folder] = false;
|
|
}
|
|
}
|
|
|
|
private void DrawDependenciesList()
|
|
{
|
|
if (dependenciesByType.Count == 0) return;
|
|
|
|
float availableHeight = position.height - 550f;
|
|
if (availableHeight < 150f) availableHeight = 150f;
|
|
|
|
depScroll = EditorGUILayout.BeginScrollView(depScroll, GUILayout.Height(availableHeight));
|
|
foreach (var kvp in dependenciesByType)
|
|
{
|
|
string type = kvp.Key;
|
|
var filesDict = kvp.Value;
|
|
|
|
if (!filterTypeToggle.TryGetValue(type, out bool showType) || !showType)
|
|
continue;
|
|
|
|
if (!typeFoldout.ContainsKey(type)) typeFoldout[type] = false;
|
|
if (!typeToggle.ContainsKey(type)) typeToggle[type] = true;
|
|
|
|
EditorGUILayout.BeginVertical("box");
|
|
|
|
EditorGUILayout.BeginHorizontal();
|
|
|
|
typeFoldout[type] = EditorGUILayout.Foldout(typeFoldout[type], $"{type} ({filesDict.Count})", true);
|
|
|
|
if (GUILayout.Button("全选", GUILayout.Width(40)))
|
|
{
|
|
typeToggle[type] = true;
|
|
foreach (var k in filesDict.Keys.ToList())
|
|
filesDict[k] = true;
|
|
}
|
|
if (GUILayout.Button("反选", GUILayout.Width(40)))
|
|
{
|
|
bool allSelected = filesDict.Values.All(v => v);
|
|
foreach (var k in filesDict.Keys.ToList())
|
|
filesDict[k] = !allSelected;
|
|
typeToggle[type] = filesDict.Values.Any(v => v);
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
bool newTypeToggle = EditorGUILayout.ToggleLeft("选择该类型全部文件", typeToggle[type]);
|
|
if (newTypeToggle != typeToggle[type])
|
|
{
|
|
typeToggle[type] = newTypeToggle;
|
|
foreach (var k in filesDict.Keys.ToList())
|
|
filesDict[k] = newTypeToggle;
|
|
}
|
|
|
|
if (typeFoldout[type])
|
|
{
|
|
EditorGUI.indentLevel++;
|
|
foreach (var fileKey in filesDict.Keys.ToList())
|
|
{
|
|
bool selected = filesDict[fileKey];
|
|
|
|
EditorGUILayout.BeginHorizontal(GUILayout.Height(22));
|
|
|
|
GUILayout.Space(6 * (EditorGUI.indentLevel - 1));
|
|
|
|
Rect toggleRect = GUILayoutUtility.GetRect(24, 22, GUILayout.Width(24));
|
|
bool newSelected = EditorGUI.Toggle(toggleRect, selected);
|
|
if (newSelected != selected)
|
|
filesDict[fileKey] = newSelected;
|
|
|
|
if (!newSelected)
|
|
GUI.enabled = false;
|
|
|
|
string fileName = Path.GetFileName(fileKey);
|
|
GUIContent fileNameContent = new GUIContent(fileName);
|
|
Vector2 fileNameSize = EditorStyles.boldLabel.CalcSize(fileNameContent);
|
|
float fileNameWidth = Mathf.Min(fileNameSize.x, 200);
|
|
|
|
GUILayout.Space(6);
|
|
|
|
Rect fileNameRect = GUILayoutUtility.GetRect(fileNameWidth, 22, GUILayout.Width(fileNameWidth));
|
|
GUI.Label(fileNameRect, fileName, EditorStyles.boldLabel);
|
|
|
|
if (Event.current.type == EventType.MouseDown && Event.current.button == 0 && fileNameRect.Contains(Event.current.mousePosition))
|
|
{
|
|
var obj = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(fileKey);
|
|
if (obj != null)
|
|
{
|
|
EditorGUIUtility.PingObject(obj);
|
|
Event.current.Use();
|
|
}
|
|
}
|
|
else if (Event.current.type == EventType.ContextClick && fileNameRect.Contains(Event.current.mousePosition))
|
|
{
|
|
Event.current.Use();
|
|
GenericMenu menu = new GenericMenu();
|
|
menu.AddItem(new GUIContent("复制资源名称"), false, () =>
|
|
{
|
|
GUIUtility.systemCopyBuffer = fileName;
|
|
});
|
|
menu.ShowAsContext();
|
|
}
|
|
|
|
GUILayout.Label(fileKey, EditorStyles.miniLabel, GUILayout.ExpandWidth(true));
|
|
|
|
if (GUILayout.Button("定位", GUILayout.Width(60)))
|
|
{
|
|
var obj = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(fileKey);
|
|
if (obj != null)
|
|
EditorGUIUtility.PingObject(obj);
|
|
}
|
|
|
|
if (!newSelected)
|
|
GUI.enabled = true;
|
|
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
if (textureUsedByMaterials.TryGetValue(fileKey, out var mats) && mats.Count > 0)
|
|
{
|
|
if (!matsFoldout.ContainsKey(fileKey)) matsFoldout[fileKey] = false;
|
|
|
|
Rect foldoutRect = GUILayoutUtility.GetRect(130, EditorGUIUtility.singleLineHeight);
|
|
matsFoldout[fileKey] = EditorGUI.Foldout(foldoutRect, matsFoldout[fileKey], $"引用于 {mats.Count} 个材质", true);
|
|
|
|
if (matsFoldout[fileKey])
|
|
{
|
|
EditorGUI.indentLevel++;
|
|
foreach (var matPath in mats)
|
|
{
|
|
Rect matRect = GUILayoutUtility.GetRect(20, 18);
|
|
GUILayout.Space(6 * (EditorGUI.indentLevel - 1));
|
|
if (GUI.Button(matRect, matPath, EditorStyles.linkLabel))
|
|
{
|
|
var matObj = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(matPath);
|
|
if (matObj != null)
|
|
EditorGUIUtility.PingObject(matObj);
|
|
}
|
|
}
|
|
EditorGUI.indentLevel--;
|
|
}
|
|
}
|
|
}
|
|
EditorGUI.indentLevel--;
|
|
}
|
|
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
EditorGUILayout.EndScrollView();
|
|
}
|
|
|
|
private void DrawSizeEstimate()
|
|
{
|
|
long totalBytes = 0;
|
|
foreach (var kvp in dependenciesByType)
|
|
{
|
|
foreach (var path in kvp.Value.Keys)
|
|
{
|
|
string absPath = Path.Combine(Application.dataPath, path.Substring("Assets/".Length));
|
|
if (File.Exists(absPath))
|
|
{
|
|
totalBytes += new FileInfo(absPath).Length;
|
|
}
|
|
}
|
|
}
|
|
EditorGUILayout.LabelField($"预估待移动资源大小: {totalBytes / 1024f / 1024f:F2} MB");
|
|
}
|
|
|
|
private void DrawTargetFolderSelector()
|
|
{
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField("目标根目录：", GUILayout.Width(80));
|
|
|
|
GUIStyle boxStyle = GUI.skin.box;
|
|
Rect dragRect = GUILayoutUtility.GetRect(EditorGUIUtility.currentViewWidth - 100, EditorGUIUtility.singleLineHeight + 6);
|
|
GUI.Box(dragRect, "", boxStyle);
|
|
|
|
GUI.Label(dragRect, string.IsNullOrEmpty(targetRootFolder) ? "<拖入目标根目录文件夹>" : targetRootFolder, EditorStyles.label);
|
|
|
|
Event evt = Event.current;
|
|
if ((evt.type == EventType.DragUpdated || evt.type == EventType.DragPerform) && dragRect.Contains(evt.mousePosition))
|
|
{
|
|
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
|
|
|
|
if (evt.type == EventType.DragPerform)
|
|
{
|
|
DragAndDrop.AcceptDrag();
|
|
|
|
if (DragAndDrop.objectReferences.Length > 0)
|
|
{
|
|
UnityEngine.Object obj = DragAndDrop.objectReferences[0];
|
|
string path = AssetDatabase.GetAssetPath(obj);
|
|
if (AssetDatabase.IsValidFolder(path))
|
|
{
|
|
targetRootFolder = path;
|
|
evt.Use();
|
|
EditorGUIUtility.ExitGUI();
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (DragAndDrop.paths != null && DragAndDrop.paths.Length > 0)
|
|
{
|
|
string firstPath = DragAndDrop.paths[0];
|
|
if (Directory.Exists(firstPath))
|
|
{
|
|
string absDataPath = Application.dataPath.Replace("/", "\\");
|
|
string absFirstPath = firstPath.Replace("/", "\\");
|
|
|
|
if (absFirstPath.StartsWith(absDataPath))
|
|
{
|
|
string relativePath = "Assets" + absFirstPath.Substring(absDataPath.Length);
|
|
targetRootFolder = relativePath.Replace("\\", "/");
|
|
evt.Use();
|
|
EditorGUIUtility.ExitGUI();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
evt.Use();
|
|
}
|
|
else
|
|
{
|
|
evt.Use();
|
|
}
|
|
}
|
|
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
|
|
private void DrawActionButtons()
|
|
{
|
|
EditorGUILayout.BeginHorizontal();
|
|
if (GUILayout.Button("整理", GUILayout.Height(30))) MoveSelectedDependencies();
|
|
if (GUILayout.Button("导出 UnityPackage", GUILayout.Height(30))) ExportPackage();
|
|
if (GUILayout.Button("撤销", GUILayout.Height(30))) ShowUndoMenu();
|
|
if (!string.IsNullOrEmpty(lastOrganizeAbsPath) && GUILayout.Button("打开生成路径", GUILayout.Height(30)))
|
|
EditorUtility.RevealInFinder(lastOrganizeAbsPath);
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
|
|
private void DrawUndoHistory()
|
|
{
|
|
if (undoManifests.Count == 0)
|
|
{
|
|
EditorGUILayout.LabelField("暂无撤销历史");
|
|
return;
|
|
}
|
|
EditorGUILayout.LabelField("撤销历史记录：");
|
|
foreach (var kvp in undoManifests.Reverse())
|
|
{
|
|
string label = DateTimeOffset.FromUnixTimeMilliseconds(kvp.Key).ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss");
|
|
EditorGUILayout.LabelField(label);
|
|
}
|
|
}
|
|
|
|
private void ShowUndoMenu()
|
|
{
|
|
if (undoManifests.Count == 0)
|
|
{
|
|
EditorUtility.DisplayDialog("提示", "没有可用的撤销记录。", "确定");
|
|
return;
|
|
}
|
|
GenericMenu menu = new GenericMenu();
|
|
foreach (var kvp in undoManifests.Reverse())
|
|
{
|
|
string label = DateTimeOffset.FromUnixTimeMilliseconds(kvp.Key).ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss");
|
|
string path = kvp.Value;
|
|
menu.AddItem(new GUIContent(label), false, () =>
|
|
{
|
|
UndoMoveAssets(path);
|
|
});
|
|
}
|
|
menu.ShowAsContext();
|
|
}
|
|
|
|
private void UndoMoveAssets(string manifestPath)
|
|
{
|
|
if (!File.Exists(manifestPath))
|
|
{
|
|
EditorUtility.DisplayDialog("错误", "撤销文件不存在。", "确定");
|
|
RemoveManifestByPath(manifestPath);
|
|
return;
|
|
}
|
|
|
|
string json = File.ReadAllText(manifestPath);
|
|
var manifest = JsonUtility.FromJson<MoveManifest>(json);
|
|
if (manifest == null || manifest.entries == null)
|
|
{
|
|
EditorUtility.DisplayDialog("错误", "撤销文件格式错误。", "确定");
|
|
return;
|
|
}
|
|
|
|
AssetDatabase.StartAssetEditing();
|
|
try
|
|
{
|
|
foreach (var e in manifest.entries.Reverse())
|
|
{
|
|
if (AssetDatabase.MoveAsset(e.destPath, e.originalPath).Length == 0)
|
|
Debug.Log($"已恢复 {e.destPath}");
|
|
else
|
|
Debug.LogWarning($"恢复失败或路径冲突: {e.destPath}");
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
AssetDatabase.StopAssetEditing();
|
|
AssetDatabase.Refresh();
|
|
}
|
|
File.Delete(manifestPath);
|
|
RemoveManifestByPath(manifestPath);
|
|
EditorUtility.DisplayDialog("撤销完成", "资源已恢复。", "确定");
|
|
}
|
|
|
|
private void RemoveManifestByPath(string manifestPath)
|
|
{
|
|
var keysToRemove = undoManifests.Where(kvp => kvp.Value == manifestPath).Select(kvp => kvp.Key).ToList();
|
|
foreach (var key in keysToRemove)
|
|
undoManifests.Remove(key);
|
|
}
|
|
|
|
private void LoadUndoManifests()
|
|
{
|
|
undoManifests.Clear();
|
|
if (!AssetDatabase.IsValidFolder(UndoManifestDir))
|
|
return;
|
|
|
|
string fullDir = Path.Combine(Application.dataPath, "Editor/DependencyOrganizerUndo");
|
|
if (!Directory.Exists(fullDir))
|
|
return;
|
|
|
|
foreach (var file in Directory.GetFiles(fullDir, UndoManifestPrefix + "*.json"))
|
|
{
|
|
try
|
|
{
|
|
string fileName = Path.GetFileNameWithoutExtension(file);
|
|
string timestampStr = fileName.Substring(UndoManifestPrefix.Length);
|
|
if (long.TryParse(timestampStr, out long ts))
|
|
undoManifests[ts] = file;
|
|
}
|
|
catch { }
|
|
}
|
|
}
|
|
|
|
private void MoveSelectedDependencies()
|
|
{
|
|
if (draggedAssets.Count == 0)
|
|
{
|
|
EditorUtility.DisplayDialog("提示", "请先拖入至少一个资源。", "确定");
|
|
return;
|
|
}
|
|
if (dependenciesByType.Count == 0)
|
|
{
|
|
EditorUtility.DisplayDialog("提示", "请先收集依赖资源。", "确定");
|
|
return;
|
|
}
|
|
|
|
if (!AssetDatabase.IsValidFolder(UndoManifestDir))
|
|
AssetDatabase.CreateFolder("Assets/Editor", "DependencyOrganizerUndo");
|
|
|
|
long timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
|
|
string manifestFile = $"{UndoManifestDir}/{UndoManifestPrefix}{timestamp}.json";
|
|
|
|
List<MoveEntry> moves = new List<MoveEntry>();
|
|
List<(string originalPath, string destPath)> movesToDo = new List<(string, string)>();
|
|
|
|
AssetDatabase.StartAssetEditing();
|
|
try
|
|
{
|
|
foreach (var obj in draggedAssets)
|
|
{
|
|
string origPath = AssetDatabase.GetAssetPath(obj);
|
|
string root;
|
|
if (!string.IsNullOrEmpty(targetRootFolder) && AssetDatabase.IsValidFolder(targetRootFolder))
|
|
{
|
|
root = targetRootFolder;
|
|
}
|
|
else
|
|
{
|
|
string exportBase = "Assets/export";
|
|
if (!AssetDatabase.IsValidFolder(exportBase))
|
|
AssetDatabase.CreateFolder("Assets", "export");
|
|
string name = Path.GetFileNameWithoutExtension(origPath);
|
|
root = $"{exportBase}/{name}";
|
|
if (!AssetDatabase.IsValidFolder(root))
|
|
AssetDatabase.CreateFolder(exportBase, name);
|
|
}
|
|
lastOrganizeAbsPath = Path.GetFullPath(root);
|
|
|
|
var deps = AssetDatabase.GetDependencies(origPath, true);
|
|
|
|
foreach (var dep in deps)
|
|
{
|
|
if (!dep.StartsWith("Assets/") || dep.StartsWith("Assets/Editor/") || dep.Contains("Packages/"))
|
|
continue;
|
|
if (movesToDo.Any(m => m.destPath == dep) || dep.StartsWith(root + "/"))
|
|
continue;
|
|
|
|
Type type = AssetDatabase.GetMainAssetTypeAtPath(dep);
|
|
string folder = GetTargetFolder(type, dep);
|
|
|
|
if (!dependenciesByType.TryGetValue(folder, out var filesDict))
|
|
continue;
|
|
if (!filesDict.TryGetValue(dep, out bool moveThis) || !moveThis)
|
|
continue;
|
|
|
|
string dstDir = $"{root}/{folder}";
|
|
if (!AssetDatabase.IsValidFolder(dstDir))
|
|
AssetDatabase.CreateFolder(root, folder);
|
|
|
|
string dst = GetUniqueAssetPath($"{dstDir}/{Path.GetFileName(dep)}");
|
|
movesToDo.Add((dep, dst));
|
|
}
|
|
}
|
|
|
|
int total = movesToDo.Count;
|
|
for (int i = 0; i < total; i++)
|
|
{
|
|
var (src, dst) = movesToDo[i];
|
|
EditorUtility.DisplayProgressBar("移动资源", $"正在移动 {Path.GetFileName(src)} ({i + 1}/{total})", (float)i / total);
|
|
string err = AssetDatabase.MoveAsset(src, dst);
|
|
if (string.IsNullOrEmpty(err))
|
|
moves.Add(new MoveEntry(src, dst));
|
|
else
|
|
Debug.LogWarning($"移动失败: {src} -> {dst}，错误：{err}");
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
EditorUtility.ClearProgressBar();
|
|
AssetDatabase.StopAssetEditing();
|
|
AssetDatabase.Refresh();
|
|
}
|
|
|
|
File.WriteAllText(manifestFile, JsonUtility.ToJson(new MoveManifest { entries = moves.ToArray() }, true));
|
|
AssetDatabase.ImportAsset(manifestFile);
|
|
LoadUndoManifests();
|
|
|
|
EditorUtility.DisplayDialog("整理完成", $"共移动 {moves.Count} 个资源，存放于 {(!string.IsNullOrEmpty(targetRootFolder) ? targetRootFolder : "Assets/export")}", "确定");
|
|
}
|
|
|
|
private string GetTargetFolder(Type type, string path)
|
|
{
|
|
string ext = Path.GetExtension(path).ToLowerInvariant();
|
|
if (new[] { ".cs" }.Contains(ext)) return "Scripts";
|
|
if (new[] { ".fbx", ".obj", ".blend" }.Contains(ext)) return "Models";
|
|
if (new[] { ".anim" }.Contains(ext) || type == typeof(AnimationClip)) return "Animations";
|
|
if (new[] { ".controller" }.Contains(ext) || type == typeof(UnityEditor.Animations.AnimatorController)) return "Animators";
|
|
if (new[] { ".shader", ".shadergraph" }.Contains(ext) || type == typeof(Shader)) return "Shaders";
|
|
if (new[] { ".png", ".jpg", ".jpeg", ".tga", ".psd", ".exr" }.Contains(ext) || type == typeof(Texture2D)) return "Textures";
|
|
if (new[] { ".wav", ".mp3", ".ogg" }.Contains(ext) || type == typeof(AudioClip)) return "Audio";
|
|
if (ext == ".mat" || type == typeof(Material)) return "Materials";
|
|
if (ext == ".physicmaterial" || type == typeof(PhysicMaterial)) return "Physics";
|
|
if (ext == ".prefab" || type == typeof(GameObject)) return "Prefabs";
|
|
return "Others";
|
|
}
|
|
|
|
private string GetUniqueAssetPath(string desiredPath)
|
|
{
|
|
string path = desiredPath;
|
|
string dir = Path.GetDirectoryName(desiredPath);
|
|
string filename = Path.GetFileNameWithoutExtension(desiredPath);
|
|
string ext = Path.GetExtension(desiredPath);
|
|
int count = 1;
|
|
|
|
while (AssetPathExists(path))
|
|
{
|
|
path = $"{dir}/{filename}_{count}{ext}";
|
|
count++;
|
|
}
|
|
return path;
|
|
}
|
|
|
|
private bool AssetPathExists(string path)
|
|
{
|
|
return AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(path) != null;
|
|
}
|
|
|
|
private void ExportPackage()
|
|
{
|
|
string exportRel = !string.IsNullOrEmpty(targetRootFolder) && AssetDatabase.IsValidFolder(targetRootFolder)
|
|
? targetRootFolder : "Assets/export";
|
|
if (!AssetDatabase.IsValidFolder(exportRel))
|
|
{
|
|
EditorUtility.DisplayDialog("错误", $"导出目录无效：{exportRel}", "确定");
|
|
return;
|
|
}
|
|
var guids = AssetDatabase.FindAssets("", new[] { exportRel });
|
|
var paths = guids.Select(AssetDatabase.GUIDToAssetPath).ToArray();
|
|
string save = EditorUtility.SaveFilePanel("保存 UnityPackage", Application.dataPath, "Package.unitypackage", "unitypackage");
|
|
if (string.IsNullOrEmpty(save)) return;
|
|
AssetDatabase.ExportPackage(paths, save, ExportPackageOptions.Default);
|
|
EditorUtility.DisplayDialog("导出成功", $"已导出 {paths.Length} 个资源到 {save}", "确定");
|
|
}
|
|
|
|
[Serializable]
|
|
private class MoveEntry
|
|
{
|
|
public string originalPath;
|
|
public string destPath;
|
|
public MoveEntry(string o, string d) { originalPath = o; destPath = d; }
|
|
}
|
|
|
|
[Serializable]
|
|
private class MoveManifest
|
|
{
|
|
public MoveEntry[] entries;
|
|
}
|
|
}
|