manim-mcp 0.1.0

package/references/manimce/rules/timing.md

@@ -0,0 +1,227 @@
+---
+name: timing
+description: Rate functions, easing, run_time, and animation timing control
+metadata:
+  tags: timing, rate_func, easing, smooth, linear, run_time
+---
+
+# Animation Timing
+
+Control the speed and feel of animations with timing parameters.
+
+## run_time
+
+Controls how long an animation takes in seconds.
+
+```python
+from manim import *
+
+class RunTimeExample(Scene):
+    def construct(self):
+        circle = Circle()
+
+        # Default (1 second)
+        self.play(Create(circle))
+
+        # Longer animation
+        self.play(circle.animate.shift(RIGHT), run_time=3)
+
+        # Quick animation
+        self.play(circle.animate.set_color(RED), run_time=0.5)
+```
+
+## Rate Functions
+
+Rate functions control how the animation progresses over time (easing).
+
+### Using Rate Functions
+
+```python
+self.play(
+    circle.animate.shift(RIGHT),
+    rate_func=smooth
+)
+```
+
+### Common Rate Functions
+
+```python
+# Smooth start and end (default for most animations)
+smooth
+
+# Constant speed
+linear
+
+# Start slow, end fast
+rush_into
+
+# Start fast, end slow
+rush_from
+
+# Go there and back
+there_and_back
+
+# Go there and back with pause
+there_and_back_with_pause
+
+# Double smooth (extra smooth)
+double_smooth
+
+# Stay put (useful for delays in AnimationGroup)
+lingering
+```
+
+### Ease Functions (CSS-like)
+
+```python
+# Ease in (start slow)
+ease_in_sine
+ease_in_quad
+ease_in_cubic
+ease_in_expo
+ease_in_circ
+ease_in_back    # Slight overshoot at start
+
+# Ease out (end slow)
+ease_out_sine
+ease_out_quad
+ease_out_cubic
+ease_out_expo
+ease_out_circ
+ease_out_back   # Slight overshoot at end
+ease_out_bounce # Bouncy ending
+
+# Ease in-out (slow at both ends)
+ease_in_out_sine
+ease_in_out_quad
+ease_in_out_cubic
+ease_in_out_expo
+ease_in_out_circ
+ease_in_out_back
+```
+
+## Visual Comparison
+
+```python
+class RateFuncComparison(Scene):
+    def construct(self):
+        funcs = [linear, smooth, rush_into, rush_from, there_and_back]
+        names = ["linear", "smooth", "rush_into", "rush_from", "there_and_back"]
+
+        dots = VGroup()
+        labels = VGroup()
+
+        for i, (func, name) in enumerate(zip(funcs, names)):
+            dot = Dot().shift(LEFT * 4 + DOWN * i)
+            label = Text(name, font_size=24).next_to(dot, LEFT)
+            dots.add(dot)
+            labels.add(label)
+
+        self.add(dots, labels)
+
+        self.play(*[
+            dot.animate(rate_func=func).shift(RIGHT * 8)
+            for dot, func in zip(dots, funcs)
+        ], run_time=3)
+```
+
+## Combining run_time and rate_func
+
+```python
+self.play(
+    square.animate.shift(RIGHT * 3),
+    run_time=2,
+    rate_func=ease_out_bounce
+)
+```
+
+## there_and_back
+
+Animation goes forward then reverses.
+
+```python
+class ThereAndBackExample(Scene):
+    def construct(self):
+        square = Square()
+        self.add(square)
+
+        # Moves right then back to start
+        self.play(
+            square.animate.shift(RIGHT * 2),
+            rate_func=there_and_back,
+            run_time=2
+        )
+```
+
+## Custom Rate Functions
+
+Create your own rate function (takes t from 0 to 1, returns progress 0 to 1):
+
+```python
+def my_rate_func(t):
+    # Quadratic ease
+    return t ** 2
+
+self.play(
+    circle.animate.shift(RIGHT),
+    rate_func=my_rate_func
+)
+```
+
+## wait() Timing
+
+```python
+# Wait for default time (1 second)
+self.wait()
+
+# Wait for specific duration
+self.wait(2)    # 2 seconds
+self.wait(0.5)  # Half second
+```
+
+## Animation Speed Multiplier
+
+Using `run_time` on AnimationGroup affects all children:
+
+```python
+self.play(AnimationGroup(
+    Create(circle),
+    Create(square),
+    lag_ratio=0.5
+), run_time=3)  # Total duration is 3 seconds
+```
+
+## Voiceover Timing with tracker.duration
+
+When using `manim-voiceover`, sync animations to speech using `tracker.duration`:
+
+```python
+with self.voiceover(text="Watch this circle appear.") as tracker:
+    self.play(Create(circle), run_time=tracker.duration)
+```
+
+**CRITICAL**: `tracker.get_remaining()` does NOT exist — it will raise AttributeError.
+The voiceover context manager automatically waits for the audio to finish when the `with` block exits.
+If you need a pause, just use `self.wait()` — never `tracker.get_remaining()`.
+
+```python
+# WRONG — will crash
+with self.voiceover(text="...") as tracker:
+    self.play(Create(circle), run_time=tracker.duration * 0.5)
+    self.wait(tracker.get_remaining())  # AttributeError!
+
+# CORRECT — context manager handles remaining time
+with self.voiceover(text="...") as tracker:
+    self.play(Create(circle), run_time=tracker.duration * 0.5)
+    self.play(circle.animate.shift(RIGHT), run_time=tracker.duration * 0.5)
+    # No need to wait — the with block auto-waits for audio to finish
+```
+
+## Best Practices
+
+1. **Use smooth for most animations** - Looks natural
+2. **Use linear for constant motion** - Mechanical/precise movement
+3. **Use ease_out_bounce for playful effects** - Attention-grabbing
+4. **Keep run_time between 0.5-3 seconds** - Maintain viewer attention
+5. **Use there_and_back for emphasis** - Show something temporarily
+6. **Match rate_func to content** - Smooth for elegant, bouncy for fun

package/references/manimce/rules/transform-animations.md

@@ -0,0 +1,157 @@
+---
+name: transform-animations
+description: Transform, ReplacementTransform, and morphing animations
+metadata:
+  tags: transform, replacementtransform, morph, transformfromcopy
+---
+
+# Transform Animations
+
+Animations that morph one mobject into another.
+
+## Transform
+
+Morphs the source mobject into the shape of the target. The source mobject is modified.
+
+```python
+class TransformExample(Scene):
+    def construct(self):
+        square = Square()
+        circle = Circle()
+
+        self.play(Create(square))
+        self.play(Transform(square, circle))
+        # Note: 'square' now looks like 'circle' but is still 'square'
+```
+
+**Important:** After Transform, the original variable still references the mobject, even though it looks like the target.
+
+## ReplacementTransform
+
+Morphs source into target and replaces the reference. More intuitive for most uses.
+
+```python
+class ReplacementTransformExample(Scene):
+    def construct(self):
+        square = Square()
+        circle = Circle()
+        triangle = Triangle()
+
+        self.play(Create(square))
+        self.play(ReplacementTransform(square, circle))
+        # 'square' is removed, 'circle' is now in the scene
+        self.play(ReplacementTransform(circle, triangle))
+        # 'circle' is removed, 'triangle' is now in the scene
+```
+
+## Transform vs ReplacementTransform
+
+```python
+# Transform - source variable changes appearance
+self.play(Transform(A, B))
+# A is still in scene (but looks like B)
+# B is NOT in scene
+
+# ReplacementTransform - source is replaced by target
+self.play(ReplacementTransform(A, B))
+# A is removed from scene
+# B is now in scene
+```
+
+## TransformFromCopy
+
+Creates a copy of source and morphs it to target. Original remains unchanged.
+
+```python
+class TransformFromCopyExample(Scene):
+    def construct(self):
+        square = Square().shift(LEFT * 2)
+        circle = Circle().shift(RIGHT * 2)
+
+        self.add(square)
+        self.play(TransformFromCopy(square, circle))
+        # Both square and circle are now visible
+```
+
+## TransformMatchingShapes
+
+Intelligently matches and transforms corresponding parts.
+
+```python
+class MatchingShapesExample(Scene):
+    def construct(self):
+        source = Text("ABC")
+        target = Text("ABCD")
+
+        self.play(Write(source))
+        self.play(TransformMatchingShapes(source, target))
+```
+
+## TransformMatchingTex
+
+Matches LaTeX parts by their TeX strings.
+
+```python
+class MatchingTexExample(Scene):
+    def construct(self):
+        eq1 = MathTex("a", "^2", "+", "b", "^2")
+        eq2 = MathTex("a", "^2", "+", "2ab", "+", "b", "^2")
+
+        self.play(Write(eq1))
+        self.play(TransformMatchingTex(eq1, eq2))
+```
+
+## MoveToTarget
+
+Pre-set a target state and animate to it.
+
+```python
+class MoveToTargetExample(Scene):
+    def construct(self):
+        square = Square()
+        self.add(square)
+
+        # Generate and modify target
+        square.generate_target()
+        square.target.shift(RIGHT * 2)
+        square.target.set_color(RED)
+        square.target.scale(2)
+
+        self.play(MoveToTarget(square))
+```
+
+## Path Arc Transforms
+
+Control the path of transformation with `path_arc`.
+
+```python
+class PathArcExample(Scene):
+    def construct(self):
+        dot1 = Dot(LEFT * 2)
+        dot2 = Dot(RIGHT * 2)
+
+        self.add(dot1)
+        # Transform along an arc
+        self.play(Transform(dot1, dot2, path_arc=PI/2))
+```
+
+## Chained Transformations
+
+```python
+class ChainedExample(Scene):
+    def construct(self):
+        shape = Square()
+        self.play(Create(shape))
+
+        # Chain of transformations
+        for target in [Circle(), Triangle(), Star()]:
+            self.play(Transform(shape, target))
+            self.wait(0.5)
+```
+
+## Best Practices
+
+1. **Use ReplacementTransform for clarity** - More intuitive variable behavior
+2. **Use TransformFromCopy to preserve original** - When you need both visible
+3. **Use TransformMatchingTex for equations** - Better alignment of matching parts
+4. **Set path_arc for visual interest** - Curved paths look more dynamic

package/references/manimce/rules/updaters.md

@@ -0,0 +1,226 @@
+---
+name: updaters
+description: Updaters, ValueTracker, and dynamic animations
+metadata:
+  tags: updater, valuetracker, dynamic, always, add_updater
+---
+
+# Updaters and Dynamic Animations
+
+Updaters allow mobjects to automatically update based on other values or mobjects.
+
+## Basic Updaters
+
+Add a function that runs every frame.
+
+```python
+from manim import *
+
+class UpdaterExample(Scene):
+    def construct(self):
+        dot = Dot()
+        label = Text("Follow me").next_to(dot, UP)
+
+        # Label always follows the dot
+        label.add_updater(lambda m: m.next_to(dot, UP))
+
+        self.add(dot, label)
+        self.play(dot.animate.shift(RIGHT * 3), run_time=2)
+        self.play(dot.animate.shift(DOWN * 2), run_time=2)
+```
+
+## Updater Syntax
+
+```python
+# Lambda function
+mobject.add_updater(lambda m: m.move_to(target.get_center()))
+
+# Named function
+def follow_target(mob):
+    mob.next_to(target, RIGHT)
+
+mobject.add_updater(follow_target)
+
+# With dt (delta time) parameter
+def time_based_update(mob, dt):
+    mob.rotate(dt * PI)  # Rotate based on time elapsed
+
+mobject.add_updater(time_based_update)
+```
+
+## ValueTracker
+
+A mobject that holds a numeric value. Perfect for animating parameters.
+
+```python
+class ValueTrackerExample(Scene):
+    def construct(self):
+        # Create tracker
+        tracker = ValueTracker(0)
+
+        # Create number display
+        number = DecimalNumber(0, num_decimal_places=2)
+        number.add_updater(lambda m: m.set_value(tracker.get_value()))
+
+        # Create circle that grows with tracker
+        circle = Circle()
+        circle.add_updater(lambda m: m.set_width(tracker.get_value()))
+
+        self.add(number, circle)
+
+        # Animate the tracker
+        self.play(tracker.animate.set_value(4), run_time=3)
+        self.play(tracker.animate.set_value(1), run_time=2)
+```
+
+### ValueTracker Operations
+
+```python
+tracker = ValueTracker(5)
+
+# Get and set value
+current = tracker.get_value()
+tracker.set_value(10)
+
+# Increment
+tracker.increment_value(2.5)
+
+# Arithmetic operators (direct manipulation, no animation)
+tracker += 1
+tracker -= 2
+tracker *= 3
+tracker /= 2
+
+# Animate changes
+self.play(tracker.animate.set_value(100))
+self.play(tracker.animate.increment_value(-50))
+```
+
+## DecimalNumber with ValueTracker
+
+Display a changing number:
+
+```python
+class NumberDisplay(Scene):
+    def construct(self):
+        tracker = ValueTracker(0)
+
+        number = DecimalNumber(
+            0,
+            num_decimal_places=2,
+            include_sign=True,
+            font_size=72
+        )
+        number.add_updater(lambda m: m.set_value(tracker.get_value()))
+        number.add_updater(lambda m: m.move_to(ORIGIN))
+
+        self.add(number)
+        self.play(tracker.animate.set_value(100), run_time=3)
+```
+
+## always_redraw
+
+Recreate a mobject every frame based on current values.
+
+```python
+class AlwaysRedrawExample(Scene):
+    def construct(self):
+        tracker = ValueTracker(1)
+
+        # Line that always connects two points based on tracker
+        line = always_redraw(
+            lambda: Line(
+                LEFT * 2,
+                RIGHT * 2 * tracker.get_value()
+            )
+        )
+
+        self.add(line)
+        self.play(tracker.animate.set_value(2), run_time=2)
+        self.play(tracker.animate.set_value(0.5), run_time=2)
+```
+
+## Common Updater Patterns
+
+### Following Another Mobject
+```python
+follower.add_updater(lambda m: m.move_to(leader.get_center()))
+follower.add_updater(lambda m: m.next_to(leader, RIGHT))
+```
+
+### Pointing at Another Mobject
+```python
+arrow = Arrow(ORIGIN, RIGHT)
+arrow.add_updater(lambda m: m.put_start_and_end_on(
+    start.get_center(),
+    end.get_center()
+))
+```
+
+### Rotating Continuously
+```python
+mobject.add_updater(lambda m, dt: m.rotate(dt * PI))
+```
+
+### Matching Properties
+```python
+# Match color
+follower.add_updater(lambda m: m.set_color(leader.get_color()))
+
+# Match position with offset
+follower.add_updater(lambda m: m.move_to(leader.get_center() + UP))
+```
+
+## Removing Updaters
+
+```python
+# Remove specific updater
+mobject.remove_updater(updater_function)
+
+# Remove all updaters
+mobject.clear_updaters()
+
+# Suspend temporarily
+mobject.suspend_updating()
+mobject.resume_updating()
+```
+
+## Updaters with Animations
+
+Updaters continue running during animations:
+
+```python
+class UpdaterDuringAnimation(Scene):
+    def construct(self):
+        dot = Dot()
+        trail = TracedPath(dot.get_center, stroke_color=YELLOW)
+
+        self.add(dot, trail)
+        self.play(dot.animate.shift(RIGHT * 3 + UP * 2), run_time=3)
+```
+
+## TracedPath
+
+Built-in updater for drawing paths:
+
+```python
+class TracedPathExample(Scene):
+    def construct(self):
+        dot = Dot()
+        path = TracedPath(dot.get_center, stroke_width=2, stroke_color=BLUE)
+
+        self.add(dot, path)
+        self.play(
+            dot.animate.shift(RIGHT * 2),
+            dot.animate.shift(UP * 2),
+            run_time=3
+        )
+```
+
+## Best Practices
+
+1. **Use ValueTracker for animated parameters** - Clean and controllable
+2. **Use always_redraw for complex shapes** - When updaters get complicated
+3. **Clear updaters when done** - Prevent performance issues
+4. **Keep updater functions simple** - Complex logic can slow rendering
+5. **Use dt for time-based animations** - Frame-rate independent

package/references/manimce/templates/basic_scene.py

@@ -0,0 +1,64 @@
+"""
+Basic Scene Template for Manim Community
+
+Copy this file and modify to create your own scene.
+
+Render: manim -pql your_file.py YourScene
+"""
+
+from manim import *
+
+
+class YourScene(Scene):
+    """
+    Basic scene template.
+
+    Attributes to configure:
+        - background_color: Scene background (default: BLACK)
+    """
+
+    def construct(self):
+        # ============================================================
+        # SETUP: Configure scene, create initial objects
+        # ============================================================
+
+        # Optional: Set background color
+        # self.camera.background_color = "#1a1a2e"
+
+        # Create your mobjects
+        title = Text("Your Animation Title", font_size=48)
+        shape = Circle(color=BLUE, fill_opacity=0.5)
+
+        # Position objects
+        title.to_edge(UP)
+        shape.move_to(ORIGIN)
+
+        # ============================================================
+        # ANIMATION: Animate your objects
+        # ============================================================
+
+        # Write title
+        self.play(Write(title))
+        self.wait(0.5)
+
+        # Create shape
+        self.play(Create(shape))
+        self.wait(0.5)
+
+        # Transform or animate
+        self.play(shape.animate.scale(1.5).set_color(RED))
+        self.wait()
+
+        # ============================================================
+        # CLEANUP: Final animations, fade out
+        # ============================================================
+
+        self.play(
+            FadeOut(title),
+            FadeOut(shape),
+        )
+        self.wait()
+
+
+# Run this specific scene:
+# manim -pql basic_scene.py YourScene