wgpu: Yeet the copy_srgb shader and pipeline

render/wgpu/src/backend.rs

@@ -599,7 +599,6 @@ impl<T: RenderTarget + 'static> RenderBackend for WgpuRenderBackend<T> {
                 run_copy_pipeline(
                     &self.descriptors,
                     target.color_texture().format(),
-                    texture.texture.format(),
                     target.color_texture().size(),
                     &texture.texture.create_view(&Default::default()),
                     target.color_view(),

render/wgpu/src/descriptors.rs

@@ -21,7 +21,6 @@ pub struct Descriptors {
     pub bind_layouts: BindLayouts,
     pub quad: Quad,
     copy_pipeline: Mutex<FnvHashMap<(u32, wgpu::TextureFormat), Arc<wgpu::RenderPipeline>>>,
-    copy_srgb_pipeline: Mutex<FnvHashMap<(u32, wgpu::TextureFormat), Arc<wgpu::RenderPipeline>>>,
     pub shaders: Shaders,
     pipelines: Mutex<FnvHashMap<(u32, wgpu::TextureFormat), Arc<Pipelines>>>,
     pub default_color_bind_group: wgpu::BindGroup,
@@ -72,93 +71,13 @@ impl Descriptors {
             bind_layouts,
             quad,
             copy_pipeline: Default::default(),
-            copy_srgb_pipeline: Default::default(),
             shaders,
             pipelines: Default::default(),
             default_color_bind_group,
             filters,
         }
     }
 
-    pub fn copy_srgb_pipeline(
-        &self,
-        format: wgpu::TextureFormat,
-        msaa_sample_count: u32,
-    ) -> Arc<wgpu::RenderPipeline> {
-        let mut pipelines = self
-            .copy_srgb_pipeline
-            .lock()
-            .expect("Pipelines should not be already locked");
-        pipelines
-            .entry((msaa_sample_count, format))
-            .or_insert_with(|| {
-                let copy_texture_pipeline_layout =
-                    &self
-                        .device
-                        .create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-                            label: create_debug_label!("Copy sRGB pipeline layout").as_deref(),
-                            bind_group_layouts: &if self.limits.max_push_constant_size > 0 {
-                                vec![&self.bind_layouts.globals, &self.bind_layouts.bitmap]
-                            } else {
-                                vec![
-                                    &self.bind_layouts.globals,
-                                    &self.bind_layouts.transforms,
-                                    &self.bind_layouts.bitmap,
-                                ]
-                            },
-                            push_constant_ranges: if self.device.limits().max_push_constant_size > 0
-                            {
-                                &[wgpu::PushConstantRange {
-                                    stages: wgpu::ShaderStages::VERTEX,
-                                    range: 0..(mem::size_of::<Transforms>() as u32),
-                                }]
-                            } else {
-                                &[]
-                            },
-                        });
-                Arc::new(
-                    self.device
-                        .create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                            label: create_debug_label!("Copy sRGB pipeline").as_deref(),
-                            layout: Some(copy_texture_pipeline_layout),
-                            vertex: wgpu::VertexState {
-                                module: &self.shaders.copy_srgb_shader,
-                                entry_point: "main_vertex",
-                                buffers: &VERTEX_BUFFERS_DESCRIPTION_POS,
-                            },
-                            fragment: Some(wgpu::FragmentState {
-                                module: &self.shaders.copy_srgb_shader,
-                                entry_point: "main_fragment",
-                                targets: &[Some(wgpu::ColorTargetState {
-                                    format,
-                                    // All of our blending has been done by now, so we want
-                                    // to overwrite the target pixels without any blending
-                                    blend: Some(wgpu::BlendState::REPLACE),
-                                    write_mask: Default::default(),
-                                })],
-                            }),
-                            primitive: wgpu::PrimitiveState {
-                                topology: wgpu::PrimitiveTopology::TriangleList,
-                                strip_index_format: None,
-                                front_face: wgpu::FrontFace::Ccw,
-                                cull_mode: None,
-                                polygon_mode: wgpu::PolygonMode::default(),
-                                unclipped_depth: false,
-                                conservative: false,
-                            },
-                            depth_stencil: None,
-                            multisample: wgpu::MultisampleState {
-                                count: msaa_sample_count,
-                                mask: !0,
-                                alpha_to_coverage_enabled: false,
-                            },
-                            multiview: None,
-                        }),
-                )
-            })
-            .clone()
-    }
-
     pub fn copy_pipeline(
         &self,
         format: wgpu::TextureFormat,

render/wgpu/src/shaders.rs

@@ -18,7 +18,6 @@ pub struct Shaders {
     /// an out-of-range value).
     pub bitmap_late_saturate_shader: wgpu::ShaderModule,
     pub gradient_shader: wgpu::ShaderModule,
-    pub copy_srgb_shader: wgpu::ShaderModule,
     pub copy_shader: wgpu::ShaderModule,
     pub blend_shaders: EnumMap<ComplexBlend, wgpu::ShaderModule>,
     pub color_matrix_filter: wgpu::ShaderModule,
@@ -62,13 +61,6 @@ impl Shaders {
             "bitmap.wgsl",
             include_str!("../shaders/bitmap.wgsl"),
         );
-        let copy_srgb_shader = make_shader(
-            device,
-            &mut composer,
-            &shader_defs,
-            "copy_srgb.wgsl",
-            include_str!("../shaders/copy_srgb.wgsl"),
-        );
         let copy_shader = make_shader(
             device,
             &mut composer,
@@ -136,7 +128,6 @@ impl Shaders {
             bitmap_shader,
             bitmap_late_saturate_shader,
             gradient_shader,
-            copy_srgb_shader,
             copy_shader,
             blend_shaders,
             color_matrix_filter,

render/wgpu/src/surface.rs

@@ -30,7 +30,6 @@ pub struct Surface {
     sample_count: u32,
     pipelines: Arc<Pipelines>,
     format: wgpu::TextureFormat,
-    actual_surface_format: wgpu::TextureFormat,
 }
 
 impl Surface {
@@ -57,7 +56,6 @@ impl Surface {
             sample_count,
             pipelines,
             format: frame_buffer_format,
-            actual_surface_format: surface_format,
         }
     }
 
@@ -93,7 +91,6 @@ impl Surface {
         run_copy_pipeline(
             descriptors,
             self.format,
-            self.actual_surface_format,
             self.size,
             frame_view,
             target.color_view(),

render/wgpu/src/surface/target.rs

@@ -287,7 +287,6 @@ impl CommandTarget {
                 run_copy_pipeline(
                     descriptors,
                     format,
-                    format,
                     size,
                     frame_buffer.texture.view(),
                     &texture.create_view(&Default::default()),

render/wgpu/src/utils.rs

@@ -205,7 +205,6 @@ pub fn supported_sample_count(
 pub fn run_copy_pipeline(
     descriptors: &Descriptors,
     format: wgpu::TextureFormat,
-    actual_surface_format: wgpu::TextureFormat,
     size: wgpu::Extent3d,
     frame_view: &wgpu::TextureView,
     input: &wgpu::TextureView,
@@ -237,11 +236,7 @@ pub fn run_copy_pipeline(
             label: create_debug_label!("Copy sRGB bind group").as_deref(),
         });
 
-    let pipeline = if actual_surface_format == format {
-        descriptors.copy_pipeline(format, sample_count)
-    } else {
-        descriptors.copy_srgb_pipeline(actual_surface_format, sample_count)
-    };
+    let pipeline = descriptors.copy_pipeline(format, sample_count);
 
     // We overwrite the pixels in the target texture (no blending at all),
     // so this doesn't matter.