fix(hal/gles): copy every depth slice in copy_texture_to_texture

AlexEgger2Build · AlexEgger2Build · commit 0ea7294d46d6 · 2026-08-03T19:31:22.000-05:00
The `C::CopyTextureToTexture` arm never read `copy.size.depth`. It
attached one slice to the read framebuffer and issued a single
`copy_tex_sub_image_*`, so a copy between 3D textures transferred only
z slice 0. Nothing errored and no validation tripped; the remaining
slices were silently left untouched.

GL has no call that copies a volume between textures, because the read
framebuffer holds one 2D slice at a time, so loop over the depth extent
and copy one slice per iteration.

The source slice index was also taken from `copy.src_base.array_layer`
while the destination used `get_z_offset()`. For `TEXTURE_3D` the z
coordinate lives in `origin.z` rather than `array_layer`, so a copy with
a nonzero source z read the wrong slice; both sides now use
`get_z_offset()`. Non-layered sources go through `get_2d_target()` as
the destination already did, so a cube map source selects the right face
rather than passing `TEXTURE_CUBE_MAP` to `glFramebufferTexture2D`.

Add a test copying a four-slice 3D texture with a distinct value per
slice. The existing `copy_texture_to_texture` coverage only ever copies
a single slice, which is how this went unnoticed.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -107,6 +107,7 @@ Bottom level categories:
 #### GLES
 
 - Fixed signed integer `%` (and `%=`) returning the wrong result for negative operands in the GLSL (OpenGL/GLES) backend, e.g. `-1 % 768` yielding `255` instead of `-1`. GLSL's `%` is undefined when either operand is negative, so signed remainder is now lowered as `a - b * (a / b)`, matching the SPIR-V, HLSL, and Metal backends. By @mstampfli in [#9687](https://github.com/gfx-rs/wgpu/pull/9687).
+- Fixed `copy_texture_to_texture()` copying only the first depth slice when the copy extent had a depth greater than 1, so copies between 3D textures silently lost every slice after the first. Copies with a nonzero source z also read the wrong slice. By @AlexEgger2Build in [#10004](https://github.com/gfx-rs/wgpu/pull/10004).
 
 #### WebGPU
 
diff --git a/tests/tests/wgpu-gpu/transfer.rs b/tests/tests/wgpu-gpu/transfer.rs
@@ -2,8 +2,88 @@ use wgpu_test::{apply, fail, gpu_test, GpuTestConfiguration, GpuTestInitializer,
 
 pub fn all_tests(vec: &mut Vec<GpuTestInitializer>) {
     vec.push(COPY_OVERFLOW_Z);
+    vec.push(COPY_TEXTURE_TO_TEXTURE_3D);
 }
 
+/// Regression test for the GLES backend copying only z slice 0 of a 3D texture.
+#[apply(gpu_test!)]
+static COPY_TEXTURE_TO_TEXTURE_3D: GpuTestConfiguration =
+    GpuTestConfiguration::new().run_async(|ctx| async move {
+        // Each slice is filled with a distinct value, so a dropped or misplaced slice is
+        // caught rather than only a wrong copy length. `width` is a multiple of
+        // `COPY_BYTES_PER_ROW_ALIGNMENT` so `bytes_per_row` stays aligned.
+        let width = 256;
+        let height = 2;
+        let depth = 4;
+        let slice_len = (width * height) as usize;
+
+        let descriptor = wgpu::TextureDescriptor {
+            label: None,
+            dimension: wgpu::TextureDimension::D3,
+            size: wgpu::Extent3d {
+                width,
+                height,
+                depth_or_array_layers: depth,
+            },
+            format: wgpu::TextureFormat::R8Uint,
+            usage: wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::COPY_SRC,
+            mip_level_count: 1,
+            sample_count: 1,
+            view_formats: &[],
+        };
+        let src = ctx.device.create_texture(&descriptor);
+        let dst = ctx.device.create_texture(&descriptor);
+
+        let data: Vec<u8> = (0..depth)
+            .flat_map(|z| vec![(z + 1) as u8; slice_len])
+            .collect();
+        let layout = wgpu::TexelCopyBufferLayout {
+            offset: 0,
+            bytes_per_row: Some(width),
+            rows_per_image: Some(height),
+        };
+        ctx.queue
+            .write_texture(src.as_image_copy(), &data, layout, descriptor.size);
+
+        let read_buffer = ctx.device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: data.len() as u64,
+            usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+
+        let mut encoder = ctx
+            .device
+            .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
+        encoder.copy_texture_to_texture(src.as_image_copy(), dst.as_image_copy(), descriptor.size);
+        encoder.copy_texture_to_buffer(
+            dst.as_image_copy(),
+            wgpu::TexelCopyBufferInfo {
+                buffer: &read_buffer,
+                layout,
+            },
+            descriptor.size,
+        );
+        ctx.queue.submit(Some(encoder.finish()));
+
+        let slice = read_buffer.slice(..);
+        slice.map_async(wgpu::MapMode::Read, |_| ());
+        ctx.async_poll(wgpu::PollType::wait_indefinitely())
+            .await
+            .unwrap();
+        let read: Vec<u8> = slice.get_mapped_range().unwrap().to_vec();
+
+        for z in 0..depth as usize {
+            let expected = (z + 1) as u8;
+            let got = &read[z * slice_len..(z + 1) * slice_len];
+            assert!(
+                got.iter().all(|&texel| texel == expected),
+                "slice z={z} not copied: expected all {expected}, got {:?}",
+                &got[..8],
+            );
+        }
+    });
+
 #[apply(gpu_test!)]
 static COPY_OVERFLOW_Z: GpuTestConfiguration = GpuTestConfiguration::new()
     .parameters(TestParameters::default().enable_noop())
diff --git a/wgpu-hal/src/gles/queue.rs b/wgpu-hal/src/gles/queue.rs
@@ -696,59 +696,63 @@ impl super::Queue {
                 dst_target,
                 ref copy,
             } => {
-                //TODO: handle 3D copies
                 unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(self.copy_fbo)) };
-                if is_layered_target(src_target) {
-                    //TODO: handle GLES without framebuffer_texture_3d
-                    unsafe {
-                        gl.framebuffer_texture_layer(
-                            glow::READ_FRAMEBUFFER,
-                            glow::COLOR_ATTACHMENT0,
-                            Some(src),
-                            copy.src_base.mip_level as i32,
-                            copy.src_base.array_layer as i32,
-                        )
-                    };
-                } else {
-                    unsafe {
-                        gl.framebuffer_texture_2d(
-                            glow::READ_FRAMEBUFFER,
-                            glow::COLOR_ATTACHMENT0,
-                            src_target,
-                            Some(src),
-                            copy.src_base.mip_level as i32,
-                        )
-                    };
-                }
-
                 unsafe { gl.bind_texture(dst_target, Some(dst)) };
-                if is_layered_target(dst_target) {
-                    unsafe {
-                        gl.copy_tex_sub_image_3d(
-                            dst_target,
-                            copy.dst_base.mip_level as i32,
-                            copy.dst_base.origin.x as i32,
-                            copy.dst_base.origin.y as i32,
-                            get_z_offset(dst_target, &copy.dst_base) as i32,
-                            copy.src_base.origin.x as i32,
-                            copy.src_base.origin.y as i32,
-                            copy.size.width as i32,
-                            copy.size.height as i32,
-                        )
-                    };
-                } else {
-                    unsafe {
-                        gl.copy_tex_sub_image_2d(
-                            get_2d_target(dst_target, copy.dst_base.array_layer),
-                            copy.dst_base.mip_level as i32,
-                            copy.dst_base.origin.x as i32,
-                            copy.dst_base.origin.y as i32,
-                            copy.src_base.origin.x as i32,
-                            copy.src_base.origin.y as i32,
-                            copy.size.width as i32,
-                            copy.size.height as i32,
-                        )
-                    };
+
+                // The read framebuffer holds a single 2D slice at a time, so a copy of
+                // depth > 1 is issued one slice per iteration.
+                for z in 0..copy.size.depth {
+                    if is_layered_target(src_target) {
+                        //TODO: handle GLES without framebuffer_texture_3d
+                        unsafe {
+                            gl.framebuffer_texture_layer(
+                                glow::READ_FRAMEBUFFER,
+                                glow::COLOR_ATTACHMENT0,
+                                Some(src),
+                                copy.src_base.mip_level as i32,
+                                (get_z_offset(src_target, &copy.src_base) + z) as i32,
+                            )
+                        };
+                    } else {
+                        unsafe {
+                            gl.framebuffer_texture_2d(
+                                glow::READ_FRAMEBUFFER,
+                                glow::COLOR_ATTACHMENT0,
+                                get_2d_target(src_target, copy.src_base.array_layer + z),
+                                Some(src),
+                                copy.src_base.mip_level as i32,
+                            )
+                        };
+                    }
+
+                    if is_layered_target(dst_target) {
+                        unsafe {
+                            gl.copy_tex_sub_image_3d(
+                                dst_target,
+                                copy.dst_base.mip_level as i32,
+                                copy.dst_base.origin.x as i32,
+                                copy.dst_base.origin.y as i32,
+                                (get_z_offset(dst_target, &copy.dst_base) + z) as i32,
+                                copy.src_base.origin.x as i32,
+                                copy.src_base.origin.y as i32,
+                                copy.size.width as i32,
+                                copy.size.height as i32,
+                            )
+                        };
+                    } else {
+                        unsafe {
+                            gl.copy_tex_sub_image_2d(
+                                get_2d_target(dst_target, copy.dst_base.array_layer + z),
+                                copy.dst_base.mip_level as i32,
+                                copy.dst_base.origin.x as i32,
+                                copy.dst_base.origin.y as i32,
+                                copy.src_base.origin.x as i32,
+                                copy.src_base.origin.y as i32,
+                                copy.size.width as i32,
+                                copy.size.height as i32,
+                            )
+                        };
+                    }
                 }
             }
             C::CopyBufferToTexture {
