manim-mcp 0.1.0

package/references/manimce/rules/config.md

@@ -0,0 +1,264 @@
+---
+name: config
+description: Configuration system, manim.cfg, and settings
+metadata:
+  tags: config, configuration, settings, manim.cfg, options
+---
+
+# Configuration
+
+Configure Manim's behavior through files and code.
+
+## Configuration Hierarchy
+
+Manim reads configuration from (in order of precedence):
+1. Command-line arguments (highest priority)
+2. User's `manim.cfg` in current directory
+3. User's global config
+4. Default values (lowest priority)
+
+## manim.cfg File
+
+Create a `manim.cfg` file in your project directory:
+
+```ini
+[CLI]
+# Preview after rendering
+preview = True
+
+# Default quality
+quality = medium_quality
+
+# Output format
+format = mp4
+
+# Frame rate
+frame_rate = 30
+
+[output]
+# Custom output directory
+media_dir = ./media
+
+# Save last frame as PNG
+save_last_frame = False
+
+[renderer]
+# Background color
+background_color = BLACK
+
+[style]
+# Default font
+font = Arial
+```
+
+## Common Configuration Options
+
+### CLI Section
+
+```ini
+[CLI]
+# Quality presets: low_quality, medium_quality, high_quality, production_quality, fourk_quality
+quality = medium_quality
+
+# Preview video after rendering
+preview = True
+
+# Frame rate
+frame_rate = 30
+
+# Output format: mp4, gif, mov, webm, png
+format = mp4
+
+# Transparent background
+transparent = False
+
+# Progress bar: display, leave, none
+progress_bar = display
+```
+
+### Rendering Section
+
+```ini
+[renderer]
+# Background color (hex or color name)
+background_color = #1e1e1e
+
+# Renderer type: cairo, opengl
+renderer = cairo
+```
+
+### Resolution
+
+```ini
+[CLI]
+# Frame dimensions
+pixel_width = 1920
+pixel_height = 1080
+```
+
+## Programmatic Configuration
+
+Access and modify config in your Python code:
+
+```python
+# Access config values
+config.pixel_width  # e.g., 1920
+config.frame_rate  # e.g., 30
+config.background_color  # e.g., BLACK
+
+# Modify config (before creating scenes)
+config.pixel_width = 1920
+config.pixel_height = 1080
+config.frame_rate = 60
+config.background_color = BLUE_E
+```
+
+### In Scene
+
+```python
+class MyScene(Scene):
+    def construct(self):
+        # Access frame dimensions
+        width = config.frame_width
+        height = config.frame_height
+
+        # Create rectangle matching frame size
+        frame_rect = Rectangle(
+            width=width,
+            height=height,
+            stroke_color=WHITE
+        )
+        self.add(frame_rect)
+```
+
+## Background Color
+
+### In Config File
+
+```ini
+[renderer]
+background_color = BLACK
+# Or hex color
+background_color = #1a1a2e
+```
+
+### In Code
+
+```python
+class DarkBackground(Scene):
+    def construct(self):
+        self.camera.background_color = "#1a1a2e"
+        # ... rest of scene
+```
+
+## Output Directory Structure
+
+Default media directory structure:
+```
+media/
+├── videos/
+│   └── scene_file/
+│       ├── 480p15/       # Low quality
+│       ├── 720p30/       # Medium quality
+│       ├── 1080p60/      # High quality
+│       └── 2160p60/      # 4K quality
+├── images/
+│   └── scene_file/
+│       └── SceneName.png
+└── Tex/                  # LaTeX cache
+```
+
+### Custom Output Directory
+
+```ini
+[output]
+media_dir = ./output
+```
+
+Or via CLI:
+```bash
+manim --media_dir ./output file.py Scene
+```
+
+## Tex Configuration
+
+For LaTeX rendering:
+
+```ini
+[tex]
+# Custom preamble
+preamble = \usepackage{amsmath}\usepackage{amssymb}
+
+# Tex compiler
+tex_compiler = latex
+```
+
+## Caching
+
+```ini
+[CLI]
+# Disable caching (useful for debugging)
+disable_caching = True
+
+# Max cached files
+max_files_cached = 100
+```
+
+## Viewing Current Config
+
+```bash
+# Show all config values
+manim cfg show
+
+# Show specific section
+manim cfg show CLI
+
+# Write current config to file
+manim cfg write
+```
+
+## Project-Specific Config
+
+Create `manim.cfg` in your project root:
+
+```ini
+[CLI]
+quality = high_quality
+preview = True
+frame_rate = 60
+
+[renderer]
+background_color = #0d1117
+
+[output]
+media_dir = ./renders
+```
+
+## Plugins
+
+Manim has an extensible plugin system:
+
+```bash
+# List installed plugins
+manim plugins -l
+
+# Install a plugin
+pip install manim-pluginname
+```
+
+Enable plugins in `manim.cfg`:
+
+```ini
+[CLI]
+plugins = manim-pluginname
+# For multiple plugins:
+plugins = plugin1,plugin2
+```
+
+## Best Practices
+
+1. **Use manim.cfg for project defaults** - Consistent settings across team
+2. **Keep quality low during development** - Faster iteration
+3. **Set background_color in config** - Not in every scene
+4. **Use custom media_dir** - Keep renders organized
+5. **Commit manim.cfg to version control** - Share settings with collaborators

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

@@ -0,0 +1,158 @@
+---
+name: creation-animations
+description: Create, Write, FadeIn, DrawBorderThenFill and other creation animations
+metadata:
+  tags: create, write, fadein, fadeout, grow, shrink, uncreate
+---
+
+# Creation Animations
+
+Animations that introduce mobjects to the scene.
+
+## Create
+
+Draws a VMobject progressively along its path.
+
+```python
+from manim import *
+
+class CreateExample(Scene):
+    def construct(self):
+        circle = Circle()
+        self.play(Create(circle))
+```
+
+Best for: Geometric shapes, lines, arrows.
+
+## Write
+
+Simulates handwriting. Best for text and equations.
+
+```python
+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 automatically sets appropriate timing based on text length.
+
+## DrawBorderThenFill
+
+Draws the outline first, then fills in the shape.
+
+```python
+class DrawBorderExample(Scene):
+    def construct(self):
+        square = Square(fill_opacity=0.8, color=BLUE)
+        self.play(DrawBorderThenFill(square))
+```
+
+Best for: Shapes with fills where you want to emphasize the outline first.
+
+## FadeIn / FadeOut
+
+Simple opacity transitions.
+
+```python
+class FadeExample(Scene):
+    def construct(self):
+        circle = Circle()
+
+        # Fade in
+        self.play(FadeIn(circle))
+        self.wait()
+
+        # Fade out
+        self.play(FadeOut(circle))
+```
+
+### Directional Fades
+
+```python
+# Fade in from a direction
+self.play(FadeIn(square, shift=UP))      # Fade in while moving up
+self.play(FadeIn(square, shift=LEFT))    # Fade in from right
+
+# Fade out to a direction
+self.play(FadeOut(square, shift=DOWN))   # Fade out while moving down
+```
+
+### Scale Fades
+
+```python
+self.play(FadeIn(circle, scale=0.5))   # Fade in while growing
+self.play(FadeOut(circle, scale=2))    # Fade out while shrinking
+```
+
+## GrowFromCenter / ShrinkToCenter
+
+```python
+class GrowExample(Scene):
+    def construct(self):
+        circle = Circle()
+
+        self.play(GrowFromCenter(circle))
+        self.wait()
+        self.play(ShrinkToCenter(circle))
+```
+
+## GrowFromPoint
+
+Grow from a specific point.
+
+```python
+self.play(GrowFromPoint(circle, ORIGIN))
+self.play(GrowFromPoint(circle, LEFT * 3))
+```
+
+## GrowFromEdge
+
+Grow from a specific edge.
+
+```python
+self.play(GrowFromEdge(square, LEFT))   # Grow from left edge
+self.play(GrowFromEdge(square, DOWN))   # Grow from bottom edge
+```
+
+## SpinInFromNothing
+
+Object spins in while growing.
+
+```python
+self.play(SpinInFromNothing(circle))
+```
+
+## Uncreate
+
+Reverse of Create - erases the mobject.
+
+```python
+self.play(Create(circle))
+self.wait()
+self.play(Uncreate(circle))  # Erases in reverse
+```
+
+## AddTextLetterByLetter
+
+Types text one character at a time.
+
+```python
+class TypingExample(Scene):
+    def construct(self):
+        text = Text("Hello World")
+        self.play(AddTextLetterByLetter(text, time_per_char=0.1))
+```
+
+Note: Only works with `Text`, not `MathTex`.
+
+## Best Practices
+
+1. **Use Write for text** - Looks more natural than Create
+2. **Use Create for shapes** - Clean progressive drawing
+3. **Use FadeIn for quick introductions** - When drawing isn't important
+4. **Match removal to creation** - If you Create, use Uncreate; if FadeIn, use FadeOut

package/references/manimce/rules/graphing.md

@@ -0,0 +1,233 @@
+---
+name: graphing
+description: Plotting functions, parametric curves, and data visualization
+metadata:
+  tags: plot, graph, function, parametric, curve, data
+---
+
+# Graphing Functions
+
+Plot mathematical functions and curves.
+
+## Plotting Functions on Axes
+
+```python
+from manim import *
+
+class BasicPlot(Scene):
+    def construct(self):
+        axes = Axes(x_range=[-3, 3], y_range=[-2, 8])
+
+        # Plot a function
+        graph = axes.plot(lambda x: x**2, color=BLUE)
+
+        self.add(axes, graph)
+```
+
+## plot() Parameters
+
+```python
+class PlotParameters(Scene):
+    def construct(self):
+        axes = Axes(x_range=[-5, 5], y_range=[-2, 2])
+
+        graph = axes.plot(
+            lambda x: np.sin(x),
+            x_range=[-PI, PI],    # Limit domain
+            color=YELLOW,
+            stroke_width=4,
+        )
+
+        self.add(axes, graph)
+```
+
+## Multiple Functions
+
+```python
+class MultiplePlots(Scene):
+    def construct(self):
+        axes = Axes(x_range=[-3, 3], y_range=[-2, 10])
+
+        sin_graph = axes.plot(lambda x: np.sin(x), color=BLUE)
+        cos_graph = axes.plot(lambda x: np.cos(x), color=RED)
+        quad_graph = axes.plot(lambda x: x**2, color=GREEN)
+
+        self.add(axes, sin_graph, cos_graph, quad_graph)
+```
+
+## Adding Labels to Graphs
+
+```python
+class GraphLabels(Scene):
+    def construct(self):
+        axes = Axes(x_range=[-3, 3], y_range=[-2, 10])
+        graph = axes.plot(lambda x: x**2, color=BLUE)
+
+        # Add label to graph
+        label = axes.get_graph_label(
+            graph,
+            label=MathTex("y = x^2"),
+            x_val=2,
+            direction=UR
+        )
+
+        self.add(axes, graph, label)
+```
+
+## Parametric Curves
+
+Plot curves defined by parametric equations.
+
+```python
+class ParametricExample(Scene):
+    def construct(self):
+        axes = Axes(x_range=[-3, 3], y_range=[-3, 3])
+
+        # Circle: x = cos(t), y = sin(t)
+        curve = axes.plot_parametric_curve(
+            lambda t: np.array([np.cos(t), np.sin(t), 0]),
+            t_range=[0, 2 * PI],
+            color=YELLOW
+        )
+
+        self.add(axes, curve)
+```
+
+### Parametric Curve Examples
+
+```python
+# Lissajous curve
+curve = axes.plot_parametric_curve(
+    lambda t: np.array([np.sin(3*t), np.sin(2*t), 0]),
+    t_range=[0, 2*PI],
+)
+
+# Spiral
+curve = axes.plot_parametric_curve(
+    lambda t: np.array([t*np.cos(t), t*np.sin(t), 0]),
+    t_range=[0, 4*PI],
+)
+
+# Heart curve
+curve = axes.plot_parametric_curve(
+    lambda t: np.array([
+        16 * np.sin(t)**3,
+        13*np.cos(t) - 5*np.cos(2*t) - 2*np.cos(3*t) - np.cos(4*t),
+        0
+    ]) / 10,
+    t_range=[0, 2*PI],
+)
+```
+
+## ParametricFunction (standalone)
+
+Create parametric curves without axes:
+
+```python
+class StandaloneParametric(Scene):
+    def construct(self):
+        curve = ParametricFunction(
+            lambda t: np.array([np.cos(t), np.sin(t), 0]),
+            t_range=[0, 2*PI],
+            color=BLUE
+        )
+        self.add(curve)
+```
+
+## Area Under Curve
+
+```python
+class AreaUnderCurve(Scene):
+    def construct(self):
+        axes = Axes(x_range=[-1, 5], y_range=[-1, 10])
+        graph = axes.plot(lambda x: x**2, x_range=[0, 3], color=BLUE)
+
+        # Shade area under curve
+        area = axes.get_area(
+            graph,
+            x_range=[0, 2],
+            color=BLUE,
+            opacity=0.5
+        )
+
+        self.add(axes, graph, area)
+```
+
+## Riemann Rectangles
+
+```python
+class RiemannRectangles(Scene):
+    def construct(self):
+        axes = Axes(x_range=[-1, 5], y_range=[-1, 10])
+        graph = axes.plot(lambda x: x**2, color=BLUE)
+
+        rects = axes.get_riemann_rectangles(
+            graph,
+            x_range=[0, 3],
+            dx=0.5,
+            color=YELLOW,
+            stroke_width=1
+        )
+
+        self.add(axes, graph, rects)
+```
+
+## Animated Graphing
+
+```python
+class AnimatedGraph(Scene):
+    def construct(self):
+        axes = Axes(x_range=[-3, 3], y_range=[-2, 2])
+        self.add(axes)
+
+        graph = axes.plot(lambda x: np.sin(x), color=BLUE)
+
+        # Animate the graph being drawn
+        self.play(Create(graph), run_time=3)
+```
+
+## Moving Point on Graph
+
+```python
+class MovingPointOnGraph(Scene):
+    def construct(self):
+        axes = Axes(x_range=[-3, 3], y_range=[-2, 2])
+        graph = axes.plot(lambda x: np.sin(x), color=BLUE)
+
+        # Point that follows graph
+        x_tracker = ValueTracker(-3)
+
+        dot = always_redraw(lambda: Dot(
+            axes.i2gp(x_tracker.get_value(), graph),
+            color=YELLOW
+        ))
+
+        self.add(axes, graph, dot)
+        self.play(x_tracker.animate.set_value(3), run_time=4)
+```
+
+## 3D Surface Plots
+
+```python
+class SurfacePlot(ThreeDScene):
+    def construct(self):
+        axes = ThreeDAxes()
+
+        surface = axes.plot_surface(
+            lambda u, v: np.sin(u) * np.cos(v),
+            u_range=[-PI, PI],
+            v_range=[-PI, PI],
+            colorscale=[BLUE, GREEN, YELLOW],
+        )
+
+        self.set_camera_orientation(phi=75*DEGREES, theta=-45*DEGREES)
+        self.add(axes, surface)
+```
+
+## Best Practices
+
+1. **Set x_range on plot for discontinuities** - Avoid graphing undefined regions
+2. **Use get_graph_label for clarity** - Label functions on the graph
+3. **Match graph color to concept** - Consistent color coding
+4. **Use i2gp for points on graphs** - Automatically handles conversion
+5. **Animate graph creation** - More engaging than static display