Method copy_texture_to_buffer

crates/wgpu_context/src/buffer_renderer.rs:127–178

(&self, cpu_buffer: &mut [u8])

    }

    pub fn copy_texture_to_buffer(&self, cpu_buffer: &mut [u8]) {
        let mut encoder = self
            .device()
            .create_command_encoder(&CommandEncoderDescriptor {
                label: Some("Copy out buffer"),
            });
        let row_byte_width = self.config.width as usize * 4;
        let padded_row_byte_width = row_byte_width.next_multiple_of(256);

        let texture = self.texture_view.texture();
        encoder.copy_texture_to_buffer(
            texture.as_image_copy(),
            TexelCopyBufferInfo {
                buffer: &self.gpu_buffer,
                layout: TexelCopyBufferLayout {
                    offset: 0,
                    bytes_per_row: Some(padded_row_byte_width as u32),
                    rows_per_image: None,
                },
            },
            texture.size(),
        );

        self.queue().submit([encoder.finish()]);
        let buf_slice = self.gpu_buffer.slice(..);

        let (sender, receiver) = futures_intrusive::channel::shared::oneshot_channel();
        buf_slice.map_async(wgpu::MapMode::Read, move |v| sender.send(v).unwrap());

        if let Ok(recv_result) =
            block_on_wgpu(self.device(), receiver.receive()).inspect_err(|err| {
                panic!("channel inaccessible: {:#}", err);
            })
        {
            let _ = recv_result.unwrap();
        }

        let data = buf_slice.get_mapped_range();

        // Pad result
        for row in 0..(self.config.height as usize) {
            let src_start = row * padded_row_byte_width;
            let src = &data[src_start..(src_start + row_byte_width)];

            let dest_start = row * row_byte_width;
            cpu_buffer[dest_start..(dest_start + row_byte_width)].clone_from_slice(src);
        }

        // Unmap buffer
        drop(data);
        self.gpu_buffer.unmap();
    }
}