Refactor canvas context to allow presenting as image

docs/gui.rst

@@ -21,7 +21,6 @@ The Canvas base classes
  ~WgpuCanvasInterface
  ~WgpuCanvasBase
  ~WgpuAutoGui
- ~WgpuOffscreenCanvasBase
 
 
 For each supported GUI toolkit there is a module that implements a ``WgpuCanvas`` class,

examples/triangle_glfw_direct.py

@@ -14,7 +14,7 @@
 import glfw
 
 from wgpu.backends.wgpu_native import GPUCanvasContext
-from wgpu.gui.glfw import get_surface_info, get_physical_size
+from wgpu.gui.glfw import get_glfw_present_info, get_physical_size
 from wgpu.utils.device import get_default_device
 
 
@@ -29,9 +29,9 @@ class GlfwCanvas:
  def __init__(self, window):
  self._window = window
 
- def get_surface_info(self):
+ def get_present_info(self):
  """get window and display id, includes some triage to deal with OS differences"""
- return get_surface_info(self._window)
+ return get_glfw_present_info(self._window)
 
  def get_physical_size(self):
  """get framebuffer size in integer pixels"""

examples/triangle_subprocess.py

@@ -31,7 +31,7 @@
 app = QtWidgets.QApplication([])
 canvas = WgpuCanvas(title="wgpu triangle in Qt subprocess")
 
-print(json.dumps(canvas.get_surface_info()))
+print(json.dumps(canvas.get_present_info()))
 print(canvas.get_physical_size())
 sys.stdout.flush()
 
@@ -42,15 +42,15 @@
 class ProxyCanvas(WgpuCanvasBase):
  def __init__(self):
  super().__init__()
- self._surface_info = json.loads(p.stdout.readline().decode())
+ self._present_info = json.loads(p.stdout.readline().decode())
  self._psize = tuple(
  int(x) for x in p.stdout.readline().decode().strip().strip("()").split(",")
  )
  print(self._psize)
  time.sleep(0.2)
 
- def get_surface_info(self):
- return self._surface_info
+ def get_present_info(self):
+ return self._present_info
 
  def get_physical_size(self):
  return self._psize

tests/test_gui_base.py

@@ -9,7 +9,7 @@
 import numpy as np
 import wgpu.gui # noqa
 from testutils import run_tests, can_use_wgpu_lib, is_pypy
-from pytest import mark
+from pytest import mark, raises
 
 
 class TheTestCanvas(wgpu.gui.WgpuCanvasBase):
@@ -37,10 +37,10 @@ def spam_method(self):
 def test_base_canvas_context():
  assert not issubclass(wgpu.gui.WgpuCanvasInterface, wgpu.GPUCanvasContext)
  assert hasattr(wgpu.gui.WgpuCanvasInterface, "get_context")
- # Provides good default already
  canvas = wgpu.gui.WgpuCanvasInterface()
- ctx = wgpu.GPUCanvasContext(canvas)
- assert ctx.get_preferred_format(None) == "bgra8unorm-srgb"
+ # Cannot instantiate, because get_present_info is not implemented
+ with raises(NotImplementedError):
+ wgpu.GPUCanvasContext(canvas)
 
 
 def test_canvas_logging(caplog):
@@ -80,12 +80,22 @@ def test_canvas_logging(caplog):
  assert text.count("division by zero") == 4
 
 
-class MyOffscreenCanvas(wgpu.gui.WgpuOffscreenCanvasBase):
+class MyOffscreenCanvas(wgpu.gui.WgpuCanvasBase):
  def __init__(self):
  super().__init__()
- self.textures = []
+ self.frame_count = 0
  self.physical_size = 100, 100
 
+ def get_present_info(self):
+ return {
+ "method": "image",
+ "formats": ["rgba8unorm-srgb"],
+ }
+
+ def present_image(self, image, **kwargs):
+ self.frame_count += 1
+ self.array = np.frombuffer(image, np.uint8).reshape(image.shape)
+
  def get_pixel_ratio(self):
  return 1
 
@@ -99,26 +109,6 @@ def _request_draw(self):
  # Note: this would normally schedule a call in a later event loop iteration
  self._draw_frame_and_present()
 
- def present(self, texture):
- self.textures.append(texture)
- device = texture._device
- size = texture.size
- bytes_per_pixel = 4
- data = device.queue.read_texture(
- {
- "texture": texture,
- "mip_level": 0,
- "origin": (0, 0, 0),
- },
- {
- "offset": 0,
- "bytes_per_row": bytes_per_pixel * size[0],
- "rows_per_image": size[1],
- },
- size,
- )
- self.array = np.frombuffer(data, np.uint8).reshape(size[1], size[0], 4)
-
 
 @mark.skipif(not can_use_wgpu_lib, reason="Needs wgpu lib")
 def test_run_bare_canvas():
@@ -181,7 +171,7 @@ def draw_frame():
  render_pass.end()
  device.queue.submit([command_encoder.finish()])
 
- assert len(canvas.textures) == 0
+ assert canvas.frame_count == 0
 
  # Draw 1
  canvas.request_draw(draw_frame)
@@ -214,8 +204,7 @@ def draw_frame():
  assert np.all(canvas.array[:, :, 1] == 255)
 
  # We now have four unique texture objects
- assert len(canvas.textures) == 4
- assert len(set(canvas.textures)) == 4
+ assert canvas.frame_count == 4
 
 
 def test_autogui_mixin():

tests/test_gui_glfw.py

@@ -171,7 +171,7 @@ def __init__(self):
  self.window = glfw.create_window(300, 200, "canvas", None, None)
  self._present_context = None
 
- def get_surface_info(self):
+ def get_present_info(self):
  if sys.platform.startswith("win"):
  return {
  "platform": "windows",

tests_mem/test_gui.py

@@ -23,7 +23,7 @@ def make_draw_func_for_canvas(canvas):
  so that we can really present something to a canvas being tested.
  """
  ctx = canvas.get_context()
- ctx.configure(device=DEVICE, format="bgra8unorm-srgb")
+ ctx.configure(device=DEVICE, format=None)
 
  def draw():
  ctx = canvas.get_context()

tests_mem/test_gui_qt.py

@@ -36,7 +36,9 @@ def test_release_canvas_context(n):
  if app is None:
  app = PySide6.QtWidgets.QApplication([""])
 
- yield {}
+ yield {
+ "ignore": {"CommandBuffer"},
+ }
 
  canvases = weakref.WeakSet()