manim-mcp 0.1.0

package/references/manimce/rules/mobjects.md

@@ -0,0 +1,116 @@
+---
+name: mobjects
+description: Mobject types, VMobject, and the mobject hierarchy in Manim
+metadata:
+  tags: mobject, vmobject, group, submobjects, hierarchy
+---
+
+# Mobjects in Manim
+
+Mobject (Mathematical Object) is the base class for all displayable objects in Manim.
+
+## Mobject Hierarchy
+
+```
+Mobject (base class)
+├── VMobject (Vectorized Mobject - most common)
+│   ├── Circle, Square, Rectangle, Polygon
+│   ├── Line, Arrow, Vector
+│   ├── Text, MathTex, Tex
+│   ├── Axes, NumberPlane
+│   └── VGroup
+├── ImageMobject (for images)
+├── PMobject (point clouds)
+└── Group (for non-VMobject collections)
+```
+
+## VMobject (Vectorized Mobject)
+
+Most shapes you'll use are VMobjects - they're defined by Bézier curves.
+
+```python
+# Common VMobjects
+circle = Circle()
+square = Square()
+rect = Rectangle(width=4, height=2)
+triangle = Triangle()
+polygon = Polygon(ORIGIN, RIGHT, UP)
+line = Line(LEFT, RIGHT)
+arrow = Arrow(LEFT, RIGHT)
+```
+
+## Creating Custom VMobjects
+
+```python
+class CustomShape(VMobject):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # Define points using set_points_as_corners or set_points_smoothly
+        self.set_points_as_corners([
+            LEFT, UP, RIGHT, DOWN, LEFT
+        ])
+```
+
+## Mobject Properties
+
+### Position and Size
+
+```python
+mobject.get_center()      # Returns center point
+mobject.get_width()       # Returns width
+mobject.get_height()      # Returns height
+mobject.get_top()         # Top edge center point
+mobject.get_bottom()      # Bottom edge center point
+mobject.get_left()        # Left edge center point
+mobject.get_right()       # Right edge center point
+```
+
+### Bounding Box Corners
+
+```python
+mobject.get_corner(UL)    # Upper left corner
+mobject.get_corner(UR)    # Upper right corner
+mobject.get_corner(DL)    # Lower left corner
+mobject.get_corner(DR)    # Lower right corner
+```
+
+## Submobjects
+
+Mobjects can contain other mobjects as submobjects.
+
+```python
+# Access submobjects
+group = VGroup(Circle(), Square())
+group.submobjects      # List of child mobjects
+group[0]               # First submobject (Circle)
+group[1]               # Second submobject (Square)
+
+# Iterate over submobjects
+for mob in group:
+    mob.set_color(RED)
+```
+
+## Copying Mobjects
+
+```python
+# Create a copy
+circle_copy = circle.copy()
+
+# Copy and position
+circle_copy = circle.copy().shift(RIGHT * 2)
+```
+
+## Method Chaining
+
+Most mobject methods return `self`, allowing method chaining:
+
+```python
+circle = Circle().set_color(RED).shift(LEFT).scale(2)
+```
+
+## Best Practices
+
+1. **Use VMobject for custom shapes** - Better rendering and animation support
+2. **Prefer VGroup over Group** - VGroup works better with most animations
+3. **Use copy() when reusing** - Avoid unintended modifications to original
+4. **Chain methods for readability** - But break into lines if too long

package/references/manimce/rules/multi-scene-composition.md

@@ -0,0 +1,112 @@
+# Multi-Scene Composition
+
+## The Golden Rule
+
+**Each scene must look visually different from every other scene.** If a viewer paused at a random frame in scene 1 and a random frame in scene 2, they should be able to tell them apart instantly.
+
+## Why This Matters
+
+Each scene renders independently — no shared state, blank canvas each time. The #1 mistake is rebuilding the same base visual (e.g., a labeled triangle) in every scene, creating repetitive content.
+
+## Scene Planning Checklist
+
+Before writing code, verify each scene has:
+- [ ] A **different primary visual** (not the same object rebuilt)
+- [ ] A **different layout** (centered vs. split-screen vs. corner)
+- [ ] A **different purpose** in the argument (introduce → prove → apply)
+
+## Patterns That Work
+
+### Progressive Revelation (Best for Proofs)
+```
+Scene 1: Pose the question with a concrete example
+  → Visual: animated scenario that creates curiosity
+Scene 2: Show the KEY INSIGHT (the "aha" moment)
+  → Visual: geometric proof, rearrangement, or transformation
+Scene 3: Formalize and verify
+  → Visual: equation derivation + numerical check
+```
+
+### Concrete → Abstract → Application
+```
+Scene 1: Specific example with numbers (3-4-5 triangle)
+Scene 2: General principle with variables (a² + b² = c²)
+Scene 3: Surprising application (distance formula, dot product)
+```
+
+### Multiple Perspectives
+```
+Scene 1: Algebraic view (equations, computations)
+Scene 2: Geometric view (shapes, areas, transformations)
+Scene 3: Synthesis (both views together, showing equivalence)
+```
+
+## Anti-Patterns — DO NOT DO THESE
+
+### Repeated Base Visual
+```python
+# BAD — Scene 1
+triangle = Polygon(A, B, C)
+a_label = MathTex("a")
+b_label = MathTex("b")
+c_label = MathTex("c")
+self.play(Create(triangle), Write(a_label), Write(b_label), Write(c_label))
+
+# BAD — Scene 2 rebuilds the SAME thing
+triangle = Polygon(A, B, C)  # Same triangle again!
+a_label = MathTex("a")       # Same labels again!
+```
+
+### Fix: Make Each Scene Visually Distinct
+```python
+# GOOD — Scene 1: Question + concrete example
+title = Text("Can we predict the longest side?")
+triangle_345 = Polygon(...)  # Specific 3-4-5 triangle with numbers
+self.play(Write(title))
+self.play(Create(triangle_345))
+
+# GOOD — Scene 2: Geometric proof (completely different visual)
+# Four copies of the triangle arranged in a square
+big_square = Square(side_length=5)
+triangles = VGroup(*[Polygon(...).rotate(i * PI/2) for i in range(4)])
+inner_square = Square(...)  # The c² square in the middle
+self.play(Create(big_square), LaggedStartMap(Create, triangles))
+
+# GOOD — Scene 3: The equation + verification
+equation = MathTex("a^2", "+", "b^2", "=", "c^2", font_size=72)
+# Show multiple examples: 3-4-5, 5-12-13, 8-15-17
+examples = VGroup(...)
+```
+
+### Slow Rebuilds
+```python
+# BAD — spending 10 seconds rebuilding what the viewer just saw
+with self.voiceover(text="Recall our triangle..."):
+    self.play(Create(triangle), run_time=3)  # Viewer already saw this!
+    self.play(Write(a_label), Write(b_label), Write(c_label), run_time=3)
+```
+
+### Fix: Brief Recap
+```python
+# GOOD — tiny reference in corner, 1-2 seconds max
+small_triangle = triangle_copy.scale(0.3).to_corner(UL)
+self.play(FadeIn(small_triangle), run_time=0.5)
+# Then focus on the NEW content
+```
+
+## Layout Variety
+
+Vary where content appears across scenes:
+
+| Scene | Layout | Example |
+|-------|--------|---------|
+| 1 | Centered, full stage | Big animated diagram |
+| 2 | Split left/right | Proof on left, annotation on right |
+| 3 | Top equation + bottom visual | Formula above, verification below |
+
+## Visual Identity Per Scene
+
+Give each scene a distinct visual signature:
+- **Scene 1**: Warm colors (RED, ORANGE, YELLOW) — the "question"
+- **Scene 2**: Cool colors (BLUE, GREEN, TEAL) — the "insight"
+- **Scene 3**: Mixed/gold (GOLD, WHITE) — the "conclusion"