| // Copyright 2024 The Dawn & Tint Authors |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // 1. Redistributions of source code must retain the above copyright notice, this |
| // list of conditions and the following disclaimer. |
| // |
| // 2. Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // |
| // 3. Neither the name of the copyright holder nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #include <vector> |
| |
| #include "dawn/tests/DawnTest.h" |
| #include "dawn/utils/ComboRenderBundleEncoderDescriptor.h" |
| #include "dawn/utils/ComboRenderPipelineDescriptor.h" |
| #include "dawn/utils/WGPUHelpers.h" |
| |
| namespace dawn { |
| namespace { |
| |
| constexpr uint32_t kRTSize = 4; |
| |
| class MultiDrawIndexedIndirectTest : public DawnTest { |
| protected: |
| wgpu::RequiredLimits GetRequiredLimits(const wgpu::SupportedLimits& supported) override { |
| // Force larger limits, that might reach into the upper 32 bits of the 64bit limit values, |
| // to help detect integer arithmetic bugs like overflows and truncations. |
| wgpu::RequiredLimits required = {}; |
| required.limits = supported.limits; |
| return required; |
| } |
| |
| std::vector<wgpu::FeatureName> GetRequiredFeatures() override { |
| if (!SupportsFeatures({wgpu::FeatureName::MultiDrawIndirect})) { |
| return {}; |
| } |
| return {wgpu::FeatureName::MultiDrawIndirect}; |
| } |
| |
| void SetUp() override { |
| DawnTest::SetUp(); |
| DAWN_TEST_UNSUPPORTED_IF(!device.HasFeature(wgpu::FeatureName::MultiDrawIndirect)); |
| |
| renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); |
| |
| wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"( |
| @vertex |
| fn main(@location(0) pos : vec4f) -> @builtin(position) vec4f { |
| return pos; |
| })"); |
| |
| wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"( |
| @fragment fn main() -> @location(0) vec4f { |
| return vec4f(0.0, 1.0, 0.0, 1.0); |
| })"); |
| |
| utils::ComboRenderPipelineDescriptor descriptor; |
| descriptor.vertex.module = vsModule; |
| descriptor.cFragment.module = fsModule; |
| descriptor.primitive.topology = wgpu::PrimitiveTopology::TriangleStrip; |
| descriptor.primitive.stripIndexFormat = wgpu::IndexFormat::Uint32; |
| descriptor.vertex.bufferCount = 1; |
| descriptor.cBuffers[0].arrayStride = 4 * sizeof(float); |
| descriptor.cBuffers[0].attributeCount = 1; |
| descriptor.cAttributes[0].format = wgpu::VertexFormat::Float32x4; |
| descriptor.cTargets[0].format = renderPass.colorFormat; |
| |
| pipeline = device.CreateRenderPipeline(&descriptor); |
| |
| vertexBuffer = utils::CreateBufferFromData<float>( |
| device, wgpu::BufferUsage::Vertex, |
| {// First quad: the first 3 vertices represent the bottom left triangle |
| -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, -1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f, |
| 0.0f, 1.0f, |
| |
| // Second quad: the first 3 vertices represent the top right triangle |
| -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, -1.0f, -1.0f, |
| 0.0f, 1.0f}); |
| } |
| |
| utils::BasicRenderPass renderPass; |
| wgpu::RenderPipeline pipeline; |
| wgpu::Buffer vertexBuffer; |
| |
| wgpu::Buffer CreateIndirectBuffer(std::initializer_list<uint32_t> indirectParamList) { |
| return utils::CreateBufferFromData<uint32_t>( |
| device, wgpu::BufferUsage::Indirect | wgpu::BufferUsage::Storage, indirectParamList); |
| } |
| |
| wgpu::Buffer CreateIndexBuffer(std::initializer_list<uint32_t> indexList) { |
| return utils::CreateBufferFromData<uint32_t>(device, wgpu::BufferUsage::Index, indexList); |
| } |
| |
| wgpu::CommandBuffer EncodeDrawCommands(std::initializer_list<uint32_t> bufferList, |
| wgpu::Buffer indexBuffer, |
| uint64_t indexOffset, |
| uint64_t indirectOffset, |
| uint32_t maxDrawCount, |
| wgpu::Buffer drawCountBuffer = nullptr, |
| uint64_t drawCountOffset = 0) { |
| wgpu::Buffer indirectBuffer = CreateIndirectBuffer(bufferList); |
| |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); |
| { |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo); |
| pass.SetPipeline(pipeline); |
| pass.SetVertexBuffer(0, vertexBuffer); |
| pass.SetIndexBuffer(indexBuffer, wgpu::IndexFormat::Uint32, indexOffset); |
| pass.MultiDrawIndexedIndirect(indirectBuffer, indirectOffset, maxDrawCount, |
| drawCountBuffer, drawCountOffset); |
| pass.End(); |
| } |
| |
| return encoder.Finish(); |
| } |
| |
| void TestDraw(wgpu::CommandBuffer commands, |
| utils::RGBA8 bottomLeftExpected, |
| utils::RGBA8 topRightExpected) { |
| queue.Submit(1, &commands); |
| |
| EXPECT_PIXEL_RGBA8_EQ(bottomLeftExpected, renderPass.color, 1, 3); |
| EXPECT_PIXEL_RGBA8_EQ(topRightExpected, renderPass.color, 3, 1); |
| } |
| |
| void Test(std::initializer_list<uint32_t> bufferList, |
| uint64_t indexOffset, |
| uint64_t indirectOffset, |
| uint32_t maxDrawCount, |
| utils::RGBA8 bottomLeftExpected, |
| utils::RGBA8 topRightExpected) { |
| wgpu::Buffer indexBuffer = |
| CreateIndexBuffer({0, 1, 2, 0, 3, 1, |
| // The indices below are added to test negative baseVertex |
| 0 + 4, 1 + 4, 2 + 4, 0 + 4, 3 + 4, 1 + 4}); |
| TestDraw( |
| EncodeDrawCommands(bufferList, indexBuffer, indexOffset, indirectOffset, maxDrawCount), |
| bottomLeftExpected, topRightExpected); |
| } |
| }; |
| |
| // The most basic DrawIndexed triangle draw. |
| TEST_P(MultiDrawIndexedIndirectTest, Uint32) { |
| utils::RGBA8 filled(0, 255, 0, 255); |
| utils::RGBA8 notFilled(0, 0, 0, 0); |
| |
| // Test a draw with no indices. |
| Test({0, 0, 0, 0, 0}, 0, 0, 1, notFilled, notFilled); |
| |
| // Test a draw with only the first 3 indices of the first quad (bottom left triangle) |
| Test({3, 1, 0, 0, 0}, 0, 0, 1, filled, notFilled); |
| |
| // Test a draw with only the last 3 indices of the first quad (top right triangle) |
| Test({3, 1, 3, 0, 0}, 0, 0, 1, notFilled, filled); |
| |
| // Test a draw with all 6 indices (both triangles). |
| Test({6, 1, 0, 0, 0}, 0, 0, 1, filled, filled); |
| } |
| |
| // Test the parameter 'baseVertex' of DrawIndexed() works. |
| TEST_P(MultiDrawIndexedIndirectTest, BaseVertex) { |
| utils::RGBA8 filled(0, 255, 0, 255); |
| utils::RGBA8 notFilled(0, 0, 0, 0); |
| |
| // Test a draw with only the first 3 indices of the second quad (top right triangle) |
| Test({3, 1, 0, 4, 0}, 0, 0, 1, notFilled, filled); |
| |
| // Test a draw with only the last 3 indices of the second quad (bottom left triangle) |
| Test({3, 1, 3, 4, 0}, 0, 0, 1, filled, notFilled); |
| |
| const int negFour = -4; |
| uint32_t unsignedNegFour; |
| std::memcpy(&unsignedNegFour, &negFour, sizeof(int)); |
| |
| // Test negative baseVertex |
| // Test a draw with only the first 3 indices of the first quad (bottom left triangle) |
| Test({3, 1, 0, unsignedNegFour, 0}, 6 * sizeof(uint32_t), 0, 1, filled, notFilled); |
| |
| // Test a draw with only the last 3 indices of the first quad (top right triangle) |
| Test({3, 1, 3, unsignedNegFour, 0}, 6 * sizeof(uint32_t), 0, 1, notFilled, filled); |
| |
| // Test a draw with only the last 3 indices of the first quad (top right triangle) and offset |
| Test({0, 3, 1, 3, unsignedNegFour, 0}, 6 * sizeof(uint32_t), 1 * sizeof(uint32_t), 1, notFilled, |
| filled); |
| } |
| |
| TEST_P(MultiDrawIndexedIndirectTest, IndirectOffset) { |
| utils::RGBA8 filled(0, 255, 0, 255); |
| utils::RGBA8 notFilled(0, 0, 0, 0); |
| |
| // Test an offset draw call, with indirect buffer containing 2 calls: |
| // 1) first 3 indices of the second quad (top right triangle) |
| // 2) last 3 indices of the second quad |
| |
| // Test #1 (no offset) |
| Test({3, 1, 0, 4, 0, 3, 1, 3, 4, 0}, 0, 0, 1, notFilled, filled); |
| |
| // Offset to draw #2 |
| Test({3, 1, 0, 4, 0, 3, 1, 3, 4, 0}, 0, 5 * sizeof(uint32_t), 1, filled, notFilled); |
| } |
| |
| // The basic triangle draw with various drawCount. |
| TEST_P(MultiDrawIndexedIndirectTest, DrawCount) { |
| // TODO(crbug.com/356461286): NVIDIA Drivers for Vulkan Linux are drawing more than specified. |
| DAWN_SUPPRESS_TEST_IF(IsLinux() && IsNvidia() && IsVulkan()); |
| |
| utils::RGBA8 filled(0, 255, 0, 255); |
| utils::RGBA8 notFilled(0, 0, 0, 0); |
| wgpu::Buffer indexBuffer = CreateIndexBuffer({0, 1, 2, 0, 3, 1}); |
| // Create a drawCount buffer with various values. |
| wgpu::Buffer drawCountBuffer = CreateIndirectBuffer({0, 1, 2}); |
| // Test a draw with drawCount = 0, which should not draw anything. |
| TestDraw(EncodeDrawCommands({3, 1, 0, 0, 0, 3, 1, 3, 0, 0}, indexBuffer, 0, 0, 2, |
| drawCountBuffer, 0), |
| notFilled, notFilled); |
| // Test a draw with drawCount = 1 where drawCount < maxDrawCount. |
| TestDraw(EncodeDrawCommands({3, 1, 0, 0, 0, 3, 1, 3, 0, 0}, indexBuffer, 0, 0, 2, |
| drawCountBuffer, 4), |
| filled, notFilled); |
| // Test a draw with drawCount = 2 where drawCount = maxDrawCount. |
| TestDraw(EncodeDrawCommands({3, 1, 0, 0, 0, 3, 1, 3, 0, 0}, indexBuffer, 0, 0, 2, |
| drawCountBuffer, 8), |
| filled, filled); |
| // Test a draw with drawCount = 2 where drawCount > maxDrawCount. |
| TestDraw(EncodeDrawCommands({3, 1, 0, 0, 0, 3, 1, 3, 0, 0}, indexBuffer, 0, 0, 1, |
| drawCountBuffer, 8), |
| filled, notFilled); |
| // Test a draw without drawCount buffer. Should draw maxDrawCount times. |
| TestDraw(EncodeDrawCommands({3, 1, 0, 0, 0, 3, 1, 3, 0, 0}, indexBuffer, 0, 0, 2), filled, |
| filled); |
| } |
| |
| TEST_P(MultiDrawIndexedIndirectTest, ValidateWithOffsets) { |
| // It doesn't make sense to test invalid inputs when validation is disabled. |
| DAWN_SUPPRESS_TEST_IF(HasToggleEnabled("skip_validation")); |
| |
| utils::RGBA8 filled(0, 255, 0, 255); |
| utils::RGBA8 notFilled(0, 0, 0, 0); |
| |
| wgpu::Buffer indexBuffer = CreateIndexBuffer({0, 1, 2, 0, 3, 1, 0, 1, 2}); |
| |
| // Test that validation properly accounts for index buffer offset. |
| TestDraw(EncodeDrawCommands({3, 1, 0, 0, 0}, indexBuffer, 6 * sizeof(uint32_t), 0, 1), filled, |
| notFilled); |
| TestDraw(EncodeDrawCommands({4, 1, 0, 0, 0}, indexBuffer, 6 * sizeof(uint32_t), 0, 1), |
| notFilled, notFilled); |
| TestDraw(EncodeDrawCommands({3, 1, 4, 0, 0}, indexBuffer, 3 * sizeof(uint32_t), 0, 1), |
| notFilled, notFilled); |
| |
| // Test that validation properly accounts for indirect buffer offset. |
| TestDraw(EncodeDrawCommands({3, 1, 0, 0, 0, 1000, 1, 0, 0, 0}, indexBuffer, 0, |
| 4 * sizeof(uint32_t), 1), |
| notFilled, notFilled); |
| TestDraw(EncodeDrawCommands({3, 1, 0, 0, 0, 1000, 1, 0, 0, 0}, indexBuffer, 0, 0, 1), filled, |
| notFilled); |
| } |
| |
| TEST_P(MultiDrawIndexedIndirectTest, ValidateMultiplePasses) { |
| // It doesn't make sense to test invalid inputs when validation is disabled. |
| DAWN_SUPPRESS_TEST_IF(HasToggleEnabled("skip_validation")); |
| |
| utils::RGBA8 filled(0, 255, 0, 255); |
| utils::RGBA8 notFilled(0, 0, 0, 0); |
| |
| wgpu::Buffer indexBuffer = CreateIndexBuffer({0, 1, 2, 0, 3, 1, 0, 1, 2}); |
| |
| // Test validation with multiple passes in a row. Namely this is exercising that scratch buffer |
| // data for use with a previous pass's validation commands is not overwritten before it can be |
| // used. |
| TestDraw(EncodeDrawCommands({10, 1, 0, 0, 0, 3, 1, 9, 0, 0}, indexBuffer, 0, 0, 2), notFilled, |
| notFilled); |
| TestDraw(EncodeDrawCommands({3, 1, 6, 0, 0, 3, 1, 0, 0, 0}, indexBuffer, 0, 0, 2), filled, |
| notFilled); |
| TestDraw(EncodeDrawCommands({4, 1, 6, 0, 0, 3, 1, 3, 0, 0}, indexBuffer, 0, 0, 2), notFilled, |
| filled); |
| TestDraw(EncodeDrawCommands({6, 1, 6, 0, 0, 6, 1, 6, 0, 0}, indexBuffer, 0, 0, 2), notFilled, |
| notFilled); |
| TestDraw(EncodeDrawCommands({3, 1, 3, 0, 0}, indexBuffer, 0, 0, 1), notFilled, filled); |
| TestDraw(EncodeDrawCommands({6, 1, 0, 0, 0}, indexBuffer, 0, 0, 1), filled, filled); |
| } |
| |
| TEST_P(MultiDrawIndexedIndirectTest, ValidateEncodeMultipleThenSubmitInOrder) { |
| // It doesn't make sense to test invalid inputs when validation is disabled. |
| DAWN_SUPPRESS_TEST_IF(HasToggleEnabled("skip_validation")); |
| |
| utils::RGBA8 filled(0, 255, 0, 255); |
| utils::RGBA8 notFilled(0, 0, 0, 0); |
| |
| wgpu::Buffer indexBuffer = CreateIndexBuffer({0, 1, 2, 0, 3, 1, 0, 1, 2}); |
| |
| wgpu::CommandBuffer commands[6]; |
| commands[0] = EncodeDrawCommands({10, 1, 0, 0, 0, 3, 1, 9, 0, 0}, indexBuffer, 0, 0, 2); |
| commands[1] = EncodeDrawCommands({3, 1, 6, 0, 0, 3, 1, 0, 0, 0}, indexBuffer, 0, 0, 2); |
| commands[2] = EncodeDrawCommands({4, 1, 6, 0, 0, 3, 1, 3, 0, 0}, indexBuffer, 0, 0, 2); |
| commands[3] = EncodeDrawCommands({6, 1, 6, 0, 0, 6, 1, 6, 0, 0}, indexBuffer, 0, 0, 2); |
| commands[4] = EncodeDrawCommands({3, 1, 3, 0, 0}, indexBuffer, 0, 0, 1); |
| commands[5] = EncodeDrawCommands({6, 1, 0, 0, 0}, indexBuffer, 0, 0, 1); |
| |
| TestDraw(commands[0], notFilled, notFilled); |
| TestDraw(commands[1], filled, notFilled); |
| TestDraw(commands[2], notFilled, filled); |
| TestDraw(commands[3], notFilled, notFilled); |
| TestDraw(commands[4], notFilled, filled); |
| TestDraw(commands[5], filled, filled); |
| } |
| |
| TEST_P(MultiDrawIndexedIndirectTest, ValidateEncodeMultipleThenSubmitOutOfOrder) { |
| // It doesn't make sense to test invalid inputs when validation is disabled. |
| DAWN_SUPPRESS_TEST_IF(HasToggleEnabled("skip_validation")); |
| |
| utils::RGBA8 filled(0, 255, 0, 255); |
| utils::RGBA8 notFilled(0, 0, 0, 0); |
| |
| wgpu::Buffer indexBuffer = CreateIndexBuffer({0, 1, 2, 0, 3, 1, 0, 1, 2}); |
| |
| wgpu::CommandBuffer commands[6]; |
| commands[0] = EncodeDrawCommands({10, 1, 0, 0, 0, 3, 1, 9, 0, 0}, indexBuffer, 0, 0, 2); |
| commands[1] = EncodeDrawCommands({3, 1, 6, 0, 0, 3, 1, 0, 0, 0}, indexBuffer, 0, 0, 2); |
| commands[2] = EncodeDrawCommands({4, 1, 6, 0, 0, 3, 1, 3, 0, 0}, indexBuffer, 0, 0, 2); |
| commands[3] = EncodeDrawCommands({6, 1, 6, 0, 0, 6, 1, 6, 0, 0}, indexBuffer, 0, 0, 2); |
| commands[4] = EncodeDrawCommands({3, 1, 3, 0, 0}, indexBuffer, 0, 0, 1); |
| commands[5] = EncodeDrawCommands({6, 1, 0, 0, 0}, indexBuffer, 0, 0, 1); |
| |
| TestDraw(commands[0], notFilled, notFilled); |
| TestDraw(commands[4], notFilled, filled); |
| TestDraw(commands[2], notFilled, filled); |
| TestDraw(commands[5], filled, filled); |
| TestDraw(commands[1], filled, notFilled); |
| TestDraw(commands[3], notFilled, notFilled); |
| } |
| |
| TEST_P(MultiDrawIndexedIndirectTest, ValidateEncodeMultipleThenSubmitAtOnce) { |
| // It doesn't make sense to test invalid inputs when validation is disabled. |
| DAWN_SUPPRESS_TEST_IF(HasToggleEnabled("skip_validation")); |
| |
| utils::RGBA8 filled(0, 255, 0, 255); |
| utils::RGBA8 notFilled(0, 0, 0, 0); |
| |
| wgpu::Buffer indexBuffer = CreateIndexBuffer({0, 1, 2, 0, 3, 1, 0, 1, 2}); |
| |
| wgpu::CommandBuffer commands[5]; |
| commands[0] = EncodeDrawCommands({10, 1, 0, 0, 0, 3, 1, 9, 0, 0}, indexBuffer, 0, 0, 2); |
| commands[1] = EncodeDrawCommands({3, 1, 6, 0, 0, 3, 1, 0, 0, 0}, indexBuffer, 0, 0, 2); |
| commands[2] = EncodeDrawCommands({4, 1, 6, 0, 0, 3, 1, 3, 0, 0}, indexBuffer, 0, 0, 2); |
| commands[3] = EncodeDrawCommands({6, 1, 6, 0, 0, 6, 1, 6, 0, 0}, indexBuffer, 0, 0, 2); |
| commands[4] = EncodeDrawCommands({3, 1, 3, 0, 0}, indexBuffer, 0, 0, 1); |
| |
| queue.Submit(5, commands); |
| EXPECT_PIXEL_RGBA8_EQ(notFilled, renderPass.color, 1, 3); |
| EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color, 3, 1); |
| } |
| |
| TEST_P(MultiDrawIndexedIndirectTest, ValidateMultiDrawMixed) { |
| // It doesn't make sense to test invalid inputs when validation is disabled. |
| DAWN_SUPPRESS_TEST_IF(HasToggleEnabled("skip_validation")); |
| |
| utils::RGBA8 filled(0, 255, 0, 255); |
| utils::RGBA8 notFilled(0, 0, 0, 0); |
| |
| // Test that the multi draw does not affect the single draw and vice versa. |
| |
| wgpu::Buffer indexBuffer = CreateIndexBuffer({0, 1, 2, 0, 3, 1}); |
| |
| wgpu::Buffer indirectBuffer = |
| CreateIndirectBuffer({3, 1, 6, 0, 0, 0, 0, 0, 0, 0, 3, 1, 3, 0, 0}); |
| |
| wgpu::Buffer drawCountBuffer = CreateIndirectBuffer({0, 1, 2}); |
| |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo); |
| pass.SetPipeline(pipeline); |
| pass.SetVertexBuffer(0, vertexBuffer); |
| pass.SetIndexBuffer(indexBuffer, wgpu::IndexFormat::Uint32, 0); |
| pass.MultiDrawIndirect(indirectBuffer, 0, 2, nullptr); |
| pass.MultiDrawIndexedIndirect(indirectBuffer, 20, 2, drawCountBuffer, 8); |
| pass.End(); |
| wgpu::CommandBuffer commands = encoder.Finish(); |
| queue.Submit(1, &commands); |
| |
| EXPECT_PIXEL_RGBA8_EQ(notFilled, renderPass.color, 1, 3); |
| EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color, 3, 1); |
| } |
| |
| TEST_P(MultiDrawIndexedIndirectTest, ValidateMultiAndSingleDrawsInSingleRenderPass) { |
| // It doesn't make sense to test invalid inputs when validation is disabled. |
| DAWN_SUPPRESS_TEST_IF(HasToggleEnabled("skip_validation")); |
| |
| utils::RGBA8 filled(0, 255, 0, 255); |
| |
| // Test that the multi draw does not affect the single draw and vice versa. |
| |
| wgpu::Buffer indexBuffer = CreateIndexBuffer({0, 1, 2, 0, 3, 1}); |
| |
| wgpu::Buffer indirectBuffer = |
| CreateIndirectBuffer({3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 3, 0, 0}); |
| |
| wgpu::Buffer drawCountBuffer = CreateIndirectBuffer({0, 1, 2}); |
| |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo); |
| pass.SetPipeline(pipeline); |
| pass.SetVertexBuffer(0, vertexBuffer); |
| pass.SetIndexBuffer(indexBuffer, wgpu::IndexFormat::Uint32, 0); |
| pass.DrawIndexedIndirect(indirectBuffer, 0); // draw the first triangle |
| pass.DrawIndirect(indirectBuffer, 16); // no draw |
| pass.MultiDrawIndexedIndirect(indirectBuffer, 20, 2, drawCountBuffer, 8); // draw the second |
| pass.MultiDrawIndirect(indirectBuffer, 28, 2, nullptr); // no draw |
| pass.End(); |
| wgpu::CommandBuffer commands = encoder.Finish(); |
| queue.Submit(1, &commands); |
| |
| EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color, 1, 3); |
| EXPECT_PIXEL_RGBA8_EQ(filled, renderPass.color, 3, 1); |
| } |
| |
| DAWN_INSTANTIATE_TEST(MultiDrawIndexedIndirectTest, |
| VulkanBackend(), |
| D3D12Backend(), |
| MetalBackend()); |
| |
| class MultiDrawIndexedIndirectUsingFirstVertexTest : public DawnTest { |
| protected: |
| std::vector<wgpu::FeatureName> GetRequiredFeatures() override { |
| if (!SupportsFeatures({wgpu::FeatureName::MultiDrawIndirect})) { |
| return {}; |
| } |
| return {wgpu::FeatureName::MultiDrawIndirect}; |
| } |
| virtual void SetupShaderModule() { |
| vsModule = utils::CreateShaderModule(device, R"( |
| struct VertexInput { |
| @builtin(vertex_index) id : u32, |
| @location(0) pos: vec4f, |
| }; |
| @group(0) @binding(0) var<uniform> offset: array<vec4f, 2>; |
| @vertex |
| fn main(input: VertexInput) -> @builtin(position) vec4f { |
| return input.pos + offset[input.id / 3u]; |
| })"); |
| fsModule = utils::CreateShaderModule(device, R"( |
| @fragment fn main() -> @location(0) vec4f { |
| return vec4f(0.0, 1.0, 0.0, 1.0); |
| })"); |
| } |
| void GeneralSetup() { |
| renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); |
| SetupShaderModule(); |
| utils::ComboRenderPipelineDescriptor descriptor; |
| descriptor.vertex.module = vsModule; |
| descriptor.cFragment.module = fsModule; |
| descriptor.primitive.topology = wgpu::PrimitiveTopology::TriangleStrip; |
| descriptor.primitive.stripIndexFormat = wgpu::IndexFormat::Uint32; |
| descriptor.vertex.bufferCount = 1; |
| descriptor.cBuffers[0].arrayStride = 4 * sizeof(float); |
| descriptor.cBuffers[0].attributeCount = 1; |
| descriptor.cAttributes[0].format = wgpu::VertexFormat::Float32x4; |
| descriptor.cTargets[0].format = renderPass.colorFormat; |
| |
| pipeline = device.CreateRenderPipeline(&descriptor); |
| |
| // Offset to the vertices, that needs correcting by the calibration offset from uniform |
| // buffer referenced by instance index to get filled triangle on screen. |
| constexpr float calibration = 99.0f; |
| vertexBuffer = dawn::utils::CreateBufferFromData<float>( |
| device, wgpu::BufferUsage::Vertex, |
| {// The bottom left triangle |
| -1.0f - calibration, 1.0f, 0.0f, 1.0f, 1.0f - calibration, -1.0f, 0.0f, 1.0f, |
| -1.0f - calibration, -1.0f, 0.0f, 1.0f, |
| // The top right triangle |
| -1.0f - calibration, 1.0f, 0.0f, 1.0f, 1.0f - calibration, -1.0f, 0.0f, 1.0f, |
| 1.0f - calibration, 1.0f, 0.0f, 1.0f}); |
| |
| indexBuffer = dawn::utils::CreateBufferFromData<uint32_t>(device, wgpu::BufferUsage::Index, |
| {0, 1, 2}); |
| |
| // Providing calibration vec4f offset values |
| wgpu::Buffer uniformBuffer = |
| utils::CreateBufferFromData<float>(device, wgpu::BufferUsage::Uniform, |
| { |
| // Bad calibration at [0] |
| 0.0, |
| 0.0, |
| 0.0, |
| 0.0, |
| // Good calibration at [1] |
| calibration, |
| 0.0, |
| 0.0, |
| 0.0, |
| }); |
| |
| bindGroup = |
| utils::MakeBindGroup(device, pipeline.GetBindGroupLayout(0), {{0, uniformBuffer}}); |
| } |
| void SetUp() override { |
| DawnTest::SetUp(); |
| DAWN_TEST_UNSUPPORTED_IF(!device.HasFeature(wgpu::FeatureName::MultiDrawIndirect)); |
| GeneralSetup(); |
| } |
| utils::BasicRenderPass renderPass; |
| wgpu::RenderPipeline pipeline; |
| wgpu::Buffer vertexBuffer; |
| wgpu::Buffer indexBuffer; |
| wgpu::BindGroup bindGroup; |
| wgpu::ShaderModule vsModule; |
| wgpu::ShaderModule fsModule; |
| // Test two DrawIndirect calls with different indirect offsets within one pass. |
| void Test(std::initializer_list<uint32_t> bufferList, |
| uint32_t maxDrawCount, |
| utils::RGBA8 bottomLeftExpected, |
| utils::RGBA8 topRightExpected) { |
| wgpu::Buffer indirectBuffer = |
| utils::CreateBufferFromData<uint32_t>(device, wgpu::BufferUsage::Indirect, bufferList); |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); |
| { |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo); |
| pass.SetPipeline(pipeline); |
| pass.SetVertexBuffer(0, vertexBuffer); |
| pass.SetBindGroup(0, bindGroup); |
| pass.SetIndexBuffer(indexBuffer, wgpu::IndexFormat::Uint32, 0); |
| pass.MultiDrawIndexedIndirect(indirectBuffer, 0, maxDrawCount, nullptr, 0); |
| pass.End(); |
| } |
| wgpu::CommandBuffer commands = encoder.Finish(); |
| queue.Submit(1, &commands); |
| EXPECT_PIXEL_RGBA8_EQ(bottomLeftExpected, renderPass.color, 1, 3); |
| EXPECT_PIXEL_RGBA8_EQ(topRightExpected, renderPass.color, 3, 1); |
| } |
| }; |
| |
| TEST_P(MultiDrawIndexedIndirectUsingFirstVertexTest, IndirectOffset) { |
| utils::RGBA8 filled(0, 255, 0, 255); |
| utils::RGBA8 notFilled(0, 0, 0, 0); |
| |
| // Test an offset draw call, with indirect buffer containing 2 calls: |
| // 1) only the first 3 indices (bottom left triangle) |
| // 2) only the last 3 indices (top right triangle) |
| // #2 draw has the correct offset applied by vertex index |
| Test({3, 1, 0, 0, 0, 3, 1, 0, 3, 0}, 2, notFilled, filled); |
| } |
| |
| DAWN_INSTANTIATE_TEST(MultiDrawIndexedIndirectUsingFirstVertexTest, |
| VulkanBackend(), |
| D3D12Backend(), |
| MetalBackend()); |
| |
| class MultiDrawIndexedIndirectUsingInstanceIndexTest |
| : public MultiDrawIndexedIndirectUsingFirstVertexTest { |
| protected: |
| std::vector<wgpu::FeatureName> GetRequiredFeatures() override { |
| if (!SupportsFeatures({wgpu::FeatureName::MultiDrawIndirect})) { |
| return {}; |
| } |
| return {wgpu::FeatureName::MultiDrawIndirect}; |
| } |
| |
| void SetupShaderModule() override { |
| vsModule = utils::CreateShaderModule(device, R"( |
| struct VertexInput { |
| @builtin(instance_index) id : u32, |
| @location(0) pos: vec4f, |
| }; |
| |
| @group(0) @binding(0) var<uniform> offset: array<vec4f, 2>; |
| |
| @vertex |
| fn main(input: VertexInput) -> @builtin(position) vec4f { |
| return input.pos + offset[input.id]; |
| })"); |
| |
| fsModule = utils::CreateShaderModule(device, R"( |
| @fragment fn main() -> @location(0) vec4f { |
| return vec4f(0.0, 1.0, 0.0, 1.0); |
| })"); |
| } |
| |
| void SetUp() override { |
| DawnTest::SetUp(); |
| DAWN_TEST_UNSUPPORTED_IF(!device.HasFeature(wgpu::FeatureName::MultiDrawIndirect)); |
| GeneralSetup(); |
| } |
| }; |
| |
| TEST_P(MultiDrawIndexedIndirectUsingInstanceIndexTest, IndirectOffset) { |
| utils::RGBA8 filled(0, 255, 0, 255); |
| utils::RGBA8 notFilled(0, 0, 0, 0); |
| |
| // Test an offset draw call, with indirect buffer containing 2 calls: |
| // 1) only the first 3 indices (bottom left triangle) |
| // 2) only the last 3 indices (top right triangle) |
| |
| // Test 1: #1 draw has the correct calibration referenced by instance index |
| Test({3, 1, 0, 0, 1, 3, 1, 0, 3, 0}, 2, filled, notFilled); |
| |
| // Test 2: #2 draw has the correct offset applied by instance index |
| Test({3, 1, 0, 0, 0, 3, 1, 0, 3, 1}, 2, notFilled, filled); |
| } |
| |
| DAWN_INSTANTIATE_TEST(MultiDrawIndexedIndirectUsingInstanceIndexTest, |
| VulkanBackend(), |
| D3D12Backend(), |
| MetalBackend()); |
| |
| } // anonymous namespace |
| } // namespace dawn |
