@woosh/meep-engine 3.29.0 → 3.30.0

package/src/shade/renderer/texture/mipmaps/WebGPUMipmapGenerator.js

@@ -490,17 +490,35 @@ export class WebGPUMipmapGenerator {
      * @param {GPUTexture} texture - Texture to generate mipmaps for.
      * @param {GPUTextureDescriptor} texture_descriptor - GPUTextureDescriptor the texture was created with.
      * @param {TextureFilterType} [filter]
-     * @param {GPUCommandEncoder} [commandEncoder]
+     * @param {GPUCommandEncoder} [commandEncoder] when supplied, the commands are recorded rather
+     *   than submitted, so the scratch resources outlive this call and `release_after_submit` is
+     *   required
+     * @param {{destroy: function():void}[]} [release_after_submit] where the scratch buffer and
+     *   textures go when the encoder is the caller's; destroy them once it has submitted
      * @returns {GPUTexture} - The originally passed texture
      */
     generateMipmap(
         texture,
         texture_descriptor,
         filter = TextureFilterType.Linear,
-        commandEncoder
+        commandEncoder,
+        release_after_submit
     ) {
         assert.defined(texture, 'texture');
         assert.defined(texture_descriptor, 'texture descriptor');
+
+        /**
+         * An ordinary throw, not an assert: a caller that supplies its own encoder has to say where
+         * the scratch resources go, because we cannot destroy them — its commands reference them and
+         * it has not submitted yet. Getting this wrong loses the caller's whole command buffer with
+         * no error of any kind, so it is not a check that may be stripped.
+         */
+        if (commandEncoder !== undefined && !Array.isArray(release_after_submit)) {
+            throw new Error(
+                "generateMipmap with a caller-supplied commandEncoder needs a `release_after_submit` array: "
+                + "the scratch resources outlive this call and must be destroyed once the caller has submitted"
+            );
+        }
         assert.enum(filter, TextureFilterType, 'filter');
 
         const mip_level_count = texture.mipLevelCount;
@@ -848,22 +866,39 @@ export class WebGPUMipmapGenerator {
             }
         }
 
+        /**
+         * Nothing here has run yet when the encoder is the caller's: the commands are recorded, and
+         * the caller submits later. `finish()`/`submit()` validate that every resource a command
+         * buffer touches is still alive, so destroying these inline had the whole command buffer
+         * rejected — not just the mips, but every pass the caller recorded in the same context, and
+         * silently, because WebGPU validation errors do not throw. The branch that was written to be
+         * careful, and the only one, was the one that got it wrong.
+         *
+         * So: when we made the encoder we submit and release; when we did not, the temporaries go to
+         * the caller's release list, to be destroyed once it has submitted.
+         *
+         * @param {{destroy: function():void}} resource
+         */
+        const release = created_command_encoder
+            ? resource => resource.destroy()
+            : resource => release_after_submit.push(resource);
+
         if (created_command_encoder) {
             device.queue.submit([commandEncoder.finish()]);
         } else {
-            parameters_buffer.destroy();
+            release(parameters_buffer);
         }
 
         if (texture !== decoded_texture) {
-            decoded_texture.destroy();
+            release(decoded_texture);
         }
 
         if (texture !== mip_texture) {
-            mip_texture.destroy();
+            release(mip_texture);
         }
 
         if (need_separate_forward_target) {
-            forward_texture.destroy();
+            release(forward_texture);
         }
 
         return texture;