encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

wgpu::InputStepMode -> VertexStepMode 

See https://github.com/gpuweb/gpuweb/pull/1927

Adds a typedef to make a gradual deprecation.

Bug: dawn:1023
Change-Id: Ic81a933a95556fbf5726056530788dde017a1449
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/59442
Reviewed-by: Austin Eng <enga@chromium.org>
Reviewed-by: Stephen White <senorblanco@chromium.org>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
This commit is contained in:
Corentin Wallez 2021-07-25 18:40:19 +00:00 committed by Dawn LUCI CQ
parent f004b6ec2a
commit ff6c9ca6f0
14 changed files with 87 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
dawn.json
View File

@ -1032,7 +1032,7 @@
"extensible": false,
"members": [
{"name": "array stride", "type": "uint64_t"},
{"name": "step mode", "type": "input step mode", "default": "vertex"},
{"name": "step mode", "type": "vertex step mode", "default": "vertex"},
{"name": "attribute count", "type": "uint32_t"},
{"name": "attributes", "type": "vertex attribute", "annotation": "const*", "length": "attribute count"}
]
@ -1042,6 +1042,10 @@
"type": "vertex buffer layout"
},
"input step mode": {
"category": "typedef",
"type": "vertex step mode"
},
"vertex step mode": {
"category": "enum",
"values": [
{"value": 0, "name": "vertex"},

2
examples/ComputeBoids.cpp
View File

@ -127,7 +127,7 @@ void initRender() {
descriptor.vertex.module = vsModule;
descriptor.vertex.bufferCount = 2;
descriptor.cBuffers[0].arrayStride = sizeof(Particle);
descriptor.cBuffers[0].stepMode = wgpu::InputStepMode::Instance;
descriptor.cBuffers[0].stepMode = wgpu::VertexStepMode::Instance;
descriptor.cBuffers[0].attributeCount = 2;
descriptor.cAttributes[0].offset = offsetof(Particle, pos);
descriptor.cAttributes[0].format = wgpu::VertexFormat::Float32x2;

2
generator/templates/dawn_native/wgpu_structs.h
View File

@ -64,7 +64,7 @@ namespace dawn_native {
{% endfor %}
{% for typeDef in by_category["typedef"] %}
{% for typeDef in by_category["typedef"] if typeDef.type.category == "structure" %}
using {{as_cppType(typeDef.name)}} = {{as_cppType(typeDef.type.name)}};
{% endfor %}

7
generator/templates/webgpu.h
View File

@ -74,7 +74,7 @@
#include <stdbool.h>
#define WGPU_WHOLE_SIZE (0xffffffffffffffffULL)
// TODO(crbug.com/520): Remove WGPU_STRIDE_UNDEFINED in favor of WGPU_COPY_STRIDE_UNDEFINED.
// TODO(crbug.com/dawn/520): Remove WGPU_STRIDE_UNDEFINED in favor of WGPU_COPY_STRIDE_UNDEFINED.
#define WGPU_STRIDE_UNDEFINED (0xffffffffUL)
#define WGPU_COPY_STRIDE_UNDEFINED (0xffffffffUL)
@ -124,6 +124,11 @@ typedef struct WGPUChainedStruct {
{% endfor %}
// TODO(crbug.com/dawn/1023): Remove after the deprecation period.
#define WGPUInputStepMode_Vertex WGPUVertexStepMode_Vertex
#define WGPUInputStepMode_Instance WGPUVertexStepMode_Instance
#define WGPUInputStepMode_Force32 WGPUVertexStepMode_Force32
#ifdef __cplusplus
extern "C" {
#endif

6
src/dawn_native/RenderPipeline.cpp
View File

@ -81,7 +81,7 @@ namespace dawn_native {
const VertexBufferLayout* buffer,
const EntryPointMetadata& metadata,
ityp::bitset<VertexAttributeLocation, kMaxVertexAttributes>* attributesSetMask) {
DAWN_TRY(ValidateInputStepMode(buffer->stepMode));
DAWN_TRY(ValidateVertexStepMode(buffer->stepMode));
if (buffer->arrayStride > kMaxVertexBufferArrayStride) {
return DAWN_VALIDATION_ERROR("Setting arrayStride out of bounds");
}
@ -411,10 +411,10 @@ namespace dawn_native {
mVertexBufferInfos[typedSlot].arrayStride = buffers[slot].arrayStride;
mVertexBufferInfos[typedSlot].stepMode = buffers[slot].stepMode;
switch (buffers[slot].stepMode) {
case wgpu::InputStepMode::Vertex:
case wgpu::VertexStepMode::Vertex:
mVertexBufferSlotsUsedAsVertexBuffer.set(typedSlot);
break;
case wgpu::InputStepMode::Instance:
case wgpu::VertexStepMode::Instance:
mVertexBufferSlotsUsedAsInstanceBuffer.set(typedSlot);
break;
default:

2
src/dawn_native/RenderPipeline.h
View File

@ -49,7 +49,7 @@ namespace dawn_native {
struct VertexBufferInfo {
uint64_t arrayStride;
wgpu::InputStepMode stepMode;
wgpu::VertexStepMode stepMode;
};
class RenderPipelineBase : public PipelineBase {

8
src/dawn_native/ShaderModule.cpp
View File

@ -119,11 +119,11 @@ namespace dawn_native {
UNREACHABLE();
}
tint::transform::InputStepMode ToTintInputStepMode(wgpu::InputStepMode mode) {
tint::transform::InputStepMode ToTintVertexStepMode(wgpu::VertexStepMode mode) {
switch (mode) {
case wgpu::InputStepMode::Vertex:
case wgpu::VertexStepMode::Vertex:
return tint::transform::InputStepMode::kVertex;
case wgpu::InputStepMode::Instance:
case wgpu::VertexStepMode::Instance:
return tint::transform::InputStepMode::kInstance;
}
}
@ -1286,7 +1286,7 @@ namespace dawn_native {
const auto& vertexBuffer = vertexState.buffers[i];
tint::transform::VertexBufferLayoutDescriptor layout;
layout.array_stride = vertexBuffer.arrayStride;
layout.step_mode = ToTintInputStepMode(vertexBuffer.stepMode);
layout.step_mode = ToTintVertexStepMode(vertexBuffer.stepMode);
for (uint32_t j = 0; j < vertexBuffer.attributeCount; ++j) {
const auto& attribute = vertexBuffer.attributes[j];

8
src/dawn_native/d3d12/RenderPipelineD3D12.cpp
View File

@ -96,11 +96,11 @@ namespace dawn_native { namespace d3d12 {
}
}
D3D12_INPUT_CLASSIFICATION InputStepModeFunction(wgpu::InputStepMode mode) {
D3D12_INPUT_CLASSIFICATION VertexStepModeFunction(wgpu::VertexStepMode mode) {
switch (mode) {
case wgpu::InputStepMode::Vertex:
case wgpu::VertexStepMode::Vertex:
return D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
case wgpu::InputStepMode::Instance:
case wgpu::VertexStepMode::Instance:
return D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA;
}
}
@ -463,7 +463,7 @@ namespace dawn_native { namespace d3d12 {
const VertexBufferInfo& input = GetVertexBuffer(attribute.vertexBufferSlot);
inputElementDescriptor.AlignedByteOffset = attribute.offset;
inputElementDescriptor.InputSlotClass = InputStepModeFunction(input.stepMode);
inputElementDescriptor.InputSlotClass = VertexStepModeFunction(input.stepMode);
if (inputElementDescriptor.InputSlotClass ==
D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA) {
inputElementDescriptor.InstanceDataStepRate = 0;

8
src/dawn_native/metal/RenderPipelineMTL.mm
View File

@ -91,11 +91,11 @@ namespace dawn_native { namespace metal {
}
}
MTLVertexStepFunction InputStepModeFunction(wgpu::InputStepMode mode) {
MTLVertexStepFunction VertexStepModeFunction(wgpu::VertexStepMode mode) {
switch (mode) {
case wgpu::InputStepMode::Vertex:
case wgpu::VertexStepMode::Vertex:
return MTLVertexStepFunctionPerVertex;
case wgpu::InputStepMode::Instance:
case wgpu::VertexStepMode::Instance:
return MTLVertexStepFunctionPerInstance;
}
}
@ -488,7 +488,7 @@ namespace dawn_native { namespace metal {
// multiple of 4 if it's not.
layoutDesc.stride = Align(maxArrayStride, 4);
} else {
layoutDesc.stepFunction = InputStepModeFunction(info.stepMode);
layoutDesc.stepFunction = VertexStepModeFunction(info.stepMode);
layoutDesc.stepRate = 1;
layoutDesc.stride = info.arrayStride;
}

4
src/dawn_native/opengl/RenderPipelineGL.cpp
View File

@ -267,9 +267,9 @@ namespace dawn_native { namespace opengl {
gl.VertexAttribDivisor(glAttrib, 0xffffffff);
} else {
switch (vertexBuffer.stepMode) {
case wgpu::InputStepMode::Vertex:
case wgpu::VertexStepMode::Vertex:
break;
case wgpu::InputStepMode::Instance:
case wgpu::VertexStepMode::Instance:
gl.VertexAttribDivisor(glAttrib, 1);
break;
}

6
src/dawn_native/vulkan/RenderPipelineVk.cpp
View File

@ -27,11 +27,11 @@ namespace dawn_native { namespace vulkan {
namespace {
VkVertexInputRate VulkanInputRate(wgpu::InputStepMode stepMode) {
VkVertexInputRate VulkanInputRate(wgpu::VertexStepMode stepMode) {
switch (stepMode) {
case wgpu::InputStepMode::Vertex:
case wgpu::VertexStepMode::Vertex:
return VK_VERTEX_INPUT_RATE_VERTEX;
case wgpu::InputStepMode::Instance:
case wgpu::VertexStepMode::Instance:
return VK_VERTEX_INPUT_RATE_INSTANCE;
}
}

85
src/tests/end2end/VertexStateTests.cpp
View File

@ -19,8 +19,8 @@
#include "utils/ComboRenderPipelineDescriptor.h"
#include "utils/WGPUHelpers.h"
using wgpu::InputStepMode;
using wgpu::VertexFormat;
using wgpu::VertexStepMode;
// Input state tests all work the same way: the test will render triangles in a grid up to 4x4. Each
// triangle is position in the grid such that X will correspond to the "triangle number" and the Y
@ -64,7 +64,7 @@ class VertexStateTest : public DawnTest {
struct ShaderTestSpec {
uint32_t location;
VertexFormat format;
InputStepMode step;
VertexStepMode step;
};
wgpu::RenderPipeline MakeTestPipeline(const utils::ComboVertexStateDescriptor& vertexState,
int multiplier,
@ -114,7 +114,7 @@ class VertexStateTest : public DawnTest {
if (ShouldComponentBeDefault(input.format, component)) {
vs << (component == 3 ? "1.0" : "0.0");
} else {
if (input.step == InputStepMode::Vertex) {
if (input.step == VertexStepMode::Vertex) {
vs << "f32(" << multiplier << "u * input.VertexIndex) + " << component
<< ".0";
} else {
@ -161,7 +161,7 @@ class VertexStateTest : public DawnTest {
};
struct VertexBufferSpec {
uint64_t arrayStride;
InputStepMode step;
VertexStepMode step;
std::vector<VertexAttributeSpec> attributes;
};
@ -249,10 +249,11 @@ class VertexStateTest : public DawnTest {
// Test compilation and usage of the fixture :)
TEST_P(VertexStateTest, Basic) {
utils::ComboVertexStateDescriptor vertexState;
MakeVertexState({{4 * sizeof(float), InputStepMode::Vertex, {{0, 0, VertexFormat::Float32x4}}}},
MakeVertexState(
{{4 * sizeof(float), VertexStepMode::Vertex, {{0, 0, VertexFormat::Float32x4}}}},
&vertexState);
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float32x4, InputStepMode::Vertex}});
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float32x4, VertexStepMode::Vertex}});
// clang-format off
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({
@ -270,9 +271,9 @@ TEST_P(VertexStateTest, ZeroStride) {
DAWN_SUPPRESS_TEST_IF(IsLinux() && IsOpenGL());
utils::ComboVertexStateDescriptor vertexState;
MakeVertexState({{0, InputStepMode::Vertex, {{0, 0, VertexFormat::Float32x4}}}}, &vertexState);
MakeVertexState({{0, VertexStepMode::Vertex, {{0, 0, VertexFormat::Float32x4}}}}, &vertexState);
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexState, 0, {{0, VertexFormat::Float32x4, InputStepMode::Vertex}});
MakeTestPipeline(vertexState, 0, {{0, VertexFormat::Float32x4, VertexStepMode::Vertex}});
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({
0,
@ -291,10 +292,10 @@ TEST_P(VertexStateTest, AttributeExpanding) {
// R32F case
{
utils::ComboVertexStateDescriptor vertexState;
MakeVertexState({{0, InputStepMode::Vertex, {{0, 0, VertexFormat::Float32}}}},
MakeVertexState({{0, VertexStepMode::Vertex, {{0, 0, VertexFormat::Float32}}}},
&vertexState);
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexState, 0, {{0, VertexFormat::Float32, InputStepMode::Vertex}});
MakeTestPipeline(vertexState, 0, {{0, VertexFormat::Float32, VertexStepMode::Vertex}});
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({0, 1, 2, 3});
DoTestDraw(pipeline, 1, 1, {DrawVertexBuffer{0, &buffer0}});
@ -302,10 +303,10 @@ TEST_P(VertexStateTest, AttributeExpanding) {
// RG32F case
{
utils::ComboVertexStateDescriptor vertexState;
MakeVertexState({{0, InputStepMode::Vertex, {{0, 0, VertexFormat::Float32x2}}}},
MakeVertexState({{0, VertexStepMode::Vertex, {{0, 0, VertexFormat::Float32x2}}}},
&vertexState);
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexState, 0, {{0, VertexFormat::Float32x2, InputStepMode::Vertex}});
wgpu::RenderPipeline pipeline = MakeTestPipeline(
vertexState, 0, {{0, VertexFormat::Float32x2, VertexStepMode::Vertex}});
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({0, 1, 2, 3});
DoTestDraw(pipeline, 1, 1, {DrawVertexBuffer{0, &buffer0}});
@ -313,10 +314,10 @@ TEST_P(VertexStateTest, AttributeExpanding) {
// RGB32F case
{
utils::ComboVertexStateDescriptor vertexState;
MakeVertexState({{0, InputStepMode::Vertex, {{0, 0, VertexFormat::Float32x3}}}},
MakeVertexState({{0, VertexStepMode::Vertex, {{0, 0, VertexFormat::Float32x3}}}},
&vertexState);
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexState, 0, {{0, VertexFormat::Float32x3, InputStepMode::Vertex}});
wgpu::RenderPipeline pipeline = MakeTestPipeline(
vertexState, 0, {{0, VertexFormat::Float32x3, VertexStepMode::Vertex}});
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({0, 1, 2, 3});
DoTestDraw(pipeline, 1, 1, {DrawVertexBuffer{0, &buffer0}});
@ -329,10 +330,11 @@ TEST_P(VertexStateTest, StrideLargerThanAttributes) {
DAWN_SUPPRESS_TEST_IF(IsLinux() && IsOpenGL());
utils::ComboVertexStateDescriptor vertexState;
MakeVertexState({{8 * sizeof(float), InputStepMode::Vertex, {{0, 0, VertexFormat::Float32x4}}}},
MakeVertexState(
{{8 * sizeof(float), VertexStepMode::Vertex, {{0, 0, VertexFormat::Float32x4}}}},
&vertexState);
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float32x4, InputStepMode::Vertex}});
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float32x4, VertexStepMode::Vertex}});
// clang-format off
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({
@ -349,11 +351,11 @@ TEST_P(VertexStateTest, TwoAttributesAtAnOffsetVertex) {
utils::ComboVertexStateDescriptor vertexState;
MakeVertexState(
{{8 * sizeof(float),
InputStepMode::Vertex,
VertexStepMode::Vertex,
{{0, 0, VertexFormat::Float32x4}, {1, 4 * sizeof(float), VertexFormat::Float32x4}}}},
&vertexState);
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float32x4, InputStepMode::Vertex}});
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float32x4, VertexStepMode::Vertex}});
// clang-format off
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({
@ -370,11 +372,11 @@ TEST_P(VertexStateTest, TwoAttributesAtAnOffsetInstance) {
utils::ComboVertexStateDescriptor vertexState;
MakeVertexState(
{{8 * sizeof(float),
InputStepMode::Instance,
VertexStepMode::Instance,
{{0, 0, VertexFormat::Float32x4}, {1, 4 * sizeof(float), VertexFormat::Float32x4}}}},
&vertexState);
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float32x4, InputStepMode::Instance}});
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float32x4, VertexStepMode::Instance}});
// clang-format off
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({
@ -390,10 +392,10 @@ TEST_P(VertexStateTest, TwoAttributesAtAnOffsetInstance) {
TEST_P(VertexStateTest, PureInstance) {
utils::ComboVertexStateDescriptor vertexState;
MakeVertexState(
{{4 * sizeof(float), InputStepMode::Instance, {{0, 0, VertexFormat::Float32x4}}}},
{{4 * sizeof(float), VertexStepMode::Instance, {{0, 0, VertexFormat::Float32x4}}}},
&vertexState);
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float32x4, InputStepMode::Instance}});
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float32x4, VertexStepMode::Instance}});
// clang-format off
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({
@ -412,18 +414,18 @@ TEST_P(VertexStateTest, MixedEverything) {
utils::ComboVertexStateDescriptor vertexState;
MakeVertexState(
{{12 * sizeof(float),
InputStepMode::Vertex,
VertexStepMode::Vertex,
{{0, 0, VertexFormat::Float32}, {1, 6 * sizeof(float), VertexFormat::Float32x2}}},
{10 * sizeof(float),
InputStepMode::Instance,
VertexStepMode::Instance,
{{2, 0, VertexFormat::Float32x3}, {3, 5 * sizeof(float), VertexFormat::Float32x4}}}},
&vertexState);
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexState, 1,
{{0, VertexFormat::Float32, InputStepMode::Vertex},
{1, VertexFormat::Float32x2, InputStepMode::Vertex},
{2, VertexFormat::Float32x3, InputStepMode::Instance},
{3, VertexFormat::Float32x4, InputStepMode::Instance}});
{{0, VertexFormat::Float32, VertexStepMode::Vertex},
{1, VertexFormat::Float32x2, VertexStepMode::Vertex},
{2, VertexFormat::Float32x3, VertexStepMode::Instance},
{3, VertexFormat::Float32x4, VertexStepMode::Instance}});
// clang-format off
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({
@ -447,11 +449,11 @@ TEST_P(VertexStateTest, UnusedVertexSlot) {
// Instance input state, using slot 1
utils::ComboVertexStateDescriptor instanceVertexState;
MakeVertexState(
{{0, InputStepMode::Vertex, {}},
{4 * sizeof(float), InputStepMode::Instance, {{0, 0, VertexFormat::Float32x4}}}},
{{0, VertexStepMode::Vertex, {}},
{4 * sizeof(float), VertexStepMode::Instance, {{0, 0, VertexFormat::Float32x4}}}},
&instanceVertexState);
wgpu::RenderPipeline instancePipeline = MakeTestPipeline(
instanceVertexState, 1, {{0, VertexFormat::Float32x4, InputStepMode::Instance}});
instanceVertexState, 1, {{0, VertexFormat::Float32x4, VertexStepMode::Instance}});
// clang-format off
wgpu::Buffer buffer = MakeVertexBuffer<float>({
@ -487,19 +489,20 @@ TEST_P(VertexStateTest, UnusedVertexSlot) {
TEST_P(VertexStateTest, MultiplePipelinesMixedVertexState) {
// Basic input state, using slot 0
utils::ComboVertexStateDescriptor vertexVertexState;
MakeVertexState({{4 * sizeof(float), InputStepMode::Vertex, {{0, 0, VertexFormat::Float32x4}}}},
MakeVertexState(
{{4 * sizeof(float), VertexStepMode::Vertex, {{0, 0, VertexFormat::Float32x4}}}},
&vertexVertexState);
wgpu::RenderPipeline vertexPipeline = MakeTestPipeline(
vertexVertexState, 1, {{0, VertexFormat::Float32x4, InputStepMode::Vertex}});
vertexVertexState, 1, {{0, VertexFormat::Float32x4, VertexStepMode::Vertex}});
// Instance input state, using slot 1
utils::ComboVertexStateDescriptor instanceVertexState;
MakeVertexState(
{{0, InputStepMode::Instance, {}},
{4 * sizeof(float), InputStepMode::Instance, {{0, 0, VertexFormat::Float32x4}}}},
{{0, VertexStepMode::Instance, {}},
{4 * sizeof(float), VertexStepMode::Instance, {{0, 0, VertexFormat::Float32x4}}}},
&instanceVertexState);
wgpu::RenderPipeline instancePipeline = MakeTestPipeline(
instanceVertexState, 1, {{0, VertexFormat::Float32x4, InputStepMode::Instance}});
instanceVertexState, 1, {{0, VertexFormat::Float32x4, VertexStepMode::Instance}});
// clang-format off
wgpu::Buffer buffer = MakeVertexBuffer<float>({
@ -539,7 +542,7 @@ TEST_P(VertexStateTest, LastAllowedVertexBuffer) {
// All the other vertex buffers default to no attributes
vertexState.vertexBufferCount = kMaxVertexBuffers;
vertexState.cVertexBuffers[kBufferIndex].arrayStride = 4 * sizeof(float);
vertexState.cVertexBuffers[kBufferIndex].stepMode = InputStepMode::Vertex;
vertexState.cVertexBuffers[kBufferIndex].stepMode = VertexStepMode::Vertex;
vertexState.cVertexBuffers[kBufferIndex].attributeCount = 1;
vertexState.cVertexBuffers[kBufferIndex].attributes = &vertexState.cAttributes[0];
vertexState.cAttributes[0].shaderLocation = 0;
@ -547,7 +550,7 @@ TEST_P(VertexStateTest, LastAllowedVertexBuffer) {
vertexState.cAttributes[0].format = VertexFormat::Float32x4;
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float32x4, InputStepMode::Vertex}});
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float32x4, VertexStepMode::Vertex}});
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5});
DoTestDraw(pipeline, 1, 1, {DrawVertexBuffer{kMaxVertexBuffers - 1, &buffer0}});
@ -559,7 +562,7 @@ TEST_P(VertexStateTest, OverlappingVertexAttributes) {
utils::ComboVertexStateDescriptor vertexState;
MakeVertexState({{16,
InputStepMode::Vertex,
VertexStepMode::Vertex,
{
// "****" represents the bytes we'll actually read in the shader.
{0, 0 /* offset */, VertexFormat::Float32x4}, // |****|----|----|----|

8
src/tests/unittests/validation/DrawVertexAndIndexBufferOOBValidationTests.cpp
View File

@ -72,7 +72,7 @@ namespace {
};
struct PipelineVertexBufferDesc {
uint64_t arrayStride;
wgpu::InputStepMode stepMode;
wgpu::VertexStepMode stepMode;
std::vector<PipelineVertexBufferAttributeDesc> attributes = {};
};
@ -171,7 +171,7 @@ namespace {
DAWN_ASSERT(bufferStride >= kFloat32x4Stride);
std::vector<PipelineVertexBufferDesc> bufferDescList = {
{bufferStride, wgpu::InputStepMode::Vertex, {{0, wgpu::VertexFormat::Float32x4}}},
{bufferStride, wgpu::VertexStepMode::Vertex, {{0, wgpu::VertexFormat::Float32x4}}},
};
return CreateRenderPipelineWithBufferDesc(bufferDescList);
@ -186,9 +186,9 @@ namespace {
DAWN_ASSERT(bufferStride2 >= kFloat32x2Stride);
std::vector<PipelineVertexBufferDesc> bufferDescList = {
{bufferStride1, wgpu::InputStepMode::Vertex, {{0, wgpu::VertexFormat::Float32x4}}},
{bufferStride1, wgpu::VertexStepMode::Vertex, {{0, wgpu::VertexFormat::Float32x4}}},
{bufferStride2,
wgpu::InputStepMode::Instance,
wgpu::VertexStepMode::Instance,
{{3, wgpu::VertexFormat::Float32x2}}},
};

4
src/utils/ComboRenderPipelineDescriptor.cpp
View File

@ -33,7 +33,7 @@ namespace utils {
}
for (uint32_t i = 0; i < kMaxVertexBuffers; ++i) {
cVertexBuffers[i].arrayStride = 0;
cVertexBuffers[i].stepMode = wgpu::InputStepMode::Vertex;
cVertexBuffers[i].stepMode = wgpu::VertexStepMode::Vertex;
cVertexBuffers[i].attributeCount = 0;
cVertexBuffers[i].attributes = nullptr;
}
@ -63,7 +63,7 @@ namespace utils {
}
for (uint32_t i = 0; i < kMaxVertexBuffers; ++i) {
cBuffers[i].arrayStride = 0;
cBuffers[i].stepMode = wgpu::InputStepMode::Vertex;
cBuffers[i].stepMode = wgpu::VertexStepMode::Vertex;
cBuffers[i].attributeCount = 0;
cBuffers[i].attributes = nullptr;
}