proper cleanup of textures

Author: mhochsteger

webgpu/camera.py

@@ -152,9 +152,11 @@ def get_shader_code(self):
     def __del__(self):
         del self.uniforms
 
-    def register_callbacks(self, input_handler, redraw_function, get_position_function=None):
+    def set_render_functions(self, redraw_function, get_position_function=None):
         self._render_function = redraw_function
         self._get_position_function = get_position_function
+
+    def register_callbacks(self, input_handler):
         input_handler.on_mousedown(self._on_mousedown)
         input_handler.on_mouseup(self._on_mouseup)
         input_handler.on_mouseout(self._on_mouseup)

webgpu/canvas.py

@@ -77,10 +77,12 @@ class Canvas:
 
     device: Device
     depth_format: TextureFormat
-    depth_texture: Texture
-    multisample_texture: Texture
-    multisample: MultisampleState
-    target_texture: Texture
+    depth_texture: Texture = None
+    multisample_texture: Texture = None
+    multisample: MultisampleState = None
+    target_texture: Texture = None
+    select_depth_texture: Texture = None
+    select_texture: Texture = None
 
     width: int = 0
     height: int = 0
@@ -142,6 +144,14 @@ def update_html_canvas(self, html_canvas):
                 self.context.unconfigure()
 
             self.canvas = html_canvas
+            self.destroy_textures()
+
+            if html_canvas is None:
+                self.context = None
+                for func in self._on_update_html_canvas:
+                    func(html_canvas)
+                return
+
             self.context = html_canvas.getContext("webgpu")
             self.context.configure(
                 {
@@ -207,10 +217,24 @@ def save_screenshot(self, filename: str):
             canvas.remove()
             path.write_bytes(b64decode(canvas.toDataURL(format).split(",")[1]))
 
+    def destroy_textures(self):
+        with self._update_mutex:
+            for tex in [
+                self.target_texture,
+                self.multisample_texture,
+                self.depth_texture,
+                self.select_texture,
+                self.select_depth_texture,
+            ]:
+                if tex is not None:
+                    tex.destroy()
+
     @debounce(5)
     def resize(self):
         with self._update_mutex:
             canvas = self.canvas
+            if canvas is None:
+                return
             rect = canvas.getBoundingClientRect()
             width = int(rect.width)
             height = int(rect.height)
@@ -229,6 +253,9 @@ def resize(self):
             canvas.height = height
 
             device = self.device
+
+            self.destroy_textures()
+
             self.target_texture = device.createTexture(
                 size=[width, height, 1],
                 sampleCount=1,

webgpu/input_handler.py

@@ -20,7 +20,8 @@ def set_canvas(self, html_canvas):
         if self.html_canvas:
             self.unregister_callbacks()
         self.html_canvas = html_canvas
-        self.register_callbacks()
+        if self.html_canvas:
+            self.register_callbacks()
 
     def __on_mousedown(self, _):
         self._is_mousedown = True

webgpu/scene.py

@@ -104,7 +104,8 @@ def init(self, canvas):
 
             camera = self.options.camera
             self._js_render = platform.create_proxy(self._render_direct)
-            camera.register_callbacks(self.input_handler, self.render, self.get_position)
+            camera.set_render_functions(self.render, self.get_position)
+            camera.register_callbacks(self.input_handler)
             # if is_pyodide:
             #     _scenes_by_id[self.id] = self
 
@@ -121,9 +122,11 @@ def init(self, canvas):
             canvas.on_update_html_canvas(self.__on_update_html_canvas)
 
     def __on_update_html_canvas(self, html_canvas):
-        self.input_handler.unregister_callbacks()
         self.input_handler.set_canvas(html_canvas)
-        self.options.camera.register_callbacks(self.input_handler, self.render, self.get_position)
+        if html_canvas is not None:
+            camera = self.options.camera
+            camera.set_render_functions(self.render, self.get_position)
+            camera.set_canvas(self.canvas)
 
     def get_position(self, x: int, y: int):
         objects = self.render_objects

webgpu/utils.py

@@ -10,6 +10,8 @@
 _device: Device = None
 
 _lock_init_device = threading.Lock()
+
+
 def init_device_sync():
     global _device
     with _lock_init_device: