manim-mcp 0.1.0

package/references/manimce/examples/updater_patterns.py

@@ -0,0 +1,369 @@
+"""
+Updater and ValueTracker Patterns for Manim Community
+
+Demonstrates dynamic animations using updaters and ValueTracker.
+Adapted from 3b1b's animation patterns for ManimCE.
+
+Run with: manim -pql updater_patterns.py SceneName
+"""
+
+from manim import *
+import numpy as np
+
+
+class BasicUpdater(Scene):
+    """Simple updater that makes an object follow another."""
+
+    def construct(self):
+        # Leader dot
+        leader = Dot(color=RED, radius=0.2)
+        leader_label = Text("Leader", font_size=24).next_to(leader, UP)
+
+        # Follower that always stays next to leader
+        follower = Dot(color=BLUE, radius=0.15)
+        follower.add_updater(lambda m: m.next_to(leader, RIGHT, buff=0.5))
+
+        follower_label = Text("Follower", font_size=24, color=BLUE)
+        follower_label.add_updater(lambda m: m.next_to(follower, DOWN))
+
+        self.add(leader, leader_label, follower, follower_label)
+
+        # Move the leader - follower automatically follows
+        self.play(leader.animate.shift(RIGHT * 3), run_time=2)
+        self.play(leader.animate.shift(UP * 2), run_time=2)
+        self.play(leader.animate.shift(LEFT * 4 + DOWN), run_time=2)
+        self.wait()
+
+
+class ValueTrackerBasics(Scene):
+    """Demonstrates ValueTracker for animating numeric values."""
+
+    def construct(self):
+        # Create a ValueTracker
+        tracker = ValueTracker(0)
+
+        # DecimalNumber that displays the tracker value
+        number = DecimalNumber(
+            0,
+            num_decimal_places=2,
+            font_size=72,
+            include_sign=True
+        )
+        number.add_updater(lambda m: m.set_value(tracker.get_value()))
+
+        # Label
+        label = Text("Value: ", font_size=48)
+        label.next_to(number, LEFT)
+
+        self.add(label, number)
+
+        # Animate the tracker
+        self.play(tracker.animate.set_value(10), run_time=2)
+        self.wait(0.5)
+        self.play(tracker.animate.set_value(-5), run_time=2)
+        self.wait(0.5)
+        self.play(tracker.animate.set_value(0), run_time=1)
+        self.wait()
+
+
+class CircleRadiusTracker(Scene):
+    """Circle that grows/shrinks with a ValueTracker."""
+
+    def construct(self):
+        tracker = ValueTracker(1)
+
+        # Circle with radius controlled by tracker
+        circle = always_redraw(
+            lambda: Circle(
+                radius=tracker.get_value(),
+                color=BLUE,
+                fill_opacity=0.3
+            )
+        )
+
+        # Radius label
+        radius_text = always_redraw(
+            lambda: MathTex(
+                f"r = {tracker.get_value():.2f}"
+            ).to_edge(UP)
+        )
+
+        self.add(circle, radius_text)
+
+        # Animate radius changes
+        self.play(tracker.animate.set_value(2.5), run_time=2)
+        self.play(tracker.animate.set_value(0.5), run_time=2)
+        self.play(tracker.animate.set_value(1.5), run_time=1)
+        self.wait()
+
+
+class RotatingUpdater(Scene):
+    """Object that rotates continuously using dt (delta time)."""
+
+    def construct(self):
+        # Create rotating group
+        square = Square(side_length=2, color=BLUE, fill_opacity=0.5)
+        dot = Dot(color=RED).move_to(square.get_corner(UR))
+
+        group = VGroup(square, dot)
+
+        # Add rotation updater with dt for smooth rotation
+        group.add_updater(lambda m, dt: m.rotate(dt * PI / 2))
+
+        self.add(group)
+        self.wait(4)  # Watch it rotate
+
+        # Remove updater
+        group.clear_updaters()
+        self.wait()
+
+
+class TracedPathExample(Scene):
+    """Demonstrates TracedPath for drawing motion trails."""
+
+    def construct(self):
+        # Moving dot
+        dot = Dot(color=RED, radius=0.15)
+        dot.move_to(LEFT * 3)
+
+        # Traced path follows the dot
+        traced_path = TracedPath(
+            dot.get_center,
+            stroke_color=YELLOW,
+            stroke_width=3
+        )
+
+        self.add(traced_path, dot)
+
+        # Move dot in a pattern
+        self.play(
+            dot.animate.shift(RIGHT * 3 + UP * 2),
+            run_time=1.5
+        )
+        self.play(
+            dot.animate.shift(RIGHT * 2 + DOWN * 3),
+            run_time=1.5
+        )
+        self.play(
+            dot.animate.shift(LEFT * 2 + UP * 1),
+            run_time=1.5
+        )
+        self.wait()
+
+
+class SineWaveTracker(Scene):
+    """Animated sine wave using ValueTracker."""
+
+    def construct(self):
+        # Phase tracker
+        phase = ValueTracker(0)
+
+        # Axes
+        axes = Axes(
+            x_range=[0, 2 * PI, PI / 2],
+            y_range=[-1.5, 1.5, 0.5],
+            x_length=10,
+            y_length=4,
+        )
+
+        # Sine wave that updates with phase
+        sine_wave = always_redraw(
+            lambda: axes.plot(
+                lambda x: np.sin(x + phase.get_value()),
+                color=BLUE,
+                x_range=[0, 2 * PI]
+            )
+        )
+
+        # Dot that follows the wave
+        dot = always_redraw(
+            lambda: Dot(color=RED).move_to(
+                axes.c2p(PI, np.sin(PI + phase.get_value()))
+            )
+        )
+
+        self.add(axes, sine_wave, dot)
+
+        # Animate phase change (wave shifts)
+        self.play(
+            phase.animate.set_value(2 * PI),
+            run_time=4,
+            rate_func=linear
+        )
+
+
+class ArrowUpdater(Scene):
+    """Arrow that always points from one object to another."""
+
+    def construct(self):
+        # Two dots
+        dot1 = Dot(color=BLUE, radius=0.2).shift(LEFT * 2)
+        dot2 = Dot(color=RED, radius=0.2).shift(RIGHT * 2)
+
+        # Arrow that always connects them
+        arrow = always_redraw(
+            lambda: Arrow(
+                dot1.get_center(),
+                dot2.get_center(),
+                buff=0.3,
+                color=YELLOW
+            )
+        )
+
+        # Distance label
+        distance = always_redraw(
+            lambda: DecimalNumber(
+                np.linalg.norm(dot2.get_center() - dot1.get_center()),
+                num_decimal_places=2,
+                font_size=36
+            ).next_to(arrow, UP)
+        )
+
+        self.add(dot1, dot2, arrow, distance)
+
+        # Move dots around
+        self.play(dot1.animate.shift(UP * 2), run_time=1.5)
+        self.play(dot2.animate.shift(DOWN + LEFT * 2), run_time=1.5)
+        self.play(
+            dot1.animate.shift(RIGHT * 3),
+            dot2.animate.shift(UP * 2),
+            run_time=2
+        )
+        self.wait()
+
+
+class ParametricCurveTracer(Scene):
+    """Traces a parametric curve using ValueTracker."""
+
+    def construct(self):
+        # Parameter t
+        t_tracker = ValueTracker(0)
+
+        # Parametric curve (Lissajous)
+        def parametric_func(t):
+            return np.array([
+                2 * np.sin(2 * t),
+                2 * np.sin(3 * t),
+                0
+            ])
+
+        # Dot at current position
+        dot = always_redraw(
+            lambda: Dot(color=RED, radius=0.15).move_to(
+                parametric_func(t_tracker.get_value())
+            )
+        )
+
+        # Traced path
+        path = TracedPath(
+            dot.get_center,
+            stroke_color=BLUE,
+            stroke_width=2
+        )
+
+        self.add(path, dot)
+
+        # Trace the curve
+        self.play(
+            t_tracker.animate.set_value(2 * PI),
+            run_time=6,
+            rate_func=linear
+        )
+        self.wait()
+
+
+class MultipleTrackers(Scene):
+    """Using multiple ValueTrackers together."""
+
+    def construct(self):
+        # Separate trackers for x and y
+        x_tracker = ValueTracker(0)
+        y_tracker = ValueTracker(0)
+
+        # Dot controlled by both trackers
+        dot = always_redraw(
+            lambda: Dot(color=RED, radius=0.2).move_to(
+                RIGHT * x_tracker.get_value() + UP * y_tracker.get_value()
+            )
+        )
+
+        # Coordinate display
+        coords = always_redraw(
+            lambda: MathTex(
+                f"({x_tracker.get_value():.1f}, {y_tracker.get_value():.1f})"
+            ).to_corner(UL)
+        )
+
+        self.add(dot, coords)
+
+        # Animate both trackers
+        self.play(x_tracker.animate.set_value(3), run_time=1.5)
+        self.play(y_tracker.animate.set_value(2), run_time=1.5)
+        self.play(
+            x_tracker.animate.set_value(-2),
+            y_tracker.animate.set_value(-1),
+            run_time=2
+        )
+        self.wait()
+
+
+class SpringMassSimulation(Scene):
+    """Simple physics simulation with updaters."""
+
+    def construct(self):
+        # Physics parameters
+        k = 10  # Spring constant
+        mass = 1
+        damping = 0.5
+
+        # State trackers
+        position = ValueTracker(2)  # Initial displacement
+        velocity = ValueTracker(0)
+
+        # Ground line
+        ground = Line(LEFT * 4, RIGHT * 4, color=WHITE).shift(DOWN * 2)
+
+        # Mass (square)
+        mass_obj = always_redraw(
+            lambda: Square(
+                side_length=0.8,
+                color=BLUE,
+                fill_opacity=0.8
+            ).move_to(UP * position.get_value())
+        )
+
+        # Spring (simplified as line)
+        spring = always_redraw(
+            lambda: Line(
+                ground.get_center() + UP * 0.1,
+                mass_obj.get_bottom(),
+                color=GREY
+            )
+        )
+
+        self.add(ground, spring, mass_obj)
+
+        # Physics update function
+        def physics_update(mob, dt):
+            x = position.get_value()
+            v = velocity.get_value()
+
+            # F = -kx - damping*v
+            acceleration = (-k * x - damping * v) / mass
+            new_v = v + acceleration * dt
+            new_x = x + new_v * dt
+
+            velocity.set_value(new_v)
+            position.set_value(new_x)
+
+        # Add physics updater to a dummy mobject
+        physics_driver = Mobject()
+        physics_driver.add_updater(physics_update)
+        self.add(physics_driver)
+
+        # Let it run
+        self.wait(5)
+
+        # Clean up
+        physics_driver.clear_updaters()
+        self.wait()