957 lines
37 KiB
C#
957 lines
37 KiB
C#
#if UNITY_EDITOR
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Reflection;
|
||
using UnityEngine;
|
||
using UnityEditor;
|
||
using Sirenix.OdinInspector;
|
||
using Sirenix.OdinInspector.Editor;
|
||
using Sirenix.Utilities.Editor;
|
||
using UnityEditor.Callbacks;
|
||
|
||
namespace SLSUtilities.Feedback.Editor
|
||
{
|
||
public class FeedbackDataEditorWindow : OdinEditorWindow
|
||
{
|
||
// ─────────────── 常量 ───────────────
|
||
|
||
private const float RULER_HEIGHT = 22f;
|
||
private const float LANE_HEIGHT = 24f;
|
||
private const float TRACK_PADDING = 2f;
|
||
private const float TRACK_LABEL_WIDTH = 140f;
|
||
private const float EXPAND_BUTTON_SIZE = 14f;
|
||
private const float DRAG_HANDLE_WIDTH = 6f;
|
||
private const float MIN_TIMELINE_DURATION = 1.0f;
|
||
private const float TIMELINE_PADDING_RATIO = 0.15f;
|
||
private const float DEFAULT_SNAP_INTERVAL = 0.05f;
|
||
private const float MIN_CLIP_DURATION = 0.01f;
|
||
|
||
// ─────────────── 序列化字段 ───────────────
|
||
|
||
[Title("Feedback Data Editor")]
|
||
[ShowInInspector, AssetsOnly, PropertyOrder(-100)]
|
||
[LabelText("Target Data")]
|
||
[OnValueChanged("OnDataChanged")]
|
||
public FeedbackData targetData;
|
||
|
||
[ShowInInspector, PropertyOrder(-99)]
|
||
[HorizontalGroup("TimelineSettings", Width = 200)]
|
||
[LabelText("View Duration")]
|
||
[LabelWidth(90)]
|
||
[MinValue(0.1f)]
|
||
[OnValueChanged("OnViewDurationChanged")]
|
||
public float viewDuration = MIN_TIMELINE_DURATION;
|
||
|
||
[ShowInInspector, PropertyOrder(-99)]
|
||
[HorizontalGroup("TimelineSettings", Width = 160)]
|
||
[LabelText("Snap")]
|
||
[LabelWidth(35)]
|
||
[MinValue(0.001f)]
|
||
public float snapInterval = DEFAULT_SNAP_INTERVAL;
|
||
|
||
[ShowInInspector, PropertyOrder(-99)]
|
||
[HorizontalGroup("TimelineSettings", Width = 120)]
|
||
[LabelText("Auto Fit")]
|
||
[LabelWidth(55)]
|
||
public bool autoFitDuration = true;
|
||
|
||
[ShowInInspector, PropertyOrder(1)]
|
||
[ShowIf("targetData")]
|
||
[InlineEditor(Expanded = true, ObjectFieldMode = InlineEditorObjectFieldModes.Hidden)]
|
||
public FeedbackData dataEditor;
|
||
|
||
// ─────────────── 拖拽状态 ───────────────
|
||
|
||
private enum DragMode { None, ClipMove, ClipLeft, ClipRight }
|
||
|
||
private DragMode _currentDragMode = DragMode.None;
|
||
private int _dragTrackIndex = -1;
|
||
private int _dragClipIndex = -1;
|
||
private float _dragStartMouseTime;
|
||
private float _dragStartClipStart;
|
||
private float _dragStartClipDuration;
|
||
private bool _isDirty;
|
||
|
||
// ─────────────── 选中状态 ───────────────
|
||
|
||
private int _selectedTrackIndex = -1;
|
||
private int _selectedClipIndex = -1;
|
||
|
||
// ─────────────── 展开状态与布局缓存 ───────────────
|
||
|
||
private readonly HashSet<int> _expandedTracks = new HashSet<int>();
|
||
|
||
private struct TrackLayout
|
||
{
|
||
public float yOffset;
|
||
public float totalHeight;
|
||
public int laneCount; // 当前显示的 lane 数（折叠时为 1）
|
||
public int naturalLaneCount; // 实际需要的 lane 数（用于决定是否显示展开按钮）
|
||
public int[] clipLanes;
|
||
}
|
||
|
||
private TrackLayout[] _trackLayouts;
|
||
|
||
// ─────────────── 颜色 ───────────────
|
||
|
||
private static readonly Dictionary<Type, Color> ActionColorCache = new Dictionary<Type, Color>();
|
||
|
||
private static readonly Color BackgroundColor = new Color(0.16f, 0.16f, 0.16f);
|
||
private static readonly Color TrackBackgroundColor = new Color(0.22f, 0.22f, 0.22f);
|
||
private static readonly Color TrackAltBackgroundColor = new Color(0.20f, 0.20f, 0.20f);
|
||
private static readonly Color RulerBackgroundColor = new Color(0.14f, 0.14f, 0.14f);
|
||
private static readonly Color SelectionOutlineColor = new Color(1f, 0.85f, 0.2f);
|
||
private static readonly Color MutedOverlayColor = new Color(0.5f, 0.5f, 0.5f, 0.4f);
|
||
private static readonly Color SoloIndicatorColor = new Color(1f, 0.85f, 0.2f);
|
||
private static readonly Color DefaultClipColor = new Color(0.5f, 0.6f, 0.7f, 0.8f);
|
||
private static readonly Color ExpandButtonColor = new Color(0.6f, 0.6f, 0.6f);
|
||
private static readonly Color LaneSeparatorColor = new Color(0.3f, 0.3f, 0.3f, 0.3f);
|
||
|
||
// ─────────────── Label 宽度 ───────────────
|
||
|
||
private const float INSPECTOR_LABEL_WIDTH = 155f;
|
||
|
||
/// <summary>
|
||
/// 包装每个 Editor 的绘制，使用 Odin 的 GUIHelper 栈式 Label 宽度，
|
||
/// 确保 InlineEditor 内部也能生效。
|
||
/// </summary>
|
||
protected override void DrawEditor(int index)
|
||
{
|
||
GUIHelper.PushLabelWidth(INSPECTOR_LABEL_WIDTH);
|
||
base.DrawEditor(index);
|
||
GUIHelper.PopLabelWidth();
|
||
}
|
||
|
||
// ─────────────── 窗口入口 ───────────────
|
||
|
||
/// <summary>
|
||
/// 通过菜单打开窗口。
|
||
/// </summary>
|
||
[MenuItem("Tools/SLS Utilities/Feedback Data Editor")]
|
||
private static void OpenWindow()
|
||
{
|
||
var window = GetWindow<FeedbackDataEditorWindow>();
|
||
window.titleContent = new GUIContent("Feedback Editor");
|
||
window.Show();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 双击 FeedbackData 资产时自动打开编辑器。
|
||
/// </summary>
|
||
[OnOpenAsset(1)]
|
||
public static bool OnOpenAsset(int instanceID, int line)
|
||
{
|
||
FeedbackData data = EditorUtility.EntityIdToObject(instanceID) as FeedbackData;
|
||
if (data == null) return false;
|
||
|
||
OpenWindow();
|
||
var window = GetWindow<FeedbackDataEditorWindow>();
|
||
window.targetData = data;
|
||
window.OnDataChanged();
|
||
return true;
|
||
}
|
||
|
||
// ─────────────── 数据变更回调 ───────────────
|
||
|
||
private void OnDataChanged()
|
||
{
|
||
dataEditor = targetData;
|
||
if (autoFitDuration) FitViewDuration();
|
||
_selectedTrackIndex = -1;
|
||
_selectedClipIndex = -1;
|
||
_expandedTracks.Clear();
|
||
}
|
||
|
||
private void OnViewDurationChanged()
|
||
{
|
||
autoFitDuration = false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 自动适配 viewDuration 到数据实际长度。
|
||
/// </summary>
|
||
private void FitViewDuration()
|
||
{
|
||
if (targetData == null) return;
|
||
float total = targetData.TotalDuration;
|
||
viewDuration = Mathf.Max(total * (1f + TIMELINE_PADDING_RATIO), MIN_TIMELINE_DURATION);
|
||
}
|
||
|
||
// ═══════════════════════════════════════════
|
||
// 轨道布局计算
|
||
// ═══════════════════════════════════════════
|
||
|
||
/// <summary>
|
||
/// 重新计算所有轨道的布局（lane 分配、高度、Y 偏移）。
|
||
/// </summary>
|
||
private void ComputeTrackLayouts()
|
||
{
|
||
if (targetData?.tracks == null || targetData.tracks.Count == 0)
|
||
{
|
||
_trackLayouts = Array.Empty<TrackLayout>();
|
||
return;
|
||
}
|
||
|
||
int numTracks = targetData.tracks.Count;
|
||
_trackLayouts = new TrackLayout[numTracks];
|
||
float currentY = 0;
|
||
|
||
for (int i = 0; i < numTracks; i++)
|
||
{
|
||
FeedbackTrack track = targetData.tracks[i];
|
||
bool isExpanded = _expandedTracks.Contains(i);
|
||
int[] clipLanes = AssignClipLanes(track);
|
||
|
||
// 始终计算实际所需 lane 数，用于决定是否显示展开按钮
|
||
int naturalLaneCount = (clipLanes != null && clipLanes.Length > 0)
|
||
? clipLanes.Max() + 1
|
||
: 1;
|
||
|
||
// 显示的 lane 数：折叠时固定为 1，展开时用实际值
|
||
int displayLaneCount = isExpanded ? naturalLaneCount : 1;
|
||
|
||
float height = displayLaneCount * LANE_HEIGHT + TRACK_PADDING * 2;
|
||
|
||
_trackLayouts[i] = new TrackLayout
|
||
{
|
||
yOffset = currentY,
|
||
totalHeight = height,
|
||
laneCount = displayLaneCount,
|
||
naturalLaneCount = naturalLaneCount,
|
||
clipLanes = clipLanes
|
||
};
|
||
|
||
currentY += height;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 为一条轨道中的 Clips 分配 lane，使重叠的 Clip 位于不同 lane。
|
||
/// 贪心算法：按 startTime 排序，依次放入第一个无冲突的 lane。
|
||
/// </summary>
|
||
private int[] AssignClipLanes(FeedbackTrack track)
|
||
{
|
||
if (track?.clips == null || track.clips.Count == 0) return Array.Empty<int>();
|
||
|
||
int clipCount = track.clips.Count;
|
||
int[] lanes = new int[clipCount];
|
||
|
||
int[] sortedIndices = Enumerable.Range(0, clipCount)
|
||
.OrderBy(idx => track.clips[idx]?.startTime ?? 0)
|
||
.ToArray();
|
||
|
||
List<float> laneEndTimes = new List<float>();
|
||
|
||
foreach (int idx in sortedIndices)
|
||
{
|
||
FeedbackClip clip = track.clips[idx];
|
||
if (clip == null) { lanes[idx] = 0; continue; }
|
||
|
||
float clipStart = clip.startTime;
|
||
int assignedLane = -1;
|
||
|
||
for (int lane = 0; lane < laneEndTimes.Count; lane++)
|
||
{
|
||
if (clipStart >= laneEndTimes[lane])
|
||
{
|
||
assignedLane = lane;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (assignedLane == -1)
|
||
{
|
||
assignedLane = laneEndTimes.Count;
|
||
laneEndTimes.Add(0);
|
||
}
|
||
|
||
lanes[idx] = assignedLane;
|
||
laneEndTimes[assignedLane] = clip.EndTime;
|
||
}
|
||
|
||
return lanes;
|
||
}
|
||
|
||
private float GetTotalTracksHeight()
|
||
{
|
||
if (_trackLayouts == null || _trackLayouts.Length == 0)
|
||
return LANE_HEIGHT + TRACK_PADDING * 2;
|
||
|
||
var last = _trackLayouts[^1];
|
||
return last.yOffset + last.totalHeight;
|
||
}
|
||
|
||
// ═══════════════════════════════════════════
|
||
// 时间轴 GUI 主入口
|
||
// ═══════════════════════════════════════════
|
||
|
||
[OnInspectorGUI]
|
||
[PropertyOrder(-98)]
|
||
[ShowIf("targetData")]
|
||
private void DrawTimelineGUI()
|
||
{
|
||
if (targetData == null) return;
|
||
if (autoFitDuration) FitViewDuration();
|
||
|
||
ComputeTrackLayouts();
|
||
|
||
float tracksHeight = GetTotalTracksHeight();
|
||
float totalHeight = RULER_HEIGHT + tracksHeight;
|
||
|
||
Rect totalArea = GUILayoutUtility.GetRect(GUIContent.none, GUIStyle.none, GUILayout.Height(totalHeight));
|
||
|
||
Rect labelHeaderArea = new Rect(totalArea.x, totalArea.y, TRACK_LABEL_WIDTH, RULER_HEIGHT);
|
||
Rect rulerArea = new Rect(
|
||
totalArea.x + TRACK_LABEL_WIDTH,
|
||
totalArea.y,
|
||
totalArea.width - TRACK_LABEL_WIDTH,
|
||
RULER_HEIGHT
|
||
);
|
||
Rect allTracksArea = new Rect(
|
||
totalArea.x,
|
||
totalArea.y + RULER_HEIGHT,
|
||
totalArea.width,
|
||
tracksHeight
|
||
);
|
||
|
||
EditorGUI.DrawRect(totalArea, BackgroundColor);
|
||
EditorGUI.DrawRect(labelHeaderArea, RulerBackgroundColor);
|
||
EditorGUI.DrawRect(rulerArea, RulerBackgroundColor);
|
||
|
||
DrawRuler(rulerArea, viewDuration);
|
||
DrawTracks(allTracksArea, viewDuration);
|
||
DrawTotalDurationLine(rulerArea, allTracksArea, viewDuration);
|
||
|
||
HandleMouseInput(totalArea, rulerArea, allTracksArea, viewDuration);
|
||
|
||
if (_isDirty)
|
||
{
|
||
Repaint();
|
||
_isDirty = false;
|
||
}
|
||
|
||
GUILayout.Space(8);
|
||
}
|
||
|
||
// ─────────────── 标尺绘制 ───────────────
|
||
|
||
private void DrawRuler(Rect rulerArea, float duration)
|
||
{
|
||
if (duration <= 0) return;
|
||
|
||
// 自适应刻度间距
|
||
float tickInterval = CalculateTickInterval(duration, rulerArea.width);
|
||
|
||
Handles.color = new Color(0.5f, 0.5f, 0.5f, 0.5f);
|
||
GUIStyle tickLabelStyle = new GUIStyle(EditorStyles.miniLabel)
|
||
{
|
||
normal = { textColor = new Color(0.7f, 0.7f, 0.7f) },
|
||
alignment = TextAnchor.UpperLeft
|
||
};
|
||
|
||
int numTicks = Mathf.FloorToInt(duration / tickInterval);
|
||
for (int i = 0; i <= numTicks; i++)
|
||
{
|
||
float time = i * tickInterval;
|
||
float xPos = rulerArea.x + (time / duration) * rulerArea.width;
|
||
|
||
bool isMajor = Mathf.Approximately(time % (tickInterval * 2f), 0f) || i == 0;
|
||
float lineHeight = isMajor ? rulerArea.height : rulerArea.height * 0.5f;
|
||
|
||
Handles.DrawLine(
|
||
new Vector3(xPos, rulerArea.yMax - lineHeight),
|
||
new Vector3(xPos, rulerArea.yMax)
|
||
);
|
||
|
||
if (isMajor)
|
||
{
|
||
GUI.Label(new Rect(xPos + 2, rulerArea.y, 50, rulerArea.height), $"{time:F2}s", tickLabelStyle);
|
||
}
|
||
}
|
||
|
||
// 总时长标记
|
||
GUIStyle totalStyle = new GUIStyle(EditorStyles.miniLabel)
|
||
{
|
||
normal = { textColor = new Color(0.9f, 0.9f, 0.5f) },
|
||
alignment = TextAnchor.UpperRight
|
||
};
|
||
string totalLabel = $"Total: {targetData.TotalDuration:F2}s";
|
||
GUI.Label(new Rect(rulerArea.xMax - 100, rulerArea.y, 98, rulerArea.height), totalLabel, totalStyle);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据时间轴总时长和像素宽度计算合理的刻度间距。
|
||
/// </summary>
|
||
private float CalculateTickInterval(float duration, float width)
|
||
{
|
||
float targetPixelsPerTick = 60f;
|
||
float idealInterval = duration * targetPixelsPerTick / width;
|
||
|
||
float[] candidates = { 0.01f, 0.02f, 0.05f, 0.1f, 0.2f, 0.25f, 0.5f, 1f, 2f, 5f, 10f };
|
||
foreach (float c in candidates)
|
||
{
|
||
if (c >= idealInterval) return c;
|
||
}
|
||
return 10f;
|
||
}
|
||
|
||
// ─────────────── TotalDuration 指示线 ───────────────
|
||
|
||
private void DrawTotalDurationLine(Rect rulerArea, Rect tracksArea, float duration)
|
||
{
|
||
float total = targetData.TotalDuration;
|
||
if (total <= 0 || duration <= 0) return;
|
||
|
||
float xPos = rulerArea.x + (total / duration) * rulerArea.width;
|
||
Handles.color = new Color(0.9f, 0.9f, 0.3f, 0.4f);
|
||
Handles.DrawLine(
|
||
new Vector3(xPos, rulerArea.y),
|
||
new Vector3(xPos, tracksArea.yMax)
|
||
);
|
||
}
|
||
|
||
// ─────────────── 轨道绘制 ───────────────
|
||
|
||
private void DrawTracks(Rect allTracksArea, float duration)
|
||
{
|
||
if (targetData.tracks == null || targetData.tracks.Count == 0)
|
||
{
|
||
GUI.Label(allTracksArea, "No tracks. Add tracks in the inspector below.",
|
||
EditorStyles.centeredGreyMiniLabel);
|
||
return;
|
||
}
|
||
|
||
for (int trackIdx = 0; trackIdx < targetData.tracks.Count; trackIdx++)
|
||
{
|
||
if (trackIdx >= _trackLayouts.Length) break;
|
||
|
||
FeedbackTrack track = targetData.tracks[trackIdx];
|
||
ref TrackLayout layout = ref _trackLayouts[trackIdx];
|
||
bool isExpanded = _expandedTracks.Contains(trackIdx);
|
||
|
||
float trackY = allTracksArea.y + layout.yOffset;
|
||
Rect labelRect = new Rect(allTracksArea.x, trackY, TRACK_LABEL_WIDTH, layout.totalHeight);
|
||
Rect contentRect = new Rect(
|
||
allTracksArea.x + TRACK_LABEL_WIDTH,
|
||
trackY,
|
||
allTracksArea.width - TRACK_LABEL_WIDTH,
|
||
layout.totalHeight
|
||
);
|
||
|
||
// 轨道背景
|
||
Color bgColor = (trackIdx % 2 == 0) ? TrackBackgroundColor : TrackAltBackgroundColor;
|
||
EditorGUI.DrawRect(contentRect, bgColor);
|
||
|
||
// 展开时绘制 lane 分隔线
|
||
if (isExpanded && layout.laneCount > 1)
|
||
{
|
||
Handles.color = LaneSeparatorColor;
|
||
for (int lane = 1; lane < layout.laneCount; lane++)
|
||
{
|
||
float lineY = trackY + TRACK_PADDING + lane * LANE_HEIGHT;
|
||
Handles.DrawLine(
|
||
new Vector3(contentRect.x, lineY),
|
||
new Vector3(contentRect.xMax, lineY)
|
||
);
|
||
}
|
||
}
|
||
|
||
// 轨道标签
|
||
DrawTrackLabel(labelRect, track, trackIdx, isExpanded, layout.laneCount);
|
||
|
||
// Clips
|
||
if (track.clips != null)
|
||
{
|
||
for (int clipIdx = 0; clipIdx < track.clips.Count; clipIdx++)
|
||
{
|
||
int lane = 0;
|
||
if (isExpanded && layout.clipLanes != null && clipIdx < layout.clipLanes.Length)
|
||
lane = layout.clipLanes[clipIdx];
|
||
|
||
DrawClip(contentRect, track.clips[clipIdx], trackIdx, clipIdx, duration, lane, isExpanded);
|
||
}
|
||
}
|
||
|
||
// Mute 叠加层
|
||
if (track.mute)
|
||
{
|
||
EditorGUI.DrawRect(contentRect, MutedOverlayColor);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 绘制轨道标签区域（名称 + mute/solo 指示 + 展开按钮）。
|
||
/// </summary>
|
||
private void DrawTrackLabel(Rect labelRect, FeedbackTrack track, int trackIdx, bool isExpanded, int laneCount)
|
||
{
|
||
EditorGUI.DrawRect(labelRect, RulerBackgroundColor);
|
||
|
||
if (track.solo)
|
||
{
|
||
EditorGUI.DrawRect(new Rect(labelRect.x, labelRect.y, 3f, labelRect.height), SoloIndicatorColor);
|
||
}
|
||
|
||
string prefix = track.mute ? "[M] " : track.solo ? "[S] " : "";
|
||
string displayName = string.IsNullOrEmpty(track.trackName) ? $"Track {trackIdx}" : track.trackName;
|
||
Color textColor = track.mute ? new Color(0.5f, 0.5f, 0.5f) : new Color(0.85f, 0.85f, 0.85f);
|
||
|
||
GUIStyle labelStyle = new GUIStyle(EditorStyles.label)
|
||
{
|
||
fontSize = 11,
|
||
padding = new RectOffset(8, 0, 0, 0),
|
||
normal = { textColor = textColor }
|
||
};
|
||
|
||
float firstLaneH = LANE_HEIGHT + TRACK_PADDING * 2;
|
||
Rect nameLabelRect = new Rect(labelRect.x, labelRect.y, labelRect.width - EXPAND_BUTTON_SIZE - 6f, firstLaneH);
|
||
EditorGUI.LabelField(nameLabelRect, $"{prefix}{displayName}", labelStyle);
|
||
|
||
// 使用 naturalLaneCount 判断是否需要显示展开按钮
|
||
ref TrackLayout layout = ref _trackLayouts[trackIdx];
|
||
if (layout.naturalLaneCount > 1 || isExpanded)
|
||
{
|
||
DrawExpandToggle(labelRect, trackIdx, isExpanded, layout.naturalLaneCount);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 绘制展开/折叠三角按钮。
|
||
/// </summary>
|
||
private void DrawExpandToggle(Rect labelRect, int trackIdx, bool isExpanded, int laneCount)
|
||
{
|
||
float firstLaneH = LANE_HEIGHT + TRACK_PADDING * 2;
|
||
float btnX = labelRect.xMax - EXPAND_BUTTON_SIZE - 4f;
|
||
float btnY = labelRect.y + (firstLaneH - EXPAND_BUTTON_SIZE) * 0.5f;
|
||
Rect btnRect = new Rect(btnX, btnY, EXPAND_BUTTON_SIZE, EXPAND_BUTTON_SIZE);
|
||
|
||
EditorGUI.DrawRect(btnRect, new Color(0.25f, 0.25f, 0.25f, 0.8f));
|
||
|
||
Vector3 center = btnRect.center;
|
||
float halfSize = EXPAND_BUTTON_SIZE * 0.25f;
|
||
Handles.color = isExpanded ? SoloIndicatorColor : ExpandButtonColor;
|
||
|
||
if (isExpanded)
|
||
{
|
||
Handles.DrawAAConvexPolygon(
|
||
new Vector3(center.x - halfSize, center.y - halfSize * 0.5f, 0),
|
||
new Vector3(center.x + halfSize, center.y - halfSize * 0.5f, 0),
|
||
new Vector3(center.x, center.y + halfSize * 0.5f, 0)
|
||
);
|
||
}
|
||
else
|
||
{
|
||
Handles.DrawAAConvexPolygon(
|
||
new Vector3(center.x - halfSize * 0.5f, center.y - halfSize, 0),
|
||
new Vector3(center.x + halfSize * 0.5f, center.y, 0),
|
||
new Vector3(center.x - halfSize * 0.5f, center.y + halfSize, 0)
|
||
);
|
||
}
|
||
|
||
// lane 数量角标
|
||
GUIStyle badgeStyle = new GUIStyle(EditorStyles.miniLabel)
|
||
{
|
||
fontSize = 8,
|
||
normal = { textColor = new Color(0.7f, 0.7f, 0.7f) },
|
||
alignment = TextAnchor.MiddleCenter
|
||
};
|
||
GUI.Label(new Rect(btnRect.xMax - 2f, btnRect.y - 2f, 12f, 10f), laneCount.ToString(), badgeStyle);
|
||
|
||
// 点击
|
||
if (Event.current.type == EventType.MouseDown && Event.current.button == 0
|
||
&& btnRect.Contains(Event.current.mousePosition))
|
||
{
|
||
if (isExpanded)
|
||
_expandedTracks.Remove(trackIdx);
|
||
else
|
||
_expandedTracks.Add(trackIdx);
|
||
|
||
_isDirty = true;
|
||
Event.current.Use();
|
||
}
|
||
}
|
||
|
||
// ─────────────── Clip 绘制 ───────────────
|
||
|
||
private void DrawClip(Rect contentRect, FeedbackClip clip, int trackIdx, int clipIdx, float duration, int lane, bool isExpanded)
|
||
{
|
||
if (clip == null || duration <= 0) return;
|
||
|
||
float startNorm = clip.startTime / duration;
|
||
float endNorm = clip.EndTime / duration;
|
||
|
||
float startX = contentRect.x + startNorm * contentRect.width;
|
||
float endX = contentRect.x + endNorm * contentRect.width;
|
||
float clipWidth = Mathf.Max(endX - startX, 2f);
|
||
|
||
float clipY, clipH;
|
||
if (isExpanded)
|
||
{
|
||
clipY = contentRect.y + TRACK_PADDING + lane * LANE_HEIGHT + 2f;
|
||
clipH = LANE_HEIGHT - 4f;
|
||
}
|
||
else
|
||
{
|
||
clipY = contentRect.y + TRACK_PADDING + 2f;
|
||
clipH = LANE_HEIGHT - 4f;
|
||
}
|
||
|
||
Rect clipRect = new Rect(startX, clipY, clipWidth, clipH);
|
||
|
||
// Clip 填充色
|
||
Color clipColor = GetActionColor(clip.action);
|
||
bool isSelected = (trackIdx == _selectedTrackIndex && clipIdx == _selectedClipIndex);
|
||
|
||
if (isSelected)
|
||
{
|
||
clipColor = Color.Lerp(clipColor, Color.white, 0.2f);
|
||
}
|
||
|
||
EditorGUI.DrawRect(clipRect, clipColor);
|
||
|
||
// 选中描边
|
||
if (isSelected)
|
||
{
|
||
DrawRectOutline(clipRect, SelectionOutlineColor, 1f);
|
||
}
|
||
|
||
// Clip 标签
|
||
string clipLabel = clip.action != null ? clip.action.DisplayName : "(null)";
|
||
GUIStyle clipLabelStyle = new GUIStyle(EditorStyles.miniLabel)
|
||
{
|
||
normal = { textColor = Color.white },
|
||
clipping = TextClipping.Clip,
|
||
alignment = TextAnchor.MiddleLeft,
|
||
padding = new RectOffset(4, 2, 0, 0),
|
||
fontSize = 10
|
||
};
|
||
|
||
if (clipRect.width > 20f)
|
||
{
|
||
GUI.Label(clipRect, clipLabel, clipLabelStyle);
|
||
}
|
||
|
||
// 左右拖拽把手的视觉提示
|
||
if (clipRect.width > DRAG_HANDLE_WIDTH * 3)
|
||
{
|
||
Color handleColor = new Color(1f, 1f, 1f, 0.15f);
|
||
Rect leftHandle = new Rect(clipRect.x, clipRect.y, DRAG_HANDLE_WIDTH, clipRect.height);
|
||
Rect rightHandle = new Rect(clipRect.xMax - DRAG_HANDLE_WIDTH, clipRect.y, DRAG_HANDLE_WIDTH, clipRect.height);
|
||
EditorGUI.DrawRect(leftHandle, handleColor);
|
||
EditorGUI.DrawRect(rightHandle, handleColor);
|
||
}
|
||
|
||
// Tooltip
|
||
string tooltip = $"{clipLabel}\n{clip.startTime:F3}s - {clip.EndTime:F3}s (dur: {clip.duration:F3}s)";
|
||
GUI.Label(clipRect, new GUIContent("", tooltip));
|
||
}
|
||
|
||
/// <summary>
|
||
/// 绘制矩形描边。
|
||
/// </summary>
|
||
private void DrawRectOutline(Rect rect, Color color, float thickness)
|
||
{
|
||
EditorGUI.DrawRect(new Rect(rect.x, rect.y, rect.width, thickness), color);
|
||
EditorGUI.DrawRect(new Rect(rect.x, rect.yMax - thickness, rect.width, thickness), color);
|
||
EditorGUI.DrawRect(new Rect(rect.x, rect.y, thickness, rect.height), color);
|
||
EditorGUI.DrawRect(new Rect(rect.xMax - thickness, rect.y, thickness, rect.height), color);
|
||
}
|
||
|
||
// ─────────────── Action 颜色 ───────────────
|
||
|
||
/// <summary>
|
||
/// 获取 Action 的时间轴显示颜色（优先从 FeedbackActionColorAttribute 读取，否则用类型哈希生成）。
|
||
/// </summary>
|
||
private Color GetActionColor(FeedbackActionBase action)
|
||
{
|
||
if (action == null) return DefaultClipColor;
|
||
|
||
Type type = action.GetType();
|
||
if (ActionColorCache.TryGetValue(type, out Color cached)) return cached;
|
||
|
||
var attr = type.GetCustomAttribute<FeedbackActionColorAttribute>();
|
||
Color color;
|
||
if (attr != null)
|
||
{
|
||
color = attr.Color;
|
||
}
|
||
else
|
||
{
|
||
// 根据类型名哈希生成确定性颜色
|
||
int hash = type.FullName?.GetHashCode() ?? 0;
|
||
float h = Mathf.Abs(hash % 360) / 360f;
|
||
color = Color.HSVToRGB(h, 0.5f, 0.75f);
|
||
color.a = 0.8f;
|
||
}
|
||
|
||
ActionColorCache[type] = color;
|
||
return color;
|
||
}
|
||
|
||
// ═══════════════════════════════════════════
|
||
// 鼠标输入处理
|
||
// ═══════════════════════════════════════════
|
||
|
||
private void HandleMouseInput(Rect totalArea, Rect rulerArea, Rect allTracksArea, float duration)
|
||
{
|
||
Event e = Event.current;
|
||
Vector2 mousePos = e.mousePosition;
|
||
|
||
if (!totalArea.Contains(mousePos))
|
||
{
|
||
if (e.type == EventType.MouseUp) ResetDrag();
|
||
return;
|
||
}
|
||
|
||
UpdateMouseCursor(allTracksArea, mousePos, duration);
|
||
|
||
switch (e.type)
|
||
{
|
||
case EventType.MouseDown when e.button == 0:
|
||
HandleMouseDown(allTracksArea, mousePos, duration, e);
|
||
break;
|
||
|
||
case EventType.MouseDrag when _currentDragMode != DragMode.None:
|
||
HandleMouseDrag(allTracksArea, mousePos, duration, e);
|
||
break;
|
||
|
||
case EventType.MouseUp when e.button == 0:
|
||
ResetDrag();
|
||
_isDirty = true;
|
||
e.Use();
|
||
break;
|
||
}
|
||
}
|
||
|
||
private void HandleMouseDown(Rect allTracksArea, Vector2 mousePos, float duration, Event e)
|
||
{
|
||
if (!allTracksArea.Contains(mousePos)) return;
|
||
|
||
Undo.RecordObject(targetData, "Modify Feedback Timeline");
|
||
|
||
var hit = HitTestClip(allTracksArea, mousePos, duration);
|
||
if (hit.trackIndex != -1)
|
||
{
|
||
_selectedTrackIndex = hit.trackIndex;
|
||
_selectedClipIndex = hit.clipIndex;
|
||
|
||
Rect contentRect = GetTrackContentRect(allTracksArea, hit.trackIndex);
|
||
float mouseTime = PixelToTime(mousePos.x, contentRect, duration);
|
||
|
||
FeedbackClip clip = targetData.tracks[hit.trackIndex].clips[hit.clipIndex];
|
||
_dragStartMouseTime = mouseTime;
|
||
_dragStartClipStart = clip.startTime;
|
||
_dragStartClipDuration = clip.duration;
|
||
|
||
_currentDragMode = hit.dragMode;
|
||
_dragTrackIndex = hit.trackIndex;
|
||
_dragClipIndex = hit.clipIndex;
|
||
|
||
_isDirty = true;
|
||
e.Use();
|
||
return;
|
||
}
|
||
|
||
// 点击空白 → 取消选中
|
||
_selectedTrackIndex = -1;
|
||
_selectedClipIndex = -1;
|
||
_isDirty = true;
|
||
e.Use();
|
||
}
|
||
|
||
private void HandleMouseDrag(Rect allTracksArea, Vector2 mousePos, float duration, Event e)
|
||
{
|
||
if (_dragTrackIndex < 0 || _dragTrackIndex >= targetData.tracks.Count) return;
|
||
var track = targetData.tracks[_dragTrackIndex];
|
||
if (_dragClipIndex < 0 || _dragClipIndex >= track.clips.Count) return;
|
||
|
||
Rect contentRect = GetTrackContentRect(allTracksArea, _dragTrackIndex);
|
||
float mouseTime = PixelToTime(mousePos.x, contentRect, duration);
|
||
float timeDelta = mouseTime - _dragStartMouseTime;
|
||
|
||
FeedbackClip clip = track.clips[_dragClipIndex];
|
||
|
||
switch (_currentDragMode)
|
||
{
|
||
case DragMode.ClipMove:
|
||
float newStart = SnapTime(_dragStartClipStart + timeDelta);
|
||
newStart = Mathf.Max(0, newStart);
|
||
clip.startTime = newStart;
|
||
break;
|
||
|
||
case DragMode.ClipLeft:
|
||
float newLeftStart = SnapTime(_dragStartClipStart + timeDelta);
|
||
newLeftStart = Mathf.Max(0, newLeftStart);
|
||
float maxLeft = _dragStartClipStart + _dragStartClipDuration - MIN_CLIP_DURATION;
|
||
newLeftStart = Mathf.Min(newLeftStart, maxLeft);
|
||
float endTime = _dragStartClipStart + _dragStartClipDuration;
|
||
clip.startTime = newLeftStart;
|
||
clip.duration = Mathf.Max(endTime - newLeftStart, MIN_CLIP_DURATION);
|
||
break;
|
||
|
||
case DragMode.ClipRight:
|
||
float newDuration = SnapTime(_dragStartClipDuration + timeDelta);
|
||
clip.duration = Mathf.Max(newDuration, MIN_CLIP_DURATION);
|
||
break;
|
||
}
|
||
|
||
EditorUtility.SetDirty(targetData);
|
||
_isDirty = true;
|
||
e.Use();
|
||
}
|
||
|
||
private void ResetDrag()
|
||
{
|
||
_currentDragMode = DragMode.None;
|
||
_dragTrackIndex = -1;
|
||
_dragClipIndex = -1;
|
||
}
|
||
|
||
// ─────────────── Hit Testing ───────────────
|
||
|
||
private struct ClipHitResult
|
||
{
|
||
public int trackIndex;
|
||
public int clipIndex;
|
||
public DragMode dragMode;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 测试鼠标位置是否命中某个 Clip，并返回拖拽模式。
|
||
/// </summary>
|
||
private ClipHitResult HitTestClip(Rect allTracksArea, Vector2 mousePos, float duration)
|
||
{
|
||
var result = new ClipHitResult { trackIndex = -1, clipIndex = -1, dragMode = DragMode.None };
|
||
if (targetData.tracks == null || duration <= 0 || _trackLayouts == null) return result;
|
||
|
||
// 通过 Y 坐标确定轨道
|
||
int trackIndex = -1;
|
||
for (int i = 0; i < _trackLayouts.Length; i++)
|
||
{
|
||
float trackY = allTracksArea.y + _trackLayouts[i].yOffset;
|
||
float trackBottom = trackY + _trackLayouts[i].totalHeight;
|
||
if (mousePos.y >= trackY && mousePos.y < trackBottom)
|
||
{
|
||
trackIndex = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (trackIndex < 0 || trackIndex >= targetData.tracks.Count) return result;
|
||
|
||
Rect contentRect = GetTrackContentRect(allTracksArea, trackIndex);
|
||
if (!contentRect.Contains(mousePos)) return result;
|
||
|
||
var track = targetData.tracks[trackIndex];
|
||
if (track.clips == null) return result;
|
||
|
||
bool isExpanded = _expandedTracks.Contains(trackIndex);
|
||
ref TrackLayout layout = ref _trackLayouts[trackIndex];
|
||
|
||
for (int i = track.clips.Count - 1; i >= 0; i--)
|
||
{
|
||
FeedbackClip clip = track.clips[i];
|
||
if (clip == null) continue;
|
||
|
||
float startX = contentRect.x + (clip.startTime / duration) * contentRect.width;
|
||
float endX = contentRect.x + (clip.EndTime / duration) * contentRect.width;
|
||
|
||
if (mousePos.x < startX || mousePos.x > endX) continue;
|
||
|
||
// 展开模式下检查 Y 方向 lane
|
||
if (isExpanded && layout.clipLanes != null && i < layout.clipLanes.Length)
|
||
{
|
||
int lane = layout.clipLanes[i];
|
||
float laneY = contentRect.y + TRACK_PADDING + lane * LANE_HEIGHT;
|
||
if (mousePos.y < laneY || mousePos.y > laneY + LANE_HEIGHT) continue;
|
||
}
|
||
|
||
result.trackIndex = trackIndex;
|
||
result.clipIndex = i;
|
||
|
||
if (mousePos.x - startX <= DRAG_HANDLE_WIDTH)
|
||
result.dragMode = DragMode.ClipLeft;
|
||
else if (endX - mousePos.x <= DRAG_HANDLE_WIDTH)
|
||
result.dragMode = DragMode.ClipRight;
|
||
else
|
||
result.dragMode = DragMode.ClipMove;
|
||
|
||
return result;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
// ─────────────── 光标更新 ───────────────
|
||
|
||
private void UpdateMouseCursor(Rect allTracksArea, Vector2 mousePos, float duration)
|
||
{
|
||
if (!allTracksArea.Contains(mousePos)) return;
|
||
|
||
var hit = HitTestClip(allTracksArea, mousePos, duration);
|
||
if (hit.trackIndex == -1)
|
||
{
|
||
EditorGUIUtility.AddCursorRect(allTracksArea, MouseCursor.Arrow);
|
||
return;
|
||
}
|
||
|
||
switch (hit.dragMode)
|
||
{
|
||
case DragMode.ClipLeft:
|
||
case DragMode.ClipRight:
|
||
EditorGUIUtility.AddCursorRect(allTracksArea, MouseCursor.ResizeHorizontal);
|
||
break;
|
||
default:
|
||
EditorGUIUtility.AddCursorRect(allTracksArea, MouseCursor.MoveArrow);
|
||
break;
|
||
}
|
||
}
|
||
|
||
// ─────────────── 工具方法 ───────────────
|
||
|
||
/// <summary>
|
||
/// 获取指定轨道的内容区域（不含标签列），高度由布局决定。
|
||
/// </summary>
|
||
private Rect GetTrackContentRect(Rect allTracksArea, int trackIndex)
|
||
{
|
||
if (_trackLayouts == null || trackIndex >= _trackLayouts.Length)
|
||
{
|
||
return new Rect(
|
||
allTracksArea.x + TRACK_LABEL_WIDTH,
|
||
allTracksArea.y,
|
||
allTracksArea.width - TRACK_LABEL_WIDTH,
|
||
LANE_HEIGHT + TRACK_PADDING * 2
|
||
);
|
||
}
|
||
|
||
ref TrackLayout layout = ref _trackLayouts[trackIndex];
|
||
return new Rect(
|
||
allTracksArea.x + TRACK_LABEL_WIDTH,
|
||
allTracksArea.y + layout.yOffset,
|
||
allTracksArea.width - TRACK_LABEL_WIDTH,
|
||
layout.totalHeight
|
||
);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 像素坐标转换为时间值。
|
||
/// </summary>
|
||
private float PixelToTime(float pixelX, Rect trackRect, float duration)
|
||
{
|
||
if (trackRect.width <= 0) return 0;
|
||
return Mathf.Clamp((pixelX - trackRect.x) / trackRect.width * duration, 0, duration);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 将时间吸附到最近的 snapInterval 刻度。
|
||
/// </summary>
|
||
private float SnapTime(float time)
|
||
{
|
||
if (snapInterval <= 0) return Mathf.Max(0, time);
|
||
return Mathf.Max(0, Mathf.Round(time / snapInterval) * snapInterval);
|
||
}
|
||
}
|
||
}
|
||
#endif
|