Add text and SVG mobjects to OpenGL

manim/animation/transform.py

@@ -30,6 +30,7 @@
 
 import numpy as np
 
+from .. import config
 from ..animation.animation import Animation
 from ..constants import DEFAULT_POINTWISE_FUNCTION_RUN_TIME, DEGREES, OUT
 from ..mobject.mobject import Group, Mobject
@@ -80,7 +81,10 @@ def begin(self) -> None:
         self.target_copy = self.target_mobject.copy()
         # Note, this potentially changes the structure
         # of both mobject and target_mobject
-        self.mobject.align_data(self.target_copy)
+        if config["renderer"] == "opengl":
+            self.mobject.align_data_and_family(self.target_copy)
+        else:
+            self.mobject.align_data(self.target_copy)
         super().begin()
 
     def create_target(self) -> typing.Union[Mobject, None]:

manim/mobject/mobject.py

@@ -223,7 +223,10 @@ def __deepcopy__(self, clone_from_id):
         return result
 
     def __repr__(self):
-        return str(self.name)
+        if config["renderer"] == "opengl":
+            return super().__repr__()
+        else:
+            return str(self.name)
 
     def reset_points(self):
         """Sets :attr:`points` to be an empty array."""

manim/mobject/opengl_mobject.py

@@ -135,7 +135,101 @@ def animate(self):
         # Borrowed from https://github.com/ManimCommunity/manim/
         return _AnimationBuilder(self)
 
+    @property
+    def width(self):
+        """The width of the mobject.
+
+        Returns
+        -------
+        :class:`float`
+
+        Examples
+        --------
+        .. manim:: WidthExample
+
+            class WidthExample(Scene):
+                def construct(self):
+                    decimal = DecimalNumber().to_edge(UP)
+                    rect = Rectangle(color=BLUE)
+                    rect_copy = rect.copy().set_stroke(GRAY, opacity=0.5)
+
+                    decimal.add_updater(lambda d: d.set_value(rect.width))
+
+                    self.add(rect_copy, rect, decimal)
+                    self.play(rect.animate.set(width=7))
+                    self.wait()
+
+        See also
+        --------
+        :meth:`length_over_dim`
+
+        """
+
+        # Get the length across the X dimension
+        return self.length_over_dim(0)
+
     # Only these methods should directly affect points
+    @width.setter
+    def width(self, value):
+        self.rescale_to_fit(value, 0, stretch=False)
+
+    @property
+    def height(self):
+        """The height of the mobject.
+
+        Returns
+        -------
+        :class:`float`
+
+        Examples
+        --------
+        .. manim:: HeightExample
+
+            class HeightExample(Scene):
+                def construct(self):
+                    decimal = DecimalNumber().to_edge(UP)
+                    rect = Rectangle(color=BLUE)
+                    rect_copy = rect.copy().set_stroke(GRAY, opacity=0.5)
+
+                    decimal.add_updater(lambda d: d.set_value(rect.height))
+
+                    self.add(rect_copy, rect, decimal)
+                    self.play(rect.animate.set(height=5))
+                    self.wait()
+
+        See also
+        --------
+        :meth:`length_over_dim`
+
+        """
+
+        # Get the length across the Y dimension
+        return self.length_over_dim(1)
+
+    @height.setter
+    def height(self, value):
+        self.rescale_to_fit(value, 1, stretch=False)
+
+    @property
+    def depth(self):
+        """The depth of the mobject.
+
+        Returns
+        -------
+        :class:`float`
+
+        See also
+        --------
+        :meth:`length_over_dim`
+
+        """
+
+        # Get the length across the Z dimension
+        return self.length_over_dim(2)
+
+    @depth.setter
+    def depth(self, value):
+        self.rescale_to_fit(value, 2, stretch=False)
 
     def resize_points(self, new_length, resize_func=resize_array):
         if new_length != len(self.data["points"]):
@@ -619,7 +713,6 @@ def rotate(
         self,
         angle,
         axis=OUT,
-        about_point: Union[np.ndarray, List, None] = None,
         **kwargs,
     ):
         rot_matrix_T = rotation_matrix_transpose(angle, axis)

manim/mobject/svg/opengl_svg_mobject.py

@@ -0,0 +1,42 @@
+from ...constants import *
+from ..svg.svg_mobject import SVGMobject
+from ..types.opengl_vectorized_mobject import OpenGLVMobject
+from .opengl_svg_path import OpenGLSVGPathMobject
+from .style_utils import cascade_element_style, parse_style
+
+
+class OpenGLSVGMobject(OpenGLVMobject, SVGMobject):
+    def __init__(
+        self,
+        file_name=None,
+        should_center=True,
+        height=2,
+        width=None,
+        unpack_groups=True,  # if False, creates a hierarchy of VGroups
+        stroke_width=DEFAULT_STROKE_WIDTH,
+        fill_opacity=1.0,
+        should_subdivide_sharp_curves=False,
+        should_remove_null_curves=False,
+        **kwargs,
+    ):
+        self.def_map = {}
+        self.file_name = file_name or self.file_name
+        self.ensure_valid_file()
+        self.should_center = should_center
+        self.unpack_groups = unpack_groups
+        self.path_string_config = {
+            "should_subdivide_sharp_curves": should_subdivide_sharp_curves,
+            "should_remove_null_curves": should_remove_null_curves,
+        }
+        OpenGLVMobject.__init__(
+            self, stroke_width=stroke_width, fill_opacity=fill_opacity, **kwargs
+        )
+        self.move_into_position(width, height)
+
+    def init_points(self):
+        self.generate_points()
+
+    def path_string_to_mobject(self, path_string: str, style: dict):
+        return OpenGLSVGPathMobject(
+            path_string, **self.path_string_config, **parse_style(style)
+        )

manim/mobject/svg/opengl_svg_path.py

@@ -0,0 +1,29 @@
+import numpy as np
+
+from ..types.opengl_vectorized_mobject import OpenGLVMobject
+from .svg_path import SVGPathMobject
+
+
+class OpenGLSVGPathMobject(OpenGLVMobject, SVGPathMobject):
+    def __init__(
+        self,
+        path_string,
+        should_subdivide_sharp_curves=False,
+        should_remove_null_curves=False,
+        **kwargs
+    ):
+        self.path_string = path_string
+        OpenGLVMobject.__init__(
+            self,
+            long_lines=True,
+            should_subdivide_sharp_curves=should_subdivide_sharp_curves,
+            should_remove_null_curves=should_remove_null_curves,
+            **kwargs
+        )
+        self.current_path_start = np.zeros((1, self.dim))
+
+    def init_points(self):
+        self.generate_points()
+
+    def start_new_path(self, point):
+        SVGPathMobject.start_new_path(self, point)