Animation Composer Skill

The Animation Composer orchestrates complex multi-part animations by breaking them into logical acts, coordinating timing, and managing transitions between scenes.

Core Concepts

Scene Graph Architecture

SceneGraph
├── GlobalStyle (colors, fonts, camera)
├── Acts[]
│   ├── Mobjects[] (visual elements)
│   ├── Animations[] (transformations)
│   └── Transitions (fade, slide, zoom)
└── Timeline (duration, pacing)

Act Structure

Each animation is composed of one or more Acts:

Introduction Act: Set the stage, introduce key elements
Development Acts: Build complexity, show transformations
Conclusion Act: Summarize, highlight key takeaways

Rules

rules/scene-structure.md

Guidelines for structuring scenes with clear beginnings, middles, and ends.

rules/timing-coordination.md

Best practices for coordinating multiple animations and avoiding visual clutter.

rules/transitions.md

Smooth transitions between acts using fades, slides, and morphs.

rules/camera-control.md

Camera movements, zooms, and focus to guide viewer attention.

Templates

Basic Multi-Act Scene

from manim import *

class ComposedScene(Scene):
    def construct(self):
        # Act 1: Introduction
        title = Text("Introduction").scale(1.5)
        self.play(Write(title))
        self.wait(1)
        self.play(FadeOut(title))

        # Act 2: Main Content
        content = self.create_main_content()
        self.play(Create(content))
        self.animate_content(content)

        # Act 3: Conclusion
        self.play(FadeOut(content))
        conclusion = Text("Key Takeaway").scale(1.2)
        self.play(FadeIn(conclusion))

Camera-Controlled Scene

from manim import *

class CameraComposedScene(MovingCameraScene):
    def construct(self):
        # Create elements at different positions
        left_group = self.create_left_section().shift(LEFT * 4)
        right_group = self.create_right_section().shift(RIGHT * 4)

        # Act 1: Overview
        self.camera.frame.scale(2)
        self.add(left_group, right_group)
        self.wait()

        # Act 2: Focus on left
        self.play(self.camera.frame.animate.scale(0.5).move_to(left_group))
        self.animate_left(left_group)

        # Act 3: Focus on right
        self.play(self.camera.frame.animate.move_to(right_group))
        self.animate_right(right_group)

        # Act 4: Zoom out for conclusion
        self.play(self.camera.frame.animate.scale(2).move_to(ORIGIN))

Composition Patterns

Sequential Composition

Elements appear one after another in a logical sequence.

self.play(Create(element1))
self.play(Create(element2))
self.play(Create(element3))

Parallel Composition

Multiple elements animate simultaneously for visual impact.

self.play(
    Create(element1),
    Create(element2),
    Create(element3)
)

Staggered Composition

Elements appear with slight delays for a cascading effect.

self.play(LaggedStart(
    *[Create(e) for e in elements],
    lag_ratio=0.2
))

Hierarchical Composition

Parent-child relationships for grouped animations.

group = VGroup(child1, child2, child3)
self.play(Create(group))  # All children animate together

Best Practices

Start simple, build complexity - Introduce elements gradually
Use visual hierarchy - Important elements should be larger/brighter
Maintain rhythm - Consistent timing creates professional feel
Guide the eye - Use camera and highlights to direct attention
End with impact - Conclusions should be memorable

Anti-Patterns to Avoid

Overwhelming the viewer with too many simultaneous elements
Inconsistent timing that feels jarring
Missing transitions between conceptually different sections
Ignoring visual hierarchy (everything same size/color)

animation-composer