manim-mcp 0.1.0

package/references/manimce/rules/camera.md

@@ -0,0 +1,208 @@
+---
+name: camera
+description: MovingCameraScene, zoom, pan, and camera manipulation
+metadata:
+  tags: camera, zoom, pan, frame, movingcamerascene, 3d
+---
+
+# Camera Control
+
+Control what the viewer sees with camera manipulation.
+
+## MovingCameraScene
+
+For 2D scenes with camera movement (zoom, pan).
+
+```python
+from manim import *
+
+class CameraExample(MovingCameraScene):
+    def construct(self):
+        circle = Circle()
+        square = Square().shift(RIGHT * 3)
+        self.add(circle, square)
+
+        # Access camera frame
+        # self.camera.frame is the viewable area
+```
+
+## Zooming
+
+### Zoom In/Out by Scaling Frame
+
+```python
+class ZoomExample(MovingCameraScene):
+    def construct(self):
+        dots = VGroup(*[Dot() for _ in range(100)])
+        dots.arrange_in_grid(10, 10, buff=0.3)
+        self.add(dots)
+
+        # Zoom in (make frame smaller)
+        self.play(self.camera.frame.animate.scale(0.5))
+        self.wait()
+
+        # Zoom out (make frame larger)
+        self.play(self.camera.frame.animate.scale(4))
+```
+
+### Zoom to Specific Width
+
+```python
+class ZoomToWidth(MovingCameraScene):
+    def construct(self):
+        text = Text("Focus on me!")
+        self.add(text)
+
+        # Zoom to fit text with padding
+        self.play(
+            self.camera.frame.animate.set(width=text.width * 1.5)
+        )
+```
+
+## Panning
+
+### Move Camera to Location
+
+```python
+class PanExample(MovingCameraScene):
+    def construct(self):
+        c1 = Circle().shift(LEFT * 3)
+        c2 = Circle().shift(RIGHT * 3)
+        self.add(c1, c2)
+
+        # Pan to first circle
+        self.play(self.camera.frame.animate.move_to(c1))
+        self.wait()
+
+        # Pan to second circle
+        self.play(self.camera.frame.animate.move_to(c2))
+```
+
+### Combined Zoom and Pan
+
+```python
+class ZoomAndPan(MovingCameraScene):
+    def construct(self):
+        square = Square().shift(LEFT * 2)
+        triangle = Triangle().shift(RIGHT * 2)
+        self.add(square, triangle)
+
+        # Zoom in and pan simultaneously
+        self.play(
+            self.camera.frame.animate.scale(0.5).move_to(square)
+        )
+        self.wait()
+
+        # Move to triangle (still zoomed)
+        self.play(self.camera.frame.animate.move_to(triangle))
+```
+
+## Save and Restore Camera State
+
+```python
+class SaveRestoreCamera(MovingCameraScene):
+    def construct(self):
+        circle = Circle()
+        self.add(circle)
+
+        # Save current state
+        self.camera.frame.save_state()
+
+        # Make changes
+        self.play(self.camera.frame.animate.scale(0.3).move_to(circle))
+        self.wait()
+
+        # Restore to saved state
+        self.play(Restore(self.camera.frame))
+```
+
+## auto_zoom
+
+Automatically zoom to fit mobjects.
+
+```python
+class AutoZoomExample(MovingCameraScene):
+    def construct(self):
+        squares = VGroup(*[
+            Square().shift(RIGHT * i + UP * j)
+            for i in range(-2, 3) for j in range(-2, 3)
+        ])
+        self.add(squares)
+
+        # Zoom to fit specific mobject
+        self.play(self.camera.auto_zoom(squares[0]))
+        self.wait()
+
+        # Zoom to fit all with margin
+        self.play(self.camera.auto_zoom(squares, margin=1))
+```
+
+## 3D Camera (ThreeDScene)
+
+```python
+class ThreeDCameraExample(ThreeDScene):
+    def construct(self):
+        axes = ThreeDAxes()
+        sphere = Sphere()
+        self.add(axes, sphere)
+
+        # Set initial camera orientation
+        self.set_camera_orientation(
+            phi=75 * DEGREES,    # Angle from z-axis
+            theta=-45 * DEGREES  # Angle around z-axis
+        )
+```
+
+### Animated Camera Rotation
+
+```python
+class RotatingCamera(ThreeDScene):
+    def construct(self):
+        axes = ThreeDAxes()
+        self.add(axes)
+
+        self.set_camera_orientation(phi=75 * DEGREES, theta=0)
+
+        # Continuous rotation
+        self.begin_ambient_camera_rotation(rate=0.2)
+        self.wait(5)
+        self.stop_ambient_camera_rotation()
+```
+
+### Move 3D Camera
+
+```python
+class Move3DCamera(ThreeDScene):
+    def construct(self):
+        axes = ThreeDAxes()
+        self.add(axes)
+
+        self.set_camera_orientation(phi=75 * DEGREES, theta=-45 * DEGREES)
+
+        # Animate camera movement
+        self.move_camera(
+            phi=45 * DEGREES,
+            theta=45 * DEGREES,
+            run_time=3
+        )
+```
+
+## Camera Background
+
+```python
+class CameraBackground(Scene):
+    def construct(self):
+        # Set background color
+        self.camera.background_color = BLUE_E
+
+        circle = Circle()
+        self.add(circle)
+```
+
+## Best Practices
+
+1. **Use MovingCameraScene for zoom/pan** - Regular Scene camera is static
+2. **Save state before complex movements** - Easy to restore
+3. **Use auto_zoom for dynamic content** - Automatically fits content
+4. **Keep camera movements smooth** - Don't make viewers dizzy
+5. **Use 3D camera rotation sparingly** - Can be disorienting

package/references/manimce/rules/cli.md

@@ -0,0 +1,232 @@
+---
+name: cli
+description: Command-line interface, rendering options, and quality flags
+metadata:
+  tags: cli, render, quality, preview, command, terminal
+---
+
+# Manim CLI
+
+The `manim` command-line interface for rendering scenes.
+
+## Basic Usage
+
+```bash
+# Render a scene
+manim file.py SceneName
+
+# With preview (opens video after rendering)
+manim -p file.py SceneName
+
+# Preview with low quality (fast)
+manim -pql file.py SceneName
+```
+
+## Quality Flags
+
+Quality presets for different use cases:
+
+```bash
+# Low Quality: 854x480, 15fps (fast for testing)
+manim -ql file.py SceneName
+
+# Medium Quality: 1280x720, 30fps
+manim -qm file.py SceneName
+
+# High Quality: 1920x1080, 60fps
+manim -qh file.py SceneName
+
+# 2K Quality: 2560x1440, 60fps
+manim -qp file.py SceneName
+
+# 4K Quality: 3840x2160, 60fps
+manim -qk file.py SceneName
+```
+
+### Common Combinations
+
+```bash
+# Preview + Low Quality (development workflow)
+manim -pql file.py SceneName
+
+# Preview + High Quality (final check)
+manim -pqh file.py SceneName
+```
+
+## Preview Flag
+
+```bash
+# -p: Open video after rendering
+manim -p file.py SceneName
+
+# Without -p: Render only (no auto-open)
+manim file.py SceneName
+```
+
+## Rendering Multiple Scenes
+
+```bash
+# Render all scenes in file
+manim -a file.py
+
+# Render specific scenes
+manim file.py Scene1 Scene2 Scene3
+```
+
+## Output Options
+
+### Save Last Frame Only
+
+```bash
+# -s: Save only the last frame as PNG
+manim -s file.py SceneName
+
+# With quality
+manim -sql file.py SceneName
+```
+
+### Output Format
+
+```bash
+# GIF output
+manim --format gif file.py SceneName
+
+# PNG sequence
+manim --format png file.py SceneName
+
+# WebM (default is MP4)
+manim --format webm file.py SceneName
+```
+
+### Custom Output Directory
+
+```bash
+manim -o custom_name file.py SceneName
+manim --media_dir /path/to/output file.py SceneName
+```
+
+## Frame Control
+
+```bash
+# Start from specific animation number
+manim -n 5 file.py SceneName
+
+# Render frames from animation 3 to 7
+manim -n 3,7 file.py SceneName
+```
+
+## Resolution and FPS
+
+```bash
+# Custom resolution
+manim -r 1920,1080 file.py SceneName
+
+# Custom frame rate
+manim --fps 24 file.py SceneName
+
+# Both
+manim -r 1280,720 --fps 30 file.py SceneName
+```
+
+## Transparency
+
+```bash
+# Render with transparent background
+manim -t file.py SceneName
+```
+
+## Renderer Selection
+
+```bash
+# Cairo renderer (default, 2D)
+manim --renderer cairo file.py SceneName
+
+# OpenGL renderer (3D, faster preview)
+manim --renderer opengl file.py SceneName
+```
+
+## Other Useful Flags
+
+```bash
+# Verbose output
+manim -v DEBUG file.py SceneName
+
+# Quiet mode
+manim -v WARNING file.py SceneName
+
+# Show progress bar
+manim --progress_bar display file.py SceneName
+
+# Disable caching
+manim --disable_caching file.py SceneName
+
+# Write to movie even if no animations
+manim --write_to_movie file.py SceneName
+```
+
+## Help
+
+```bash
+# Show all options
+manim --help
+
+# Show render command options
+manim render --help
+```
+
+## Other Commands
+
+```bash
+# Check installation and dependencies
+manim checkhealth
+
+# Initialize new project
+manim init
+
+# Show config values
+manim cfg show
+
+# Write current config to file
+manim cfg write
+
+# List installed plugins
+manim plugins -l
+```
+
+## Jupyter Notebook Support
+
+Use the `%%manim` cell magic in Jupyter notebooks:
+
+```python
+%%manim -qm -v WARNING MyScene
+class MyScene(Scene):
+    def construct(self):
+        circle = Circle()
+        self.play(Create(circle))
+```
+
+Flags work the same as CLI (`-qm`, `-ql`, etc.).
+
+## Typical Development Workflow
+
+```bash
+# 1. Develop with fast preview
+manim -pql scene.py MyScene
+
+# 2. Check at medium quality
+manim -pqm scene.py MyScene
+
+# 3. Final render at high quality
+manim -qh scene.py MyScene
+
+# 4. Create GIF for sharing
+manim --format gif -qm scene.py MyScene
+```
+
+## Best Practices
+
+1. **Use -pql for development** - Fast iteration cycle
+2. **Use -qh for final output** - Good quality, reasonable render time
+3. **Use -s for thumbnails** - Quick last-frame capture
+4. **Use -a sparingly** - Renders everything, can be slow
+5. **Use --format gif for demos** - Easy to share and embed