Deal with flip_y and multiplication

Author: cwfitzgerald

wgpu-core/src/device/queue.rs

@@ -996,7 +996,12 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
 
         unsafe {
             encoder.transition_textures(transitions.map(|pending| pending.into_hal(dst)));
-            encoder.copy_external_image_to_texture(&source.source, dst_raw, iter::once(regions));
+            encoder.copy_external_image_to_texture(
+                source,
+                dst_raw,
+                destination.premultiplied_alpha,
+                iter::once(regions),
+            );
         }
 
         Ok(())

wgpu-hal/src/empty.rs

@@ -267,8 +267,9 @@ impl crate::CommandEncoder<Api> for Encoder {
     #[cfg(all(target_arch = "wasm32", not(feature = "emscripten")))]
     unsafe fn copy_external_image_to_texture<T>(
         &mut self,
-        src: &wgt::ExternalImageSource,
+        src: &wgt::ImageCopyExternalImage,
         dst: &Resource,
+        dst_premultiplication: bool,
         regions: T,
     ) where
         T: Iterator<Item = crate::TextureCopy>,

wgpu-hal/src/gles/command.rs

@@ -312,8 +312,9 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
     #[cfg(all(target_arch = "wasm32", not(feature = "emscripten")))]
     unsafe fn copy_external_image_to_texture<T>(
         &mut self,
-        src: &wgt::ExternalImageSource,
+        src: &wgt::ImageCopyExternalImage,
         dst: &super::Texture,
+        dst_premultiplication: bool,
         regions: T,
     ) where
         T: Iterator<Item = crate::TextureCopy>,
@@ -328,6 +329,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
                     dst: dst_raw,
                     dst_target,
                     dst_format: dst.format,
+                    dst_premultiplication,
                     copy,
                 })
         }

wgpu-hal/src/gles/mod.rs

@@ -663,10 +663,11 @@ enum Command {
     },
     #[cfg(all(target_arch = "wasm32", not(feature = "emscripten")))]
     CopyExternalImageToTexture {
-        src: wgt::ExternalImageSource,
+        src: wgt::ImageCopyExternalImage,
         dst: glow::Texture,
         dst_target: BindTarget,
         dst_format: wgt::TextureFormat,
+        dst_premultiplication: bool,
         copy: crate::TextureCopy,
     },
     CopyTextureToTexture {

wgpu-hal/src/gles/queue.rs

@@ -381,12 +381,24 @@ impl super::Queue {
                 dst,
                 dst_target,
                 dst_format,
+                dst_premultiplication,
                 ref copy,
             } => {
+                const UNPACK_FLIP_Y_WEBGL: u32 = 0x9240;
+                const UNPACK_PREMULTIPLY_ALPHA_WEBGL: u32 = 0x9241;
+
+                unsafe {
+                    gl.pixel_store_i32(UNPACK_FLIP_Y_WEBGL, src.flip_y as i32);
+                    gl.pixel_store_i32(
+                        UNPACK_PREMULTIPLY_ALPHA_WEBGL,
+                        dst_premultiplication as i32,
+                    );
+                }
+
                 unsafe { gl.bind_texture(dst_target, Some(dst)) };
                 let format_desc = self.shared.describe_texture_format(dst_format);
                 if is_layered_target(dst_target) {
-                    match *src {
+                    match src.source {
                         wgt::ExternalImageSource::ImageBitmap(ref b) => unsafe {
                             gl.tex_sub_image_3d_with_image_bitmap(
                                 dst_target,
@@ -435,7 +447,7 @@ impl super::Queue {
                         wgt::ExternalImageSource::OffscreenCanvas(_) => unreachable!(),
                     }
                 } else {
-                    match *src {
+                    match src.source {
                         wgt::ExternalImageSource::ImageBitmap(ref b) => unsafe {
                             gl.tex_sub_image_2d_with_image_bitmap_and_width_and_height(
                                 dst_target,
@@ -478,6 +490,11 @@ impl super::Queue {
                         wgt::ExternalImageSource::OffscreenCanvas(_) => unreachable!(),
                     }
                 }
+
+                unsafe {
+                    gl.pixel_store_i32(UNPACK_FLIP_Y_WEBGL, 0);
+                    gl.pixel_store_i32(UNPACK_PREMULTIPLY_ALPHA_WEBGL, 0);
+                }
             }
             C::CopyTextureToTexture {
                 src,

wgpu-hal/src/lib.rs

@@ -405,8 +405,9 @@ pub trait CommandEncoder<A: Api>: Send + Sync + fmt::Debug {
     #[cfg(all(target_arch = "wasm32", not(feature = "emscripten")))]
     unsafe fn copy_external_image_to_texture<T>(
         &mut self,
-        src: &wgt::ExternalImageSource,
+        src: &wgt::ImageCopyExternalImage,
         dst: &A::Texture,
+        dst_premultiplication: bool,
         regions: T,
     ) where
         T: Iterator<Item = TextureCopy>;

wgpu/tests/3x3_colors.png

@@ -45,6 +45,10 @@ async fn image_bitmap_import() {
     enum TestCase {
         // Import the image as normal
         Normal,
+        // Sets the FlipY flag. Deals with global state on GLES, so run before other tests to ensure it's reset.
+        FlipY,
+        // Sets the premultiplied alpha flag. Deals with global state on GLES, so run before other tests to ensure it's reset.
+        Premultiplied,
         // Set both the input offset and output offset to 1 in x, so the first column is omitted.
         TrimLeft,
         // Set the size to 2 in x, so the last column is omitted
@@ -62,6 +66,8 @@ async fn image_bitmap_import() {
     }
     let cases = [
         TestCase::Normal,
+        TestCase::FlipY,
+        TestCase::Premultiplied,
         TestCase::TrimLeft,
         TestCase::TrimRight,
         TestCase::SlideRight,
@@ -77,10 +83,14 @@ async fn image_bitmap_import() {
             let mut raw_image = raw_image.clone();
             // The origin used for the external copy on the source side.
             let mut src_origin = wgpu::Origin2d::ZERO;
+            // If the source should be flipped in Y
+            let mut src_flip_y = false;
             // The origin used for the external copy on the destination side.
             let mut dest_origin = wgpu::Origin3d::ZERO;
             // The layer the external image's data should end up in.
             let mut dest_data_layer = 0;
+            // The layer the external image's data should end up in.
+            let mut dest_premultiplied = false;
             // Size of the external copy
             let mut copy_size = wgpu::Extent3d {
                 width: 3,
@@ -98,6 +108,25 @@ async fn image_bitmap_import() {
             let mut correct = true;
             match case {
                 TestCase::Normal => {}
+                TestCase::FlipY => {
+                    src_flip_y = true;
+                    for x in 0..3 {
+                        let top = raw_image[(x, 0)];
+                        let bottom = raw_image[(x, 2)];
+                        raw_image[(x, 0)] = bottom;
+                        raw_image[(x, 2)] = top;
+                    }
+                }
+                TestCase::Premultiplied => {
+                    dest_premultiplied = true;
+                    for pixel in raw_image.pixels_mut() {
+                        let mut float_pix = pixel.0.map(|v| v as f32 / 255.0);
+                        float_pix[0] *= float_pix[3];
+                        float_pix[1] *= float_pix[3];
+                        float_pix[2] *= float_pix[3];
+                        pixel.0 = float_pix.map(|v| (v * 255.0).round() as u8);
+                    }
+                }
                 TestCase::TrimLeft => {
                     valid = ctx
                         .adapter_downlevel_capabilities
@@ -173,15 +202,15 @@ async fn image_bitmap_import() {
                     &wgpu::ImageCopyExternalImage {
                         source: wgpu::ExternalImageSource::ImageBitmap(image_bitmap.clone()),
                         origin: src_origin,
-                        flip_y: false,
+                        flip_y: src_flip_y,
                     },
                     wgpu::ImageCopyTextureTagged {
                         texture: &texture,
                         mip_level: 0,
                         origin: dest_origin,
                         aspect: wgpu::TextureAspect::All,
                         color_space: wgpu::PredefinedColorSpace::Srgb,
-                        premultiplied_alpha: false,
+                        premultiplied_alpha: dest_premultiplied,
                     },
                     copy_size,
                 );