fastplotlib · clewis7 · Jan 6, 2025 · Dec 25, 2024 · Dec 25, 2024 · Dec 25, 2024
@@ -17,7 +17,7 @@ jobs:
   test-build-full:
     name: Test Linux, notebook + offscreen
     runs-on: ubuntu-latest
-    timeout-minutes: 10
+    timeout-minutes: 30
     if: ${{ !github.event.pull_request.draft }}
     strategy:
       fail-fast: false
@@ -40,7 +40,7 @@ jobs:
     - name: Install llvmpipe and lavapipe for offscreen canvas
       run: |
         sudo apt-get update -y -qq
-        sudo apt-get install --no-install-recommends -y ffmpeg libegl1-mesa-dev libgl1-mesa-dri libxcb-xfixes0-dev mesa-vulkan-drivers
+        sudo apt-get install --no-install-recommends -y ffmpeg libegl1-mesa-dev libgl1-mesa-dri libxcb-xfixes0-dev mesa-vulkan-drivers xorg-dev
     - name: Install dev dependencies
       run: |
         python -m pip install --upgrade pip setuptools
@@ -73,7 +73,7 @@ jobs:
   test-build-offscreen:
     name: Test Linux, only offscreen
     runs-on: ubuntu-latest
-    timeout-minutes: 10
+    timeout-minutes: 30
     if: ${{ !github.event.pull_request.draft }}
     strategy:
       fail-fast: false
@@ -96,7 +96,7 @@ jobs:
     - name: Install llvmpipe and lavapipe for offscreen canvas
       run: |
         sudo apt-get update -y -qq
-        sudo apt-get install --no-install-recommends -y libegl1-mesa-dev libgl1-mesa-dri libxcb-xfixes0-dev mesa-vulkan-drivers
+        sudo apt-get install --no-install-recommends -y libegl1-mesa-dev libgl1-mesa-dri libxcb-xfixes0-dev mesa-vulkan-drivers xorg-dev
     - name: Install dev dependencies
       run: |
         python -m pip install --upgrade pip setuptools

@@ -18,7 +18,7 @@
 import imageio.v3 as iio
 
 MAX_TEXTURE_SIZE = 2048
-pygfx.renderers.wgpu.set_wgpu_limits(**{"max-texture-dimension2d": MAX_TEXTURE_SIZE})
+pygfx.renderers.wgpu.set_wgpu_limits(**{"max-texture-dimension-2d": MAX_TEXTURE_SIZE})
 
 ROOT_DIR = Path(__file__).parents[1].parents[0]  # repo root
 EXAMPLES_DIR = Path.joinpath(ROOT_DIR, "examples")

@@ -235,38 +235,38 @@ Example output::
 
                                                       adapter  device
 
-                                    max_bind_groups:        8       8
-                max_bind_groups_plus_vertex_buffers:        0       0
-                        max_bindings_per_bind_group:    1.00K   1.00K
-                                    max_buffer_size:    2.14G   2.14G
-              max_color_attachment_bytes_per_sample:        0       0
-                              max_color_attachments:        0       0
-              max_compute_invocations_per_workgroup:    1.02K   1.02K
-                       max_compute_workgroup_size_x:    1.02K   1.02K
-                       max_compute_workgroup_size_y:    1.02K   1.02K
-                       max_compute_workgroup_size_z:    1.02K   1.02K
-                 max_compute_workgroup_storage_size:    32.7K   32.7K
-               max_compute_workgroups_per_dimension:    65.5K   65.5K
-    max_dynamic_storage_buffers_per_pipeline_layout:        8       8
-    max_dynamic_uniform_buffers_per_pipeline_layout:       16      16
-                  max_inter_stage_shader_components:      128     128
-                   max_inter_stage_shader_variables:        0       0
-              max_sampled_textures_per_shader_stage:    8.38M   8.38M
-                      max_samplers_per_shader_stage:    8.38M   8.38M
-                    max_storage_buffer_binding_size:    2.14G   2.14G
-               max_storage_buffers_per_shader_stage:    8.38M   8.38M
-              max_storage_textures_per_shader_stage:    8.38M   8.38M
-                           max_texture_array_layers:    2.04K   2.04K
-                            max_texture_dimension1d:    16.3K   16.3K
-                            max_texture_dimension2d:    16.3K   16.3K
-                            max_texture_dimension3d:    2.04K   2.04K
-                    max_uniform_buffer_binding_size:    2.14G   2.14G
-               max_uniform_buffers_per_shader_stage:    8.38M   8.38M
-                              max_vertex_attributes:       32      32
-                     max_vertex_buffer_array_stride:    2.04K   2.04K
-                                 max_vertex_buffers:       16      16
-                min_storage_buffer_offset_alignment:       32      32
-                min_uniform_buffer_offset_alignment:       32      32
+                                    max-bind-groups:        8       8
+                max-bind-groups-plus-vertex-buffers:        0       0
+                        max-bindings-per-bind-group:    1.00K   1.00K
+                                    max-buffer-size:    2.14G   2.14G
+              max-color-attachment-bytes-per-sample:        0       0
+                              max-color-attachments:        0       0
+              max-compute-invocations-per-workgroup:    1.02K   1.02K
+                       max-compute-workgroup-size-x:    1.02K   1.02K
+                       max-compute-workgroup-size-y:    1.02K   1.02K
+                       max-compute-workgroup-size-z:    1.02K   1.02K
+                 max-compute-workgroup-storage-size:    32.7K   32.7K
+               max-compute-workgroups-per-dimension:    65.5K   65.5K
+    max-dynamic-storage-buffers-per-pipeline-layout:        8       8
+    max-dynamic-uniform-buffers-per-pipeline-layout:       16      16
+                  max-inter-stage-shader-components:      128     128
+                   max-inter-stage-shader-variables:        0       0
+              max-sampled-textures-per-shader-stage:    8.38M   8.38M
+                      max-samplers-per-shader-stage:    8.38M   8.38M
+                    max-storage-buffer-binding-size:    2.14G   2.14G
+               max-storage-buffers-per-shader-stage:    8.38M   8.38M
+              max-storage-textures-per-shader-stage:    8.38M   8.38M
+                           max-texture-array-layers:    2.04K   2.04K
+                           max-texture-dimension-1d:    16.3K   16.3K
+                           max-texture-dimension-2d:    16.3K   16.3K
+                           max-texture-dimension-3d:    2.04K   2.04K
+                    max-uniform-buffer-binding-size:    2.14G   2.14G
+               max-uniform-buffers-per-shader-stage:    8.38M   8.38M
+                              max-vertex-attributes:       32      32
+                     max-vertex-buffer-array-stride:    2.04K   2.04K
+                                 max-vertex-buffers:       16      16
+                min-storage-buffer-offset-alignment:       32      32
+                min-uniform-buffer-offset-alignment:       32      32
 
     ██ pygfx_caches:
 

@@ -12,7 +12,7 @@
 import pygfx
 
 MAX_TEXTURE_SIZE = 2048
-pygfx.renderers.wgpu.set_wgpu_limits(**{"max-texture-dimension2d": MAX_TEXTURE_SIZE})
+pygfx.renderers.wgpu.set_wgpu_limits(**{"max-texture-dimension-2d": MAX_TEXTURE_SIZE})
 
 from .testutils import (
     ROOT,

@@ -1,7 +1,7 @@
 from pathlib import Path
 
 # this must be the first import for auto-canvas detection
-from .utils import run  # noqa
+from .utils import loop  # noqa
 from .graphics import *
 from .graphics.selectors import *
 from .graphics.utils import pause_events

@@ -21,7 +21,7 @@ def __init__(self, data, isolated_buffer: bool = True):
         data = self._fix_data(data)
 
         shared = pygfx.renderers.wgpu.get_shared()
-        self._texture_limit_2d = shared.device.limits["max-texture-dimension2d"]
+        self._texture_limit_2d = shared.device.limits["max-texture-dimension-2d"]
 
         if isolated_buffer:
             # useful if data is read-only, example: memmaps
@@ -202,8 +202,8 @@ def value(self) -> str:
 
     def set_value(self, graphic, value: str):
         new_colors = make_colors(256, value)
-        graphic._material.map.data[:] = new_colors
-        graphic._material.map.update_range((0, 0, 0), size=(256, 1, 1))
+        graphic._material.map.texture.data[:] = new_colors
+        graphic._material.map.texture.update_range((0, 0, 0), size=(256, 1, 1))
 
         self._value = value
         event = FeatureEvent(type="cmap", info={"value": value})
@@ -258,7 +258,8 @@ def set_value(self, graphic, value: str):
         self._validate(value)
 
         # common material for all image tiles
-        graphic._material.map_interpolation = value
+        graphic._material.map.min_filter = value
+        graphic._material.map.mag_filter = value
 
         self._value = value
         event = FeatureEvent(type="cmap_interpolation", info={"value": value})

@@ -132,27 +132,28 @@ def __init__(
         self._vmin = ImageVmin(vmin)
         self._vmax = ImageVmax(vmax)
 
-        # set cmap to None for RGB images
+        self._interpolation = ImageInterpolation(interpolation)
+
+        # set map to None for RGB images
         if self._data.value.ndim > 2:
             self._cmap = None
+            _map = None
         else:
+            # use TextureMap for grayscale images
             self._cmap = ImageCmap(cmap)
+            self._cmap_interpolation = ImageCmapInterpolation(cmap_interpolation)
 
-        self._interpolation = ImageInterpolation(interpolation)
-        self._cmap_interpolation = ImageCmapInterpolation(cmap_interpolation)
-
-        # use cmap if not RGB
-        if self._data.value.ndim == 2:
-            _map = self._cmap.texture
-        else:
-            _map = None
+            _map = pygfx.TextureMap(
+                self._cmap.texture,
+                filter=self._cmap_interpolation.value,
+                wrap="clamp-to-edge",
+            )
 
         # one common material is used for every Texture chunk
         self._material = pygfx.ImageBasicMaterial(
             clim=(vmin, vmax),
             map=_map,
             interpolation=self._interpolation.value,
-            map_interpolation=self._cmap_interpolation.value,
             pick_write=True,
         )
 

@@ -11,7 +11,7 @@
 
 import pygfx
 
-from wgpu.gui import WgpuCanvasBase
+from rendercanvas import BaseRenderCanvas
 
 from ._video_writer import VideoWriterAV
 from ._utils import make_canvas_and_renderer, create_controller, create_camera
@@ -41,7 +41,7 @@ def __init__(
             | Iterable[Iterable[str]]
         ) = None,
         controllers: pygfx.Controller | Iterable[Iterable[pygfx.Controller]] = None,
-        canvas: str | WgpuCanvasBase | pygfx.Texture = None,
+        canvas: str | BaseRenderCanvas | pygfx.Texture = None,
         renderer: pygfx.WgpuRenderer = None,
         size: tuple[int, int] = (500, 300),
         names: list | np.ndarray = None,
@@ -84,8 +84,8 @@ def __init__(
             plot/subplot. Other controller kwargs, i.e. ``controller_types`` and ``controller_ids`` are ignored if
             ``controllers`` are provided.
 
-        canvas: WgpuCanvas, optional
-            Canvas for drawing
+        canvas: str, BaseRenderCanvas, pygfx.Texture
+            Canvas to draw the figure onto, usually auto-selected based on running environment.
 
         renderer: pygfx.Renderer, optional
             pygfx renderer instance
@@ -334,13 +334,13 @@ def shape(self) -> tuple[int, int]:
         return self._shape
 
     @property
-    def canvas(self) -> WgpuCanvasBase:
-        """The canvas associated to this Figure"""
+    def canvas(self) -> BaseRenderCanvas:
+        """The canvas this Figure is drawn onto"""
         return self._canvas
 
     @property
     def renderer(self) -> pygfx.WgpuRenderer:
-        """The renderer associated to this Figure"""
+        """The renderer that renders this Figure"""
         return self._renderer
 
     @property
@@ -422,7 +422,7 @@ def show(
 
         Returns
         -------
-        WgpuCanvasBase
+        BaseRenderCanvas
             In Qt or GLFW, the canvas window containing the Figure will be shown.
             In jupyter, it will display the plot in the output cell or sidecar.
         """
@@ -452,7 +452,7 @@ def show(
                 subplot.auto_scale(maintain_aspect=maintain_aspect)
 
         # parse based on canvas type
-        if self.canvas.__class__.__name__ == "JupyterWgpuCanvas":
+        if self.canvas.__class__.__name__ == "JupyterRenderCanvas":
             if sidecar:
                 from sidecar import Sidecar
                 from IPython.display import display
@@ -464,12 +464,12 @@ def show(
             self._output = self.canvas
             return self._output
 
-        elif self.canvas.__class__.__name__ == "QWgpuCanvas":
+        elif self.canvas.__class__.__name__ == "QRenderCanvas":
             self._output = self.canvas
             self._output.show()
             return self.canvas
 
-        elif self.canvas.__class__.__name__ == "WgpuManualOffscreenCanvas":
+        elif self.canvas.__class__.__name__ == "OffscreenRenderCanvas":
             # for test and docs gallery screenshots
             for subplot in self:
                 subplot.set_viewport_rect()
@@ -494,18 +494,6 @@ def close(self):
         if self._sidecar:
             self._sidecar.close()
 
-    def get_pygfx_render_area(self, *args) -> tuple[int, int, int, int]:
-        """
-        Get rect for the portion of the canvas that the pygfx renderer draws to
-
-        Returns
-        -------
-        tuple[int, int, int, int]
-            x_pos, y_pos, width, height
-
-        """
-        return 0, 0, *self.canvas.get_logical_size()
-
     def _call_animate_functions(self, funcs: list[callable]):
         for fn in funcs:
             try:

@@ -7,7 +7,7 @@
 from imgui_bundle import imgui, icons_fontawesome_6 as fa
 
 from wgpu.utils.imgui import ImguiRenderer
-from wgpu.gui import WgpuCanvasBase
+from rendercanvas import BaseRenderCanvas
 
 import pygfx
 
@@ -38,7 +38,7 @@ def __init__(
             | Iterable[Iterable[str]]
         ) = None,
         controllers: pygfx.Controller | Iterable[Iterable[pygfx.Controller]] = None,
-        canvas: str | WgpuCanvasBase | pygfx.Texture = None,
+        canvas: str | BaseRenderCanvas | pygfx.Texture = None,
         renderer: pygfx.WgpuRenderer = None,
         size: tuple[int, int] = (500, 300),
         names: list | np.ndarray = None,
@@ -198,7 +198,7 @@ def get_pygfx_render_area(self, *args) -> tuple[int, int, int, int]:
         else:
             ypos = 0
 
-        return xpos, ypos, width, height
+        return xpos, ypos, max(1, width), max(1, height)
 
     def _reset_viewports(self):
         # TODO: think about moving this to Figure later,

@@ -6,7 +6,7 @@
 
 import pygfx
 from pylinalg import vec_transform, vec_unproject
-from wgpu.gui import WgpuCanvasBase
+from rendercanvas import BaseRenderCanvas
 
 from ._utils import create_controller
 from ..graphics._base import Graphic
@@ -32,9 +32,8 @@ def __init__(
         camera: pygfx.PerspectiveCamera,
         controller: pygfx.Controller,
         scene: pygfx.Scene,
-        canvas: WgpuCanvasBase,
+        canvas: BaseRenderCanvas,
         renderer: pygfx.WgpuRenderer,
-        extra_renderers: dict = None,
         name: str = None,
     ):
         """
@@ -59,7 +58,7 @@ def __init__(
         scene: pygfx.Scene
             represents the root of a scene graph, will be viewed by the given ``camera``
 
-        canvas: WgpuCanvas
+        canvas: BaseRenderCanvas
             provides surface on which a scene will be rendered
 
         renderer: pygfx.WgpuRenderer
@@ -153,7 +152,7 @@ def scene(self) -> pygfx.Scene:
         return self._scene
 
     @property
-    def canvas(self) -> WgpuCanvasBase:
+    def canvas(self) -> BaseRenderCanvas:
         """Canvas associated to the plot area"""
         return self._canvas