manim-mcp 0.1.0

package/references/manimce/rules/grouping.md

@@ -0,0 +1,220 @@
+---
+name: grouping
+description: VGroup, Group, arrange, and layout patterns
+metadata:
+  tags: vgroup, group, arrange, layout, grid, submobjects
+---
+
+# Grouping Mobjects
+
+Organize multiple mobjects into groups for collective manipulation.
+
+## VGroup
+
+VGroup (Vectorized Group) is for grouping VMobjects. Most commonly used.
+
+```python
+from manim import *
+
+class VGroupExample(Scene):
+    def construct(self):
+        # Create a group
+        group = VGroup(
+            Circle(),
+            Square(),
+            Triangle()
+        )
+
+        # Operations apply to all members
+        group.set_color(RED)
+        group.shift(UP)
+
+        self.add(group)
+```
+
+## Group
+
+Group is for mixing different mobject types (VMobjects, ImageMobjects, etc.).
+
+```python
+class GroupExample(Scene):
+    def construct(self):
+        # Mix different types
+        text = Text("Hello")
+        group = Group(
+            Circle(),
+            text
+        )
+        self.add(group)
+```
+
+## Creating Groups
+
+```python
+# From individual mobjects
+group = VGroup(circle, square, triangle)
+
+# From a list
+shapes = [Circle(), Square(), Triangle()]
+group = VGroup(*shapes)
+
+# Using list comprehension
+group = VGroup(*[Circle() for _ in range(5)])
+
+# Empty group, add later
+group = VGroup()
+group.add(Circle())
+group.add(Square())
+```
+
+## arrange
+
+Arrange mobjects in a line.
+
+```python
+class ArrangeExample(Scene):
+    def construct(self):
+        # Horizontal arrangement (default)
+        row = VGroup(*[Circle().scale(0.3) for _ in range(5)])
+        row.arrange(RIGHT, buff=0.5).shift(UP * 2)
+
+        # Vertical arrangement
+        column = VGroup(*[Square().scale(0.3) for _ in range(4)])
+        column.arrange(DOWN, buff=0.5).shift(LEFT * 2)
+
+        # With custom buffer
+        spaced = VGroup(*[Triangle().scale(0.3) for _ in range(3)])
+        spaced.arrange(RIGHT, buff=1).shift(DOWN * 2)
+
+        self.add(row, column, spaced)
+```
+
+### Direction Options
+```python
+group.arrange(RIGHT)      # Left to right
+group.arrange(LEFT)       # Right to left
+group.arrange(UP)         # Bottom to top
+group.arrange(DOWN)       # Top to bottom
+```
+
+## arrange_in_grid
+
+Arrange in a grid pattern.
+
+```python
+class GridExample(Scene):
+    def construct(self):
+        # Auto grid
+        grid = VGroup(*[Square().scale(0.3) for _ in range(20)])
+        grid.arrange_in_grid()
+
+        # Specify rows and columns
+        grid = VGroup(*[Circle().scale(0.2) for _ in range(12)])
+        grid.arrange_in_grid(rows=3, cols=4)
+
+        # With spacing
+        grid.arrange_in_grid(rows=3, cols=4, buff=0.5)
+
+        self.add(grid)
+```
+
+## Accessing Group Members
+
+```python
+group = VGroup(Circle(), Square(), Triangle())
+
+# By index
+first = group[0]          # Circle
+second = group[1]         # Square
+last = group[-1]          # Triangle
+
+# Slicing
+first_two = group[0:2]    # VGroup with Circle and Square
+
+# Iteration
+for mob in group:
+    mob.set_color(random_color())
+
+# Length
+num_items = len(group)
+```
+
+## Modifying Groups
+
+```python
+group = VGroup(Circle(), Square())
+
+# Add mobjects
+group.add(Triangle())
+group.add(Star(), Pentagon())
+
+# Remove mobjects
+group.remove(circle)
+
+# Insert at position
+group.insert(0, new_mobject)
+
+# Submobjects list
+group.submobjects  # List of all children
+```
+
+## Group Transformations
+
+```python
+group = VGroup(Circle(), Square(), Triangle()).arrange(RIGHT)
+
+# All transformations apply to entire group
+group.shift(UP * 2)
+group.scale(0.5)
+group.rotate(PI / 4)
+group.set_color(BLUE)
+
+# But can target individuals
+group[0].set_color(RED)  # Just the circle
+```
+
+## Nested Groups
+
+```python
+class NestedGroups(Scene):
+    def construct(self):
+        # Create sub-groups
+        row1 = VGroup(*[Circle() for _ in range(3)]).arrange(RIGHT)
+        row2 = VGroup(*[Square() for _ in range(3)]).arrange(RIGHT)
+        row3 = VGroup(*[Triangle() for _ in range(3)]).arrange(RIGHT)
+
+        # Group of groups
+        all_rows = VGroup(row1, row2, row3).arrange(DOWN)
+
+        self.add(all_rows)
+```
+
+## Useful Group Methods
+
+```python
+group = VGroup(Circle(), Square(), Triangle())
+
+# Get bounding box info
+group.get_center()
+group.get_width()
+group.get_height()
+
+# Set position for whole group
+group.move_to(ORIGIN)
+group.to_edge(LEFT)
+
+# Copy entire group
+group_copy = group.copy()
+
+# Match layout of another group
+group1.match_height(group2)
+group1.match_width(group2)
+```
+
+## Best Practices
+
+1. **Use VGroup for VMobjects** - Better performance and compatibility
+2. **Use arrange after creating** - Don't position individually then group
+3. **Name your groups semantically** - `equation_parts` not `group1`
+4. **Use nested groups for structure** - Rows within columns, etc.
+5. **Copy groups when needed** - Avoid unintended modifications

package/references/manimce/rules/latex.md

@@ -0,0 +1,202 @@
+---
+name: latex
+description: MathTex, Tex, LaTeX rendering and equation styling in Manim
+metadata:
+  tags: latex, mathtex, tex, equation, formula, math
+---
+
+# LaTeX in Manim
+
+Manim uses LaTeX to render mathematical expressions and formatted text.
+
+## MathTex vs Tex
+
+- **MathTex**: Automatically wraps content in math mode (`align*` environment)
+- **Tex**: Raw LaTeX - you control the mode
+
+```python
+from manim import *
+
+class LaTeXComparison(Scene):
+    def construct(self):
+        # MathTex - auto math mode
+        math = MathTex(r"E = mc^2")
+
+        # Tex - need explicit math delimiters
+        tex = Tex(r"$E = mc^2$")
+
+        # Both render the same
+        VGroup(math, tex).arrange(DOWN)
+        self.add(math, tex)
+```
+
+## Basic MathTex
+
+```python
+class MathTexExample(Scene):
+    def construct(self):
+        # Simple equation
+        eq1 = MathTex(r"x^2 + y^2 = z^2")
+
+        # Fractions
+        eq2 = MathTex(r"\frac{a}{b}")
+
+        # Square roots
+        eq3 = MathTex(r"\sqrt{2}")
+
+        # Greek letters
+        eq4 = MathTex(r"\alpha + \beta = \gamma")
+
+        # Integrals
+        eq5 = MathTex(r"\int_0^\infty e^{-x} dx")
+
+        # Summations
+        eq6 = MathTex(r"\sum_{n=1}^{\infty} \frac{1}{n^2}")
+
+        equations = VGroup(eq1, eq2, eq3, eq4, eq5, eq6).arrange_in_grid(2, 3)
+        self.add(equations)
+```
+
+## Coloring Parts of Equations
+
+### Using set_color_by_tex
+
+```python
+class ColoredEquation(Scene):
+    def construct(self):
+        eq = MathTex(r"e^{i\pi} + 1 = 0")
+        eq.set_color_by_tex("e", RED)
+        eq.set_color_by_tex(r"\pi", BLUE)
+        eq.set_color_by_tex("i", GREEN)
+        self.add(eq)
+```
+
+### Using substrings_to_isolate
+
+For precise coloring, isolate substrings first:
+
+```python
+class IsolatedColoring(Scene):
+    def construct(self):
+        eq = MathTex(
+            r"e^x = x^0 + x^1 + \frac{1}{2}x^2 + \cdots",
+            substrings_to_isolate=["x"]
+        )
+        eq.set_color_by_tex("x", YELLOW)
+        self.add(eq)
+```
+
+### Using index_labels for debugging
+
+```python
+class DebugLabels(Scene):
+    def construct(self):
+        eq = MathTex(r"\frac{a}{b}")
+        # Add index labels to see which index is which part
+        self.add(index_labels(eq[0]))
+        self.add(eq)
+```
+
+### Direct indexing
+
+```python
+eq = MathTex(r"a + b = c")
+eq[0][0].set_color(RED)   # 'a'
+eq[0][2].set_color(BLUE)  # 'b'
+eq[0][4].set_color(GREEN) # 'c'
+```
+
+## Multi-part Equations
+
+Split equations into parts for individual control:
+
+```python
+class MultiPartEquation(Scene):
+    def construct(self):
+        eq = MathTex("a", "^2", "+", "b", "^2", "=", "c", "^2")
+
+        eq[0].set_color(RED)    # a
+        eq[3].set_color(BLUE)   # b
+        eq[6].set_color(GREEN)  # c
+
+        self.play(Write(eq))
+```
+
+## Text with Math (Tex)
+
+```python
+class MixedContent(Scene):
+    def construct(self):
+        # Mix text and math
+        tex = Tex(r"The area is $A = \pi r^2$")
+        self.play(Write(tex))
+```
+
+## Custom LaTeX Packages
+
+```python
+class CustomPackage(Scene):
+    def construct(self):
+        template = TexTemplate()
+        template.add_to_preamble(r"\usepackage{mathrsfs}")
+
+        eq = Tex(
+            r"$\mathscr{L}$",
+            tex_template=template
+        )
+        self.add(eq)
+```
+
+## Equation Alignment
+
+```python
+class AlignedEquations(Scene):
+    def construct(self):
+        eqs = MathTex(
+            r"a &= b + c \\",
+            r"d &= e + f + g \\",
+            r"h &= i"
+        )
+        self.add(eqs)
+```
+
+## Common LaTeX Symbols
+
+```python
+# Greek letters
+MathTex(r"\alpha \beta \gamma \delta \epsilon")
+MathTex(r"\Gamma \Delta \Theta \Lambda \Pi")
+
+# Operators
+MathTex(r"\times \div \pm \mp \cdot")
+
+# Relations
+MathTex(r"\leq \geq \neq \approx \equiv")
+
+# Arrows
+MathTex(r"\rightarrow \leftarrow \Rightarrow \Leftrightarrow")
+
+# Sets
+MathTex(r"\in \notin \subset \supset \cup \cap")
+
+# Calculus
+MathTex(r"\int \iint \oint \partial \nabla")
+```
+
+## Font Size
+
+```python
+# Using font_size parameter
+eq = MathTex(r"E = mc^2", font_size=72)
+
+# Using scale
+eq = MathTex(r"E = mc^2").scale(2)
+```
+
+## Best Practices
+
+1. **Use raw strings** - Always use `r"..."` for LaTeX
+2. **Use MathTex for pure math** - Simpler than adding `$...$`
+3. **Use Tex for mixed content** - When combining text and math
+4. **Split for animation control** - Separate parts you'll animate differently
+5. **Use substrings_to_isolate** - For reliable coloring of repeated elements

package/references/manimce/rules/lines.md

@@ -0,0 +1,241 @@
+---
+name: lines
+description: Line, Arrow, Vector, DashedLine and connectors
+metadata:
+  tags: line, arrow, vector, dashedline, brace, connector
+---
+
+# Lines and Arrows
+
+Connect points and show relationships with lines and arrows.
+
+## Line
+
+Basic line between two points.
+
+```python
+from manim import *
+
+class LineExample(Scene):
+    def construct(self):
+        # Line from two points
+        line = Line(LEFT * 2, RIGHT * 2)
+
+        # With styling
+        styled_line = Line(
+            UP * 2, DOWN * 2,
+            color=BLUE,
+            stroke_width=4
+        )
+
+        self.add(line, styled_line)
+```
+
+### Line Properties
+
+```python
+line = Line(LEFT, RIGHT)
+
+# Get points
+line.get_start()
+line.get_end()
+line.get_center()
+line.get_length()
+line.get_angle()
+
+# Modify
+line.put_start_and_end_on(new_start, new_end)
+line.set_length(3)  # Keep direction, change length
+```
+
+## Arrow
+
+Line with an arrowhead.
+
+```python
+class ArrowExample(Scene):
+    def construct(self):
+        # Basic arrow
+        arrow = Arrow(LEFT * 2, RIGHT * 2)
+
+        # Styled arrow
+        styled = Arrow(
+            start=UP,
+            end=DOWN,
+            color=RED,
+            stroke_width=6,
+            tip_length=0.4,
+            max_tip_length_to_length_ratio=0.5
+        )
+
+        self.add(arrow, styled)
+```
+
+### Arrow Variations
+
+```python
+# Double-headed arrow
+double = DoubleArrow(LEFT * 2, RIGHT * 2)
+
+# Arrow with custom tip
+arrow = Arrow(LEFT, RIGHT)
+arrow.tip  # Access the tip mobject
+```
+
+## Vector
+
+Arrow starting from origin (useful for physics/math).
+
+```python
+class VectorExample(Scene):
+    def construct(self):
+        # Vector from origin
+        v1 = Vector([2, 1, 0], color=YELLOW)
+        v2 = Vector([-1, 2, 0], color=GREEN)
+
+        self.add(v1, v2)
+```
+
+## DashedLine
+
+```python
+class DashedLineExample(Scene):
+    def construct(self):
+        dashed = DashedLine(
+            LEFT * 2, RIGHT * 2,
+            dash_length=0.2,
+            dashed_ratio=0.5,  # Ratio of dash to gap
+            color=WHITE
+        )
+        self.add(dashed)
+```
+
+## TangentLine
+
+Line tangent to a curve at a point.
+
+```python
+class TangentLineExample(Scene):
+    def construct(self):
+        circle = Circle(radius=2)
+
+        # Tangent at specific point (t parameter 0-1 along curve)
+        tangent = TangentLine(circle, alpha=0.25, length=3, color=YELLOW)
+
+        self.add(circle, tangent)
+```
+
+## Brace
+
+Curly brace for highlighting.
+
+```python
+class BraceExample(Scene):
+    def construct(self):
+        rect = Rectangle(width=4, height=1)
+
+        # Brace under the rectangle
+        brace = Brace(rect, DOWN)
+
+        # With label
+        brace_text = brace.get_text("Width")
+
+        # Alternative: BraceLabel
+        brace_label = BraceLabel(rect, "Width", DOWN)
+
+        self.add(rect, brace, brace_text)
+```
+
+### Brace Directions
+
+```python
+brace_down = Brace(mobject, DOWN)
+brace_up = Brace(mobject, UP)
+brace_left = Brace(mobject, LEFT)
+brace_right = Brace(mobject, RIGHT)
+```
+
+## CurvedArrow
+
+Curved arrow between points.
+
+```python
+class CurvedArrowExample(Scene):
+    def construct(self):
+        curved = CurvedArrow(
+            start_point=LEFT * 2,
+            end_point=RIGHT * 2,
+            angle=PI/2  # Curvature
+        )
+        self.add(curved)
+```
+
+## Elbow
+
+Right-angle connector.
+
+```python
+class ElbowExample(Scene):
+    def construct(self):
+        elbow = Elbow(width=2, angle=PI/2)
+        self.add(elbow)
+```
+
+## NumberLine Ticks
+
+```python
+class TicksExample(Scene):
+    def construct(self):
+        line = NumberLine(x_range=[-3, 3, 1])
+        self.add(line)
+```
+
+## Connecting Mobjects
+
+### Line Between Mobjects
+
+```python
+class ConnectMobjects(Scene):
+    def construct(self):
+        c1 = Circle().shift(LEFT * 2)
+        c2 = Circle().shift(RIGHT * 2)
+
+        # Line connecting centers
+        line = Line(c1.get_center(), c2.get_center())
+
+        # Arrow between edges
+        arrow = Arrow(
+            c1.get_right(),  # Right edge of c1
+            c2.get_left(),   # Left edge of c2
+            buff=0.1         # Small gap from edges
+        )
+
+        self.add(c1, c2, line, arrow)
+```
+
+### Dynamic Connections with Updaters
+
+```python
+class DynamicLine(Scene):
+    def construct(self):
+        dot1 = Dot(LEFT * 2)
+        dot2 = Dot(RIGHT * 2)
+
+        # Line that follows dots
+        line = always_redraw(lambda: Line(
+            dot1.get_center(),
+            dot2.get_center(),
+            color=YELLOW
+        ))
+
+        self.add(dot1, dot2, line)
+        self.play(dot1.animate.shift(UP * 2), run_time=2)
+```
+
+## Best Practices
+
+1. **Use Arrow for direction** - Clearer than plain lines
+2. **Use Vector for physics/math** - Semantically meaningful
+3. **Use Brace for labeling dimensions** - Professional look
+4. **Use DashedLine for auxiliary lines** - Distinguishes from main content
+5. **Use always_redraw for dynamic lines** - Updates with moving endpoints