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

Update naming for vertex state 

- VertexInputDescriptor -> VertexStateDescriptor
- VertexBufferDescriptor -> VertexBufferLayoutDescriptor
- VertexBufferDescriptor.stride -> .arrayStride
- VertexAttributeDescriptor.offset no longer optional

gpuweb PR: https://github.com/gpuweb/gpuweb/pull/469

Bug: dawn:22
Change-Id: I5431df4ba22cfbdb1bc81e6709e562cd736892a3
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/13100
Commit-Queue: Kai Ninomiya <kainino@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
This commit is contained in:
Kai Ninomiya 2019-11-07 22:23:29 +00:00 committed by Commit Bot service account
parent c3284fa40e
commit ae1f25fee8
39 changed files with 507 additions and 497 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
BUILD.gn
View File

@ -839,7 +839,7 @@ test("dawn_unittests") {
"src/tests/unittests/validation/ValidationTest.cpp",
"src/tests/unittests/validation/ValidationTest.h",
"src/tests/unittests/validation/VertexBufferValidationTests.cpp",
"src/tests/unittests/validation/VertexInputValidationTests.cpp",
"src/tests/unittests/validation/VertexStateValidationTests.cpp",
"src/tests/unittests/wire/WireArgumentTests.cpp",
"src/tests/unittests/wire/WireBasicTests.cpp",
"src/tests/unittests/wire/WireBufferMappingTests.cpp",
@ -918,7 +918,7 @@ source_set("dawn_end2end_tests_sources") {
"src/tests/end2end/TextureViewTests.cpp",
"src/tests/end2end/TextureZeroInitTests.cpp",
"src/tests/end2end/VertexFormatTests.cpp",
"src/tests/end2end/VertexInputTests.cpp",
"src/tests/end2end/VertexStateTests.cpp",
"src/tests/end2end/ViewportOrientationTests.cpp",
"src/tests/end2end/ViewportTests.cpp",
]

18
dawn.json
View File

@ -693,28 +693,28 @@
"category": "structure",
"extensible": false,
"members": [
{"name": "shader location", "type": "uint32_t"},
{"name": "offset", "type": "uint64_t", "default": "0"},
{"name": "format", "type": "vertex format"}
{"name": "format", "type": "vertex format"},
{"name": "offset", "type": "uint64_t"},
{"name": "shader location", "type": "uint32_t"}
]
},
"vertex buffer descriptor": {
"vertex buffer layout descriptor": {
"category": "structure",
"extensible": false,
"members": [
{"name": "stride", "type": "uint64_t"},
{"name": "array stride", "type": "uint64_t"},
{"name": "step mode", "type": "input step mode", "default": "vertex"},
{"name": "attribute count", "type": "uint32_t"},
{"name": "attributes", "type": "vertex attribute descriptor", "annotation": "const*", "length": "attribute count"}
]
},
"vertex input descriptor": {
"vertex state descriptor": {
"category": "structure",
"extensible": true,
"members": [
{"name": "index format", "type": "index format", "default": "uint32"},
{"name": "buffer count", "type": "uint32_t", "default": 0},
{"name": "buffers", "type": "vertex buffer descriptor", "annotation": "const*", "length": "buffer count"}
{"name": "vertex buffer count", "type": "uint32_t", "default": 0},
{"name": "vertex buffers", "type": "vertex buffer layout descriptor", "annotation": "const*", "length": "vertex buffer count"}
]
},
"input step mode": {
@ -1102,7 +1102,7 @@
{"name": "layout", "type": "pipeline layout"},
{"name": "vertex stage", "type": "programmable stage descriptor"},
{"name": "fragment stage", "type": "programmable stage descriptor", "annotation": "const*", "optional": true},
{"name": "vertex input", "type": "vertex input descriptor", "annotation": "const*", "optional": true},
{"name": "vertex state", "type": "vertex state descriptor", "annotation": "const*", "optional": true},
{"name": "primitive topology", "type": "primitive topology"},
{"name": "rasterization state", "type": "rasterization state descriptor", "annotation": "const*", "optional": true},
{"name": "sample count", "type": "uint32_t", "default": "1"},

12
examples/CHelloTriangle.cpp
View File

@ -95,12 +95,12 @@ void init() {
pl.bindGroupLayouts = nullptr;
descriptor.layout = wgpuDeviceCreatePipelineLayout(device, &pl);
WGPUVertexInputDescriptor vertexInput;
vertexInput.nextInChain = nullptr;
vertexInput.indexFormat = WGPUIndexFormat_Uint32;
vertexInput.bufferCount = 0;
vertexInput.buffers = nullptr;
descriptor.vertexInput = &vertexInput;
WGPUVertexStateDescriptor vertexState;
vertexState.nextInChain = nullptr;
vertexState.indexFormat = WGPUIndexFormat_Uint32;
vertexState.vertexBufferCount = 0;
vertexState.vertexBuffers = nullptr;
descriptor.vertexState = &vertexState;
WGPURasterizationStateDescriptor rasterizationState;
rasterizationState.nextInChain = nullptr;

28
examples/ComputeBoids.cpp
View File

@ -125,20 +125,20 @@ void initRender() {
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.cVertexInput.bufferCount = 2;
descriptor.cVertexInput.cBuffers[0].stride = sizeof(Particle);
descriptor.cVertexInput.cBuffers[0].stepMode = wgpu::InputStepMode::Instance;
descriptor.cVertexInput.cBuffers[0].attributeCount = 2;
descriptor.cVertexInput.cAttributes[0].offset = offsetof(Particle, pos);
descriptor.cVertexInput.cAttributes[0].format = wgpu::VertexFormat::Float2;
descriptor.cVertexInput.cAttributes[1].shaderLocation = 1;
descriptor.cVertexInput.cAttributes[1].offset = offsetof(Particle, vel);
descriptor.cVertexInput.cAttributes[1].format = wgpu::VertexFormat::Float2;
descriptor.cVertexInput.cBuffers[1].stride = sizeof(glm::vec2);
descriptor.cVertexInput.cBuffers[1].attributeCount = 1;
descriptor.cVertexInput.cBuffers[1].attributes = &descriptor.cVertexInput.cAttributes[2];
descriptor.cVertexInput.cAttributes[2].shaderLocation = 2;
descriptor.cVertexInput.cAttributes[2].format = wgpu::VertexFormat::Float2;
descriptor.cVertexState.vertexBufferCount = 2;
descriptor.cVertexState.cVertexBuffers[0].arrayStride = sizeof(Particle);
descriptor.cVertexState.cVertexBuffers[0].stepMode = wgpu::InputStepMode::Instance;
descriptor.cVertexState.cVertexBuffers[0].attributeCount = 2;
descriptor.cVertexState.cAttributes[0].offset = offsetof(Particle, pos);
descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float2;
descriptor.cVertexState.cAttributes[1].shaderLocation = 1;
descriptor.cVertexState.cAttributes[1].offset = offsetof(Particle, vel);
descriptor.cVertexState.cAttributes[1].format = wgpu::VertexFormat::Float2;
descriptor.cVertexState.cVertexBuffers[1].arrayStride = sizeof(glm::vec2);
descriptor.cVertexState.cVertexBuffers[1].attributeCount = 1;
descriptor.cVertexState.cVertexBuffers[1].attributes = &descriptor.cVertexState.cAttributes[2];
descriptor.cVertexState.cAttributes[2].shaderLocation = 2;
descriptor.cVertexState.cAttributes[2].format = wgpu::VertexFormat::Float2;
descriptor.depthStencilState = &descriptor.cDepthStencilState;
descriptor.cDepthStencilState.format = wgpu::TextureFormat::Depth24PlusStencil8;
descriptor.cColorStates[0].format = GetPreferredSwapChainTextureFormat();

8
examples/CppHelloTriangle.cpp
View File

@ -129,10 +129,10 @@ void init() {
descriptor.layout = utils::MakeBasicPipelineLayout(device, &bgl);
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.cVertexInput.bufferCount = 1;
descriptor.cVertexInput.cBuffers[0].stride = 4 * sizeof(float);
descriptor.cVertexInput.cBuffers[0].attributeCount = 1;
descriptor.cVertexInput.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cVertexState.vertexBufferCount = 1;
descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.depthStencilState = &descriptor.cDepthStencilState;
descriptor.cDepthStencilState.format = wgpu::TextureFormat::Depth24PlusStencil8;
descriptor.cColorStates[0].format = GetPreferredSwapChainTextureFormat();

22
examples/CubeReflection.cpp
View File

@ -160,15 +160,15 @@ void init() {
fragColor = vec4(mix(f_col, vec3(0.5, 0.5, 0.5), 0.5), 1.0);
})");
utils::ComboVertexInputDescriptor vertexInput;
vertexInput.cBuffers[0].attributeCount = 2;
vertexInput.cAttributes[0].format = wgpu::VertexFormat::Float3;
vertexInput.cAttributes[1].shaderLocation = 1;
vertexInput.cAttributes[1].offset = 3 * sizeof(float);
vertexInput.cAttributes[1].format = wgpu::VertexFormat::Float3;
utils::ComboVertexStateDescriptor vertexState;
vertexState.cVertexBuffers[0].attributeCount = 2;
vertexState.cAttributes[0].format = wgpu::VertexFormat::Float3;
vertexState.cAttributes[1].shaderLocation = 1;
vertexState.cAttributes[1].offset = 3 * sizeof(float);
vertexState.cAttributes[1].format = wgpu::VertexFormat::Float3;
vertexInput.bufferCount = 1;
vertexInput.cBuffers[0].stride = 6 * sizeof(float);
vertexState.vertexBufferCount = 1;
vertexState.cVertexBuffers[0].arrayStride = 6 * sizeof(float);
auto bgl = utils::MakeBindGroupLayout(
device, {
@ -207,7 +207,7 @@ void init() {
descriptor.layout = pl;
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.vertexInput = &vertexInput;
descriptor.vertexState = &vertexState;
descriptor.depthStencilState = &descriptor.cDepthStencilState;
descriptor.cDepthStencilState.format = wgpu::TextureFormat::Depth24PlusStencil8;
descriptor.cColorStates[0].format = GetPreferredSwapChainTextureFormat();
@ -220,7 +220,7 @@ void init() {
pDescriptor.layout = pl;
pDescriptor.vertexStage.module = vsModule;
pDescriptor.cFragmentStage.module = fsModule;
pDescriptor.vertexInput = &vertexInput;
pDescriptor.vertexState = &vertexState;
pDescriptor.depthStencilState = &pDescriptor.cDepthStencilState;
pDescriptor.cDepthStencilState.format = wgpu::TextureFormat::Depth24PlusStencil8;
pDescriptor.cColorStates[0].format = GetPreferredSwapChainTextureFormat();
@ -234,7 +234,7 @@ void init() {
rfDescriptor.layout = pl;
rfDescriptor.vertexStage.module = vsModule;
rfDescriptor.cFragmentStage.module = fsReflectionModule;
rfDescriptor.vertexInput = &vertexInput;
rfDescriptor.vertexState = &vertexState;
rfDescriptor.depthStencilState = &rfDescriptor.cDepthStencilState;
rfDescriptor.cDepthStencilState.format = wgpu::TextureFormat::Depth24PlusStencil8;
rfDescriptor.cColorStates[0].format = GetPreferredSwapChainTextureFormat();

7
src/dawn_native/CommandBufferStateTracker.cpp
View File

@ -106,8 +106,9 @@ namespace dawn_native {
if (aspects[VALIDATION_ASPECT_VERTEX_BUFFERS]) {
ASSERT(mLastRenderPipeline != nullptr);
auto requiredInputs = mLastRenderPipeline->GetInputsSetMask();
if ((mInputsSet & requiredInputs) == requiredInputs) {
const std::bitset<kMaxVertexBuffers>& requiredVertexBuffers =
mLastRenderPipeline->GetVertexBufferSlotsUsed();
if ((mVertexBufferSlotsUsed & requiredVertexBuffers) == requiredVertexBuffers) {
mAspects.set(VALIDATION_ASPECT_VERTEX_BUFFERS);
}
}
@ -153,7 +154,7 @@ namespace dawn_native {
}
void CommandBufferStateTracker::SetVertexBuffer(uint32_t slot) {
mInputsSet.set(slot);
mVertexBufferSlotsUsed.set(slot);
}
void CommandBufferStateTracker::SetPipelineCommon(PipelineBase* pipeline) {

2
src/dawn_native/CommandBufferStateTracker.h
View File

@ -53,7 +53,7 @@ namespace dawn_native {
ValidationAspects mAspects;
std::array<BindGroupBase*, kMaxBindGroups> mBindgroups = {};
std::bitset<kMaxVertexBuffers> mInputsSet;
std::bitset<kMaxVertexBuffers> mVertexBufferSlotsUsed;
PipelineLayoutBase* mLastPipelineLayout = nullptr;
RenderPipelineBase* mLastRenderPipeline = nullptr;

131
src/dawn_native/RenderPipeline.cpp
View File

@ -61,44 +61,44 @@ namespace dawn_native {
return {};
}
MaybeError ValidateVertexBufferDescriptor(
const VertexBufferDescriptor* buffer,
MaybeError ValidateVertexBufferLayoutDescriptor(
const VertexBufferLayoutDescriptor* buffer,
std::bitset<kMaxVertexAttributes>* attributesSetMask) {
DAWN_TRY(ValidateInputStepMode(buffer->stepMode));
if (buffer->stride > kMaxVertexBufferStride) {
return DAWN_VALIDATION_ERROR("Setting input stride out of bounds");
if (buffer->arrayStride > kMaxVertexBufferStride) {
return DAWN_VALIDATION_ERROR("Setting arrayStride out of bounds");
}
if (buffer->stride % 4 != 0) {
if (buffer->arrayStride % 4 != 0) {
return DAWN_VALIDATION_ERROR(
"Stride of Vertex buffer needs to be a multiple of 4 bytes");
"arrayStride of Vertex buffer needs to be a multiple of 4 bytes");
}
for (uint32_t i = 0; i < buffer->attributeCount; ++i) {
DAWN_TRY(ValidateVertexAttributeDescriptor(&buffer->attributes[i], buffer->stride,
attributesSetMask));
DAWN_TRY(ValidateVertexAttributeDescriptor(&buffer->attributes[i],
buffer->arrayStride, attributesSetMask));
}
return {};
}
MaybeError ValidateVertexInputDescriptor(
const VertexInputDescriptor* descriptor,
MaybeError ValidateVertexStateDescriptor(
const VertexStateDescriptor* descriptor,
std::bitset<kMaxVertexAttributes>* attributesSetMask) {
if (descriptor->nextInChain != nullptr) {
return DAWN_VALIDATION_ERROR("nextInChain must be nullptr");
}
DAWN_TRY(ValidateIndexFormat(descriptor->indexFormat));
if (descriptor->bufferCount > kMaxVertexBuffers) {
return DAWN_VALIDATION_ERROR("Vertex Inputs number exceeds maximum");
if (descriptor->vertexBufferCount > kMaxVertexBuffers) {
return DAWN_VALIDATION_ERROR("Vertex buffer count exceeds maximum");
}
uint32_t totalAttributesNum = 0;
for (uint32_t i = 0; i < descriptor->bufferCount; ++i) {
DAWN_TRY(
ValidateVertexBufferDescriptor(&descriptor->buffers[i], attributesSetMask));
totalAttributesNum += descriptor->buffers[i].attributeCount;
for (uint32_t i = 0; i < descriptor->vertexBufferCount; ++i) {
DAWN_TRY(ValidateVertexBufferLayoutDescriptor(&descriptor->vertexBuffers[i],
attributesSetMask));
totalAttributesNum += descriptor->vertexBuffers[i].attributeCount;
}
// Every vertex attribute has a member called shaderLocation, and there are some
@ -288,8 +288,8 @@ namespace dawn_native {
}
std::bitset<kMaxVertexAttributes> attributesSetMask;
if (descriptor->vertexInput) {
DAWN_TRY(ValidateVertexInputDescriptor(descriptor->vertexInput, &attributesSetMask));
if (descriptor->vertexState) {
DAWN_TRY(ValidateVertexStateDescriptor(descriptor->vertexState, &attributesSetMask));
}
DAWN_TRY(ValidatePrimitiveTopology(descriptor->primitiveTopology));
@ -305,7 +305,7 @@ namespace dawn_native {
if ((descriptor->vertexStage.module->GetUsedVertexAttributes() & ~attributesSetMask)
.any()) {
return DAWN_VALIDATION_ERROR(
"Pipeline vertex stage uses inputs not in the input state");
"Pipeline vertex stage uses vertex buffers not in the vertex state");
}
if (!IsValidSampleCount(descriptor->sampleCount)) {
@ -378,29 +378,31 @@ namespace dawn_native {
mVertexEntryPoint(descriptor->vertexStage.entryPoint),
mFragmentModule(descriptor->fragmentStage->module),
mFragmentEntryPoint(descriptor->fragmentStage->entryPoint) {
if (descriptor->vertexInput != nullptr) {
mVertexInput = *descriptor->vertexInput;
if (descriptor->vertexState != nullptr) {
mVertexState = *descriptor->vertexState;
} else {
mVertexInput = VertexInputDescriptor();
mVertexState = VertexStateDescriptor();
}
for (uint32_t slot = 0; slot < mVertexInput.bufferCount; ++slot) {
if (mVertexInput.buffers[slot].attributeCount == 0) {
for (uint32_t slot = 0; slot < mVertexState.vertexBufferCount; ++slot) {
if (mVertexState.vertexBuffers[slot].attributeCount == 0) {
continue;
}
mInputsSetMask.set(slot);
mInputInfos[slot].stride = mVertexInput.buffers[slot].stride;
mInputInfos[slot].stepMode = mVertexInput.buffers[slot].stepMode;
mVertexBufferSlotsUsed.set(slot);
mVertexBufferInfos[slot].arrayStride = mVertexState.vertexBuffers[slot].arrayStride;
mVertexBufferInfos[slot].stepMode = mVertexState.vertexBuffers[slot].stepMode;
uint32_t location = 0;
for (uint32_t i = 0; i < mVertexInput.buffers[slot].attributeCount; ++i) {
location = mVertexInput.buffers[slot].attributes[i].shaderLocation;
mAttributesSetMask.set(location);
for (uint32_t i = 0; i < mVertexState.vertexBuffers[slot].attributeCount; ++i) {
location = mVertexState.vertexBuffers[slot].attributes[i].shaderLocation;
mAttributeLocationsUsed.set(location);
mAttributeInfos[location].shaderLocation = location;
mAttributeInfos[location].inputSlot = slot;
mAttributeInfos[location].offset = mVertexInput.buffers[slot].attributes[i].offset;
mAttributeInfos[location].format = mVertexInput.buffers[slot].attributes[i].format;
mAttributeInfos[location].vertexBufferSlot = slot;
mAttributeInfos[location].offset =
mVertexState.vertexBuffers[slot].attributes[i].offset;
mAttributeInfos[location].format =
mVertexState.vertexBuffers[slot].attributes[i].format;
}
}
@ -454,31 +456,31 @@ namespace dawn_native {
}
}
const VertexInputDescriptor* RenderPipelineBase::GetVertexInputDescriptor() const {
const VertexStateDescriptor* RenderPipelineBase::GetVertexStateDescriptor() const {
ASSERT(!IsError());
return &mVertexInput;
return &mVertexState;
}
const std::bitset<kMaxVertexAttributes>& RenderPipelineBase::GetAttributesSetMask() const {
const std::bitset<kMaxVertexAttributes>& RenderPipelineBase::GetAttributeLocationsUsed() const {
ASSERT(!IsError());
return mAttributesSetMask;
return mAttributeLocationsUsed;
}
const VertexAttributeInfo& RenderPipelineBase::GetAttribute(uint32_t location) const {
ASSERT(!IsError());
ASSERT(mAttributesSetMask[location]);
ASSERT(mAttributeLocationsUsed[location]);
return mAttributeInfos[location];
}
const std::bitset<kMaxVertexBuffers>& RenderPipelineBase::GetInputsSetMask() const {
const std::bitset<kMaxVertexBuffers>& RenderPipelineBase::GetVertexBufferSlotsUsed() const {
ASSERT(!IsError());
return mInputsSetMask;
return mVertexBufferSlotsUsed;
}
const VertexBufferInfo& RenderPipelineBase::GetInput(uint32_t slot) const {
const VertexBufferInfo& RenderPipelineBase::GetVertexBuffer(uint32_t slot) const {
ASSERT(!IsError());
ASSERT(mInputsSetMask[slot]);
return mInputInfos[slot];
ASSERT(mVertexBufferSlotsUsed[slot]);
return mVertexBufferInfos[slot];
}
const ColorStateDescriptor* RenderPipelineBase::GetColorStateDescriptor(
@ -540,10 +542,10 @@ namespace dawn_native {
return mAttachmentState.Get();
}
std::bitset<kMaxVertexAttributes> RenderPipelineBase::GetAttributesUsingInput(
std::bitset<kMaxVertexAttributes> RenderPipelineBase::GetAttributesUsingVertexBuffer(
uint32_t slot) const {
ASSERT(!IsError());
return attributesUsingInput[slot];
return attributesUsingVertexBuffer[slot];
}
size_t RenderPipelineBase::HashFunc::operator()(const RenderPipelineBase* pipeline) const {
@ -578,20 +580,21 @@ namespace dawn_native {
desc.stencilBack.depthFailOp, desc.stencilBack.passOp);
}
// Hash vertex input state
HashCombine(&hash, pipeline->mAttributesSetMask);
for (uint32_t i : IterateBitSet(pipeline->mAttributesSetMask)) {
// Hash vertex state
HashCombine(&hash, pipeline->mAttributeLocationsUsed);
for (uint32_t i : IterateBitSet(pipeline->mAttributeLocationsUsed)) {
const VertexAttributeInfo& desc = pipeline->GetAttribute(i);
HashCombine(&hash, desc.shaderLocation, desc.inputSlot, desc.offset, desc.format);
HashCombine(&hash, desc.shaderLocation, desc.vertexBufferSlot, desc.offset,
desc.format);
}
HashCombine(&hash, pipeline->mInputsSetMask);
for (uint32_t i : IterateBitSet(pipeline->mInputsSetMask)) {
const VertexBufferInfo& desc = pipeline->GetInput(i);
HashCombine(&hash, desc.stride, desc.stepMode);
HashCombine(&hash, pipeline->mVertexBufferSlotsUsed);
for (uint32_t i : IterateBitSet(pipeline->mVertexBufferSlotsUsed)) {
const VertexBufferInfo& desc = pipeline->GetVertexBuffer(i);
HashCombine(&hash, desc.arrayStride, desc.stepMode);
}
HashCombine(&hash, pipeline->mVertexInput.indexFormat);
HashCombine(&hash, pipeline->mVertexState.indexFormat);
// Hash rasterization state
{
@ -666,34 +669,34 @@ namespace dawn_native {
}
}
// Check vertex input state
if (a->mAttributesSetMask != b->mAttributesSetMask) {
// Check vertex state
if (a->mAttributeLocationsUsed != b->mAttributeLocationsUsed) {
return false;
}
for (uint32_t i : IterateBitSet(a->mAttributesSetMask)) {
for (uint32_t i : IterateBitSet(a->mAttributeLocationsUsed)) {
const VertexAttributeInfo& descA = a->GetAttribute(i);
const VertexAttributeInfo& descB = b->GetAttribute(i);
if (descA.shaderLocation != descB.shaderLocation ||
descA.inputSlot != descB.inputSlot || descA.offset != descB.offset ||
descA.vertexBufferSlot != descB.vertexBufferSlot || descA.offset != descB.offset ||
descA.format != descB.format) {
return false;
}
}
if (a->mInputsSetMask != b->mInputsSetMask) {
if (a->mVertexBufferSlotsUsed != b->mVertexBufferSlotsUsed) {
return false;
}
for (uint32_t i : IterateBitSet(a->mInputsSetMask)) {
const VertexBufferInfo& descA = a->GetInput(i);
const VertexBufferInfo& descB = b->GetInput(i);
if (descA.stride != descB.stride || descA.stepMode != descB.stepMode) {
for (uint32_t i : IterateBitSet(a->mVertexBufferSlotsUsed)) {
const VertexBufferInfo& descA = a->GetVertexBuffer(i);
const VertexBufferInfo& descB = b->GetVertexBuffer(i);
if (descA.arrayStride != descB.arrayStride || descA.stepMode != descB.stepMode) {
return false;
}
}
if (a->mVertexInput.indexFormat != b->mVertexInput.indexFormat) {
if (a->mVertexState.indexFormat != b->mVertexState.indexFormat) {
return false;
}

31
src/dawn_native/RenderPipeline.h
View File

@ -41,14 +41,14 @@ namespace dawn_native {
bool BlendEnabled(const ColorStateDescriptor* mColorState);
struct VertexAttributeInfo {
uint32_t shaderLocation;
uint32_t inputSlot;
uint64_t offset;
wgpu::VertexFormat format;
uint64_t offset;
uint32_t shaderLocation;
uint32_t vertexBufferSlot;
};
struct VertexBufferInfo {
uint64_t stride;
uint64_t arrayStride;
wgpu::InputStepMode stepMode;
};
@ -59,11 +59,11 @@ namespace dawn_native {
static RenderPipelineBase* MakeError(DeviceBase* device);
const VertexInputDescriptor* GetVertexInputDescriptor() const;
const std::bitset<kMaxVertexAttributes>& GetAttributesSetMask() const;
const VertexStateDescriptor* GetVertexStateDescriptor() const;
const std::bitset<kMaxVertexAttributes>& GetAttributeLocationsUsed() const;
const VertexAttributeInfo& GetAttribute(uint32_t location) const;
const std::bitset<kMaxVertexBuffers>& GetInputsSetMask() const;
const VertexBufferInfo& GetInput(uint32_t slot) const;
const std::bitset<kMaxVertexBuffers>& GetVertexBufferSlotsUsed() const;
const VertexBufferInfo& GetVertexBuffer(uint32_t slot) const;
const ColorStateDescriptor* GetColorStateDescriptor(uint32_t attachmentSlot) const;
const DepthStencilStateDescriptor* GetDepthStencilStateDescriptor() const;
@ -79,8 +79,9 @@ namespace dawn_native {
const AttachmentState* GetAttachmentState() const;
std::bitset<kMaxVertexAttributes> GetAttributesUsingInput(uint32_t slot) const;
std::array<std::bitset<kMaxVertexAttributes>, kMaxVertexBuffers> attributesUsingInput;
std::bitset<kMaxVertexAttributes> GetAttributesUsingVertexBuffer(uint32_t slot) const;
std::array<std::bitset<kMaxVertexAttributes>, kMaxVertexBuffers>
attributesUsingVertexBuffer;
// Functors necessary for the unordered_set<RenderPipelineBase*>-based cache.
struct HashFunc {
@ -93,12 +94,12 @@ namespace dawn_native {
private:
RenderPipelineBase(DeviceBase* device, ObjectBase::ErrorTag tag);
// Vertex input
VertexInputDescriptor mVertexInput;
std::bitset<kMaxVertexAttributes> mAttributesSetMask;
// Vertex state
VertexStateDescriptor mVertexState;
std::bitset<kMaxVertexAttributes> mAttributeLocationsUsed;
std::array<VertexAttributeInfo, kMaxVertexAttributes> mAttributeInfos;
std::bitset<kMaxVertexBuffers> mInputsSetMask;
std::array<VertexBufferInfo, kMaxVertexBuffers> mInputInfos;
std::bitset<kMaxVertexBuffers> mVertexBufferSlotsUsed;
std::array<VertexBufferInfo, kMaxVertexBuffers> mVertexBufferInfos;
// Attachments
Ref<AttachmentState> mAttachmentState;

13
src/dawn_native/d3d12/CommandBufferD3D12.cpp
View File

@ -397,29 +397,30 @@ namespace dawn_native { namespace d3d12 {
auto* d3d12BufferView = &mD3D12BufferViews[slot];
d3d12BufferView->BufferLocation = buffer->GetVA() + offset;
d3d12BufferView->SizeInBytes = buffer->GetSize() - offset;
// The bufferView stride is set based on the input state before a draw.
// The bufferView stride is set based on the vertex state before a draw.
}
void Apply(ID3D12GraphicsCommandList* commandList,
const RenderPipeline* renderPipeline) {
ASSERT(renderPipeline != nullptr);
std::bitset<kMaxVertexBuffers> inputsMask = renderPipeline->GetInputsSetMask();
std::bitset<kMaxVertexBuffers> vertexBufferSlotsUsed =
renderPipeline->GetVertexBufferSlotsUsed();
uint32_t startSlot = mStartSlot;
uint32_t endSlot = mEndSlot;
// If the input state has changed, we need to update the StrideInBytes
// If the vertex state has changed, we need to update the StrideInBytes
// for the D3D12 buffer views. We also need to extend the dirty range to
// touch all these slots because the stride may have changed.
if (mLastAppliedRenderPipeline != renderPipeline) {
mLastAppliedRenderPipeline = renderPipeline;
for (uint32_t slot : IterateBitSet(inputsMask)) {
for (uint32_t slot : IterateBitSet(vertexBufferSlotsUsed)) {
startSlot = std::min(startSlot, slot);
endSlot = std::max(endSlot, slot + 1);
mD3D12BufferViews[slot].StrideInBytes =
renderPipeline->GetInput(slot).stride;
renderPipeline->GetVertexBuffer(slot).arrayStride;
}
}
@ -462,7 +463,7 @@ namespace dawn_native { namespace d3d12 {
void OnSetPipeline(const RenderPipelineBase* pipeline) {
mD3D12BufferView.Format =
DXGIIndexFormat(pipeline->GetVertexInputDescriptor()->indexFormat);
DXGIIndexFormat(pipeline->GetVertexStateDescriptor()->indexFormat);
}
void Apply(ID3D12GraphicsCommandList* commandList) {

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

@ -359,7 +359,7 @@ namespace dawn_native { namespace d3d12 {
// D3D12 logs warnings if any empty input state is used
std::array<D3D12_INPUT_ELEMENT_DESC, kMaxVertexAttributes> inputElementDescriptors;
if (GetAttributesSetMask().any()) {
if (GetAttributeLocationsUsed().any()) {
descriptorD3D12.InputLayout = ComputeInputLayout(&inputElementDescriptors);
}
@ -423,7 +423,7 @@ namespace dawn_native { namespace d3d12 {
D3D12_INPUT_LAYOUT_DESC RenderPipeline::ComputeInputLayout(
std::array<D3D12_INPUT_ELEMENT_DESC, kMaxVertexAttributes>* inputElementDescriptors) {
unsigned int count = 0;
for (auto i : IterateBitSet(GetAttributesSetMask())) {
for (auto i : IterateBitSet(GetAttributeLocationsUsed())) {
D3D12_INPUT_ELEMENT_DESC& inputElementDescriptor = (*inputElementDescriptors)[count++];
const VertexAttributeInfo& attribute = GetAttribute(i);
@ -433,9 +433,9 @@ namespace dawn_native { namespace d3d12 {
inputElementDescriptor.SemanticName = "TEXCOORD";
inputElementDescriptor.SemanticIndex = static_cast<uint32_t>(i);
inputElementDescriptor.Format = VertexFormatType(attribute.format);
inputElementDescriptor.InputSlot = attribute.inputSlot;
inputElementDescriptor.InputSlot = attribute.vertexBufferSlot;
const VertexBufferInfo& input = GetInput(attribute.inputSlot);
const VertexBufferInfo& input = GetVertexBuffer(attribute.vertexBufferSlot);
inputElementDescriptor.AlignedByteOffset = attribute.offset;
inputElementDescriptor.InputSlotClass = InputStepModeFunction(input.stepMode);

24
src/dawn_native/metal/CommandBufferMTL.mm
View File

@ -549,7 +549,7 @@ namespace dawn_native { namespace metal {
// Keeps track of the dirty vertex buffer values so they can be lazily applied when we know
// all the relevant state.
class VertexInputBufferTracker {
class VertexBufferTracker {
public:
void OnSetVertexBuffer(uint32_t slot, Buffer* buffer, uint64_t offset) {
mVertexBuffers[slot] = buffer->GetMTLBuffer();
@ -564,12 +564,12 @@ namespace dawn_native { namespace metal {
// When a new pipeline is bound we must set all the vertex buffers again because
// they might have been offset by the pipeline layout, and they might be packed
// differently from the previous pipeline.
mDirtyVertexBuffers |= pipeline->GetInputsSetMask();
mDirtyVertexBuffers |= pipeline->GetVertexBufferSlotsUsed();
}
void Apply(id<MTLRenderCommandEncoder> encoder, RenderPipeline* pipeline) {
std::bitset<kMaxVertexBuffers> vertexBuffersToApply =
mDirtyVertexBuffers & pipeline->GetInputsSetMask();
mDirtyVertexBuffers & pipeline->GetVertexBufferSlotsUsed();
for (uint32_t dawnIndex : IterateBitSet(vertexBuffersToApply)) {
uint32_t metalIndex = pipeline->GetMtlVertexBufferIndex(dawnIndex);
@ -904,7 +904,7 @@ namespace dawn_native { namespace metal {
RenderPipeline* lastPipeline = nullptr;
id<MTLBuffer> indexBuffer = nil;
uint32_t indexBufferBaseOffset = 0;
VertexInputBufferTracker vertexInputBuffers;
VertexBufferTracker vertexBuffers;
StorageBufferLengthTracker storageBufferLengths = {};
BindGroupTracker bindGroups(&storageBufferLengths);
@ -917,7 +917,7 @@ namespace dawn_native { namespace metal {
case Command::Draw: {
DrawCmd* draw = iter->NextCommand<DrawCmd>();
vertexInputBuffers.Apply(encoder, lastPipeline);
vertexBuffers.Apply(encoder, lastPipeline);
bindGroups.Apply(encoder);
storageBufferLengths.Apply(encoder, lastPipeline);
@ -934,9 +934,9 @@ namespace dawn_native { namespace metal {
case Command::DrawIndexed: {
DrawIndexedCmd* draw = iter->NextCommand<DrawIndexedCmd>();
size_t formatSize =
IndexFormatSize(lastPipeline->GetVertexInputDescriptor()->indexFormat);
IndexFormatSize(lastPipeline->GetVertexStateDescriptor()->indexFormat);
vertexInputBuffers.Apply(encoder, lastPipeline);
vertexBuffers.Apply(encoder, lastPipeline);
bindGroups.Apply(encoder);
storageBufferLengths.Apply(encoder, lastPipeline);
@ -957,7 +957,7 @@ namespace dawn_native { namespace metal {
case Command::DrawIndirect: {
DrawIndirectCmd* draw = iter->NextCommand<DrawIndirectCmd>();
vertexInputBuffers.Apply(encoder, lastPipeline);
vertexBuffers.Apply(encoder, lastPipeline);
bindGroups.Apply(encoder);
storageBufferLengths.Apply(encoder, lastPipeline);
@ -971,7 +971,7 @@ namespace dawn_native { namespace metal {
case Command::DrawIndexedIndirect: {
DrawIndirectCmd* draw = iter->NextCommand<DrawIndirectCmd>();
vertexInputBuffers.Apply(encoder, lastPipeline);
vertexBuffers.Apply(encoder, lastPipeline);
bindGroups.Apply(encoder);
storageBufferLengths.Apply(encoder, lastPipeline);
@ -1013,7 +1013,7 @@ namespace dawn_native { namespace metal {
SetRenderPipelineCmd* cmd = iter->NextCommand<SetRenderPipelineCmd>();
RenderPipeline* newPipeline = ToBackend(cmd->pipeline).Get();
vertexInputBuffers.OnSetPipeline(lastPipeline, newPipeline);
vertexBuffers.OnSetPipeline(lastPipeline, newPipeline);
bindGroups.OnSetPipeline(newPipeline);
[encoder setDepthStencilState:newPipeline->GetMTLDepthStencilState()];
@ -1045,8 +1045,8 @@ namespace dawn_native { namespace metal {
case Command::SetVertexBuffer: {
SetVertexBufferCmd* cmd = iter->NextCommand<SetVertexBufferCmd>();
vertexInputBuffers.OnSetVertexBuffer(cmd->slot, ToBackend(cmd->buffer.Get()),
cmd->offset);
vertexBuffers.OnSetVertexBuffer(cmd->slot, ToBackend(cmd->buffer.Get()),
cmd->offset);
} break;
default:

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

@ -313,7 +313,7 @@ namespace dawn_native { namespace metal {
RenderPipeline::RenderPipeline(Device* device, const RenderPipelineDescriptor* descriptor)
: RenderPipelineBase(device, descriptor),
mMtlIndexType(MTLIndexFormat(GetVertexInputDescriptor()->indexFormat)),
mMtlIndexType(MTLIndexFormat(GetVertexStateDescriptor()->indexFormat)),
mMtlPrimitiveTopology(MTLPrimitiveTopology(GetPrimitiveTopology())),
mMtlFrontFace(MTLFrontFace(GetFrontFace())),
mMtlCullMode(ToMTLCullMode(GetCullMode())) {
@ -432,49 +432,49 @@ namespace dawn_native { namespace metal {
uint32_t mtlVertexBufferIndex =
ToBackend(GetLayout())->GetBufferBindingCount(SingleShaderStage::Vertex);
for (uint32_t dawnVertexBufferIndex : IterateBitSet(GetInputsSetMask())) {
const VertexBufferInfo& info = GetInput(dawnVertexBufferIndex);
for (uint32_t dawnVertexBufferSlot : IterateBitSet(GetVertexBufferSlotsUsed())) {
const VertexBufferInfo& info = GetVertexBuffer(dawnVertexBufferSlot);
MTLVertexBufferLayoutDescriptor* layoutDesc = [MTLVertexBufferLayoutDescriptor new];
if (info.stride == 0) {
if (info.arrayStride == 0) {
// For MTLVertexStepFunctionConstant, the stepRate must be 0,
// but the stride must NOT be 0, so we made up it with
// but the arrayStride must NOT be 0, so we made up it with
// max(attrib.offset + sizeof(attrib) for each attrib)
size_t max_stride = 0;
for (uint32_t attribIndex : IterateBitSet(GetAttributesSetMask())) {
size_t maxArrayStride = 0;
for (uint32_t attribIndex : IterateBitSet(GetAttributeLocationsUsed())) {
const VertexAttributeInfo& attrib = GetAttribute(attribIndex);
// Only use the attributes that use the current input
if (attrib.inputSlot != dawnVertexBufferIndex) {
if (attrib.vertexBufferSlot != dawnVertexBufferSlot) {
continue;
}
max_stride = std::max(max_stride,
VertexFormatSize(attrib.format) + size_t(attrib.offset));
maxArrayStride = std::max(
maxArrayStride, VertexFormatSize(attrib.format) + size_t(attrib.offset));
}
layoutDesc.stepFunction = MTLVertexStepFunctionConstant;
layoutDesc.stepRate = 0;
// Metal requires the stride must be a multiple of 4 bytes, align it with next
// multiple of 4 if it's not.
layoutDesc.stride = Align(max_stride, 4);
layoutDesc.stride = Align(maxArrayStride, 4);
} else {
layoutDesc.stepFunction = InputStepModeFunction(info.stepMode);
layoutDesc.stepRate = 1;
layoutDesc.stride = info.stride;
layoutDesc.stride = info.arrayStride;
}
mtlVertexDescriptor.layouts[mtlVertexBufferIndex] = layoutDesc;
[layoutDesc release];
mMtlVertexBufferIndices[dawnVertexBufferIndex] = mtlVertexBufferIndex;
mMtlVertexBufferIndices[dawnVertexBufferSlot] = mtlVertexBufferIndex;
mtlVertexBufferIndex++;
}
for (uint32_t i : IterateBitSet(GetAttributesSetMask())) {
for (uint32_t i : IterateBitSet(GetAttributeLocationsUsed())) {
const VertexAttributeInfo& info = GetAttribute(i);
auto attribDesc = [MTLVertexAttributeDescriptor new];
attribDesc.format = VertexFormatType(info.format);
attribDesc.offset = info.offset;
attribDesc.bufferIndex = mMtlVertexBufferIndices[info.inputSlot];
attribDesc.bufferIndex = mMtlVertexBufferIndices[info.vertexBufferSlot];
mtlVertexDescriptor.attributes[i] = attribDesc;
[attribDesc release];
}

57
src/dawn_native/opengl/CommandBufferGL.cpp
View File

@ -133,9 +133,9 @@ namespace dawn_native { namespace opengl {
}
// Vertex buffers and index buffers are implemented as part of an OpenGL VAO that
// corresponds to an VertexInput. On the contrary in Dawn they are part of the global state.
// This means that we have to re-apply these buffers on an VertexInput change.
class InputBufferTracker {
// corresponds to a VertexState. On the contrary in Dawn they are part of the global state.
// This means that we have to re-apply these buffers on a VertexState change.
class VertexStateBufferBindingTracker {
public:
void OnSetIndexBuffer(BufferBase* buffer) {
mIndexBufferDirty = true;
@ -157,7 +157,7 @@ namespace dawn_native { namespace opengl {
}
mIndexBufferDirty = true;
mDirtyVertexBuffers |= pipeline->GetInputsSetMask();
mDirtyVertexBuffers |= pipeline->GetVertexBufferSlotsUsed();
mLastPipeline = pipeline;
}
@ -168,30 +168,32 @@ namespace dawn_native { namespace opengl {
mIndexBufferDirty = false;
}
for (uint32_t slot :
IterateBitSet(mDirtyVertexBuffers & mLastPipeline->GetInputsSetMask())) {
for (uint32_t slot : IterateBitSet(mDirtyVertexBuffers &
mLastPipeline->GetVertexBufferSlotsUsed())) {
for (uint32_t location :
IterateBitSet(mLastPipeline->GetAttributesUsingInput(slot))) {
auto attribute = mLastPipeline->GetAttribute(location);
IterateBitSet(mLastPipeline->GetAttributesUsingVertexBuffer(slot))) {
const VertexAttributeInfo& attribute =
mLastPipeline->GetAttribute(location);
GLuint buffer = mVertexBuffers[slot]->GetHandle();
uint64_t offset = mVertexBufferOffsets[slot];
auto input = mLastPipeline->GetInput(slot);
auto components = VertexFormatNumComponents(attribute.format);
auto formatType = VertexFormatType(attribute.format);
const VertexBufferInfo& vertexBuffer = mLastPipeline->GetVertexBuffer(slot);
uint32_t components = VertexFormatNumComponents(attribute.format);
GLenum formatType = VertexFormatType(attribute.format);
GLboolean normalized = VertexFormatIsNormalized(attribute.format);
gl.BindBuffer(GL_ARRAY_BUFFER, buffer);
if (VertexFormatIsInt(attribute.format)) {
gl.VertexAttribIPointer(location, components, formatType, input.stride,
reinterpret_cast<void*>(static_cast<intptr_t>(
offset + attribute.offset)));
} else {
gl.VertexAttribPointer(
location, components, formatType, normalized, input.stride,
gl.VertexAttribIPointer(
location, components, formatType, vertexBuffer.arrayStride,
reinterpret_cast<void*>(
static_cast<intptr_t>(offset + attribute.offset)));
} else {
gl.VertexAttribPointer(location, components, formatType, normalized,
vertexBuffer.arrayStride,
reinterpret_cast<void*>(static_cast<intptr_t>(
offset + attribute.offset)));
}
}
}
@ -855,14 +857,14 @@ namespace dawn_native { namespace opengl {
RenderPipeline* lastPipeline = nullptr;
uint64_t indexBufferBaseOffset = 0;
InputBufferTracker inputBuffers;
VertexStateBufferBindingTracker vertexStateBufferBindingTracker;
BindGroupTracker bindGroupTracker = {};
auto DoRenderBundleCommand = [&](CommandIterator* iter, Command type) {
switch (type) {
case Command::Draw: {
DrawCmd* draw = iter->NextCommand<DrawCmd>();
inputBuffers.Apply(gl);
vertexStateBufferBindingTracker.Apply(gl);
bindGroupTracker.Apply(gl);
if (draw->firstInstance > 0) {
@ -879,11 +881,11 @@ namespace dawn_native { namespace opengl {
case Command::DrawIndexed: {
DrawIndexedCmd* draw = iter->NextCommand<DrawIndexedCmd>();
inputBuffers.Apply(gl);
vertexStateBufferBindingTracker.Apply(gl);
bindGroupTracker.Apply(gl);
wgpu::IndexFormat indexFormat =
lastPipeline->GetVertexInputDescriptor()->indexFormat;
lastPipeline->GetVertexStateDescriptor()->indexFormat;
size_t formatSize = IndexFormatSize(indexFormat);
GLenum formatType = IndexFormatType(indexFormat);
@ -905,7 +907,7 @@ namespace dawn_native { namespace opengl {
case Command::DrawIndirect: {
DrawIndirectCmd* draw = iter->NextCommand<DrawIndirectCmd>();
inputBuffers.Apply(gl);
vertexStateBufferBindingTracker.Apply(gl);
bindGroupTracker.Apply(gl);
uint64_t indirectBufferOffset = draw->indirectOffset;
@ -919,11 +921,11 @@ namespace dawn_native { namespace opengl {
case Command::DrawIndexedIndirect: {
DrawIndexedIndirectCmd* draw = iter->NextCommand<DrawIndexedIndirectCmd>();
inputBuffers.Apply(gl);
vertexStateBufferBindingTracker.Apply(gl);
bindGroupTracker.Apply(gl);
wgpu::IndexFormat indexFormat =
lastPipeline->GetVertexInputDescriptor()->indexFormat;
lastPipeline->GetVertexStateDescriptor()->indexFormat;
GLenum formatType = IndexFormatType(indexFormat);
uint64_t indirectBufferOffset = draw->indirectOffset;
@ -948,7 +950,7 @@ namespace dawn_native { namespace opengl {
lastPipeline = ToBackend(cmd->pipeline).Get();
lastPipeline->ApplyNow(persistentPipelineState);
inputBuffers.OnSetPipeline(lastPipeline);
vertexStateBufferBindingTracker.OnSetPipeline(lastPipeline);
bindGroupTracker.OnSetPipeline(lastPipeline);
} break;
@ -965,12 +967,13 @@ namespace dawn_native { namespace opengl {
case Command::SetIndexBuffer: {
SetIndexBufferCmd* cmd = iter->NextCommand<SetIndexBufferCmd>();
indexBufferBaseOffset = cmd->offset;
inputBuffers.OnSetIndexBuffer(cmd->buffer.Get());
vertexStateBufferBindingTracker.OnSetIndexBuffer(cmd->buffer.Get());
} break;
case Command::SetVertexBuffer: {
SetVertexBufferCmd* cmd = iter->NextCommand<SetVertexBufferCmd>();
inputBuffers.OnSetVertexBuffer(cmd->slot, cmd->buffer.Get(), cmd->offset);
vertexStateBufferBindingTracker.OnSetVertexBuffer(cmd->slot, cmd->buffer.Get(),
cmd->offset);
} break;
default:

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

@ -202,7 +202,7 @@ namespace dawn_native { namespace opengl {
modules[SingleShaderStage::Fragment] = ToBackend(descriptor->fragmentStage->module);
PipelineGL::Initialize(device->gl, ToBackend(GetLayout()), modules);
CreateVAOForVertexInput(descriptor->vertexInput);
CreateVAOForVertexState(descriptor->vertexState);
}
RenderPipeline::~RenderPipeline() {
@ -215,25 +215,25 @@ namespace dawn_native { namespace opengl {
return mGlPrimitiveTopology;
}
void RenderPipeline::CreateVAOForVertexInput(const VertexInputDescriptor* vertexInput) {
void RenderPipeline::CreateVAOForVertexState(const VertexStateDescriptor* vertexState) {
const OpenGLFunctions& gl = ToBackend(GetDevice())->gl;
gl.GenVertexArrays(1, &mVertexArrayObject);
gl.BindVertexArray(mVertexArrayObject);
for (uint32_t location : IterateBitSet(GetAttributesSetMask())) {
for (uint32_t location : IterateBitSet(GetAttributeLocationsUsed())) {
const auto& attribute = GetAttribute(location);
gl.EnableVertexAttribArray(location);
attributesUsingInput[attribute.inputSlot][location] = true;
auto input = GetInput(attribute.inputSlot);
attributesUsingVertexBuffer[attribute.vertexBufferSlot][location] = true;
const VertexBufferInfo& vertexBuffer = GetVertexBuffer(attribute.vertexBufferSlot);
if (input.stride == 0) {
if (vertexBuffer.arrayStride == 0) {
// Emulate a stride of zero (constant vertex attribute) by
// setting the attribute instance divisor to a huge number.
gl.VertexAttribDivisor(location, 0xffffffff);
} else {
switch (input.stepMode) {
switch (vertexBuffer.stepMode) {
case wgpu::InputStepMode::Vertex:
break;
case wgpu::InputStepMode::Instance:

2
src/dawn_native/opengl/RenderPipelineGL.h
View File

@ -37,7 +37,7 @@ namespace dawn_native { namespace opengl {
void ApplyNow(PersistentPipelineState& persistentPipelineState);
private:
void CreateVAOForVertexInput(const VertexInputDescriptor* vertexInput);
void CreateVAOForVertexState(const VertexStateDescriptor* vertexState);
// TODO(yunchao.he@intel.com): vao need to be deduplicated between pipelines.
GLuint mVertexArrayObject;

2
src/dawn_native/vulkan/CommandBufferVk.cpp
View File

@ -867,7 +867,7 @@ namespace dawn_native { namespace vulkan {
// and rebind if needed on pipeline change
ASSERT(lastPipeline != nullptr);
VkIndexType indexType =
VulkanIndexType(lastPipeline->GetVertexInputDescriptor()->indexFormat);
VulkanIndexType(lastPipeline->GetVertexStateDescriptor()->indexFormat);
device->fn.CmdBindIndexBuffer(
commands, indexBuffer, static_cast<VkDeviceSize>(cmd->offset), indexType);
} break;

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

@ -351,11 +351,9 @@ namespace dawn_native { namespace vulkan {
shaderStages[1].pName = descriptor->fragmentStage->entryPoint;
}
std::array<VkVertexInputBindingDescription, kMaxVertexBuffers> mBindings;
std::array<VkVertexInputAttributeDescription, kMaxVertexAttributes> mAttributes;
const VertexInputDescriptor* vertexInput = GetVertexInputDescriptor();
PipelineVertexInputStateCreateInfoTemporaryAllocations tempAllocations;
VkPipelineVertexInputStateCreateInfo vertexInputCreateInfo =
ComputeVertexInputDesc(vertexInput, &mBindings, &mAttributes);
ComputeVertexInputDesc(&tempAllocations);
VkPipelineInputAssemblyStateCreateInfo inputAssembly;
inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
@ -507,32 +505,31 @@ namespace dawn_native { namespace vulkan {
}
VkPipelineVertexInputStateCreateInfo RenderPipeline::ComputeVertexInputDesc(
const VertexInputDescriptor* vertexInput,
std::array<VkVertexInputBindingDescription, kMaxVertexBuffers>* mBindings,
std::array<VkVertexInputAttributeDescription, kMaxVertexAttributes>* mAttributes) {
PipelineVertexInputStateCreateInfoTemporaryAllocations* tempAllocations) {
// Fill in the "binding info" that will be chained in the create info
uint32_t bindingCount = 0;
for (uint32_t i : IterateBitSet(GetInputsSetMask())) {
const auto& bindingInfo = GetInput(i);
for (uint32_t i : IterateBitSet(GetVertexBufferSlotsUsed())) {
const VertexBufferInfo& bindingInfo = GetVertexBuffer(i);
auto& bindingDesc = (*mBindings)[bindingCount];
bindingDesc.binding = i;
bindingDesc.stride = bindingInfo.stride;
bindingDesc.inputRate = VulkanInputRate(bindingInfo.stepMode);
VkVertexInputBindingDescription* bindingDesc = &tempAllocations->bindings[bindingCount];
bindingDesc->binding = i;
bindingDesc->stride = bindingInfo.arrayStride;
bindingDesc->inputRate = VulkanInputRate(bindingInfo.stepMode);
bindingCount++;
}
// Fill in the "attribute info" that will be chained in the create info
uint32_t attributeCount = 0;
for (uint32_t i : IterateBitSet(GetAttributesSetMask())) {
const auto& attributeInfo = GetAttribute(i);
for (uint32_t i : IterateBitSet(GetAttributeLocationsUsed())) {
const VertexAttributeInfo& attributeInfo = GetAttribute(i);
auto& attributeDesc = (*mAttributes)[attributeCount];
attributeDesc.location = i;
attributeDesc.binding = attributeInfo.inputSlot;
attributeDesc.format = VulkanVertexFormat(attributeInfo.format);
attributeDesc.offset = attributeInfo.offset;
VkVertexInputAttributeDescription* attributeDesc =
&tempAllocations->attributes[attributeCount];
attributeDesc->location = i;
attributeDesc->binding = attributeInfo.vertexBufferSlot;
attributeDesc->format = VulkanVertexFormat(attributeInfo.format);
attributeDesc->offset = attributeInfo.offset;
attributeCount++;
}
@ -543,9 +540,9 @@ namespace dawn_native { namespace vulkan {
mCreateInfo.pNext = nullptr;
mCreateInfo.flags = 0;
mCreateInfo.vertexBindingDescriptionCount = bindingCount;
mCreateInfo.pVertexBindingDescriptions = &(*mBindings)[0];
mCreateInfo.pVertexBindingDescriptions = tempAllocations->bindings.data();
mCreateInfo.vertexAttributeDescriptionCount = attributeCount;
mCreateInfo.pVertexAttributeDescriptions = &(*mAttributes)[0];
mCreateInfo.pVertexAttributeDescriptions = tempAllocations->attributes.data();
return mCreateInfo;
}

8
src/dawn_native/vulkan/RenderPipelineVk.h
View File

@ -36,10 +36,12 @@ namespace dawn_native { namespace vulkan {
using RenderPipelineBase::RenderPipelineBase;
MaybeError Initialize(const RenderPipelineDescriptor* descriptor);
struct PipelineVertexInputStateCreateInfoTemporaryAllocations {
std::array<VkVertexInputBindingDescription, kMaxVertexBuffers> bindings;
std::array<VkVertexInputAttributeDescription, kMaxVertexAttributes> attributes;
};
VkPipelineVertexInputStateCreateInfo ComputeVertexInputDesc(
const VertexInputDescriptor* vertexInput,
std::array<VkVertexInputBindingDescription, kMaxVertexBuffers>* mBindings,
std::array<VkVertexInputAttributeDescription, kMaxVertexAttributes>* mAttributes);
PipelineVertexInputStateCreateInfoTemporaryAllocations* temporaryAllocations);
VkPipeline mHandle = VK_NULL_HANDLE;
};

8
src/tests/end2end/DestroyTests.cpp
View File

@ -46,10 +46,10 @@ class DestroyTest : public DawnTest {
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.primitiveTopology = wgpu::PrimitiveTopology::TriangleStrip;
descriptor.cVertexInput.bufferCount = 1;
descriptor.cVertexInput.cBuffers[0].stride = 4 * sizeof(float);
descriptor.cVertexInput.cBuffers[0].attributeCount = 1;
descriptor.cVertexInput.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cVertexState.vertexBufferCount = 1;
descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cColorStates[0].format = renderPass.colorFormat;
pipeline = device.CreateRenderPipeline(&descriptor);

8
src/tests/end2end/DrawIndexedIndirectTests.cpp
View File

@ -46,10 +46,10 @@ class DrawIndexedIndirectTest : public DawnTest {
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.primitiveTopology = wgpu::PrimitiveTopology::TriangleStrip;
descriptor.cVertexInput.bufferCount = 1;
descriptor.cVertexInput.cBuffers[0].stride = 4 * sizeof(float);
descriptor.cVertexInput.cBuffers[0].attributeCount = 1;
descriptor.cVertexInput.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cVertexState.vertexBufferCount = 1;
descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cColorStates[0].format = renderPass.colorFormat;
pipeline = device.CreateRenderPipeline(&descriptor);

8
src/tests/end2end/DrawIndexedTests.cpp
View File

@ -46,10 +46,10 @@ class DrawIndexedTest : public DawnTest {
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.primitiveTopology = wgpu::PrimitiveTopology::TriangleStrip;
descriptor.cVertexInput.bufferCount = 1;
descriptor.cVertexInput.cBuffers[0].stride = 4 * sizeof(float);
descriptor.cVertexInput.cBuffers[0].attributeCount = 1;
descriptor.cVertexInput.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cVertexState.vertexBufferCount = 1;
descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cColorStates[0].format = renderPass.colorFormat;
pipeline = device.CreateRenderPipeline(&descriptor);

8
src/tests/end2end/DrawIndirectTests.cpp
View File

@ -46,10 +46,10 @@ class DrawIndirectTest : public DawnTest {
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.primitiveTopology = wgpu::PrimitiveTopology::TriangleStrip;
descriptor.cVertexInput.bufferCount = 1;
descriptor.cVertexInput.cBuffers[0].stride = 4 * sizeof(float);
descriptor.cVertexInput.cBuffers[0].attributeCount = 1;
descriptor.cVertexInput.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cVertexState.vertexBufferCount = 1;
descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cColorStates[0].format = renderPass.colorFormat;
pipeline = device.CreateRenderPipeline(&descriptor);

8
src/tests/end2end/DrawTests.cpp
View File

@ -46,10 +46,10 @@ class DrawTest : public DawnTest {
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.primitiveTopology = wgpu::PrimitiveTopology::TriangleStrip;
descriptor.cVertexInput.bufferCount = 1;
descriptor.cVertexInput.cBuffers[0].stride = 4 * sizeof(float);
descriptor.cVertexInput.cBuffers[0].attributeCount = 1;
descriptor.cVertexInput.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cVertexState.vertexBufferCount = 1;
descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cColorStates[0].format = renderPass.colorFormat;
pipeline = device.CreateRenderPipeline(&descriptor);

10
src/tests/end2end/IndexFormatTests.cpp
View File

@ -51,11 +51,11 @@ class IndexFormatTest : public DawnTest {
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.primitiveTopology = wgpu::PrimitiveTopology::TriangleStrip;
descriptor.cVertexInput.indexFormat = format;
descriptor.cVertexInput.bufferCount = 1;
descriptor.cVertexInput.cBuffers[0].stride = 4 * sizeof(float);
descriptor.cVertexInput.cBuffers[0].attributeCount = 1;
descriptor.cVertexInput.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cVertexState.indexFormat = format;
descriptor.cVertexState.vertexBufferCount = 1;
descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cColorStates[0].format = renderPass.colorFormat;
return device.CreateRenderPipeline(&descriptor);

8
src/tests/end2end/PrimitiveTopologyTests.cpp
View File

@ -187,10 +187,10 @@ class PrimitiveTopologyTest : public DawnTest {
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.primitiveTopology = primitiveTopology;
descriptor.cVertexInput.bufferCount = 1;
descriptor.cVertexInput.cBuffers[0].stride = 4 * sizeof(float);
descriptor.cVertexInput.cBuffers[0].attributeCount = 1;
descriptor.cVertexInput.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cVertexState.vertexBufferCount = 1;
descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cColorStates[0].format = renderPass.colorFormat;
wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor);

8
src/tests/end2end/RenderBundleTests.cpp
View File

@ -77,10 +77,10 @@ class RenderBundleTest : public DawnTest {
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.primitiveTopology = wgpu::PrimitiveTopology::TriangleStrip;
descriptor.cVertexInput.bufferCount = 1;
descriptor.cVertexInput.cBuffers[0].stride = 4 * sizeof(float);
descriptor.cVertexInput.cBuffers[0].attributeCount = 1;
descriptor.cVertexInput.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cVertexState.vertexBufferCount = 1;
descriptor.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
descriptor.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
descriptor.cColorStates[0].format = renderPass.colorFormat;
pipeline = device.CreateRenderPipeline(&descriptor);

8
src/tests/end2end/VertexFormatTests.cpp
View File

@ -362,10 +362,10 @@ class VertexFormatTest : public DawnTest {
utils::ComboRenderPipelineDescriptor descriptor(device);
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.cVertexInput.bufferCount = 1;
descriptor.cVertexInput.cBuffers[0].stride = strideBytes;
descriptor.cVertexInput.cBuffers[0].attributeCount = 1;
descriptor.cVertexInput.cAttributes[0].format = format;
descriptor.cVertexState.vertexBufferCount = 1;
descriptor.cVertexState.cVertexBuffers[0].arrayStride = strideBytes;
descriptor.cVertexState.cVertexBuffers[0].attributeCount = 1;
descriptor.cVertexState.cAttributes[0].format = format;
descriptor.cColorStates[0].format = renderPass.colorFormat;
return device.CreateRenderPipeline(&descriptor);

157
src/tests/end2end/VertexInputTests.cpp → src/tests/end2end/VertexStateTests.cpp
View File

@ -21,10 +21,11 @@
using wgpu::InputStepMode;
using wgpu::VertexFormat;
// 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 to the instance number.
// Each test will set up an input state and buffers, and the vertex shader will check that the vertex attributes
// corresponds to predetermined values. On success it outputs green, otherwise red.
// 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
// to the instance number. Each test will set up an input state and buffers, and the vertex shader
// will check that the vertex attributes corresponds to predetermined values. On success it outputs
// green, otherwise red.
//
// The predetermined values are "K * gl_VertexID + componentIndex" for vertex-indexed buffers, and
// "K * gl_InstanceID + componentIndex" for instance-indexed buffers.
@ -33,7 +34,7 @@ constexpr static unsigned int kRTSize = 400;
constexpr static unsigned int kRTCellOffset = 50;
constexpr static unsigned int kRTCellSize = 100;
class VertexInputTest : public DawnTest {
class VertexStateTest : public DawnTest {
protected:
void TestSetUp() override {
DawnTest::TestSetUp();
@ -64,7 +65,7 @@ class VertexInputTest : public DawnTest {
VertexFormat format;
InputStepMode step;
};
wgpu::RenderPipeline MakeTestPipeline(const wgpu::VertexInputDescriptor& vertexInput,
wgpu::RenderPipeline MakeTestPipeline(const wgpu::VertexStateDescriptor& vertexState,
int multiplier,
const std::vector<ShaderTestSpec>& testSpec) {
std::ostringstream vs;
@ -131,7 +132,7 @@ class VertexInputTest : public DawnTest {
utils::ComboRenderPipelineDescriptor descriptor(device);
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.vertexInput = &vertexInput;
descriptor.vertexState = &vertexState;
descriptor.cColorStates[0].format = renderPass.colorFormat;
return device.CreateRenderPipeline(&descriptor);
@ -143,37 +144,37 @@ class VertexInputTest : public DawnTest {
VertexFormat format;
};
struct VertexBufferSpec {
uint64_t stride;
uint64_t arrayStride;
InputStepMode step;
std::vector<VertexAttributeSpec> attributes;
};
utils::ComboVertexInputDescriptor MakeVertexInput(
utils::ComboVertexStateDescriptor MakeVertexState(
const std::vector<VertexBufferSpec>& buffers) {
utils::ComboVertexInputDescriptor vertexInput;
uint32_t bufferCount = 0;
utils::ComboVertexStateDescriptor vertexState;
uint32_t vertexBufferCount = 0;
uint32_t totalNumAttributes = 0;
for (const VertexBufferSpec& buffer : buffers) {
vertexInput.cBuffers[bufferCount].stride = buffer.stride;
vertexInput.cBuffers[bufferCount].stepMode = buffer.step;
vertexState.cVertexBuffers[vertexBufferCount].arrayStride = buffer.arrayStride;
vertexState.cVertexBuffers[vertexBufferCount].stepMode = buffer.step;
vertexInput.cBuffers[bufferCount].attributes =
&vertexInput.cAttributes[totalNumAttributes];
vertexState.cVertexBuffers[vertexBufferCount].attributes =
&vertexState.cAttributes[totalNumAttributes];
for (const VertexAttributeSpec& attribute : buffer.attributes) {
vertexInput.cAttributes[totalNumAttributes].shaderLocation = attribute.location;
vertexInput.cAttributes[totalNumAttributes].offset = attribute.offset;
vertexInput.cAttributes[totalNumAttributes].format = attribute.format;
vertexState.cAttributes[totalNumAttributes].shaderLocation = attribute.location;
vertexState.cAttributes[totalNumAttributes].offset = attribute.offset;
vertexState.cAttributes[totalNumAttributes].format = attribute.format;
totalNumAttributes++;
}
vertexInput.cBuffers[bufferCount].attributeCount =
vertexState.cVertexBuffers[vertexBufferCount].attributeCount =
static_cast<uint32_t>(buffer.attributes.size());
bufferCount++;
vertexBufferCount++;
}
vertexInput.bufferCount = bufferCount;
return vertexInput;
vertexState.vertexBufferCount = vertexBufferCount;
return vertexState;
}
template <typename T>
@ -232,11 +233,11 @@ class VertexInputTest : public DawnTest {
};
// Test compilation and usage of the fixture :)
TEST_P(VertexInputTest, Basic) {
utils::ComboVertexInputDescriptor vertexInput = MakeVertexInput(
TEST_P(VertexStateTest, Basic) {
utils::ComboVertexStateDescriptor vertexState = MakeVertexState(
{{4 * sizeof(float), InputStepMode::Vertex, {{0, 0, VertexFormat::Float4}}}});
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexInput, 1, {{0, VertexFormat::Float4, InputStepMode::Vertex}});
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float4, InputStepMode::Vertex}});
// clang-format off
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({
@ -249,14 +250,14 @@ TEST_P(VertexInputTest, Basic) {
}
// Test a stride of 0 works
TEST_P(VertexInputTest, ZeroStride) {
TEST_P(VertexStateTest, ZeroStride) {
// This test was failing only on AMD but the OpenGL backend doesn't gather PCI info yet.
DAWN_SKIP_TEST_IF(IsLinux() && IsOpenGL());
utils::ComboVertexInputDescriptor vertexInput =
MakeVertexInput({{0, InputStepMode::Vertex, {{0, 0, VertexFormat::Float4}}}});
utils::ComboVertexStateDescriptor vertexState =
MakeVertexState({{0, InputStepMode::Vertex, {{0, 0, VertexFormat::Float4}}}});
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexInput, 0, {{0, VertexFormat::Float4, InputStepMode::Vertex}});
MakeTestPipeline(vertexState, 0, {{0, VertexFormat::Float4, InputStepMode::Vertex}});
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({
0,
@ -268,36 +269,36 @@ TEST_P(VertexInputTest, ZeroStride) {
}
// Test attributes defaults to (0, 0, 0, 1) if the input state doesn't have all components
TEST_P(VertexInputTest, AttributeExpanding) {
TEST_P(VertexStateTest, AttributeExpanding) {
// This test was failing only on AMD but the OpenGL backend doesn't gather PCI info yet.
DAWN_SKIP_TEST_IF(IsLinux() && IsOpenGL());
// R32F case
{
utils::ComboVertexInputDescriptor vertexInput =
MakeVertexInput({{0, InputStepMode::Vertex, {{0, 0, VertexFormat::Float}}}});
utils::ComboVertexStateDescriptor vertexState =
MakeVertexState({{0, InputStepMode::Vertex, {{0, 0, VertexFormat::Float}}}});
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexInput, 0, {{0, VertexFormat::Float, InputStepMode::Vertex}});
MakeTestPipeline(vertexState, 0, {{0, VertexFormat::Float, InputStepMode::Vertex}});
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({0, 1, 2, 3});
DoTestDraw(pipeline, 1, 1, {DrawVertexBuffer{0, &buffer0}});
}
// RG32F case
{
utils::ComboVertexInputDescriptor vertexInput =
MakeVertexInput({{0, InputStepMode::Vertex, {{0, 0, VertexFormat::Float2}}}});
utils::ComboVertexStateDescriptor vertexState =
MakeVertexState({{0, InputStepMode::Vertex, {{0, 0, VertexFormat::Float2}}}});
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexInput, 0, {{0, VertexFormat::Float2, InputStepMode::Vertex}});
MakeTestPipeline(vertexState, 0, {{0, VertexFormat::Float2, InputStepMode::Vertex}});
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({0, 1, 2, 3});
DoTestDraw(pipeline, 1, 1, {DrawVertexBuffer{0, &buffer0}});
}
// RGB32F case
{
utils::ComboVertexInputDescriptor vertexInput =
MakeVertexInput({{0, InputStepMode::Vertex, {{0, 0, VertexFormat::Float3}}}});
utils::ComboVertexStateDescriptor vertexState =
MakeVertexState({{0, InputStepMode::Vertex, {{0, 0, VertexFormat::Float3}}}});
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexInput, 0, {{0, VertexFormat::Float3, InputStepMode::Vertex}});
MakeTestPipeline(vertexState, 0, {{0, VertexFormat::Float3, InputStepMode::Vertex}});
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({0, 1, 2, 3});
DoTestDraw(pipeline, 1, 1, {DrawVertexBuffer{0, &buffer0}});
@ -305,14 +306,14 @@ TEST_P(VertexInputTest, AttributeExpanding) {
}
// Test a stride larger than the attributes
TEST_P(VertexInputTest, StrideLargerThanAttributes) {
TEST_P(VertexStateTest, StrideLargerThanAttributes) {
// This test was failing only on AMD but the OpenGL backend doesn't gather PCI info yet.
DAWN_SKIP_TEST_IF(IsLinux() && IsOpenGL());
utils::ComboVertexInputDescriptor vertexInput = MakeVertexInput(
utils::ComboVertexStateDescriptor vertexState = MakeVertexState(
{{8 * sizeof(float), InputStepMode::Vertex, {{0, 0, VertexFormat::Float4}}}});
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexInput, 1, {{0, VertexFormat::Float4, InputStepMode::Vertex}});
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float4, InputStepMode::Vertex}});
// clang-format off
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({
@ -325,13 +326,13 @@ TEST_P(VertexInputTest, StrideLargerThanAttributes) {
}
// Test two attributes at an offset, vertex version
TEST_P(VertexInputTest, TwoAttributesAtAnOffsetVertex) {
utils::ComboVertexInputDescriptor vertexInput = MakeVertexInput(
TEST_P(VertexStateTest, TwoAttributesAtAnOffsetVertex) {
utils::ComboVertexStateDescriptor vertexState = MakeVertexState(
{{8 * sizeof(float),
InputStepMode::Vertex,
{{0, 0, VertexFormat::Float4}, {1, 4 * sizeof(float), VertexFormat::Float4}}}});
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexInput, 1, {{0, VertexFormat::Float4, InputStepMode::Vertex}});
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float4, InputStepMode::Vertex}});
// clang-format off
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({
@ -344,13 +345,13 @@ TEST_P(VertexInputTest, TwoAttributesAtAnOffsetVertex) {
}
// Test two attributes at an offset, instance version
TEST_P(VertexInputTest, TwoAttributesAtAnOffsetInstance) {
utils::ComboVertexInputDescriptor vertexInput = MakeVertexInput(
TEST_P(VertexStateTest, TwoAttributesAtAnOffsetInstance) {
utils::ComboVertexStateDescriptor vertexState = MakeVertexState(
{{8 * sizeof(float),
InputStepMode::Instance,
{{0, 0, VertexFormat::Float4}, {1, 4 * sizeof(float), VertexFormat::Float4}}}});
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexInput, 1, {{0, VertexFormat::Float4, InputStepMode::Instance}});
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float4, InputStepMode::Instance}});
// clang-format off
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({
@ -363,11 +364,11 @@ TEST_P(VertexInputTest, TwoAttributesAtAnOffsetInstance) {
}
// Test a pure-instance input state
TEST_P(VertexInputTest, PureInstance) {
utils::ComboVertexInputDescriptor vertexInput = MakeVertexInput(
TEST_P(VertexStateTest, PureInstance) {
utils::ComboVertexStateDescriptor vertexState = MakeVertexState(
{{4 * sizeof(float), InputStepMode::Instance, {{0, 0, VertexFormat::Float4}}}});
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexInput, 1, {{0, VertexFormat::Float4, InputStepMode::Instance}});
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float4, InputStepMode::Instance}});
// clang-format off
wgpu::Buffer buffer0 = MakeVertexBuffer<float>({
@ -382,8 +383,8 @@ TEST_P(VertexInputTest, PureInstance) {
// Test with mixed everything, vertex vs. instance, different stride and offsets
// different attribute types
TEST_P(VertexInputTest, MixedEverything) {
utils::ComboVertexInputDescriptor vertexInput = MakeVertexInput(
TEST_P(VertexStateTest, MixedEverything) {
utils::ComboVertexStateDescriptor vertexState = MakeVertexState(
{{12 * sizeof(float),
InputStepMode::Vertex,
{{0, 0, VertexFormat::Float}, {1, 6 * sizeof(float), VertexFormat::Float2}}},
@ -391,7 +392,7 @@ TEST_P(VertexInputTest, MixedEverything) {
InputStepMode::Instance,
{{2, 0, VertexFormat::Float3}, {3, 5 * sizeof(float), VertexFormat::Float4}}}});
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexInput, 1,
MakeTestPipeline(vertexState, 1,
{{0, VertexFormat::Float, InputStepMode::Vertex},
{1, VertexFormat::Float2, InputStepMode::Vertex},
{2, VertexFormat::Float3, InputStepMode::Instance},
@ -415,13 +416,13 @@ TEST_P(VertexInputTest, MixedEverything) {
}
// Test input state is unaffected by unused vertex slot
TEST_P(VertexInputTest, UnusedVertexSlot) {
TEST_P(VertexStateTest, UnusedVertexSlot) {
// Instance input state, using slot 1
utils::ComboVertexInputDescriptor instanceVertexInput = MakeVertexInput(
utils::ComboVertexStateDescriptor instanceVertexState = MakeVertexState(
{{0, InputStepMode::Vertex, {}},
{4 * sizeof(float), InputStepMode::Instance, {{0, 0, VertexFormat::Float4}}}});
wgpu::RenderPipeline instancePipeline = MakeTestPipeline(
instanceVertexInput, 1, {{0, VertexFormat::Float4, InputStepMode::Instance}});
instanceVertexState, 1, {{0, VertexFormat::Float4, InputStepMode::Instance}});
// clang-format off
wgpu::Buffer buffer = MakeVertexBuffer<float>({
@ -454,19 +455,19 @@ TEST_P(VertexInputTest, UnusedVertexSlot) {
// This was a problem with the D3D12 backend where SetVertexBuffer
// was getting the input from the last set pipeline, not the current.
// SetVertexBuffer should be reapplied when the input state changes.
TEST_P(VertexInputTest, MultiplePipelinesMixedVertexInput) {
TEST_P(VertexStateTest, MultiplePipelinesMixedVertexState) {
// Basic input state, using slot 0
utils::ComboVertexInputDescriptor vertexVertexInput = MakeVertexInput(
utils::ComboVertexStateDescriptor vertexVertexState = MakeVertexState(
{{4 * sizeof(float), InputStepMode::Vertex, {{0, 0, VertexFormat::Float4}}}});
wgpu::RenderPipeline vertexPipeline =
MakeTestPipeline(vertexVertexInput, 1, {{0, VertexFormat::Float4, InputStepMode::Vertex}});
MakeTestPipeline(vertexVertexState, 1, {{0, VertexFormat::Float4, InputStepMode::Vertex}});
// Instance input state, using slot 1
utils::ComboVertexInputDescriptor instanceVertexInput = MakeVertexInput(
utils::ComboVertexStateDescriptor instanceVertexState = MakeVertexState(
{{0, InputStepMode::Instance, {}},
{4 * sizeof(float), InputStepMode::Instance, {{0, 0, VertexFormat::Float4}}}});
wgpu::RenderPipeline instancePipeline = MakeTestPipeline(
instanceVertexInput, 1, {{0, VertexFormat::Float4, InputStepMode::Instance}});
instanceVertexState, 1, {{0, VertexFormat::Float4, InputStepMode::Instance}});
// clang-format off
wgpu::Buffer buffer = MakeVertexBuffer<float>({
@ -499,28 +500,28 @@ TEST_P(VertexInputTest, MultiplePipelinesMixedVertexInput) {
}
// Checks that using the last vertex buffer doesn't overflow the vertex buffer table in Metal.
TEST_P(VertexInputTest, LastAllowedVertexBuffer) {
TEST_P(VertexStateTest, LastAllowedVertexBuffer) {
constexpr uint32_t kBufferIndex = kMaxVertexBuffers - 1;
utils::ComboVertexInputDescriptor vertexInput;
utils::ComboVertexStateDescriptor vertexState;
// All the other vertex buffers default to no attributes
vertexInput.bufferCount = kMaxVertexBuffers;
vertexInput.cBuffers[kBufferIndex].stride = 4 * sizeof(float);
vertexInput.cBuffers[kBufferIndex].stepMode = InputStepMode::Vertex;
vertexInput.cBuffers[kBufferIndex].attributeCount = 1;
vertexInput.cBuffers[kBufferIndex].attributes = &vertexInput.cAttributes[0];
vertexInput.cAttributes[0].shaderLocation = 0;
vertexInput.cAttributes[0].offset = 0;
vertexInput.cAttributes[0].format = VertexFormat::Float4;
vertexState.vertexBufferCount = kMaxVertexBuffers;
vertexState.cVertexBuffers[kBufferIndex].arrayStride = 4 * sizeof(float);
vertexState.cVertexBuffers[kBufferIndex].stepMode = InputStepMode::Vertex;
vertexState.cVertexBuffers[kBufferIndex].attributeCount = 1;
vertexState.cVertexBuffers[kBufferIndex].attributes = &vertexState.cAttributes[0];
vertexState.cAttributes[0].shaderLocation = 0;
vertexState.cAttributes[0].offset = 0;
vertexState.cAttributes[0].format = VertexFormat::Float4;
wgpu::RenderPipeline pipeline =
MakeTestPipeline(vertexInput, 1, {{0, VertexFormat::Float4, InputStepMode::Vertex}});
MakeTestPipeline(vertexState, 1, {{0, VertexFormat::Float4, InputStepMode::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}});
}
DAWN_INSTANTIATE_TEST(VertexInputTest, D3D12Backend, MetalBackend, OpenGLBackend, VulkanBackend);
DAWN_INSTANTIATE_TEST(VertexStateTest, D3D12Backend, MetalBackend, OpenGLBackend, VulkanBackend);
// TODO for the input state:
// - Add more vertex formats
@ -530,10 +531,10 @@ DAWN_INSTANTIATE_TEST(VertexInputTest, D3D12Backend, MetalBackend, OpenGLBackend
// - Check for attribute narrowing
// - Check that the input state and the pipeline vertex input types match
class OptionalVertexInputTest : public DawnTest {};
class OptionalVertexStateTest : public DawnTest {};
// Test that vertex input is not required in render pipeline descriptor.
TEST_P(OptionalVertexInputTest, Basic) {
TEST_P(OptionalVertexStateTest, Basic) {
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 3, 3);
wgpu::ShaderModule vsModule =
@ -556,7 +557,7 @@ TEST_P(OptionalVertexInputTest, Basic) {
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.primitiveTopology = wgpu::PrimitiveTopology::PointList;
descriptor.vertexInput = nullptr;
descriptor.vertexState = nullptr;
wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor);
@ -574,7 +575,7 @@ TEST_P(OptionalVertexInputTest, Basic) {
EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), renderPass.color, 1, 1);
}
DAWN_INSTANTIATE_TEST(OptionalVertexInputTest,
DAWN_INSTANTIATE_TEST(OptionalVertexStateTest,
D3D12Backend,
MetalBackend,
OpenGLBackend,

8
src/tests/perf_tests/DrawCallPerf.cpp
View File

@ -346,10 +346,10 @@ void DrawCallPerf::TestSetUp() {
// Setup the base render pipeline descriptor.
utils::ComboRenderPipelineDescriptor renderPipelineDesc(device);
renderPipelineDesc.cVertexInput.bufferCount = 1;
renderPipelineDesc.cVertexInput.cBuffers[0].stride = 4 * sizeof(float);
renderPipelineDesc.cVertexInput.cBuffers[0].attributeCount = 1;
renderPipelineDesc.cVertexInput.cAttributes[0].format = wgpu::VertexFormat::Float4;
renderPipelineDesc.cVertexState.vertexBufferCount = 1;
renderPipelineDesc.cVertexState.cVertexBuffers[0].arrayStride = 4 * sizeof(float);
renderPipelineDesc.cVertexState.cVertexBuffers[0].attributeCount = 1;
renderPipelineDesc.cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float4;
renderPipelineDesc.depthStencilState = &renderPipelineDesc.cDepthStencilState;
renderPipelineDesc.cDepthStencilState.format = wgpu::TextureFormat::Depth24PlusStencil8;
renderPipelineDesc.cColorStates[0].format = wgpu::TextureFormat::RGBA8Unorm;

10
src/tests/unittests/validation/RenderBundleValidationTests.cpp
View File

@ -98,11 +98,11 @@ namespace {
descriptor->layout = pipelineLayout;
descriptor->vertexStage.module = vsModule;
descriptor->cFragmentStage.module = fsModule;
descriptor->cVertexInput.bufferCount = 1;
descriptor->cVertexInput.cBuffers[0].stride = 2 * sizeof(float);
descriptor->cVertexInput.cBuffers[0].attributeCount = 1;
descriptor->cVertexInput.cAttributes[0].format = wgpu::VertexFormat::Float2;
descriptor->cVertexInput.cAttributes[0].shaderLocation = 0;
descriptor->cVertexState.vertexBufferCount = 1;
descriptor->cVertexState.cVertexBuffers[0].arrayStride = 2 * sizeof(float);
descriptor->cVertexState.cVertexBuffers[0].attributeCount = 1;
descriptor->cVertexState.cAttributes[0].format = wgpu::VertexFormat::Float2;
descriptor->cVertexState.cAttributes[0].shaderLocation = 0;
}
wgpu::ShaderModule vsModule;

2
src/tests/unittests/validation/RenderPipelineValidationTests.cpp
View File

@ -57,7 +57,7 @@ TEST_F(RenderPipelineValidationTest, CreationSuccess) {
utils::ComboRenderPipelineDescriptor descriptor(device);
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.vertexInput = nullptr;
descriptor.vertexState = nullptr;
device.CreateRenderPipeline(&descriptor);
}

12
src/tests/unittests/validation/VertexBufferValidationTests.cpp
View File

@ -70,13 +70,13 @@ class VertexBufferValidationTest : public ValidationTest {
descriptor.cFragmentStage.module = fsModule;
for (unsigned int i = 0; i < bufferCount; ++i) {
descriptor.cVertexInput.cBuffers[i].attributeCount = 1;
descriptor.cVertexInput.cBuffers[i].attributes =
&descriptor.cVertexInput.cAttributes[i];
descriptor.cVertexInput.cAttributes[i].shaderLocation = i;
descriptor.cVertexInput.cAttributes[i].format = wgpu::VertexFormat::Float3;
descriptor.cVertexState.cVertexBuffers[i].attributeCount = 1;
descriptor.cVertexState.cVertexBuffers[i].attributes =
&descriptor.cVertexState.cAttributes[i];
descriptor.cVertexState.cAttributes[i].shaderLocation = i;
descriptor.cVertexState.cAttributes[i].format = wgpu::VertexFormat::Float3;
}
descriptor.cVertexInput.bufferCount = bufferCount;
descriptor.cVertexState.vertexBufferCount = bufferCount;
return device.CreateRenderPipeline(&descriptor);
}

218
src/tests/unittests/validation/VertexInputValidationTests.cpp → src/tests/unittests/validation/VertexStateValidationTests.cpp
View File

@ -17,10 +17,10 @@
#include "utils/ComboRenderPipelineDescriptor.h"
#include "utils/WGPUHelpers.h"
class VertexInputTest : public ValidationTest {
class VertexStateTest : public ValidationTest {
protected:
void CreatePipeline(bool success,
const utils::ComboVertexInputDescriptor& state,
const utils::ComboVertexStateDescriptor& state,
std::string vertexSource) {
wgpu::ShaderModule vsModule = utils::CreateShaderModule(
device, utils::SingleShaderStage::Vertex, vertexSource.c_str());
@ -36,7 +36,7 @@ class VertexInputTest : public ValidationTest {
utils::ComboRenderPipelineDescriptor descriptor(device);
descriptor.vertexStage.module = vsModule;
descriptor.cFragmentStage.module = fsModule;
descriptor.vertexInput = &state;
descriptor.vertexState = &state;
descriptor.cColorStates[0].format = wgpu::TextureFormat::RGBA8Unorm;
if (!success) {
@ -48,8 +48,8 @@ class VertexInputTest : public ValidationTest {
};
// Check an empty vertex input is valid
TEST_F(VertexInputTest, EmptyIsOk) {
utils::ComboVertexInputDescriptor state;
TEST_F(VertexStateTest, EmptyIsOk) {
utils::ComboVertexStateDescriptor state;
CreatePipeline(true, state, R"(
#version 450
void main() {
@ -59,13 +59,13 @@ TEST_F(VertexInputTest, EmptyIsOk) {
}
// Check null buffer is valid
TEST_F(VertexInputTest, NullBufferIsOk) {
utils::ComboVertexInputDescriptor state;
TEST_F(VertexStateTest, NullBufferIsOk) {
utils::ComboVertexStateDescriptor state;
// One null buffer (buffer[0]) is OK
state.bufferCount = 1;
state.cBuffers[0].stride = 0;
state.cBuffers[0].attributeCount = 0;
state.cBuffers[0].attributes = nullptr;
state.vertexBufferCount = 1;
state.cVertexBuffers[0].arrayStride = 0;
state.cVertexBuffers[0].attributeCount = 0;
state.cVertexBuffers[0].attributes = nullptr;
CreatePipeline(true, state, R"(
#version 450
void main() {
@ -74,10 +74,10 @@ TEST_F(VertexInputTest, NullBufferIsOk) {
)");
// One null buffer (buffer[0]) followed by a buffer (buffer[1]) is OK
state.bufferCount = 2;
state.cBuffers[1].stride = 0;
state.cBuffers[1].attributeCount = 1;
state.cBuffers[1].attributes = &state.cAttributes[0];
state.vertexBufferCount = 2;
state.cVertexBuffers[1].arrayStride = 0;
state.cVertexBuffers[1].attributeCount = 1;
state.cVertexBuffers[1].attributes = &state.cAttributes[0];
state.cAttributes[0].shaderLocation = 0;
CreatePipeline(true, state, R"(
#version 450
@ -87,11 +87,11 @@ TEST_F(VertexInputTest, NullBufferIsOk) {
)");
// Null buffer (buffer[2]) sitting between buffers (buffer[1] and buffer[3]) is OK
state.bufferCount = 4;
state.cBuffers[2].attributeCount = 0;
state.cBuffers[2].attributes = nullptr;
state.cBuffers[3].attributeCount = 1;
state.cBuffers[3].attributes = &state.cAttributes[1];
state.vertexBufferCount = 4;
state.cVertexBuffers[2].attributeCount = 0;
state.cVertexBuffers[2].attributes = nullptr;
state.cVertexBuffers[3].attributeCount = 1;
state.cVertexBuffers[3].attributes = &state.cAttributes[1];
state.cAttributes[1].shaderLocation = 1;
CreatePipeline(true, state, R"(
#version 450
@ -103,11 +103,11 @@ TEST_F(VertexInputTest, NullBufferIsOk) {
// Check validation that pipeline vertex buffers are backed by attributes in the vertex input
// Check validation that pipeline vertex buffers are backed by attributes in the vertex input
TEST_F(VertexInputTest, PipelineCompatibility) {
utils::ComboVertexInputDescriptor state;
state.bufferCount = 1;
state.cBuffers[0].stride = 2 * sizeof(float);
state.cBuffers[0].attributeCount = 2;
TEST_F(VertexStateTest, PipelineCompatibility) {
utils::ComboVertexStateDescriptor state;
state.vertexBufferCount = 1;
state.cVertexBuffers[0].arrayStride = 2 * sizeof(float);
state.cVertexBuffers[0].attributeCount = 2;
state.cAttributes[0].shaderLocation = 0;
state.cAttributes[1].shaderLocation = 1;
state.cAttributes[1].offset = sizeof(float);
@ -122,7 +122,7 @@ TEST_F(VertexInputTest, PipelineCompatibility) {
}
)");
// Check it is valid for the pipeline to use a subset of the VertexInput
// Check it is valid for the pipeline to use a subset of the VertexState
CreatePipeline(true, state, R"(
#version 450
layout(location = 0) in vec4 a;
@ -141,13 +141,13 @@ TEST_F(VertexInputTest, PipelineCompatibility) {
)");
}
// Test that a stride of 0 is valid
TEST_F(VertexInputTest, StrideZero) {
// Test that a arrayStride of 0 is valid
TEST_F(VertexStateTest, StrideZero) {
// Works ok without attributes
utils::ComboVertexInputDescriptor state;
state.bufferCount = 1;
state.cBuffers[0].stride = 0;
state.cBuffers[0].attributeCount = 1;
utils::ComboVertexStateDescriptor state;
state.vertexBufferCount = 1;
state.cVertexBuffers[0].arrayStride = 0;
state.cVertexBuffers[0].attributeCount = 1;
CreatePipeline(true, state, R"(
#version 450
void main() {
@ -165,14 +165,14 @@ TEST_F(VertexInputTest, StrideZero) {
)");
}
// Check validation that vertex attribute offset should be within vertex buffer stride,
// if vertex buffer stride is not zero.
TEST_F(VertexInputTest, SetOffsetOutOfBounds) {
// Control case, setting correct stride and offset
utils::ComboVertexInputDescriptor state;
state.bufferCount = 1;
state.cBuffers[0].stride = 2 * sizeof(float);
state.cBuffers[0].attributeCount = 2;
// Check validation that vertex attribute offset should be within vertex buffer arrayStride,
// if vertex buffer arrayStride is not zero.
TEST_F(VertexStateTest, SetOffsetOutOfBounds) {
// Control case, setting correct arrayStride and offset
utils::ComboVertexStateDescriptor state;
state.vertexBufferCount = 1;
state.cVertexBuffers[0].arrayStride = 2 * sizeof(float);
state.cVertexBuffers[0].attributeCount = 2;
state.cAttributes[0].shaderLocation = 0;
state.cAttributes[1].shaderLocation = 1;
state.cAttributes[1].offset = sizeof(float);
@ -183,8 +183,8 @@ TEST_F(VertexInputTest, SetOffsetOutOfBounds) {
}
)");
// Test vertex attribute offset exceed vertex buffer stride range
state.cBuffers[0].stride = sizeof(float);
// Test vertex attribute offset exceed vertex buffer arrayStride range
state.cVertexBuffers[0].arrayStride = sizeof(float);
CreatePipeline(false, state, R"(
#version 450
void main() {
@ -192,8 +192,8 @@ TEST_F(VertexInputTest, SetOffsetOutOfBounds) {
}
)");
// It's OK if stride is zero
state.cBuffers[0].stride = 0;
// It's OK if arrayStride is zero
state.cVertexBuffers[0].arrayStride = 0;
CreatePipeline(true, state, R"(
#version 450
void main() {
@ -203,13 +203,13 @@ TEST_F(VertexInputTest, SetOffsetOutOfBounds) {
}
// Check out of bounds condition on total number of vertex buffers
TEST_F(VertexInputTest, SetVertexBuffersNumLimit) {
TEST_F(VertexStateTest, SetVertexBuffersNumLimit) {
// Control case, setting max vertex buffer number
utils::ComboVertexInputDescriptor state;
state.bufferCount = kMaxVertexBuffers;
utils::ComboVertexStateDescriptor state;
state.vertexBufferCount = kMaxVertexBuffers;
for (uint32_t i = 0; i < kMaxVertexBuffers; ++i) {
state.cBuffers[i].attributeCount = 1;
state.cBuffers[i].attributes = &state.cAttributes[i];
state.cVertexBuffers[i].attributeCount = 1;
state.cVertexBuffers[i].attributes = &state.cAttributes[i];
state.cAttributes[i].shaderLocation = i;
}
CreatePipeline(true, state, R"(
@ -220,7 +220,7 @@ TEST_F(VertexInputTest, SetVertexBuffersNumLimit) {
)");
// Test vertex buffer number exceed the limit
state.bufferCount = kMaxVertexBuffers + 1;
state.vertexBufferCount = kMaxVertexBuffers + 1;
CreatePipeline(false, state, R"(
#version 450
void main() {
@ -230,11 +230,11 @@ TEST_F(VertexInputTest, SetVertexBuffersNumLimit) {
}
// Check out of bounds condition on total number of vertex attributes
TEST_F(VertexInputTest, SetVertexAttributesNumLimit) {
TEST_F(VertexStateTest, SetVertexAttributesNumLimit) {
// Control case, setting max vertex attribute number
utils::ComboVertexInputDescriptor state;
state.bufferCount = 2;
state.cBuffers[0].attributeCount = kMaxVertexAttributes;
utils::ComboVertexStateDescriptor state;
state.vertexBufferCount = 2;
state.cVertexBuffers[0].attributeCount = kMaxVertexAttributes;
for (uint32_t i = 0; i < kMaxVertexAttributes; ++i) {
state.cAttributes[i].shaderLocation = i;
}
@ -246,8 +246,8 @@ TEST_F(VertexInputTest, SetVertexAttributesNumLimit) {
)");
// Test vertex attribute number exceed the limit
state.cBuffers[1].attributeCount = 1;
state.cBuffers[1].attributes = &state.cAttributes[kMaxVertexAttributes - 1];
state.cVertexBuffers[1].attributeCount = 1;
state.cVertexBuffers[1].attributes = &state.cAttributes[kMaxVertexAttributes - 1];
CreatePipeline(false, state, R"(
#version 450
void main() {
@ -256,13 +256,13 @@ TEST_F(VertexInputTest, SetVertexAttributesNumLimit) {
)");
}
// Check out of bounds condition on input stride
TEST_F(VertexInputTest, SetInputStrideOutOfBounds) {
// Control case, setting max input stride
utils::ComboVertexInputDescriptor state;
state.bufferCount = 1;
state.cBuffers[0].stride = kMaxVertexBufferStride;
state.cBuffers[0].attributeCount = 1;
// Check out of bounds condition on input arrayStride
TEST_F(VertexStateTest, SetInputStrideOutOfBounds) {
// Control case, setting max input arrayStride
utils::ComboVertexStateDescriptor state;
state.vertexBufferCount = 1;
state.cVertexBuffers[0].arrayStride = kMaxVertexBufferStride;
state.cVertexBuffers[0].attributeCount = 1;
CreatePipeline(true, state, R"(
#version 450
void main() {
@ -270,8 +270,8 @@ TEST_F(VertexInputTest, SetInputStrideOutOfBounds) {
}
)");
// Test input stride OOB
state.cBuffers[0].stride = kMaxVertexBufferStride + 1;
// Test input arrayStride OOB
state.cVertexBuffers[0].arrayStride = kMaxVertexBufferStride + 1;
CreatePipeline(false, state, R"(
#version 450
void main() {
@ -280,13 +280,13 @@ TEST_F(VertexInputTest, SetInputStrideOutOfBounds) {
)");
}
// Check multiple of 4 bytes constraint on input stride
TEST_F(VertexInputTest, SetInputStrideNotAligned) {
// Control case, setting input stride 4 bytes.
utils::ComboVertexInputDescriptor state;
state.bufferCount = 1;
state.cBuffers[0].stride = 4;
state.cBuffers[0].attributeCount = 1;
// Check multiple of 4 bytes constraint on input arrayStride
TEST_F(VertexStateTest, SetInputStrideNotAligned) {
// Control case, setting input arrayStride 4 bytes.
utils::ComboVertexStateDescriptor state;
state.vertexBufferCount = 1;
state.cVertexBuffers[0].arrayStride = 4;
state.cVertexBuffers[0].attributeCount = 1;
CreatePipeline(true, state, R"(
#version 450
void main() {
@ -294,8 +294,8 @@ TEST_F(VertexInputTest, SetInputStrideNotAligned) {
}
)");
// Test input stride not multiple of 4 bytes
state.cBuffers[0].stride = 2;
// Test input arrayStride not multiple of 4 bytes
state.cVertexBuffers[0].arrayStride = 2;
CreatePipeline(false, state, R"(
#version 450
void main() {
@ -305,11 +305,11 @@ TEST_F(VertexInputTest, SetInputStrideNotAligned) {
}
// Test that we cannot set an already set attribute
TEST_F(VertexInputTest, AlreadySetAttribute) {
TEST_F(VertexStateTest, AlreadySetAttribute) {
// Control case, setting attribute 0
utils::ComboVertexInputDescriptor state;
state.bufferCount = 1;
state.cBuffers[0].attributeCount = 1;
utils::ComboVertexStateDescriptor state;
state.vertexBufferCount = 1;
state.cVertexBuffers[0].attributeCount = 1;
state.cAttributes[0].shaderLocation = 0;
CreatePipeline(true, state, R"(
#version 450
@ -319,7 +319,7 @@ TEST_F(VertexInputTest, AlreadySetAttribute) {
)");
// Oh no, attribute 0 is set twice
state.cBuffers[0].attributeCount = 2;
state.cVertexBuffers[0].attributeCount = 2;
state.cAttributes[0].shaderLocation = 0;
state.cAttributes[1].shaderLocation = 0;
CreatePipeline(false, state, R"(
@ -330,12 +330,12 @@ TEST_F(VertexInputTest, AlreadySetAttribute) {
)");
}
// Test that a stride of 0 is valid
TEST_F(VertexInputTest, SetSameShaderLocation) {
// Test that a arrayStride of 0 is valid
TEST_F(VertexStateTest, SetSameShaderLocation) {
// Control case, setting different shader locations in two attributes
utils::ComboVertexInputDescriptor state;
state.bufferCount = 1;
state.cBuffers[0].attributeCount = 2;
utils::ComboVertexStateDescriptor state;
state.vertexBufferCount = 1;
state.cVertexBuffers[0].attributeCount = 2;
state.cAttributes[0].shaderLocation = 0;
state.cAttributes[1].shaderLocation = 1;
state.cAttributes[1].offset = sizeof(float);
@ -356,11 +356,11 @@ TEST_F(VertexInputTest, SetSameShaderLocation) {
)");
// Test same shader location in two attributes in different buffers
state.bufferCount = 2;
state.cBuffers[0].attributeCount = 1;
state.vertexBufferCount = 2;
state.cVertexBuffers[0].attributeCount = 1;
state.cAttributes[0].shaderLocation = 0;
state.cBuffers[1].attributeCount = 1;
state.cBuffers[1].attributes = &state.cAttributes[1];
state.cVertexBuffers[1].attributeCount = 1;
state.cVertexBuffers[1].attributes = &state.cAttributes[1];
state.cAttributes[1].shaderLocation = 0;
CreatePipeline(false, state, R"(
#version 450
@ -371,11 +371,11 @@ TEST_F(VertexInputTest, SetSameShaderLocation) {
}
// Check out of bounds condition on attribute shader location
TEST_F(VertexInputTest, SetAttributeLocationOutOfBounds) {
TEST_F(VertexStateTest, SetAttributeLocationOutOfBounds) {
// Control case, setting last attribute shader location
utils::ComboVertexInputDescriptor state;
state.bufferCount = 1;
state.cBuffers[0].attributeCount = 1;
utils::ComboVertexStateDescriptor state;
state.vertexBufferCount = 1;
state.cVertexBuffers[0].attributeCount = 1;
state.cAttributes[0].shaderLocation = kMaxVertexAttributes - 1;
CreatePipeline(true, state, R"(
#version 450
@ -395,11 +395,11 @@ TEST_F(VertexInputTest, SetAttributeLocationOutOfBounds) {
}
// Check attribute offset out of bounds
TEST_F(VertexInputTest, SetAttributeOffsetOutOfBounds) {
TEST_F(VertexStateTest, SetAttributeOffsetOutOfBounds) {
// Control case, setting max attribute offset for FloatR32 vertex format
utils::ComboVertexInputDescriptor state;
state.bufferCount = 1;
state.cBuffers[0].attributeCount = 1;
utils::ComboVertexStateDescriptor state;
state.vertexBufferCount = 1;
state.cVertexBuffers[0].attributeCount = 1;
state.cAttributes[0].offset = kMaxVertexAttributeEnd - sizeof(wgpu::VertexFormat::Float);
CreatePipeline(true, state, R"(
#version 450
@ -419,11 +419,11 @@ TEST_F(VertexInputTest, SetAttributeOffsetOutOfBounds) {
}
// Check multiple of 4 bytes constraint on offset
TEST_F(VertexInputTest, SetOffsetNotAligned) {
TEST_F(VertexStateTest, SetOffsetNotAligned) {
// Control case, setting offset 4 bytes.
utils::ComboVertexInputDescriptor state;
state.bufferCount = 1;
state.cBuffers[0].attributeCount = 1;
utils::ComboVertexStateDescriptor state;
state.vertexBufferCount = 1;
state.cVertexBuffers[0].attributeCount = 1;
state.cAttributes[0].offset = 4;
CreatePipeline(true, state, R"(
#version 450
@ -443,10 +443,10 @@ TEST_F(VertexInputTest, SetOffsetNotAligned) {
}
// Check attribute offset overflow
TEST_F(VertexInputTest, SetAttributeOffsetOverflow) {
utils::ComboVertexInputDescriptor state;
state.bufferCount = 1;
state.cBuffers[0].attributeCount = 1;
TEST_F(VertexStateTest, SetAttributeOffsetOverflow) {
utils::ComboVertexStateDescriptor state;
state.vertexBufferCount = 1;
state.cVertexBuffers[0].attributeCount = 1;
state.cAttributes[0].offset = std::numeric_limits<uint32_t>::max();
CreatePipeline(false, state, R"(
#version 450
@ -457,11 +457,11 @@ TEST_F(VertexInputTest, SetAttributeOffsetOverflow) {
}
// Check for some potential underflow in the vertex input validation
TEST_F(VertexInputTest, VertexFormatLargerThanNonZeroStride) {
utils::ComboVertexInputDescriptor state;
state.bufferCount = 1;
state.cBuffers[0].stride = 4;
state.cBuffers[0].attributeCount = 1;
TEST_F(VertexStateTest, VertexFormatLargerThanNonZeroStride) {
utils::ComboVertexStateDescriptor state;
state.vertexBufferCount = 1;
state.cVertexBuffers[0].arrayStride = 4;
state.cVertexBuffers[0].attributeCount = 1;
state.cAttributes[0].format = wgpu::VertexFormat::Float4;
CreatePipeline(false, state, R"(
#version 450

12
src/tests/unittests/wire/WireArgumentTests.cpp
View File

@ -117,11 +117,11 @@ TEST_F(WireArgumentTests, CStringArgument) {
colorStateDescriptor.writeMask = WGPUColorWriteMask_All;
// Create the input state
WGPUVertexInputDescriptor vertexInput;
vertexInput.nextInChain = nullptr;
vertexInput.indexFormat = WGPUIndexFormat_Uint32;
vertexInput.bufferCount = 0;
vertexInput.buffers = nullptr;
WGPUVertexStateDescriptor vertexState;
vertexState.nextInChain = nullptr;
vertexState.indexFormat = WGPUIndexFormat_Uint32;
vertexState.vertexBufferCount = 0;
vertexState.vertexBuffers = nullptr;
// Create the rasterization state
WGPURasterizationStateDescriptor rasterizationState;
@ -179,7 +179,7 @@ TEST_F(WireArgumentTests, CStringArgument) {
pipelineDescriptor.sampleMask = 0xFFFFFFFF;
pipelineDescriptor.alphaToCoverageEnabled = false;
pipelineDescriptor.layout = layout;
pipelineDescriptor.vertexInput = &vertexInput;
pipelineDescriptor.vertexState = &vertexState;
pipelineDescriptor.primitiveTopology = WGPUPrimitiveTopology_TriangleList;
pipelineDescriptor.rasterizationState = &rasterizationState;
pipelineDescriptor.depthStencilState = &depthStencilState;

12
src/tests/unittests/wire/WireOptionalTests.cpp
View File

@ -90,11 +90,11 @@ TEST_F(WireOptionalTests, OptionalStructPointer) {
colorStateDescriptor.writeMask = WGPUColorWriteMask_All;
// Create the input state
WGPUVertexInputDescriptor vertexInput;
vertexInput.nextInChain = nullptr;
vertexInput.indexFormat = WGPUIndexFormat_Uint32;
vertexInput.bufferCount = 0;
vertexInput.buffers = nullptr;
WGPUVertexStateDescriptor vertexState;
vertexState.nextInChain = nullptr;
vertexState.indexFormat = WGPUIndexFormat_Uint32;
vertexState.vertexBufferCount = 0;
vertexState.vertexBuffers = nullptr;
// Create the rasterization state
WGPURasterizationStateDescriptor rasterizationState;
@ -154,7 +154,7 @@ TEST_F(WireOptionalTests, OptionalStructPointer) {
pipelineDescriptor.sampleMask = 0xFFFFFFFF;
pipelineDescriptor.alphaToCoverageEnabled = false;
pipelineDescriptor.layout = layout;
pipelineDescriptor.vertexInput = &vertexInput;
pipelineDescriptor.vertexState = &vertexState;
pipelineDescriptor.primitiveTopology = WGPUPrimitiveTopology_TriangleList;
pipelineDescriptor.rasterizationState = &rasterizationState;

29
src/utils/ComboRenderPipelineDescriptor.cpp
View File

@ -18,11 +18,11 @@
namespace utils {
ComboVertexInputDescriptor::ComboVertexInputDescriptor() {
wgpu::VertexInputDescriptor* descriptor = this;
ComboVertexStateDescriptor::ComboVertexStateDescriptor() {
wgpu::VertexStateDescriptor* descriptor = this;
descriptor->indexFormat = wgpu::IndexFormat::Uint32;
descriptor->bufferCount = 0;
descriptor->vertexBufferCount = 0;
// Fill the default values for vertexBuffers and vertexAttributes in buffers.
wgpu::VertexAttributeDescriptor vertexAttribute;
@ -33,17 +33,18 @@ namespace utils {
cAttributes[i] = vertexAttribute;
}
for (uint32_t i = 0; i < kMaxVertexBuffers; ++i) {
cBuffers[i].stride = 0;
cBuffers[i].stepMode = wgpu::InputStepMode::Vertex;
cBuffers[i].attributeCount = 0;
cBuffers[i].attributes = nullptr;
cVertexBuffers[i].arrayStride = 0;
cVertexBuffers[i].stepMode = wgpu::InputStepMode::Vertex;
cVertexBuffers[i].attributeCount = 0;
cVertexBuffers[i].attributes = nullptr;
}
// cBuffers[i].attributes points to somewhere in cAttributes. cBuffers[0].attributes
// points to &cAttributes[0] by default. Assuming cBuffers[0] has two attributes, then
// cBuffers[1].attributes should point to &cAttributes[2]. Likewise, if cBuffers[1]
// has 3 attributes, then cBuffers[2].attributes should point to &cAttributes[5].
cBuffers[0].attributes = &cAttributes[0];
descriptor->buffers = &cBuffers[0];
// cVertexBuffers[i].attributes points to somewhere in cAttributes.
// cVertexBuffers[0].attributes points to &cAttributes[0] by default. Assuming
// cVertexBuffers[0] has two attributes, then cVertexBuffers[1].attributes should point to
// &cAttributes[2]. Likewise, if cVertexBuffers[1] has 3 attributes, then
// cVertexBuffers[2].attributes should point to &cAttributes[5].
cVertexBuffers[0].attributes = &cAttributes[0];
descriptor->vertexBuffers = &cVertexBuffers[0];
}
ComboRenderPipelineDescriptor::ComboRenderPipelineDescriptor(const wgpu::Device& device) {
@ -62,7 +63,7 @@ namespace utils {
}
// Set defaults for the input state descriptors.
descriptor->vertexInput = &cVertexInput;
descriptor->vertexState = &cVertexState;
// Set defaults for the rasterization state descriptor.
{

8
src/utils/ComboRenderPipelineDescriptor.h
View File

@ -23,11 +23,11 @@
namespace utils {
class ComboVertexInputDescriptor : public wgpu::VertexInputDescriptor {
class ComboVertexStateDescriptor : public wgpu::VertexStateDescriptor {
public:
ComboVertexInputDescriptor();
ComboVertexStateDescriptor();
std::array<wgpu::VertexBufferDescriptor, kMaxVertexBuffers> cBuffers;
std::array<wgpu::VertexBufferLayoutDescriptor, kMaxVertexBuffers> cVertexBuffers;
std::array<wgpu::VertexAttributeDescriptor, kMaxVertexAttributes> cAttributes;
};
@ -42,7 +42,7 @@ namespace utils {
wgpu::ProgrammableStageDescriptor cFragmentStage;
ComboVertexInputDescriptor cVertexInput;
ComboVertexStateDescriptor cVertexState;
wgpu::RasterizationStateDescriptor cRasterizationState;
std::array<wgpu::ColorStateDescriptor, kMaxColorAttachments> cColorStates;
wgpu::DepthStencilStateDescriptor cDepthStencilState;