encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-06-30 10:23:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Deprecate BG[L]Desc::binding[s|Count] in favor of entr[ies|yCount]

Browse Source 
Bug: dawn:22

Change-Id: I02188d70103a1bee25b9b2024a2ea9f785656236
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/19862
Reviewed-by: Austin Eng <enga@chromium.org>
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
This commit is contained in:
Corentin Wallez 2020-04-21 07:36:30 +00:00 committed by Commit Bot service account
parent be08000cb5
commit 3966eb1175
18 changed files with 406 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
dawn.json
View File

@ -77,8 +77,10 @@
"members": [ "members": [
{"name": "label", "type": "char", "annotation": "const*", "length": "strlen", "optional": true}, {"name": "label", "type": "char", "annotation": "const*", "length": "strlen", "optional": true},
{"name": "layout", "type": "bind group layout"}, {"name": "layout", "type": "bind group layout"},
{"name": "binding count", "type": "uint32_t"}, {"name": "binding count", "type": "uint32_t", "default": 0},
{"name": "bindings", "type": "bind group entry", "annotation": "const*", "length": "binding count"} {"name": "bindings", "type": "bind group entry", "annotation": "const*", "length": "binding count"},
{"name": "entry count", "type": "uint32_t", "default": 0},
{"name": "entries", "type": "bind group entry", "annotation": "const*", "length": "entry count"}
] ]
}, },
"bind group layout": { "bind group layout": {
@ -104,8 +106,10 @@
"extensible": true, "extensible": true,
"members": [ "members": [
{"name": "label", "type": "char", "annotation": "const*", "length": "strlen", "optional": true}, {"name": "label", "type": "char", "annotation": "const*", "length": "strlen", "optional": true},
{"name": "binding count", "type": "uint32_t"}, {"name": "binding count", "type": "uint32_t", "default": 0},
{"name": "bindings", "type": "bind group layout entry", "annotation": "const*", "length": "binding count"} {"name": "bindings", "type": "bind group layout entry", "annotation": "const*", "length": "binding count"},
{"name": "entry count", "type": "uint32_t", "default": 0},
{"name": "entries", "type": "bind group layout entry", "annotation": "const*", "length": "entry count"}
] ]
}, },
"binding type": { "binding type": {

88
src/dawn_native/BindGroup.cpp
View File

@ -29,22 +29,22 @@ namespace dawn_native {
// Helper functions to perform binding-type specific validation // Helper functions to perform binding-type specific validation
MaybeError ValidateBufferBinding(const DeviceBase* device, MaybeError ValidateBufferBinding(const DeviceBase* device,
const BindGroupEntry& binding, const BindGroupEntry& entry,
wgpu::BufferUsage requiredUsage) { wgpu::BufferUsage requiredUsage) {
if (binding.buffer == nullptr || binding.sampler != nullptr || if (entry.buffer == nullptr || entry.sampler != nullptr ||
binding.textureView != nullptr) { entry.textureView != nullptr) {
return DAWN_VALIDATION_ERROR("expected buffer binding"); return DAWN_VALIDATION_ERROR("expected buffer binding");
} }
DAWN_TRY(device->ValidateObject(binding.buffer)); DAWN_TRY(device->ValidateObject(entry.buffer));
uint64_t bufferSize = binding.buffer->GetSize(); uint64_t bufferSize = entry.buffer->GetSize();
// Handle wgpu::WholeSize, avoiding overflows. // Handle wgpu::WholeSize, avoiding overflows.
if (binding.offset > bufferSize) { if (entry.offset > bufferSize) {
return DAWN_VALIDATION_ERROR("Buffer binding doesn't fit in the buffer"); return DAWN_VALIDATION_ERROR("Buffer binding doesn't fit in the buffer");
} }
uint64_t bindingSize = uint64_t bindingSize =
(binding.size == wgpu::kWholeSize) ? bufferSize - binding.offset : binding.size; (entry.size == wgpu::kWholeSize) ? bufferSize - entry.offset : entry.size;
if (bindingSize > bufferSize) { if (bindingSize > bufferSize) {
return DAWN_VALIDATION_ERROR("Buffer binding size larger than the buffer"); return DAWN_VALIDATION_ERROR("Buffer binding size larger than the buffer");
@ -56,16 +56,16 @@ namespace dawn_native {
// Note that no overflow can happen because we already checked that // Note that no overflow can happen because we already checked that
// bufferSize >= bindingSize // bufferSize >= bindingSize
if (binding.offset > bufferSize - bindingSize) { if (entry.offset > bufferSize - bindingSize) {
return DAWN_VALIDATION_ERROR("Buffer binding doesn't fit in the buffer"); return DAWN_VALIDATION_ERROR("Buffer binding doesn't fit in the buffer");
} }
if (!IsAligned(binding.offset, 256)) { if (!IsAligned(entry.offset, 256)) {
return DAWN_VALIDATION_ERROR( return DAWN_VALIDATION_ERROR(
"Buffer offset for bind group needs to be 256-byte aligned"); "Buffer offset for bind group needs to be 256-byte aligned");
} }
if (!(binding.buffer->GetUsage() & requiredUsage)) { if (!(entry.buffer->GetUsage() & requiredUsage)) {
return DAWN_VALIDATION_ERROR("buffer binding usage mismatch"); return DAWN_VALIDATION_ERROR("buffer binding usage mismatch");
} }
@ -73,16 +73,16 @@ namespace dawn_native {
} }
MaybeError ValidateTextureBinding(const DeviceBase* device, MaybeError ValidateTextureBinding(const DeviceBase* device,
const BindGroupEntry& binding, const BindGroupEntry& entry,
wgpu::TextureUsage requiredUsage, wgpu::TextureUsage requiredUsage,
const BindingInfo& bindingInfo) { const BindingInfo& bindingInfo) {
if (binding.textureView == nullptr || binding.sampler != nullptr || if (entry.textureView == nullptr || entry.sampler != nullptr ||
binding.buffer != nullptr) { entry.buffer != nullptr) {
return DAWN_VALIDATION_ERROR("expected texture binding"); return DAWN_VALIDATION_ERROR("expected texture binding");
} }
DAWN_TRY(device->ValidateObject(binding.textureView)); DAWN_TRY(device->ValidateObject(entry.textureView));
TextureBase* texture = binding.textureView->GetTexture(); TextureBase* texture = entry.textureView->GetTexture();
if (!(texture->GetUsage() & requiredUsage)) { if (!(texture->GetUsage() & requiredUsage)) {
return DAWN_VALIDATION_ERROR("texture binding usage mismatch"); return DAWN_VALIDATION_ERROR("texture binding usage mismatch");
@ -110,7 +110,7 @@ namespace dawn_native {
break; break;
} }
if (binding.textureView->GetDimension() != bindingInfo.viewDimension) { if (entry.textureView->GetDimension() != bindingInfo.viewDimension) {
return DAWN_VALIDATION_ERROR("texture view dimension mismatch"); return DAWN_VALIDATION_ERROR("texture view dimension mismatch");
} }
@ -118,22 +118,22 @@ namespace dawn_native {
} }
MaybeError ValidateSamplerBinding(const DeviceBase* device, MaybeError ValidateSamplerBinding(const DeviceBase* device,
const BindGroupEntry& binding, const BindGroupEntry& entry,
wgpu::BindingType bindingType) { wgpu::BindingType bindingType) {
if (binding.sampler == nullptr || binding.textureView != nullptr || if (entry.sampler == nullptr || entry.textureView != nullptr ||
binding.buffer != nullptr) { entry.buffer != nullptr) {
return DAWN_VALIDATION_ERROR("expected sampler binding"); return DAWN_VALIDATION_ERROR("expected sampler binding");
} }
DAWN_TRY(device->ValidateObject(binding.sampler)); DAWN_TRY(device->ValidateObject(entry.sampler));
switch (bindingType) { switch (bindingType) {
case wgpu::BindingType::Sampler: case wgpu::BindingType::Sampler:
if (binding.sampler->HasCompareFunction()) { if (entry.sampler->HasCompareFunction()) {
return DAWN_VALIDATION_ERROR("Did not expect comparison sampler"); return DAWN_VALIDATION_ERROR("Did not expect comparison sampler");
} }
break; break;
case wgpu::BindingType::ComparisonSampler: case wgpu::BindingType::ComparisonSampler:
if (!binding.sampler->HasCompareFunction()) { if (!entry.sampler->HasCompareFunction()) {
return DAWN_VALIDATION_ERROR("Expected comparison sampler"); return DAWN_VALIDATION_ERROR("Expected comparison sampler");
} }
break; break;
@ -153,17 +153,17 @@ namespace dawn_native {
} }
DAWN_TRY(device->ValidateObject(descriptor->layout)); DAWN_TRY(device->ValidateObject(descriptor->layout));
if (descriptor->bindingCount != descriptor->layout->GetBindingCount()) { if (descriptor->entryCount != descriptor->layout->GetBindingCount()) {
return DAWN_VALIDATION_ERROR("numBindings mismatch"); return DAWN_VALIDATION_ERROR("numBindings mismatch");
} }
const BindGroupLayoutBase::BindingMap& bindingMap = descriptor->layout->GetBindingMap(); const BindGroupLayoutBase::BindingMap& bindingMap = descriptor->layout->GetBindingMap();
std::bitset<kMaxBindingsPerGroup> bindingsSet; std::bitset<kMaxBindingsPerGroup> bindingsSet;
for (uint32_t i = 0; i < descriptor->bindingCount; ++i) { for (uint32_t i = 0; i < descriptor->entryCount; ++i) {
const BindGroupEntry& binding = descriptor->bindings[i]; const BindGroupEntry& entry = descriptor->entries[i];
const auto& it = bindingMap.find(BindingNumber(binding.binding)); const auto& it = bindingMap.find(BindingNumber(entry.binding));
if (it == bindingMap.end()) { if (it == bindingMap.end()) {
return DAWN_VALIDATION_ERROR("setting non-existent binding"); return DAWN_VALIDATION_ERROR("setting non-existent binding");
} }
@ -180,25 +180,25 @@ namespace dawn_native {
// Perform binding-type specific validation. // Perform binding-type specific validation.
switch (bindingInfo.type) { switch (bindingInfo.type) {
case wgpu::BindingType::UniformBuffer: case wgpu::BindingType::UniformBuffer:
DAWN_TRY(ValidateBufferBinding(device, binding, wgpu::BufferUsage::Uniform)); DAWN_TRY(ValidateBufferBinding(device, entry, wgpu::BufferUsage::Uniform));
break; break;
case wgpu::BindingType::StorageBuffer: case wgpu::BindingType::StorageBuffer:
case wgpu::BindingType::ReadonlyStorageBuffer: case wgpu::BindingType::ReadonlyStorageBuffer:
DAWN_TRY(ValidateBufferBinding(device, binding, wgpu::BufferUsage::Storage)); DAWN_TRY(ValidateBufferBinding(device, entry, wgpu::BufferUsage::Storage));
break; break;
case wgpu::BindingType::SampledTexture: case wgpu::BindingType::SampledTexture:
DAWN_TRY(ValidateTextureBinding(device, binding, wgpu::TextureUsage::Sampled, DAWN_TRY(ValidateTextureBinding(device, entry, wgpu::TextureUsage::Sampled,
bindingInfo)); bindingInfo));
break; break;
case wgpu::BindingType::Sampler: case wgpu::BindingType::Sampler:
case wgpu::BindingType::ComparisonSampler: case wgpu::BindingType::ComparisonSampler:
DAWN_TRY(ValidateSamplerBinding(device, binding, bindingInfo.type)); DAWN_TRY(ValidateSamplerBinding(device, entry, bindingInfo.type));
break; break;
// TODO(jiawei.shao@intel.com): support creating bind group with read-only and // TODO(jiawei.shao@intel.com): support creating bind group with read-only and
// write-only storage textures. // write-only storage textures.
case wgpu::BindingType::ReadonlyStorageTexture: case wgpu::BindingType::ReadonlyStorageTexture:
case wgpu::BindingType::WriteonlyStorageTexture: case wgpu::BindingType::WriteonlyStorageTexture:
DAWN_TRY(ValidateTextureBinding(device, binding, wgpu::TextureUsage::Storage, DAWN_TRY(ValidateTextureBinding(device, entry, wgpu::TextureUsage::Storage,
bindingInfo)); bindingInfo));
break; break;
case wgpu::BindingType::StorageTexture: case wgpu::BindingType::StorageTexture:
@ -231,36 +231,36 @@ namespace dawn_native {
new (&mBindingData.bindings[i]) Ref<ObjectBase>(); new (&mBindingData.bindings[i]) Ref<ObjectBase>();
} }
for (uint32_t i = 0; i < descriptor->bindingCount; ++i) { for (uint32_t i = 0; i < descriptor->entryCount; ++i) {
const BindGroupEntry& binding = descriptor->bindings[i]; const BindGroupEntry& entry = descriptor->entries[i];
BindingIndex bindingIndex = BindingIndex bindingIndex =
descriptor->layout->GetBindingIndex(BindingNumber(binding.binding)); descriptor->layout->GetBindingIndex(BindingNumber(entry.binding));
ASSERT(bindingIndex < mLayout->GetBindingCount()); ASSERT(bindingIndex < mLayout->GetBindingCount());
// Only a single binding type should be set, so once we found it we can skip to the // Only a single binding type should be set, so once we found it we can skip to the
// next loop iteration. // next loop iteration.
if (binding.buffer != nullptr) { if (entry.buffer != nullptr) {
ASSERT(mBindingData.bindings[bindingIndex].Get() == nullptr); ASSERT(mBindingData.bindings[bindingIndex].Get() == nullptr);
mBindingData.bindings[bindingIndex] = binding.buffer; mBindingData.bindings[bindingIndex] = entry.buffer;
mBindingData.bufferData[bindingIndex].offset = binding.offset; mBindingData.bufferData[bindingIndex].offset = entry.offset;
uint64_t bufferSize = (binding.size == wgpu::kWholeSize) uint64_t bufferSize = (entry.size == wgpu::kWholeSize)
? binding.buffer->GetSize() - binding.offset ? entry.buffer->GetSize() - entry.offset
: binding.size; : entry.size;
mBindingData.bufferData[bindingIndex].size = bufferSize; mBindingData.bufferData[bindingIndex].size = bufferSize;
continue; continue;
} }
if (binding.textureView != nullptr) { if (entry.textureView != nullptr) {
ASSERT(mBindingData.bindings[bindingIndex].Get() == nullptr); ASSERT(mBindingData.bindings[bindingIndex].Get() == nullptr);
mBindingData.bindings[bindingIndex] = binding.textureView; mBindingData.bindings[bindingIndex] = entry.textureView;
continue; continue;
} }
if (binding.sampler != nullptr) { if (entry.sampler != nullptr) {
ASSERT(mBindingData.bindings[bindingIndex].Get() == nullptr); ASSERT(mBindingData.bindings[bindingIndex].Get() == nullptr);
mBindingData.bindings[bindingIndex] = binding.sampler; mBindingData.bindings[bindingIndex] = entry.sampler;
continue; continue;
} }
} }

42
src/dawn_native/BindGroupLayout.cpp
View File

@ -102,26 +102,26 @@ namespace dawn_native {
std::set<BindingNumber> bindingsSet; std::set<BindingNumber> bindingsSet;
uint32_t dynamicUniformBufferCount = 0; uint32_t dynamicUniformBufferCount = 0;
uint32_t dynamicStorageBufferCount = 0; uint32_t dynamicStorageBufferCount = 0;
for (BindingIndex i = 0; i < descriptor->bindingCount; ++i) { for (uint32_t i = 0; i < descriptor->entryCount; ++i) {
const BindGroupLayoutEntry& binding = descriptor->bindings[i]; const BindGroupLayoutEntry& entry = descriptor->entries[i];
BindingNumber bindingNumber = BindingNumber(binding.binding); BindingNumber bindingNumber = BindingNumber(entry.binding);
DAWN_TRY(ValidateShaderStage(binding.visibility)); DAWN_TRY(ValidateShaderStage(entry.visibility));
DAWN_TRY(ValidateBindingType(binding.type)); DAWN_TRY(ValidateBindingType(entry.type));
DAWN_TRY(ValidateTextureComponentType(binding.textureComponentType)); DAWN_TRY(ValidateTextureComponentType(entry.textureComponentType));
if (binding.viewDimension != wgpu::TextureViewDimension::Undefined) { if (entry.viewDimension != wgpu::TextureViewDimension::Undefined) {
DAWN_TRY(ValidateTextureViewDimension(binding.viewDimension)); DAWN_TRY(ValidateTextureViewDimension(entry.viewDimension));
// TODO(dawn:22): Remove this once users use viewDimension // TODO(dawn:22): Remove this once users use viewDimension
if (binding.textureDimension != wgpu::TextureViewDimension::Undefined) { if (entry.textureDimension != wgpu::TextureViewDimension::Undefined) {
return DAWN_VALIDATION_ERROR( return DAWN_VALIDATION_ERROR(
"Cannot use both viewDimension and textureDimension"); "Cannot use both viewDimension and textureDimension");
} }
} else { } else {
// TODO(dawn:22): Remove this once users use viewDimension // TODO(dawn:22): Remove this once users use viewDimension
if (binding.textureDimension != wgpu::TextureViewDimension::Undefined) { if (entry.textureDimension != wgpu::TextureViewDimension::Undefined) {
DAWN_TRY(ValidateTextureViewDimension(binding.textureDimension)); DAWN_TRY(ValidateTextureViewDimension(entry.textureDimension));
device->EmitDeprecationWarning( device->EmitDeprecationWarning(
"BindGroupLayoutEntry::textureDimension is deprecated, use viewDimension " "BindGroupLayoutEntry::textureDimension is deprecated, use viewDimension "
"instead"); "instead");
@ -132,21 +132,19 @@ namespace dawn_native {
return DAWN_VALIDATION_ERROR("some binding index was specified more than once"); return DAWN_VALIDATION_ERROR("some binding index was specified more than once");
} }
DAWN_TRY( DAWN_TRY(ValidateBindingTypeWithShaderStageVisibility(entry.type, entry.visibility));
ValidateBindingTypeWithShaderStageVisibility(binding.type, binding.visibility));
DAWN_TRY( DAWN_TRY(ValidateStorageTextureFormat(device, entry.type, entry.storageTextureFormat));
ValidateStorageTextureFormat(device, binding.type, binding.storageTextureFormat));
switch (binding.type) { switch (entry.type) {
case wgpu::BindingType::UniformBuffer: case wgpu::BindingType::UniformBuffer:
if (binding.hasDynamicOffset) { if (entry.hasDynamicOffset) {
++dynamicUniformBufferCount; ++dynamicUniformBufferCount;
} }
break; break;
case wgpu::BindingType::StorageBuffer: case wgpu::BindingType::StorageBuffer:
case wgpu::BindingType::ReadonlyStorageBuffer: case wgpu::BindingType::ReadonlyStorageBuffer:
if (binding.hasDynamicOffset) { if (entry.hasDynamicOffset) {
++dynamicStorageBufferCount; ++dynamicStorageBufferCount;
} }
break; break;
@ -155,7 +153,7 @@ namespace dawn_native {
case wgpu::BindingType::ComparisonSampler: case wgpu::BindingType::ComparisonSampler:
case wgpu::BindingType::ReadonlyStorageTexture: case wgpu::BindingType::ReadonlyStorageTexture:
case wgpu::BindingType::WriteonlyStorageTexture: case wgpu::BindingType::WriteonlyStorageTexture:
if (binding.hasDynamicOffset) { if (entry.hasDynamicOffset) {
return DAWN_VALIDATION_ERROR("Samplers and textures cannot be dynamic"); return DAWN_VALIDATION_ERROR("Samplers and textures cannot be dynamic");
} }
break; break;
@ -163,7 +161,7 @@ namespace dawn_native {
return DAWN_VALIDATION_ERROR("storage textures aren't supported (yet)"); return DAWN_VALIDATION_ERROR("storage textures aren't supported (yet)");
} }
if (binding.multisampled) { if (entry.multisampled) {
return DAWN_VALIDATION_ERROR( return DAWN_VALIDATION_ERROR(
"BindGroupLayoutEntry::multisampled must be false (for now)"); "BindGroupLayoutEntry::multisampled must be false (for now)");
} }
@ -273,9 +271,9 @@ namespace dawn_native {
BindGroupLayoutBase::BindGroupLayoutBase(DeviceBase* device, BindGroupLayoutBase::BindGroupLayoutBase(DeviceBase* device,
const BindGroupLayoutDescriptor* descriptor) const BindGroupLayoutDescriptor* descriptor)
: CachedObject(device), mBindingCount(descriptor->bindingCount) { : CachedObject(device), mBindingCount(descriptor->entryCount) {
std::vector<BindGroupLayoutEntry> sortedBindings( std::vector<BindGroupLayoutEntry> sortedBindings(
descriptor->bindings, descriptor->bindings + descriptor->bindingCount); descriptor->entries, descriptor->entries + descriptor->entryCount);
std::sort(sortedBindings.begin(), sortedBindings.end(), SortBindingsCompare); std::sort(sortedBindings.begin(), sortedBindings.end(), SortBindingsCompare);

42
src/dawn_native/Device.cpp
View File

@ -731,10 +731,25 @@ namespace dawn_native {
MaybeError DeviceBase::CreateBindGroupInternal(BindGroupBase** result, MaybeError DeviceBase::CreateBindGroupInternal(BindGroupBase** result,
const BindGroupDescriptor* descriptor) { const BindGroupDescriptor* descriptor) {
DAWN_TRY(ValidateIsAlive()); DAWN_TRY(ValidateIsAlive());
if (IsValidationEnabled()) {
DAWN_TRY(ValidateBindGroupDescriptor(this, descriptor)); // TODO(dawn:22): Remove this once users use entries/entryCount
BindGroupDescriptor fixedDescriptor = *descriptor;
if (fixedDescriptor.bindingCount != 0) {
if (fixedDescriptor.entryCount != 0) {
return DAWN_VALIDATION_ERROR("Cannot use bindings and entries at the same time");
} else {
EmitDeprecationWarning(
"BindGroupEntry::bindings/bindingCount is deprecated, use entries/entryCount "
"instead");
fixedDescriptor.entryCount = fixedDescriptor.bindingCount;
fixedDescriptor.entries = fixedDescriptor.bindings;
} }
DAWN_TRY_ASSIGN(*result, CreateBindGroupImpl(descriptor)); }
if (IsValidationEnabled()) {
DAWN_TRY(ValidateBindGroupDescriptor(this, &fixedDescriptor));
}
DAWN_TRY_ASSIGN(*result, CreateBindGroupImpl(&fixedDescriptor));
return {}; return {};
} }
@ -742,10 +757,25 @@ namespace dawn_native {
BindGroupLayoutBase** result, BindGroupLayoutBase** result,
const BindGroupLayoutDescriptor* descriptor) { const BindGroupLayoutDescriptor* descriptor) {
DAWN_TRY(ValidateIsAlive()); DAWN_TRY(ValidateIsAlive());
if (IsValidationEnabled()) {
DAWN_TRY(ValidateBindGroupLayoutDescriptor(this, descriptor)); // TODO(dawn:22): Remove this once users use entries/entryCount
BindGroupLayoutDescriptor fixedDescriptor = *descriptor;
if (fixedDescriptor.bindingCount != 0) {
if (fixedDescriptor.entryCount != 0) {
return DAWN_VALIDATION_ERROR("Cannot use bindings and entries at the same time");
} else {
EmitDeprecationWarning(
"BindGroupLayoutEntry::bindings/bindingCount is deprecated, use "
"entries/entryCount instead");
fixedDescriptor.entryCount = fixedDescriptor.bindingCount;
fixedDescriptor.entries = fixedDescriptor.bindings;
} }
DAWN_TRY_ASSIGN(*result, GetOrCreateBindGroupLayout(descriptor)); }
if (IsValidationEnabled()) {
DAWN_TRY(ValidateBindGroupLayoutDescriptor(this, &fixedDescriptor));
}
DAWN_TRY_ASSIGN(*result, GetOrCreateBindGroupLayout(&fixedDescriptor));
return {}; return {};
} }

4
src/dawn_native/Pipeline.cpp
View File

@ -89,8 +89,8 @@ namespace dawn_native {
// a Ref<BindGroupLayoutBase>, then the VkDevice will be destroyed before the // a Ref<BindGroupLayoutBase>, then the VkDevice will be destroyed before the
// VkDescriptorSetLayout. // VkDescriptorSetLayout.
BindGroupLayoutDescriptor desc = {}; BindGroupLayoutDescriptor desc = {};
desc.bindingCount = 0; desc.entryCount = 0;
desc.bindings = nullptr; desc.entries = nullptr;
BindGroupLayoutBase* bgl = nullptr; BindGroupLayoutBase* bgl = nullptr;
if (GetDevice()->ConsumedError(GetDevice()->GetOrCreateBindGroupLayout(&desc), &bgl)) { if (GetDevice()->ConsumedError(GetDevice()->GetOrCreateBindGroupLayout(&desc), &bgl)) {

20
src/dawn_native/PipelineLayout.cpp
View File

@ -126,13 +126,13 @@ namespace dawn_native {
// Data which BindGroupLayoutDescriptor will point to for creation // Data which BindGroupLayoutDescriptor will point to for creation
std::array<std::array<BindGroupLayoutEntry, kMaxBindingsPerGroup>, kMaxBindGroups> std::array<std::array<BindGroupLayoutEntry, kMaxBindingsPerGroup>, kMaxBindGroups>
bindingData = {}; entryData = {};
// A map of bindings to the index in |bindingData| // A map of bindings to the index in |entryData|
std::array<std::map<BindingNumber, BindingIndex>, kMaxBindGroups> usedBindingsMap = {}; std::array<std::map<BindingNumber, BindingIndex>, kMaxBindGroups> usedBindingsMap = {};
// A counter of how many bindings we've populated in |bindingData| // A counter of how many bindings we've populated in |entryData|
std::array<uint32_t, kMaxBindGroups> bindingCounts = {}; std::array<uint32_t, kMaxBindGroups> entryCounts = {};
uint32_t bindGroupLayoutCount = 0; uint32_t bindGroupLayoutCount = 0;
for (uint32_t moduleIndex = 0; moduleIndex < count; ++moduleIndex) { for (uint32_t moduleIndex = 0; moduleIndex < count; ++moduleIndex) {
@ -170,7 +170,7 @@ namespace dawn_native {
{ {
const auto& it = usedBindingsMap[group].find(bindingNumber); const auto& it = usedBindingsMap[group].find(bindingNumber);
if (it != usedBindingsMap[group].end()) { if (it != usedBindingsMap[group].end()) {
if (bindingSlot == bindingData[group][it->second]) { if (bindingSlot == entryData[group][it->second]) {
// Already used and the data is the same. Continue. // Already used and the data is the same. Continue.
continue; continue;
} else { } else {
@ -181,12 +181,12 @@ namespace dawn_native {
} }
} }
uint32_t currentBindingCount = bindingCounts[group]; uint32_t currentBindingCount = entryCounts[group];
bindingData[group][currentBindingCount] = bindingSlot; entryData[group][currentBindingCount] = bindingSlot;
usedBindingsMap[group][bindingNumber] = currentBindingCount; usedBindingsMap[group][bindingNumber] = currentBindingCount;
bindingCounts[group]++; entryCounts[group]++;
bindGroupLayoutCount = std::max(bindGroupLayoutCount, group + 1); bindGroupLayoutCount = std::max(bindGroupLayoutCount, group + 1);
} }
@ -196,8 +196,8 @@ namespace dawn_native {
std::array<BindGroupLayoutBase*, kMaxBindGroups> bindGroupLayouts = {}; std::array<BindGroupLayoutBase*, kMaxBindGroups> bindGroupLayouts = {};
for (uint32_t group = 0; group < bindGroupLayoutCount; ++group) { for (uint32_t group = 0; group < bindGroupLayoutCount; ++group) {
BindGroupLayoutDescriptor desc = {}; BindGroupLayoutDescriptor desc = {};
desc.bindings = bindingData[group].data(); desc.entries = entryData[group].data();
desc.bindingCount = bindingCounts[group]; desc.entryCount = entryCounts[group];
// We should never produce a bad descriptor. // We should never produce a bad descriptor.
ASSERT(!ValidateBindGroupLayoutDescriptor(device, &desc).IsError()); ASSERT(!ValidateBindGroupLayoutDescriptor(device, &desc).IsError());

6
src/tests/end2end/BindGroupTests.cpp
View File

@ -750,11 +750,11 @@ TEST_P(BindGroupTests, DrawThenChangePipelineAndBindGroup) {
TEST_P(BindGroupTests, BindGroupLayoutVisibilityCanBeNone) { TEST_P(BindGroupTests, BindGroupLayoutVisibilityCanBeNone) {
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
wgpu::BindGroupLayoutEntry binding = {0, wgpu::ShaderStage::None, wgpu::BindGroupLayoutEntry entry = {0, wgpu::ShaderStage::None,
wgpu::BindingType::UniformBuffer}; wgpu::BindingType::UniformBuffer};
wgpu::BindGroupLayoutDescriptor descriptor; wgpu::BindGroupLayoutDescriptor descriptor;
descriptor.bindingCount = 1; descriptor.entryCount = 1;
descriptor.bindings = &binding; descriptor.entries = &entry;
wgpu::BindGroupLayout layout = device.CreateBindGroupLayout(&descriptor); wgpu::BindGroupLayout layout = device.CreateBindGroupLayout(&descriptor);
wgpu::RenderPipeline pipeline = MakeTestPipeline(renderPass, {}, {layout}); wgpu::RenderPipeline pipeline = MakeTestPipeline(renderPass, {}, {layout});

171
src/tests/end2end/DeprecatedAPITests.cpp
View File

@ -79,8 +79,8 @@ TEST_P(DeprecationTests, BGLEntryTextureDimensionIsDeprecated) {
}; };
wgpu::BindGroupLayoutDescriptor bglDesc = { wgpu::BindGroupLayoutDescriptor bglDesc = {
.bindingCount = 1, .entryCount = 1,
.bindings = &entryDesc, .entries = &entryDesc,
}; };
EXPECT_DEPRECATION_WARNING(device.CreateBindGroupLayout(&bglDesc)); EXPECT_DEPRECATION_WARNING(device.CreateBindGroupLayout(&bglDesc));
} }
@ -92,8 +92,8 @@ TEST_P(DeprecationTests, BGLEntryTextureDimensionAndViewUndefinedEmitsNoWarning)
}; };
wgpu::BindGroupLayoutDescriptor bglDesc = { wgpu::BindGroupLayoutDescriptor bglDesc = {
.bindingCount = 1, .entryCount = 1,
.bindings = &entryDesc, .entries = &entryDesc,
}; };
device.CreateBindGroupLayout(&bglDesc); device.CreateBindGroupLayout(&bglDesc);
} }
@ -106,8 +106,8 @@ TEST_P(DeprecationTests, BGLEntryTextureAndViewDimensionIsInvalid) {
}; };
wgpu::BindGroupLayoutDescriptor bglDesc = { wgpu::BindGroupLayoutDescriptor bglDesc = {
.bindingCount = 1, .entryCount = 1,
.bindings = &entryDesc, .entries = &entryDesc,
}; };
ASSERT_DEVICE_ERROR(device.CreateBindGroupLayout(&bglDesc)); ASSERT_DEVICE_ERROR(device.CreateBindGroupLayout(&bglDesc));
} }
@ -121,8 +121,8 @@ TEST_P(DeprecationTests, BGLEntryTextureDimensionStateTracking) {
}; };
wgpu::BindGroupLayoutDescriptor bglDesc = { wgpu::BindGroupLayoutDescriptor bglDesc = {
.bindingCount = 1, .entryCount = 1,
.bindings = &entryDesc, .entries = &entryDesc,
}; };
wgpu::BindGroupLayout layout; wgpu::BindGroupLayout layout;
EXPECT_DEPRECATION_WARNING(layout = device.CreateBindGroupLayout(&bglDesc)); EXPECT_DEPRECATION_WARNING(layout = device.CreateBindGroupLayout(&bglDesc));
@ -152,6 +152,161 @@ TEST_P(DeprecationTests, BGLEntryTextureDimensionStateTracking) {
ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, arrayView}})); ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, arrayView}}));
} }
// Test for BindGroupLayout::bindings/bindingCount -> entries/entryCount
// Test that creating a BGL with bindings emits a deprecation warning.
TEST_P(DeprecationTests, BGLDescBindingIsDeprecated) {
wgpu::BindGroupLayoutEntry entryDesc = {
.type = wgpu::BindingType::Sampler,
};
wgpu::BindGroupLayoutDescriptor bglDesc = {
.bindingCount = 1,
.bindings = &entryDesc,
};
EXPECT_DEPRECATION_WARNING(device.CreateBindGroupLayout(&bglDesc));
}
// Test that creating a BGL with both entries and bindings is an error
TEST_P(DeprecationTests, BGLDescBindingAndEntriesIsInvalid) {
wgpu::BindGroupLayoutEntry entryDesc = {
.type = wgpu::BindingType::Sampler,
};
wgpu::BindGroupLayoutDescriptor bglDesc = {
.bindingCount = 1,
.bindings = &entryDesc,
.entryCount = 1,
.entries = &entryDesc,
};
ASSERT_DEVICE_ERROR(device.CreateBindGroupLayout(&bglDesc));
}
// Test that creating a BGL with both entries and bindings to 0 doesn't emit warnings
TEST_P(DeprecationTests, BGLDescBindingAndEntriesBothZeroEmitsNoWarning) {
// TODO(cwallez@chromium.org): In Vulkan it is disallowed to create 0-sized descriptor pools
// but the Vulkan backend doesn't special case it yet.
DAWN_SKIP_TEST_IF(IsVulkan());
wgpu::BindGroupLayoutDescriptor bglDesc = {
.bindingCount = 0,
.bindings = nullptr,
.entryCount = 0,
.entries = nullptr,
};
device.CreateBindGroupLayout(&bglDesc);
}
// Test that creating a BGL with bindings still does correct state tracking
TEST_P(DeprecationTests, BGLDescBindingStateTracking) {
wgpu::BindGroupLayoutEntry entryDesc = {
.binding = 0,
.type = wgpu::BindingType::Sampler,
};
wgpu::BindGroupLayoutDescriptor bglDesc = {
.bindingCount = 1,
.bindings = &entryDesc,
};
wgpu::BindGroupLayout layout;
EXPECT_DEPRECATION_WARNING(layout = device.CreateBindGroupLayout(&bglDesc));
// Test a case where if |bindings| wasn't taken into account, no validation error would happen
// because the layout would be empty
wgpu::BindGroupDescriptor badBgDesc = {
.layout = layout,
.entryCount = 0,
.entries = nullptr,
};
ASSERT_DEVICE_ERROR(device.CreateBindGroup(&badBgDesc));
}
// Test for BindGroup::bindings/bindingCount -> entries/entryCount
// Test that creating a BG with bindings emits a deprecation warning.
TEST_P(DeprecationTests, BGDescBindingIsDeprecated) {
wgpu::SamplerDescriptor samplerDesc = {};
wgpu::Sampler sampler = device.CreateSampler(&samplerDesc);
wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout(
device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::Sampler}});
wgpu::BindGroupEntry entryDesc = {
.binding = 0,
.sampler = sampler,
};
wgpu::BindGroupDescriptor bgDesc = {
.layout = layout,
.bindingCount = 1,
.bindings = &entryDesc,
};
EXPECT_DEPRECATION_WARNING(device.CreateBindGroup(&bgDesc));
}
// Test that creating a BG with both entries and bindings is an error
TEST_P(DeprecationTests, BGDescBindingAndEntriesIsInvalid) {
wgpu::SamplerDescriptor samplerDesc = {};
wgpu::Sampler sampler = device.CreateSampler(&samplerDesc);
wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout(
device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::Sampler}});
wgpu::BindGroupEntry entryDesc = {
.binding = 0,
.sampler = sampler,
};
wgpu::BindGroupDescriptor bgDesc = {
.layout = layout,
.bindingCount = 1,
.bindings = &entryDesc,
.entryCount = 1,
.entries = &entryDesc,
};
ASSERT_DEVICE_ERROR(device.CreateBindGroup(&bgDesc));
}
// Test that creating a BG with both entries and bindings to 0 doesn't emit warnings
TEST_P(DeprecationTests, BGDescBindingAndEntriesBothZeroEmitsNoWarning) {
// TODO(cwallez@chromium.org): In Vulkan it is disallowed to create 0-sized descriptor pools
// but the Vulkan backend doesn't special case it yet.
DAWN_SKIP_TEST_IF(IsVulkan());
wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout(device, {});
wgpu::BindGroupDescriptor bgDesc = {
.layout = layout,
.bindingCount = 0,
.bindings = nullptr,
.entryCount = 0,
.entries = nullptr,
};
device.CreateBindGroup(&bgDesc);
}
// Test that creating a BG with bindings still does correct state tracking
TEST_P(DeprecationTests, BGDescBindingStateTracking) {
wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout(device, {});
// Test a case where if |bindings| wasn't taken into account, no validation error would happen
// because it would match the empty layout.
wgpu::SamplerDescriptor samplerDesc = {};
wgpu::Sampler sampler = device.CreateSampler(&samplerDesc);
wgpu::BindGroupEntry entryDesc = {
.binding = 0,
.sampler = sampler,
};
wgpu::BindGroupDescriptor bgDesc = {
.layout = layout,
.bindingCount = 1,
.bindings = &entryDesc,
};
EXPECT_DEPRECATION_WARNING(ASSERT_DEVICE_ERROR(device.CreateBindGroup(&bgDesc)));
}
DAWN_INSTANTIATE_TEST(DeprecationTests, DAWN_INSTANTIATE_TEST(DeprecationTests,
D3D12Backend(), D3D12Backend(),
MetalBackend(), MetalBackend(),

24
src/tests/end2end/DeviceLostTests.cpp
View File

@ -105,11 +105,11 @@ TEST_P(DeviceLostTest, SubmitFails) {
TEST_P(DeviceLostTest, CreateBindGroupLayoutFails) { TEST_P(DeviceLostTest, CreateBindGroupLayoutFails) {
SetCallbackAndLoseForTesting(); SetCallbackAndLoseForTesting();
wgpu::BindGroupLayoutEntry binding = {0, wgpu::ShaderStage::None, wgpu::BindGroupLayoutEntry entry = {0, wgpu::ShaderStage::None,
wgpu::BindingType::UniformBuffer}; wgpu::BindingType::UniformBuffer};
wgpu::BindGroupLayoutDescriptor descriptor; wgpu::BindGroupLayoutDescriptor descriptor;
descriptor.bindingCount = 1; descriptor.entryCount = 1;
descriptor.bindings = &binding; descriptor.entries = &entry;
ASSERT_DEVICE_ERROR(device.CreateBindGroupLayout(&descriptor)); ASSERT_DEVICE_ERROR(device.CreateBindGroupLayout(&descriptor));
} }
@ -139,18 +139,18 @@ TEST_P(DeviceLostTest, GetBindGroupLayoutFails) {
TEST_P(DeviceLostTest, CreateBindGroupFails) { TEST_P(DeviceLostTest, CreateBindGroupFails) {
SetCallbackAndLoseForTesting(); SetCallbackAndLoseForTesting();
wgpu::BindGroupEntry binding; wgpu::BindGroupEntry entry;
binding.binding = 0; entry.binding = 0;
binding.sampler = nullptr; entry.sampler = nullptr;
binding.textureView = nullptr; entry.textureView = nullptr;
binding.buffer = nullptr; entry.buffer = nullptr;
binding.offset = 0; entry.offset = 0;
binding.size = 0; entry.size = 0;
wgpu::BindGroupDescriptor descriptor; wgpu::BindGroupDescriptor descriptor;
descriptor.layout = nullptr; descriptor.layout = nullptr;
descriptor.bindingCount = 1; descriptor.entryCount = 1;
descriptor.bindings = &binding; descriptor.entries = &entry;
ASSERT_DEVICE_ERROR(device.CreateBindGroup(&descriptor)); ASSERT_DEVICE_ERROR(device.CreateBindGroup(&descriptor));
} }

16
src/tests/end2end/StorageTextureTests.cpp
View File

@ -23,24 +23,24 @@ TEST_P(StorageTextureTests, BindGroupLayoutWithStorageTextureBindingType) {
// wgpu::BindingType::ReadonlyStorageTexture is a valid binding type to create a bind group // wgpu::BindingType::ReadonlyStorageTexture is a valid binding type to create a bind group
// layout. // layout.
{ {
wgpu::BindGroupLayoutEntry binding = {0, wgpu::ShaderStage::Compute, wgpu::BindGroupLayoutEntry entry = {0, wgpu::ShaderStage::Compute,
wgpu::BindingType::ReadonlyStorageTexture}; wgpu::BindingType::ReadonlyStorageTexture};
binding.storageTextureFormat = wgpu::TextureFormat::R32Float; entry.storageTextureFormat = wgpu::TextureFormat::R32Float;
wgpu::BindGroupLayoutDescriptor descriptor; wgpu::BindGroupLayoutDescriptor descriptor;
descriptor.bindingCount = 1; descriptor.entryCount = 1;
descriptor.bindings = &binding; descriptor.entries = &entry;
device.CreateBindGroupLayout(&descriptor); device.CreateBindGroupLayout(&descriptor);
} }
// wgpu::BindingType::WriteonlyStorageTexture is a valid binding type to create a bind group // wgpu::BindingType::WriteonlyStorageTexture is a valid binding type to create a bind group
// layout. // layout.
{ {
wgpu::BindGroupLayoutEntry binding = {0, wgpu::ShaderStage::Compute, wgpu::BindGroupLayoutEntry entry = {0, wgpu::ShaderStage::Compute,
wgpu::BindingType::WriteonlyStorageTexture}; wgpu::BindingType::WriteonlyStorageTexture};
binding.storageTextureFormat = wgpu::TextureFormat::R32Float; entry.storageTextureFormat = wgpu::TextureFormat::R32Float;
wgpu::BindGroupLayoutDescriptor descriptor; wgpu::BindGroupLayoutDescriptor descriptor;
descriptor.bindingCount = 1; descriptor.entryCount = 1;
descriptor.bindings = &binding; descriptor.entries = &entry;
device.CreateBindGroupLayout(&descriptor); device.CreateBindGroupLayout(&descriptor);
} }
} }

52
src/tests/unittests/validation/BindGroupValidationTests.cpp
View File

@ -75,8 +75,8 @@ TEST_F(BindGroupValidationTest, NextInChainNullptr) {
wgpu::BindGroupDescriptor descriptor; wgpu::BindGroupDescriptor descriptor;
descriptor.layout = layout; descriptor.layout = layout;
descriptor.bindingCount = 0; descriptor.entryCount = 0;
descriptor.bindings = nullptr; descriptor.entries = nullptr;
// Control case: check that nextInChain = nullptr is valid // Control case: check that nextInChain = nullptr is valid
descriptor.nextInChain = nullptr; descriptor.nextInChain = nullptr;
@ -88,15 +88,15 @@ TEST_F(BindGroupValidationTest, NextInChainNullptr) {
ASSERT_DEVICE_ERROR(device.CreateBindGroup(&descriptor)); ASSERT_DEVICE_ERROR(device.CreateBindGroup(&descriptor));
} }
// Check constraints on bindingCount // Check constraints on entryCount
TEST_F(BindGroupValidationTest, bindingCountMismatch) { TEST_F(BindGroupValidationTest, EntryCountMismatch) {
wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout( wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout(
device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::Sampler}}); device, {{0, wgpu::ShaderStage::Fragment, wgpu::BindingType::Sampler}});
// Control case: check that a descriptor with one binding is ok // Control case: check that a descriptor with one binding is ok
utils::MakeBindGroup(device, layout, {{0, mSampler}}); utils::MakeBindGroup(device, layout, {{0, mSampler}});
// Check that bindingCount != layout.bindingCount fails. // Check that entryCount != layout.entryCount fails.
ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {})); ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {}));
} }
@ -149,8 +149,8 @@ TEST_F(BindGroupValidationTest, SamplerBindingType) {
wgpu::BindGroupDescriptor descriptor; wgpu::BindGroupDescriptor descriptor;
descriptor.layout = layout; descriptor.layout = layout;
descriptor.bindingCount = 1; descriptor.entryCount = 1;
descriptor.bindings = &binding; descriptor.entries = &binding;
// Not setting anything fails // Not setting anything fails
ASSERT_DEVICE_ERROR(device.CreateBindGroup(&descriptor)); ASSERT_DEVICE_ERROR(device.CreateBindGroup(&descriptor));
@ -198,8 +198,8 @@ TEST_F(BindGroupValidationTest, TextureBindingType) {
wgpu::BindGroupDescriptor descriptor; wgpu::BindGroupDescriptor descriptor;
descriptor.layout = layout; descriptor.layout = layout;
descriptor.bindingCount = 1; descriptor.entryCount = 1;
descriptor.bindings = &binding; descriptor.entries = &binding;
// Not setting anything fails // Not setting anything fails
ASSERT_DEVICE_ERROR(device.CreateBindGroup(&descriptor)); ASSERT_DEVICE_ERROR(device.CreateBindGroup(&descriptor));
@ -252,8 +252,8 @@ TEST_F(BindGroupValidationTest, BufferBindingType) {
wgpu::BindGroupDescriptor descriptor; wgpu::BindGroupDescriptor descriptor;
descriptor.layout = layout; descriptor.layout = layout;
descriptor.bindingCount = 1; descriptor.entryCount = 1;
descriptor.bindings = &binding; descriptor.entries = &binding;
// Not setting anything fails // Not setting anything fails
ASSERT_DEVICE_ERROR(device.CreateBindGroup(&descriptor)); ASSERT_DEVICE_ERROR(device.CreateBindGroup(&descriptor));
@ -473,8 +473,8 @@ class BindGroupLayoutValidationTest : public ValidationTest {
bool expected) { bool expected) {
wgpu::BindGroupLayoutDescriptor descriptor; wgpu::BindGroupLayoutDescriptor descriptor;
descriptor.bindingCount = count; descriptor.entryCount = count;
descriptor.bindings = binding; descriptor.entries = binding;
if (!expected) { if (!expected) {
ASSERT_DEVICE_ERROR(device.CreateBindGroupLayout(&descriptor)); ASSERT_DEVICE_ERROR(device.CreateBindGroupLayout(&descriptor));
@ -526,23 +526,23 @@ TEST_F(BindGroupLayoutValidationTest, BindGroupLayoutEntryUnbounded) {
// Test that there can't be more than kMaxBindingPerGroup bindings per group // Test that there can't be more than kMaxBindingPerGroup bindings per group
TEST_F(BindGroupLayoutValidationTest, BindGroupLayoutMaxBindings) { TEST_F(BindGroupLayoutValidationTest, BindGroupLayoutMaxBindings) {
wgpu::BindGroupLayoutEntry bindings[kMaxBindingsPerGroup + 1]; wgpu::BindGroupLayoutEntry entries[kMaxBindingsPerGroup + 1];
for (uint32_t i = 0; i < kMaxBindingsPerGroup + 1; i++) { for (uint32_t i = 0; i < kMaxBindingsPerGroup + 1; i++) {
bindings[i].type = wgpu::BindingType::UniformBuffer; entries[i].type = wgpu::BindingType::UniformBuffer;
bindings[i].binding = i; entries[i].binding = i;
bindings[i].visibility = wgpu::ShaderStage::Compute; entries[i].visibility = wgpu::ShaderStage::Compute;
} }
wgpu::BindGroupLayoutDescriptor desc; wgpu::BindGroupLayoutDescriptor desc;
desc.bindings = bindings; desc.entries = entries;
// Control case: kMaxBindingsPerGroup bindings is allowed. // Control case: kMaxBindingsPerGroup bindings is allowed.
desc.bindingCount = kMaxBindingsPerGroup; desc.entryCount = kMaxBindingsPerGroup;
device.CreateBindGroupLayout(&desc); device.CreateBindGroupLayout(&desc);
// Error case: kMaxBindingsPerGroup + 1 bindings is not allowed. // Error case: kMaxBindingsPerGroup + 1 bindings is not allowed.
desc.bindingCount = kMaxBindingsPerGroup + 1; desc.entryCount = kMaxBindingsPerGroup + 1;
ASSERT_DEVICE_ERROR(device.CreateBindGroupLayout(&desc)); ASSERT_DEVICE_ERROR(device.CreateBindGroupLayout(&desc));
} }
@ -594,8 +594,8 @@ TEST_F(BindGroupLayoutValidationTest, BindGroupLayoutVisibilityNone) {
wgpu::BindGroupLayoutEntry binding = {0, wgpu::ShaderStage::None, wgpu::BindGroupLayoutEntry binding = {0, wgpu::ShaderStage::None,
wgpu::BindingType::UniformBuffer}; wgpu::BindingType::UniformBuffer};
wgpu::BindGroupLayoutDescriptor descriptor; wgpu::BindGroupLayoutDescriptor descriptor;
descriptor.bindingCount = 1; descriptor.entryCount = 1;
descriptor.bindings = &binding; descriptor.entries = &binding;
device.CreateBindGroupLayout(&descriptor); device.CreateBindGroupLayout(&descriptor);
} }
@ -642,8 +642,8 @@ TEST_F(BindGroupLayoutValidationTest, DynamicBufferNumberLimit) {
auto MakeBindGroupLayout = [&](wgpu::BindGroupLayoutEntry* binding, auto MakeBindGroupLayout = [&](wgpu::BindGroupLayoutEntry* binding,
uint32_t count) -> wgpu::BindGroupLayout { uint32_t count) -> wgpu::BindGroupLayout {
wgpu::BindGroupLayoutDescriptor descriptor; wgpu::BindGroupLayoutDescriptor descriptor;
descriptor.bindingCount = count; descriptor.entryCount = count;
descriptor.bindings = binding; descriptor.entries = binding;
return device.CreateBindGroupLayout(&descriptor); return device.CreateBindGroupLayout(&descriptor);
}; };
@ -1055,8 +1055,8 @@ class SetBindGroupPersistenceValidationTest : public ValidationTest {
// Create the bind group layout. // Create the bind group layout.
wgpu::BindGroupLayoutDescriptor bglDescriptor; wgpu::BindGroupLayoutDescriptor bglDescriptor;
bglDescriptor.bindingCount = static_cast<uint32_t>(bindings.size()); bglDescriptor.entryCount = static_cast<uint32_t>(bindings.size());
bglDescriptor.bindings = bindings.data(); bglDescriptor.entries = bindings.data();
bindGroupLayouts[l] = device.CreateBindGroupLayout(&bglDescriptor); bindGroupLayouts[l] = device.CreateBindGroupLayout(&bglDescriptor);
} }

40
src/tests/unittests/validation/GetBindGroupLayoutValidationTests.cpp
View File

@ -108,8 +108,8 @@ TEST_F(GetBindGroupLayoutTests, DefaultShaderStageAndDynamicOffsets) {
binding.multisampled = false; binding.multisampled = false;
wgpu::BindGroupLayoutDescriptor desc = {}; wgpu::BindGroupLayoutDescriptor desc = {};
desc.bindingCount = 1; desc.entryCount = 1;
desc.bindings = &binding; desc.entries = &binding;
// Check that visibility and dynamic offsets match // Check that visibility and dynamic offsets match
binding.hasDynamicOffset = false; binding.hasDynamicOffset = false;
@ -157,8 +157,8 @@ TEST_F(GetBindGroupLayoutTests, ComputePipeline) {
binding.hasDynamicOffset = false; binding.hasDynamicOffset = false;
wgpu::BindGroupLayoutDescriptor desc = {}; wgpu::BindGroupLayoutDescriptor desc = {};
desc.bindingCount = 1; desc.entryCount = 1;
desc.bindings = &binding; desc.entries = &binding;
EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get()); EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
} }
@ -171,8 +171,8 @@ TEST_F(GetBindGroupLayoutTests, BindingType) {
binding.multisampled = false; binding.multisampled = false;
wgpu::BindGroupLayoutDescriptor desc = {}; wgpu::BindGroupLayoutDescriptor desc = {};
desc.bindingCount = 1; desc.entryCount = 1;
desc.bindings = &binding; desc.entries = &binding;
{ {
// Storage buffer binding is not supported in vertex shader. // Storage buffer binding is not supported in vertex shader.
@ -243,8 +243,8 @@ TEST_F(GetBindGroupLayoutTests, Multisampled) {
binding.hasDynamicOffset = false; binding.hasDynamicOffset = false;
wgpu::BindGroupLayoutDescriptor desc = {}; wgpu::BindGroupLayoutDescriptor desc = {};
desc.bindingCount = 1; desc.entryCount = 1;
desc.bindings = &binding; desc.entries = &binding;
{ {
binding.multisampled = false; binding.multisampled = false;
@ -281,8 +281,8 @@ TEST_F(GetBindGroupLayoutTests, ViewDimension) {
binding.multisampled = false; binding.multisampled = false;
wgpu::BindGroupLayoutDescriptor desc = {}; wgpu::BindGroupLayoutDescriptor desc = {};
desc.bindingCount = 1; desc.entryCount = 1;
desc.bindings = &binding; desc.entries = &binding;
{ {
binding.viewDimension = wgpu::TextureViewDimension::e1D; binding.viewDimension = wgpu::TextureViewDimension::e1D;
@ -355,8 +355,8 @@ TEST_F(GetBindGroupLayoutTests, TextureComponentType) {
binding.multisampled = false; binding.multisampled = false;
wgpu::BindGroupLayoutDescriptor desc = {}; wgpu::BindGroupLayoutDescriptor desc = {};
desc.bindingCount = 1; desc.entryCount = 1;
desc.bindings = &binding; desc.entries = &binding;
{ {
binding.textureComponentType = wgpu::TextureComponentType::Float; binding.textureComponentType = wgpu::TextureComponentType::Float;
@ -398,8 +398,8 @@ TEST_F(GetBindGroupLayoutTests, BindingIndices) {
binding.multisampled = false; binding.multisampled = false;
wgpu::BindGroupLayoutDescriptor desc = {}; wgpu::BindGroupLayoutDescriptor desc = {};
desc.bindingCount = 1; desc.entryCount = 1;
desc.bindings = &binding; desc.entries = &binding;
{ {
binding.binding = 0; binding.binding = 0;
@ -605,8 +605,8 @@ TEST_F(GetBindGroupLayoutTests, UnusedIndex) {
void main() {})"); void main() {})");
wgpu::BindGroupLayoutDescriptor desc = {}; wgpu::BindGroupLayoutDescriptor desc = {};
desc.bindingCount = 0; desc.entryCount = 0;
desc.bindings = nullptr; desc.entries = nullptr;
wgpu::BindGroupLayout emptyBindGroupLayout = device.CreateBindGroupLayout(&desc); wgpu::BindGroupLayout emptyBindGroupLayout = device.CreateBindGroupLayout(&desc);
@ -625,8 +625,8 @@ TEST_F(GetBindGroupLayoutTests, Reflection) {
binding.visibility = wgpu::ShaderStage::Vertex; binding.visibility = wgpu::ShaderStage::Vertex;
wgpu::BindGroupLayoutDescriptor bglDesc = {}; wgpu::BindGroupLayoutDescriptor bglDesc = {};
bglDesc.bindingCount = 1; bglDesc.entryCount = 1;
bglDesc.bindings = &binding; bglDesc.entries = &binding;
wgpu::BindGroupLayout bindGroupLayout = device.CreateBindGroupLayout(&bglDesc); wgpu::BindGroupLayout bindGroupLayout = device.CreateBindGroupLayout(&bglDesc);
@ -663,8 +663,8 @@ TEST_F(GetBindGroupLayoutTests, Reflection) {
{ {
wgpu::BindGroupLayoutDescriptor emptyDesc = {}; wgpu::BindGroupLayoutDescriptor emptyDesc = {};
emptyDesc.bindingCount = 0; emptyDesc.entryCount = 0;
emptyDesc.bindings = nullptr; emptyDesc.entries = nullptr;
wgpu::BindGroupLayout emptyBindGroupLayout = device.CreateBindGroupLayout(&emptyDesc); wgpu::BindGroupLayout emptyBindGroupLayout = device.CreateBindGroupLayout(&emptyDesc);

9
src/tests/unittests/validation/StorageTextureValidationTests.cpp
View File

@ -381,11 +381,12 @@ TEST_F(StorageTextureValidationTests, BindGroupLayoutWithStorageTextureBindingTy
{wgpu::ShaderStage::Compute, wgpu::BindingType::StorageTexture, false}}}; {wgpu::ShaderStage::Compute, wgpu::BindingType::StorageTexture, false}}};
for (const auto& testSpec : kTestSpecs) { for (const auto& testSpec : kTestSpecs) {
wgpu::BindGroupLayoutEntry binding = {0, testSpec.stage, testSpec.type}; wgpu::BindGroupLayoutEntry entry = {0, testSpec.stage, testSpec.type};
binding.storageTextureFormat = wgpu::TextureFormat::R32Uint; entry.storageTextureFormat = wgpu::TextureFormat::R32Uint;
wgpu::BindGroupLayoutDescriptor descriptor; wgpu::BindGroupLayoutDescriptor descriptor;
descriptor.bindingCount = 1; descriptor.entryCount = 1;
descriptor.bindings = &binding; descriptor.entries = &entry;
if (testSpec.valid) { if (testSpec.valid) {
device.CreateBindGroupLayout(&descriptor); device.CreateBindGroupLayout(&descriptor);

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

@ -49,8 +49,8 @@ TEST_F(WireArgumentTests, ValueArgument) {
TEST_F(WireArgumentTests, ValueArrayArgument) { TEST_F(WireArgumentTests, ValueArrayArgument) {
// Create a bindgroup. // Create a bindgroup.
WGPUBindGroupLayoutDescriptor bglDescriptor = {}; WGPUBindGroupLayoutDescriptor bglDescriptor = {};
bglDescriptor.bindingCount = 0; bglDescriptor.entryCount = 0;
bglDescriptor.bindings = nullptr; bglDescriptor.entries = nullptr;
WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor); WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor);
WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout(); WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
@ -58,8 +58,8 @@ TEST_F(WireArgumentTests, ValueArrayArgument) {
WGPUBindGroupDescriptor bindGroupDescriptor = {}; WGPUBindGroupDescriptor bindGroupDescriptor = {};
bindGroupDescriptor.layout = bgl; bindGroupDescriptor.layout = bgl;
bindGroupDescriptor.bindingCount = 0; bindGroupDescriptor.entryCount = 0;
bindGroupDescriptor.bindings = nullptr; bindGroupDescriptor.entries = nullptr;
WGPUBindGroup bindGroup = wgpuDeviceCreateBindGroup(device, &bindGroupDescriptor); WGPUBindGroup bindGroup = wgpuDeviceCreateBindGroup(device, &bindGroupDescriptor);
WGPUBindGroup apiBindGroup = api.GetNewBindGroup(); WGPUBindGroup apiBindGroup = api.GetNewBindGroup();
@ -284,8 +284,8 @@ TEST_F(WireArgumentTests, StructureOfValuesArgument) {
// Test that the wire is able to send structures that contain objects // Test that the wire is able to send structures that contain objects
TEST_F(WireArgumentTests, StructureOfObjectArrayArgument) { TEST_F(WireArgumentTests, StructureOfObjectArrayArgument) {
WGPUBindGroupLayoutDescriptor bglDescriptor = {}; WGPUBindGroupLayoutDescriptor bglDescriptor = {};
bglDescriptor.bindingCount = 0; bglDescriptor.entryCount = 0;
bglDescriptor.bindings = nullptr; bglDescriptor.entries = nullptr;
WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor); WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor);
WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout(); WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
@ -313,7 +313,7 @@ TEST_F(WireArgumentTests, StructureOfObjectArrayArgument) {
// Test that the wire is able to send structures that contain objects // Test that the wire is able to send structures that contain objects
TEST_F(WireArgumentTests, StructureOfStructureArrayArgument) { TEST_F(WireArgumentTests, StructureOfStructureArrayArgument) {
static constexpr int NUM_BINDINGS = 3; static constexpr int NUM_BINDINGS = 3;
WGPUBindGroupLayoutEntry bindings[NUM_BINDINGS]{ WGPUBindGroupLayoutEntry entries[NUM_BINDINGS]{
{0, {0,
WGPUShaderStage_Vertex, WGPUShaderStage_Vertex,
WGPUBindingType_Sampler, WGPUBindingType_Sampler,
@ -343,24 +343,24 @@ TEST_F(WireArgumentTests, StructureOfStructureArrayArgument) {
WGPUTextureFormat_RGBA8Unorm}, WGPUTextureFormat_RGBA8Unorm},
}; };
WGPUBindGroupLayoutDescriptor bglDescriptor = {}; WGPUBindGroupLayoutDescriptor bglDescriptor = {};
bglDescriptor.bindingCount = NUM_BINDINGS; bglDescriptor.entryCount = NUM_BINDINGS;
bglDescriptor.bindings = bindings; bglDescriptor.entries = entries;
wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor); wgpuDeviceCreateBindGroupLayout(device, &bglDescriptor);
WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout(); WGPUBindGroupLayout apiBgl = api.GetNewBindGroupLayout();
EXPECT_CALL( EXPECT_CALL(
api, api,
DeviceCreateBindGroupLayout( DeviceCreateBindGroupLayout(
apiDevice, MatchesLambda([bindings](const WGPUBindGroupLayoutDescriptor* desc) -> bool { apiDevice, MatchesLambda([entries](const WGPUBindGroupLayoutDescriptor* desc) -> bool {
for (int i = 0; i < NUM_BINDINGS; ++i) { for (int i = 0; i < NUM_BINDINGS; ++i) {
const auto& a = desc->bindings[i]; const auto& a = desc->entries[i];
const auto& b = bindings[i]; const auto& b = entries[i];
if (a.binding != b.binding || a.visibility != b.visibility || if (a.binding != b.binding || a.visibility != b.visibility ||
a.type != b.type) { a.type != b.type) {
return false; return false;
} }
} }
return desc->nextInChain == nullptr && desc->bindingCount == 3; return desc->nextInChain == nullptr && desc->entryCount == 3;
}))) })))
.WillOnce(Return(apiBgl)); .WillOnce(Return(apiBgl));

10
src/tests/unittests/wire/WireMultipleDeviceTests.cpp
View File

@ -166,11 +166,11 @@ TEST_F(WireMultipleDeviceTests, DifferentDeviceObjectCreationIsError) {
wireA.FlushClient(); wireA.FlushClient();
std::array<WGPUBindGroupBinding, 2> bindings = {}; std::array<WGPUBindGroupBinding, 2> entries = {};
// Create a buffer on wire A. // Create a buffer on wire A.
WGPUBufferDescriptor bufferDesc = {}; WGPUBufferDescriptor bufferDesc = {};
bindings[0].buffer = wgpuDeviceCreateBuffer(wireA.ClientDevice(), &bufferDesc); entries[0].buffer = wgpuDeviceCreateBuffer(wireA.ClientDevice(), &bufferDesc);
EXPECT_CALL(*wireA.Api(), DeviceCreateBuffer(wireA.ServerDevice(), _)) EXPECT_CALL(*wireA.Api(), DeviceCreateBuffer(wireA.ServerDevice(), _))
.WillOnce(Return(wireA.Api()->GetNewBuffer())); .WillOnce(Return(wireA.Api()->GetNewBuffer()));
@ -178,7 +178,7 @@ TEST_F(WireMultipleDeviceTests, DifferentDeviceObjectCreationIsError) {
// Create a sampler on wire B. // Create a sampler on wire B.
WGPUSamplerDescriptor samplerDesc = {}; WGPUSamplerDescriptor samplerDesc = {};
bindings[1].sampler = wgpuDeviceCreateSampler(wireB.ClientDevice(), &samplerDesc); entries[1].sampler = wgpuDeviceCreateSampler(wireB.ClientDevice(), &samplerDesc);
EXPECT_CALL(*wireB.Api(), DeviceCreateSampler(wireB.ServerDevice(), _)) EXPECT_CALL(*wireB.Api(), DeviceCreateSampler(wireB.ServerDevice(), _))
.WillOnce(Return(wireB.Api()->GetNewSampler())); .WillOnce(Return(wireB.Api()->GetNewSampler()));
@ -187,8 +187,8 @@ TEST_F(WireMultipleDeviceTests, DifferentDeviceObjectCreationIsError) {
// Create a bind group on wire A using the bgl (A), buffer (A), and sampler (B). // Create a bind group on wire A using the bgl (A), buffer (A), and sampler (B).
WGPUBindGroupDescriptor bgDesc = {}; WGPUBindGroupDescriptor bgDesc = {};
bgDesc.layout = bglA; bgDesc.layout = bglA;
bgDesc.bindingCount = bindings.size(); bgDesc.entryCount = entries.size();
bgDesc.bindings = bindings.data(); bgDesc.entries = entries.data();
WGPUBindGroup bindGroupA = wgpuDeviceCreateBindGroup(wireA.ClientDevice(), &bgDesc); WGPUBindGroup bindGroupA = wgpuDeviceCreateBindGroup(wireA.ClientDevice(), &bgDesc);
// It should inject an error because the sampler is from a different device. // It should inject an error because the sampler is from a different device.

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

@ -27,7 +27,7 @@ class WireOptionalTests : public WireTest {
// Test passing nullptr instead of objects - object as value version // Test passing nullptr instead of objects - object as value version
TEST_F(WireOptionalTests, OptionalObjectValue) { TEST_F(WireOptionalTests, OptionalObjectValue) {
WGPUBindGroupLayoutDescriptor bglDesc = {}; WGPUBindGroupLayoutDescriptor bglDesc = {};
bglDesc.bindingCount = 0; bglDesc.entryCount = 0;
WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDesc); WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(device, &bglDesc);
WGPUBindGroupLayout apiBindGroupLayout = api.GetNewBindGroupLayout(); WGPUBindGroupLayout apiBindGroupLayout = api.GetNewBindGroupLayout();
@ -35,27 +35,27 @@ TEST_F(WireOptionalTests, OptionalObjectValue) {
.WillOnce(Return(apiBindGroupLayout)); .WillOnce(Return(apiBindGroupLayout));
// The `sampler`, `textureView` and `buffer` members of a binding are optional. // The `sampler`, `textureView` and `buffer` members of a binding are optional.
WGPUBindGroupEntry binding; WGPUBindGroupEntry entry;
binding.binding = 0; entry.binding = 0;
binding.sampler = nullptr; entry.sampler = nullptr;
binding.textureView = nullptr; entry.textureView = nullptr;
binding.buffer = nullptr; entry.buffer = nullptr;
WGPUBindGroupDescriptor bgDesc = {}; WGPUBindGroupDescriptor bgDesc = {};
bgDesc.layout = bgl; bgDesc.layout = bgl;
bgDesc.bindingCount = 1; bgDesc.entryCount = 1;
bgDesc.bindings = &binding; bgDesc.entries = &entry;
wgpuDeviceCreateBindGroup(device, &bgDesc); wgpuDeviceCreateBindGroup(device, &bgDesc);
WGPUBindGroup apiDummyBindGroup = api.GetNewBindGroup(); WGPUBindGroup apiDummyBindGroup = api.GetNewBindGroup();
EXPECT_CALL(api, DeviceCreateBindGroup( EXPECT_CALL(api, DeviceCreateBindGroup(
apiDevice, MatchesLambda([](const WGPUBindGroupDescriptor* desc) -> bool { apiDevice, MatchesLambda([](const WGPUBindGroupDescriptor* desc) -> bool {
return desc->nextInChain == nullptr && desc->bindingCount == 1 && return desc->nextInChain == nullptr && desc->entryCount == 1 &&
desc->bindings[0].binding == 0 && desc->entries[0].binding == 0 &&
desc->bindings[0].sampler == nullptr && desc->entries[0].sampler == nullptr &&
desc->bindings[0].buffer == nullptr && desc->entries[0].buffer == nullptr &&
desc->bindings[0].textureView == nullptr; desc->entries[0].textureView == nullptr;
}))) })))
.WillOnce(Return(apiDummyBindGroup)); .WillOnce(Return(apiDummyBindGroup));

25
src/utils/WGPUHelpers.cpp
View File

@ -271,16 +271,15 @@ namespace utils {
wgpu::BindGroupLayout MakeBindGroupLayout( wgpu::BindGroupLayout MakeBindGroupLayout(
const wgpu::Device& device, const wgpu::Device& device,
std::initializer_list<wgpu::BindGroupLayoutEntry> bindingsInitializer) { std::initializer_list<wgpu::BindGroupLayoutEntry> entriesInitializer) {
std::vector<wgpu::BindGroupLayoutEntry> entries;
std::vector<wgpu::BindGroupLayoutEntry> bindings; for (const wgpu::BindGroupLayoutEntry& entry : entriesInitializer) {
for (const wgpu::BindGroupLayoutEntry& binding : bindingsInitializer) { entries.push_back(entry);
bindings.push_back(binding);
} }
wgpu::BindGroupLayoutDescriptor descriptor; wgpu::BindGroupLayoutDescriptor descriptor;
descriptor.bindingCount = static_cast<uint32_t>(bindings.size()); descriptor.entryCount = static_cast<uint32_t>(entries.size());
descriptor.bindings = bindings.data(); descriptor.entries = entries.data();
return device.CreateBindGroupLayout(&descriptor); return device.CreateBindGroupLayout(&descriptor);
} }
@ -317,16 +316,16 @@ namespace utils {
wgpu::BindGroup MakeBindGroup( wgpu::BindGroup MakeBindGroup(
const wgpu::Device& device, const wgpu::Device& device,
const wgpu::BindGroupLayout& layout, const wgpu::BindGroupLayout& layout,
std::initializer_list<BindingInitializationHelper> bindingsInitializer) { std::initializer_list<BindingInitializationHelper> entriesInitializer) {
std::vector<wgpu::BindGroupEntry> bindings; std::vector<wgpu::BindGroupEntry> entries;
for (const BindingInitializationHelper& helper : bindingsInitializer) { for (const BindingInitializationHelper& helper : entriesInitializer) {
bindings.push_back(helper.GetAsBinding()); entries.push_back(helper.GetAsBinding());
} }
wgpu::BindGroupDescriptor descriptor; wgpu::BindGroupDescriptor descriptor;
descriptor.layout = layout; descriptor.layout = layout;
descriptor.bindingCount = bindings.size(); descriptor.entryCount = entries.size();
descriptor.bindings = bindings.data(); descriptor.entries = entries.data();
return device.CreateBindGroup(&descriptor); return device.CreateBindGroup(&descriptor);
} }

4
src/utils/WGPUHelpers.h
View File

@ -91,7 +91,7 @@ namespace utils {
const wgpu::BindGroupLayout* bindGroupLayout); const wgpu::BindGroupLayout* bindGroupLayout);
wgpu::BindGroupLayout MakeBindGroupLayout( wgpu::BindGroupLayout MakeBindGroupLayout(
const wgpu::Device& device, const wgpu::Device& device,
std::initializer_list<wgpu::BindGroupLayoutEntry> bindingsInitializer); std::initializer_list<wgpu::BindGroupLayoutEntry> entriesInitializer);
// Helpers to make creating bind groups look nicer: // Helpers to make creating bind groups look nicer:
// //
@ -124,7 +124,7 @@ namespace utils {
wgpu::BindGroup MakeBindGroup( wgpu::BindGroup MakeBindGroup(
const wgpu::Device& device, const wgpu::Device& device,
const wgpu::BindGroupLayout& layout, const wgpu::BindGroupLayout& layout,
std::initializer_list<BindingInitializationHelper> bindingsInitializer); std::initializer_list<BindingInitializationHelper> entriesInitializer);
} // namespace utils } // namespace utils