D3D12: Add firstVertex/Instance to vertex/instance_index

Added root constants to emulate the behavior of other APIs under D3D12.
This patch only fixed Draw and DrawIndexed.

Bug: dawn:548
Change-Id: Ic759c22e0db1092f890d45c5db489697b1583827
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/37620
Commit-Queue: Enrico Galli <enrico.galli@intel.com>
Reviewed-by: Austin Eng <enga@chromium.org>

src/tests/BUILD.gn

@@ -298,6 +298,7 @@ source_set("dawn_end2end_tests_sources") {
     "end2end/DynamicBufferOffsetTests.cpp",
     "end2end/EntryPointTests.cpp",
     "end2end/FenceTests.cpp",
+    "end2end/FirstIndexOffsetTests.cpp",
     "end2end/GpuMemorySynchronizationTests.cpp",
     "end2end/IndexFormatTests.cpp",
     "end2end/MultisampledRenderingTests.cpp",

src/tests/end2end/FirstIndexOffsetTests.cpp

@@ -0,0 +1,237 @@
+// Copyright 2021 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 <sstream>
+#include <vector>
+
+#include "utils/ComboRenderPipelineDescriptor.h"
+#include "utils/WGPUHelpers.h"
+
+constexpr uint32_t kRTSize = 1;
+
+enum class DrawMode {
+    NonIndexed,
+    Indexed,
+};
+
+enum class CheckIndex : uint32_t {
+    Vertex = 0x0000001,
+    Instance = 0x0000002,
+};
+
+namespace wgpu {
+    template <>
+    struct IsDawnBitmask<CheckIndex> {
+        static constexpr bool enable = true;
+    };
+}  // namespace wgpu
+
+class FirstIndexOffsetTests : public DawnTest {
+  public:
+    void TestVertexIndex(DrawMode mode, uint32_t firstVertex);
+    void TestInstanceIndex(DrawMode mode, uint32_t firstInstance);
+    void TestBothIndices(DrawMode mode, uint32_t firstVertex, uint32_t firstInstance);
+
+  protected:
+    void SetUp() override {
+        DawnTest::SetUp();
+
+        // WGSL doesn't have the ability to tag attributes as "flat". "flat" is required on u32
+        // attributes for correct runtime behavior under Vulkan and codegen under OpenGL(ES).
+        // TODO(tint:451): Remove once resolved by spec/tint
+        DAWN_SKIP_TEST_IF(IsVulkan() || IsOpenGL() || IsOpenGLES());
+    }
+
+  private:
+    void TestImpl(DrawMode mode,
+                  CheckIndex checkIndex,
+                  uint32_t vertexIndex,
+                  uint32_t instanceIndex);
+};
+
+void FirstIndexOffsetTests::TestVertexIndex(DrawMode mode, uint32_t firstVertex) {
+    TestImpl(mode, CheckIndex::Vertex, firstVertex, 0);
+}
+
+void FirstIndexOffsetTests::TestInstanceIndex(DrawMode mode, uint32_t firstInstance) {
+    TestImpl(mode, CheckIndex::Instance, 0, firstInstance);
+}
+
+void FirstIndexOffsetTests::TestBothIndices(DrawMode mode,
+                                            uint32_t firstVertex,
+                                            uint32_t firstInstance) {
+    using wgpu::operator|;
+    TestImpl(mode, CheckIndex::Vertex | CheckIndex::Instance, firstVertex, firstInstance);
+}
+
+// Conditionally tests if first/baseVertex and/or firstInstance have been correctly passed to the
+// vertex shader. Since vertex shaders can't write to storage buffers, we pass vertex/instance
+// indices to a fragment shader via u32 attributes. The fragment shader runs once and writes the
+// values to a storage buffer. If vertex index is used, the vertex buffer is padded with 0s.
+void FirstIndexOffsetTests::TestImpl(DrawMode mode,
+                                     CheckIndex checkIndex,
+                                     uint32_t firstVertex,
+                                     uint32_t firstInstance) {
+    using wgpu::operator&;
+    std::stringstream vertexShader;
+    std::stringstream fragmentShader;
+
+    if ((checkIndex & CheckIndex::Vertex) != 0) {
+        vertexShader << R"(
+        [[builtin(vertex_idx)]] var<in> vertex_index : u32;
+        [[location(1)]] var<out> out_vertex_index : u32;
+        )";
+        fragmentShader << R"(
+        [[location(1)]] var<in> in_vertex_index : u32;
+    )";
+    }
+    if ((checkIndex & CheckIndex::Instance) != 0) {
+        vertexShader << R"(
+            [[builtin(instance_idx)]] var<in> instance_index : u32;
+            [[location(2)]] var<out> out_instance_index : u32;
+            )";
+        fragmentShader << R"(
+            [[location(2)]] var<in> in_instance_index : u32;
+        )";
+    }
+
+    vertexShader << R"(
+        [[builtin(position)]] var<out> position : vec4<f32>;
+        [[location(0)]] var<in> pos : vec4<f32>;
+
+        [[stage(vertex)]] fn main() -> void {)";
+    fragmentShader << R"(
+         [[block]] struct IndexVals {
+             [[offset(0)]] vertex_index : u32;
+             [[offset(4)]] instance_index : u32;
+         };
+
+        [[set(0), binding(0)]] var<storage_buffer> idx_vals : [[access(read_write)]] IndexVals;
+
+        [[stage(fragment)]] fn main() -> void  {
+        )";
+
+    if ((checkIndex & CheckIndex::Vertex) != 0) {
+        vertexShader << R"(
+            out_vertex_index = vertex_index;
+            )";
+        fragmentShader << R"(
+            idx_vals.vertex_index = in_vertex_index;
+            )";
+    }
+    if ((checkIndex & CheckIndex::Instance) != 0) {
+        vertexShader << R"(
+            out_instance_index = instance_index;
+            )";
+        fragmentShader << R"(
+            idx_vals.instance_index = in_instance_index;
+            )";
+    }
+
+    vertexShader << R"(
+            position = pos;
+            return;
+        })";
+
+    fragmentShader << R"(
+            return;
+        })";
+
+    utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
+
+    constexpr uint32_t kComponentsPerVertex = 4;
+
+    utils::ComboRenderPipelineDescriptor pipelineDesc(device);
+    pipelineDesc.vertexStage.module =
+        utils::CreateShaderModuleFromWGSL(device, vertexShader.str().c_str());
+    pipelineDesc.cFragmentStage.module =
+        utils::CreateShaderModuleFromWGSL(device, fragmentShader.str().c_str());
+    pipelineDesc.primitiveTopology = wgpu::PrimitiveTopology::PointList;
+    pipelineDesc.cVertexState.vertexBufferCount = 1;
+    pipelineDesc.cVertexState.cVertexBuffers[0].arrayStride = kComponentsPerVertex * sizeof(float);
+    pipelineDesc.cVertexState.cVertexBuffers[0].attributeCount = 1;
+    pipelineDesc.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
+    pipelineDesc.cColorStates[0].format = renderPass.colorFormat;
+
+    wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&pipelineDesc);
+
+    std::vector<float> vertexData(firstVertex * kComponentsPerVertex);
+    vertexData.insert(vertexData.end(), {0, 0, 0, 1});
+    wgpu::Buffer vertices = utils::CreateBufferFromData(
+        device, vertexData.data(), vertexData.size() * sizeof(float), wgpu::BufferUsage::Vertex);
+    wgpu::Buffer indices =
+        utils::CreateBufferFromData<uint32_t>(device, wgpu::BufferUsage::Index, {0});
+    wgpu::Buffer buffer = utils::CreateBufferFromData(
+        device, wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::Storage, {0u, 0u});
+
+    wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+    wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
+    pass.SetPipeline(pipeline);
+    pass.SetVertexBuffer(0, vertices);
+    pass.SetBindGroup(0,
+                      utils::MakeBindGroup(device, pipeline.GetBindGroupLayout(0), {{0, buffer}}));
+    if (mode == DrawMode::Indexed) {
+        pass.SetIndexBuffer(indices, wgpu::IndexFormat::Uint32);
+        pass.DrawIndexed(1, 1, 0, firstVertex, firstInstance);
+
+    } else {
+        pass.Draw(1, 1, firstVertex, firstInstance);
+    }
+    pass.EndPass();
+    wgpu::CommandBuffer commands = encoder.Finish();
+    queue.Submit(1, &commands);
+
+    std::array<uint32_t, 2> expected = {firstVertex, firstInstance};
+    EXPECT_BUFFER_U32_RANGE_EQ(expected.data(), buffer, 0, expected.size());
+}
+
+// Test that vertex_index starts at 7 when drawn using Draw()
+TEST_P(FirstIndexOffsetTests, NonIndexedVertexOffset) {
+    TestVertexIndex(DrawMode::NonIndexed, 7);
+}
+
+// Test that instance_index starts at 11 when drawn using Draw()
+TEST_P(FirstIndexOffsetTests, NonIndexedInstanceOffset) {
+    TestInstanceIndex(DrawMode::NonIndexed, 11);
+}
+
+// Test that vertex_index and instance_index start at 7 and 11 respectively when drawn using Draw()
+TEST_P(FirstIndexOffsetTests, NonIndexedBothOffset) {
+    TestBothIndices(DrawMode::NonIndexed, 7, 11);
+}
+
+// Test that vertex_index starts at 7 when drawn using DrawIndexed()
+TEST_P(FirstIndexOffsetTests, IndexedVertex) {
+    TestVertexIndex(DrawMode::Indexed, 7);
+}
+
+// Test that instance_index starts at 11 when drawn using DrawIndexed()
+TEST_P(FirstIndexOffsetTests, IndexedInstance) {
+    TestInstanceIndex(DrawMode::Indexed, 11);
+}
+
+// Test that vertex_index and instance_index start at 7 and 11 respectively when drawn using
+// DrawIndexed()
+TEST_P(FirstIndexOffsetTests, IndexedBothOffset) {
+    TestBothIndices(DrawMode::Indexed, 7, 11);
+}
+
+DAWN_INSTANTIATE_TEST(FirstIndexOffsetTests,
+                      D3D12Backend({"use_tint_generator"}),
+                      MetalBackend(),
+                      OpenGLBackend(),
+                      OpenGLESBackend(),
+                      VulkanBackend());