Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

Added OpenGL compatibility to :meth:`.ThreeDScene.begin_ambient_camera_rotation` and :meth:`.ThreeDScene.move_camera` (#2113)

icedcoffeeee8a4222e4f4e6
diff --git a/manim/scene/three_d_scene.py b/manim/scene/three_d_scene.py
index 45eaac642..b6147ff68 100644
--- a/manim/scene/three_d_scene.py
+++ b/manim/scene/three_d_scene.py
@@ -3,21 +3,24 @@
__all__ = ["ThreeDScene", "SpecialThreeDScene"]
+import warnings
from typing import Iterable, Optional, Sequence, Union
import numpy as np
from .. import config
from ..animation.animation import Animation
-from ..animation.transform import ApplyMethod
+from ..animation.transform import Transform
from ..camera.three_d_camera import ThreeDCamera
from ..constants import DEGREES
from ..mobject.coordinate_systems import ThreeDAxes
from ..mobject.geometry import Line
from ..mobject.mobject import Mobject
+from ..mobject.opengl_mobject import OpenGLMobject
from ..mobject.three_dimensions import Sphere
from ..mobject.types.vectorized_mobject import VectorizedPoint, VGroup
from ..mobject.value_tracker import ValueTracker
+from ..renderer.opengl_renderer import OpenGLCamera
from ..scene.scene import Scene
from ..utils.config_ops import merge_dicts_recursively
@@ -107,34 +110,49 @@ class ThreeDScene(Scene):
"""
# TODO, use a ValueTracker for rate, so that it
# can begin and end smoothly
- if about.lower() == "phi":
- x = self.renderer.camera.phi_tracker
- elif about.lower() == "gamma":
- x = self.renderer.camera.gamma_tracker
- elif about.lower() == "theta":
- x = self.renderer.camera.theta_tracker
- else:
+ about: str = about.lower()
+ try:
+ if config.renderer != "opengl":
+ trackers = {
+ "theta": self.camera.theta_tracker,
+ "phi": self.camera.phi_tracker,
+ "gamma": self.camera.gamma_tracker,
+ }
+ x: ValueTracker = trackers[about]
+ x.add_updater(lambda m, dt: x.increment_value(rate * dt))
+ self.add(x)
+ else:
+ cam: OpenGLCamera = self.camera
+ methods = {
+ "theta": cam.increment_theta,
+ "phi": cam.increment_phi,
+ "gamma": cam.increment_gamma,
+ }
+ cam.add_updater(lambda m, dt: methods[about](rate * dt))
+ self.add(self.camera)
+ except:
raise ValueError("Invalid ambient rotation angle.")
- x.add_updater(lambda m, dt: m.increment_value(rate * dt))
- self.add(x)
-
def stop_ambient_camera_rotation(self, about="theta"):
"""
This method stops all ambient camera rotation.
"""
- if about.lower() == "phi":
- x = self.renderer.camera.phi_tracker
- elif about.lower() == "gamma":
- x = self.renderer.camera.gamma_tracker
- elif about.lower() == "theta":
- x = self.renderer.camera.theta_tracker
- else:
+ about: str = about.lower()
+ try:
+ if config.renderer != "opengl":
+ trackers = {
+ "theta": self.camera.theta_tracker,
+ "phi": self.camera.phi_tracker,
+ "gamma": self.camera.gamma_tracker,
+ }
+ x: ValueTracker = trackers[about]
+ x.clear_updaters()
+ self.remove(x)
+ else:
+ self.camera.clear_updaters()
+ except:
raise ValueError("Invalid ambient rotation angle.")
- x.clear_updaters()
- self.remove(x)
-
def begin_3dillusion_camera_rotation(
self,
rate=1,
@@ -210,31 +228,67 @@ class ThreeDScene(Scene):
"""
anims = []
- value_tracker_pairs = [
- (phi, self.renderer.camera.phi_tracker),
- (theta, self.renderer.camera.theta_tracker),
- (distance, self.renderer.camera.distance_tracker),
- (gamma, self.renderer.camera.gamma_tracker),
- (zoom, self.renderer.camera.zoom_tracker),
- ]
- for value, tracker in value_tracker_pairs:
- if value is not None:
- anims.append(ApplyMethod(tracker.set_value, value, **kwargs))
- if frame_center is not None:
- anims.append(
- ApplyMethod(
- self.renderer.camera._frame_center.move_to, frame_center, **kwargs
- ),
- )
- self.play(*anims + added_anims)
+ if config.renderer != "opengl":
+ self.camera: ThreeDCamera
+ value_tracker_pairs = [
+ (phi, self.camera.phi_tracker),
+ (theta, self.camera.theta_tracker),
+ (distance, self.camera.distance_tracker),
+ (gamma, self.camera.gamma_tracker),
+ (zoom, self.camera.zoom_tracker),
+ ]
+ for value, tracker in value_tracker_pairs:
+ if value is not None:
+ anims.append(tracker.animate.set_value(value))
+ if frame_center is not None:
+ anims.append(self.camera._frame_center.animate.move_to(frame_center))
+ else:
+ cam: OpenGLCamera = self.camera
+ cam2 = cam.copy()
+ methods = {
+ "theta": cam2.set_theta,
+ "phi": cam2.set_phi,
+ "gamma": cam2.set_gamma,
+ "zoom": cam2.scale,
+ "frame_center": cam2.move_to,
+ }
+ if frame_center is not None:
+ if isinstance(frame_center, OpenGLMobject):
+ frame_center = frame_center.get_center()
+ frame_center = list(frame_center)
+
+ for value, method in [
+ [theta, "theta"],
+ [phi, "phi"],
+ [gamma, "gamma"],
+ [
+ config.frame_height / (zoom * cam.height)
+ if zoom is not None
+ else None,
+ "zoom",
+ ],
+ [frame_center, "frame_center"],
+ ]:
+ if value is not None:
+ methods[method](value)
+
+ if distance is not None:
+ warnings.warn(
+ "focal distance of OpenGLCamera can not be adjusted.",
+ stacklevel=2,
+ )
+
+ anims += [Transform(cam, cam2)]
+
+ self.play(*anims + added_anims, **kwargs)
# These lines are added to improve performance. If manim thinks that frame_center is moving,
# it is required to redraw every object. These lines remove frame_center from the Scene once
# its animation is done, ensuring that manim does not think that it is moving. Since the
# frame_center is never actually drawn, this shouldn't break anything.
- if frame_center is not None:
- self.remove(self.renderer.camera._frame_center)
+ if frame_center is not None and config.renderer != "opengl":
+ self.remove(self.camera._frame_center)
def get_moving_mobjects(self, *animations):
"""