• 中文：中文文档 · 概述 · 具体制作过程 · 注意事项 · 工具使用说明 · AI Agent 提示词
• English: English Documentation · Overview · Production Workflow · Limitations · Tool Usage · AI Agent Prompt

在很多低成本游戏中，立绘都是纯静态图，因为制作 Spine 或 Live2D 动画需要较高的时间和金钱成本。即使有了 AI，可以很轻易地生成 AI 视频，但在游戏中播放视频仍然相对麻烦。也可以将视频转成序列帧，但高清立绘生成的流畅序列帧体积很大，一次性加载通常难以接受。

本文提供一种基于 AI 和 Mesh 顶点动画制作类似 Live2D 效果的技术。无论是内存占用、运行时开销还是制作成本，这种方案都比较低，适合不追求高质量立绘动画的项目。下面是仅靠单张立绘（无分层）制作的 Idle 效果：

_{点击动态预览可播放原始 MP4 视频。}

初始美术资源只需要一张图片。制作过程中还会用到其他资源，但这些资源都可以基于这张图片生成；如果已经具备这些资源，则可以直接使用。

需要安装 FFmpeg 和 OpenCV，并通过 Python 调用，也可以让 AI Agent 协助安装。

本文使用 Unity 演示，因此最好准备好 Unity 命令行环境及流水线所需的包，也可以让 Agent 协助安装。这一步很重要，因为生成 Unity 资源的过程中需要编写并执行一些 Unity 代码。

基本原理与 Mesh 变形、Blend Shape 类似，都是通过改变 Mesh 的顶点位置形成动画。至于从图片生成 Mesh，则可以利用 AI 技术，也可以人工制作。完成一系列姿态 Mesh 后，将后一个姿态的顶点位置减去前一个姿态的顶点位置，把得到的差值写入相应的 Mesh 通道，再由顶点 Shader 根据当前动画进度，将这些通道中存储的差值按权重累加到原始顶点位置上。

生成 Mesh 时，不能只跟 AI Agent 说“帮我把这张图片转成 Mesh”。如果只提供这样的要求，它生成的 Mesh 很可能是这样：

这个 Mesh 的问题在于存在很多非常长的三角形边。虽然看上去划分了身体部位，但实际上无法正常使用。这种 Mesh 会导致局部顶点移动时，相距很远的顶点也随之移动，最终使全身动画变得非常奇怪。

我的方法是先定义一个数据结构，让 AI 分析图像中包含哪些身体部位，再记录每个部位的顶点索引。这样也方便后续生成其他姿态的 Mesh 时进行参考。

[SerializeField]
private Mesh _mesh;
[SerializeField]
private List<Region> _regionList = new List<Region>();


[Serializable]
public sealed class Region
{
    #region fields
    [SerializeField]
    private string _regionName;
    [SerializeField]
    private int[] _vertexIndices;
    #endregion
    
    #region properties
    public string Name => _regionName;
    public IReadOnlyList<int> VertexIndices => _vertexIndices;
    #endregion
    
    #region methods
    public Region(string name, int[] indices)
    {
        _regionName = name;
        _vertexIndices = indices;
    }
    #endregion
}

需要向 Agent 明确说明：顶点应使用规则网格，相邻四点组成一个小矩形，再拆分成两个局部三角形；禁止生成跨网格、跨透明区域或跨身体部位的长三角形边。这样生成的 Mesh 才能符合要求：

关于身体部位，如果只看图片，AI 的分析结果不一定适用于目标动画。最好直接提供所需动画的视频或文字描述，这样分析结果会更加准确。

这一步用于生成具体的姿态 Mesh。我目前使用的方案最多包含 13 个姿态（包括初始姿态）。如果一个动作幅度过大或包含往复运动，直接从初始姿态变换到最终姿态显然无法正确表现动作过程。

所有姿态 Mesh 都必须由同一个初始 Mesh 变形得到，并满足以下约束：

• 顶点数量必须完全一致。
• 顶点索引和排列顺序必须完全一致；每个索引在所有姿态中都必须对应同一个身体位置。
• 三角形拓扑必须完全一致，不能重新布线，也不能增加、删除或合并顶点。
• UV0 的数量、索引关系和纹理对应关系必须保持一致，以保证所有姿态都能正确采样原始贴图。
• 所有姿态必须使用相同的对象坐标空间、原点、朝向和缩放，不能通过改变 Transform 代替顶点变形。
• 当前方案只记录顶点的 XY 位移，因此不要依赖 Z 轴变化表达动画。

需要特别注意，顶点数量相同并不代表 Mesh 一定兼容。如果顶点顺序或拓扑发生变化，相同索引就会指向不同的身体位置，编码后的动画将出现撕裂、跳点或大范围错误变形。当前编码工具只会自动检查顶点数量，其余约束需要在生成姿态 Mesh 时自行保证。

这里使用的动作来自一个由 AI 根据立绘生成的视频（立绘本身也是由 AI 生成的）：

_{点击动态预览可播放包含声音的原始 MP4 视频。}

我的工作流是让 AI 参考这张图片和视频，生成各个姿态 Mesh。

具体来说，AI 会使用前面提到的 FFmpeg 和 OpenCV 分析视频，找出视频中真正的循环区间。例如，一个 10 秒的视频可能只是将 2.5 秒的动作重复了 4 次，所以这一步非常重要。如果错误地将完整的 10 秒视频视为一个循环，每个关键帧的位置就会出现偏差。

AI 确定需要采用哪些关键帧后，就可以为每个关键帧生成对应的 Mesh。注意，为了保证循环效果，最后一个关键帧需要能够平滑过渡回初始姿态。

为了方便动画计算，这里会计算每个姿态相对于前一个姿态的顶点位置差值，并将其保存到最终的 Mesh 通道中。由于处理的是 2D 图片，所以只需要保存 XY 变化。12 个后续姿态对应 12 组差值。当前实现使用 Normal、Tangent、UV0.zw 以及 UV1～UV4 存储这些数据，其中 UV0.xy 必须保留用于采样贴图。

float3 keyFrame1 : NORMAL;
float4 keyFrame2And3 : TANGENT;
float4 uv0AndKeyFrame4 : TEXCOORD0;
float4 keyFrame5And6 : TEXCOORD1;
float4 keyFrame7And8 : TEXCOORD2;
float4 keyFrame9And10 : TEXCOORD3;
float4 keyFrame11And12 : TEXCOORD4;

接下来在 Shader 中设置动画进度参数 _AnimationProgress，取值范围为 0～1，并使用如下算法变换顶点位置：

float animationProgress = saturate(_AnimationProgress) * (_AnimationCount + 1.0);
float keyFrameProgress = min(animationProgress, _AnimationCount);
positionOS.xy += input.keyFrame1.xy * saturate(keyFrameProgress);
positionOS.xy += input.keyFrame2And3.xy * saturate(keyFrameProgress - 1.0);
positionOS.xy += input.keyFrame2And3.zw * saturate(keyFrameProgress - 2.0);
positionOS.xy += input.uv0AndKeyFrame4.zw * saturate(keyFrameProgress - 3.0);
positionOS.xy += input.keyFrame5And6.xy * saturate(keyFrameProgress - 4.0);
positionOS.xy += input.keyFrame5And6.zw * saturate(keyFrameProgress - 5.0);
positionOS.xy += input.keyFrame7And8.xy * saturate(keyFrameProgress - 6.0);
positionOS.xy += input.keyFrame7And8.zw * saturate(keyFrameProgress - 7.0);
positionOS.xy += input.keyFrame9And10.xy * saturate(keyFrameProgress - 8.0);
positionOS.xy += input.keyFrame9And10.zw * saturate(keyFrameProgress - 9.0);
positionOS.xy += input.keyFrame11And12.xy * saturate(keyFrameProgress - 10.0);
positionOS.xy += input.keyFrame11And12.zw * saturate(keyFrameProgress - 11.0);
float returnProgress = saturate(animationProgress - _AnimationCount);
positionOS.xy = lerp(positionOS.xy, input.positionOS.xy, returnProgress);

可以看到，从最后一个姿态回到初始姿态的计算与之前稍有不同：需要从最后一个姿态插值到初始姿态，而不是直接把变化量累加到前一个位置上。

目前演示的内容都是基于单张图片生成，没有进行任何图片分层。做过 Live2D 或 Spine 的同学应该知道，单张图片通常是不够的。例如，当衣服和皮肤相连的部位发生顶点变形时，衣服会带着皮肤一起变形，造成肌肉异常扭曲、局部异常膨胀等问题。对于这些区域，需要明确要求 AI 不要进行大幅变形。

解决思路是对图片进行分层。前面介绍的技术在分层后依然适用，但需要让 AI 在生成 Mesh 时注意各层相对于原点的坐标。

但目前 AI 还无法很好地完成切图分层，等相关能力更加成熟后，我会再补充后续工作流。

即便如此，本文介绍的方案依然具有实际意义。现在仍有大量游戏，尤其是低成本独立游戏，其立绘和部分场景元素仍然使用静态图片。通过这种方式，可以用几乎零成本将这些图片转换成动态图，从而提升画面表现力和制作效率。

本工程提供了一个 Unity 编辑器工具，用于将初始姿态和后续姿态 Mesh 的顶点差值编码到最终 Mesh 中。使用步骤如下：

1. 使用 Unity 打开 ImageToMeshAnim_Unity 工程。
2. 在顶部菜单中选择 Tools > Mesh > Encode Vertex Key Frames，打开编码工具。
3. 将初始姿态 Mesh 放入 Start Pose Mesh，再按照播放顺序将 1～12 个后续姿态 Mesh 放入 Animation Pose Meshes。所有 Mesh 都必须满足前文所述的硬性约束。
4. 单击 Generate Mesh Asset，选择保存位置并生成包含顶点动画数据的 Mesh 资源。
5. 创建材质并选择 ImageToMeshAnim/Vertex Delta Shader，然后设置原始贴图，并将 _AnimationCount 设置为后续姿态 Mesh 的实际数量。
6. 将生成的 Mesh 和材质赋给 MeshFilter、MeshRenderer，再通过 Animation、脚本或其他方式让材质参数 _AnimationProgress 从 0 变化到 1，即可循环播放动画。

工程中的 Assets/ImageToMesh/Sample/GeneratedMeshes/MaoNiang 提供了完整示例，包括生成后的 Mesh、材质、动画片段、Animator Controller 和 Prefab，可用于对照设置。

将下面的提示词复制给能够读取图片、视频并操作 Unity 工程的 AI Agent，再替换尖括号中的内容即可使用：

请在指定 Unity 工程中，根据一张角色立绘和一段动作参考视频，生成用于制作循环顶点动画的一组同拓扑姿态 Mesh。不要只给出方案或代码片段，请直接完成初始姿态 Mesh、后续关键姿态 Mesh 及其一致性验证。

输入信息：
- Unity 工程路径：<Unity 工程绝对路径>
- 角色立绘路径：<PNG 图片绝对路径>
- 动作参考视频路径：<MP4 视频绝对路径>
- 角色名称：<角色英文名称>
- 输出目录：<Unity Assets 下的输出目录>

执行要求：
1. 先检查工程结构、Unity 版本和现有资源，优先复用 ImageToMeshAnim 工程中的 ImageMeshRegionConfig 和现有目录结构，不要重复创建功能相同的数据结构。
2. 使用 FFmpeg、OpenCV 或等效工具分析参考视频，识别真正的单次循环区间，排除视频中重复播放的循环，并根据动作变化选择初始姿态和最多 12 个后续关键姿态。
3. 根据角色立绘生成初始 Mesh。使用规则、局部且密度合理的网格；相邻顶点组成局部三角形，禁止跨透明区域、跨身体部位或跨度过大的长三角形边。记录头部、头发、躯干、手臂、手、腿、服装和饰品等区域及其顶点索引。
4. 所有后续姿态 Mesh 必须由初始 Mesh 变形得到，并严格保持相同的顶点数量、顶点索引顺序、三角形拓扑、UV0 对应关系、对象坐标空间、原点、朝向和缩放。每个顶点索引在所有姿态中必须始终对应同一个身体位置。不能重新拓扑，也不能增加、删除、合并或重新排列顶点。
5. 当前动画只允许修改顶点 XY 坐标，不要依赖 Z 轴位移。注意衣服与皮肤、头发与身体、肢体交界处的变形，避免露底、粘连、异常拉伸、局部膨胀和纹理撕裂。
6. 按动作播放顺序保存初始姿态和后续姿态 Mesh，使用清晰、连续的编号命名，并为每个 Mesh 保留对应的区域信息和原始贴图 UV。
7. 完成后逐项检查所有姿态的顶点数、顶点顺序、三角形索引、UV0 和坐标空间，汇总所有生成或修改的文件、关键参数、验证结果及仍然存在的视觉限制。如果发现输入资源不足或动作无法可靠还原，请明确说明具体原因，不要通过改变拓扑或顶点顺序规避问题。

请保留工程中无关的现有修改，不要覆盖其他角色资源；如果目标文件已经存在，请先检查并只更新本次角色对应的文件。

上述提示词默认只负责生成初始姿态 Mesh 和后续姿态 Mesh。如果希望 AI Agent 继续自动完成顶点差值编码、最终 Mesh、材质、Animation Clip、Animator Controller 和 Prefab 等资源，可以根据项目需求在提示词末尾自行追加相应要求。

第一次执行时，AI Agent 通常还需要编写 Mesh 生成、姿态处理、数据校验和 Unity 批处理等中间工具代码，因此耗时可能较长。建议保留这些可复用的工具代码和配置文件，不要在任务结束后删除。后续制作其他角色或动作时，AI Agent 可以直接复用这些文件，生成速度会明显更快。

In many low-budget games, character illustrations are completely static because producing Spine or Live2D animation requires significant time and money. AI can now generate videos easily, but playing video directly in a game is still inconvenient. Converting video into an image sequence is another option, but a smooth sequence of high-resolution character art consumes too much storage and memory to load comfortably.

This article presents a low-cost technique for creating a Live2D-like effect with AI-assisted Mesh generation and vertex animation. It is intended for projects that do not require high-end character animation and offers relatively low memory use, runtime overhead, and production cost. The following Idle animations were created from a single, non-layered character image:

_{Click an animated preview to play the original MP4 video.}

The only initial art asset required is a single image. Other assets are used during production, but they can all be generated from that image; if they already exist, they can be used directly.

FFmpeg and OpenCV are required and can be called through Python. An AI Agent can also help install them.

This project uses Unity for the demonstration, so it is best to prepare a Unity command-line environment and any packages required by the production pipeline. This is important because generating Unity assets may require writing and executing Unity code.

The core idea is similar to Mesh deformation and Blend Shapes: animation is produced by changing Mesh vertex positions. A Mesh can be generated from the source image with AI assistance or created manually. After a series of pose Meshes has been prepared, each pose's vertex positions are subtracted from those of the preceding pose. The resulting deltas are packed into Mesh vertex channels, and a vertex Shader accumulates those values according to the current animation progress.

When generating the Mesh, it is not enough to tell an AI Agent, “Convert this image into a Mesh.” With such a vague instruction, the result may look like this:

This Mesh contains many extremely long triangle edges. Although it appears to separate body regions, it is not suitable for deformation. Moving one local vertex can also move vertices much farther away, causing unnatural full-body motion.

My approach is to define a data structure first, let the AI identify the body regions in the image, and then record the vertex indices belonging to each region. This also provides a stable reference when generating the remaining pose Meshes.

[SerializeField]
private Mesh _mesh;
[SerializeField]
private List<Region> _regionList = new List<Region>();


[Serializable]
public sealed class Region
{
    #region fields
    [SerializeField]
    private string _regionName;
    [SerializeField]
    private int[] _vertexIndices;
    #endregion
    
    #region properties
    public string Name => _regionName;
    public IReadOnlyList<int> VertexIndices => _vertexIndices;
    #endregion
    
    #region methods
    public Region(string name, int[] indices)
    {
        _regionName = name;
        _vertexIndices = indices;
    }
    #endregion
}

Give the Agent explicit topology requirements: use a regular grid with reasonable local density; form small rectangles from adjacent vertices and split each rectangle into two local triangles; never create long triangle edges that cross grid regions, transparent areas, or body parts. A suitable Mesh looks like this:

When only the source image is available, the body-region analysis may not match the intended animation. Supplying the target animation as a video or written description gives the AI a more accurate basis for dividing the character into regions.

The next step is to generate the individual pose Meshes. The current implementation supports up to 13 poses, including the initial pose. If an action has a large range of motion or contains back-and-forth movement, interpolating directly from the initial pose to the final pose cannot represent it correctly.

Every pose Mesh must be deformed from the same initial Mesh and satisfy all of the following requirements:

• The vertex count must be identical.
• Vertex indices and ordering must be identical. A given index must always represent the same point on the body in every pose.
• Triangle topology must be identical. Do not retopologize or add, remove, merge, or reorder vertices.
• UV0 count, index mapping, and texture correspondence must remain unchanged so every pose samples the original texture correctly.
• Every pose must use the same object space, origin, orientation, and scale. Do not substitute Transform changes for vertex deformation.
• The current system records XY displacement only, so the animation must not rely on Z-axis movement.

Matching vertex counts alone does not make two Meshes compatible. If vertex ordering or topology changes, the same index will point to a different part of the body, and the encoded animation will tear, jump, or deform large areas incorrectly. The current encoder checks only the vertex count; the remaining constraints must be enforced while generating the pose Meshes.

The action used here comes from a video generated by AI from a character illustration. The illustration itself was also AI-generated:

_{Click the animated preview to play the original MP4 video with audio.}

My workflow is to ask the AI to use both the image and the video as references when generating the pose Meshes.

The AI uses FFmpeg, OpenCV, or equivalent tools to analyze the video and identify the actual loop interval. For example, a ten-second video may simply repeat the same 2.5-second action four times. Treating the entire ten seconds as one loop would place the selected key poses at the wrong points in the motion.

After determining the poses to use, the AI can generate a corresponding Mesh for each one. The final pose must be able to transition smoothly back to the initial pose to preserve the loop.

For efficient animation, each pose is stored as a vertex-position delta relative to the preceding pose. Because the source is a 2D image, only XY displacement needs to be recorded. Twelve subsequent poses therefore require twelve sets of deltas. The current implementation stores them in Normal, Tangent, UV0.zw, and UV1 through UV4, while UV0.xy remains available for texture sampling.

float3 keyFrame1 : NORMAL;
float4 keyFrame2And3 : TANGENT;
float4 uv0AndKeyFrame4 : TEXCOORD0;
float4 keyFrame5And6 : TEXCOORD1;
float4 keyFrame7And8 : TEXCOORD2;
float4 keyFrame9And10 : TEXCOORD3;
float4 keyFrame11And12 : TEXCOORD4;

The Shader exposes an _AnimationProgress parameter in the range 0 to 1 and transforms the vertices with the following calculation:

float animationProgress = saturate(_AnimationProgress) * (_AnimationCount + 1.0);
float keyFrameProgress = min(animationProgress, _AnimationCount);
positionOS.xy += input.keyFrame1.xy * saturate(keyFrameProgress);
positionOS.xy += input.keyFrame2And3.xy * saturate(keyFrameProgress - 1.0);
positionOS.xy += input.keyFrame2And3.zw * saturate(keyFrameProgress - 2.0);
positionOS.xy += input.uv0AndKeyFrame4.zw * saturate(keyFrameProgress - 3.0);
positionOS.xy += input.keyFrame5And6.xy * saturate(keyFrameProgress - 4.0);
positionOS.xy += input.keyFrame5And6.zw * saturate(keyFrameProgress - 5.0);
positionOS.xy += input.keyFrame7And8.xy * saturate(keyFrameProgress - 6.0);
positionOS.xy += input.keyFrame7And8.zw * saturate(keyFrameProgress - 7.0);
positionOS.xy += input.keyFrame9And10.xy * saturate(keyFrameProgress - 8.0);
positionOS.xy += input.keyFrame9And10.zw * saturate(keyFrameProgress - 9.0);
positionOS.xy += input.keyFrame11And12.xy * saturate(keyFrameProgress - 10.0);
positionOS.xy += input.keyFrame11And12.zw * saturate(keyFrameProgress - 11.0);
float returnProgress = saturate(animationProgress - _AnimationCount);
positionOS.xy = lerp(positionOS.xy, input.positionOS.xy, returnProgress);

The transition from the final pose back to the initial pose is calculated differently from the earlier intervals. Instead of adding another delta, the Shader interpolates from the final accumulated position back to the original vertex position.

The demonstrations currently use a single image without any layer separation. Anyone familiar with Live2D or Spine will know that one flat image is usually insufficient. For example, when vertices at a boundary between clothing and skin are deformed, the clothing can drag the skin with it, causing unnatural muscle distortion or local swelling. Large deformations should be avoided in those areas.

The general solution is to split the image into layers. The same vertex-animation technique remains applicable, but each layer's Mesh must preserve a consistent position relative to the shared origin.

At present, AI still cannot perform reliable image-layer separation in every case. A complete layered workflow can be added when this capability becomes more mature.

Even with these limitations, the technique remains useful. Many games, especially low-budget indie games, still rely on static character illustrations and scene elements. This approach can turn some of those images into animated assets at almost no additional production cost, improving visual presentation and production efficiency.

This project includes a Unity Editor tool that encodes the vertex deltas between an initial pose and subsequent pose Meshes into a final Mesh. Use it as follows:

1. Open the ImageToMeshAnim_Unity project in Unity.
2. Select Tools > Mesh > Encode Vertex Key Frames from the main menu.
3. Assign the initial pose Mesh to Start Pose Mesh, then add 1 to 12 subsequent pose Meshes to Animation Pose Meshes in playback order. Every Mesh must satisfy the hard requirements listed above.
4. Click Generate Mesh Asset, choose a save location, and generate the Mesh asset containing the vertex-animation data.
5. Create a material with the ImageToMeshAnim/Vertex Delta Shader, assign the original texture, and set _AnimationCount to the actual number of subsequent pose Meshes.
6. Assign the generated Mesh and material to a MeshFilter and MeshRenderer. Animate the material's _AnimationProgress parameter from 0 to 1 with an Animation Clip, script, or another system to play the loop.

The sample at Assets/ImageToMesh/Sample/GeneratedMeshes/MaoNiang includes the generated Mesh, material, Animation Clip, Animator Controller, and Prefab for reference.

Copy the prompt below into an AI Agent that can inspect images and videos and operate a Unity project. Replace the text in angle brackets before using it:

In the specified Unity project, use one character illustration and one action-reference video to generate a set of topology-identical pose Meshes for a loopable vertex animation. Do not stop at a plan or code snippets. Generate the initial-pose Mesh, the subsequent key-pose Meshes, and validate their consistency.

Inputs:
- Unity project path: <absolute path to the Unity project>
- Character illustration path: <absolute path to the PNG image>
- Action-reference video path: <absolute path to the MP4 video>
- Character name: <English character name>
- Output directory: <output directory under Unity Assets>

Requirements:
1. Inspect the project structure, Unity version, and existing assets first. Reuse ImageMeshRegionConfig and the existing directory structure in the ImageToMeshAnim project instead of creating duplicate data structures.
2. Analyze the reference video with FFmpeg, OpenCV, or equivalent tools. Identify the true single-loop interval, exclude repeated copies of the loop, and select an initial pose plus no more than 12 subsequent key poses according to meaningful changes in the motion.
3. Generate the initial Mesh from the character illustration. Use a regular, local grid with reasonable density. Adjacent vertices should form local triangles. Never create long triangle edges that cross transparent areas, body regions, or an excessive distance. Record the vertex indices for the head, hair, torso, arms, hands, legs, clothing, accessories, and other relevant regions.
4. Every subsequent pose Mesh must be deformed from the initial Mesh and preserve exactly the same vertex count, vertex-index order, triangle topology, UV0 correspondence, object space, origin, orientation, and scale. A vertex index must always represent the same body location in every pose. Do not retopologize, add, remove, merge, or reorder vertices.
5. The current animation supports XY vertex displacement only. Do not rely on Z-axis movement. Pay particular attention to boundaries between clothing and skin, hair and body, and connected limbs. Avoid exposed gaps, sticking, excessive stretching, local swelling, and texture tearing.
6. Save the initial and subsequent pose Meshes in playback order with clear, consecutive numbering. Preserve the region data and original texture UVs for every Mesh.
7. Validate the vertex count, vertex order, triangle indices, UV0 data, and coordinate space of every pose. Report every generated or modified file, important parameters, validation results, and remaining visual limitations. If the input assets are insufficient or the action cannot be reconstructed reliably, explain the exact reason instead of working around it by changing topology or vertex order.

Preserve unrelated existing changes in the project and do not overwrite assets belonging to other characters. If a target file already exists, inspect it first and update only files associated with this character.

By default, this prompt generates only the initial and subsequent pose Meshes. If you want the AI Agent to also perform vertex-delta encoding and create the final Mesh, material, Animation Clip, Animator Controller, and Prefab, append those requirements to the prompt according to your project's needs.

On the first run, the AI Agent will usually need to create reusable intermediate tooling for Mesh generation, pose processing, data validation, and Unity batch operations, so the task may take longer. Keep these reusable scripts and configuration files instead of deleting them when the task finishes. The Agent can reuse them for later characters or actions, making subsequent generation noticeably faster.

That concludes this article. Feedback and discussion are welcome.

以上就是本文的全部内容，欢迎讨论。