Cease useless rendering

Change so that with a live window, rendering only happens if there has been an event (mouse motion, key press, etc.) to respond to.

manimlib/window.py

@@ -6,6 +6,7 @@ import moderngl_window as mglw
 from moderngl_window.context.pyglet.window import Window as PygletWindow
 from moderngl_window.timers.clock import Timer
 from screeninfo import get_monitors
+from functools import wraps
 
 from manimlib.constants import FRAME_SHAPE
 from manimlib.utils.customization import get_customization
@@ -39,6 +40,8 @@ class Window(PygletWindow):
         self.title = str(scene)
         self.size = size
 
+        self._has_undrawn_event = True
+
         mglw.activate_context(window=self)
         self.timer = Timer()
         self.config = mglw.WindowConfig(ctx=self.ctx, wnd=self, timer=self.timer)
@@ -95,56 +98,82 @@ class Window(PygletWindow):
             coords[:2] -= 0.5 * fixed_frame_shape
         return frame.from_fixed_frame_point(coords, relative)
 
+    def has_undrawn_event(self) -> bool:
+        return self._has_undrawn_event
+
+    def swap_buffers(self):
+        super().swap_buffers()
+        self._has_undrawn_event = False
+
+    @staticmethod
+    def note_undrawn_event(func: Callable[..., T]) -> Callable[..., T]:
+        @wraps(func)
+        def wrapper(self, *args, **kwargs):
+            func(self, *args, **kwargs)
+            self._has_undrawn_event = True
+        return wrapper
+
+    @note_undrawn_event
     def on_mouse_motion(self, x: int, y: int, dx: int, dy: int) -> None:
         super().on_mouse_motion(x, y, dx, dy)
         point = self.pixel_coords_to_space_coords(x, y)
         d_point = self.pixel_coords_to_space_coords(dx, dy, relative=True)
         self.scene.on_mouse_motion(point, d_point)
 
+    @note_undrawn_event
     def on_mouse_drag(self, x: int, y: int, dx: int, dy: int, buttons: int, modifiers: int) -> None:
         super().on_mouse_drag(x, y, dx, dy, buttons, modifiers)
         point = self.pixel_coords_to_space_coords(x, y)
         d_point = self.pixel_coords_to_space_coords(dx, dy, relative=True)
         self.scene.on_mouse_drag(point, d_point, buttons, modifiers)
 
+    @note_undrawn_event
     def on_mouse_press(self, x: int, y: int, button: int, mods: int) -> None:
         super().on_mouse_press(x, y, button, mods)
         point = self.pixel_coords_to_space_coords(x, y)
         self.scene.on_mouse_press(point, button, mods)
 
+    @note_undrawn_event
     def on_mouse_release(self, x: int, y: int, button: int, mods: int) -> None:
         super().on_mouse_release(x, y, button, mods)
         point = self.pixel_coords_to_space_coords(x, y)
         self.scene.on_mouse_release(point, button, mods)
 
+    @note_undrawn_event
     def on_mouse_scroll(self, x: int, y: int, x_offset: float, y_offset: float) -> None:
         super().on_mouse_scroll(x, y, x_offset, y_offset)
         point = self.pixel_coords_to_space_coords(x, y)
         offset = self.pixel_coords_to_space_coords(x_offset, y_offset, relative=True)
         self.scene.on_mouse_scroll(point, offset, x_offset, y_offset)
 
+    @note_undrawn_event
     def on_key_press(self, symbol: int, modifiers: int) -> None:
         self.pressed_keys.add(symbol)  # Modifiers?
         super().on_key_press(symbol, modifiers)
         self.scene.on_key_press(symbol, modifiers)
 
+    @note_undrawn_event
     def on_key_release(self, symbol: int, modifiers: int) -> None:
         self.pressed_keys.difference_update({symbol})  # Modifiers?
         super().on_key_release(symbol, modifiers)
         self.scene.on_key_release(symbol, modifiers)
 
+    @note_undrawn_event
     def on_resize(self, width: int, height: int) -> None:
         super().on_resize(width, height)
         self.scene.on_resize(width, height)
 
+    @note_undrawn_event
     def on_show(self) -> None:
         super().on_show()
         self.scene.on_show()
 
+    @note_undrawn_event
     def on_hide(self) -> None:
         super().on_hide()
         self.scene.on_hide()
 
+    @note_undrawn_event
     def on_close(self) -> None:
         super().on_close()
         self.scene.on_close()