[d3d12,metal,gl] add support for rendering to slices of 3D textures

Author: teoxoy

tests/tests/wgpu-gpu/render_target.rs

@@ -2,7 +2,7 @@ use wgpu::{
     util::{BufferInitDescriptor, DeviceExt},
     vertex_attr_array,
 };
-use wgpu_test::{gpu_test, GpuTestConfiguration, TestParameters, TestingContext};
+use wgpu_test::{gpu_test, FailureCase, GpuTestConfiguration, TestParameters, TestingContext};
 
 #[gpu_test]
 static DRAW_TO_2D_VIEW: GpuTestConfiguration = GpuTestConfiguration::new()
@@ -233,3 +233,188 @@ async fn run_test(
     let succeeded = data.iter().all(|b| *b == u8::MAX);
     assert!(succeeded);
 }
+
+#[gpu_test]
+static DRAW_TO_3D_VIEW: GpuTestConfiguration = GpuTestConfiguration::new()
+    .parameters(
+        TestParameters::default()
+            .limits(wgpu::Limits {
+                max_texture_dimension_3d: 512,
+                ..wgpu::Limits::downlevel_webgl2_defaults()
+            })
+            .skip(FailureCase::backend(wgpu::Backends::VULKAN)),
+    )
+    .run_async(run_test_3d);
+
+async fn run_test_3d(ctx: TestingContext) {
+    let vertex_buffer_content: &[f32; 12] = &[
+        // Triangle 1
+        -1.0, -1.0, // Bottom left
+        1.0, 1.0, // Top right
+        -1.0, 1.0, // Top left
+        // Triangle 2
+        -1.0, -1.0, // Bottom left
+        1.0, -1.0, // Bottom right
+        1.0, 1.0, // Top right
+    ];
+    let vertex_buffer = ctx.device.create_buffer_init(&BufferInitDescriptor {
+        label: None,
+        contents: bytemuck::cast_slice(vertex_buffer_content),
+        usage: wgpu::BufferUsages::VERTEX,
+    });
+
+    let shader_src = "
+            @vertex
+            fn vs_main(@location(0) position: vec2f) -> @builtin(position) vec4f {
+                return vec4f(position, 0.0, 1.0);
+            }
+
+            @fragment
+            fn fs_main() -> @location(0) vec4f {
+                return vec4f(1.0);
+            }
+        ";
+
+    let shader = ctx
+        .device
+        .create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: None,
+            source: wgpu::ShaderSource::Wgsl(shader_src.into()),
+        });
+
+    let pipeline_desc = wgpu::RenderPipelineDescriptor {
+        label: None,
+        layout: None,
+        vertex: wgpu::VertexState {
+            buffers: &[wgpu::VertexBufferLayout {
+                array_stride: 8,
+                step_mode: wgpu::VertexStepMode::Vertex,
+                attributes: &vertex_attr_array![0 => Float32x2],
+            }],
+            module: &shader,
+            entry_point: Some("vs_main"),
+            compilation_options: Default::default(),
+        },
+        primitive: wgpu::PrimitiveState::default(),
+        depth_stencil: None,
+        multisample: wgpu::MultisampleState::default(),
+        fragment: Some(wgpu::FragmentState {
+            module: &shader,
+            entry_point: Some("fs_main"),
+            compilation_options: Default::default(),
+            targets: &[Some(wgpu::ColorTargetState {
+                format: wgpu::TextureFormat::R8Unorm,
+                blend: None,
+                write_mask: wgpu::ColorWrites::ALL,
+            })],
+        }),
+        multiview: None,
+        cache: None,
+    };
+    let pipeline = ctx.device.create_render_pipeline(&pipeline_desc);
+
+    const SIZE: u32 = 512;
+    const DEPTH: u32 = 2;
+    const MIPS: u32 = 2;
+    const fn size_for_mips(mips: u32) -> u64 {
+        let mut out: u64 = 0;
+        let mut mip = 0;
+        while mip < mips {
+            let size = SIZE as u64 >> mip;
+            let z = DEPTH as u64 >> mip;
+            out += size * size * z;
+
+            mip += 1;
+        }
+        out
+    }
+
+    let out_texture = ctx.device.create_texture(&wgpu::TextureDescriptor {
+        label: None,
+        size: wgpu::Extent3d {
+            width: SIZE,
+            height: SIZE,
+            depth_or_array_layers: DEPTH,
+        },
+        mip_level_count: MIPS,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D3,
+        format: wgpu::TextureFormat::R8Unorm,
+        usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+        view_formats: &[],
+    });
+
+    let readback_buffer = ctx.device.create_buffer(&wgpu::BufferDescriptor {
+        label: None,
+        size: size_for_mips(MIPS),
+        usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+        mapped_at_creation: false,
+    });
+
+    let mut encoder = ctx
+        .device
+        .create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
+
+    for mip in 0..MIPS {
+        let out_texture_view = out_texture.create_view(&wgpu::TextureViewDescriptor {
+            base_mip_level: mip,
+            mip_level_count: Some(1),
+            ..Default::default()
+        });
+        for layer in 0..DEPTH >> mip {
+            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: None,
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &out_texture_view,
+                    depth_slice: Some(layer),
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                depth_stencil_attachment: None,
+                timestamp_writes: None,
+                occlusion_query_set: None,
+            });
+            rpass.set_pipeline(&pipeline);
+            rpass.set_vertex_buffer(0, vertex_buffer.slice(..));
+            rpass.draw(0..6, 0..1);
+        }
+    }
+
+    for mip in 0..MIPS {
+        encoder.copy_texture_to_buffer(
+            wgpu::TexelCopyTextureInfo {
+                texture: &out_texture,
+                mip_level: mip,
+                origin: wgpu::Origin3d::ZERO,
+                aspect: wgpu::TextureAspect::All,
+            },
+            wgpu::TexelCopyBufferInfo {
+                buffer: &readback_buffer,
+                layout: wgpu::TexelCopyBufferLayout {
+                    offset: size_for_mips(mip),
+                    bytes_per_row: Some(SIZE >> mip),
+                    rows_per_image: Some(SIZE >> mip),
+                },
+            },
+            wgpu::Extent3d {
+                width: SIZE >> mip,
+                height: SIZE >> mip,
+                depth_or_array_layers: DEPTH >> mip,
+            },
+        );
+    }
+
+    ctx.queue.submit([encoder.finish()]);
+
+    let slice = readback_buffer.slice(..);
+    slice.map_async(wgpu::MapMode::Read, |_| ());
+
+    ctx.async_poll(wgpu::PollType::wait()).await.unwrap();
+
+    let data = slice.get_mapped_range();
+    let succeeded = data.iter().all(|b| *b == u8::MAX);
+    assert!(succeeded);
+}

wgpu-core/src/command/render.rs

@@ -14,7 +14,7 @@ use crate::command::{
 };
 use crate::init_tracker::BufferInitTrackerAction;
 use crate::pipeline::{RenderPipeline, VertexStep};
-use crate::resource::InvalidResourceError;
+use crate::resource::{InvalidResourceError, ResourceErrorIdent};
 use crate::snatch::SnatchGuard;
 use crate::{
     api_log,
@@ -621,6 +621,18 @@ pub enum ColorAttachmentError {
     TooMany { given: usize, limit: usize },
     #[error("The total number of bytes per sample in color attachments {total} exceeds the limit {limit}")]
     TooManyBytesPerSample { total: u32, limit: u32 },
+    #[error("Depth slice must be less than {limit} but is {given}")]
+    DepthSliceLimit { given: u32, limit: u32 },
+    #[error("Color attachment's view is 3D and requires depth slice to be provided")]
+    MissingDepthSlice,
+    #[error("Depth slice was provided but the color attachment's view is not 3D")]
+    UnneededDepthSlice,
+    #[error("{view}'s subresource at mip {mip_level} and depth/array layer {depth_or_array_layer} is already attached to this render pass")]
+    SubresourceOverlap {
+        view: ResourceErrorIdent,
+        mip_level: u32,
+        depth_or_array_layer: u32,
+    },
 }
 
 #[derive(Clone, Debug, Error)]
@@ -1096,6 +1108,8 @@ impl<'d> RenderPassInfo<'d> {
             });
         }
 
+        let mut attachment_set = crate::FastHashSet::default();
+
         let mut color_attachments_hal =
             ArrayVec::<Option<hal::ColorAttachment<_>>, { hal::MAX_COLOR_ATTACHMENTS }>::new();
         for (index, attachment) in color_attachments.iter().enumerate() {
@@ -1126,6 +1140,71 @@ impl<'d> RenderPassInfo<'d> {
                 ));
             }
 
+            if color_view.desc.dimension == TextureViewDimension::D3 {
+                if let Some(depth_slice) = at.depth_slice {
+                    let mip = color_view.desc.range.base_mip_level;
+                    let mip_size = color_view
+                        .parent
+                        .desc
+                        .size
+                        .mip_level_size(mip, color_view.parent.desc.dimension);
+                    let limit = mip_size.depth_or_array_layers;
+                    if depth_slice >= limit {
+                        return Err(RenderPassErrorInner::ColorAttachment(
+                            ColorAttachmentError::DepthSliceLimit {
+                                given: depth_slice,
+                                limit,
+                            },
+                        ));
+                    }
+                } else {
+                    return Err(RenderPassErrorInner::ColorAttachment(
+                        ColorAttachmentError::MissingDepthSlice,
+                    ));
+                }
+            } else if at.depth_slice.is_some() {
+                return Err(RenderPassErrorInner::ColorAttachment(
+                    ColorAttachmentError::UnneededDepthSlice,
+                ));
+            }
+
+            fn check_attachment_overlap(
+                attachment_set: &mut crate::FastHashSet<(crate::track::TrackerIndex, u32, u32)>,
+                view: &TextureView,
+                depth_slice: Option<u32>,
+            ) -> Result<(), ColorAttachmentError> {
+                let mut insert = |slice| {
+                    let mip_level = view.desc.range.base_mip_level;
+                    if attachment_set.insert((view.tracking_data.tracker_index(), mip_level, slice))
+                    {
+                        Ok(())
+                    } else {
+                        Err(ColorAttachmentError::SubresourceOverlap {
+                            view: view.error_ident(),
+                            mip_level,
+                            depth_or_array_layer: slice,
+                        })
+                    }
+                };
+                match view.desc.dimension {
+                    TextureViewDimension::D2 => {
+                        insert(view.desc.range.base_array_layer)?;
+                    }
+                    TextureViewDimension::D2Array => {
+                        for layer in view.selector.layers.clone() {
+                            insert(layer)?;
+                        }
+                    }
+                    TextureViewDimension::D3 => {
+                        insert(depth_slice.unwrap())?;
+                    }
+                    _ => unreachable!(),
+                };
+                Ok(())
+            }
+
+            check_attachment_overlap(&mut attachment_set, color_view, at.depth_slice)?;
+
             Self::add_pass_texture_init_actions(
                 at.load_op,
                 at.store_op,
@@ -1141,6 +1220,8 @@ impl<'d> RenderPassInfo<'d> {
                 resolve_view.same_device(device)?;
                 check_multiview(resolve_view)?;
 
+                check_attachment_overlap(&mut attachment_set, resolve_view, None)?;
+
                 let resolve_location = AttachmentErrorLocation::Color {
                     index,
                     resolve: true,

wgpu-core/src/device/resource.rs

@@ -929,8 +929,11 @@ impl Device {
                     desc.format,
                 ));
             }
-            // Renderable textures can only be 2D
-            if desc.usage.contains(wgt::TextureUsages::RENDER_ATTACHMENT) {
+
+            // Renderable textures can only be 2D on Vulkan (until we implement 3D support)
+            if self.backend() == wgt::Backend::Vulkan
+                && desc.usage.contains(wgt::TextureUsages::RENDER_ATTACHMENT)
+            {
                 return Err(CreateTextureError::InvalidDimensionUsages(
                     wgt::TextureUsages::RENDER_ATTACHMENT,
                     desc.dimension,
@@ -948,6 +951,14 @@ impl Device {
                     desc.format,
                 ));
             }
+
+            // Renderable textures can only be 2D or 3D
+            if desc.usage.contains(wgt::TextureUsages::RENDER_ATTACHMENT) {
+                return Err(CreateTextureError::InvalidDimensionUsages(
+                    wgt::TextureUsages::RENDER_ATTACHMENT,
+                    desc.dimension,
+                ));
+            }
         }
 
         if desc.format.is_compressed() {
@@ -1124,17 +1135,13 @@ impl Device {
 
         let clear_mode = if hal_usage
             .intersects(wgt::TextureUses::DEPTH_STENCIL_WRITE | wgt::TextureUses::COLOR_TARGET)
+            && desc.dimension == wgt::TextureDimension::D2
         {
             let (is_color, usage) = if desc.format.is_depth_stencil_format() {
                 (false, wgt::TextureUses::DEPTH_STENCIL_WRITE)
             } else {
                 (true, wgt::TextureUses::COLOR_TARGET)
             };
-            let dimension = match desc.dimension {
-                wgt::TextureDimension::D1 => TextureViewDimension::D1,
-                wgt::TextureDimension::D2 => TextureViewDimension::D2,
-                wgt::TextureDimension::D3 => unreachable!(),
-            };
 
             let clear_label = hal_label(
                 Some("(wgpu internal) clear texture view"),
@@ -1149,7 +1156,7 @@ impl Device {
                             let desc = hal::TextureViewDescriptor {
                                 label: clear_label,
                                 format: $format,
-                                dimension,
+                                dimension: TextureViewDimension::D2,
                                 usage,
                                 range: wgt::ImageSubresourceRange {
                                     aspect: $aspect,
@@ -1420,9 +1427,12 @@ impl Device {
                 break 'error Err(TextureViewNotRenderableReason::Usage(resolved_usage));
             }
 
-            if !(resolved_dimension == TextureViewDimension::D2
-                || resolved_dimension == TextureViewDimension::D2Array)
-            {
+            let allowed_view_dimensions = [
+                TextureViewDimension::D2,
+                TextureViewDimension::D2Array,
+                TextureViewDimension::D3,
+            ];
+            if !allowed_view_dimensions.contains(&resolved_dimension) {
                 break 'error Err(TextureViewNotRenderableReason::Dimension(
                     resolved_dimension,
                 ));