[EXPERIMENTAL] Mobject shader cleanup + Scene changes + Undo orientation input in vertex shader + Transparency Fix (#3474)

* Updated Scene.remove

* Updated Scene.replace

* When shader file is missing, log its absolute path

* Undo adding 'orientation' in vert.glsl, revert to 'unit_normal' in OpenGLVMobject

* Added removed docstring to Scene.replace

* Removed and rewrote multiple OpenGL(V)Mobject methods

* Fixed OpenGLVMobject.get_style()

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Fixing transparency and generator bug

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: MrDiver <[email protected]>

Author: 3 people

example_scenes/new_test_new.py

@@ -0,0 +1,162 @@
+import time
+
+import numpy as np
+import pyglet
+from PIL import Image
+from pyglet import shapes
+from pyglet.gl import Config
+from pyglet.window import Window
+
+import manim.utils.color.manim_colors as col
+from manim._config import config, tempconfig
+from manim.animation.creation import Create, DrawBorderThenFill, Write
+from manim.animation.fading import FadeIn
+from manim.animation.transform import Transform
+from manim.camera.camera import OpenGLCameraFrame
+from manim.constants import LEFT, OUT, RIGHT, UP
+from manim.mobject.geometry.arc import Circle
+from manim.mobject.geometry.polygram import Square
+from manim.mobject.logo import ManimBanner
+from manim.mobject.opengl.opengl_vectorized_mobject import OpenGLVMobject
+from manim.mobject.text.numbers import DecimalNumber
+from manim.mobject.text.text_mobject import Text
+from manim.renderer.opengl_renderer import OpenGLRenderer
+
+
+def progress_through_animations(animations):
+    dt = t - last_t
+    last_t = t
+    for animation in animations:
+        animation.update_mobjects(dt)
+        alpha = t / animation.run_time
+        animation.interpolate(alpha)
+    self.update_frame(dt)
+    self.emit_frame()
+
+
+if __name__ == "__main__":
+    with tempconfig({"renderer": "opengl"}):
+        win = Window(
+            width=1920,
+            height=1080,
+            vsync=True,
+            config=Config(double_buffer=True, samples=0),
+        )
+        renderer = OpenGLRenderer(1920, 1080, background_color=col.GRAY)
+        # vm = OpenGLVMobject([col.RED, col.GREEN])
+        vm = (
+            Circle(
+                radius=1,
+                stroke_color=col.YELLOW,
+            )
+            .shift(3 * RIGHT + OUT)
+            .set_opacity(0.6)
+        )
+        vm2 = Square(stroke_color=col.GREEN, fill_opacity=0, stroke_opacity=1).move_to(
+            (0, 0, -0.5)
+        )
+        vm3 = ManimBanner().set_opacity(0.6)
+        vm4 = (
+            Circle(0.5, col.GREEN)
+            .set_opacity(0.6)
+            .shift(OUT)
+            .set_fill(col.BLUE, opacity=0.2)
+        )
+        # vm.set_points_as_corners([[-1920/2, 0, 0], [1920/2, 0, 0], [0, 1080/2, 0]])
+        # print(vm.color)
+        # print(vm.fill_color)
+        # print(vm.stroke_color)
+
+        clock_mobject = DecimalNumber(0.0).shift(4 * LEFT + 2.5 * UP)
+        clock_mobject.fix_in_frame()
+
+        camera = OpenGLCameraFrame()
+        camera.save_state()
+        # renderer.init_camera(camera)
+
+        # renderer.render(camera, [vm, vm2])
+        # image = renderer.get_pixels()
+        # print(image.shape)
+        # Image.fromarray(image, "RGBA").show()
+        # exit(0)
+        renderer.use_window()
+
+        clock = pyglet.clock.get_default()
+
+        def update_circle(dt):
+            vm.move_to((np.sin(dt) * 4, np.cos(dt) * 4, -1))
+
+        def p2m(x, y, z):
+            from manim._config import config
+
+            return (
+                config.frame_width * (x / config.pixel_width - 0.5),
+                config.frame_height * (y / config.pixel_height - 0.5),
+                z,
+            )
+
+        @win.event
+        def on_close():
+            win.close()
+
+        @win.event
+        def on_mouse_motion(x, y, dx, dy):
+            # vm.move_to((14.2222 * (x / 1920 - 0.5), 8 * (y / 1080 - 0.5), 0))
+            # camera.move_to(p2m(x,y,camera.get_center()[2]))
+            from scipy.spatial.transform import Rotation
+
+            camera.set_orientation(
+                Rotation.from_rotvec(
+                    (-UP * (x / 1920 - 0.5) + RIGHT * (y / 1080 - 0.5)) * 2 * 3.1415
+                )
+            )
+            # vm.set_color(col.RED.interpolate(col.GREEN,x/1920))
+            # print(x,y)
+
+        @win.event
+        def on_draw():
+            dt = clock.update_time()
+            renderer.render(camera, [vm2, vm3, vm4, clock_mobject, vm])
+            # update_circle(counter)
+
+        @win.event
+        def on_resize(width, height):
+            super(Window, win).on_resize(width, height)
+
+        # pyglet.app.run()
+        has_started = False
+        is_finished = False
+
+        run_time = 5
+        new_vm = Square(fill_color=col.GREEN, stroke_color=col.BLUE).shift(
+            2.5 * RIGHT - UP + 2 * OUT
+        )
+        animation = DrawBorderThenFill(vm3, run_time=run_time)
+
+        real_time = 0
+        virtual_time = 0
+        start_timestamp = time.time()
+        dt = 1 / 30
+
+        while True:
+            # pyglet.app.platform_event_loop.step()
+            win.switch_to()
+            if not has_started:
+                animation.begin()
+                has_started = True
+
+            real_time = time.time() - start_timestamp
+            while virtual_time < real_time:
+                virtual_time += dt
+                if not is_finished:
+                    if virtual_time >= run_time:
+                        animation.finish()
+                        has_finished = True
+                    else:
+                        animation.update_mobjects(dt)
+                        animation.interpolate(virtual_time / run_time)
+            # update_circle(virtual_time)
+            clock_mobject.set_value(virtual_time)
+            win.dispatch_event("on_draw")
+            win.dispatch_events()
+            win.flip()

manim/mobject/opengl/opengl_mobject.py

@@ -174,10 +174,6 @@ def __init__(
         self.init_points()
         self.color = ManimColor.parse(color)
         self.init_colors()
-        self.init_shader_data()
-
-        if self.depth_test:
-            self.apply_depth_test()
 
     @classmethod
     def __init_subclass__(cls, **kwargs):
@@ -2639,8 +2635,6 @@ def align_data_and_family(self, mobject):
         self.align_data(mobject)
 
     def align_data(self, mobject) -> None:
-        # In case any data arrays get resized when aligned to shader data
-        self.refresh_shader_data()
         for mob1, mob2 in zip(self.get_family(), mobject.get_family()):
             # Separate out how points are treated so that subclasses
             # can handle that case differently if they choose
@@ -2731,24 +2725,9 @@ def construct(self):
 
                     self.add(dotL, dotR, dotMiddle)
         """
-        for key in self.data:
-            if key in self.locked_data_keys:
-                continue
-            if len(self.data[key]) == 0:  # type: ignore
-                continue
-            if key not in mobject1.data or key not in mobject2.data:
-                continue
-
-            if key in ("points", "bounding_box"):
-                func = path_func
-            else:
-                func = interpolate
-
-            self.data[key][:] = func(mobject1.data[key], mobject2.data[key], alpha)  # type: ignore
-        for key in self.uniforms:
-            self.uniforms[key] = interpolate(  # type: ignore
-                mobject1.uniforms[key], mobject2.uniforms[key], alpha
-            )
+        # TODO: replace with list of attribute names with a locking system
+        self.points = path_func(mobject1.points, mobject2.points, alpha)
+        self.interpolate_color(mobject1, mobject2, alpha)
         return self
 
     def pointwise_become_partial(self, mobject, a, b):
@@ -2906,44 +2885,36 @@ def has_same_shape_as(self, mobject: OpenGLMobject) -> bool:
         return bool(np.isclose(points1, points2).all())
 
     # Operations touching shader uniforms
-
-    @affects_shader_info_id
     def fix_in_frame(self) -> Self:
         self.uniforms["is_fixed_in_frame"] = float(1.0)
         self.is_fixed_in_frame = True
         return self
 
-    @affects_shader_info_id
     def fix_orientation(self) -> Self:
         self.uniforms["is_fixed_orientation"] = float(1.0)
         self.is_fixed_orientation = True
         self.fixed_orientation_center = tuple(self.get_center())
         return self
 
-    @affects_shader_info_id
     def unfix_from_frame(self) -> Self:
         self.uniforms["is_fixed_in_frame"] = float(0.0)
         self.is_fixed_in_frame = False
         return self
 
-    @affects_shader_info_id
     def unfix_orientation(self):
         self.is_fixed_orientation = 0.0
         self.fixed_orientation_center = (0, 0, 0)
         return self
 
-    @affects_shader_info_id
     def apply_depth_test(self):
         self.depth_test = True
         return self
 
-    @affects_shader_info_id
     def deactivate_depth_test(self):
         self.depth_test = False
         return self
 
     # Shader code manipulation
-
     def replace_shader_code(self, old, new):
         # TODO, will this work with VMobject structure, given
         # that it does not simpler return shader_wrappers of
@@ -2988,47 +2959,6 @@ def set_color_by_xyz_func(
         )
         return self
 
-    # For shader data
-    def init_shader_data(self):
-        # TODO, only call this when needed?
-        self.shader_data = np.zeros(len(self.points), dtype=self.shader_dtype)
-        self.shader_indices = None
-        self.shader_wrapper = ShaderWrapper(
-            vert_data=self.shader_data,
-            shader_folder=self.shader_folder,
-            texture_paths=self.texture_paths,
-            depth_test=self.depth_test,
-            render_primitive=self.render_primitive,
-        )
-
-    def refresh_shader_wrapper_id(self):
-        self.shader_wrapper.refresh_id()
-        return self
-
-    def get_shader_wrapper(self):
-        self.shader_wrapper.vert_data = self.get_shader_data()
-        self.shader_wrapper.vert_indices = self.get_shader_vert_indices()
-        self.shader_wrapper.uniforms = self.get_shader_uniforms()
-        self.shader_wrapper.depth_test = self.depth_test
-        return self.shader_wrapper
-
-    def get_shader_wrapper_list(self):
-        shader_wrappers = it.chain(
-            [self.get_shader_wrapper()],
-            *(sm.get_shader_wrapper_list() for sm in self.submobjects),
-        )
-        batches = batch_by_property(shader_wrappers, lambda sw: sw.get_id())
-
-        result = []
-        for wrapper_group, _ in batches:
-            shader_wrapper = wrapper_group[0]
-            if not shader_wrapper.is_valid():
-                continue
-            shader_wrapper.combine_with(*wrapper_group[1:])
-            if len(shader_wrapper.vert_data) > 0:
-                result.append(shader_wrapper)
-        return result
-
     def check_data_alignment(self, array, data_key):
         # Makes sure that self.data[key] can be broadcast into
         # the given array, meaning its length has to be either 1
@@ -3041,33 +2971,6 @@ def check_data_alignment(self, array, data_key):
             )
         return self
 
-    def get_resized_shader_data_array(self, length: int) -> np.ndarray:
-        # If possible, try to populate an existing array, rather
-        # than recreating it each frame
-        if len(self.shader_data) != length:
-            self.shader_data = resize_array(self.shader_data, length)
-        return self.shader_data
-
-    def read_data_to_shader(self, shader_data, shader_data_key, data_key):
-        if data_key in self.locked_data_keys:
-            return
-        self.check_data_alignment(shader_data, data_key)
-        shader_data[shader_data_key] = self.data[data_key]
-
-    def get_shader_data(self):
-        shader_data = self.get_resized_shader_data_array(self.get_num_points())
-        self.read_data_to_shader(shader_data, "point", "points")
-        return shader_data
-
-    def refresh_shader_data(self):
-        self.get_shader_data()
-
-    def get_shader_uniforms(self):
-        return self.uniforms
-
-    def get_shader_vert_indices(self):
-        return self.shader_indices
-
     # Event Handlers
     """
         Event handling follows the Event Bubbling model of DOM in javascript.