wgpu: Implement blend modes

core/src/bitmap/bitmap_data.rs

@@ -1000,11 +1000,10 @@ impl<'gc> BitmapData<'gc> {
         let mut transform_stack = ruffle_render::transform::TransformStack::new();
         transform_stack.push(&transform);
         let handle = self.bitmap_handle(context.renderer).unwrap();
-        let mut commands = CommandList::new();
 
         let mut render_context = RenderContext {
             renderer: context.renderer,
-            commands: &mut commands,
+            commands: CommandList::new(),
             gc_context: context.gc_context,
             ui: context.ui,
             library: &context.library,
@@ -1016,7 +1015,6 @@ impl<'gc> BitmapData<'gc> {
         };
 
         // Make the screen opacity match the opacity of this bitmap
-        render_context.commands.push_blend_mode(blend_mode);
         match &mut source {
             IBitmapDrawable::BitmapData(data) => {
                 // if try_write fails,
@@ -1037,10 +1035,17 @@ impl<'gc> BitmapData<'gc> {
                 object.render_self(&mut render_context);
             }
         }
-        render_context.commands.pop_blend_mode();
 
         self.update_dirty_texture(&mut render_context);
 
+        let commands = if blend_mode == BlendMode::Normal {
+            render_context.commands
+        } else {
+            let mut commands = CommandList::new();
+            commands.blend(&render_context.commands, blend_mode);
+            commands
+        };
+
         let image = context.renderer.render_offscreen(
             handle,
             bitmapdata_width,

core/src/context.rs

@@ -426,7 +426,7 @@ pub struct RenderContext<'a, 'gc, 'gc_context> {
     pub renderer: &'a mut dyn RenderBackend,
 
     /// The command list, used by the display objects to draw themselves.
-    pub commands: &'a mut CommandList,
+    pub commands: CommandList,
 
     /// The GC MutationContext, used to perform any GcCell writes
     /// that must occur during rendering.

core/src/display_object.rs

@@ -395,12 +395,6 @@ impl<'gc> DisplayObjectBase<'gc> {
     }
 
     fn set_blend_mode(&mut self, value: BlendMode) {
-        if value != BlendMode::Normal {
-            log::warn!(
-                "Blend mode '{}' is unsupported and will not render correctly.",
-                value
-            );
-        }
         self.blend_mode = value;
     }
 
@@ -512,9 +506,11 @@ pub fn render_base<'gc>(this: DisplayObject<'gc>, context: &mut RenderContext<'_
     }
     context.transform_stack.push(this.base().transform());
     let blend_mode = this.blend_mode();
-    if blend_mode != BlendMode::Normal {
-        context.commands.push_blend_mode(this.blend_mode());
-    }
+    let original_commands = if blend_mode != BlendMode::Normal {
+        Some(std::mem::take(&mut context.commands))
+    } else {
+        None
+    };
 
     let scroll_rect_matrix = if let Some(rect) = this.scroll_rect() {
         let cur_transform = context.transform_stack.transform();
@@ -590,8 +586,10 @@ pub fn render_base<'gc>(this: DisplayObject<'gc>, context: &mut RenderContext<'_
         context.allow_mask = true;
         context.commands.pop_mask();
     }
-    if blend_mode != BlendMode::Normal {
-        context.commands.pop_blend_mode();
+
+    if let Some(original_commands) = original_commands {
+        let sub_commands = std::mem::replace(&mut context.commands, original_commands);
+        context.commands.blend(&sub_commands, blend_mode);
     }
 
     if scroll_rect_matrix.is_some() {

core/src/player.rs

@@ -1450,16 +1450,15 @@ impl Player {
     pub fn render(&mut self) {
         let (renderer, ui, transform_stack) =
             (&mut self.renderer, &mut self.ui, &mut self.transform_stack);
-        let mut commands = CommandList::new();
         let mut background_color = Color::WHITE;
 
-        self.gc_arena.borrow().mutate(|gc_context, gc_root| {
+        let commands = self.gc_arena.borrow().mutate(|gc_context, gc_root| {
             let root_data = gc_root.data.read();
             let stage = root_data.stage;
 
             let mut render_context = RenderContext {
                 renderer: renderer.deref_mut(),
-                commands: &mut commands,
+                commands: CommandList::new(),
                 gc_context,
                 ui: ui.deref_mut(),
                 library: &root_data.library,
@@ -1478,6 +1477,8 @@ impl Player {
                 } else {
                     Color::from_rgba(0)
                 };
+
+            render_context.commands
         });
 
         renderer.submit_frame(background_color, commands);

exporter/src/main.rs

@@ -114,7 +114,7 @@ fn take_screenshot(
         .map_err(|e| anyhow!(e.to_string()))?;
     let player = PlayerBuilder::new()
         .with_renderer(
-            WgpuRenderBackend::new(descriptors, target).map_err(|e| anyhow!(e.to_string()))?,
+            WgpuRenderBackend::new(descriptors, target, 4).map_err(|e| anyhow!(e.to_string()))?,
         )
         .with_movie(movie)
         .with_viewport_dimensions(width, height, size.scale)

render/Cargo.toml

@@ -19,6 +19,7 @@ lyon = { version = "1.0.1", optional = true }
 thiserror = "1.0"
 wasm-bindgen = { version = "=0.2.83", optional = true }
 gc-arena = { git = "https://github.com/ruffle-rs/gc-arena" }
+enum-map = "2.4.2"
 
 [dependencies.jpeg-decoder]
 version = "0.3.0"

render/canvas/src/lib.rs

@@ -395,6 +395,22 @@ impl WebCanvasRenderBackend {
 
         self.mask_state = MaskState::DrawContent;
     }
+
+    fn push_blend_mode(&mut self, blend: BlendMode) {
+        if Some(&blend) != self.blend_modes.last() {
+            self.apply_blend_mode(blend);
+        }
+        self.blend_modes.push(blend);
+    }
+
+    fn pop_blend_mode(&mut self) {
+        let old = self.blend_modes.pop();
+        // We should never pop our base 'BlendMode::Normal'
+        let current = *self.blend_modes.last().unwrap();
+        if old != Some(current) {
+            self.apply_blend_mode(current);
+        }
+    }
 }
 
 impl RenderBackend for WebCanvasRenderBackend {
@@ -750,20 +766,10 @@ impl<'a> CommandHandler<'a> for WebCanvasRenderBackend {
         }
     }
 
-    fn push_blend_mode(&mut self, blend: BlendMode) {
-        if Some(&blend) != self.blend_modes.last() {
-            self.apply_blend_mode(blend);
-        }
-        self.blend_modes.push(blend);
-    }
-
-    fn pop_blend_mode(&mut self) {
-        let old = self.blend_modes.pop();
-        // We should never pop our base 'BlendMode::Normal'
-        let current = *self.blend_modes.last().unwrap();
-        if old != Some(current) {
-            self.apply_blend_mode(current);
-        }
+    fn blend(&mut self, commands: &'a CommandList, blend: BlendMode) {
+        self.push_blend_mode(blend);
+        commands.execute(self);
+        self.pop_blend_mode();
     }
 }
 

render/src/commands.rs

@@ -13,20 +13,21 @@ pub trait CommandHandler<'a> {
     fn deactivate_mask(&mut self);
     fn pop_mask(&mut self);
 
-    fn push_blend_mode(&mut self, blend: BlendMode);
-    fn pop_blend_mode(&mut self);
+    fn blend(&mut self, commands: &'a CommandList, blend_mode: BlendMode);
 }
 
-#[derive(Debug, Default)]
-pub struct CommandList(Vec<Command>);
+#[derive(Debug, Default, Clone)]
+pub struct CommandList {
+    pub commands: Vec<Command>,
+}
 
 impl CommandList {
     pub fn new() -> Self {
         Self::default()
     }
 
     pub fn execute<'a>(&'a self, handler: &mut impl CommandHandler<'a>) {
-        for command in &self.0 {
+        for command in &self.commands {
             match command {
                 Command::RenderBitmap {
                     bitmap,
@@ -41,62 +42,58 @@ impl CommandList {
                 Command::ActivateMask => handler.activate_mask(),
                 Command::DeactivateMask => handler.deactivate_mask(),
                 Command::PopMask => handler.pop_mask(),
-                Command::PushBlendMode(blend) => handler.push_blend_mode(*blend),
-                Command::PopBlendMode => handler.pop_blend_mode(),
+                Command::Blend(commands, blend_mode) => handler.blend(commands, *blend_mode),
             }
         }
     }
 }
 
 impl<'a> CommandHandler<'a> for CommandList {
     fn render_bitmap(&mut self, bitmap: &'a BitmapHandle, transform: &Transform, smoothing: bool) {
-        self.0.push(Command::RenderBitmap {
+        self.commands.push(Command::RenderBitmap {
             bitmap: bitmap.clone(),
             transform: transform.clone(),
             smoothing,
         });
     }
 
     fn render_shape(&mut self, shape: ShapeHandle, transform: &Transform) {
-        self.0.push(Command::RenderShape {
+        self.commands.push(Command::RenderShape {
             shape,
             transform: transform.clone(),
         });
     }
 
     fn draw_rect(&mut self, color: Color, matrix: &Matrix) {
-        self.0.push(Command::DrawRect {
+        self.commands.push(Command::DrawRect {
             color,
             matrix: *matrix,
         });
     }
 
     fn push_mask(&mut self) {
-        self.0.push(Command::PushMask);
+        self.commands.push(Command::PushMask);
     }
 
     fn activate_mask(&mut self) {
-        self.0.push(Command::ActivateMask);
+        self.commands.push(Command::ActivateMask);
     }
 
     fn deactivate_mask(&mut self) {
-        self.0.push(Command::DeactivateMask);
+        self.commands.push(Command::DeactivateMask);
     }
 
     fn pop_mask(&mut self) {
-        self.0.push(Command::PopMask);
-    }
-
-    fn push_blend_mode(&mut self, blend: BlendMode) {
-        self.0.push(Command::PushBlendMode(blend));
+        self.commands.push(Command::PopMask);
     }
 
-    fn pop_blend_mode(&mut self) {
-        self.0.push(Command::PopBlendMode);
+    fn blend(&mut self, commands: &'a CommandList, blend_mode: BlendMode) {
+        self.commands
+            .push(Command::Blend(commands.to_owned(), blend_mode));
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Command {
     RenderBitmap {
         bitmap: BitmapHandle,
@@ -115,6 +112,5 @@ pub enum Command {
     ActivateMask,
     DeactivateMask,
     PopMask,
-    PushBlendMode(BlendMode),
-    PopBlendMode,
+    Blend(CommandList, BlendMode),
 }

render/src/tessellator.rs

@@ -1,5 +1,6 @@
 use crate::bitmap::BitmapSource;
 use crate::shape_utils::{DistilledShape, DrawCommand, DrawPath};
+use enum_map::Enum;
 use lyon::path::Path;
 use lyon::tessellation::{
     self,
@@ -440,7 +441,7 @@ impl StrokeVertexConstructor<Vertex> for RuffleVertexCtor {
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Enum)]
 pub enum GradientType {
     Linear,
     Radial,

render/webgl/src/lib.rs

@@ -910,6 +910,22 @@ impl WebGlRenderBackend {
             );
         }
     }
+
+    fn push_blend_mode(&mut self, blend: BlendMode) {
+        if self.blend_modes.last() != Some(&blend) {
+            self.apply_blend_mode(blend);
+        }
+        self.blend_modes.push(blend);
+    }
+
+    fn pop_blend_mode(&mut self) {
+        let old = self.blend_modes.pop();
+        // We never pop our base 'BlendMode::Normal'
+        let current = *self.blend_modes.last().unwrap();
+        if old != Some(current) {
+            self.apply_blend_mode(current);
+        }
+    }
 }
 
 impl RenderBackend for WebGlRenderBackend {
@@ -1401,20 +1417,10 @@ impl<'a> CommandHandler<'a> for WebGlRenderBackend {
         self.mask_state_dirty = true;
     }
 
-    fn push_blend_mode(&mut self, blend: BlendMode) {
-        if self.blend_modes.last() != Some(&blend) {
-            self.apply_blend_mode(blend);
-        }
-        self.blend_modes.push(blend);
-    }
-
-    fn pop_blend_mode(&mut self) {
-        let old = self.blend_modes.pop();
-        // We never pop our base 'BlendMode::Normal'
-        let current = *self.blend_modes.last().unwrap();
-        if old != Some(current) {
-            self.apply_blend_mode(current);
-        }
+    fn blend(&mut self, commands: &'a CommandList, blend: BlendMode) {
+        self.push_blend_mode(blend);
+        commands.execute(self);
+        self.pop_blend_mode();
     }
 }
 

render/wgpu/shaders/bitmap.wgsl

@@ -5,9 +5,11 @@ struct VertexOutput {
     @location(0) uv: vec2<f32>,
 };
 
-@group(2) @binding(0) var<uniform> textureTransforms: TextureTransforms;
-@group(2) @binding(1) var texture: texture_2d<f32>;
-@group(2) @binding(2) var texture_sampler: sampler;
+@group(2) @binding(0) var<uniform> colorTransforms: ColorTransforms;
+
+@group(3) @binding(0) var<uniform> textureTransforms: TextureTransforms;
+@group(3) @binding(1) var texture: texture_2d<f32>;
+@group(3) @binding(2) var texture_sampler: sampler;
 
 @vertex
 fn main_vertex(in: VertexInput) -> VertexOutput {
@@ -24,7 +26,7 @@ fn main_fragment(in: VertexOutput) -> @location(0) vec4<f32> {
     // Unmultiply alpha, apply color transform, remultiply alpha.
     if( color.a > 0.0 ) {
         color = vec4<f32>(color.rgb / color.a, color.a);
-        color = color * transforms.mult_color + transforms.add_color;
+        color = color * colorTransforms.mult_color + colorTransforms.add_color;
         let alpha = clamp(color.a, 0.0, 1.0);
         color = vec4<f32>(color.rgb * alpha, alpha);
     }