Grupos de animaciones

Hasta ahora hemos visto animaciones que ocurren o bien en paralelo o bien secuencialmente. ¿Qué ocurre si quiero lanzar animaciones de forma que una empiece antes de que termine la otra? ¿O si quiero que empiecen a la vez pero duren diferente? Para ello tenemos las clases AnimationGroup, LaggedStart, LaggedStartMap y Succession.

AnimationGroup

Como su propio nombre nos indica, agrupa animaciones dentro de sí. Esto nos puede resultar útil si queremos tener animaciones que empiecen a la vez pero que tengan una duración distinta.

animation_group_example.py

from manim import *

class AnimationGroupExample(Scene):
    def construct(self):
        dots = VGroup(
            [
                Dot(color=random_color()) for _ in range(10)
            ]
        ).scale(3).arrange()

        self.wait()
        self.play(
            AnimationGroup(*[Write(dot) for dot in dots[0:5]], run_time=2),
            AnimationGroup(*[Write(dot) for dot in dots[5:]], run_time=4),
        )
        self.wait()

LaggedStart

Con LaggedStart podemos lanzar varias animaciones secuencialmente pero separadas una cantidad de tiempo específica.

lagged_start_example.py

from manim import *

class LaggedStartExample(Scene):
    def construct(self):
        dots = VGroup(
            [
                Dot(color=random_color()) for _ in range(10)
            ]
        ).scale(3).arrange()

        self.wait()
        self.play(
            LaggedStart(
                *[Write(dot) for dot in dots[0:5]],
                *[FadeIn(dot) for dot in dots[5:]]
            ),
            run_time=5
        )
        self.wait()

LaggedStartMap

Es similar a LaggedStart con la diferencia de que aquí aplicamos la misma animación a todos los objetos

lagged_start_map_example.py

from manim import *

class LaggedStartMapExample(Scene):
    def construct(self):
        dots = VGroup(
            [
                Dot(color=random_color()) for _ in range(10)
            ]
        ).scale(3).arrange()

        self.wait()
        self.play(
            LaggedStartMap(
                Write,
                dots
            ),
            run_time=5
        )
        self.wait()

Succession

Lanza las animaciones una tras otra. Nos ayuda a no tener que escribir muchas veces self.play.

succession_example.py

from manim import *

class SuccessionExample(Scene):
    def construct(self):
        dots = VGroup(
            [
                Dot(color=random_color()) for _ in range(10)
            ]
        ).scale(3).arrange()

        self.wait()
        self.play(
            Succession(
                *[Write(dot) for dot in dots]
            ),
            run_time=5
        )
        self.wait()