Working window rendering with events

example_scenes/test_new.py

@@ -1,8 +1,10 @@
 import time
 
 from PIL import Image
+import pyglet
 from pyglet.gl import Config
 from pyglet.window import Window
+from pyglet import shapes
 
 import manim.utils.color.manim_colors as col
 from manim._config import tempconfig
@@ -14,10 +16,12 @@ from manim.mobject.logo import ManimBanner
 from manim.mobject.opengl.opengl_vectorized_mobject import OpenGLVMobject
 from manim.renderer.opengl_renderer import OpenGLRenderer
 
+
 if __name__ == "__main__":
     with tempconfig({"renderer": "opengl"}):
         win = Window(width=1920, height=1080)
         renderer = OpenGLRenderer(1920, 1080)
+        renderer.use_window_fbo()
         # vm = OpenGLVMobject([col.RED, col.GREEN])
         vm = Circle(
             radius=1, stroke_color=col.YELLOW, fill_opacity=1, fill_color=col.RED
@@ -30,13 +34,42 @@ if __name__ == "__main__":
         # print(vm.stroke_color)
 
         camera = OpenGLCameraFrame()
-        renderer.set_camera(camera)
+        renderer.init_camera(camera)
 
-        image = renderer.render(camera, [vm, vm2])
+        # image = renderer.render(camera, [vm, vm2])
         # print(image.shape)
         # Image.fromarray(image,"RGBA").show()
-        for _ in range(4):
+
+        label = pyglet.text.Label('Hello, world',
+                      font_name='Times New Roman',
+                      font_size=36,
+                      x=0, y=0,
+                      anchor_x='center', anchor_y='center')
+
+        @win.event
+        def on_close():
+            win.close()
+            pass
+
+        @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))
+            vm.set_color(col.RED.interpolate(col.GREEN,x/1920))
+            # print(x,y)
+
+        @win.event
+        def on_draw():
             image = renderer.render(camera, [vm, vm2])
+            pass
+
+        @win.event
+        def on_resize(width,height):
+            pass
+
+        while True:
+            pyglet.clock.tick()
+            pyglet.app.platform_event_loop.step()
+            win.switch_to()
+            win.dispatch_event('on_draw')
             win.dispatch_events()
             win.flip()
-            time.sleep(1)

manim/renderer/opengl_renderer.py

@@ -228,11 +228,11 @@ class OpenGLRenderer(Renderer):
             self.ctx, "quadratic_bezier_stroke"
         )
 
-    def substitute_fbo(self):
+    def use_window_fbo(self):
         self.output_fbo.release()
         self.output_fbo = self.ctx.detect_framebuffer()
 
-    def set_camera(self, camera: OpenGLCameraFrame) -> ImageType:
+    def init_camera(self, camera: OpenGLCameraFrame) -> ImageType:
         self.vmobject_fill_program["is_fixed_in_frame"] = 0.0
         self.vmobject_fill_program["frame_shape"] = camera.frame_shape
         self.vmobject_fill_program["focal_distance"] = float(
@@ -286,17 +286,13 @@ class OpenGLRenderer(Renderer):
         fill_data["vert_index"] = np.reshape(range(len(mob.points)), (-1, 1))
         return fill_data
 
-    def render(self, camera, renderables: list[OpenGLVMobject]) -> ImageType:
-        self.set_camera(camera=camera)
+    def pre_render(self, camera):
+        self.init_camera(camera=camera)
         self.target_fbo.use()
         self.target_fbo.clear(*self.background_color)
 
-        super().render(camera, renderables)
-
+    def post_render(self):
         self.ctx.copy_framebuffer(self.output_fbo, self.target_fbo)
-        # from PIL import Image
-        # Image.frombytes('RGB', self.output_fbo.size, self.output_fbo.read(), 'raw', 'RGB', 0, -1).show()
-        return self.get_pixels()
 
     def render_vmobject(self, mob: OpenGLVMobject) -> None:
         # Setting camera uniforms
@@ -322,7 +318,7 @@ class OpenGLRenderer(Renderer):
                 [mob.get_unit_normal()], points_length, axis=0
             )
             mob.renderer_data.bounding_box = compute_bounding_box(mob)
-            print(mob.renderer_data)
+            # print(mob.renderer_data)
 
         # if mob.colors_changed:
         #     mob.renderer_data.fill_rgbas = np.resize(mob.fill_color, (len(mob.renderer_data.mesh),4))

manim/renderer/renderer.py

@@ -25,6 +25,7 @@ class Renderer(ABC):
         ]
 
     def render(self, camera, renderables: list[OpenGLVMobject]) -> ImageType:  # Image
+        self.pre_render(camera)
         for mob in renderables:
             for type, render_func in self.capabilities:
                 if isinstance(mob, type):
@@ -34,9 +35,15 @@ class Renderer(ABC):
                 logger.warn(
                     f"The type{type(mob)} is not supported in Renderer: {self.__class__}"
                 )
-
+        self.post_render()
         return self.get_pixels()
 
+    def pre_render(self, camera):
+        raise NotImplementedError
+
+    def post_render(self):
+        raise NotImplementedError
+
     @abstractclassmethod
     def render_vmobject(self, mob: OpenGLVMobject) -> None:
         raise NotImplementedError