| // Copyright 2020 The Dawn Authors |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "tests/DawnTest.h" |
| |
| #include "utils/ComboRenderPipelineDescriptor.h" |
| #include "utils/WGPUHelpers.h" |
| |
| namespace { |
| struct CreatePipelineAsyncTask { |
| wgpu::ComputePipeline computePipeline = nullptr; |
| wgpu::RenderPipeline renderPipeline = nullptr; |
| bool isCompleted = false; |
| std::string message; |
| }; |
| } // anonymous namespace |
| |
| class CreatePipelineAsyncTest : public DawnTest { |
| protected: |
| void ValidateCreateComputePipelineAsync(CreatePipelineAsyncTask* currentTask) { |
| wgpu::BufferDescriptor bufferDesc; |
| bufferDesc.size = sizeof(uint32_t); |
| bufferDesc.usage = wgpu::BufferUsage::Storage | wgpu::BufferUsage::CopySrc; |
| wgpu::Buffer ssbo = device.CreateBuffer(&bufferDesc); |
| |
| wgpu::CommandBuffer commands; |
| { |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); |
| wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); |
| |
| while (!currentTask->isCompleted) { |
| WaitABit(); |
| } |
| ASSERT_TRUE(currentTask->message.empty()); |
| ASSERT_NE(nullptr, currentTask->computePipeline.Get()); |
| wgpu::BindGroup bindGroup = |
| utils::MakeBindGroup(device, currentTask->computePipeline.GetBindGroupLayout(0), |
| { |
| {0, ssbo, 0, sizeof(uint32_t)}, |
| }); |
| pass.SetBindGroup(0, bindGroup); |
| pass.SetPipeline(currentTask->computePipeline); |
| |
| pass.Dispatch(1); |
| pass.EndPass(); |
| |
| commands = encoder.Finish(); |
| } |
| |
| queue.Submit(1, &commands); |
| |
| constexpr uint32_t kExpected = 1u; |
| EXPECT_BUFFER_U32_EQ(kExpected, ssbo, 0); |
| } |
| |
| void ValidateCreateComputePipelineAsync() { |
| ValidateCreateComputePipelineAsync(&task); |
| } |
| |
| void ValidateCreateRenderPipelineAsync(CreatePipelineAsyncTask* currentTask) { |
| constexpr wgpu::TextureFormat kRenderAttachmentFormat = wgpu::TextureFormat::RGBA8Unorm; |
| |
| wgpu::TextureDescriptor textureDescriptor; |
| textureDescriptor.size = {1, 1, 1}; |
| textureDescriptor.format = kRenderAttachmentFormat; |
| textureDescriptor.usage = |
| wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc; |
| wgpu::Texture outputTexture = device.CreateTexture(&textureDescriptor); |
| |
| utils::ComboRenderPassDescriptor renderPassDescriptor({outputTexture.CreateView()}); |
| renderPassDescriptor.cColorAttachments[0].loadOp = wgpu::LoadOp::Clear; |
| renderPassDescriptor.cColorAttachments[0].clearColor = {1.f, 0.f, 0.f, 1.f}; |
| |
| wgpu::CommandBuffer commands; |
| { |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); |
| wgpu::RenderPassEncoder renderPassEncoder = |
| encoder.BeginRenderPass(&renderPassDescriptor); |
| |
| while (!currentTask->isCompleted) { |
| WaitABit(); |
| } |
| ASSERT_TRUE(currentTask->message.empty()); |
| ASSERT_NE(nullptr, currentTask->renderPipeline.Get()); |
| |
| renderPassEncoder.SetPipeline(currentTask->renderPipeline); |
| renderPassEncoder.Draw(1); |
| renderPassEncoder.EndPass(); |
| commands = encoder.Finish(); |
| } |
| |
| queue.Submit(1, &commands); |
| |
| EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), outputTexture, 0, 0); |
| } |
| |
| void ValidateCreateRenderPipelineAsync() { |
| ValidateCreateRenderPipelineAsync(&task); |
| } |
| |
| void DoCreateRenderPipelineAsync( |
| const utils::ComboRenderPipelineDescriptor& renderPipelineDescriptor) { |
| device.CreateRenderPipelineAsync( |
| &renderPipelineDescriptor, |
| [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline returnPipeline, |
| const char* message, void* userdata) { |
| EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Success, |
| status); |
| |
| CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); |
| task->renderPipeline = wgpu::RenderPipeline::Acquire(returnPipeline); |
| task->isCompleted = true; |
| task->message = message; |
| }, |
| &task); |
| } |
| |
| CreatePipelineAsyncTask task; |
| }; |
| |
| // Verify the basic use of CreateComputePipelineAsync works on all backends. |
| TEST_P(CreatePipelineAsyncTest, BasicUseOfCreateComputePipelineAsync) { |
| wgpu::ComputePipelineDescriptor csDesc; |
| csDesc.compute.module = utils::CreateShaderModule(device, R"( |
| struct SSBO { |
| value : u32; |
| }; |
| [[group(0), binding(0)]] var<storage, read_write> ssbo : SSBO; |
| |
| [[stage(compute), workgroup_size(1)]] fn main() { |
| ssbo.value = 1u; |
| })"); |
| csDesc.compute.entryPoint = "main"; |
| |
| device.CreateComputePipelineAsync( |
| &csDesc, |
| [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline returnPipeline, |
| const char* message, void* userdata) { |
| EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Success, status); |
| |
| CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); |
| task->computePipeline = wgpu::ComputePipeline::Acquire(returnPipeline); |
| task->isCompleted = true; |
| task->message = message; |
| }, |
| &task); |
| |
| ValidateCreateComputePipelineAsync(); |
| } |
| |
| // This is a regression test for a bug on the member "entryPoint" of FlatComputePipelineDescriptor. |
| TEST_P(CreatePipelineAsyncTest, ReleaseEntryPointAfterCreatComputePipelineAsync) { |
| wgpu::ComputePipelineDescriptor csDesc; |
| csDesc.compute.module = utils::CreateShaderModule(device, R"( |
| struct SSBO { |
| value : u32; |
| }; |
| [[group(0), binding(0)]] var<storage, read_write> ssbo : SSBO; |
| |
| [[stage(compute), workgroup_size(1)]] fn main() { |
| ssbo.value = 1u; |
| })"); |
| |
| std::string entryPoint = "main"; |
| |
| csDesc.compute.entryPoint = entryPoint.c_str(); |
| |
| device.CreateComputePipelineAsync( |
| &csDesc, |
| [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline returnPipeline, |
| const char* message, void* userdata) { |
| EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Success, status); |
| |
| CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); |
| task->computePipeline = wgpu::ComputePipeline::Acquire(returnPipeline); |
| task->isCompleted = true; |
| task->message = message; |
| }, |
| &task); |
| |
| entryPoint = ""; |
| ValidateCreateComputePipelineAsync(); |
| } |
| |
| // Verify CreateComputePipelineAsync() works as expected when there is any error that happens during |
| // the creation of the compute pipeline. The SPEC requires that during the call of |
| // CreateComputePipelineAsync() any error won't be forwarded to the error scope / unhandled error |
| // callback. |
| TEST_P(CreatePipelineAsyncTest, CreateComputePipelineFailed) { |
| DAWN_TEST_UNSUPPORTED_IF(HasToggleEnabled("skip_validation")); |
| |
| wgpu::ComputePipelineDescriptor csDesc; |
| csDesc.compute.module = utils::CreateShaderModule(device, R"( |
| struct SSBO { |
| value : u32; |
| }; |
| [[group(0), binding(0)]] var<storage, read_write> ssbo : SSBO; |
| |
| [[stage(compute), workgroup_size(1)]] fn main() { |
| ssbo.value = 1u; |
| })"); |
| csDesc.compute.entryPoint = "main0"; |
| |
| device.CreateComputePipelineAsync( |
| &csDesc, |
| [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline returnPipeline, |
| const char* message, void* userdata) { |
| EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Error, status); |
| |
| CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); |
| task->computePipeline = wgpu::ComputePipeline::Acquire(returnPipeline); |
| task->isCompleted = true; |
| task->message = message; |
| }, |
| &task); |
| |
| while (!task.isCompleted) { |
| WaitABit(); |
| } |
| |
| ASSERT_FALSE(task.message.empty()); |
| ASSERT_EQ(nullptr, task.computePipeline.Get()); |
| } |
| |
| // Verify the basic use of CreateRenderPipelineAsync() works on all backends. |
| TEST_P(CreatePipelineAsyncTest, BasicUseOfCreateRenderPipelineAsync) { |
| constexpr wgpu::TextureFormat kRenderAttachmentFormat = wgpu::TextureFormat::RGBA8Unorm; |
| |
| utils::ComboRenderPipelineDescriptor renderPipelineDescriptor; |
| wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"( |
| [[stage(vertex)]] fn main() -> [[builtin(position)]] vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| })"); |
| wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"( |
| [[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> { |
| return vec4<f32>(0.0, 1.0, 0.0, 1.0); |
| })"); |
| renderPipelineDescriptor.vertex.module = vsModule; |
| renderPipelineDescriptor.cFragment.module = fsModule; |
| renderPipelineDescriptor.cTargets[0].format = kRenderAttachmentFormat; |
| renderPipelineDescriptor.primitive.topology = wgpu::PrimitiveTopology::PointList; |
| |
| DoCreateRenderPipelineAsync(renderPipelineDescriptor); |
| |
| ValidateCreateRenderPipelineAsync(); |
| } |
| |
| // Verify the render pipeline created with CreateRenderPipelineAsync() still works when the entry |
| // points are released after the creation of the render pipeline. |
| TEST_P(CreatePipelineAsyncTest, ReleaseEntryPointsAfterCreateRenderPipelineAsync) { |
| constexpr wgpu::TextureFormat kRenderAttachmentFormat = wgpu::TextureFormat::RGBA8Unorm; |
| |
| utils::ComboRenderPipelineDescriptor renderPipelineDescriptor; |
| wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"( |
| [[stage(vertex)]] fn main() -> [[builtin(position)]] vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| })"); |
| wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"( |
| [[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> { |
| return vec4<f32>(0.0, 1.0, 0.0, 1.0); |
| })"); |
| renderPipelineDescriptor.vertex.module = vsModule; |
| renderPipelineDescriptor.cFragment.module = fsModule; |
| renderPipelineDescriptor.cTargets[0].format = kRenderAttachmentFormat; |
| renderPipelineDescriptor.primitive.topology = wgpu::PrimitiveTopology::PointList; |
| |
| std::string vertexEntryPoint = "main"; |
| std::string fragmentEntryPoint = "main"; |
| renderPipelineDescriptor.vertex.entryPoint = vertexEntryPoint.c_str(); |
| renderPipelineDescriptor.cFragment.entryPoint = fragmentEntryPoint.c_str(); |
| |
| DoCreateRenderPipelineAsync(renderPipelineDescriptor); |
| |
| vertexEntryPoint = ""; |
| fragmentEntryPoint = ""; |
| |
| wgpu::TextureDescriptor textureDescriptor; |
| textureDescriptor.size = {1, 1, 1}; |
| textureDescriptor.format = kRenderAttachmentFormat; |
| textureDescriptor.usage = wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc; |
| wgpu::Texture outputTexture = device.CreateTexture(&textureDescriptor); |
| |
| utils::ComboRenderPassDescriptor renderPassDescriptor({outputTexture.CreateView()}); |
| renderPassDescriptor.cColorAttachments[0].loadOp = wgpu::LoadOp::Clear; |
| renderPassDescriptor.cColorAttachments[0].clearColor = {1.f, 0.f, 0.f, 1.f}; |
| |
| wgpu::CommandBuffer commands; |
| { |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); |
| wgpu::RenderPassEncoder renderPassEncoder = encoder.BeginRenderPass(&renderPassDescriptor); |
| |
| while (!task.isCompleted) { |
| WaitABit(); |
| } |
| ASSERT_TRUE(task.message.empty()); |
| ASSERT_NE(nullptr, task.renderPipeline.Get()); |
| |
| renderPassEncoder.SetPipeline(task.renderPipeline); |
| renderPassEncoder.Draw(1); |
| renderPassEncoder.EndPass(); |
| commands = encoder.Finish(); |
| } |
| |
| queue.Submit(1, &commands); |
| |
| EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), outputTexture, 0, 0); |
| } |
| |
| // Verify CreateRenderPipelineAsync() works as expected when there is any error that happens during |
| // the creation of the render pipeline. The SPEC requires that during the call of |
| // CreateRenderPipelineAsync() any error won't be forwarded to the error scope / unhandled error |
| // callback. |
| TEST_P(CreatePipelineAsyncTest, CreateRenderPipelineFailed) { |
| DAWN_TEST_UNSUPPORTED_IF(HasToggleEnabled("skip_validation")); |
| |
| constexpr wgpu::TextureFormat kRenderAttachmentFormat = wgpu::TextureFormat::Depth32Float; |
| |
| utils::ComboRenderPipelineDescriptor renderPipelineDescriptor; |
| wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"( |
| [[stage(vertex)]] fn main() -> [[builtin(position)]] vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| })"); |
| wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"( |
| [[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> { |
| return vec4<f32>(0.0, 1.0, 0.0, 1.0); |
| })"); |
| renderPipelineDescriptor.vertex.module = vsModule; |
| renderPipelineDescriptor.cFragment.module = fsModule; |
| renderPipelineDescriptor.cTargets[0].format = kRenderAttachmentFormat; |
| renderPipelineDescriptor.primitive.topology = wgpu::PrimitiveTopology::PointList; |
| |
| device.CreateRenderPipelineAsync( |
| &renderPipelineDescriptor, |
| [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline returnPipeline, |
| const char* message, void* userdata) { |
| EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Error, status); |
| |
| CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); |
| task->renderPipeline = wgpu::RenderPipeline::Acquire(returnPipeline); |
| task->isCompleted = true; |
| task->message = message; |
| }, |
| &task); |
| |
| while (!task.isCompleted) { |
| WaitABit(); |
| } |
| |
| ASSERT_FALSE(task.message.empty()); |
| ASSERT_EQ(nullptr, task.computePipeline.Get()); |
| } |
| |
| // Verify there is no error when the device is released before the callback of |
| // CreateComputePipelineAsync() is called. |
| TEST_P(CreatePipelineAsyncTest, ReleaseDeviceBeforeCallbackOfCreateComputePipelineAsync) { |
| wgpu::ComputePipelineDescriptor csDesc; |
| csDesc.compute.module = utils::CreateShaderModule(device, R"( |
| [[stage(compute), workgroup_size(1)]] fn main() { |
| })"); |
| csDesc.compute.entryPoint = "main"; |
| |
| device.CreateComputePipelineAsync( |
| &csDesc, |
| [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline returnPipeline, |
| const char* message, void* userdata) { |
| EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_DeviceDestroyed, |
| status); |
| |
| CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); |
| task->computePipeline = wgpu::ComputePipeline::Acquire(returnPipeline); |
| task->isCompleted = true; |
| task->message = message; |
| }, |
| &task); |
| } |
| |
| // Verify there is no error when the device is released before the callback of |
| // CreateRenderPipelineAsync() is called. |
| TEST_P(CreatePipelineAsyncTest, ReleaseDeviceBeforeCallbackOfCreateRenderPipelineAsync) { |
| utils::ComboRenderPipelineDescriptor renderPipelineDescriptor; |
| wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"( |
| [[stage(vertex)]] fn main() -> [[builtin(position)]] vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| })"); |
| wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"( |
| [[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> { |
| return vec4<f32>(0.0, 1.0, 0.0, 1.0); |
| })"); |
| renderPipelineDescriptor.vertex.module = vsModule; |
| renderPipelineDescriptor.cFragment.module = fsModule; |
| renderPipelineDescriptor.cTargets[0].format = wgpu::TextureFormat::RGBA8Unorm; |
| renderPipelineDescriptor.primitive.topology = wgpu::PrimitiveTopology::PointList; |
| |
| device.CreateRenderPipelineAsync( |
| &renderPipelineDescriptor, |
| [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline returnPipeline, |
| const char* message, void* userdata) { |
| EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_DeviceDestroyed, |
| status); |
| |
| CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); |
| task->renderPipeline = wgpu::RenderPipeline::Acquire(returnPipeline); |
| task->isCompleted = true; |
| task->message = message; |
| }, |
| &task); |
| } |
| |
| // Verify there is no error when the device is destroyed before the callback of |
| // CreateComputePipelineAsync() is called. |
| TEST_P(CreatePipelineAsyncTest, DestroyDeviceBeforeCallbackOfCreateComputePipelineAsync) { |
| wgpu::ComputePipelineDescriptor csDesc; |
| csDesc.compute.module = utils::CreateShaderModule(device, R"( |
| [[stage(compute), workgroup_size(1)]] fn main() { |
| })"); |
| csDesc.compute.entryPoint = "main"; |
| |
| device.CreateComputePipelineAsync( |
| &csDesc, |
| [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline returnPipeline, |
| const char* message, void* userdata) { |
| EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_DeviceDestroyed, |
| status); |
| |
| CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); |
| task->computePipeline = wgpu::ComputePipeline::Acquire(returnPipeline); |
| task->isCompleted = true; |
| task->message = message; |
| }, |
| &task); |
| ExpectDeviceDestruction(); |
| device.Destroy(); |
| } |
| |
| // Verify there is no error when the device is destroyed before the callback of |
| // CreateRenderPipelineAsync() is called. |
| TEST_P(CreatePipelineAsyncTest, DestroyDeviceBeforeCallbackOfCreateRenderPipelineAsync) { |
| utils::ComboRenderPipelineDescriptor renderPipelineDescriptor; |
| wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"( |
| [[stage(vertex)]] fn main() -> [[builtin(position)]] vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| })"); |
| wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"( |
| [[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> { |
| return vec4<f32>(0.0, 1.0, 0.0, 1.0); |
| })"); |
| renderPipelineDescriptor.vertex.module = vsModule; |
| renderPipelineDescriptor.cFragment.module = fsModule; |
| renderPipelineDescriptor.cTargets[0].format = wgpu::TextureFormat::RGBA8Unorm; |
| renderPipelineDescriptor.primitive.topology = wgpu::PrimitiveTopology::PointList; |
| |
| device.CreateRenderPipelineAsync( |
| &renderPipelineDescriptor, |
| [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline returnPipeline, |
| const char* message, void* userdata) { |
| EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_DeviceDestroyed, |
| status); |
| |
| CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); |
| task->renderPipeline = wgpu::RenderPipeline::Acquire(returnPipeline); |
| task->isCompleted = true; |
| task->message = message; |
| }, |
| &task); |
| ExpectDeviceDestruction(); |
| device.Destroy(); |
| } |
| |
| // Verify the code path of CreateComputePipelineAsync() to directly return the compute pipeline |
| // object from cache works correctly. |
| TEST_P(CreatePipelineAsyncTest, CreateSameComputePipelineTwice) { |
| wgpu::ComputePipelineDescriptor csDesc; |
| csDesc.compute.module = utils::CreateShaderModule(device, R"( |
| struct SSBO { |
| value : u32; |
| }; |
| [[group(0), binding(0)]] var<storage, read_write> ssbo : SSBO; |
| |
| [[stage(compute), workgroup_size(1)]] fn main() { |
| ssbo.value = 1u; |
| })"); |
| csDesc.compute.entryPoint = "main"; |
| |
| auto callback = [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline returnPipeline, |
| const char* message, void* userdata) { |
| EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Success, status); |
| |
| CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); |
| task->computePipeline = wgpu::ComputePipeline::Acquire(returnPipeline); |
| task->isCompleted = true; |
| task->message = message; |
| }; |
| |
| // Create a pipeline object and save it into anotherTask.computePipeline. |
| CreatePipelineAsyncTask anotherTask; |
| device.CreateComputePipelineAsync(&csDesc, callback, &anotherTask); |
| while (!anotherTask.isCompleted) { |
| WaitABit(); |
| } |
| ASSERT_TRUE(anotherTask.message.empty()); |
| ASSERT_NE(nullptr, anotherTask.computePipeline.Get()); |
| |
| // Create another pipeline object task.comnputepipeline with the same compute pipeline |
| // descriptor used in the creation of anotherTask.computePipeline. This time the pipeline |
| // object should be directly got from the pipeline object cache. |
| device.CreateComputePipelineAsync(&csDesc, callback, &task); |
| ValidateCreateComputePipelineAsync(); |
| } |
| |
| // Verify creating compute pipeline with same descriptor and CreateComputePipelineAsync() at the |
| // same time works correctly. |
| TEST_P(CreatePipelineAsyncTest, CreateSameComputePipelineTwiceAtSameTime) { |
| wgpu::BindGroupLayoutEntry binding = {}; |
| binding.binding = 0; |
| binding.buffer.type = wgpu::BufferBindingType::Storage; |
| binding.visibility = wgpu::ShaderStage::Compute; |
| |
| wgpu::BindGroupLayoutDescriptor desc = {}; |
| desc.entryCount = 1; |
| desc.entries = &binding; |
| |
| wgpu::BindGroupLayout bindGroupLayout = device.CreateBindGroupLayout(&desc); |
| |
| wgpu::PipelineLayoutDescriptor pipelineLayoutDesc = {}; |
| pipelineLayoutDesc.bindGroupLayoutCount = 1; |
| pipelineLayoutDesc.bindGroupLayouts = &bindGroupLayout; |
| |
| wgpu::PipelineLayout pipelineLayout = device.CreatePipelineLayout(&pipelineLayoutDesc); |
| |
| wgpu::ComputePipelineDescriptor csDesc; |
| csDesc.layout = pipelineLayout; |
| csDesc.compute.module = utils::CreateShaderModule(device, R"( |
| struct SSBO { |
| value : u32; |
| }; |
| [[group(0), binding(0)]] var<storage, read_write> ssbo : SSBO; |
| |
| [[stage(compute), workgroup_size(1)]] fn main() { |
| ssbo.value = 1u; |
| })"); |
| csDesc.compute.entryPoint = "main"; |
| |
| auto callback = [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline returnPipeline, |
| const char* message, void* userdata) { |
| EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Success, status); |
| |
| CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); |
| task->computePipeline = wgpu::ComputePipeline::Acquire(returnPipeline); |
| task->isCompleted = true; |
| task->message = message; |
| }; |
| |
| // Create two pipeline objects with same descriptor. |
| CreatePipelineAsyncTask anotherTask; |
| device.CreateComputePipelineAsync(&csDesc, callback, &task); |
| device.CreateComputePipelineAsync(&csDesc, callback, &anotherTask); |
| |
| // Verify both task.computePipeline and anotherTask.computePipeline are created correctly. |
| ValidateCreateComputePipelineAsync(&anotherTask); |
| ValidateCreateComputePipelineAsync(&task); |
| |
| // Verify task.computePipeline and anotherTask.computePipeline are pointing to the same Dawn |
| // object. |
| if (!UsesWire()) { |
| EXPECT_EQ(task.computePipeline.Get(), anotherTask.computePipeline.Get()); |
| } |
| } |
| |
| // Verify the basic use of CreateRenderPipelineAsync() works on all backends. |
| TEST_P(CreatePipelineAsyncTest, CreateSameRenderPipelineTwiceAtSameTime) { |
| constexpr wgpu::TextureFormat kRenderAttachmentFormat = wgpu::TextureFormat::RGBA8Unorm; |
| |
| utils::ComboRenderPipelineDescriptor renderPipelineDescriptor; |
| wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"( |
| [[stage(vertex)]] fn main() -> [[builtin(position)]] vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| })"); |
| wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"( |
| [[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> { |
| return vec4<f32>(0.0, 1.0, 0.0, 1.0); |
| })"); |
| renderPipelineDescriptor.vertex.module = vsModule; |
| renderPipelineDescriptor.cFragment.module = fsModule; |
| renderPipelineDescriptor.cTargets[0].format = kRenderAttachmentFormat; |
| renderPipelineDescriptor.primitive.topology = wgpu::PrimitiveTopology::PointList; |
| |
| auto callback = [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline returnPipeline, |
| const char* message, void* userdata) { |
| EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Success, status); |
| |
| CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata); |
| task->renderPipeline = wgpu::RenderPipeline::Acquire(returnPipeline); |
| task->isCompleted = true; |
| task->message = message; |
| }; |
| |
| // Create two render pipelines with same descriptor. |
| CreatePipelineAsyncTask anotherTask; |
| device.CreateRenderPipelineAsync(&renderPipelineDescriptor, callback, &task); |
| device.CreateRenderPipelineAsync(&renderPipelineDescriptor, callback, &anotherTask); |
| |
| // Verify task.renderPipeline and anotherTask.renderPipeline are both created correctly. |
| ValidateCreateRenderPipelineAsync(&task); |
| ValidateCreateRenderPipelineAsync(&anotherTask); |
| |
| // Verify task.renderPipeline and anotherTask.renderPipeline are pointing to the same Dawn |
| // object. |
| if (!UsesWire()) { |
| EXPECT_EQ(task.renderPipeline.Get(), anotherTask.renderPipeline.Get()); |
| } |
| } |
| |
| // Verify calling CreateRenderPipelineAsync() with valid VertexBufferLayouts works on all backends. |
| TEST_P(CreatePipelineAsyncTest, CreateRenderPipelineAsyncWithVertexBufferLayouts) { |
| wgpu::TextureDescriptor textureDescriptor; |
| textureDescriptor.size = {1, 1, 1}; |
| textureDescriptor.format = wgpu::TextureFormat::RGBA8Unorm; |
| textureDescriptor.usage = wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc; |
| wgpu::Texture renderTarget = device.CreateTexture(&textureDescriptor); |
| wgpu::TextureView renderTargetView = renderTarget.CreateView(); |
| |
| utils::ComboRenderPassDescriptor renderPass({renderTargetView}); |
| { |
| utils::ComboRenderPipelineDescriptor renderPipelineDescriptor; |
| renderPipelineDescriptor.vertex.module = utils::CreateShaderModule(device, R"( |
| struct VertexInput { |
| [[location(0)]] input0: u32; |
| [[location(1)]] input1: u32; |
| }; |
| |
| struct VertexOutput { |
| [[location(0)]] vertexColorOut: vec4<f32>; |
| [[builtin(position)]] position: vec4<f32>; |
| }; |
| |
| [[stage(vertex)]] |
| fn main(vertexInput : VertexInput) -> VertexOutput { |
| var vertexOutput : VertexOutput; |
| vertexOutput.position = vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| if (vertexInput.input0 == 1u && vertexInput.input1 == 2u) { |
| vertexOutput.vertexColorOut = vec4<f32>(0.0, 1.0, 0.0, 1.0); |
| } else { |
| vertexOutput.vertexColorOut = vec4<f32>(1.0, 0.0, 0.0, 1.0); |
| } |
| return vertexOutput; |
| })"); |
| renderPipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"( |
| [[stage(fragment)]] |
| fn main([[location(0)]] fragColorIn : vec4<f32>) -> [[location(0)]] vec4<f32> { |
| return fragColorIn; |
| })"); |
| |
| renderPipelineDescriptor.primitive.topology = wgpu::PrimitiveTopology::PointList; |
| renderPipelineDescriptor.cFragment.targetCount = 1; |
| renderPipelineDescriptor.cTargets[0].format = wgpu::TextureFormat::RGBA8Unorm; |
| |
| // Create a render pipeline with two VertexBufferLayouts |
| renderPipelineDescriptor.vertex.buffers = renderPipelineDescriptor.cBuffers.data(); |
| renderPipelineDescriptor.vertex.bufferCount = 2; |
| renderPipelineDescriptor.cBuffers[0].attributeCount = 1; |
| renderPipelineDescriptor.cBuffers[0].attributes = &renderPipelineDescriptor.cAttributes[0]; |
| renderPipelineDescriptor.cAttributes[0].format = wgpu::VertexFormat::Uint32; |
| renderPipelineDescriptor.cAttributes[0].shaderLocation = 0; |
| renderPipelineDescriptor.cBuffers[1].attributeCount = 1; |
| renderPipelineDescriptor.cBuffers[1].attributes = &renderPipelineDescriptor.cAttributes[1]; |
| renderPipelineDescriptor.cAttributes[1].format = wgpu::VertexFormat::Uint32; |
| renderPipelineDescriptor.cAttributes[1].shaderLocation = 1; |
| |
| DoCreateRenderPipelineAsync(renderPipelineDescriptor); |
| } |
| |
| wgpu::Buffer vertexBuffer1 = utils::CreateBufferFromData( |
| device, wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Vertex, {1u}); |
| wgpu::Buffer vertexBuffer2 = utils::CreateBufferFromData( |
| device, wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Vertex, {2u}); |
| |
| // Do the draw call with the render pipeline |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); |
| { |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); |
| |
| while (!task.isCompleted) { |
| WaitABit(); |
| } |
| ASSERT_TRUE(task.message.empty()); |
| ASSERT_NE(nullptr, task.renderPipeline.Get()); |
| pass.SetPipeline(task.renderPipeline); |
| |
| pass.SetVertexBuffer(0, vertexBuffer1); |
| pass.SetVertexBuffer(1, vertexBuffer2); |
| pass.Draw(1); |
| pass.EndPass(); |
| } |
| |
| wgpu::CommandBuffer commands = encoder.Finish(); |
| queue.Submit(1, &commands); |
| |
| // The color attachment will have the expected color when the vertex attribute values are |
| // fetched correctly. |
| EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), renderTarget, 0, 0); |
| } |
| |
| // Verify calling CreateRenderPipelineAsync() with valid depthStencilState works on all backends. |
| TEST_P(CreatePipelineAsyncTest, CreateRenderPipelineAsyncWithDepthStencilState) { |
| wgpu::TextureDescriptor textureDescriptor; |
| textureDescriptor.size = {1, 1, 1}; |
| textureDescriptor.format = wgpu::TextureFormat::RGBA8Unorm; |
| textureDescriptor.usage = wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc; |
| wgpu::Texture renderTarget = device.CreateTexture(&textureDescriptor); |
| wgpu::TextureView renderTargetView = renderTarget.CreateView(); |
| |
| textureDescriptor.format = wgpu::TextureFormat::Depth24PlusStencil8; |
| wgpu::Texture depthStencilTarget = device.CreateTexture(&textureDescriptor); |
| wgpu::TextureView depthStencilView = depthStencilTarget.CreateView(); |
| |
| // Clear the color attachment to green and the stencil aspect of the depth stencil attachment |
| // to 0. |
| utils::ComboRenderPassDescriptor renderPass({renderTargetView}, depthStencilView); |
| renderPass.cColorAttachments[0].loadOp = wgpu::LoadOp::Clear; |
| renderPass.cColorAttachments[0].clearColor = {0.0, 1.0, 0.0, 1.0}; |
| renderPass.cDepthStencilAttachmentInfo.stencilLoadOp = wgpu::LoadOp::Clear; |
| renderPass.cDepthStencilAttachmentInfo.clearStencil = 0u; |
| |
| wgpu::RenderPipeline pipeline; |
| { |
| utils::ComboRenderPipelineDescriptor renderPipelineDescriptor; |
| renderPipelineDescriptor.vertex.module = utils::CreateShaderModule(device, R"( |
| [[stage(vertex)]] |
| fn main() -> [[builtin(position)]] vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| })"); |
| renderPipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"( |
| [[stage(fragment)]] |
| fn main() -> [[location(0)]] vec4<f32> { |
| return vec4<f32>(1.0, 0.0, 0.0, 1.0); |
| })"); |
| |
| renderPipelineDescriptor.primitive.topology = wgpu::PrimitiveTopology::PointList; |
| renderPipelineDescriptor.cFragment.targetCount = 1; |
| renderPipelineDescriptor.cTargets[0].format = wgpu::TextureFormat::RGBA8Unorm; |
| |
| // Create a render pipeline with stencil compare function "Equal". |
| renderPipelineDescriptor.depthStencil = &renderPipelineDescriptor.cDepthStencil; |
| renderPipelineDescriptor.cDepthStencil.stencilFront.compare = wgpu::CompareFunction::Equal; |
| |
| DoCreateRenderPipelineAsync(renderPipelineDescriptor); |
| } |
| |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); |
| { |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); |
| |
| while (!task.isCompleted) { |
| WaitABit(); |
| } |
| ASSERT_TRUE(task.message.empty()); |
| ASSERT_NE(nullptr, task.renderPipeline.Get()); |
| pass.SetPipeline(task.renderPipeline); |
| |
| // The stencil reference is set to 1, so there should be no pixel that can pass the stencil |
| // test. |
| pass.SetStencilReference(1); |
| |
| pass.Draw(1); |
| pass.EndPass(); |
| } |
| |
| wgpu::CommandBuffer commands = encoder.Finish(); |
| queue.Submit(1, &commands); |
| |
| // The color in the color attachment should not be changed after the draw call as no pixel can |
| // pass the stencil test. |
| EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), renderTarget, 0, 0); |
| } |
| |
| // Verify calling CreateRenderPipelineAsync() with multisample.Count > 1 works on all backends. |
| TEST_P(CreatePipelineAsyncTest, CreateRenderPipelineWithMultisampleState) { |
| wgpu::TextureDescriptor textureDescriptor; |
| textureDescriptor.size = {1, 1, 1}; |
| textureDescriptor.format = wgpu::TextureFormat::RGBA8Unorm; |
| textureDescriptor.usage = wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc; |
| wgpu::Texture resolveTarget = device.CreateTexture(&textureDescriptor); |
| wgpu::TextureView resolveTargetView = resolveTarget.CreateView(); |
| |
| textureDescriptor.sampleCount = 4; |
| wgpu::Texture renderTarget = device.CreateTexture(&textureDescriptor); |
| wgpu::TextureView renderTargetView = renderTarget.CreateView(); |
| |
| // Set the multi-sampled render target, its resolve target to render pass and clear color to |
| // (1, 0, 0, 1). |
| utils::ComboRenderPassDescriptor renderPass({renderTargetView}); |
| renderPass.cColorAttachments[0].loadOp = wgpu::LoadOp::Clear; |
| renderPass.cColorAttachments[0].clearColor = {1.0, 0.0, 0.0, 1.0}; |
| renderPass.cColorAttachments[0].resolveTarget = resolveTargetView; |
| |
| wgpu::RenderPipeline pipeline; |
| { |
| utils::ComboRenderPipelineDescriptor renderPipelineDescriptor; |
| renderPipelineDescriptor.vertex.module = utils::CreateShaderModule(device, R"( |
| [[stage(vertex)]] |
| fn main() -> [[builtin(position)]] vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| })"); |
| renderPipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"( |
| [[stage(fragment)]] |
| fn main() -> [[location(0)]] vec4<f32> { |
| return vec4<f32>(0.0, 1.0, 0.0, 1.0); |
| })"); |
| |
| renderPipelineDescriptor.primitive.topology = wgpu::PrimitiveTopology::PointList; |
| renderPipelineDescriptor.cFragment.targetCount = 1; |
| renderPipelineDescriptor.cTargets[0].format = wgpu::TextureFormat::RGBA8Unorm; |
| |
| // Create a render pipeline with multisample.count == 4. |
| renderPipelineDescriptor.multisample.count = 4; |
| |
| DoCreateRenderPipelineAsync(renderPipelineDescriptor); |
| } |
| |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); |
| { |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); |
| |
| while (!task.isCompleted) { |
| WaitABit(); |
| } |
| ASSERT_TRUE(task.message.empty()); |
| ASSERT_NE(nullptr, task.renderPipeline.Get()); |
| pass.SetPipeline(task.renderPipeline); |
| |
| pass.Draw(6); |
| pass.EndPass(); |
| } |
| |
| wgpu::CommandBuffer commands = encoder.Finish(); |
| queue.Submit(1, &commands); |
| |
| // The color in resolveTarget should be the expected color (0, 1, 0, 1). |
| EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), resolveTarget, 0, 0); |
| } |
| |
| // Verify calling CreateRenderPipelineAsync() with valid BlendState works on all backends. |
| TEST_P(CreatePipelineAsyncTest, CreateRenderPipelineAsyncWithBlendState) { |
| DAWN_TEST_UNSUPPORTED_IF(HasToggleEnabled("disable_indexed_draw_buffers")); |
| |
| std::array<wgpu::Texture, 2> renderTargets; |
| std::array<wgpu::TextureView, 2> renderTargetViews; |
| |
| { |
| wgpu::TextureDescriptor textureDescriptor; |
| textureDescriptor.size = {1, 1, 1}; |
| textureDescriptor.format = wgpu::TextureFormat::RGBA8Unorm; |
| textureDescriptor.usage = |
| wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc; |
| |
| for (uint32_t i = 0; i < renderTargets.size(); ++i) { |
| renderTargets[i] = device.CreateTexture(&textureDescriptor); |
| renderTargetViews[i] = renderTargets[i].CreateView(); |
| } |
| } |
| |
| // Prepare two color attachments |
| utils::ComboRenderPassDescriptor renderPass({renderTargetViews[0], renderTargetViews[1]}); |
| renderPass.cColorAttachments[0].loadOp = wgpu::LoadOp::Clear; |
| renderPass.cColorAttachments[0].clearColor = {0.2, 0.0, 0.0, 0.2}; |
| renderPass.cColorAttachments[1].loadOp = wgpu::LoadOp::Clear; |
| renderPass.cColorAttachments[1].clearColor = {0.0, 0.2, 0.0, 0.2}; |
| |
| { |
| utils::ComboRenderPipelineDescriptor renderPipelineDescriptor; |
| renderPipelineDescriptor.vertex.module = utils::CreateShaderModule(device, R"( |
| [[stage(vertex)]] |
| fn main() -> [[builtin(position)]] vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| })"); |
| renderPipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"( |
| struct FragmentOut { |
| [[location(0)]] fragColor0 : vec4<f32>; |
| [[location(1)]] fragColor1 : vec4<f32>; |
| }; |
| |
| [[stage(fragment)]] fn main() -> FragmentOut { |
| var output : FragmentOut; |
| output.fragColor0 = vec4<f32>(0.4, 0.0, 0.0, 0.4); |
| output.fragColor1 = vec4<f32>(0.0, 1.0, 0.0, 1.0); |
| return output; |
| })"); |
| |
| renderPipelineDescriptor.primitive.topology = wgpu::PrimitiveTopology::PointList; |
| |
| // Create a render pipeline with blending states |
| renderPipelineDescriptor.cFragment.targetCount = renderTargets.size(); |
| |
| // The blend operation for the first render target is "add". |
| wgpu::BlendComponent blendComponent0; |
| blendComponent0.operation = wgpu::BlendOperation::Add; |
| blendComponent0.srcFactor = wgpu::BlendFactor::One; |
| blendComponent0.dstFactor = wgpu::BlendFactor::One; |
| |
| wgpu::BlendState blend0; |
| blend0.color = blendComponent0; |
| blend0.alpha = blendComponent0; |
| |
| // The blend operation for the first render target is "subtract". |
| wgpu::BlendComponent blendComponent1; |
| blendComponent1.operation = wgpu::BlendOperation::Subtract; |
| blendComponent1.srcFactor = wgpu::BlendFactor::One; |
| blendComponent1.dstFactor = wgpu::BlendFactor::One; |
| |
| wgpu::BlendState blend1; |
| blend1.color = blendComponent1; |
| blend1.alpha = blendComponent1; |
| |
| renderPipelineDescriptor.cTargets[0].blend = &blend0; |
| renderPipelineDescriptor.cTargets[0].format = wgpu::TextureFormat::RGBA8Unorm; |
| renderPipelineDescriptor.cTargets[1].blend = &blend1; |
| renderPipelineDescriptor.cTargets[1].format = wgpu::TextureFormat::RGBA8Unorm; |
| |
| DoCreateRenderPipelineAsync(renderPipelineDescriptor); |
| } |
| |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); |
| { |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); |
| |
| while (!task.isCompleted) { |
| WaitABit(); |
| } |
| ASSERT_TRUE(task.message.empty()); |
| ASSERT_NE(nullptr, task.renderPipeline.Get()); |
| pass.SetPipeline(task.renderPipeline); |
| |
| pass.Draw(1); |
| pass.EndPass(); |
| } |
| |
| wgpu::CommandBuffer commands = encoder.Finish(); |
| queue.Submit(1, &commands); |
| |
| // When the blend states are all set correctly, the color of renderTargets[0] should be |
| // (0.6, 0, 0, 0.6) = colorAttachment0.clearColor + (0.4, 0.0, 0.0, 0.4), and the color of |
| // renderTargets[1] should be (0.8, 0, 0, 0.8) = (1, 0, 0, 1) - colorAttachment1.clearColor. |
| RGBA8 expected0 = {153, 0, 0, 153}; |
| RGBA8 expected1 = {0, 204, 0, 204}; |
| EXPECT_PIXEL_RGBA8_EQ(expected0, renderTargets[0], 0, 0); |
| EXPECT_PIXEL_RGBA8_EQ(expected1, renderTargets[1], 0, 0); |
| } |
| |
| DAWN_INSTANTIATE_TEST(CreatePipelineAsyncTest, |
| D3D12Backend(), |
| MetalBackend(), |
| OpenGLBackend(), |
| OpenGLESBackend(), |
| VulkanBackend()); |
