manim-mcp 0.1.0

package/references/manimce/rules/positioning.md

@@ -0,0 +1,211 @@
+---
+name: positioning
+description: move_to, next_to, align_to, shift and positioning methods
+metadata:
+  tags: position, move_to, next_to, shift, align, layout
+---
+
+# Positioning in Manim
+
+Methods for placing and moving mobjects in the scene.
+
+## Coordinate System
+
+Manim uses a coordinate system where:
+- Origin (0, 0, 0) is at the center of the screen
+- X-axis: LEFT (-) to RIGHT (+)
+- Y-axis: DOWN (-) to UP (+)
+- Z-axis: IN (-) to OUT (+) (for 3D)
+
+### Direction Constants
+```python
+UP = np.array([0, 1, 0])
+DOWN = np.array([0, -1, 0])
+LEFT = np.array([-1, 0, 0])
+RIGHT = np.array([1, 0, 0])
+ORIGIN = np.array([0, 0, 0])
+
+# Diagonals
+UL = UP + LEFT      # Upper left
+UR = UP + RIGHT     # Upper right
+DL = DOWN + LEFT    # Lower left
+DR = DOWN + RIGHT   # Lower right
+```
+
+## move_to
+
+Move to an absolute position.
+
+```python
+from manim import *
+
+class MoveToExample(Scene):
+    def construct(self):
+        circle = Circle()
+
+        # Move to origin
+        circle.move_to(ORIGIN)
+
+        # Move to specific coordinates
+        circle.move_to(RIGHT * 2 + UP * 1)
+
+        # Move to another mobject's position
+        square = Square().shift(LEFT * 2)
+        circle.move_to(square)
+
+        # Move to a specific point of another mobject
+        circle.move_to(square.get_top())
+```
+
+## shift
+
+Move relative to current position.
+
+```python
+class ShiftExample(Scene):
+    def construct(self):
+        circle = Circle()
+
+        # Shift in one direction
+        circle.shift(RIGHT)
+        circle.shift(UP * 2)
+
+        # Shift in multiple directions
+        circle.shift(RIGHT * 2 + UP * 1)
+
+        # Chain shifts
+        circle.shift(LEFT).shift(DOWN)
+```
+
+## next_to
+
+Position relative to another mobject.
+
+```python
+class NextToExample(Scene):
+    def construct(self):
+        square = Square()
+        circle = Circle()
+        triangle = Triangle()
+
+        # Place circle to the right of square
+        circle.next_to(square, RIGHT)
+
+        # With buffer (spacing)
+        triangle.next_to(square, DOWN, buff=0.5)
+
+        # Aligned to specific edge
+        circle.next_to(square, RIGHT, aligned_edge=UP)
+```
+
+### buff Parameter
+```python
+# Default buffer
+circle.next_to(square, RIGHT)  # Uses DEFAULT_MOBJECT_TO_MOBJECT_BUFFER
+
+# Custom buffer
+circle.next_to(square, RIGHT, buff=0)    # No gap
+circle.next_to(square, RIGHT, buff=1)    # 1 unit gap
+circle.next_to(square, RIGHT, buff=0.5)  # Half unit gap
+```
+
+## align_to
+
+Align edges with another mobject.
+
+```python
+class AlignToExample(Scene):
+    def construct(self):
+        square = Square().shift(LEFT)
+        circle = Circle().shift(RIGHT)
+
+        # Align circle's left edge with square's left edge
+        circle.align_to(square, LEFT)
+
+        # Align tops
+        circle.align_to(square, UP)
+
+        # Align to a point
+        circle.align_to(ORIGIN, DOWN)
+```
+
+## Edge Methods
+
+Position at screen edges.
+
+```python
+class EdgeExample(Scene):
+    def construct(self):
+        # To screen edges
+        text1 = Text("Top").to_edge(UP)
+        text2 = Text("Bottom").to_edge(DOWN)
+        text3 = Text("Left").to_edge(LEFT)
+        text4 = Text("Right").to_edge(RIGHT)
+
+        # With buffer
+        text5 = Text("Buffered").to_edge(UP, buff=1)
+```
+
+## Corner Methods
+
+Position at screen corners.
+
+```python
+class CornerExample(Scene):
+    def construct(self):
+        t1 = Text("UL").to_corner(UL)
+        t2 = Text("UR").to_corner(UR)
+        t3 = Text("DL").to_corner(DL)
+        t4 = Text("DR").to_corner(DR)
+
+        # With buffer
+        t5 = Text("Buffered").to_corner(UL, buff=0.5)
+```
+
+## center
+
+Center on screen or another mobject.
+
+```python
+mobject.center()           # Center on screen
+mobject.center_on(other)   # Center on another mobject (custom helper)
+```
+
+## Getting Positions
+
+```python
+circle = Circle()
+
+# Get various points
+circle.get_center()        # Center point
+circle.get_top()           # Top edge center
+circle.get_bottom()        # Bottom edge center
+circle.get_left()          # Left edge center
+circle.get_right()         # Right edge center
+circle.get_corner(UL)      # Upper left corner
+circle.get_corner(DR)      # Lower right corner
+circle.get_start()         # Start of path
+circle.get_end()           # End of path
+```
+
+## Animated Positioning
+
+```python
+class AnimatedPosition(Scene):
+    def construct(self):
+        square = Square()
+        self.add(square)
+
+        # Animate movement
+        self.play(square.animate.shift(RIGHT * 2))
+        self.play(square.animate.move_to(UP * 2))
+        self.play(square.animate.to_edge(LEFT))
+```
+
+## Best Practices
+
+1. **Use next_to for relative positioning** - Maintains relationships
+2. **Use move_to for absolute positioning** - Precise coordinates
+3. **Use shift for relative adjustments** - Quick tweaks
+4. **Use to_edge/to_corner for screen positioning** - Responsive layouts
+5. **Adjust buff for visual spacing** - Don't let elements crowd

package/references/manimce/rules/scenes.md

@@ -0,0 +1,121 @@
+---
+name: scenes
+description: Scene structure, construct method, and scene types in Manim
+metadata:
+  tags: scene, construct, setup, render, ThreeDScene, MovingCameraScene
+---
+
+# Scenes in Manim
+
+A Scene is the canvas where all animations take place. Every Manim animation is defined within a Scene class.
+
+## Basic Scene Structure
+
+All animation code resides within the `construct()` method of a Scene subclass.
+
+```python
+from manim import *
+
+class MyScene(Scene):
+    def construct(self):
+        circle = Circle()
+        self.play(Create(circle))
+        self.wait(1)
+```
+
+## Scene Lifecycle Methods
+
+### construct()
+The main method where you define your animation. Called automatically when rendering.
+
+### setup()
+Called before `construct()`. Use for initialization that should happen before animation logic.
+
+```python
+class MyScene(Scene):
+    def setup(self):
+        self.camera.background_color = BLUE_E
+
+    def construct(self):
+        circle = Circle()
+        self.play(Create(circle))
+```
+
+## Scene Methods
+
+### Adding and Removing Objects
+
+```python
+# Add without animation (instant)
+self.add(mobject)
+self.add(mobject1, mobject2, mobject3)
+
+# Remove without animation
+self.remove(mobject)
+
+# Clear all mobjects
+self.clear()
+```
+
+### Playing Animations
+
+```python
+# Play a single animation
+self.play(Create(circle))
+
+# Play multiple animations simultaneously
+self.play(Create(circle), FadeIn(square))
+
+# With run_time
+self.play(Create(circle), run_time=2)
+```
+
+### Waiting
+
+```python
+# Wait for 1 second (default)
+self.wait()
+
+# Wait for specific duration
+self.wait(2)
+```
+
+## Scene Types
+
+### Scene (Default)
+Standard 2D scene for most animations.
+
+### ThreeDScene
+For 3D animations with camera orientation control.
+
+```python
+class My3DScene(ThreeDScene):
+    def construct(self):
+        self.set_camera_orientation(phi=75 * DEGREES, theta=-45 * DEGREES)
+        axes = ThreeDAxes()
+        sphere = Sphere()
+        self.add(axes, sphere)
+```
+
+### MovingCameraScene
+For animations that require camera movement (zoom, pan).
+
+```python
+class ZoomScene(MovingCameraScene):
+    def construct(self):
+        circle = Circle()
+        self.add(circle)
+        self.play(self.camera.frame.animate.scale(0.5).move_to(circle))
+```
+
+## Multiple Scenes in One File
+
+Render specific scene:
+```bash
+manim -pql file.py Scene1
+```
+
+Render all scenes:
+```bash
+manim -pql -a file.py
+```

package/references/manimce/rules/shapes.md

@@ -0,0 +1,300 @@
+---
+name: shapes
+description: Circle, Square, Rectangle, Polygon and geometric primitives
+metadata:
+  tags: shapes, circle, square, rectangle, polygon, geometry
+---
+
+# Geometric Shapes
+
+Basic geometric primitives in Manim.
+
+## Circle
+
+```python
+from manim import *
+
+class CircleExample(Scene):
+    def construct(self):
+        # Default circle
+        c1 = Circle()
+
+        # With parameters
+        c2 = Circle(
+            radius=2,
+            color=BLUE,
+            fill_opacity=0.5,
+            stroke_width=4
+        )
+
+        self.add(c1, c2)
+```
+
+### Circle Methods
+
+```python
+circle = Circle()
+
+# Get properties
+circle.get_radius()
+circle.get_center()
+
+# Create from points
+Circle.from_three_points(p1, p2, p3)
+
+# Surround another mobject
+triangle = Triangle()
+circle = Circle().surround(triangle)  # Circle wraps around triangle
+circle = Circle().surround(triangle, buffer_factor=1.5)  # With padding
+circle = Circle().surround(triangle, stretch=True)  # Stretch to fit
+```
+
+## Ellipse
+
+```python
+class EllipseExample(Scene):
+    def construct(self):
+        ellipse = Ellipse(
+            width=4,
+            height=2,
+            color=GREEN
+        )
+        self.add(ellipse)
+```
+
+## Square
+
+```python
+class SquareExample(Scene):
+    def construct(self):
+        # Default square
+        s1 = Square()
+
+        # With parameters
+        s2 = Square(
+            side_length=2,
+            color=RED,
+            fill_opacity=0.8
+        )
+
+        self.add(s1, s2)
+```
+
+## Rectangle
+
+```python
+class RectangleExample(Scene):
+    def construct(self):
+        rect = Rectangle(
+            width=4,
+            height=2,
+            color=YELLOW,
+            fill_opacity=0.5
+        )
+        self.add(rect)
+```
+
+### RoundedRectangle
+
+```python
+class RoundedRectExample(Scene):
+    def construct(self):
+        rounded = RoundedRectangle(
+            width=4,
+            height=2,
+            corner_radius=0.5,
+            color=BLUE,
+            fill_opacity=0.8
+        )
+        self.add(rounded)
+```
+
+## Triangle
+
+```python
+class TriangleExample(Scene):
+    def construct(self):
+        # Equilateral triangle
+        tri = Triangle(color=PURPLE)
+
+        # Custom triangle (using Polygon)
+        custom_tri = Polygon(
+            ORIGIN, RIGHT * 2, UP * 3,
+            color=GREEN
+        )
+
+        self.add(tri, custom_tri.shift(RIGHT * 3))
+```
+
+## Polygon
+
+Create any polygon from vertices.
+
+```python
+class PolygonExample(Scene):
+    def construct(self):
+        # Pentagon
+        pentagon = RegularPolygon(n=5, color=ORANGE)
+
+        # Hexagon
+        hexagon = RegularPolygon(n=6, color=TEAL)
+
+        # Custom polygon
+        custom = Polygon(
+            [-2, -1, 0],
+            [2, -1, 0],
+            [2, 1, 0],
+            [0, 2, 0],
+            [-2, 1, 0],
+            color=PINK
+        )
+
+        VGroup(pentagon, hexagon, custom).arrange(RIGHT, buff=1)
+        self.add(pentagon, hexagon, custom)
+```
+
+## RegularPolygon
+
+```python
+class RegularPolygonExamples(Scene):
+    def construct(self):
+        shapes = VGroup(
+            RegularPolygon(n=3),   # Triangle
+            RegularPolygon(n=4),   # Square
+            RegularPolygon(n=5),   # Pentagon
+            RegularPolygon(n=6),   # Hexagon
+            RegularPolygon(n=8),   # Octagon
+        ).arrange(RIGHT)
+        self.add(shapes)
+```
+
+## Star
+
+```python
+class StarExample(Scene):
+    def construct(self):
+        star = Star(
+            n=5,                    # Number of points
+            outer_radius=2,
+            inner_radius=1,         # Optional: auto-calculated if not specified
+            density=2,              # How vertices connect (affects shape)
+            color=YELLOW,
+            fill_opacity=1
+        )
+        self.add(star)
+
+        # Different densities create different star patterns
+        star_d2 = Star(7, outer_radius=2, density=2, color=RED)
+        star_d3 = Star(7, outer_radius=2, density=3, color=PURPLE)
+```
+
+## RegularPolygram
+
+Star-like shapes with vertices connected by density.
+
+```python
+class PolygramExample(Scene):
+    def construct(self):
+        # Pentagram (5-pointed star pattern)
+        pentagram = RegularPolygram(5, radius=2)
+        self.add(pentagram)
+```
+
+## Annulus (Ring)
+
+```python
+class AnnulusExample(Scene):
+    def construct(self):
+        ring = Annulus(
+            inner_radius=1,
+            outer_radius=2,
+            color=BLUE,
+            fill_opacity=0.5
+        )
+        self.add(ring)
+```
+
+## Sector and Arc
+
+```python
+class SectorArcExample(Scene):
+    def construct(self):
+        # Sector (pie slice)
+        sector = Sector(
+            radius=2,
+            angle=PI/2,
+            start_angle=0,
+            color=RED,
+            fill_opacity=0.8
+        ).shift(LEFT * 2)
+
+        # Arc (just the curve)
+        arc = Arc(
+            radius=2,
+            angle=PI/2,
+            start_angle=PI,
+            color=BLUE
+        ).shift(RIGHT * 2)
+
+        self.add(sector, arc)
+```
+
+## ArcBetweenPoints
+
+```python
+class ArcBetweenPointsExample(Scene):
+    def construct(self):
+        arc = ArcBetweenPoints(
+            start=LEFT * 2,
+            end=RIGHT * 2,
+            angle=PI/2,  # Curvature
+            color=GREEN
+        )
+        self.add(arc)
+```
+
+## Dot
+
+```python
+class DotExample(Scene):
+    def construct(self):
+        # Default dot
+        d1 = Dot()
+
+        # Customized
+        d2 = Dot(
+            point=RIGHT * 2,
+            radius=0.2,
+            color=YELLOW
+        )
+
+        self.add(d1, d2)
+```
+
+## Common Shape Operations
+
+```python
+shape = Square()
+
+# Transform
+shape.scale(2)
+shape.rotate(PI/4)
+shape.stretch(2, dim=0)  # Stretch horizontally
+
+# Style
+shape.set_fill(RED, opacity=0.5)
+shape.set_stroke(WHITE, width=4)
+
+# Position
+shape.move_to(ORIGIN)
+shape.shift(UP * 2)
+shape.next_to(other, RIGHT)
+```
+
+## Best Practices
+
+1. **Use RegularPolygon for regular shapes** - More precise than manual Polygon
+2. **Set fill_opacity for visibility** - Default is often 0 (transparent)
+3. **Use Dot for points** - Better than Circle with small radius
+4. **Use RoundedRectangle for UI elements** - More polished look
+5. **Combine shapes with VGroup** - For complex figures