# Animation Libraries Integrated into the Undertale-Changer Template: A Complete Technical Guide

> Explore the Undertale-Changer template's integrated animation libraries. This technical guide details Unity 2D, TextMeshPro, Live2D Cubism, and Unity Timeline for dynamic character animation and cutscenes.

- Repository: [Archived AIk/undertale-changer-template](https://github.com/arch-aik/undertale-changer-template)
- Tags: technical-guide
- Published: 2026-02-25

---

**The Undertale-Changer template integrates eight distinct animation libraries, including Unity's built-in 2D animation system, TextMeshPro for vertex-based text effects, the Live2D Cubism SDK for skeletal 2D character animation, and Unity Timeline for cutscene sequencing.**

The arch-aik/undertale-changer-template provides a comprehensive Unity framework for developing Undertale-style games. Understanding which animation libraries are integrated into the template is essential for developers looking to customize character movements, UI transitions, and cinematic sequences without adding external dependencies.

## Core Unity 2D Animation Packages

The foundation of the template's animation system relies on several official Unity packages defined in [`Packages/manifest.json`](https://github.com/arch-aik/undertale-changer-template/blob/main/Packages/manifest.json).

### Sprite and Keyframe Animation

The `com.unity.2d.animation` package provides the core 2D animation tools, including animation clips, keyframe editing, and sprite-sheet support. This enables traditional frame-by-frame animation for characters and objects using the Unity Animator Controller workflow.

### Procedural Shape Animation

The `com.unity.2d.spriteshape` package enables procedural 2D shape generation that can be animated, such as wavy borders and dynamic terrain that morphs over time without manual frame creation.

### Animated Tile Systems

The `com.unity.2d.tilemap` package includes a tile-map system with animation support for animated tiles, allowing for dynamic backgrounds, flowing water, and environmental effects that cycle through sprite frames automatically.

### Low-Level Animation Engine

The `com.unity.modules.animation` package provides the low-level animation module required by all other animation packages. You can create animation clips programmatically using this module for runtime-generated animations:

```csharp
using UnityEngine;

public class SimpleAnim : MonoBehaviour {
    public Sprite[] frames;
    private AnimationClip clip;

    void Awake() {
        clip = new AnimationClip { frameRate = 12 };
        var curve = AnimationCurve.Linear(0, 0, frames.Length / clip.frameRate, 1);
        clip.SetCurve("", typeof(SpriteRenderer), "m_Sprite", curve);
        var anim = gameObject.AddComponent<Animation>();
        anim.AddClip(clip, "Loop");
        anim.Play("Loop");
    }
}

```

## Live2D Cubism SDK for Skeletal 2D Animation

The template includes the **Live2D Cubism SDK** located under `Assets/Plugins/Live2D/Cubism`, providing full-featured 2D skeletal animation for Live2D models with motion-clip import, blending, and physics support.

The `CubismMotionController` class in [`Assets/Plugins/Live2D/Cubism/Framework/Motion/CubismMotionController.cs`](https://github.com/arch-aik/undertale-changer-template/blob/main/Assets/Plugins/Live2D/Cubism/Framework/Motion/CubismMotionController.cs) serves as the central controller for motion playback. This class provides the `PlayAnimation()` method for playing motion clips with looping and blending capabilities:

```csharp
using Live2D.Cubism.Core;
using Live2D.Cubism.Framework.Motion;
using UnityEngine;

public class Live2DPlay : MonoBehaviour {
    [SerializeField] private CubismMotion motion;
    private CubismMotionController controller;

    void Awake() => controller = GetComponent<CubismMotionController>();

    void Start() => controller.PlayAnimation(motion, isLoop: true);
}

```

The SDK also includes [`Assets/Plugins/Live2D/Cubism/Editor/Importers/CubismMotion3JsonImporter.cs`](https://github.com/arch-aik/undertale-changer-template/blob/main/Assets/Plugins/Live2D/Cubism/Editor/Importers/CubismMotion3JsonImporter.cs), which imports native Live2D [`.motion3.json`](https://github.com/arch-aik/undertale-changer-template/blob/main/.motion3.json) files and converts them into Unity `AnimationClip` assets during the import pipeline.

## Text Animation with TextMeshPro

The `com.unity.textmeshpro` package provides advanced text rendering with animated text effects such as vertex jitter, warp, and color transitions. The template includes example implementations demonstrating vertex manipulation for dynamic UI text.

You can animate text vertices programmatically for effects like shaking or wavy text:

```csharp
using TMPro;
using UnityEngine;

[RequireComponent(typeof(TMP_Text))]
public class JitterExample : MonoBehaviour {
    TMP_Text txt;
    void Awake() => txt = GetComponent<TMP_Text>();

    void Update() {
        var mesh = txt.textInfo.meshInfo;
        for (int i = 0; i < mesh.Length; i++) {
            var verts = mesh[i].vertices;
            for (int v = 0; v < verts.Length; v++) {
                verts[v] += Random.insideUnitSphere * 0.01f;
            }
            mesh[i].mesh.vertices = verts;
        }
        txt.UpdateVertexData();
    }
}

```

## Cutscene Sequencing with Unity Timeline

The `com.unity.timeline` package enables sequencing and blending of animation tracks for cutscenes and scripted events. This allows developers to choreograph complex scenes involving multiple animated objects, camera movements, and audio tracks without writing extensive coroutine-based scripts.

You can trigger Timeline assets programmatically using the `PlayableDirector` component:

```csharp
using UnityEngine;
using UnityEngine.Timeline;
using UnityEngine.Playables;

public class TimelineStarter : MonoBehaviour {
    public PlayableAsset timelineAsset;

    void Start() {
        var playableDirector = gameObject.AddComponent<PlayableDirector>();
        playableDirector.playableAsset = timelineAsset;
        playableDirector.Play();
    }
}

```

## Key Implementation Files and Source Paths

The animation ecosystem in the Undertale-Changer template is defined by these critical files:

- **[`Packages/manifest.json`](https://github.com/arch-aik/undertale-changer-template/blob/main/Packages/manifest.json)** — Lists all Unity package dependencies, including `com.unity.2d.animation`, `com.unity.timeline`, and `com.unity.textmeshpro`.

- **[`Assets/Plugins/Live2D/Cubism/Framework/Motion/CubismMotionController.cs`](https://github.com/arch-aik/undertale-changer-template/blob/main/Assets/Plugins/Live2D/Cubism/Framework/Motion/CubismMotionController.cs)** — Central controller for Live2D motion playback, blending, and looping via the `PlayAnimation` method.

- **[`Assets/Plugins/Live2D/Cubism/Editor/Importers/CubismMotion3JsonImporter.cs`](https://github.com/arch-aik/undertale-changer-template/blob/main/Assets/Plugins/Live2D/Cubism/Editor/Importers/CubismMotion3JsonImporter.cs)** — Editor tool that imports Live2D [`.motion3.json`](https://github.com/arch-aik/undertale-changer-template/blob/main/.motion3.json) files and converts them to Unity `AnimationClip` assets.

- **`Assets/Plugins/TextMesh Pro/Examples & Extras/Scripts/VertexJitter.cs`** — Reference implementation demonstrating vertex-based text animation techniques using TextMeshPro.

## Summary

- The Undertale-Changer template integrates **eight animation libraries** ranging from Unity's native 2D tools to third-party Live2D support.
- **Core animation** relies on `com.unity.2d.animation` and `com.unity.modules.animation` for sprite and keyframe workflows.
- **Live2D Cubism SDK** provides skeletal animation capabilities through `CubismMotionController` for advanced character rigging and physics-based motion.
- **TextMeshPro** enables programmable vertex animation for dynamic UI text effects like jitter and warp.
- **Unity Timeline** handles complex cutscene sequencing and multi-track animation blending for scripted events.

## Frequently Asked Questions

### What is the primary animation system used in the Undertale-Changer template?

The primary system is Unity's built-in 2D animation stack, specifically the `com.unity.2d.animation` package combined with `com.unity.modules.animation`. These provide the foundation for sprite-based keyframe animation and runtime clip generation, while the Live2D Cubism SDK handles skeletal animation for more complex character models requiring physics and bone-based deformation.

### How does the template handle Live2D model animation?

The template includes the Live2D Cubism SDK under `Assets/Plugins/Live2D/Cubism`. Animation playback is managed by the `CubismMotionController` class in [`CubismMotionController.cs`](https://github.com/arch-aik/undertale-changer-template/blob/main/CubismMotionController.cs), which provides the `PlayAnimation()` method for playing motion clips with looping and blending support. The SDK also includes [`CubismMotion3JsonImporter.cs`](https://github.com/arch-aik/undertale-changer-template/blob/main/CubismMotion3JsonImporter.cs) for importing native Live2D [`.motion3.json`](https://github.com/arch-aik/undertale-changer-template/blob/main/.motion3.json) motion files directly into Unity as `AnimationClip` assets.

### Can I use Unity Timeline for cutscenes in this template?

Yes, the `com.unity.timeline` package is included in the template's [`Packages/manifest.json`](https://github.com/arch-aik/undertale-changer-template/blob/main/Packages/manifest.json). You can create Timeline assets to sequence animations, camera movements, and audio tracks. The `PlayableDirector` component can be used to trigger these timelines programmatically, enabling complex cutscene choreography without extensive scripting.

### Which file contains the complete list of animation packages?

The complete list of all integrated animation libraries is defined in [`Packages/manifest.json`](https://github.com/arch-aik/undertale-changer-template/blob/main/Packages/manifest.json) at the repository root. This manifest declares dependencies for `com.unity.2d.animation`, `com.unity.2d.spriteshape`, `com.unity.2d.tilemap`, `com.unity.modules.animation`, `com.unity.textmeshpro`, and `com.unity.timeline`, along with the Live2D SDK plugins located in the `Assets/Plugins` directory.