许可优化
许可优化
产品
产品
解决方案
解决方案
服务支持
服务支持
关于
关于
软件库
当前位置:服务支持 >  软件文章 >  Unity一键翻转Timeline工具分享,动画编辑效率提升

Unity一键翻转Timeline工具分享,动画编辑效率提升

阅读数 11
点赞 0
article_banner


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

效果图

代码块


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;
    }
}
     


免责声明:本文系网络转载或改编,未找到原创作者,版权归原作者所有。如涉及版权,请联系删

相关文章
技术文档
QR Code
微信扫一扫,欢迎咨询~
customer

online

联系我们
武汉格发信息技术有限公司
湖北省武汉市经开区科技园西路6号103孵化器
电话:155-2731-8020 座机:027-59821821
邮件:tanzw@gofarlic.com
Copyright © 2023 Gofarsoft Co.,Ltd. 保留所有权利
遇到许可问题?该如何解决!?
评估许可证实际采购量? 
不清楚软件许可证使用数据? 
收到软件厂商律师函!?  
想要少购买点许可证,节省费用? 
收到软件厂商侵权通告!?  
有正版license,但许可证不够用,需要新购? 
联系方式 board-phone 155-2731-8020
close1
预留信息,一起解决您的问题
* 姓名:
* 手机:

* 公司名称:

姓名不为空

姓名不为空

姓名不为空
手机不正确

手机不正确

手机不正确
公司不为空

公司不为空

公司不为空