做类似拆装设备的程序可能会用到

效果图
代码块
using UnityEngine;
using UnityEditor;
using UnityEngine.Playables;
using UnityEngine.Timeline;
using System.Linq;
/// <summary>
/// 简化版Timeline翻转工具,专门为拆装演示设计
/// </summary>
public class SimpleTimelineReverser : EditorWindow
{
private TimelineAsset sourceTimeline;
private string outputName = "Reversed_Timeline";
private bool includeAudioTracks = true;
private bool includeAnimationTracks = true;
private bool includeActivationTracks = true;
[MenuItem("AGV Tools/Simple Timeline Reverser")]
public static void ShowWindow()
{
var window = GetWindow<SimpleTimelineReverser>("Timeline Reverser");
window.minSize = new Vector2(400, 300);
}
void OnGUI()
{
EditorGUILayout.LabelField("AGV Timeline Reverser", EditorStyles.boldLabel);
EditorGUILayout.Space();
// 源Timeline选择
EditorGUILayout.LabelField("Source Timeline", EditorStyles.boldLabel);
sourceTimeline = EditorGUILayout.ObjectField("Timeline Asset", sourceTimeline, typeof(TimelineAsset), false) as TimelineAsset;
EditorGUILayout.Space();
// 输出设置
EditorGUILayout.LabelField("Output Settings", EditorStyles.boldLabel);
outputName = EditorGUILayout.TextField("Output Name", outputName);
EditorGUILayout.Space();
// 轨道类型选择
EditorGUILayout.LabelField("Track Types to Include", EditorStyles.boldLabel);
includeAnimationTracks = EditorGUILayout.Toggle("Animation Tracks", includeAnimationTracks);
includeAudioTracks = EditorGUILayout.Toggle("Audio Tracks", includeAudioTracks);
includeActivationTracks = EditorGUILayout.Toggle("Activation Tracks", includeActivationTracks);
EditorGUILayout.Space();
// Timeline信息显示
if (sourceTimeline != null)
{
EditorGUILayout.LabelField("Timeline Information", EditorStyles.boldLabel);
EditorGUILayout.LabelField($"Duration: {sourceTimeline.duration:F2} seconds");
var tracks = sourceTimeline.GetRootTracks().ToArray();
EditorGUILayout.LabelField($"Root Tracks: {tracks.Length}");
foreach (var track in tracks)
{
EditorGUILayout.LabelField($" - {track.name} ({track.GetType().Name})");
}
}
EditorGUILayout.Space();
// 创建按钮
GUI.enabled = sourceTimeline != null && !string.IsNullOrEmpty(outputName);
if (GUILayout.Button("Create Reversed Timeline", GUILayout.Height(30)))
{
CreateReversedTimeline();
}
GUI.enabled = true;
}
void CreateReversedTimeline()
{
try
{
EditorUtility.DisplayProgressBar("Creating Reversed Timeline", "Initializing...", 0f);
// 创建新的Timeline资产
TimelineAsset reversedTimeline = ScriptableObject.CreateInstance<TimelineAsset>();
reversedTimeline.name = outputName;
reversedTimeline.editorSettings.frameRate = sourceTimeline.editorSettings.frameRate;
double originalDuration = sourceTimeline.duration;
var rootTracks = sourceTimeline.GetRootTracks().ToArray();
// 处理每个轨道
for (int i = 0; i < rootTracks.Length; i++)
{
var track = rootTracks[i];
float progress = (float)i / rootTracks.Length;
EditorUtility.DisplayProgressBar("Creating Reversed Timeline", $"Processing {track.name}...", progress);
if (ShouldIncludeTrack(track))
{
ProcessTrack(track, reversedTimeline, originalDuration);
}
}
// 保存Timeline
SaveTimeline(reversedTimeline);
EditorUtility.DisplayDialog("Success",
$"Reversed timeline '{outputName}' has been created successfully!\n\n" +
$"Location: Assets/timeline/{outputName}.playable", "OK");
}
catch (System.Exception e)
{
EditorUtility.DisplayDialog("Error", $"Failed to create reversed timeline:\n{e.Message}", "OK");
Debug.LogError($"Timeline reversal error: {e}");
}
finally
{
EditorUtility.ClearProgressBar();
}
}
bool ShouldIncludeTrack(TrackAsset track)
{
if (track is AnimationTrack && includeAnimationTracks) return true;
if (track is AudioTrack && includeAudioTracks) return true;
if (track is ActivationTrack && includeActivationTracks) return true;
// 包含其他类型的轨道
return !(track is AnimationTrack || track is AudioTrack || track is ActivationTrack);
}
void ProcessTrack(TrackAsset sourceTrack, TimelineAsset targetTimeline, double totalDuration)
{
// 创建新轨道
var newTrack = targetTimeline.CreateTrack(sourceTrack.GetType(), null, sourceTrack.name + "_Reversed");
// 复制轨道属性
newTrack.muted = sourceTrack.muted;
newTrack.locked = sourceTrack.locked;
// 若为动画轨道且存在无限模式的关键帧,则拷贝无限曲线
var srcAnimTrack = sourceTrack as AnimationTrack;
var dstAnimTrack = newTrack as AnimationTrack;
if (srcAnimTrack != null && dstAnimTrack != null && srcAnimTrack.infiniteClip != null)
{
// 在新轨道上创建无限曲线容器
dstAnimTrack.CreateInfiniteClip(srcAnimTrack.infiniteClip.name);
var srcInf = srcAnimTrack.infiniteClip;
var dstInf = dstAnimTrack.infiniteClip;
if (dstInf != null)
{
// 复制浮点曲线
var curveBindings = AnimationUtility.GetCurveBindings(srcInf);
foreach (var b in curveBindings)
{
var curve = AnimationUtility.GetEditorCurve(srcInf, b);
// 使用全局基准时长进行时间翻转,保证跨轨道同步
var reversed = ReverseCurve(curve, (float)totalDuration);
AnimationUtility.SetEditorCurve(dstInf, b, reversed);
}
// 复制对象引用曲线(并翻转时间)
var objBindings = AnimationUtility.GetObjectReferenceCurveBindings(srcInf);
foreach (var b in objBindings)
{
var keys = AnimationUtility.GetObjectReferenceCurve(srcInf, b);
// 使用全局基准时长进行时间翻转,保证跨轨道同步
var reversedKeys = ReverseObjectCurve(keys, (float)totalDuration);
AnimationUtility.SetObjectReferenceCurve(dstInf, b, reversedKeys);
}
// 复制偏移与外推设置
dstAnimTrack.infiniteClipOffsetPosition = srcAnimTrack.infiniteClipOffsetPosition;
dstAnimTrack.infiniteClipOffsetEulerAngles = srcAnimTrack.infiniteClipOffsetEulerAngles;
dstAnimTrack.infiniteClipPreExtrapolation = srcAnimTrack.infiniteClipPreExtrapolation;
dstAnimTrack.infiniteClipPostExtrapolation = srcAnimTrack.infiniteClipPostExtrapolation;
}
}
// 处理剪辑
var clips = sourceTrack.GetClips().ToArray();
foreach (var clip in clips)
{
ProcessClip(clip, newTrack, totalDuration);
}
}
void ProcessClip(TimelineClip sourceClip, TrackAsset targetTrack, double totalDuration)
{
// 计算翻转后的时间
double originalStart = sourceClip.start;
double originalEnd = sourceClip.end;
double reversedStart = totalDuration - originalEnd;
// 创建新剪辑
TimelineClip newClip = null;
if (sourceClip.asset != null)
{
// 创建默认剪辑后替换其资产
newClip = targetTrack.CreateDefaultClip();
newClip.asset = Object.Instantiate(sourceClip.asset);
}
else
{
// 如果没有资产,创建默认剪辑
newClip = targetTrack.CreateDefaultClip();
}
// 设置时间属性
newClip.start = reversedStart;
newClip.duration = sourceClip.duration;
newClip.displayName = sourceClip.displayName + "_Rev";
// 复制剪辑属性
newClip.blendInDuration = sourceClip.blendOutDuration;
newClip.blendOutDuration = sourceClip.blendInDuration;
newClip.timeScale = sourceClip.timeScale;
newClip.clipIn = sourceClip.clipIn;
// 复制并翻转剪辑上的参数曲线(Clip Curves)
if (sourceClip.hasCurves && sourceClip.curves != null)
{
newClip.CreateCurves(sourceClip.curves.name);
var srcCurves = sourceClip.curves;
var dstCurves = newClip.curves;
if (dstCurves != null)
{
float clipLen = srcCurves.length;
var bindings = AnimationUtility.GetCurveBindings(srcCurves);
foreach (var b in bindings)
{
var curve = AnimationUtility.GetEditorCurve(srcCurves, b);
var reversed = ReverseCurve(curve, clipLen);
AnimationUtility.SetEditorCurve(dstCurves, b, reversed);
}
var objBindings = AnimationUtility.GetObjectReferenceCurveBindings(srcCurves);
foreach (var b in objBindings)
{
var keys = AnimationUtility.GetObjectReferenceCurve(srcCurves, b);
var reversedKeys = ReverseObjectCurve(keys, clipLen);
AnimationUtility.SetObjectReferenceCurve(dstCurves, b, reversedKeys);
}
}
}
}
void SaveTimeline(TimelineAsset timeline)
{
// 确定保存路径
string savePath = "Assets/timeline";
if (!AssetDatabase.IsValidFolder(savePath))
{
savePath = "Assets";
}
string fullPath = $"{savePath}/{outputName}.playable";
fullPath = AssetDatabase.GenerateUniqueAssetPath(fullPath);
// 创建并保存资产
AssetDatabase.CreateAsset(timeline, fullPath);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
// 选中新创建的Timeline
Selection.activeObject = timeline;
EditorGUIUtility.PingObject(timeline);
}
// --- Helpers: reverse curves in time for SimpleTimelineReverser ---
private AnimationCurve ReverseCurve(AnimationCurve originalCurve, float duration)
{
if (originalCurve == null) return null;
var reversed = new AnimationCurve();
for (int i = 0; i < originalCurve.length; i++)
{
var k = originalCurve[i];
var rk = new Keyframe(
duration - k.time,
k.value,
-k.outTangent,
-k.inTangent,
k.inWeight,
k.outWeight
);
rk.weightedMode = k.weightedMode;
reversed.AddKey(rk);
}
return reversed;
}
private ObjectReferenceKeyframe[] ReverseObjectCurve(ObjectReferenceKeyframe[] originalCurve, float duration)
{
if (originalCurve == null) return null;
var len = originalCurve.Length;
var reversed = new ObjectReferenceKeyframe[len];
for (int i = 0; i < len; i++)
{
var src = originalCurve[len - 1 - i];
reversed[i] = new ObjectReferenceKeyframe
{
time = duration - src.time,
value = src.value
};
}
return reversed;
}
}
免责声明:本文系网络转载或改编,未找到原创作者,版权归原作者所有。如涉及版权,请联系删