Save the window surface to disk

[Hperigo]

Hello!

I've been spinning my head around this for a little bit and I can't seem to find a good awenser, but basically I want to save whatever is rendered on the screen to disk. Right now I'm able to save a file but it's a black image.

Let me know if it's possible to use the window surface or if I need to render everything into a another renderpass and save that

thanks!

here's my code:

        let output_surface = self.window_surface.get_current_texture().unwrap();
        let width = output_surface.texture.width();
        let height = output_surface.texture.height();
        let format = wgpu::TextureFormat::Bgra8UnormSrgb; 

        let mid_texture = factories::Texture2dFactory::new_with_options(
            self,
            [width, height],
            factories::texture::Texture2dOptions {
                format,
                usage: wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::TEXTURE_BINDING,
                label: Some("Temp Texture for Saving"),
                ..Default::default()
            },
            factories::texture::SamplerOptions {
                ..Default::default()
            },
            
            &[],
        );

        let u8_size = std::mem::size_of::<u8>() as u32;
        let bytes_per_pixel = u8_size * 4; // RGBA has 4 channels
        let unpadded_bytes_per_row = width * bytes_per_pixel;
        let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT;
        let padded_bytes_per_row = (unpadded_bytes_per_row + align - 1) & !(align - 1);
        let buffer_size = padded_bytes_per_row * height;

        let output_buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Output Buffer"),
            size: buffer_size as wgpu::BufferAddress,
            usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
            mapped_at_creation: false,
        });

        // 3. Encode the copy command
        let mut encoder = self
            .device
            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
                label: Some("SAVE TEXTURE Copy Encoder"),
            });

            let texture_size = wgpu::Extent3d {
                width,
                height,
                depth_or_array_layers: 1,
            };
        
        self.temp_texture = Some(mid_texture);

        encoder.copy_texture_to_texture(
            TexelCopyTextureInfoBase {
                texture: & output_surface.texture,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            TexelCopyTextureInfoBase {
                texture: &self.temp_texture.as_ref().unwrap().texture,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            texture_size
        );

        println!(
            "Encoding copy command... {:?} - {:?}",
            output_surface.texture.usage(),
            self.config
        );

            encoder.copy_texture_to_buffer(
            wgpu::TexelCopyTextureInfo {
                texture: &output_surface.texture,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            wgpu::TexelCopyBufferInfo {
                buffer: &output_buffer,
                layout: wgpu::TexelCopyBufferLayout {
                    offset: 0,
                    bytes_per_row: Some(padded_bytes_per_row),
                    rows_per_image: Some(height),
                },
            },
            texture_size,
        );

        self.queue.submit(Some(encoder.finish()));
        // // 5. Map the buffer and wait
        let buffer_slice = output_buffer.slice(..);


        let (tx, rx) = futures::channel::oneshot::channel();
        buffer_slice.map_async(wgpu::MapMode::Read, move |result| {
            println!("Buffer mapped... {:?}", result);
            tx.send(result).unwrap();
        });

        self.device.poll(wgpu::wgt::PollType::Wait { submission_index: None, timeout: None }).unwrap();
        // rx.await??;

        pollster::block_on( rx ).unwrap().unwrap();

        // Get the mapped data
        let data = buffer_slice.get_mapped_range();

        println!("Creating image buffer... {}", data.len());

        let mut img_data = Vec::with_capacity((width * height * 4) as usize);
        for row in 0..height {
            let start = (row * padded_bytes_per_row) as usize;
            let end = start + (width * bytes_per_pixel) as usize;
            img_data.extend_from_slice(&data[start..end]);
        }

        // Save using the image crate
        image::save_buffer(
            "Test.jpg",
            &img_data,
            width,
            height,
            image::ColorType::Rgba8,
        ).unwrap();

        drop(data);
        output_buffer.unmap();

[kpreid]

I’m not sure whether it’s supposed to be possible to copy from the surface texture, but presuming it isn’t, you still don't need to render more than once. Create a normal texture, render to it, and copy that texture to the surface texture as well as to your screenshot buffer.

[mfluehr]

This approach worked for me.