From 3d8a4baeb8f85e64aac7f4f0688b7bef74f75422 Mon Sep 17 00:00:00 2001 From: Connor Fitzgerald Date: Sat, 19 Jun 2021 17:58:29 -0400 Subject: [PATCH] Add out multiple tests of vertex pulling --- wgpu/tests/common/mod.rs | 30 ++- wgpu/tests/vertex_indexes/draw.vert.wgsl | 3 +- wgpu/tests/vertex_indexes/mod.rs | 288 +++++++++++++---------- 3 files changed, 186 insertions(+), 135 deletions(-) diff --git a/wgpu/tests/common/mod.rs b/wgpu/tests/common/mod.rs index 070131c30..5fb43a94e 100644 --- a/wgpu/tests/common/mod.rs +++ b/wgpu/tests/common/mod.rs @@ -2,9 +2,7 @@ use std::panic::{catch_unwind, AssertUnwindSafe}; -use wgt::{ - BackendBit, DeviceDescriptor, DownlevelProperties, Features, Limits, -}; +use wgt::{BackendBit, DeviceDescriptor, DownlevelProperties, Features, Limits}; use wgpu::{util, Adapter, Device, Instance, Queue}; @@ -101,28 +99,38 @@ impl Default for TestParameters { // Builder pattern to make it easier #[allow(dead_code)] impl TestParameters { + /// Set of common features that most tests require. + pub fn test_features(self) -> Self { + self.features(Features::MAPPABLE_PRIMARY_BUFFERS | Features::VERTEX_WRITABLE_STORAGE) + } + pub fn features(mut self, features: Features) -> Self { self.required_features |= features; self } + pub fn backend_failures(mut self, backends: BackendBit) -> Self { + self.backend_failures |= backends; + self + } + pub fn failure(mut self) -> Self { self.always_failure = true; self } } -pub fn initialize_test( - parameters: TestParameters, - test_function: impl FnOnce(TestingContext), -) { - // We don't actually care if it fails - let _ = env_logger::try_init(); +pub fn initialize_test(parameters: TestParameters, test_function: impl FnOnce(TestingContext)) { + // We don't actually care if it fails + let _ = env_logger::try_init(); let backend_bits = util::backend_bits_from_env().unwrap_or(BackendBit::all()); let instance = Instance::new(backend_bits); - let adapter = pollster::block_on(util::initialize_adapter_from_env_or_default(&instance, backend_bits)) - .expect("could not find sutable adapter on the system"); + let adapter = pollster::block_on(util::initialize_adapter_from_env_or_default( + &instance, + backend_bits, + )) + .expect("could not find sutable adapter on the system"); let adapter_info = adapter.get_info(); let adapter_lowercase_name = adapter_info.name.to_lowercase(); diff --git a/wgpu/tests/vertex_indexes/draw.vert.wgsl b/wgpu/tests/vertex_indexes/draw.vert.wgsl index b99cec091..69babbcd4 100644 --- a/wgpu/tests/vertex_indexes/draw.vert.wgsl +++ b/wgpu/tests/vertex_indexes/draw.vert.wgsl @@ -8,7 +8,8 @@ var indices: [[access(read_write)]] Indices; [[stage(vertex)]] fn vs_main([[builtin(instance_index)]] instance: u32, [[builtin(vertex_index)]] index: u32) -> [[builtin(position)]] vec4 { - indices.arr[index] = instance; + let idx = instance * 3u + index; + indices.arr[idx] = idx; return vec4(0.0, 0.0, 0.0, 1.0); } diff --git a/wgpu/tests/vertex_indexes/mod.rs b/wgpu/tests/vertex_indexes/mod.rs index 880926213..e5e107450 100644 --- a/wgpu/tests/vertex_indexes/mod.rs +++ b/wgpu/tests/vertex_indexes/mod.rs @@ -2,135 +2,177 @@ use std::num::NonZeroU64; use wgpu::util::DeviceExt; -use crate::common::{initialize_test, TestParameters}; +use crate::common::{initialize_test, TestParameters, TestingContext}; + +fn pulling_common( + ctx: TestingContext, + expected: &[u32], + function: impl FnOnce(&mut wgpu::RenderPass<'_>), +) { + let shader = ctx + .device + .create_shader_module(&wgpu::include_wgsl!("draw.vert.wgsl")); + + let bgl = ctx + .device + .create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { + label: None, + entries: &[wgpu::BindGroupLayoutEntry { + binding: 0, + ty: wgpu::BindingType::Buffer { + ty: wgpu::BufferBindingType::Storage { read_only: false }, + has_dynamic_offset: false, + min_binding_size: NonZeroU64::new(4), + }, + visibility: wgpu::ShaderStage::VERTEX, + count: None, + }], + }); + + let buffer = ctx.device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size: 4 * expected.len() as u64, + usage: wgpu::BufferUsage::COPY_SRC + | wgpu::BufferUsage::STORAGE + | wgpu::BufferUsage::MAP_READ, + mapped_at_creation: false, + }); + + let bg = ctx.device.create_bind_group(&wgpu::BindGroupDescriptor { + label: None, + layout: &bgl, + entries: &[wgpu::BindGroupEntry { + binding: 0, + resource: buffer.as_entire_binding(), + }], + }); + + let ppl = ctx + .device + .create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { + label: None, + bind_group_layouts: &[&bgl], + push_constant_ranges: &[], + }); + + let pipeline = ctx + .device + .create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: None, + layout: Some(&ppl), + vertex: wgpu::VertexState { + buffers: &[], + entry_point: "vs_main", + module: &shader, + }, + primitive: wgpu::PrimitiveState::default(), + depth_stencil: None, + multisample: wgpu::MultisampleState::default(), + fragment: Some(wgpu::FragmentState { + entry_point: "fs_main", + module: &shader, + targets: &[wgpu::ColorTargetState { + format: wgpu::TextureFormat::Rgba8Unorm, + blend: None, + write_mask: wgpu::ColorWrite::ALL, + }], + }), + }); + + let dummy = ctx + .device + .create_texture_with_data( + &ctx.queue, + &wgpu::TextureDescriptor { + label: Some("dummy"), + size: wgpu::Extent3d { + width: 1, + height: 1, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsage::RENDER_ATTACHMENT | wgpu::TextureUsage::COPY_DST, + }, + &[0, 0, 0, 1], + ) + .create_view(&wgpu::TextureViewDescriptor::default()); + + let mut encoder = ctx + .device + .create_command_encoder(&wgpu::CommandEncoderDescriptor::default()); + + let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + color_attachments: &[wgpu::RenderPassColorAttachment { + ops: wgpu::Operations::default(), + resolve_target: None, + view: &dummy, + }], + depth_stencil_attachment: None, + label: None, + }); + + rpass.set_pipeline(&pipeline); + rpass.set_bind_group(0, &bg, &[]); + function(&mut rpass); + + drop(rpass); + + ctx.queue.submit(Some(encoder.finish())); + let slice = buffer.slice(..); + let _ = slice.map_async(wgpu::MapMode::Read); + ctx.device.poll(wgpu::Maintain::Wait); + let data: Vec = bytemuck::cast_slice(&*slice.get_mapped_range()).to_vec(); + + assert_eq!(data, expected); +} #[test] fn draw() { + initialize_test(TestParameters::default().test_features(), |ctx| { + pulling_common(ctx, &[0, 1, 2, 3, 4, 5], |cmb| { + cmb.draw(0..6, 0..1); + }) + }) +} + +#[test] +fn draw_vertex_offset() { initialize_test( TestParameters::default() - .features( - wgpu::Features::VERTEX_WRITABLE_STORAGE | wgpu::Features::MAPPABLE_PRIMARY_BUFFERS, - ) - .failure(), + .test_features() + .backend_failures(wgpu::BackendBit::DX12 | wgpu::BackendBit::DX11), |ctx| { - let shader = ctx - .device - .create_shader_module(&wgpu::include_wgsl!("draw.vert.wgsl")); - - let bgl = ctx - .device - .create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { - label: None, - entries: &[wgpu::BindGroupLayoutEntry { - binding: 0, - ty: wgpu::BindingType::Buffer { - ty: wgpu::BufferBindingType::Storage { read_only: false }, - has_dynamic_offset: false, - min_binding_size: NonZeroU64::new(4), - }, - visibility: wgpu::ShaderStage::VERTEX, - count: None, - }], - }); - - let buffer = ctx.device.create_buffer(&wgpu::BufferDescriptor { - label: None, - size: 4 * 6, - usage: wgpu::BufferUsage::COPY_SRC - | wgpu::BufferUsage::STORAGE - | wgpu::BufferUsage::MAP_READ, - mapped_at_creation: false, - }); - - let bg = ctx.device.create_bind_group(&wgpu::BindGroupDescriptor { - label: None, - layout: &bgl, - entries: &[wgpu::BindGroupEntry { - binding: 0, - resource: buffer.as_entire_binding(), - }], - }); - - let ppl = ctx - .device - .create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { - label: None, - bind_group_layouts: &[&bgl], - push_constant_ranges: &[], - }); - - let pipeline = ctx - .device - .create_render_pipeline(&wgpu::RenderPipelineDescriptor { - label: None, - layout: Some(&ppl), - vertex: wgpu::VertexState { - buffers: &[], - entry_point: "vs_main", - module: &shader, - }, - primitive: wgpu::PrimitiveState::default(), - depth_stencil: None, - multisample: wgpu::MultisampleState::default(), - fragment: Some(wgpu::FragmentState { - entry_point: "fs_main", - module: &shader, - targets: &[wgpu::ColorTargetState { - format: wgpu::TextureFormat::Rgba8Unorm, - blend: None, - write_mask: wgpu::ColorWrite::ALL, - }], - }), - }); - - let dummy = ctx - .device - .create_texture_with_data( - &ctx.queue, - &wgpu::TextureDescriptor { - label: Some("dummy"), - size: wgpu::Extent3d { - width: 1, - height: 1, - depth_or_array_layers: 1, - }, - mip_level_count: 1, - sample_count: 1, - dimension: wgpu::TextureDimension::D2, - format: wgpu::TextureFormat::Rgba8Unorm, - usage: wgpu::TextureUsage::RENDER_ATTACHMENT | wgpu::TextureUsage::COPY_DST, - }, - &[0, 0, 0, 1], - ) - .create_view(&wgpu::TextureViewDescriptor::default()); - - let mut encoder = ctx - .device - .create_command_encoder(&wgpu::CommandEncoderDescriptor::default()); - - let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { - color_attachments: &[wgpu::RenderPassColorAttachment { - ops: wgpu::Operations::default(), - resolve_target: None, - view: &dummy, - }], - depth_stencil_attachment: None, - label: None, - }); - - rpass.set_pipeline(&pipeline); - rpass.set_bind_group(0, &bg, &[]); - rpass.draw(0..6, 0..1); - - drop(rpass); - - ctx.queue.submit(Some(encoder.finish())); - let slice = buffer.slice(..); - let _ = slice.map_async(wgpu::MapMode::Read); - ctx.device.poll(wgpu::Maintain::Wait); - let data: Vec = bytemuck::cast_slice(&*slice.get_mapped_range()).to_vec(); - - assert_eq!(data, [0, 1, 2, 3, 4, 5]); + pulling_common(ctx, &[0, 1, 2, 3, 4, 5], |cmb| { + cmb.draw(0..3, 0..1); + cmb.draw(3..6, 0..1); + }) + }, + ) +} + +#[test] +fn draw_instanced() { + initialize_test(TestParameters::default().test_features(), |ctx| { + pulling_common(ctx, &[0, 1, 2, 3, 4, 5], |cmb| { + cmb.draw(0..3, 0..2); + }) + }) +} + +#[test] +fn draw_instanced_offset() { + initialize_test( + TestParameters::default() + .test_features() + .backend_failures(wgpu::BackendBit::DX12 | wgpu::BackendBit::DX11), + |ctx| { + pulling_common(ctx, &[0, 1, 2, 3, 4, 5], |cmb| { + cmb.draw(0..3, 0..1); + cmb.draw(0..3, 1..2); + }) }, ) }