manim-mcp 0.1.0

package/references/manimce/rules/styling.md

@@ -0,0 +1,177 @@
+---
+name: styling
+description: Fill, stroke, opacity and visual styling of mobjects
+metadata:
+  tags: fill, stroke, opacity, style, width, appearance
+---
+
+# Styling Mobjects
+
+Control the visual appearance of mobjects with fill, stroke, and opacity settings.
+
+## Fill Properties
+
+Fill controls the interior of shapes.
+
+```python
+from manim import *
+
+class FillExample(Scene):
+    def construct(self):
+        # Set fill on creation
+        circle = Circle(fill_color=BLUE, fill_opacity=0.8)
+
+        # Set fill after creation
+        square = Square()
+        square.set_fill(RED, opacity=0.5)
+
+        self.add(circle, square)
+```
+
+### Fill Methods
+```python
+mobject.set_fill(color=RED)                    # Color only
+mobject.set_fill(RED, opacity=0.5)             # Color and opacity
+mobject.set_fill(opacity=0.5)                  # Opacity only
+mobject.set_fill_color(RED)                    # Color only (alternative)
+mobject.set_fill_opacity(0.5)                  # Opacity only (alternative)
+```
+
+## Stroke Properties
+
+Stroke controls the outline/border of shapes.
+
+```python
+class StrokeExample(Scene):
+    def construct(self):
+        # Set stroke on creation
+        circle = Circle(stroke_color=BLUE, stroke_width=4)
+
+        # Set stroke after creation
+        square = Square()
+        square.set_stroke(RED, width=8)
+
+        self.add(circle, square)
+```
+
+### Stroke Methods
+```python
+mobject.set_stroke(color=RED)                  # Color only
+mobject.set_stroke(RED, width=4)               # Color and width
+mobject.set_stroke(width=4)                    # Width only
+mobject.set_stroke(opacity=0.5)                # Opacity only
+mobject.set_stroke_color(RED)                  # Color only (alternative)
+mobject.set_stroke_width(4)                    # Width only (alternative)
+mobject.set_stroke_opacity(0.5)                # Opacity only (alternative)
+```
+
+### Stroke Width Reference
+```python
+# Common stroke widths
+DEFAULT_STROKE_WIDTH = 4
+thin = 1
+normal = 4
+thick = 8
+very_thick = 12
+```
+
+## Combined Styling
+
+```python
+class CombinedStyling(Scene):
+    def construct(self):
+        square = Square()
+        square.set_fill(BLUE, opacity=0.5)
+        square.set_stroke(YELLOW, width=6)
+        self.add(square)
+```
+
+### Method Chaining
+```python
+square = Square().set_fill(RED, 0.5).set_stroke(WHITE, 4)
+```
+
+## The set_style Method
+
+Set multiple style properties at once:
+
+```python
+square = Square()
+square.set_style(
+    fill_color=BLUE,
+    fill_opacity=0.5,
+    stroke_color=WHITE,
+    stroke_width=4,
+    stroke_opacity=1
+)
+```
+
+## Opacity
+
+Control transparency of mobjects:
+
+```python
+# Overall opacity
+mobject.set_opacity(0.5)  # Affects both fill and stroke
+
+# Separate opacities
+mobject.set_fill_opacity(0.8)
+mobject.set_stroke_opacity(0.3)
+
+# Fade effect
+mobject.fade(0.5)  # 0.5 = 50% faded (opposite of opacity)
+```
+
+## Background Rectangle
+
+Add a background behind text or other mobjects:
+
+```python
+class BackgroundExample(Scene):
+    def construct(self):
+        text = Text("Important!")
+        bg = BackgroundRectangle(text, fill_opacity=0.8, buff=0.1)
+        group = VGroup(bg, text)
+        self.add(group)
+```
+
+## Applying Style to Submobjects
+
+```python
+# Apply to all submobjects (family=True, default)
+group.set_fill(RED, opacity=0.5, family=True)
+
+# Apply only to parent, not submobjects
+group.set_fill(RED, opacity=0.5, family=False)
+```
+
+## Style Based on Position
+
+```python
+class GradientFill(Scene):
+    def construct(self):
+        squares = VGroup(*[Square() for _ in range(5)]).arrange(RIGHT)
+
+        for i, sq in enumerate(squares):
+            opacity = (i + 1) / 5
+            sq.set_fill(BLUE, opacity=opacity)
+
+        self.add(squares)
+```
+
+## Copying Style
+
+```python
+# Copy style from another mobject
+source = Circle().set_fill(RED, 0.5).set_stroke(WHITE, 4)
+target = Square()
+target.match_style(source)  # Now has same fill and stroke
+```
+
+## Best Practices
+
+1. **Use fill_opacity for shapes** - Fully opaque fills can hide other elements
+2. **Consistent stroke width** - Pick a width and stick with it
+3. **Contrast fill and stroke** - Different colors help definition
+4. **Use BackgroundRectangle for readability** - Behind text on busy backgrounds
+5. **Chain methods for concise code** - But break lines if too long

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

@@ -0,0 +1,222 @@
+---
+name: text-animations
+description: Write, AddTextLetterByLetter, TypeWithCursor text animations
+metadata:
+  tags: text, write, typing, letter, cursor, animation
+---
+
+# Text Animations
+
+Animations specifically designed for text and equations.
+
+## Write
+
+The most common text animation. Simulates handwriting.
+
+```python
+from manim import *
+
+class WriteExample(Scene):
+    def construct(self):
+        text = Text("Hello World")
+        equation = MathTex(r"E = mc^2")
+
+        self.play(Write(text))
+        self.wait()
+        self.play(Write(equation))
+```
+
+### Write Parameters
+
+```python
+self.play(Write(
+    text,
+    run_time=2,           # Override auto-calculated time
+    rate_func=linear,     # Timing curve
+    reverse=False,        # Write backwards if True
+))
+```
+
+Write automatically adjusts `run_time` based on text length.
+
+## AddTextLetterByLetter
+
+Types text one character at a time.
+
+```python
+class LetterByLetterExample(Scene):
+    def construct(self):
+        text = Text("Typing effect")
+
+        self.play(AddTextLetterByLetter(
+            text,
+            time_per_char=0.1  # Speed of typing
+        ))
+```
+
+**Note:** Only works with `Text`, not `MathTex`.
+
+## RemoveTextLetterByLetter
+
+Reverse of AddTextLetterByLetter - removes character by character.
+
+```python
+class RemoveLetterByLetter(Scene):
+    def construct(self):
+        text = Text("Disappearing text")
+        self.add(text)
+
+        self.play(RemoveTextLetterByLetter(
+            text,
+            time_per_char=0.05
+        ))
+```
+
+## TypeWithCursor
+
+Types text with a visible cursor.
+
+```python
+class TypeWithCursorExample(Scene):
+    def construct(self):
+        text = Text("Typing with cursor")
+
+        # Create cursor
+        cursor = Rectangle(
+            color=GREY_A,
+            fill_color=GREY_A,
+            fill_opacity=1.0,
+            height=1.1,
+            width=0.1,
+        )
+
+        self.play(TypeWithCursor(text, cursor))
+
+        # Optional: blink cursor after typing
+        self.play(Blink(cursor, blinks=3))
+```
+
+### Cursor Customization
+
+```python
+# Line cursor
+cursor = Line(UP * 0.5, DOWN * 0.5, color=WHITE, stroke_width=2)
+
+# Block cursor
+cursor = Rectangle(width=0.5, height=1, fill_opacity=0.8, color=WHITE)
+
+# Custom cursor position
+self.play(TypeWithCursor(
+    text,
+    cursor,
+    buff=0.05,           # Space between text and cursor
+    keep_cursor_y=True,  # Keep cursor at consistent height
+    leave_cursor_on=True # Show cursor after animation
+))
+```
+
+## Blink (for cursors)
+
+```python
+class BlinkExample(Scene):
+    def construct(self):
+        cursor = Rectangle(height=1, width=0.1, fill_opacity=1)
+        self.add(cursor)
+
+        self.play(Blink(cursor, blinks=5, time_on=0.3, time_off=0.3))
+```
+
+## Word by Word Animation
+
+Using LaggedStart for word-by-word appearance:
+
+```python
+class WordByWord(Scene):
+    def construct(self):
+        # Split into individual Text objects
+        words = VGroup(
+            Text("Hello"),
+            Text("World"),
+            Text("!")
+        ).arrange(RIGHT, buff=0.3)
+
+        self.play(LaggedStart(
+            *[Write(word) for word in words],
+            lag_ratio=0.5
+        ))
+```
+
+## Equation Transformations
+
+Animate between equations:
+
+```python
+class EquationTransform(Scene):
+    def construct(self):
+        eq1 = MathTex(r"a^2 + b^2 = c^2")
+        eq2 = MathTex(r"c = \sqrt{a^2 + b^2}")
+
+        self.play(Write(eq1))
+        self.wait()
+        self.play(TransformMatchingTex(eq1, eq2))
+```
+
+## Highlighting Text
+
+```python
+class HighlightText(Scene):
+    def construct(self):
+        text = Text("Important message")
+        self.add(text)
+
+        # Circumscribe (draw around)
+        self.play(Circumscribe(text, color=YELLOW))
+
+        # Indicate (pulse)
+        self.play(Indicate(text, color=RED))
+
+        # Flash
+        self.play(Flash(text.get_center(), color=WHITE))
+```
+
+## Replacing Text
+
+```python
+class ReplaceText(Scene):
+    def construct(self):
+        text1 = Text("Before")
+        text2 = Text("After")
+
+        self.play(Write(text1))
+        self.wait()
+
+        # Transform text
+        self.play(Transform(text1, text2))
+
+        # Or replacement transform
+        self.play(ReplacementTransform(text1, text2))
+```
+
+## Colored Text Animation
+
+```python
+class ColoredTextAnimation(Scene):
+    def construct(self):
+        text = Text("Colorful")
+        self.play(Write(text))
+
+        # Animate color change per letter
+        self.play(LaggedStart(
+            *[char.animate.set_color(random_bright_color()) for char in text],
+            lag_ratio=0.1
+        ))
+```
+
+## Best Practices
+
+1. **Use Write for most text** - Natural and smooth
+2. **Use AddTextLetterByLetter for "typing" effect** - Terminal/code aesthetics
+3. **Use TypeWithCursor for interactive feel** - Good for tutorials
+4. **Use TransformMatchingTex for equations** - Smooth mathematical transitions
+5. **Adjust time_per_char for pacing** - 0.05-0.1 is usually good
+6. **Only use Text (not MathTex) for letter-by-letter** - API limitation

package/references/manimce/rules/text.md

@@ -0,0 +1,189 @@
+---
+name: text
+description: Text mobjects, fonts, and text styling in Manim
+metadata:
+  tags: text, font, typography, markup, paragraph
+---
+
+# Text in Manim
+
+The `Text` class renders text using Pango/Cairo, supporting various fonts and styles.
+
+## Basic Text
+
+```python
+from manim import *
+
+class TextExample(Scene):
+    def construct(self):
+        text = Text("Hello World")
+        self.play(Write(text))
+```
+
+## Text Parameters
+
+```python
+text = Text(
+    "Hello World",
+    font_size=48,           # Size (default: 48)
+    color=BLUE,             # Text color
+    font="Arial",           # Font family
+    weight=BOLD,            # NORMAL, BOLD, etc.
+    slant=ITALIC,           # NORMAL, ITALIC, OBLIQUE
+    line_spacing=1.5,       # Space between lines
+)
+```
+
+## Font Size
+
+```python
+# Using font_size parameter
+small = Text("Small", font_size=24)
+medium = Text("Medium", font_size=48)
+large = Text("Large", font_size=72)
+
+# Using scale after creation
+text = Text("Hello").scale(2)
+```
+
+## Custom Fonts
+
+```python
+# Use any installed system font
+text = Text("Custom Font", font="Comic Sans MS")
+text = Text("Monospace", font="Courier New")
+text = Text("Serif", font="Times New Roman")
+```
+
+## Text Styling with MarkupText
+
+Use Pango markup for mixed styling within one Text object:
+
+```python
+class MarkupExample(Scene):
+    def construct(self):
+        text = MarkupText(
+            f'all in red <span fgcolor="{YELLOW}">except this</span>',
+            color=RED
+        )
+        self.play(Write(text))
+```
+
+### Available Markup Tags
+
+```python
+# Bold and italic
+text = MarkupText('<b>Bold</b> and <i>Italic</i>')
+
+# Colors using fgcolor
+text = MarkupText('<span fgcolor="yellow">Yellow</span>')
+
+# Subscripts and superscripts
+text = MarkupText('H<sub>2</sub>O and x<sup>2</sup>')
+
+# Font size
+text = MarkupText('<big>Big</big> and <small>small</small>')
+
+# Underline and strikethrough
+text = MarkupText('<u>Underline</u> and <s>Strike</s>')
+
+# Double underline with color
+text = MarkupText('<span underline="double" underline_color="green">text</span>')
+
+# Monospace
+text = MarkupText('type <tt>help</tt> for help')
+```
+
+### Gradients in MarkupText
+
+```python
+# Global gradient
+text = MarkupText("nice gradient", gradient=(BLUE, GREEN))
+
+# Inline gradient
+text = MarkupText(
+    'nice <gradient from="RED" to="YELLOW">colored</gradient> text'
+)
+```
+
+### Escaping Special Characters
+
+```python
+# Must escape these characters:
+# > as &gt;
+# < as &lt;
+# & as &amp;
+text = MarkupText("5 &gt; 3 and 2 &lt; 4")
+```
+
+## Multi-line Text
+
+```python
+# Using \n for line breaks
+text = Text("Line 1\nLine 2\nLine 3")
+
+# Using Paragraph for better control
+from manim import Paragraph
+
+para = Paragraph(
+    "This is a longer text",
+    "that spans multiple lines",
+    "with automatic alignment",
+    line_spacing=0.5
+)
+```
+
+## Coloring Parts of Text
+
+```python
+class ColoredText(Scene):
+    def construct(self):
+        text = Text("Hello World")
+        text[0:5].set_color(RED)    # "Hello" in red
+        text[6:11].set_color(BLUE)  # "World" in blue
+        self.play(Write(text))
+```
+
+## Text with Gradients
+
+```python
+text = Text("Gradient Text")
+text.set_color_by_gradient(RED, YELLOW, GREEN)
+```
+
+## Accessing Characters
+
+```python
+text = Text("ABCDE")
+
+# Individual characters
+text[0]  # 'A'
+text[1]  # 'B'
+
+# Slices
+text[0:3]  # 'ABC'
+text[-1]   # 'E'
+
+# Iterate
+for char in text:
+    char.set_color(random_color())
+```
+
+## Text Positioning
+
+```python
+# Standard positioning methods work
+text = Text("Hello")
+text.to_edge(UP)
+text.to_corner(UL)
+text.move_to(ORIGIN)
+text.next_to(other_mobject, DOWN)
+```
+
+## Best Practices
+
+1. **Use Text for regular text** - Simple and fast
+2. **Use MarkupText for mixed styles** - When you need multiple colors/weights
+3. **Use MathTex for math** - Text doesn't render LaTeX
+4. **Install fonts system-wide** - Manim uses system fonts
+5. **Keep font_size consistent** - Use the same size for related text