mirror of
https://github.com/jeertmans/manim-slides.git
synced 2025-05-18 03:05:21 +08:00
356 lines
9.4 KiB
Python
356 lines
9.4 KiB
Python
# flake8: noqa: F403, F405
|
|
# type: ignore
|
|
import sys
|
|
|
|
if "manim" in sys.modules:
|
|
from manim import *
|
|
|
|
MANIMGL = False
|
|
elif "manimlib" in sys.modules:
|
|
from manimlib import *
|
|
|
|
MANIMGL = True
|
|
else:
|
|
raise ImportError("This script must be run with either `manim` or `manimgl`")
|
|
|
|
from manim_slides import Slide, ThreeDSlide
|
|
|
|
|
|
class BasicExample(Slide):
|
|
def construct(self):
|
|
circle = Circle(radius=3, color=BLUE)
|
|
dot = Dot()
|
|
|
|
self.play(GrowFromCenter(circle))
|
|
self.pause() # Waits user to press continue to go to the next slide
|
|
|
|
self.start_loop() # Start loop
|
|
self.play(MoveAlongPath(dot, circle), run_time=2, rate_func=linear)
|
|
self.end_loop() # This will loop until user inputs a key
|
|
|
|
self.play(dot.animate.move_to(ORIGIN))
|
|
self.pause() # Waits user to press continue to go to the next slide
|
|
|
|
|
|
class TestFileTooLong(Slide):
|
|
"""This is used to check against solution for issue #123."""
|
|
|
|
def construct(self):
|
|
import random
|
|
|
|
circle = Circle(radius=3, color=BLUE)
|
|
dot = Dot()
|
|
self.play(GrowFromCenter(circle), run_time=0.1)
|
|
|
|
for _ in range(30):
|
|
direction = (random.random() - 0.5) * LEFT + (random.random() - 0.5) * UP
|
|
self.play(dot.animate.move_to(direction), run_time=0.1)
|
|
self.play(dot.animate.move_to(ORIGIN), run_time=0.1)
|
|
|
|
self.pause()
|
|
|
|
|
|
class ConvertExample(Slide):
|
|
"""WARNING: this example does not seem to work with ManimGL."""
|
|
|
|
def tinywait(self):
|
|
self.wait(0.1)
|
|
|
|
def construct(self):
|
|
title = VGroup(
|
|
Text("From Manim animations", t2c={"From": BLUE}),
|
|
Text("to slides presentation", t2c={"to": BLUE}),
|
|
Text("with Manim Slides", t2w={"[-12:]": BOLD}, t2c={"[-13:]": YELLOW}),
|
|
).arrange(DOWN)
|
|
|
|
step_1 = Text("1. In your scenes file, import Manim Slides")
|
|
step_2 = Text("2. Replace Scene with Slide")
|
|
step_3 = Text("3. In construct, add pauses where you need")
|
|
step_4 = Text("4. You can also create loops")
|
|
step_5 = Text("5. Render you scene with Manim")
|
|
step_6 = Text("6. Open your presentation with Manim Slides")
|
|
|
|
for step in [step_1, step_2, step_3, step_4, step_5, step_6]:
|
|
step.scale(0.5).to_corner(UL)
|
|
|
|
step = step_1
|
|
|
|
self.play(FadeIn(title))
|
|
|
|
self.pause()
|
|
|
|
code = Code(
|
|
code="""from manim import *
|
|
|
|
|
|
class Example(Scene):
|
|
def construct(self):
|
|
dot = Dot()
|
|
self.add(dot)
|
|
|
|
self.play(Indicate(dot, scale_factor=2))
|
|
|
|
square = Square()
|
|
self.play(Transform(dot, square))
|
|
|
|
self.play(Rotate(square, angle=PI/2))
|
|
""",
|
|
language="python",
|
|
)
|
|
|
|
code_step_1 = Code(
|
|
code="""from manim import *
|
|
from manim_slides import Slide
|
|
|
|
class Example(Scene):
|
|
def construct(self):
|
|
dot = Dot()
|
|
self.add(dot)
|
|
|
|
self.play(Indicate(dot, scale_factor=2))
|
|
|
|
square = Square()
|
|
self.play(Transform(dot, square))
|
|
|
|
self.play(Rotate(square, angle=PI/2))
|
|
""",
|
|
language="python",
|
|
)
|
|
|
|
code_step_2 = Code(
|
|
code="""from manim import *
|
|
from manim_slides import Slide
|
|
|
|
class Example(Slide):
|
|
def construct(self):
|
|
dot = Dot()
|
|
self.add(dot)
|
|
|
|
self.play(Indicate(dot, scale_factor=2))
|
|
|
|
square = Square()
|
|
self.play(Transform(dot, square))
|
|
|
|
self.play(Rotate(square, angle=PI/2))
|
|
""",
|
|
language="python",
|
|
)
|
|
|
|
code_step_3 = Code(
|
|
code="""from manim import *
|
|
from manim_slides import Slide
|
|
|
|
class Example(Slide):
|
|
def construct(self):
|
|
dot = Dot()
|
|
self.add(dot)
|
|
|
|
self.play(Indicate(dot, scale_factor=2))
|
|
self.pause()
|
|
square = Square()
|
|
self.play(Transform(dot, square))
|
|
self.pause()
|
|
self.play(Rotate(square, angle=PI/2))
|
|
""",
|
|
language="python",
|
|
)
|
|
|
|
code_step_4 = Code(
|
|
code="""from manim import *
|
|
from manim_slides import Slide
|
|
|
|
class Example(Slide):
|
|
def construct(self):
|
|
dot = Dot()
|
|
self.add(dot)
|
|
self.start_loop()
|
|
self.play(Indicate(dot, scale_factor=2))
|
|
self.end_loop()
|
|
square = Square()
|
|
self.play(Transform(dot, square))
|
|
self.pause()
|
|
self.play(Rotate(square, angle=PI/2))
|
|
""",
|
|
language="python",
|
|
)
|
|
|
|
code_step_5 = Code(
|
|
code="manim example.py Example",
|
|
language="console",
|
|
)
|
|
|
|
code_step_6 = Code(
|
|
code="manim-slides Example",
|
|
language="console",
|
|
)
|
|
|
|
or_text = Text("or generate HTML presentation").scale(0.5)
|
|
|
|
code_step_7 = Code(
|
|
code="manim-slides convert Example slides.html --open",
|
|
language="console",
|
|
).shift(DOWN)
|
|
|
|
self.clear()
|
|
|
|
self.play(FadeIn(code))
|
|
self.tinywait()
|
|
self.pause()
|
|
|
|
self.play(FadeIn(step, shift=RIGHT))
|
|
self.play(Transform(code, code_step_1))
|
|
self.tinywait()
|
|
self.pause()
|
|
|
|
self.play(Transform(step, step_2))
|
|
self.play(Transform(code, code_step_2))
|
|
self.tinywait()
|
|
self.pause()
|
|
|
|
self.play(Transform(step, step_3))
|
|
self.play(Transform(code, code_step_3))
|
|
self.tinywait()
|
|
self.pause()
|
|
|
|
self.play(Transform(step, step_4))
|
|
self.play(Transform(code, code_step_4))
|
|
self.tinywait()
|
|
self.pause()
|
|
|
|
self.play(Transform(step, step_5))
|
|
self.play(Transform(code, code_step_5))
|
|
self.tinywait()
|
|
self.pause()
|
|
|
|
self.play(Transform(step, step_6))
|
|
self.play(Transform(code, code_step_6))
|
|
self.play(code.animate.shift(UP), FadeIn(code_step_7), FadeIn(or_text))
|
|
self.tinywait()
|
|
self.pause()
|
|
|
|
watch_text = Text("Watch result on next slides!").shift(2 * DOWN).scale(0.5)
|
|
|
|
self.start_loop()
|
|
self.play(FadeIn(watch_text))
|
|
self.play(FadeOut(watch_text))
|
|
self.end_loop()
|
|
self.clear()
|
|
|
|
dot = Dot()
|
|
self.add(dot)
|
|
self.start_loop()
|
|
self.play(Indicate(dot, scale_factor=2))
|
|
self.end_loop()
|
|
square = Square()
|
|
self.play(Transform(dot, square))
|
|
self.remove(dot)
|
|
self.add(square)
|
|
self.tinywait()
|
|
self.pause()
|
|
self.play(Rotate(square, angle=PI / 4))
|
|
self.tinywait()
|
|
self.pause()
|
|
|
|
learn_more_text = (
|
|
VGroup(
|
|
Text("Learn more about Manim Slides:"),
|
|
Text("https://github.com/jeertmans/manim-slides", color=YELLOW),
|
|
)
|
|
.arrange(DOWN)
|
|
.scale(0.75)
|
|
)
|
|
|
|
self.play(Transform(square, learn_more_text))
|
|
self.tinywait()
|
|
|
|
|
|
# For ThreeDExample, things are different
|
|
|
|
if not MANIMGL:
|
|
# [manim-3d]
|
|
class ThreeDExample(ThreeDSlide):
|
|
def construct(self):
|
|
axes = ThreeDAxes()
|
|
circle = Circle(radius=3, color=BLUE)
|
|
dot = Dot(color=RED)
|
|
|
|
self.add(axes)
|
|
|
|
self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
|
|
|
|
self.play(GrowFromCenter(circle))
|
|
self.begin_ambient_camera_rotation(rate=75 * DEGREES / 4)
|
|
|
|
self.pause()
|
|
|
|
self.start_loop()
|
|
self.play(MoveAlongPath(dot, circle), run_time=4, rate_func=linear)
|
|
self.end_loop()
|
|
|
|
self.stop_ambient_camera_rotation()
|
|
self.move_camera(phi=75 * DEGREES, theta=30 * DEGREES)
|
|
|
|
self.play(dot.animate.move_to(ORIGIN))
|
|
self.pause()
|
|
|
|
self.play(dot.animate.move_to(RIGHT * 3))
|
|
self.pause()
|
|
|
|
self.start_loop()
|
|
self.play(MoveAlongPath(dot, circle), run_time=2, rate_func=linear)
|
|
self.end_loop()
|
|
|
|
# Each slide MUST end with an animation (a self.wait is considered an animation)
|
|
self.play(dot.animate.move_to(ORIGIN))
|
|
|
|
# [manim-3d]
|
|
else:
|
|
# [manimgl-3d]
|
|
# WARNING: 3b1b's manim change how ThreeDScene work,
|
|
# this is why things have to be managed differently.
|
|
class ThreeDExample(Slide):
|
|
CONFIG = {
|
|
"camera_class": ThreeDCamera,
|
|
}
|
|
|
|
def construct(self):
|
|
axes = ThreeDAxes()
|
|
circle = Circle(radius=3, color=BLUE)
|
|
dot = Dot(color=RED)
|
|
|
|
self.add(axes)
|
|
|
|
frame = self.camera.frame
|
|
frame.set_euler_angles(
|
|
theta=30 * DEGREES,
|
|
phi=75 * DEGREES,
|
|
gamma=0,
|
|
)
|
|
|
|
self.play(GrowFromCenter(circle))
|
|
updater = lambda m, dt: m.increment_theta((75 * DEGREES / 4) * dt)
|
|
frame.add_updater(updater)
|
|
|
|
self.pause()
|
|
|
|
self.start_loop()
|
|
self.play(MoveAlongPath(dot, circle), run_time=4, rate_func=linear)
|
|
self.end_loop()
|
|
|
|
frame.remove_updater(updater)
|
|
self.play(frame.animate.set_theta(30 * DEGREES))
|
|
self.play(dot.animate.move_to(ORIGIN))
|
|
self.pause()
|
|
|
|
self.play(dot.animate.move_to(RIGHT * 3))
|
|
self.pause()
|
|
|
|
self.start_loop()
|
|
self.play(MoveAlongPath(dot, circle), run_time=2, rate_func=linear)
|
|
self.end_loop()
|
|
|
|
# Each slide MUST end with an animation (a self.wait is considered an animation)
|
|
self.play(dot.animate.move_to(ORIGIN))
|
|
|
|
# [manimgl-3d]
|