745 lines
31 KiB
C#
745 lines
31 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using UnityEditor;
|
||
using UnityEngine;
|
||
|
||
namespace AibisDream.FrameAnimation.Editor
|
||
{
|
||
internal enum FrameAnimationEditorSelectionKind
|
||
{
|
||
None,
|
||
Graph,
|
||
Clip,
|
||
Flow,
|
||
Source,
|
||
Node,
|
||
Edge
|
||
}
|
||
|
||
internal readonly struct FrameAnimationEditorSelection
|
||
{
|
||
public FrameAnimationEditorSelectionKind Kind { get; }
|
||
public object Value { get; }
|
||
|
||
public FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind kind, object value)
|
||
{
|
||
Kind = kind;
|
||
Value = value;
|
||
}
|
||
}
|
||
|
||
internal enum FrameAnimationClipFilter
|
||
{
|
||
All,
|
||
Manual,
|
||
Imported,
|
||
Normal,
|
||
Missing,
|
||
Referenced,
|
||
Unused
|
||
}
|
||
|
||
internal enum FrameAnimationClipSort
|
||
{
|
||
Name,
|
||
Source,
|
||
FrameCount,
|
||
Duration,
|
||
Missing,
|
||
ReferenceCount
|
||
}
|
||
|
||
internal static class FrameAnimationAssetReferenceIndex
|
||
{
|
||
public static IReadOnlyList<FrameAnimationGraph> FindGraphsReferencing(FrameClip clip)
|
||
{
|
||
if (clip == null)
|
||
{
|
||
return Array.Empty<FrameAnimationGraph>();
|
||
}
|
||
|
||
return AssetDatabase.FindAssets("t:FrameAnimationGraph")
|
||
.Select(guid => AssetDatabase.LoadAssetAtPath<FrameAnimationGraph>(AssetDatabase.GUIDToAssetPath(guid)))
|
||
.Where(graph => graph != null && graph.Clips.Any(item => item == clip))
|
||
.Distinct()
|
||
.OrderBy(graph => AssetDatabase.GetAssetPath(graph), StringComparer.Ordinal)
|
||
.ToArray();
|
||
}
|
||
}
|
||
|
||
internal static class FrameAnimationResourceQuery
|
||
{
|
||
public static IReadOnlyList<FrameClip> QueryClips(
|
||
FrameAnimationGraph graph,
|
||
string search,
|
||
FrameAnimationClipFilter filter,
|
||
FrameAnimationClipSort sort)
|
||
{
|
||
if (graph == null)
|
||
{
|
||
return Array.Empty<FrameClip>();
|
||
}
|
||
|
||
var sourceNames = graph.ImportSources.Where(source => source != null)
|
||
.GroupBy(source => source.InternalId ?? string.Empty)
|
||
.ToDictionary(group => group.Key, group => group.First().DisplayName ?? string.Empty);
|
||
var query = graph.Clips.Where(clip => clip != null && MatchesSearch(clip, sourceNames, search));
|
||
query = filter switch
|
||
{
|
||
FrameAnimationClipFilter.Manual => query.Where(clip => !clip.IsImported),
|
||
FrameAnimationClipFilter.Imported => query.Where(clip => clip.IsImported),
|
||
FrameAnimationClipFilter.Normal => query.Where(clip => !clip.IsImported || !clip.ImportInfo.IsMissingFromSource),
|
||
FrameAnimationClipFilter.Missing => query.Where(clip => clip.IsImported && clip.ImportInfo.IsMissingFromSource),
|
||
FrameAnimationClipFilter.Referenced => query.Where(clip => ReferenceCount(graph, clip) > 0),
|
||
FrameAnimationClipFilter.Unused => query.Where(clip => ReferenceCount(graph, clip) == 0),
|
||
_ => query
|
||
};
|
||
|
||
IOrderedEnumerable<FrameClip> ordered = sort switch
|
||
{
|
||
FrameAnimationClipSort.Source => query.OrderBy(clip => SourceName(clip, sourceNames), StringComparer.Ordinal),
|
||
FrameAnimationClipSort.FrameCount => query.OrderBy(clip => clip.FrameCount),
|
||
FrameAnimationClipSort.Duration => query.OrderBy(clip => clip.TotalDurationMs),
|
||
FrameAnimationClipSort.Missing => query.OrderBy(clip => clip.IsImported && clip.ImportInfo.IsMissingFromSource ? 1 : 0),
|
||
FrameAnimationClipSort.ReferenceCount => query.OrderBy(clip => ReferenceCount(graph, clip)),
|
||
_ => query.OrderBy(clip => clip.DisplayName ?? clip.Id, StringComparer.Ordinal)
|
||
};
|
||
return ordered.ThenBy(clip => clip.Id, StringComparer.Ordinal)
|
||
.ThenBy(clip => AssetDatabase.GetAssetPath(clip), StringComparer.Ordinal)
|
||
.ToArray();
|
||
}
|
||
|
||
public static int ReferenceCount(FrameAnimationGraph graph, FrameClip clip)
|
||
{
|
||
return graph?.Nodes.Count(node => node != null && node.ClipId == clip?.Id) ?? 0;
|
||
}
|
||
|
||
public static string SourceName(
|
||
FrameClip clip,
|
||
IReadOnlyDictionary<string, string> sourceNames = null)
|
||
{
|
||
if (clip == null || !clip.IsImported)
|
||
{
|
||
return clip != null && clip.HasStandaloneImportSource ? "Standalone Source" : "Manual";
|
||
}
|
||
var sourceId = clip.ImportInfo?.ImportSourceId;
|
||
if (sourceNames != null && !string.IsNullOrEmpty(sourceId) &&
|
||
sourceNames.TryGetValue(sourceId, out var name))
|
||
{
|
||
return name;
|
||
}
|
||
return sourceId ?? string.Empty;
|
||
}
|
||
|
||
private static bool MatchesSearch(
|
||
FrameClip clip,
|
||
IReadOnlyDictionary<string, string> sourceNames,
|
||
string search)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(search))
|
||
{
|
||
return true;
|
||
}
|
||
return Contains(clip.Id, search) || Contains(clip.DisplayName, search) ||
|
||
Contains(clip.ImportInfo?.SourceTagName, search) ||
|
||
Contains(SourceName(clip, sourceNames), search);
|
||
}
|
||
|
||
private static bool Contains(string value, string search)
|
||
{
|
||
return !string.IsNullOrEmpty(value) && value.IndexOf(search, StringComparison.OrdinalIgnoreCase) >= 0;
|
||
}
|
||
}
|
||
|
||
internal static class FrameAnimationAssetOperations
|
||
{
|
||
public static bool IsPlayableIdAvailable(
|
||
FrameAnimationGraph graph,
|
||
string id,
|
||
FrameClip exceptClip = null,
|
||
AnimationFlow exceptFlow = null)
|
||
{
|
||
return graph != null && !string.IsNullOrWhiteSpace(id) &&
|
||
graph.Clips.All(clip => clip == null || clip == exceptClip || clip.Id != id) &&
|
||
graph.Flows.All(flow => flow == null || flow == exceptFlow || flow.Id != id);
|
||
}
|
||
|
||
public static bool CreateManualClip(
|
||
FrameAnimationGraph graph,
|
||
string id,
|
||
string displayName,
|
||
string externalPath,
|
||
out FrameClip clip,
|
||
out string error)
|
||
{
|
||
clip = null;
|
||
error = string.Empty;
|
||
if (!IsPlayableIdAvailable(graph, id))
|
||
{
|
||
error = "Clip id 为空或与现有 Clip / Flow 冲突。";
|
||
return false;
|
||
}
|
||
|
||
Undo.IncrementCurrentGroup();
|
||
var group = Undo.GetCurrentGroup();
|
||
Undo.SetCurrentGroupName("Create Manual Frame Clip");
|
||
try
|
||
{
|
||
Undo.RecordObject(graph, "Add Manual Frame Clip");
|
||
clip = ScriptableObject.CreateInstance<FrameClip>();
|
||
clip.name = id;
|
||
clip.Configure(id, string.IsNullOrWhiteSpace(displayName) ? id : displayName,
|
||
Array.Empty<FrameAnimationFrame>(), 1f,
|
||
graph.Settings.NewManualClipDefaultEndBehavior);
|
||
if (string.IsNullOrWhiteSpace(externalPath))
|
||
{
|
||
AssetDatabase.AddObjectToAsset(clip, graph);
|
||
}
|
||
else
|
||
{
|
||
AssetDatabase.CreateAsset(clip, externalPath);
|
||
}
|
||
Undo.RegisterCreatedObjectUndo(clip, "Create Manual Frame Clip");
|
||
graph.AddClip(clip);
|
||
EditorUtility.SetDirty(graph);
|
||
EditorUtility.SetDirty(clip);
|
||
AssetDatabase.SaveAssets();
|
||
Undo.CollapseUndoOperations(group);
|
||
return true;
|
||
}
|
||
catch (Exception exception)
|
||
{
|
||
Undo.RevertAllDownToGroup(group);
|
||
clip = null;
|
||
error = exception.Message;
|
||
return false;
|
||
}
|
||
}
|
||
|
||
public static bool AddExistingManualClip(
|
||
FrameAnimationGraph graph,
|
||
FrameClip clip,
|
||
out string error)
|
||
{
|
||
error = string.Empty;
|
||
if (graph == null || clip == null)
|
||
{
|
||
error = "Graph 或 Clip 为空。";
|
||
return false;
|
||
}
|
||
if (clip.IsImported || AssetDatabase.IsSubAsset(clip) ||
|
||
string.IsNullOrEmpty(AssetDatabase.GetAssetPath(clip)))
|
||
{
|
||
error = "只能添加独立 .asset 形式、且不由 Graph ImportSource 管理的 Clip。";
|
||
return false;
|
||
}
|
||
if (graph.Clips.Contains(clip))
|
||
{
|
||
error = "当前 Graph 已引用该 Clip。";
|
||
return false;
|
||
}
|
||
if (!IsPlayableIdAvailable(graph, clip.Id))
|
||
{
|
||
error = $"playable id '{clip.Id}' 与当前 Graph 中的 Clip / Flow 冲突。";
|
||
return false;
|
||
}
|
||
|
||
Undo.RecordObject(graph, "Add Existing Manual Frame Clip");
|
||
graph.AddClip(clip);
|
||
EditorUtility.SetDirty(graph);
|
||
return true;
|
||
}
|
||
|
||
public static bool CopyToManual(
|
||
FrameAnimationGraph graph,
|
||
FrameClip source,
|
||
string id,
|
||
string displayName,
|
||
string externalPath,
|
||
out FrameClip copy,
|
||
out string error)
|
||
{
|
||
copy = null;
|
||
error = string.Empty;
|
||
if (source == null || !IsPlayableIdAvailable(graph, id))
|
||
{
|
||
error = "来源为空，或新 id 与现有 Clip / Flow 冲突。";
|
||
return false;
|
||
}
|
||
|
||
Undo.IncrementCurrentGroup();
|
||
var group = Undo.GetCurrentGroup();
|
||
Undo.SetCurrentGroupName("Copy Frame Clip As Manual");
|
||
try
|
||
{
|
||
Undo.RecordObject(graph, "Add Manual Frame Clip Copy");
|
||
copy = ScriptableObject.CreateInstance<FrameClip>();
|
||
copy.name = id;
|
||
copy.Configure(id,
|
||
string.IsNullOrWhiteSpace(displayName) ? source.DisplayName : displayName,
|
||
source.Frames.Select(frame => frame == null
|
||
? null
|
||
: new FrameAnimationFrame(frame.Sprite, frame.DurationMs, frame.FrameName, frame.SourceIndex)),
|
||
source.Speed,
|
||
source.DefaultEndBehavior);
|
||
if (string.IsNullOrWhiteSpace(externalPath))
|
||
{
|
||
AssetDatabase.AddObjectToAsset(copy, graph);
|
||
}
|
||
else
|
||
{
|
||
AssetDatabase.CreateAsset(copy, externalPath);
|
||
}
|
||
Undo.RegisterCreatedObjectUndo(copy, "Create Manual Frame Clip Copy");
|
||
graph.AddClip(copy);
|
||
EditorUtility.SetDirty(graph);
|
||
EditorUtility.SetDirty(copy);
|
||
AssetDatabase.SaveAssets();
|
||
Undo.CollapseUndoOperations(group);
|
||
return true;
|
||
}
|
||
catch (Exception exception)
|
||
{
|
||
Undo.RevertAllDownToGroup(group);
|
||
copy = null;
|
||
error = exception.Message;
|
||
return false;
|
||
}
|
||
}
|
||
|
||
public static bool RenameClip(
|
||
FrameAnimationGraph graph,
|
||
FrameClip clip,
|
||
string newId,
|
||
out string error)
|
||
{
|
||
error = string.Empty;
|
||
if (graph == null || clip == null || !graph.Clips.Contains(clip))
|
||
{
|
||
error = "Clip 不属于当前 Graph。";
|
||
return false;
|
||
}
|
||
var owners = FrameAnimationAssetReferenceIndex.FindGraphsReferencing(clip);
|
||
if (!AssetDatabase.IsSubAsset(clip) && owners.Count > 1)
|
||
{
|
||
error = "外部 Manual Clip 被多个 Graph 共享，禁止重命名：" +
|
||
string.Join(", ", owners.Select(owner => owner.name));
|
||
return false;
|
||
}
|
||
if (!IsPlayableIdAvailable(graph, newId, clip))
|
||
{
|
||
error = "新 id 为空或与现有 Clip / Flow 冲突。";
|
||
return false;
|
||
}
|
||
|
||
var oldId = clip.Id;
|
||
Undo.IncrementCurrentGroup();
|
||
var group = Undo.GetCurrentGroup();
|
||
Undo.SetCurrentGroupName("Rename Frame Clip");
|
||
Undo.RecordObject(graph, "Update Frame Clip References");
|
||
Undo.RecordObject(clip, "Rename Frame Clip");
|
||
clip.SetId(newId);
|
||
foreach (var node in graph.Nodes.Where(node => node != null && node.ClipId == oldId))
|
||
{
|
||
node.SetClipId(newId);
|
||
}
|
||
if (graph.Settings.DefaultPlayableId == oldId)
|
||
{
|
||
graph.Settings.SetDefaultPlayableId(newId);
|
||
}
|
||
EditorUtility.SetDirty(graph);
|
||
EditorUtility.SetDirty(clip);
|
||
Undo.CollapseUndoOperations(group);
|
||
return true;
|
||
}
|
||
|
||
public static bool RenameFlow(
|
||
FrameAnimationGraph graph,
|
||
AnimationFlow flow,
|
||
string newId,
|
||
out string error)
|
||
{
|
||
error = string.Empty;
|
||
if (graph == null || flow == null || !graph.Flows.Contains(flow) ||
|
||
!IsPlayableIdAvailable(graph, newId, exceptFlow: flow))
|
||
{
|
||
error = "Flow 不属于当前 Graph，或新 id 与现有 Clip / Flow 冲突。";
|
||
return false;
|
||
}
|
||
|
||
var oldId = flow.Id;
|
||
Undo.RecordObject(graph, "Rename Animation Flow");
|
||
flow.SetId(newId);
|
||
if (graph.Settings.DefaultPlayableId == oldId)
|
||
{
|
||
graph.Settings.SetDefaultPlayableId(newId);
|
||
}
|
||
foreach (var data in graph.EditorData.FlowEditorData.Where(data => data != null && data.FlowId == oldId))
|
||
{
|
||
data.SetFlowId(newId);
|
||
}
|
||
EditorUtility.SetDirty(graph);
|
||
return true;
|
||
}
|
||
|
||
public static bool RenameGraph(FrameAnimationGraph graph, string newId, out string error)
|
||
{
|
||
error = string.Empty;
|
||
if (graph == null || string.IsNullOrWhiteSpace(newId))
|
||
{
|
||
error = "Graph id 不能为空。";
|
||
return false;
|
||
}
|
||
Undo.RecordObject(graph, "Rename Frame Animation Graph");
|
||
graph.SetId(newId);
|
||
EditorUtility.SetDirty(graph);
|
||
return true;
|
||
}
|
||
|
||
public static bool RemoveClip(FrameAnimationGraph graph, FrameClip clip, out string error)
|
||
{
|
||
if (!CanRemoveClip(graph, clip, out error))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
Undo.IncrementCurrentGroup();
|
||
var group = Undo.GetCurrentGroup();
|
||
Undo.SetCurrentGroupName("Remove Frame Clip");
|
||
Undo.RecordObject(graph, "Remove Frame Clip Reference");
|
||
graph.RemoveClip(clip);
|
||
if (AssetDatabase.IsSubAsset(clip) && AssetDatabase.GetAssetPath(clip) == AssetDatabase.GetAssetPath(graph))
|
||
{
|
||
Undo.DestroyObjectImmediate(clip);
|
||
}
|
||
EditorUtility.SetDirty(graph);
|
||
AssetDatabase.SaveAssets();
|
||
Undo.CollapseUndoOperations(group);
|
||
return true;
|
||
}
|
||
|
||
public static bool CanRemoveClip(FrameAnimationGraph graph, FrameClip clip, out string error)
|
||
{
|
||
error = string.Empty;
|
||
if (graph == null || clip == null || !graph.Clips.Contains(clip))
|
||
{
|
||
error = "Clip 不属于当前 Graph。";
|
||
return false;
|
||
}
|
||
var nodeCount = graph.Nodes.Count(node => node != null && node.ClipId == clip.Id);
|
||
if (nodeCount > 0)
|
||
{
|
||
error = $"Clip 仍被 {nodeCount} 个 AnimationNode 引用。";
|
||
return false;
|
||
}
|
||
if (graph.Settings.DefaultPlayableId == clip.Id)
|
||
{
|
||
error = "Clip 仍被 defaultPlayableId 引用。";
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
public static bool RemoveFlow(FrameAnimationGraph graph, AnimationFlow flow, out string error)
|
||
{
|
||
if (!CanRemoveFlow(graph, flow, out error))
|
||
{
|
||
return false;
|
||
}
|
||
Undo.RecordObject(graph, "Remove Animation Flow");
|
||
graph.RemoveFlow(flow);
|
||
graph.EditorData.RemoveFlowData(flow.Id);
|
||
EditorUtility.SetDirty(graph);
|
||
return true;
|
||
}
|
||
|
||
public static bool CanRemoveFlow(FrameAnimationGraph graph, AnimationFlow flow, out string error)
|
||
{
|
||
error = string.Empty;
|
||
if (graph == null || flow == null || !graph.Flows.Contains(flow))
|
||
{
|
||
error = "Flow 不属于当前 Graph。";
|
||
return false;
|
||
}
|
||
if (graph.Settings.DefaultPlayableId == flow.Id)
|
||
{
|
||
error = "Flow 仍被 defaultPlayableId 引用。";
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
public static bool RemoveSource(
|
||
FrameAnimationGraph graph,
|
||
FrameAnimationImportSource source,
|
||
out string error)
|
||
{
|
||
error = string.Empty;
|
||
if (graph == null || source == null || !graph.ImportSources.Contains(source))
|
||
{
|
||
error = "ImportSource 不属于当前 Graph。";
|
||
return false;
|
||
}
|
||
var clips = graph.Clips.Where(clip => clip != null &&
|
||
clip.ImportInfo?.ImportSourceId == source.InternalId).ToArray();
|
||
if (clips.Length > 0)
|
||
{
|
||
error = "ImportSource 仍关联 Imported Clip：" + string.Join(", ", clips.Select(clip => clip.Id));
|
||
return false;
|
||
}
|
||
Undo.RecordObject(graph, "Remove Frame Animation ImportSource");
|
||
graph.RemoveImportSource(source);
|
||
EditorUtility.SetDirty(graph);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
internal sealed class FrameAnimationEditorIssue
|
||
{
|
||
public FrameAnimationValidationSeverity Severity { get; }
|
||
public string Code { get; }
|
||
public FrameAnimationEditorSelection Selection { get; }
|
||
public string Message { get; }
|
||
public string Suggestion { get; }
|
||
|
||
public FrameAnimationEditorIssue(
|
||
FrameAnimationValidationSeverity severity,
|
||
string code,
|
||
FrameAnimationEditorSelection selection,
|
||
string message,
|
||
string suggestion)
|
||
{
|
||
Severity = severity;
|
||
Code = code ?? string.Empty;
|
||
Selection = selection;
|
||
Message = message ?? string.Empty;
|
||
Suggestion = suggestion ?? string.Empty;
|
||
}
|
||
}
|
||
|
||
internal static class FrameAnimationEditorValidationService
|
||
{
|
||
public static IReadOnlyList<FrameAnimationEditorIssue> Validate(
|
||
FrameAnimationGraph graph,
|
||
bool includeImports,
|
||
out FrameAnimationImportPreview importPreview)
|
||
{
|
||
importPreview = null;
|
||
if (graph == null)
|
||
{
|
||
return Array.Empty<FrameAnimationEditorIssue>();
|
||
}
|
||
|
||
var issues = FrameAnimationGraphValidator.Validate(graph).Issues
|
||
.Select(issue => new FrameAnimationEditorIssue(
|
||
issue.Severity,
|
||
issue.Code.ToString(),
|
||
Locate(graph, issue.TargetType, issue.TargetId),
|
||
issue.Message,
|
||
Suggestion(issue.Code)))
|
||
.ToList();
|
||
|
||
foreach (var duplicate in graph.Clips.Where(clip => clip != null)
|
||
.GroupBy(clip => clip).Where(group => group.Count() > 1))
|
||
{
|
||
issues.Add(new FrameAnimationEditorIssue(
|
||
FrameAnimationValidationSeverity.Error,
|
||
"DuplicateClipReference",
|
||
new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Clip, duplicate.Key),
|
||
$"Graph 重复引用 Clip '{duplicate.Key.Id}'。",
|
||
"移除重复的 Clip 引用。"));
|
||
}
|
||
|
||
var graphPath = AssetDatabase.GetAssetPath(graph);
|
||
foreach (var clip in graph.Clips.Where(clip => clip != null))
|
||
{
|
||
if (AssetDatabase.IsSubAsset(clip) && AssetDatabase.GetAssetPath(clip) != graphPath)
|
||
{
|
||
issues.Add(new FrameAnimationEditorIssue(
|
||
FrameAnimationValidationSeverity.Error,
|
||
"ForeignSubAssetClip",
|
||
new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Clip, clip),
|
||
$"Clip '{clip.Id}' 是其他资产的 sub-asset。",
|
||
"移除该引用，并复制为当前 Graph 的 Manual Clip。"));
|
||
}
|
||
if (clip.IsImported && (!AssetDatabase.IsSubAsset(clip) || AssetDatabase.GetAssetPath(clip) != graphPath))
|
||
{
|
||
issues.Add(new FrameAnimationEditorIssue(
|
||
FrameAnimationValidationSeverity.Error,
|
||
"ImportedClipOwnership",
|
||
new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Clip, clip),
|
||
$"Imported Clip '{clip.Id}' 不是当前 Graph 的 sub-asset。",
|
||
"删除非法引用并从对应 ImportSource 重新刷新。"));
|
||
}
|
||
}
|
||
|
||
foreach (var node in graph.Nodes.Where(node => node != null))
|
||
{
|
||
var clip = graph.Clips.SingleOrDefault(item => item != null && item.Id == node.ClipId);
|
||
if (clip?.ImportInfo?.IsMissingFromSource == true)
|
||
{
|
||
issues.Add(new FrameAnimationEditorIssue(
|
||
FrameAnimationValidationSeverity.Error,
|
||
"NodeReferencesMissingClip",
|
||
new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Node, node),
|
||
$"Node '{node.InternalId}' 引用了 Missing Clip '{clip.Id}'。",
|
||
"恢复源 Tag、修改节点引用或删除该节点。"));
|
||
}
|
||
}
|
||
|
||
var nodeIds = new HashSet<string>(graph.Nodes.Where(node => node != null)
|
||
.Select(node => node.InternalId));
|
||
foreach (var node in graph.Nodes.Where(node => node != null &&
|
||
graph.EditorData.NodeEditorData.All(data => data == null || data.NodeId != node.InternalId)))
|
||
{
|
||
issues.Add(new FrameAnimationEditorIssue(
|
||
FrameAnimationValidationSeverity.Warning,
|
||
"EditorDataMissing",
|
||
new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Node, node),
|
||
$"Node '{node.InternalId}' 缺少画布位置数据。",
|
||
"打开 Graph Editor 初始化位置，或执行自动布局。"));
|
||
}
|
||
foreach (var data in graph.EditorData.NodeEditorData.Where(data => data != null &&
|
||
!nodeIds.Contains(data.NodeId)))
|
||
{
|
||
issues.Add(new FrameAnimationEditorIssue(
|
||
FrameAnimationValidationSeverity.Warning,
|
||
"EditorDataOrphan",
|
||
new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Graph, graph),
|
||
$"存在孤立的 NodeEditorData '{data.NodeId}'。",
|
||
"该数据不会影响运行时；确认无引用后可由后续维护工具清理。"));
|
||
}
|
||
foreach (var duplicate in graph.EditorData.NodeEditorData.Where(data => data != null)
|
||
.GroupBy(data => data.NodeId).Where(group => group.Count() > 1))
|
||
{
|
||
issues.Add(new FrameAnimationEditorIssue(
|
||
FrameAnimationValidationSeverity.Error,
|
||
"EditorDataDuplicate",
|
||
new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Graph, graph),
|
||
$"NodeEditorData '{duplicate.Key}' 重复。",
|
||
"保留一条对应位置数据并移除重复项。"));
|
||
}
|
||
|
||
var flowIds = new HashSet<string>(graph.Flows.Where(flow => flow != null).Select(flow => flow.Id));
|
||
foreach (var flow in graph.Flows.Where(flow => flow != null &&
|
||
graph.EditorData.FlowEditorData.All(data => data == null || data.FlowId != flow.Id)))
|
||
{
|
||
issues.Add(new FrameAnimationEditorIssue(
|
||
FrameAnimationValidationSeverity.Warning,
|
||
"FlowEditorDataMissing",
|
||
new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Flow, flow),
|
||
$"Flow '{flow.Id}' 缺少画布颜色数据。",
|
||
"打开 Graph Editor 初始化 Flow 颜色。"));
|
||
}
|
||
foreach (var data in graph.EditorData.FlowEditorData.Where(data => data != null &&
|
||
!flowIds.Contains(data.FlowId)))
|
||
{
|
||
issues.Add(new FrameAnimationEditorIssue(
|
||
FrameAnimationValidationSeverity.Warning,
|
||
"FlowEditorDataOrphan",
|
||
new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Graph, graph),
|
||
$"存在孤立的 FlowEditorData '{data.FlowId}'。",
|
||
"确认 Flow 已删除后可由后续维护工具清理。"));
|
||
}
|
||
foreach (var duplicate in graph.EditorData.FlowEditorData.Where(data => data != null)
|
||
.GroupBy(data => data.FlowId).Where(group => group.Count() > 1))
|
||
{
|
||
issues.Add(new FrameAnimationEditorIssue(
|
||
FrameAnimationValidationSeverity.Error,
|
||
"FlowEditorDataDuplicate",
|
||
new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Graph, graph),
|
||
$"FlowEditorData '{duplicate.Key}' 重复。",
|
||
"保留一条对应颜色数据并移除重复项。"));
|
||
}
|
||
|
||
if (!includeImports)
|
||
{
|
||
return issues;
|
||
}
|
||
|
||
importPreview = FrameAnimationImportService.PreviewAll(graph);
|
||
foreach (var sourcePreview in importPreview.Sources)
|
||
{
|
||
foreach (var importIssue in sourcePreview.Issues)
|
||
{
|
||
issues.Add(new FrameAnimationEditorIssue(
|
||
importIssue.Severity,
|
||
importIssue.Code.ToString(),
|
||
new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Source, sourcePreview.Source),
|
||
importIssue.Message,
|
||
"打开对应 ImportSource，修复来源设置后重新 Preview。"));
|
||
}
|
||
}
|
||
return issues;
|
||
}
|
||
|
||
private static FrameAnimationEditorSelection Locate(
|
||
FrameAnimationGraph graph,
|
||
FrameAnimationValidationTargetType type,
|
||
string id)
|
||
{
|
||
return type switch
|
||
{
|
||
FrameAnimationValidationTargetType.Clip => new FrameAnimationEditorSelection(
|
||
FrameAnimationEditorSelectionKind.Clip, graph.Clips.FirstOrDefault(clip => clip != null && clip.Id == id)),
|
||
FrameAnimationValidationTargetType.Flow => new FrameAnimationEditorSelection(
|
||
FrameAnimationEditorSelectionKind.Flow, graph.Flows.FirstOrDefault(flow => flow != null && flow.Id == id)),
|
||
FrameAnimationValidationTargetType.Node => new FrameAnimationEditorSelection(
|
||
FrameAnimationEditorSelectionKind.Node, graph.Nodes.FirstOrDefault(node => node != null && node.InternalId == id)),
|
||
FrameAnimationValidationTargetType.Edge => new FrameAnimationEditorSelection(
|
||
FrameAnimationEditorSelectionKind.Edge, graph.Edges.FirstOrDefault(edge => edge != null && edge.InternalId == id)),
|
||
FrameAnimationValidationTargetType.ImportSource => new FrameAnimationEditorSelection(
|
||
FrameAnimationEditorSelectionKind.Source, graph.ImportSources.FirstOrDefault(source => source != null && source.InternalId == id)),
|
||
_ => new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Graph, graph)
|
||
};
|
||
}
|
||
|
||
private static string Suggestion(FrameAnimationValidationCode code)
|
||
{
|
||
return code switch
|
||
{
|
||
FrameAnimationValidationCode.PlayableIdEmpty => "使用正式 Rename 命令设置唯一 playable id。",
|
||
FrameAnimationValidationCode.PlayableIdDuplicate => "重命名冲突的 Clip 或 Flow。",
|
||
FrameAnimationValidationCode.ClipFramesEmpty => "为 Manual Clip 添加帧，或刷新 Imported Clip 来源。",
|
||
FrameAnimationValidationCode.FrameDurationInvalid => "将 durationMs 修改为大于 0 的整数。",
|
||
FrameAnimationValidationCode.DefaultPlayableInvalid => "在 Graph 属性中选择有效的默认 Clip 或 Flow。",
|
||
FrameAnimationValidationCode.ImportedClipMissingFromSource => "恢复源 Tag，或确认没有引用后删除 Missing Clip。",
|
||
_ => "打开问题对象并修复对应字段或引用。"
|
||
};
|
||
}
|
||
}
|
||
|
||
internal static class FrameAnimationWorkspaceState
|
||
{
|
||
private const string Prefix = "AibisDream.FrameAnimation.Workspace.";
|
||
|
||
public static string Key(FrameAnimationGraph graph, string name)
|
||
{
|
||
var graphPath = graph != null ? AssetDatabase.GetAssetPath(graph) : string.Empty;
|
||
var graphGuid = string.IsNullOrEmpty(graphPath) ? "none" : AssetDatabase.AssetPathToGUID(graphPath);
|
||
var project = Hash128.Compute(Application.dataPath).ToString();
|
||
return Prefix + project + "." + graphGuid + "." + name;
|
||
}
|
||
|
||
public static float GetFloat(FrameAnimationGraph graph, string name, float fallback) =>
|
||
EditorPrefs.GetFloat(Key(graph, name), fallback);
|
||
|
||
public static void SetFloat(FrameAnimationGraph graph, string name, float value) =>
|
||
EditorPrefs.SetFloat(Key(graph, name), value);
|
||
|
||
public static string GetString(FrameAnimationGraph graph, string name, string fallback) =>
|
||
EditorPrefs.GetString(Key(graph, name), fallback);
|
||
|
||
public static void SetString(FrameAnimationGraph graph, string name, string value) =>
|
||
EditorPrefs.SetString(Key(graph, name), value ?? string.Empty);
|
||
|
||
public static bool GetBool(FrameAnimationGraph graph, string name, bool fallback) =>
|
||
EditorPrefs.GetBool(Key(graph, name), fallback);
|
||
|
||
public static void SetBool(FrameAnimationGraph graph, string name, bool value) =>
|
||
EditorPrefs.SetBool(Key(graph, name), value);
|
||
}
|
||
}
|