Update examples to use rendercanvas (#714)

* update examples

* make cube reuseable

* fix screenshot testing

* fix unlimited fps

* update subprocess example

* update remaining examples

* ruff format

* add pause example

* cleanup

* add subprocess loop

* use DSL for title

* ruff format

* import canvas from main

* ruff format again

---------

Co-authored-by: Almar Klein <[email protected]>

Author: Vipitis

examples/cube.py

@@ -15,7 +15,7 @@
 import wgpu
 import numpy as np
 
-from wgpu.gui.auto import WgpuCanvas, run
+from rendercanvas.auto import RenderCanvas, loop
 
 
 # %% Entrypoints (sync and async)
@@ -459,17 +459,15 @@ async def draw_frame_async():
 for a in wgpu.gpu.enumerate_adapters_sync():
     print(a.summary)
 
-canvas = WgpuCanvas(size=(640, 480), title="wgpu cube example")
-
-draw_frame = setup_drawing_sync(canvas)
-
-
-def animate():
-    draw_frame()
-    canvas.request_draw()
-
-
-canvas.request_draw(animate)
 
 if __name__ == "__main__":
-    run()
+    canvas = RenderCanvas(
+        size=(640, 480),
+        title="wgpu cube example at $fps using $backend",
+        update_mode="continuous",
+        max_fps=60,
+        vsync=True,
+    )
+    draw_frame = setup_drawing_sync(canvas)
+    canvas.request_draw(draw_frame)
+    loop.run()

examples/gui_auto.py

@@ -4,14 +4,14 @@
 
 # test_example = true
 
-from wgpu.gui.auto import WgpuCanvas, run
+from rendercanvas.auto import RenderCanvas, loop
 
 try:
     from .triangle import setup_drawing_sync
 except ImportError:
     from triangle import setup_drawing_sync
 
-canvas = WgpuCanvas(title=f"Triangle example on {WgpuCanvas.__name__}")
+canvas = RenderCanvas(title="Triangle example on $backend")
 draw_frame = setup_drawing_sync(canvas)
 
 
@@ -22,4 +22,4 @@ def animate():
 
 
 if __name__ == "__main__":
-    run()
+    loop.run()

examples/gui_direct.py

@@ -14,13 +14,13 @@
 import glfw
 
 from wgpu.backends.wgpu_native import GPUCanvasContext
-from wgpu.gui.glfw import get_glfw_present_methods, poll_glfw_briefly
+from rendercanvas.glfw import get_glfw_present_methods, poll_glfw_briefly, enable_glfw
 
 # from triangle import setup_drawing_sync
 from cube import setup_drawing_sync
 
 # Setup glfw
-glfw.init()
+enable_glfw()
 atexit.register(glfw.terminate)
 
 

examples/gui_events.py

@@ -2,10 +2,10 @@
 A simple example to demonstrate events.
 """
 
-from wgpu.gui.auto import WgpuCanvas, run
+from rendercanvas.auto import RenderCanvas, loop
 
 
-canvas = WgpuCanvas(size=(640, 480), title="wgpu events")
+canvas = RenderCanvas(size=(640, 480), title="wgpu events")
 
 
 @canvas.add_event_handler("*")
@@ -15,4 +15,4 @@ def process_event(event):
 
 
 if __name__ == "__main__":
-    run()
+    loop.run()

examples/gui_glfw.py

@@ -1,16 +1,16 @@
 """
-Run triangle/cube example in the glfw GUI backend.
+Run triangle/cube example in the glfw rendercanvas backend.
 """
 
 # run_example = false
 
-from wgpu.gui.glfw import WgpuCanvas, run
+from rendercanvas.glfw import GlfwRenderCanvas, loop
 
-from triangle import setup_drawing_sync
-# from cube import setup_drawing_sync
+# from triangle import setup_drawing_sync
+from cube import setup_drawing_sync
 
 
-canvas = WgpuCanvas(title=f"Triangle example on {WgpuCanvas.__name__}")
+canvas = GlfwRenderCanvas(title=f"Triangle example on {GlfwRenderCanvas.__name__}")
 draw_frame = setup_drawing_sync(canvas)
 
 
@@ -21,4 +21,4 @@ def animate():
 
 
 if __name__ == "__main__":
-    run()
+    loop.run()

examples/gui_qt.py

@@ -11,18 +11,19 @@
 for lib in ("PySide6", "PyQt6", "PySide2", "PyQt5"):
     try:
         QtWidgets = importlib.import_module(".QtWidgets", lib)
+        print(f"Using {lib} for Qt GUI")
         break
     except ModuleNotFoundError:
         pass
 
 
-from wgpu.gui.qt import WgpuCanvas  # noqa: E402
+from rendercanvas.qt import RenderCanvas  # noqa: E402
 
 from triangle import setup_drawing_sync  # noqa: E402
 
 
 app = QtWidgets.QApplication([])
-canvas = WgpuCanvas(title=f"Triangle example on {WgpuCanvas.__name__}")
+canvas = RenderCanvas(title="Triangle example on $backend")
 
 draw_frame = setup_drawing_sync(canvas)
 

examples/gui_qt_asyncio.py

@@ -18,7 +18,7 @@
 import asyncio
 
 from PySide6 import QtWidgets, QtAsyncio
-from wgpu.gui.qt import WgpuWidget
+from rendercanvas.qt import QRenderWidget
 from triangle import setup_drawing_sync
 
 
@@ -49,7 +49,7 @@ def __init__(self):
         splitter = QtWidgets.QSplitter()
 
         self.button = QtWidgets.QPushButton("Hello world", self)
-        self.canvas = WgpuWidget(splitter)
+        self.canvas = QRenderWidget(splitter)
         self.output = QtWidgets.QTextEdit(splitter)
 
         # self.button.clicked.connect(self.whenButtonClicked)  # see above :(

examples/gui_qt_embed.py

@@ -10,7 +10,7 @@
 import time
 import importlib
 
-from triangle import setup_drawing_sync
+from cube import setup_drawing_sync
 
 # For the sake of making this example Just Work, we try multiple QT libs
 for lib in ("PySide6", "PyQt6", "PySide2", "PyQt5"):
@@ -20,33 +20,39 @@
     except ModuleNotFoundError:
         pass
 
-from wgpu.gui.qt import WgpuWidget  # noqa: E402
+from rendercanvas.qt import QRenderWidget  # noqa: E402
 
 
 class ExampleWidget(QtWidgets.QWidget):
     def __init__(self):
         super().__init__()
         self.resize(640, 480)
-        self.setWindowTitle("wgpu triangle embedded in a qt app")
+        self.setWindowTitle("wgpu cube embedded in a qt app")
 
         splitter = QtWidgets.QSplitter()
 
         self.button = QtWidgets.QPushButton("Hello world", self)
-        self.canvas = WgpuWidget(splitter)
+        self.button2 = QtWidgets.QPushButton("pause", self)
+        self.canvas = QRenderWidget(splitter, update_mode="continuous")
         self.output = QtWidgets.QTextEdit(splitter)
 
         self.button.clicked.connect(self.whenButtonClicked)
+        self.button2.clicked.connect(self.whenButton2Clicked)
 
         splitter.addWidget(self.canvas)
         splitter.addWidget(self.output)
         splitter.setSizes([400, 300])
 
+        button_layout = QtWidgets.QVBoxLayout()
+        button_layout.addWidget(self.button)
+        button_layout.addWidget(self.button2)
         layout = QtWidgets.QHBoxLayout()
-        layout.addWidget(self.button, 0)
+        layout.addLayout(button_layout)
         layout.addWidget(splitter, 1)
         self.setLayout(layout)
 
         self.show()
+        self._paused = False
 
     def addLine(self, line):
         t = self.output.toPlainText()
@@ -56,6 +62,19 @@ def addLine(self, line):
     def whenButtonClicked(self):
         self.addLine(f"Clicked at {time.time():0.1f}")
 
+    def whenButton2Clicked(self):
+        # showcases how rendercanvas allows changes to sheduling interactively
+        if self._paused:
+            self.canvas.set_update_mode("continuous", max_fps=60)
+            self.button2.setText("pause")
+            self._paused = False
+        else:
+            # note: the cube example bases rotation on unix time, which we don't pause with this button
+            # with "ondemand", resize events such as the window or the splitter will still trigger a draw!
+            self.canvas.set_update_mode("ondemand")
+            self.button2.setText("resume")
+            self._paused = True
+
 
 app = QtWidgets.QApplication([])
 example = ExampleWidget()

examples/gui_subprocess.py

@@ -16,72 +16,85 @@
 import time
 import subprocess
 
-from wgpu.gui import WgpuCanvasBase
+from rendercanvas.asyncio import loop
+from rendercanvas.base import BaseRenderCanvas, BaseCanvasGroup
 
 # Import the function that we must call to run the visualization
-from triangle import setup_drawing_sync
-# from cube import setup_drawing_sync
+# from triangle import setup_drawing_sync
+from cube import setup_drawing_sync
 
 
 code = """
 import sys
 import json
-from PySide6 import QtWidgets  # Use either PySide6 or PyQt6
-from wgpu.gui.qt import WgpuCanvas
+from PyQt6 import QtWidgets  # Use either PySide6 or PyQt6
+from rendercanvas.qt import RenderCanvas
 
 app = QtWidgets.QApplication([])
-canvas = WgpuCanvas(title="wgpu triangle in Qt subprocess")
+canvas = RenderCanvas(title="wgpu cube in Qt subprocess", update_mode="ondemand")
 
-print(json.dumps(canvas.get_present_methods()))
+print(json.dumps(canvas._subwidget._rc_get_present_methods()))
 print(canvas.get_physical_size())
 sys.stdout.flush()
 
-app.exec_()
+app.exec()
 """
 
 
-class ProxyCanvas(WgpuCanvasBase):
+class ProxyCanvasGroup(BaseCanvasGroup):
+    pass
+
+
+class ProxyCanvas(BaseRenderCanvas):
+    _rc_canvas_group = ProxyCanvasGroup(loop)
+
     def __init__(self):
         super().__init__()
         self._present_methods = json.loads(p.stdout.readline().decode())
+        print(self._present_methods)
         self._psize = tuple(
             int(x) for x in p.stdout.readline().decode().strip().strip("()").split(",")
         )
         print(self._psize)
         time.sleep(0.2)
 
-    def get_present_methods(self):
+    def _rc_get_present_methods(self):
         return self._present_methods
 
-    def get_physical_size(self):
+    def _rc_request_draw(self):
+        loop = self._rc_canvas_group.get_loop()
+        loop.call_soon(self._draw_frame_and_present)
+
+    def _rc_get_physical_size(self):
         return self._psize
 
-    def get_pixel_ratio(self):
+    def _rc_get_pixel_ratio(self):
         return 1
 
-    def get_logical_size(self):
+    def _rc_get_logical_size(self):
         return self._psize
 
-    def set_logical_size(self, width, height):
+    def _rc_set_logical_size(self, width, height):
         pass
 
-    def close(self):
+    def _rc_close(self):
         p.kill()
 
-    def is_closed(self):
-        raise NotImplementedError()
-
-    def _request_draw(self):
-        self.draw_frame()
+    def _rc_get_closed(self):
+        return_code = p.poll()
+        return return_code is not None
 
 
 # Create subprocess
 p = subprocess.Popen([sys.executable, "-c", code], stdout=subprocess.PIPE)
 
 # Create a canvas that maps to the window of that subprocess
 canvas = ProxyCanvas()
+canvas.set_update_mode("continuous")
 
-# Go!
+# Register our draw function
 draw_frame = setup_drawing_sync(canvas)
 canvas.request_draw(draw_frame)
-time.sleep(3)
+
+# Start the event loop
+loop.run()

examples/gui_wx.py

@@ -5,14 +5,14 @@
 # run_example = false
 
 import wx
-from wgpu.gui.wx import WgpuCanvas
+from rendercanvas.wx import RenderCanvas
 
 from triangle import setup_drawing_sync
 # from cube import setup_drawing_sync
 
 
 app = wx.App()
-canvas = WgpuCanvas(title=f"Triangle example on {WgpuCanvas.__name__}")
+canvas = RenderCanvas(title="Triangle example on $backend")
 
 draw_func = setup_drawing_sync(canvas)
 canvas.request_draw(draw_func)

examples/gui_wx_embed.py

@@ -5,21 +5,22 @@
 # run_example = false
 
 import wx
-from wgpu.gui.wx import WgpuWidget
+from rendercanvas.wx import WxRenderWidget
 
-from triangle import setup_drawing_sync
+from triangle import setup_drawing_sync as setup_drawing_sync_triangle
+from cube import setup_drawing_sync as setup_drawing_sync_cube
 
 
 class Example(wx.Frame):
     def __init__(self):
-        super().__init__(None, title="wgpu triangle embedded in a wx app")
+        super().__init__(None, title="wgpu triangle and cube embedded in a wx app")
         self.SetSize(640, 480)
 
         splitter = wx.SplitterWindow(self)
 
         self.button = wx.Button(self, -1, "Hello world")
-        self.canvas1 = WgpuWidget(splitter)
-        self.canvas2 = WgpuWidget(splitter)
+        self.canvas1 = WxRenderWidget(splitter)
+        self.canvas2 = WxRenderWidget(splitter, update_mode="continuous")
 
         splitter.SplitVertically(self.canvas1, self.canvas2)
         splitter.SetSashGravity(0.5)
@@ -35,8 +36,8 @@ def __init__(self):
 app = wx.App()
 example = Example()
 
-draw_frame1 = setup_drawing_sync(example.canvas1)
-draw_frame2 = setup_drawing_sync(example.canvas2)
+draw_frame1 = setup_drawing_sync_triangle(example.canvas1)
+draw_frame2 = setup_drawing_sync_cube(example.canvas2)
 
 example.canvas1.request_draw(draw_frame1)
 example.canvas2.request_draw(draw_frame2)