Unity动画录制全攻略：编辑器与运行时AnimationClip生成详解

做Unity动画相关工作的人，肯定都遇到过这种需求：角色在编辑器里刚刚摆好一套动作，或者在游戏里跑出了一段完全没法复现的物理表演，想把这段过程完整记录成AnimationClip，方便回放、剪辑，或者拿去做表现对比。这件事在Unity圈子里有一个很常见的叫法：Animation Recorder。文章不打算只讲按钮在哪，而是想把编辑器捕获和运行时捕获两条路都拆开，把原理、代码、坑位放到一起讲清楚。不管你是刚写第一行Unity脚本的新手，还是已经在折腾动画系统的老手，这篇文章应该都能帮上忙。

Unity本身对“录制动画”这套需求支持得其实挺早，但官方的封装往往偏黑盒，编辑器模式下点几个按钮就能导出Clip，看着很省心，一旦想要在运行时里自动录制、想要控制关键帧精度、想要录完立刻做数据后处理，很容易一头扎进文档里出不来。这篇文章我会按项目实现的完整路径来写：先从方案选型讲起，再分别拆编辑器模式和运行时模式的做法，最后给到我在真实项目里踩过的坑和排查思路。代码部分以C#为主，使用的API都是Unity 2020 LTS以上版本通用的，老版本也能平移过去。

1. 项目整体设计与方案选型

1.1 先想明白三个核心问题

做动画捕获，本质上只干三件事：确定数据来源、确定采样频率、把采样结果转成AnimationClip。听起来简单，但每一步都有坑。

数据来源指的是你要记录哪些对象哪些属性。最常见的肯定是Transform，也就是物体的位置、旋转、缩放。但实际项目里，动画捕获往往不只是记录Transform这么简单。比如你想记录一个手臂IK的权重变化，或者记录一个程序的参数曲线，这时候只靠Transform就不够了，必须支持自定义组件属性的采样。这意味着你在设计录制器的时候，不能把代码写死在Transform上，要留出扩展属性绑定的空间。

采样频率则是精度和性能的平衡点。60Hz是人眼感知的临界值，做普通动作回放60Hz足够。但物理交互、布料模拟、高速运动物体，60Hz可能不够，容易出现细节丢失。我一般会做成可配置项，默认60，特殊场景可以拉高到120甚至240。采样频率直接决定了最终关键帧数量，也决定了Clip的体积，这块后面会专门讲。

把采样结果转成AnimationClip，Unity提供的核心API是AnimationClip.SetCurve。单条曲线用一个AnimationCurve对象承载，把采样到的时间点和值填进去，就成了一个可用Animator播放的Clip。整个过程不复杂，但要处理好旋转拆分量、切线模式、循环设置这些细节，否则录出来动画轻则抖动，重则直接跳变。

1.2 编辑器录制和运行时录制的本质区别

很多人以为编辑器录制和运行时录制只是调用时机不同，实际差别比想象中大得多。

编辑器模式的核心优势是所见即所得。你可以先在场景里摆好角色、拖好时间轴预览，然后一键录制。Unity官方Unity Recorder包在编辑器模式下提供了非常顺滑的体验，输出AnimationClip、图像序列、视频都行。

运行时模式则完全不同。录制脚本会跟着游戏一起打包发布，游戏过程中随时可以开启录制，把玩家实际操作产生的动画状态保存下来。这种需求在动作游戏回放、体育游戏判定复盘、甚至AI行为数据采集中非常常见。运行时模式没办法依赖编辑器里的任何工具，一切都要用AnimationClip.SetCurve这类运行时API手动拼。

选型的时候不要盲目追求统一方案。如果只是给美术做个离线烘焙工具，编辑器模式就够了，硬要在运行时写一套反而浪费时间。如果目标是录制玩家操作，那就必须走运行时方案。也有两者共存的场景，我的做法是录制采样的核心逻辑共用一套，只是数据写入Clip的入口不同，这个架构后面会展开。

1.3 为什么我不建议完全依赖现成插件

Unity Asset Store上动画录制插件不少，官方也出了Unity Recorder。但我在实际项目里越来越少直接套用现成工具，原因有两个。

第一，黑盒难排查。插件在编辑器里表现良好，一旦出现录制精度不准、物体层级变化导致Clip错乱、运行时环境报错等问题，你很难定位是插件的问题还是自己使用姿势的问题。如果你心里对底层实现有数，排查起来会快很多。

第二，定制空间有限。比如我要录制一个自定义组件里的float字段，还要在两个模式里走同一套后处理逻辑，很多插件做不到这么灵活。自己动手实现一套底层的帧采样和关键帧生成逻辑，前期多花一点时间，后期扩展起来很舒服。

2. 编辑器模式：场景动画烘焙成AnimationClip

2.1 官方Unity Recorder的快速上手姿势

如果你只是偶尔需要把Editor场景里的动画导出成Clip，官方Unity Recorder是效率最高的选择。通过Package Manager搜索“Unity Recorder”安装，然后在Window菜单下打开Recorder窗口。

配置时有几个关键项需要注意。Output Format选“Animation Clip”，Recorded Properties选择要录制的GameObject，建议勾选子物体层级，因为一个角色动画通常涉及多个骨骼节点。Frame Rate默认60，可以根据需要调整。录制开始前，把Scene视图的播放头拖到起点，点击录制按钮，Recorder会按照你设置的帧率在后台采样，结束后自动生成一个.anim文件。

在使用这套流程时，我吃过一个亏：Recorder生成的Clip默认是Clamped Auto切线，回放时曲线会自动平滑。但如果你录制的是程序化生成的物理动作、或者带有明显节奏感的关键帧打击动作，这种平滑反而会改变手感。所以录制完成之后，我习惯在Animation窗口里把所有关键帧切线改成Linear或者Constant，具体取决于原始动作的性质。

官方Recorder的底层逻辑并不复杂：编辑器环境下通过EditorApplication回调做定时采样，采样结果写入AnimationClip。它能记录的属性范围比较广，只要在Inspector里能看到的可动画属性，基本都能录下来。

2.2 自己动手写一个编辑器烘焙器

官方Recorder虽好用，但遇到批量烘焙需求时还是得写工具。比如你有100个不同姿势的Prefab，要分别生成对应的动画Clip，手动点按钮肯定不现实。这时候用Editor脚本遍历处理才是正解。

下面这个简化版烘焙器，思路是选中一个GameObject，以60帧率烘焙其所有Transform属性到新的AnimationClip。实际项目里你可以在这个基础上扩展自定义属性录制。

csharp复制#if UNITY_EDITOR
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;

public static class EditorAnimationBaker
{
    [MenuItem("Tools/Animation Recorder/Bake Selected Transform")]
    public static void BakeSelected()
    {
        GameObject target = Selection.activeGameObject;
        if (target == null)
        {
            Debug.LogWarning("请先选中要烘焙的对象");
            return;
        }

        AnimationClip clip = new AnimationClip();
        clip.frameRate = 60f;

        // 这里以Transform的三个属性为例，自行扩展其他组件属性同理
        List<EditorCurveBinding> bindings = new List<EditorCurveBinding>();
        AddTransformBindings(target.transform, bindings, "");

        // 采样持续时间，这里假设录制1秒
        float duration = 1f;
        int frameCount = Mathf.CeilToInt(duration * 60f);

        // 记录每一帧所有属性的值
        Dictionary<EditorCurveBinding, Keyframe[]> frameData = new Dictionary<EditorCurveBinding, Keyframe[]>();
        foreach (var binding in bindings)
        {
            frameData[binding] = new Keyframe[frameCount];
        }

        for (int i = 0; i < frameCount; i++)
        {
            float time = i / 60f;
            // 在编辑器中强制更新目标对象的Transform为指定时间点的状态
            // 实际操作中，此处应驱动你场景中的时间轴/动画状态到time时刻
            foreach (var binding in bindings)
            {
                float value = GetTransfromValue(target.transform, binding);
                frameData[binding][i] = new Keyframe(time, value);
            }
        }

        // 写入AnimationClip
        foreach (var binding in bindings)
        {
            AnimationCurve curve = new AnimationCurve(frameData[binding]);
            AnimationUtility.SetEditorCurve(clip, binding, curve);
        }

        AnimationUtility.SetAnimationClipSettings(clip, new AnimationClipSettings
        {
            loopTime = true
        });

        string path = $"Assets/Recorded_{target.name}.anim";
        AssetDatabase.CreateAsset(clip, path);
        AssetDatabase.SaveAssets();
        EditorUtility.FocusProjectWindow();
        Selection.activeObject = clip;
        Debug.Log($"烘焙完成，已保存到 {path}");
    }

    private static void AddTransformBindings(Transform t, List<EditorCurveBinding> bindings, string path)
    {
        string prefix = string.IsNullOrEmpty(path) ? t.name : path + "/" + t.name;

        bindings.Add(EditorCurveBinding.FloatCurve(prefix, typeof(Transform), "m_LocalPosition.x"));
        bindings.Add(EditorCurveBinding.FloatCurve(prefix, typeof(Transform), "m_LocalPosition.y"));
        bindings.Add(EditorCurveBinding.FloatCurve(prefix, typeof(Transform), "m_LocalPosition.z"));
        bindings.Add(EditorCurveBinding.FloatCurve(prefix, typeof(Transform), "m_LocalRotation.x"));
        bindings.Add(EditorCurveBinding.FloatCurve(prefix, typeof(Transform), "m_LocalRotation.y"));
        bindings.Add(EditorCurveBinding.FloatCurve(prefix, typeof(Transform), "m_LocalRotation.z"));
        bindings.Add(EditorCurveBinding.FloatCurve(prefix, typeof(Transform), "m_LocalRotation.w"));
        bindings.Add(EditorCurveBinding.FloatCurve(prefix, typeof(Transform), "m_LocalScale.x"));
        bindings.Add(EditorCurveBinding.FloatCurve(prefix, typeof(Transform), "m_LocalScale.y"));
        bindings.Add(EditorCurveBinding.FloatCurve(prefix, typeof(Transform), "m_LocalScale.z"));

        for (int i = 0; i < t.childCount; i++)
        {
            AddTransformBindings(t.GetChild(i), bindings, prefix);
        }
    }

    private static float GetTransfromValue(Transform t, EditorCurveBinding binding)
    {
        // 根据binding.path定位到具体子节点，这里简化为当前选中节点，
        // 实际工具里需要遍历查找
        if (binding.propertyName == "m_LocalPosition.x") return t.localPosition.x;
        if (binding.propertyName == "m_LocalPosition.y") return t.localPosition.y;
        if (binding.propertyName == "m_LocalPosition.z") return t.localPosition.z;
        if (binding.propertyName == "m_LocalRotation.x") return t.localRotation.x;
        if (binding.propertyName == "m_LocalRotation.y") return t.localRotation.y;
        if (binding.propertyName == "m_LocalRotation.z") return t.localRotation.z;
        if (binding.propertyName == "m_LocalRotation.w") return t.localRotation.w;
        if (binding.propertyName == "m_LocalScale.x") return t.localScale.x;
        if (binding.propertyName == "m_LocalScale.y") return t.localScale.y;
        if (binding.propertyName == "m_LocalScale.z") return t.localScale.z;
        return 0f;
    }
}
#endif

这段脚本最大的局限在于没有真正的场景时间轴驱动。实际烘焙时，你需要把场景里的Animator、Timeline或者自定义动画状态在采样前驱赶到对应的时间点，否则采出来的全是静态值。我一般会把“驱动场景到某一帧”的逻辑抽象成一个委托，烘焙器和真实业务通过委托对接，这样工具就通用很多。

2.3 编辑器模式下最容易忽略的细节

编辑器录制最大的坑是脏数据污染。如果角色在录制开始前已经处于一个半播放状态，或者某个脚本在Awake里修改了Transform位置，你录出来的第一条曲线可能就不是真实的起始状态。录制前最好把目标对象重置到初始姿态，再开始采样。

其次，Clip的根骨骼设置。如果你录制的是完整角色，Animation Clip导入后默认会把第一层骨骼当Root Transform处理。有些动画师希望角色位置不随动画飘移，只录制骨骼旋转就够了，这时候就不要把根节点的Position曲线写入Clip，或者需要把AnimationClipSettings.rootTransformPositionY等参数设置为BakeIntoPose。这个细节处理不好，播放时角色会原地乱飘，排查起来非常困惑。

还有一个是我自己经常忘的：录制结束后务必调用AssetDatabase.SaveAssets()。编辑器模式下内存里的Clip和磁盘上的Asset不是实时同步的，忘了保存，关掉工程就全丢了。

3. 运行时模式：把实际游戏过程录下来

3.1 运行时录制的完整流程拆解

运行时录制比编辑器模式麻烦不少，因为打包之后你能用的API只有Runtime层面的东西。完整流程可以拆成四步：创建AnimationClip容器、按固定时间步长采样、判断是否需要写入关键帧、结束后设置Clip属性并注册到Animator。

第一步创建AnimationClip很简单，new AnimationClip()就行。第二步采样是整个方案的核心，采样设计得好不好，直接决定后续生成的Clip是否可用。第三步关键帧判断是控制数据量的关键，不可能每一帧都往里塞，否则一个10秒的录制就能生成上万关键帧，文件体积直接爆炸。第四步是收尾工作，设置循环、调用EnsureQuaternionContinuity处理旋转连续性，最后用clip.SampleAnimation或者Animator验证回放效果。

运行时录制的使用场景非常宽泛。我做过一个运动游戏，角色做出一套复杂的空中动作后，系统要把这套动作实时录下来发到服务器，用来校验玩家的操作是否符合判定条件。这时候录制器必须足够轻量，打包体积可控，同时采样精度要能还原出动作细节，否则服务器端判定模型就会失真。

另一个典型的应用场景是物理模拟记录。布娃娃系统倒地的过程很难在编辑器里复现，但通过运行时录制可以完美保存这次倒地的所有骨骼姿态变化，用来做特效匹配或者回放系统。

3.2 核心类设计：从帧采样到关键帧归并

运行时录制器的核心组件，我命名为RuntimeAnimationRecorder。它的职责可以分成三块：对外暴露开始和结束接口、在Update中驱动采样、把采样数据后处理成Clip。

csharp复制using System.Collections.Generic;
using UnityEngine;

public class RuntimeAnimationRecorder : MonoBehaviour
{
    [Header("录制目标")]
    public GameObject targetRoot;

    [Header("采样配置")]
    public float sampleRate = 60f;
    public float positionThreshold = 0.001f;
    public float rotationThreshold = 0.01f;

    private List<Keyframe>[] posXKeys, posYKeys, posZKeys;
    private List<Keyframe>[] rotXKeys, rotYKeys, rotZKeys, rotWKeys;
    private List<Transform> boneList;
    private float accumulator;
    private float totalTime;
    private bool isRecording;

    public void StartRecording()
    {
        if (targetRoot == null) return;
        boneList = new List<Transform>();
        CollectBones(targetRoot.transform);
        int count = boneList.Count;

        posXKeys = new List<Keyframe>[count];
        posYKeys = new List<Keyframe>[count];
        posZKeys = new List<Keyframe>[count];
        rotXKeys = new List<Keyframe>[count];
        rotYKeys = new List<Keyframe>[count];
        rotZKeys = new List<Keyframe>[count];
        rotWKeys = new List<Keyframe>[count];
        for (int i = 0; i < count; i++)
        {
            posXKeys[i] = new List<Keyframe>();
            posYKeys[i] = new List<Keyframe>();
            posZKeys[i] = new List<Keyframe>();
            rotXKeys[i] = new List<Keyframe>();
            rotYKeys[i] = new List<Keyframe>();
            rotZKeys[i] = new List<Keyframe>();
            rotWKeys[i] = new List<Keyframe>();
        }

        accumulator = 0f;
        totalTime = 0f;
        isRecording = true;
    }

    void Update()
    {
        if (!isRecording) return;

        // 固定时间步长采样，避免帧率波动带来的采样间隔不均匀
        accumulator += Time.deltaTime;
        float interval = 1f / sampleRate;
        while (accumulator >= interval)
        {
            totalTime += interval;
            SampleFrame(totalTime);
            accumulator -= interval;
        }
    }

    private void SampleFrame(float time)
    {
        for (int i = 0; i < boneList.Count; i++)
        {
            Transform bone = boneList[i];
            if (bone == null) continue;

            Vector3 localPos = bone.localPosition;
            Quaternion localRot = bone.localRotation;

            // 关键帧归并：与上一条记录对比，变化超过阈值才写入
            if (ShouldWritePosition(i, localPos))
            {
                posXKeys[i].Add(new Keyframe(time, localPos.x));
                posYKeys[i].Add(new Keyframe(time, localPos.y));
                posZKeys[i].Add(new Keyframe(time, localPos.z));
            }

            if (ShouldWriteRotation(i, localRot))
            {
                rotXKeys[i].Add(new Keyframe(time, localRot.x));
                rotYKeys[i].Add(new Keyframe(time, localRot.y));
                rotZKeys[i].Add(new Keyframe(time, localRot.z));
                rotWKeys[i].Add(new Keyframe(time, localRot.w));
            }
        }
    }

    private bool ShouldWritePosition(int index, Vector3 newPos)
    {
        if (posXKeys[index].Count == 0) return true;
        Keyframe lastX = posXKeys[index][posXKeys[index].Count - 1];
        Vector3 lastPos = new Vector3(lastX.value,
            posYKeys[index][posYKeys[index].Count - 1].value,
            posZKeys[index][posZKeys[index].Count - 1].value);
        return Vector3.Distance(lastPos, newPos) > positionThreshold;
    }

    private bool ShouldWriteRotation(int index, Quaternion newRot)
    {
        if (rotXKeys[index].Count == 0) return true;
        Keyframe lastX = rotXKeys[index][rotXKeys[index].Count - 1];
        Quaternion lastRot = new Quaternion(lastX.value,
            rotYKeys[index][rotYKeys[index].Count - 1].value,
            rotZKeys[index][rotZKeys[index].Count - 1].value,
            rotWKeys[index][rotWKeys[index].Count - 1].value);
        return Quaternion.Angle(lastRot, newRot) > rotationThreshold;
    }

    private void CollectBones(Transform current)
    {
        boneList.Add(current);
        for (int i = 0; i < current.childCount; i++)
        {
            CollectBones(current.GetChild(i));
        }
    }

    public AnimationClip EndRecording()
    {
        isRecording = false;
        if (boneList == null || boneList.Count == 0) return null;

        AnimationClip clip = new AnimationClip();
        clip.frameRate = sampleRate;

        for (int i = 0; i < boneList.Count; i++)
        {
            Transform bone = boneList[i];
            if (bone == null) continue;

            string path = GetRelativePath(bone);

            clip.SetCurve(path, typeof(Transform), "localPosition.x", BuildCurve(posXKeys[i]));
            clip.SetCurve(path, typeof(Transform), "localPosition.y", BuildCurve(posYKeys[i]));
            clip.SetCurve(path, typeof(Transform), "localPosition.z", BuildCurve(posZKeys[i]));
            clip.SetCurve(path, typeof(Transform), "localRotation.x", BuildCurve(rotXKeys[i]));
            clip.SetCurve(path, typeof(Transform), "localRotation.y", BuildCurve(rotYKeys[i]));
            clip.SetCurve(path, typeof(Transform), "localRotation.z", BuildCurve(rotZKeys[i]));
            clip.SetCurve(path, typeof(Transform), "localRotation.w", BuildCurve(rotWKeys[i]));
        }

        // 处理旋转曲线连续性问题，避免回放时旋转跳180度
        clip.EnsureQuaternionContinuity();

        AnimationClipSettings settings = new AnimationClipSettings
        {
            loopTime = true,
            loopBlend = true
        };
        AnimationUtility.SetAnimationClipSettings(clip, settings);
        return clip;
    }

    private AnimationCurve BuildCurve(List<Keyframe> keys)
    {
        if (keys.Count == 0)
        {
            // 曲线为空会导致Clip出错，至少保持一个静态关键帧
            return AnimationCurve.Constant(0f, 0f, 0f);
        }
        return new AnimationCurve(keys.ToArray());
    }

    private string GetRelativePath(Transform bone)
    {
        string path = bone.name;
        Transform current = bone.parent;
        while (current != null && current != targetRoot.transform && current != transform)
        {
            path = current.name + "/" + path;
            current = current.parent;
        }
        return path;
    }
}

这个脚本里最容易被忽略的是BuildCurve方法里的空曲线保护。如果一个骨骼在整个录制过程中完全没有移动，它对应的List会是空的。空List直接构造AnimationCurve会得到一条空曲线，给Clip.SetCurve使用时，播放时会报错或不输出任何值。我习惯把它兜底成一条Constant曲线，值设为0。

另外注意GetRelativePath的实现，动画Clip的曲线路径是相对Animator根节点的，所以递归到targetRoot的层就必须停。这个路径拼错的话，Clip曲线会绑到不存在的节点上，播放时静默失败，非常隐蔽。

3.3 固定时间步长采样为什么能解决抖动问题

很多初学运行时录制的朋友，会直接在Update里采样，每帧记录一次。表面看没问题，实际效果却很糟。因为Update回调严格跟随渲染帧率，你的设备有时跑满60帧，有时掉到30帧，录像的关键帧时间间隔就不均匀。关键帧之间的动画数据本身没问题，但Animator在播放时会尝试做插值，时间间隔不均匀就会导致速度忽快忽慢、曲线抖动。

解决办法就是我在Update里写的那个accumulator累加器。它模拟了一个稳定的固定时间步长时钟：不管渲染帧率怎么波动，采样点始终严格按照1/sampleRate秒的间隔对齐。这个思路写起来不复杂，但提升效果非常明显。实测下来，同一个动作，固定步长采样和每帧采样的回放流畅度差别很大，前者几乎和实时表演一致，后者明显有卡顿感。

3.4 录制非Transform属性：把插件扩展成通用方案

做了几轮工具之后，我发现只录Transform远远不够。比如某个角色技能需要记录剑光特效的透明度变化，这是挂在Light组件上的intensity字段。为了支持这类需求，我引入了“属性采样器”的概念，本质上是给每个采样点提供一个获取具体属性值的委托。

csharp复制public class CustomPropertySampler
{
    public string path;
    public System.Type componentType;
    public string propertyName;
    public System.Func<Component, float> getter;
}

录制开始前，你把这些采样器注册进来，SampleFrame里除了采样Transform，再逐个调用getter拿到当前帧的值，写入对应的Keyframe列表。生成Clip时，通过SetCurve(path, componentType, propertyName, curve)把这些额外曲线也写进去。

这样设计之后，运行时录制器就从一个“只录骨骼”的小工具，变成了一个“任意可动画属性都支持”的通用录制框架。我在做游戏回放系统的时候，连角色表情的BlendShape权重都是这么录进去的。

4. 捕获数据后处理：从原始采样到干净动画

4.1 关键帧精简：别把垃圾录进Clip

如果录制时不做任何优化，一秒60帧、每个骨骼12条曲线，录制10秒动作，关键帧数量会非常恐怖。假设一个角色有50个骨骼，理论上会产生60×10×50×12=360000个关键帧，这么大的数据量无论是对文件体积还是内存都是灾难。

阈值归并已经能把大量冗余帧滤掉，但这还不够。还有一个细节：同一段数据里，如果某个属性在连续一段时间内保持恒定值，阈值归并会在起点留一个关键帧、终点留一个关键帧，中间全部删除。看起来没问题，但如果你用的是Clamped Auto切线，起点和终点之间的曲线不会是平的，Animator会在中间做平滑过渡，导致回放状态和你录到的原始状态不一致。

处理办法有两种。一种是把恒定值区间的起点和终点切线模式设为Constant，这样中间就不会有插值。另一种是录完以后统一对曲线做后处理，把所有切线改成Linear或Constant。我在实际项目中更倾向于用后者，因为处理一次全局生效，不用在录制过程中纠结每个关键帧的切线类型。只要动作本身不是强调渐变的，Linear切线足够还原大部分运动。

4.2 旋转曲线的连续性问题

Transform的旋转是四元数，不能直接作为一条曲线写入Clip，必须拆成x/y/z/w四个分量。但四元数有一个特性：q和-q表示同一个旋转，如果采样过程中某个点从q变成了-q，拆出来的四分量曲线会在那个位置剧烈跳变。播放时Unity会尝试插值，结果就是骨骼瞬间旋转360度再转回来，表现上就是“闪一下”。

Unity专门提供了AnimationClip.EnsureQuaternionContinuity()方法，原理就是检测相邻四元数关键帧是否符号翻转，如果翻转就在写入前纠正。我强烈建议生成Clip后无条件调用一次这个方法。自己手动处理很容易漏边界情况，官方API做了完整的平滑处理，用起来简单得多。

4.3 录制资源的体积优化

运行时录制产生的Clip通常不会直接作为Asset保存在包里，更多是存成二进制数据传给服务器，或者在本地序列化后下次启动时恢复。数据量和序列化格式关系很大。

我做过一个对比，使用不同策略录制同一个10秒动作，结果非常直观：

如果录制的是角色动作，采样率降到30Hz会丢失不少细节，尤其是挥拳、转身这类快速动作，回放时会有明显的“定格”感。我通常保留60Hz采样率，但用阈值归并和切线性压缩来控制体积，这样既能保证流畅度，数据量也不至于失控。

5. 真实项目中的问题排查与技巧

5.1 录出来的动画播放时整体偏了位置

这个坑我踩过不止一次，主要原因是混淆了世界坐标和本地坐标。录制时如果直接采样transform.position，写入Clip的曲线是绝对世界位置，一旦回放的对象父节点位置不同，整个动画就会错位。正确做法是采样localPosition，曲线路径写成相对Animator根节点的路径。

另一个容易导致偏移的原因是录制时根节点本身有位移。比如角色在跑步，根骨骼移动了一段距离。如果你只想记录上半身动作，忽略根骨骼位置，回放时角色会原地做跑步动作，没有位移。处理办法是把根骨骼的位置曲线也录进去，或在生成Clip时显式配置RootMotion位移，让Animator知道位移由哪条曲线驱动。

5.2 曲线路径写错导致动画静默失效

SetCurve的relativePath参数非常严格，路径分隔符是/，而且要求路径相对Animator的根节点。写得稍微差一个字符，Animator播放时就找不到目标对象，动画表现得像是没有录制成功，但其实Clip里曲线数据都在。

排查方法很简单，把生成的Clip拖进Animation窗口，看曲线是否绑到目标对象上。如果曲线列表是空的，或者绑到了不存在的节点，问题基本出在路径。我后来改成用AnimationUtility.CalculateTransformPath来生成路径，彻底告别手动拼字符串。

5.3 运行时录制导致卡顿

运行时录制最影响性能的地方，一是每帧遍历所有骨骼采样，二是结束录制时一次性写入大量曲线。前者可以通过降低采样频率、只录制活动骨骼来优化。后者卡顿的最大原因是调用SetCurve次数太多，每条曲线一次，骨骼一多几百次调用全部挤在同一个函数里，Profiler面板必红。

我的优化策略是把录制过程拆成“边录边攒数据”，结束录制时先保存成自定义二进制格式，等下一帧空闲时再异步生成Clip，避免卡主线程。如果必须同步生成，就把骨骼数量压缩到最低，或者把目标对象拆成多个Clip分帧处理。

5.4 我保留的三个日常习惯

录制前先调用一次Resources.UnloadUnusedAssets()清掉旧数据，避免录制过程中内存碎片堆积。这个习惯是从一次连续录制几十个片段的内存暴涨里总结出来的。

每次采样前做一次NaN检查。如果录制过程中某个Transform被脚本设置成了NaN值，后面所有采样都会跟着变成NaN，最终生成的Clip播放起来全是乱动。检查很简单，判断Vector3.IsFinite(localPos)和Quaternion.IsFinite(localRot)，发现异常就跳过当前采样点并打日志，至少能让工具崩溃之前暴露问题。

最后一个是版本号。我会在录制的二进制数据头部加一个version字段，每次修改采样格式或压缩算法都递增。这样后续读取历史数据时，可以按照不同版本走不同的反序列化逻辑，不用每次改动都担心旧数据读不出来。

录数据这件事，看着不难，真正落地的时候问题总比想象中多。现在我在项目里遇到需要回放、校验、表现对比的需求时，第一反应不再是找现成插件硬凑，而是先想清楚数据来源、采样策略、如何后处理，然后直接基于这套运行时录制框架去实现。这套思路帮我把很多看似复杂的动画录制需求，拆成了一个个可以快速落地的模块。最后再分享一个小技巧：运行时生成的动画Clip，场景里临时验证时不需要重新播放整个游戏的流程，直接调clip.SampleAnimation(gameObject, time)就能定位到任意一帧的姿势，非常方便排查路径绑定和曲线数据问题。