Unity 3D 全自动制作 2D 动画——集成 OpenClaw 与 Hermes 完整技术方案

核心思路：Hermes 负责"想"（剧本/分镜/技能进化），OpenClaw 负责"做"（任务调度/Unity 驱动/渠道交互），Unity 负责"渲染"（2D 骨骼动画/场景合成/视频输出）。素材自备。

---

一、整体架构

┌──────────────────────────────────────────────────────────────┐
│                      用户交互层                               │
│   Telegram / 飞书 / Discord / Web UI / 命令行                │
├──────────────────────────────────────────────────────────────┤
│                  OpenClaw Agent 层                            │
│   · 消息路由 · Skill 匹配 · 任务调度 · 记忆管理               │
│   · 心跳监控 · MCP Server 桥接 Unity                         │
├───────────────┬──────────────────────────────────────────────┤
│               │  双 Agent 协作协议                            │
├───────────────▼──────────────────────────────────────────────┤
│                  Hermes Agent 层                              │
│   · 剧本生成/改写 · 智能分镜 · 角色调度                       │
│   · Skill 自进化(GEPA) · 主动记忆 · 风格学习                  │
├──────────────────────────────────────────────────────────────┤
│                  MCP Bridge 层                                │
│   OpenClaw ←→ MCP Server ←→ Unity Plugin                    │
├──────────────────────────────────────────────────────────────┤
│                  Unity 3D 引擎层                              │
│   ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐      │
│   │2D Animation│ │ Timeline │ │ 2D IK   │ │Spine运行时│      │
│   │(骨骼/蒙皮) │ │(动画编排) │ │(反向动力学)│ │(Spine动画)│      │
│   └──────────┘ └──────────┘ └──────────┘ └──────────┘      │
│   ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐      │
│   │PSD Importer│ │Cinemachine│ │Audio系统 │ │视频录制  │      │
│   │(素材导入) │ │(虚拟相机) │ │(配音/BGM)│ │(输出成片) │      │
│   └──────────┘ └──────────┘ └──────────┘ └──────────┘      │
├──────────────────────────────────────────────────────────────┤
│                  素材资产层（自备）                            │
│   ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐             │
│   │角色素材 │ │场景素材 │ │道具素材 │ │音频素材 │             │
│   │PSB/Spine│ │PNG/PSB │ │PNG/PSB │ │WAV/MP3 │             │
│   └────────┘ └────────┘ └────────┘ └────────┘             │
├──────────────────────────────────────────────────────────────┤
│                  存储 & 基础设施                              │
│   PostgreSQL + Redis + S3/COS + FFmpeg                      │
└──────────────────────────────────────────────────────────────┘

---

二、三角色分工

🐎 Hermes：创意大脑

职责	输入	输出
剧本生成/改写	一句话创意 / 网文片段	多集完整剧本
角色情感分析	剧本文本	每个镜头的角色表情/动作指令
智能分镜	剧本 + 角色信息	镜头列表（景别/运镜/灯光/时长/台词）
场景调度	分镜脚本	每个镜头的场景切换指令
Skill 自进化	执行反馈	优化后的分镜/调度策略
音频编排	台词 + BGM 列表	配音时间轴 + BGM 切换点

🦞 OpenClaw：执行调度

职责	输入	输出
用户交互	IM 消息 / 命令	任务分发
任务编排	Hermes 输出的分镜脚本	Unity 可执行的指令序列
Unity MCP 桥接	动画指令	Unity 场景操作
资产管理	素材库索引	角色/场景/道具/音频加载
渲染调度	合成指令	视频输出
记忆持久化	项目状态	跨会话恢复
7×24 监控	心跳/错误	自动恢复/通知

🎮 Unity 3D：渲染引擎

职责	输入	输出
素材导入	PSB/Spine/PNG/WAV	角色/场景/道具/音频 Prefab
骨骼动画播放	角色ID + 动作名 + 表情	实时骨骼动画
场景构建	场景ID + 布局参数	2D 场景
Timeline 编排	镜头序列	动画时间线
音频同步	台词 + BGM 时间轴	音画同步播放
视频录制	录制指令	MP4 成片

---

三、素材规范（自备素材的格式要求）

3.1 角色素材

方案 A：Unity 原生 2D Animation（推荐入门）

角色素材/
├── hero.psb              ← Photoshop 大文件格式
│   ├── 图层: 头发
│   ├── 图层: 脸
│   ├── 图层: 左眼
│   ├── 图层: 右眼
│   ├── 图层: 嘴巴
│   ├── 图层: 身体
│   ├── 图层: 左上臂
│   ├── 图层: 左前臂
│   ├── 图层: 左手
│   ├── 图层: 右上臂
│   ├── 图层: 右前臂
│   ├── 图层: 右手
│   ├── 图层: 左大腿
│   ├── 图层: 左小腿
│   ├── 图层: 右大腿
│   └── 图层: 右小腿
├── hero_idle.anim        ← 待机动画剪辑
├── hero_walk.anim        ← 走路动画剪辑
├── hero_run.anim         ← 跑步动画剪辑
└── hero_talk.anim        ← 说话动画剪辑

PSB 导入设置（关键）：

• Texture Type → Sprite (2D and UI)
• Sprite Mode → Multiple
• ✅ Mosaic（自动生成 Sprite Sheet）
• ✅ Character Rig（自动生成骨骼 Prefab）
• ✅ Use Layer Grouping（保留图层分组）

方案 B：Spine（推荐专业级）

角色素材/
├── hero/
│   ├── hero.json         ← Spine 骨骼数据
│   ├── hero.atlas        ← 图集描述
│   ├── hero.png          ← 图集纹理
│   └── hero_assets/      ← 原始分层素材
│       ├── head.png
│       ├── body.png
│       ├── arm_l.png
│       └── ...

Spine 动画命名规范（自动化必需）：

动画名	用途	必须包含
idle	待机	呼吸起伏
walk	行走	循环走路
run	跑步	循环跑步
talk	说话	嘴巴动+手势
angry	生气	表情+肢体
sad	悲伤	表情+肢体
happy	开心	表情+肢体
surprised	惊讶	表情+肢体
sit	坐下	静态坐姿
enter	入场	从画面外走入
exit	出场	走出画面

3.2 场景素材

场景素材/
├── bg_classroom.png      ← 教室背景（1920×1080 或项目分辨率）
├── bg_street.png         ← 街道背景
├── bg_forest.png         ← 森林背景
├── bg_night_city.png     ← 夜晚城市
├── fg_classroom.png      ← 教室前景（可选，增加纵深感）
└── overlay_rain.png      ← 雨天叠加层（可选）

分层建议（从远到近）：

1. 远景背景（天空/建筑远景）
2. 中景（主要活动区域）
3. 近景/前景（栏杆/植物等遮挡物）

3.3 道具素材

道具素材/
├── sword.png             ← 单帧道具
├── book/
│   ├── book_open.anim    ← 有动画的道具
│   └── book_close.anim
└── phone/
    ├── phone_idle.anim
    └── phone_ring.anim

3.4 音频素材

音频素材/
├── bgm/
│   ├── bgm_tension.mp3   ← 紧张
│   ├── bgm_romantic.mp3  ← 浪漫
│   ├── bgm_sad.mp3       ← 悲伤
│   └── bgm_happy.mp3     ← 欢快
├── sfx/
│   ├── sfx_door.wav      ← 音效
│   ├── sfx_footstep.wav
│   └── sfx_thunder.wav
└── voice/                 ← 如有预制配音
    ├── hero_line01.wav
    └── heroine_line01.wav

---

四、Unity 项目搭建

4.1 必装 Package

通过 Package Manager 安装：
✅ 2D Animation          — 骨骼动画核心
✅ 2D PSD Importer        — PSB 文件导入
✅ 2D IK                  — 反向动力学
✅ Timeline               — 动画编排
✅ Cinemachine            — 虚拟相机（2D 也可用）
✅ TextMeshPro            — 字幕渲染
✅ Unity Recorder         — 视频录制输出
✅ Spine-Unity Runtime    — 如使用 Spine（从 Asset Store 安装）
✅ MCP for Unity          — OpenClaw 桥接（从 GitHub 安装）

4.2 项目结构

Assets/
├── Characters/            ← 角色素材
│   ├── Hero/
│   │   ├── hero.psb       ← PSB 源文件
│   │   └── hero@idle.anim ← 动画剪辑
│   ├── Heroine/
│   └── Villain/
├── Scenes_BG/             ← 场景背景
├── Props/                 ← 道具素材
├── Audio/
│   ├── BGM/
│   ├── SFX/
│   └── Voice/
├── Scripts/               ← 自动化脚本
│   ├── AutoDirector/      ← 自动导演系统
│   ├── AssetManager/      ← 素材管理
│   ├── TimelineBuilder/   ← Timeline 编程构建
│   └── VideoRecorder/     ← 录制输出
├── Prefabs/               ← 预制体
│   ├── Characters/
│   ├── Scenes/
│   └── UI/
├── Timelines/             ← 生成的 Timeline 资产
└── Output/                ← 视频输出目录

---

五、核心自动化脚本

5.1 自动导演系统（AutoDirector）

using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Timeline;
using UnityEngine.Rendering.Universal;

/// <summary>
/// 自动导演系统：接收 JSON 指令，自动构建 Timeline 并播放
/// </summary>
public class AutoDirector : MonoBehaviour
{
    [SerializeField] private AssetCatalog catalog;
    [SerializeField] private Transform stageRoot;
    
    private PlayableDirector director;
    private TimelineAsset currentTimeline;
    
    // 当前场景中的活跃角色
    private Dictionary<string, GameObject> activeCharacters = new();
    // 当前场景
    private GameObject currentBackground;
    
    /// <summary>
    /// 从 JSON 构建完整动画时间线
    /// 由 OpenClaw 通过 MCP 调用
    /// </summary>
    public void BuildTimelineFromJson(string json)
    {
        var episode = JsonUtility.FromJson<EpisodeData>(json);
        BuildTimeline(episode);
    }
    
    public void BuildTimeline(EpisodeData episode)
    {
        // 1. 创建新 Timeline
        currentTimeline = TimelineAsset.Create(typeof(TimelineAsset));
        director = GetComponent<PlayableDirector>();
        director.playableAsset = currentTimeline;
        
        // 2. 为每个镜头构建轨道
        foreach (var shot in episode.shots)
        {
            BuildShot(shot, episode.shots.IndexOf(shot));
        }
        
        // 3. 构建音频轨道
        BuildAudioTracks(episode);
        
        // 4. 构建字幕轨道
        BuildSubtitleTrack(episode);
        
        // 5. 绑定引用并播放
        BindTrackReferences();
        director.Play();
    }
    
    private void BuildShot(ShotData shot, int shotIndex)
    {
        float startTime = shot.startTime;
        float duration = shot.durationSeconds;
        
        // --- 场景切换 ---
        if (shot.sceneChange)
        {
            var sceneTrack = currentTimeline.CreateTrack<ActivationTrack>(null, $"Scene_{shotIndex}");
            // 切换背景逻辑
        }
        
        // --- 角色轨道 ---
        foreach (var charData in shot.characters)
        {
            string trackName = $"{charData.characterId}_{shotIndex}";
            var animTrack = currentTimeline.CreateTrack<AnimationTrack>(null, trackName);
            
            // 加载角色
            var characterObj = GetOrCreateCharacter(charData.characterId);
            
            // 创建动画剪辑
            var clip = animTrack.CreateClip(charData.animationName);
            clip.start = startTime;
            clip.duration = duration;
            
            // 位置轨道（角色走位）
            if (charData.position != null)
            {
                var posTrack = currentTimeline.CreateTrack<AnimationTrack>(null, $"{trackName}_Pos");
                // 设置关键帧：从 charData.positionFrom → charData.positionTo
            }
            
            // 表情切换（Spine 或 2D Animation）
            if (!string.IsNullOrEmpty(charData.expression))
            {
                var exprTrack = currentTimeline.CreateTrack<AnimationTrack>(null, $"{trackName}_Expr");
                var exprClip = exprTrack.CreateClip(charData.expression);
                exprClip.start = startTime;
                exprClip.duration = duration;
            }
        }
        
        // --- 虚拟相机 ---
        var cameraTrack = currentTimeline.CreateTrack<CinemachineTrack>(null, $"Camera_{shotIndex}");
        // 设置景别和运镜
    }
    
    private GameObject GetOrCreateCharacter(string characterId)
    {
        if (activeCharacters.TryGetValue(characterId, out var obj))
            return obj;
        
        // 从素材目录加载 Prefab
        var prefab = catalog.GetCharacterPrefab(characterId);
        obj = Instantiate(prefab, stageRoot);
        obj.name = characterId;
        activeCharacters[characterId] = obj;
        return obj;
    }
    
    private void BuildAudioTracks(EpisodeData episode)
    {
        // BGM 轨道
        var bgmTrack = currentTimeline.CreateTrack<AudioTrack>(null, "BGM");
        foreach (var bgm in episode.bgmCues)
        {
            var clip = bgmTrack.CreateClip(catalog.GetBGMClip(bgm.clipName));
            clip.start = bgm.startTime;
            clip.duration = bgm.duration;
            // 淡入淡出
        }
        
        // 配音轨道
        var voiceTrack = currentTimeline.CreateTrack<AudioTrack>(null, "Voice");
        foreach (var line in episode.dialogues)
        {
            var clip = voiceTrack.CreateClip(catalog.GetVoiceClip(line.clipName));
            clip.start = line.startTime;
        }
        
        // 音效轨道
        var sfxTrack = currentTimeline.CreateTrack<AudioTrack>(null, "SFX");
        foreach (var sfx in episode.sfxCues)
        {
            var clip = sfxTrack.CreateClip(catalog.GetSFXClip(sfx.clipName));
            clip.start = sfx.startTime;
        }
    }
    
    private void BuildSubtitleTrack(EpisodeData episode)
    {
        // 使用自定义 PlayableBehaviour 渲染字幕
        var subtitleTrack = currentTimeline.CreateTrack<CustomSubtitleTrack>(null, "Subtitles");
        foreach (var line in episode.dialogues)
        {
            if (!string.IsNullOrEmpty(line.text))
            {
                var clip = subtitleTrack.CreateDefaultClip();
                var subtitleClip = clip.asset as SubtitleClip;
                subtitleClip.text = line.text;
                subtitleClip.speaker = line.speaker;
                clip.start = line.startTime;
                clip.duration = line.duration;
            }
        }
    }
}

5.2 数据结构（JSON 指令格式）

[System.Serializable]
public class EpisodeData
{
    public string episodeTitle;
    public List<ShotData> shots;
    public List<DialogueData> dialogues;
    public List<BGMCueData> bgmCues;
    public List<SFXCueData> sfxCues;
}

[System.Serializable]
public class ShotData
{
    public int shotNumber;
    public float startTime;
    public float durationSeconds;
    public string sceneId;           // 场景ID，对应素材目录
    public bool sceneChange;         // 是否切换场景
    public string shotType;          // wide/full/medium/close_up/extreme_close_up
    public string cameraMovement;    // static/pan_left/pan_right/zoom_in/zoom_out/tracking
    public List<CharacterCueData> characters;
}

[System.Serializable]
public class CharacterCueData
{
    public string characterId;       // 角色ID，对应素材目录
    public string animationName;     // idle/walk/run/talk/angry/sad/happy/surprised
    public string expression;        // 表情覆盖（可选）
    public Vector2Data positionFrom; // 起始位置（归一化坐标 0~1）
    public Vector2Data positionTo;   // 结束位置
    public bool flipX;               // 水平翻转
    public int sortOrder;            // 渲染层级
}

[System.Serializable]
public class Vector2Data
{
    public float x;
    public float y;
}

[System.Serializable]
public class DialogueData
{
    public string speaker;           // 说话人
    public string text;              // 台词文本（用于字幕）
    public string clipName;          // 音频文件名
    public float startTime;
    public float duration;
}

[System.Serializable]
public class BGMCueData
{
    public string clipName;          // BGM 文件名
    public float startTime;
    public float duration;
    public float fadeInDuration;
    public float fadeOutDuration;
}

[System.Serializable]
public class SFXCueData
{
    public string clipName;
    public float startTime;
}

5.3 素材目录管理器

/// <summary>
/// 素材目录：管理所有角色/场景/道具/音频资源的索引
/// 运行时从 Assets/ 目录自动扫描生成
/// </summary>
[CreateAssetMenu(fileName = "AssetCatalog", menuName = "AutoAnime/AssetCatalog")]
public class AssetCatalog : ScriptableObject
{
    [Header("角色")]
    public List<CharacterEntry> characters = new();
    
    [Header("场景")]
    public List<SceneEntry> scenes = new();
    
    [Header("道具")]
    public List<PropEntry> props = new();
    
    [Header("BGM")]
    public List<AudioEntry> bgms = new();
    
    [Header("音效")]
    public List<AudioEntry> sfxs = new();
    
    [Header("配音")]
    public List<AudioEntry> voices = new();
    
    // ---- 查询方法 ----
    
    public GameObject GetCharacterPrefab(string characterId)
    {
        var entry = characters.Find(c => c.id == characterId);
        if (entry == null) Debug.LogError($"角色未找到: {characterId}");
        return entry?.prefab;
    }
    
    public GameObject GetScenePrefab(string sceneId)
    {
        var entry = scenes.Find(s => s.id == sceneId);
        return entry?.prefab;
    }
    
    public AudioClip GetBGMClip(string clipName)
    {
        var entry = bgms.Find(b => b.id == clipName);
        return entry?.clip;
    }
    
    public AudioClip GetSFXClip(string clipName)
    {
        var entry = sfxs.Find(s => s.id == clipName);
        return entry?.clip;
    }
    
    public AudioClip GetVoiceClip(string clipName)
    {
        var entry = voices.Find(v => v.id == clipName);
        return entry?.clip;
    }
    
    /// <summary>
    /// 自动扫描素材目录，生成索引（编辑器工具）
    /// </summary>
    [ContextMenu("重新扫描素材目录")]
    public void RescanAssets()
    {
        characters.Clear();
        scenes.Clear();
        props.Clear();
        bgms.Clear();
        sfxs.Clear();
        voices.Clear();
        
        // 扫描角色
        var charDirs = System.IO.Directory.GetDirectories("Assets/Characters");
        foreach (var dir in charDirs)
        {
            var id = System.IO.Path.GetFileName(dir);
            var prefab = FindPrefabInDir(dir);
            if (prefab != null)
            {
                characters.Add(new CharacterEntry
                {
                    id = id,
                    prefab = prefab,
                    availableAnimations = GetAvailableAnimations(prefab)
                });
            }
        }
        
        // 扫描场景、音频等同理...
        
        UnityEditor.EditorUtility.SetDirty(this);
        UnityEditor.AssetDatabase.SaveAssets();
    }
}

[System.Serializable]
public class CharacterEntry
{
    public string id;
    public GameObject prefab;
    public List<string> availableAnimations; // 可用动画列表
}

[System.Serializable]
public class SceneEntry
{
    public string id;
    public GameObject prefab;
    public Sprite backgroundImage;
}

[System.Serializable]
public class PropEntry
{
    public string id;
    public GameObject prefab;
}

[System.Serializable]
public class AudioEntry
{
    public string id;
    public AudioClip clip;
}

5.4 视频录制输出

using UnityEngine;
using Unity.Recorder;

/// <summary>
/// 自动录制：Timeline 播放完毕后自动输出视频
/// </summary>
public class AutoRecorder : MonoBehaviour
{
    [SerializeField] private AutoDirector director;
    [SerializeField] private string outputFolder = "Output/";
    [SerializeField] private int width = 1920;
    [SerializeField] private int height = 1080;
    [SerializeField] private int frameRate = 30;
    
    private RecorderWindow recorder;
    
    public void StartRecording(string episodeId)
    {
        var settings = ScriptableObject.CreateInstance<MP4RecorderSettings>();
        settings.name = $"Episode_{episodeId}";
        settings.OutputFile = $"{outputFolder}{episodeId}/{episodeId}";
        settings.FrameRate = frameRate;
        settings.FrameSize = new Vector2Int(width, height);
        settings.CaptureAlpha = false;
        
        // 启动录制
        RecorderController.StartRecording(settings);
        
        // 监听 Timeline 播放结束
        director.OnTimelineComplete += () =>
        {
            RecorderController.StopRecording();
            Debug.Log($"录制完成: {outputFolder}{episodeId}");
            
            // 通知 OpenClaw（通过 MCP）
            MCPBridge.NotifyRecordingComplete(episodeId, 
                $"{outputFolder}{episodeId}/{episodeId}.mp4");
        };
    }
}

5.5 Headless 渲染模式（批量出片）

/// <summary>
/// Headless 渲染入口：支持命令行批量渲染
/// 用法：Unity.exe -batchmode -nographics -executeMethod BatchRenderer.Render -episodeId E01
/// </summary>
public class BatchRenderer
{
    public static void Render()
    {
        var args = System.Environment.GetCommandLineArgs();
        string episodeId = "";
        string projectPath = "";
        
        for (int i = 0; i < args.Length; i++)
        {
            if (args[i] == "-episodeId" && i + 1 < args.Length)
                episodeId = args[i + 1];
            if (args[i] == "-projectPath" && i + 1 < args.Length)
                projectPath = args[i + 1];
        }
        
        if (string.IsNullOrEmpty(episodeId))
        {
            Debug.LogError("缺少 -episodeId 参数");
            UnityEditor.EditorApplication.Exit(1);
            return;
        }
        
        // 加载项目数据
        var director = FindObjectOfType<AutoDirector>();
        var jsonPath = $"{projectPath}/episodes/{episodeId}.json";
        string json = System.IO.File.ReadAllText(jsonPath);
        
        // 构建并播放
        director.BuildTimelineFromJson(json);
        
        // 录制完成后自动退出
        var recorder = FindObjectOfType<AutoRecorder>();
        recorder.StartRecording(episodeId);
    }
}

---

六、OpenClaw 配置与 Skill 开发

6.1 安装 Unity MCP 插件

# 1. 克隆 MCP for Unity
git clone https://github.com/CoplayDev/unity-mcp.git

# 2. 在 Unity 中：Window → Package Manager → Add from Disk
#    选择 unity-mcp/package.json

# 3. 安装 uv 环境（MCP Server 依赖）
# Windows:
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
# macOS/Linux:
curl -LsSf https://astral.sh/uv/install.sh | sh

# 4. 在 Unity 中打开 Toggle MCP Window → Start Server
#    默认地址：http://127.0.0.1:8080

# 5. OpenClaw 连接
openclaw mcp connect unity http://127.0.0.1:8080

6.2 OpenClaw Skill：动画制作主控

---
name: auto-anime
version: 1.0.0
description: 全自动 2D 动画制作主控技能
trigger: "制作动画|生成动画|make anime|produce animation|开始制作"
tools: [shell, http, memory, chat]
depends: [hermes-bridge, unity-mcp]
---

# 全自动 2D 动画制作

## 触发条件
当用户要求制作动画、生成漫剧时触发。

## 执行步骤

### 1. 需求确认
询问用户：
- 剧本来源：已有剧本 / 一句话创意 / 从网文改编
- 风格要求：上传风格参考图或描述
- 集数：默认 10 集
- 分辨率：1920×1080 / 1080×1920（竖屏）

### 2. 调用 Hermes 生成剧本和分镜
发送指令给 Hermes Agent：

hermes generate-script --prompt “{用户输入}” --episodes {集数} --style “{风格}”

等待 Hermes 返回：完整剧本 + 分镜 JSON + 角色调度表

### 3. 素材匹配
检查 AssetCatalog 中是否有对应角色/场景/音频：
- 角色匹配：按角色描述匹配最近似的角色素材
- 场景匹配：按场景描述匹配场景素材
- 音频匹配：按情绪关键词匹配 BGM

如缺少素材，提示用户补充。

### 4. 构建 Unity Timeline
通过 MCP 向 Unity 发送构建指令：
```json
{
  "method": "auto_director.build_timeline",
  "params": {
    "episodeData": {分镜JSON}
  }
}

5. 录制输出

通过 MCP 触发录制：

{
  "method": "auto_recorder.start_recording",
  "params": {
    "episodeId": "E01"
  }
}

6. 交付

录制完成后，将视频文件路径发送给用户。

异常处理

• Unity MCP 连接失败：尝试重连 3 次，仍失败则通知用户检查 Unity
• 素材缺失：列出缺失清单，等用户补充后继续
• 录制超时：超过 10 分钟未完成，检查 Unity 是否卡死

注意事项

• 每次制作前先检查 Unity 编辑器是否打开
• 大项目（>20 集）建议分批渲染
• 渲染期间不要操作 Unity 窗口

### 6.3 OpenClaw Skill：Hermes 桥接

```markdown
---
name: hermes-bridge
version: 1.0.0
description: 与 Hermes Agent 协作的桥接技能
trigger: "hermes|ask hermes|爱马仕"
tools: [shell, http, memory]
---

# Hermes 桥接技能

## 用途
当需要创意内容（剧本/分镜/角色分析）时，委托 Hermes 处理。

## 执行步骤

### 1. 构建 Prompt
根据任务类型，组装 Prompt：
- 剧本生成：用户创意 + 风格 + 集数
- 分镜生成：剧本文本 + 角色信息 + 镜头规范
- 角色分析：剧本文本 → 角色列表 + 情感曲线

### 2. 调用 Hermes
```bash
hermes chat --skill generate-script --input "{prompt}"

或通过 HTTP API：

curl -X POST http://localhost:8765/api/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "{prompt}", "skill": "generate-script"}'

3. 解析输出

将 Hermes 返回的结构化数据转为 Unity 可用的 JSON。

输出格式规范

所有 Hermes 输出必须符合 EpisodeData JSON Schema（见 5.2 节）。

---

## 七、Hermes Skill 开发

### 7.1 剧本生成技能

```markdown
---
name: generate-script
version: 1.0.0
description: 从一句话创意生成完整动画剧本与分镜
triggers:
  - "生成剧本"
  - "写剧本"
  - "generate script"
tools_required:
  - read_file
  - write_file
  - web_search
model_preference: claude-sonnet
tags: [动画, 剧本, 分镜]
---

# 动画剧本生成

## 目标
从用户的一句话创意，生成可直接用于 Unity 自动化制作的完整剧本+分镜 JSON。

## 执行步骤

### 1. 创意扩展
将用户的一句话创意扩展为故事大纲：
- 核心冲突
- 主线剧情走向
- 角色关系图
- 情感弧线

### 2. 分集编写
按用户指定的集数，逐集编写剧本：
- 每集 300-500 字
- 标注场景切换
- 标注角色表情和动作
- 每集结尾留悬念

### 3. 分镜拆解
将每集剧本拆解为分镜镜头，输出严格符合以下 JSON Schema：

```json
{
  "episodeTitle": "第X集",
  "shots": [
    {
      "shotNumber": 1,
      "startTime": 0,
      "durationSeconds": 3.0,
      "sceneId": "bg_classroom",
      "sceneChange": true,
      "shotType": "wide",
      "cameraMovement": "static",
      "characters": [
        {
          "characterId": "hero",
          "animationName": "sit",
          "expression": "neutral",
          "positionFrom": {"x": 0.3, "y": 0.5},
          "positionTo": {"x": 0.3, "y": 0.5},
          "flipX": false,
          "sortOrder": 1
        }
      ]
    }
  ],
  "dialogues": [
    {
      "speaker": "hero",
      "text": "今天的风好大啊",
      "clipName": "hero_line01",
      "startTime": 1.0,
      "duration": 2.0
    }
  ],
  "bgmCues": [
    {
      "clipName": "bgm_sad",
      "startTime": 0,
      "duration": 30,
      "fadeInDuration": 1.0,
      "fadeOutDuration": 2.0
    }
  ],
  "sfxCues": [
    {
      "clipName": "sfx_wind",
      "startTime": 0.5
    }
  ]
}

4. 角色素材映射

根据角色描述，匹配 AssetCatalog 中已有的角色 ID：

• 按外貌相似度匹配
• 列出匹配结果供用户确认

注意事项

• characterId 必须与 AssetCatalog 中的 id 完全一致
• sceneId 必须与场景素材文件名对应
• animationName 只能使用角色已有的动画（查看 availableAnimations）
• 时间轴不能重叠
• 总时长控制在 60-120 秒/集

### 7.2 分镜优化技能（自进化）

```markdown
---
name: optimize-storyboard
version: 1.0.0
description: 根据渲染反馈自动优化分镜
triggers:
  - "优化分镜"
  - "分镜不好"
  - "镜头优化"
tools_required:
  - read_file
  - write_file
model_preference: claude-sonnet
tags: [动画, 分镜, 优化]
---

# 分镜优化

## 目标
根据渲染结果反馈（用户评分/播放数据），自动优化分镜策略。

## 优化维度

### 节奏优化
- 连续同景别超过 3 个镜头 → 自动插入不同景别
- 对话场景缺少正反打 → 自动补充
- 高潮段落镜头太短 → 自动延长

### 视觉优化
- 角色遮挡 → 调整 sortOrder 和位置
- 同一位置角色重叠 → 自动分散
- 运镜过于单调 → 根据情绪切换运镜方式

### 情绪匹配
- 紧张场景 → 推进景别 + 快速切换
- 温馨场景 → 中景 + 慢速运镜
- 悲伤场景 → 远景 + 静止镜头

## 进化机制
每次优化后记录：
- 修改了什么
- 用户是否满意
- 播放数据变化

基于历史数据持续进化分镜策略。

---

八、双 Agent 协作协议

8.1 通信架构

用户 → OpenClaw（消息入口）
         │
         ├─ 简单查询 → OpenClaw 直接回答
         │
         ├─ 制作动画 → OpenClaw 编排全流程
         │     │
         │     ├─ Step 1: 调用 Hermes 生成剧本+分镜
         │     │         POST http://hermes-host:8765/api/chat
         │     │
         │     ├─ Step 2: 素材匹配（OpenClaw 本地执行）
         │     │
         │     ├─ Step 3: 通过 MCP 驱动 Unity 构建 Timeline
         │     │         POST http://127.0.0.1:8080/mcp
         │     │
         │     ├─ Step 4: 触发录制
         │     │
         │     └─ Step 5: 交付视频
         │
         └─ 优化/迭代 → Hermes 学习反馈，进化 Skill

8.2 OpenClaw 与 Hermes 的对接方式

方式 A：本地双进程（推荐开发阶段）

# 终端 1：启动 OpenClaw
openclaw gateway

# 终端 2：启动 Hermes
hermes serve --port 8765

# OpenClaw 通过 shell 工具调用 Hermes
# 或通过 HTTP API 调用

方式 B：OpenClaw 内嵌 Hermes（简化部署）

# OpenClaw 配置多模型
openclaw models add hermes --type custom \
  --endpoint http://localhost:8765/api/chat \
  --skill-bridge enabled

方式 C：通过 MCP 双向桥接

OpenClaw ←→ MCP Server ←→ Hermes MCP Client

---

九、完整工作流示例

场景：用户说"帮我做一部废土少女的 10 集动画"

时间线：~2 小时出 10 集成片（素材齐全的情况下）

T+0s    用户发送消息
T+1s    OpenClaw 匹配 auto-anime Skill
T+2s    OpenClaw 确认需求：集数、风格、分辨率
T+10s   用户回复确认
T+11s   OpenClaw 调用 Hermes 生成剧本
T+60s   Hermes 返回 10 集完整剧本 + 分镜 JSON（并行生成）
T+61s   OpenClaw 检查素材匹配
        - 角色：废土少女 → 匹配 hero（heroine/战士类型）
        - 场景：废土 → bg_wasteland, bg_ruins, bg_desert
        - BGM：bgm_tension, bgm_sad, bgm_epic
        - 音效：sfx_wind, sfx_explosion, sfx_footstep
T+65s   OpenClaw 通过 MCP 发送 E01 分镜 JSON 到 Unity
T+70s   Unity AutoDirector 构建 Timeline
T+75s   Unity 开始播放 + 录制
T+135s  E01 录制完成，输出 MP4
T+136s  自动开始 E02 渲染（或并行渲染，如果有多 GPU）
...
T+1200s 全部 10 集渲染完成
T+1201s OpenClaw 将视频列表发送给用户

---

十、批量渲染方案

10.1 单机批量

# 批量渲染脚本 render_all.sh
for i in $(seq -w 1 10); do
  /path/to/Unity.exe \
    -batchmode \
    -nographics \
    -projectPath /path/to/AutoAnimeProject \
    -executeMethod BatchRenderer.Render \
    -episodeId "E${i}" \
    -logFile "Output/E${i}/render.log" \
    -quit
  echo "Episode E${i} rendered."
done

10.2 多 GPU 并行

# GPU 0 渲染 E01-E05
CUDA_VISIBLE_DEVICES=0 ./render_range.sh 1 5 &

# GPU 1 渲染 E06-E10
CUDA_VISIBLE_DEVICES=1 ./render_range.sh 6 10 &

wait
echo "All episodes rendered."

10.3 OpenClaw 调度批量渲染

# 在 auto-anime Skill 中增加批量逻辑

### 批量渲染
如果集数 > 1：
1. 先渲染 E01 作为预览，让用户确认质量
2. 用户确认后，使用 shell 工具启动批量渲染
3. 监控渲染进度，每集完成后通知用户
4. 全部完成后，汇总交付

---

十一、技术难点与解决方案

难点	影响	解决方案
角色表情切换不自然	动画生硬	Spine 混合树 + 表情叠加层，混合时间 0.2s
场景切换有黑帧	视频不连贯	Timeline 轨道交叉淡入淡出，重叠 0.5s
音画不同步	配音与嘴型不匹配	TTS 生成时长 → 反向推算动画时长 → 动态调整
骨骼蒙皮穿帮	关节处撕裂	PSD 分层时留够重叠区域（每层多画 10px）
Timeline 编程构建复杂	代码量大	封装 High-Level API：AddCharacterShot() / AddDialogue()
MCP 连接不稳定	Unity 操作中断	心跳检测 + 自动重连 + 操作幂等设计
批量渲染卡死	进程不退出	每集独立进程 + 超时 kill + 错误重试
素材命名不规范	自动化失败	提供素材规范模板 + 导入时自动校验

---

十二、进阶方向

12.1 实时预览模式

用户在 IM 中发送修改指令
        ↓
OpenClaw 实时调整 Unity Timeline
        ↓
Unity 实时预览（不录制）
        ↓
用户确认后录制输出

12.2 多人协作

角色动画师 → 维护 Spine/PSB 素材
场景美术   → 维护场景背景素材
编剧       → 在 Hermes 中编写剧本
导演       → 在 OpenClaw 中审改分镜

12.3 风格迁移

利用 Hermes 的学习能力：

• 分析已有作品的分镜风格
• 自动学习镜头语言偏好
• 新项目自动应用已学风格

12.4 与 AI 图像生成结合（扩展）

素材不足时：
Hermes 描述 → Stable Diffusion 生成角色立绘
           → 自动转为 PSB 分层
           → 导入 Unity 骨骼绑定

---

十三、硬件与成本

最低配置

组件	要求
CPU	i7-12700 / Ryzen 7 5800X
内存	32 GB
GPU	RTX 3060 12GB（渲染+录制）
存储	500 GB SSD（素材+输出）

推荐配置

组件	要求
CPU	i9-13900K / Ryzen 9 7950X
内存	64 GB
GPU	RTX 4070 Ti（双卡更佳）
存储	1 TB NVMe SSD

AI API 月成本（10 集/月）

用途	预估费用
剧本生成	¥50–100
分镜生成	¥100–200
素材匹配	¥20–50
合计	¥170–350/月

素材自备 = 零图像生成成本，这是最大的成本优势。

---

十四、落地路线图

阶段	时间	目标	交付
P0	2 周	Unity 项目搭建 + 素材导入 + 手动 Timeline	1 集 2D 动画手动出片
P1	4 周	AutoDirector + JSON 驱动	JSON 指令 → 自动构建 Timeline → 出片
P2	6 周	OpenClaw MCP 桥接 + Skill	IM 发消息 → 自动出片
P3	8 周	Hermes 剧本/分镜 + 双 Agent 协作	一句话创意 → 10 集自动出片
P4	12 周	批量渲染 + Skill 进化 + 风格学习	工业化产出 + 质量自优化

---

十五、总结

的独特优势：素材自备。

神经猫、即梦、可灵都在用 AI 生成图片和视频，成本高、一致性差。而：

• ✅ 角色素材自备 → 零图像生成成本 + 100% 一致性
• ✅ 场景/道具自备 → 风格完全可控
• ✅ 音频自备 → 音质保证 + 无版权风险
• ✅ Unity 3D 渲染 → 2D 骨骼动画质量远超 AI 视频生成
• ✅ OpenClaw + Hermes → 全自动编排 + 创意自进化

不是在做一个"AI 视频生成工具"，而是在做一个"AI 导演系统"——素材是现成的演员和布景，AI 负责编剧、导演、剪辑。

这个方向比纯 AI 视频生成更务实，比手工做动画更高效。干就完了。