Merge :class:~.OpenGLMobject and :class:~.Mobject (#1167)

* Update mobject.py

* 2 test failed

* Update mobject.py

* fix set_rgba_array

* finish

* no errors with cairo so far

* SurfaceExample partially works

* SquareToCircle works

* Update opengl_mobject.py

* SurfaceExample works without  Textures

* More updates

* all opengl examples work pefectly

* Update opengl_surface.py

* fix test case

* fix flake8 and refactor code

* remove all OpenGLMobject related code

* add functions from OpenGL

* remove comments

* Fix bug

example_scenes/opengl.py

@@ -54,13 +54,42 @@ class InteractiveDevelopment(Scene):
         # always(circle.move_to, self.mouse_point)
 
 
+class SquareToCircle(Scene):
+    def construct(self):
+        square = OpenGLSquare()
+        circle = OpenGLCircle()
+
+        self.add(square)
+        self.wait()
+
+        self.play(Transform(square, circle))
+        self.wait()
+
+
+class UpdaterTest(Scene):
+    def construct(self):
+        squares = OpenGLVGroup()
+        for _ in range(9):
+            squares.add(OpenGLSquare(1, stroke_opacity=0).set_fill(WHITE, 0.5))
+        squares.arrange_in_grid(3, 3, buff=0)
+
+        def line():
+            return OpenGLLine(ORIGIN, squares.get_corner(UL))
+
+        self.add(always_redraw(line))
+        self.play(squares.animate.to_edge(UP))
+        self.play(squares.animate.to_edge(DR))
+        self.play(squares.animate.shift(LEFT * 10))
+        self.wait()
+
+
 class SurfaceExample(Scene):
     def construct(self):
-        # surface_text = Text("For 3d scenes, try using surfaces")
-        # surface_text.fix_in_frame()
-        # surface_text.to_edge(UP)
-        # self.add(surface_text)
-        # self.wait(0.1)
+        surface_text = Tex("For 3d scenes, try using surfaces")
+        surface_text.fix_in_frame()
+        surface_text.to_edge(UP)
+        self.add(surface_text)
+        self.wait(0.1)
 
         torus1 = OpenGLTorus(r1=1, r2=1)
         torus2 = OpenGLTorus(r1=3, r2=1)
@@ -123,7 +152,6 @@ class SurfaceExample(Scene):
         # light_text = Text("You can move around the light source")
         # light_text.move_to(surface_text)
         # light_text.fix_in_frame()
-
         # self.play(FadeTransform(surface_text, light_text))
         light = self.camera.light_source
         self.add(light)

manim/animation/animation.py

@@ -18,7 +18,6 @@ from ..mobject import mobject
 from ..mobject import opengl_mobject
 from ..mobject.mobject import Mobject
 from ..utils.rate_functions import smooth
-from ..mobject.opengl_mobject import OpenGLMobject
 
 DEFAULT_ANIMATION_RUN_TIME: float = 1.0
 DEFAULT_ANIMATION_LAG_RATIO: float = 0.0
@@ -64,9 +63,7 @@ class Animation:
     def _typecheck_input(self, mobject: Mobject) -> None:
         if mobject is None:
             logger.debug("creating dummy animation")
-        elif not isinstance(mobject, Mobject) and not isinstance(
-            mobject, OpenGLMobject
-        ):
+        elif not isinstance(mobject, Mobject):
             raise TypeError("Animation only works on Mobjects")
 
     def __str__(self) -> str:
@@ -232,9 +229,6 @@ def prepare_animation(
     if isinstance(anim, mobject._AnimationBuilder):
         return anim.build()
 
-    if isinstance(anim, opengl_mobject._AnimationBuilder):
-        return anim.build()
-
     if isinstance(anim, Animation):
         return anim
 

manim/animation/transform.py

@@ -31,7 +31,6 @@ import numpy as np
 from ..animation.animation import Animation
 from ..constants import DEFAULT_POINTWISE_FUNCTION_RUN_TIME, DEGREES, OUT
 from ..mobject.mobject import Group, Mobject
-from ..mobject.opengl_mobject import OpenGLMobject
 from ..utils.paths import path_along_arc, straight_path
 from ..utils.rate_functions import smooth, squish_rate_func
 
@@ -218,7 +217,7 @@ class ApplyMethod(Transform):
                 "Whoops, looks like you accidentally invoked "
                 "the method you want to animate"
             )
-        assert isinstance(method.__self__, (Mobject, OpenGLMobject))
+        assert isinstance(method.__self__, Mobject)
 
     def create_target(self) -> Mobject:
         method = self.method

manim/mobject/opengl_geometry.py

@@ -214,7 +214,7 @@ class OpenGLArc(OpenGLTipableVMobject):
         self.arc_center = arc_center
         OpenGLVMobject.__init__(self, **kwargs)
 
-    def init_points(self):
+    def generate_points(self):
         self.set_points(
             OpenGLArc.create_quadratic_bezier_points(
                 angle=self.angle,
@@ -383,7 +383,7 @@ class OpenGLAnnularSector(OpenGLArc):
             **kwargs
         )
 
-    def init_points(self):
+    def generate_points(self):
         inner_arc, outer_arc = [
             OpenGLArc(
                 start_angle=self.start_angle,
@@ -429,7 +429,7 @@ class OpenGLAnnulus(OpenGLCircle):
             **kwargs
         )
 
-    def init_points(self):
+    def generate_points(self):
         self.radius = self.outer_radius
         outer_circle = OpenGLCircle(radius=self.outer_radius)
         inner_circle = OpenGLCircle(radius=self.inner_radius)
@@ -447,7 +447,7 @@ class OpenGLLine(OpenGLTipableVMobject):
         self.set_start_and_end_attrs(start, end)
         super().__init__(**kwargs)
 
-    def init_points(self):
+    def generate_points(self):
         self.set_points_by_ends(self.start, self.end, self.buff, self.path_arc)
 
     def set_points_by_ends(self, start, end, buff=0, path_arc=0):
@@ -460,7 +460,7 @@ class OpenGLLine(OpenGLTipableVMobject):
 
     def set_path_arc(self, new_value):
         self.path_arc = new_value
-        self.init_points()
+        self.generate_points()
 
     def account_for_buff(self, buff):
         if buff == 0:
@@ -773,7 +773,7 @@ class OpenGLPolygon(OpenGLVMobject):
         self.vertices = vertices
         super().__init__(**kwargs)
 
-    def init_points(self):
+    def generate_points(self):
         verts = self.vertices
         self.set_points_as_corners([*verts, verts[0]])
 

manim/mobject/opengl_three_dimensions.py

@@ -32,7 +32,7 @@ class OpenGLSurfaceMesh(OpenGLVGroup):
             **kwargs
         )
 
-    def init_points(self):
+    def generate_points(self):
         uv_surface = self.uv_surface
 
         full_nu, full_nv = uv_surface.resolution

manim/mobject/types/opengl_surface.py

@@ -1,8 +1,8 @@
+from manim.mobject.mobject import Mobject
 import numpy as np
 import moderngl
 
 from ...constants import *
-from ...mobject.opengl_mobject import OpenGLMobject
 from ...utils.bezier import integer_interpolate
 from ...utils.bezier import interpolate
 from ...utils.images import get_full_raster_image_path
@@ -11,7 +11,7 @@ from ...utils.color import *
 from ...utils.space_ops import normalize_along_axis
 
 
-class OpenGLSurface(OpenGLMobject):
+class OpenGLSurface(Mobject):
     shader_dtype = [
         ("point", np.float32, (3,)),
         ("du_point", np.float32, (3,)),
@@ -67,12 +67,11 @@ class OpenGLSurface(OpenGLMobject):
         self.compute_triangle_indices()
 
     def uv_func(self, u, v):
-        # To be implemented in subclasses
         if self.passed_uv_func:
             return self.passed_uv_func(u, v)
         return (u, v, 0.0)
 
-    def init_points(self):
+    def generate_points(self):
         dim = self.dim
         nu, nv = self.resolution
         u_range = np.linspace(*self.u_range, nu)
@@ -211,7 +210,7 @@ class OpenGLSurfaceGroup(OpenGLSurface):
         super().__init__(uv_func=None, **kwargs)
         self.add(*parametric_surfaces)
 
-    def init_points(self):
+    def generate_points(self):
         pass  # Needed?
 
 
@@ -254,7 +253,7 @@ class OpenGLTexturedSurface(OpenGLSurface):
         self.data["im_coords"] = np.zeros((0, 2))
         self.data["opacity"] = np.zeros((0, 1))
 
-    def init_points(self):
+    def generate_points(self):
         nu, nv = self.uv_surface.resolution
         self.set_points(self.uv_surface.get_points())
         self.data["im_coords"] = np.array(

manim/mobject/types/opengl_vectorized_mobject.py

@@ -6,7 +6,8 @@ import moderngl
 import numpy as np
 
 from ...constants import *
-from ...mobject.opengl_mobject import OpenGLMobject, OpenGLPoint
+from ...mobject.mobject import Mobject
+from ...mobject.opengl_mobject import OpenGLPoint
 
 # from manimlib.utils.bezier import get_smooth_quadratic_bezier_handle_points
 from ...utils.bezier import (
@@ -40,7 +41,7 @@ JOINT_TYPE_MAP = {
 }
 
 
-class OpenGLVMobject(OpenGLMobject):
+class OpenGLVMobject(Mobject):
     fill_dtype = [
         ("point", np.float32, (3,)),
         ("unit_normal", np.float32, (3,)),
@@ -115,11 +116,6 @@ class OpenGLVMobject(OpenGLMobject):
         super().__init__(**kwargs)
         self.refresh_unit_normal()
 
-        #
-        #     def get_group_class(self):
-        #         return VGroup
-        #
-
     def init_data(self):
         super().init_data()
         self.data.pop("rgbas")
@@ -645,7 +641,7 @@ class OpenGLVMobject(OpenGLMobject):
         if not recompute:
             return self.data["unit_normal"][0]
 
-        if len(self.data["points"]) < 3:
+        if len(self.points) < 3:
             return OUT
 
         area_vect = self.get_area_vector()
@@ -1007,7 +1003,7 @@ class OpenGLVMobject(OpenGLMobject):
         }
 
     def get_stroke_shader_data(self):
-        points = self.data["points"]
+        points = self.points
         stroke_data = np.zeros(len(points), dtype=OpenGLVMobject.stroke_dtype)
 
         nppc = self.n_points_per_curve
@@ -1024,7 +1020,7 @@ class OpenGLVMobject(OpenGLMobject):
         return stroke_data
 
     def get_fill_shader_data(self):
-        points = self.data["points"]
+        points = self.points
         fill_data = np.zeros(len(points), dtype=OpenGLVMobject.fill_dtype)
         fill_data["vert_index"][:, 0] = range(len(points))
 

manim/renderer/opengl_renderer.py

@@ -1,20 +1,15 @@
+from manim.mobject.mobject import Mobject
 from manim.utils.exceptions import EndSceneEarlyException
 from manim.utils.caching import handle_caching_play
 from manim.renderer.cairo_renderer import handle_play_like_call
 from manim.utils.color import color_to_rgba
 import moderngl
 from .opengl_renderer_window import Window
-from .shader_wrapper import ShaderWrapper
 import numpy as np
-from ..mobject.types.vectorized_mobject import VMobject
 import itertools as it
 import time
-from .. import logger
 from ..constants import *
 from ..utils.space_ops import (
-    cross2d,
-    earclip_triangulation,
-    z_to_vector,
     quaternion_mult,
     quaternion_from_angle_axis,
     rotation_matrix_transpose_from_quaternion,
@@ -24,13 +19,13 @@ from ..utils.space_ops import (
 from ..utils.simple_functions import clip
 
 from ..mobject import opengl_geometry
-from ..mobject.opengl_mobject import OpenGLMobject, OpenGLPoint
+from ..mobject.opengl_mobject import OpenGLPoint
 from PIL import Image
 from manim import config
 from ..scene.scene_file_writer import SceneFileWriter
 
 
-class OpenGLCamera(OpenGLMobject):
+class OpenGLCamera(Mobject):
     def __init__(
         self,
         frame_shape=None,
@@ -74,7 +69,7 @@ class OpenGLCamera(OpenGLMobject):
         self.data["euler_angles"] = np.array(self.euler_angles, dtype=float)
         self.refresh_rotation_matrix()
 
-    def init_points(self):
+    def generate_points(self):
         self.set_points([ORIGIN, LEFT, RIGHT, DOWN, UP])
         self.set_width(self.frame_shape[0], stretch=True)
         self.set_height(self.frame_shape[1], stretch=True)