render: Support rendering filters in BitmapData.draw

core/src/bitmap/operations.rs

@@ -1526,7 +1526,13 @@ pub fn draw<'gc>(
         library: context.library,
         transform_stack: &mut transform_stack,
         is_offscreen: true,
-        use_bitmap_cache: false,
+
+        // Use CAB only when drawing with the same quality, because this draw
+        // will update caches. When drawing with a different quality, we would
+        // either (1) update caches for regular draws with this temporary
+        // quality, or (2) draw cached bitmaps with the regular quality.
+        // TODO Support CAB draw with different quality and remove this param.
+        use_bitmap_cache: context.stage.quality() == quality,
         stage: context.stage,
     };
 
@@ -1597,13 +1603,10 @@ pub fn draw<'gc>(
         dirty_region.union(old);
     }
 
-    assert!(
-        cache_draws.is_empty(),
-        "BitmapData.draw() should not use cacheAsBitmap"
-    );
-    let image = context
-        .renderer
-        .render_offscreen(handle, commands, quality, dirty_region);
+    let image =
+        context
+            .renderer
+            .render_offscreen(handle, commands, quality, dirty_region, cache_draws);
 
     match image {
         Some(sync_handle) => {

render/canvas/src/lib.rs

@@ -511,6 +511,7 @@ impl RenderBackend for WebCanvasRenderBackend {
         _commands: CommandList,
         _quality: StageQuality,
         _bounds: PixelRegion,
+        _cache_entries: Vec<BitmapCacheEntry>,
     ) -> Option<Box<dyn SyncHandle>> {
         None
     }

render/src/backend.rs

@@ -41,6 +41,7 @@ pub trait RenderBackend: Any {
         commands: CommandList,
         quality: StageQuality,
         bounds: PixelRegion,
+        cache_entries: Vec<BitmapCacheEntry>,
     ) -> Option<Box<dyn SyncHandle>>;
 
     /// Applies the given filter with a `BitmapHandle` source onto a destination `BitmapHandle`.

render/src/backend/null.rs

@@ -68,6 +68,7 @@ impl RenderBackend for NullRenderer {
         _commands: CommandList,
         _quality: StageQuality,
         _bounds: PixelRegion,
+        _cache_entries: Vec<BitmapCacheEntry>,
     ) -> Option<Box<dyn SyncHandle>> {
         None
     }

render/webgl/src/lib.rs

@@ -997,6 +997,7 @@ impl RenderBackend for WebGlRenderBackend {
         _commands: CommandList,
         _quality: StageQuality,
         _bounds: PixelRegion,
+        _cache_entries: Vec<BitmapCacheEntry>,
     ) -> Option<Box<dyn SyncHandle>> {
         None
     }

render/wgpu/src/backend.rs

@@ -368,6 +368,85 @@ impl<T: RenderTarget> WgpuRenderBackend<T> {
             }) => unreachable!("Buffer must be Borrowed as it was set to be Borrowed earlier"),
         }
     }
+
+    fn draw_cache(&mut self, cache_entries: Vec<BitmapCacheEntry>) {
+        for entry in cache_entries {
+            let texture = as_texture(&entry.handle);
+            let mut surface = Surface::new(
+                &self.descriptors,
+                self.surface.quality(),
+                texture.texture.width(),
+                texture.texture.height(),
+                wgpu::TextureFormat::Rgba8Unorm,
+            );
+            if entry.filters.is_empty() {
+                surface.draw_commands(
+                    RenderTargetMode::ExistingWithColor(
+                        texture.texture.clone(),
+                        wgpu::Color {
+                            r: f64::from(entry.clear.r) / 255.0,
+                            g: f64::from(entry.clear.g) / 255.0,
+                            b: f64::from(entry.clear.b) / 255.0,
+                            a: f64::from(entry.clear.a) / 255.0,
+                        },
+                    ),
+                    &self.descriptors,
+                    &self.meshes,
+                    entry.commands,
+                    &mut self.active_frame.staging_belt,
+                    &self.dynamic_transforms,
+                    &mut self.active_frame.command_encoder,
+                    LayerRef::None,
+                    &mut self.offscreen_texture_pool,
+                );
+            } else {
+                // We're relying on there being no impotent filters here,
+                // so that we can safely start by using the actual CAB texture.
+                // It's guaranteed that at least one filter would have used it and moved the target to something else,
+                // letting us safely copy back to it later.
+                let mut target = surface.draw_commands(
+                    RenderTargetMode::ExistingWithColor(
+                        texture.texture.clone(),
+                        wgpu::Color {
+                            r: f64::from(entry.clear.r) / 255.0,
+                            g: f64::from(entry.clear.g) / 255.0,
+                            b: f64::from(entry.clear.b) / 255.0,
+                            a: f64::from(entry.clear.a) / 255.0,
+                        },
+                    ),
+                    &self.descriptors,
+                    &self.meshes,
+                    entry.commands,
+                    &mut self.active_frame.staging_belt,
+                    &self.dynamic_transforms,
+                    &mut self.active_frame.command_encoder,
+                    LayerRef::None,
+                    &mut self.offscreen_texture_pool,
+                );
+                for filter in entry.filters {
+                    target = self.descriptors.filters.apply(
+                        &self.descriptors,
+                        &mut self.active_frame.command_encoder,
+                        &mut self.offscreen_texture_pool,
+                        &mut self.active_frame.staging_belt,
+                        FilterSource::for_entire_texture(target.color_texture()),
+                        filter,
+                    );
+                }
+                run_copy_pipeline(
+                    &self.descriptors,
+                    target.color_texture().format(),
+                    texture.texture.format(),
+                    &texture.texture.create_view(&Default::default()),
+                    target.color_view(),
+                    target.whole_frame_bind_group(&self.descriptors),
+                    target.globals(),
+                    target.color_texture().sample_count(),
+                    &mut self.active_frame.command_encoder,
+                );
+            }
+        }
+    }
 }
 
 impl<T: RenderTarget + 'static> RenderBackend for WgpuRenderBackend<T> {
@@ -499,82 +578,7 @@ impl<T: RenderTarget + 'static> RenderBackend for WgpuRenderBackend<T> {
             }
         };
 
-        for entry in cache_entries {
-            let texture = as_texture(&entry.handle);
-            let mut surface = Surface::new(
-                &self.descriptors,
-                self.surface.quality(),
-                texture.texture.width(),
-                texture.texture.height(),
-                wgpu::TextureFormat::Rgba8Unorm,
-            );
-            if entry.filters.is_empty() {
-                surface.draw_commands(
-                    RenderTargetMode::ExistingWithColor(
-                        texture.texture.clone(),
-                        wgpu::Color {
-                            r: f64::from(entry.clear.r) / 255.0,
-                            g: f64::from(entry.clear.g) / 255.0,
-                            b: f64::from(entry.clear.b) / 255.0,
-                            a: f64::from(entry.clear.a) / 255.0,
-                        },
-                    ),
-                    &self.descriptors,
-                    &self.meshes,
-                    entry.commands,
-                    &mut self.active_frame.staging_belt,
-                    &self.dynamic_transforms,
-                    &mut self.active_frame.command_encoder,
-                    LayerRef::None,
-                    &mut self.offscreen_texture_pool,
-                );
-            } else {
-                // We're relying on there being no impotent filters here,
-                // so that we can safely start by using the actual CAB texture.
-                // It's guaranteed that at least one filter would have used it and moved the target to something else,
-                // letting us safely copy back to it later.
-                let mut target = surface.draw_commands(
-                    RenderTargetMode::ExistingWithColor(
-                        texture.texture.clone(),
-                        wgpu::Color {
-                            r: f64::from(entry.clear.r) / 255.0,
-                            g: f64::from(entry.clear.g) / 255.0,
-                            b: f64::from(entry.clear.b) / 255.0,
-                            a: f64::from(entry.clear.a) / 255.0,
-                        },
-                    ),
-                    &self.descriptors,
-                    &self.meshes,
-                    entry.commands,
-                    &mut self.active_frame.staging_belt,
-                    &self.dynamic_transforms,
-                    &mut self.active_frame.command_encoder,
-                    LayerRef::None,
-                    &mut self.offscreen_texture_pool,
-                );
-                for filter in entry.filters {
-                    target = self.descriptors.filters.apply(
-                        &self.descriptors,
-                        &mut self.active_frame.command_encoder,
-                        &mut self.offscreen_texture_pool,
-                        &mut self.active_frame.staging_belt,
-                        FilterSource::for_entire_texture(target.color_texture()),
-                        filter,
-                    );
-                }
-                run_copy_pipeline(
-                    &self.descriptors,
-                    target.color_texture().format(),
-                    texture.texture.format(),
-                    &texture.texture.create_view(&Default::default()),
-                    target.color_view(),
-                    target.whole_frame_bind_group(&self.descriptors),
-                    target.globals(),
-                    target.color_texture().sample_count(),
-                    &mut self.active_frame.command_encoder,
-                );
-            }
-        }
+        self.draw_cache(cache_entries);
 
         self.surface.draw_commands_and_copy_to(
             frame_output.view(),
@@ -710,6 +714,7 @@ impl<T: RenderTarget + 'static> RenderBackend for WgpuRenderBackend<T> {
         commands: CommandList,
         quality: StageQuality,
         bounds: PixelRegion,
+        cache_entries: Vec<BitmapCacheEntry>,
     ) -> Option<Box<dyn SyncHandle>> {
         let texture = as_texture(&handle);
 
@@ -730,6 +735,8 @@ impl<T: RenderTarget + 'static> RenderBackend for WgpuRenderBackend<T> {
             .get_next_texture()
             .expect("TextureTargetFrame.get_next_texture is infallible");
 
+        self.draw_cache(cache_entries);
+
         let mut surface = Surface::new(
             &self.descriptors,
             quality,

tests/tests/swfs/avm2/away3d_advanced_shallow_water_demo/test.toml

@@ -2,7 +2,7 @@ num_ticks = 20
 
 [image_comparisons.output]
 tolerance = 30
-max_outliers = 400
+max_outliers = 500
 
 [player_options]
 with_renderer = { optional = false, sample_count = 1 }

tests/tests/swfs/avm2/bitmapdata_draw_cab_quality/Test.as

@@ -0,0 +1,39 @@
+package {
+import flash.display.*;
+import flash.geom.*;
+import flash.filters.*;
+import flash.utils.*;
+
+[SWF(width="40", height="40")]
+public class Test extends MovieClip {
+    public function Test() {
+        var s:Sprite = new Sprite();
+        s.graphics.beginFill(0xFF00FF);
+        s.graphics.drawTriangles(Vector.<Number>([
+            0, 0,
+            0, 20,
+            20, 20
+        ]), Vector.<int>([
+            0, 1, 2
+        ]));
+        s.graphics.endFill();
+        s.cacheAsBitmap = true;
+
+        var bd:BitmapData = new BitmapData(40, 20);
+        bd.fillRect(new Rectangle(0,0,40,20), 0xFF000000);
+        bd.drawWithQuality(
+            s,
+            new Matrix(1, 0, 0, 1, 20, 0),
+            new ColorTransform(0, 1, 1),
+            "difference",
+            new Rectangle(0, 10, 40, 10),
+            false,
+            "low"
+        );
+        var b:Bitmap = new Bitmap(bd);
+        b.y = 20;
+        addChild(b);
+        addChild(s);
+    }
+}
+}

tests/tests/swfs/avm2/bitmapdata_draw_cab_quality/test.toml

@@ -0,0 +1,10 @@
+num_ticks = 1
+
+[image_comparisons.output]
+# Outliers come from the top triangle due to MSAA,
+# the bottom one should produce a lot more in case something's wrong.
+max_outliers = 80
+
+[player_options]
+with_renderer = { optional = false, sample_count = 4 }
+viewport_dimensions = { width = 160, height = 160, scale_factor = 1 }

tests/tests/swfs/avm2/bitmapdata_draw_filters/test.toml

@@ -1,8 +1,5 @@
 num_ticks = 1
 
-# FIXME Ruffle does not use CAB in BitmapData.draw
-known_failure = true
-
 [image_comparisons.output]
 tolerance = 0