blob: 5603b22246de5912e88638c9d5419c603dc59151 [file] [log] [blame]
// Copyright 2023 The Dawn & Tint Authors
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <string>
#include <vector>
#include "dawn/common/NonMovable.h"
#include "dawn/tests/unittests/validation/ValidationTest.h"
#include "dawn/utils/ComboRenderPipelineDescriptor.h"
#include "dawn/utils/WGPUHelpers.h"
namespace dawn {
namespace {
class PixelLocalStorageDisabledTest : public ValidationTest {};
// Check that creating a StorageAttachment texture is disallowed without the extension.
TEST_F(PixelLocalStorageDisabledTest, StorageAttachmentTextureNotAllowed) {
wgpu::TextureDescriptor desc;
desc.size = {1, 1, 1};
desc.format = wgpu::TextureFormat::R32Uint;
desc.usage = wgpu::TextureUsage::TextureBinding;
// Control case: creating the texture without StorageAttachment is allowed.
device.CreateTexture(&desc);
// Error case: creating the texture without StorageAttachment is disallowed.
desc.usage = wgpu::TextureUsage::StorageAttachment;
ASSERT_DEVICE_ERROR(device.CreateTexture(&desc));
}
// Check that creating a pipeline layout with a PipelineLayoutPixelLocalStorage is disallowed
// without the extension.
TEST_F(PixelLocalStorageDisabledTest, PipelineLayoutPixelLocalStorageDisallowed) {
wgpu::PipelineLayoutDescriptor desc;
desc.bindGroupLayoutCount = 0;
// Control case: creating the pipeline layout without the PLS is allowed.
device.CreatePipelineLayout(&desc);
// Error case: creating the pipeline layout with a PLS is disallowed even if it is empty.
wgpu::PipelineLayoutPixelLocalStorage pls;
pls.totalPixelLocalStorageSize = 0;
pls.storageAttachmentCount = 0;
desc.nextInChain = &pls;
ASSERT_DEVICE_ERROR(device.CreatePipelineLayout(&desc));
}
// Check that a render pass with a RenderPassPixelLocalStorage is disallowed without the extension.
TEST_F(PixelLocalStorageDisabledTest, RenderPassPixelLocalStorageDisallowed) {
utils::BasicRenderPass rp = utils::CreateBasicRenderPass(device, 1, 1);
// Control case: beginning the render pass without the PLS is allowed.
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&rp.renderPassInfo);
pass.End();
encoder.Finish();
}
// Error case: beginning the render pass without the PLS is disallowed, even if it is empty.
{
wgpu::RenderPassPixelLocalStorage pls;
pls.totalPixelLocalStorageSize = 0;
pls.storageAttachmentCount = 0;
rp.renderPassInfo.nextInChain = &pls;
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&rp.renderPassInfo);
pass.End();
ASSERT_DEVICE_ERROR(encoder.Finish());
}
}
// Check that it is not possible to use the WGSL extension without the device extension enabled.
TEST_F(PixelLocalStorageDisabledTest, WGSLExtensionDisallowed) {
ASSERT_DEVICE_ERROR(utils::CreateShaderModule(device, R"(
enable chromium_experimental_pixel_local;
)"));
}
// Check that PixelLocalStorageBarrier() is disallowed without the extension.
TEST_F(PixelLocalStorageDisabledTest, PixelLocalStorageBarrierDisallowed) {
utils::BasicRenderPass rp = utils::CreateBasicRenderPass(device, 1, 1);
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&rp.renderPassInfo);
pass.PixelLocalStorageBarrier();
pass.End();
ASSERT_DEVICE_ERROR(encoder.Finish());
}
class PixelLocalStorageOtherExtensionTest : public ValidationTest {
protected:
std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
// Only test the coherent extension. The non-coherent one has the rest of the validation
// tests.
return {wgpu::FeatureName::PixelLocalStorageCoherent};
}
};
// Simple test checking all the various things that are normally validated out without PLS are
// available if the coherent PLS extension is enabled.
TEST_F(PixelLocalStorageOtherExtensionTest, SmokeTest) {
// Creating a StorageAttachment texture is allowed.
wgpu::TextureDescriptor textureDesc;
textureDesc.size = {1, 1, 1};
textureDesc.format = wgpu::TextureFormat::R32Uint;
textureDesc.usage = wgpu::TextureUsage::StorageAttachment;
wgpu::Texture tex = device.CreateTexture(&textureDesc);
// Creating a pipeline layout with PLS is allowed.
wgpu::PipelineLayoutPixelLocalStorage plPlsDesc;
plPlsDesc.totalPixelLocalStorageSize = 0;
plPlsDesc.storageAttachmentCount = 0;
wgpu::PipelineLayoutDescriptor plDesc;
plDesc.bindGroupLayoutCount = 0;
plDesc.nextInChain = &plPlsDesc;
device.CreatePipelineLayout(&plDesc);
// Creating a PLS render pass is allowed.
wgpu::RenderPassPixelLocalStorage rpPlsDesc;
rpPlsDesc.totalPixelLocalStorageSize = 0;
rpPlsDesc.storageAttachmentCount = 0;
utils::BasicRenderPass rp = utils::CreateBasicRenderPass(device, 1, 1);
rp.renderPassInfo.nextInChain = &rpPlsDesc;
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&rp.renderPassInfo);
// Calling PixelLocalStorageBarrier is allowed.
pass.PixelLocalStorageBarrier();
pass.End();
encoder.Finish();
// Creating a shader with the extension is allowed.
utils::CreateShaderModule(device, R"(
enable chromium_experimental_pixel_local;
)");
}
struct OffsetAndFormat {
uint64_t offset;
wgpu::TextureFormat format;
};
struct PLSSpec {
uint64_t totalSize;
std::vector<OffsetAndFormat> attachments;
bool active = true;
};
constexpr std::array<wgpu::TextureFormat, 3> kStorageAttachmentFormats = {
wgpu::TextureFormat::R32Float,
wgpu::TextureFormat::R32Uint,
wgpu::TextureFormat::R32Sint,
};
bool IsStorageAttachmentFormat(wgpu::TextureFormat format) {
return std::find(kStorageAttachmentFormats.begin(), kStorageAttachmentFormats.end(), format) !=
kStorageAttachmentFormats.end();
}
struct ComboTestPLSRenderPassDescriptor : NonMovable {
std::array<wgpu::RenderPassStorageAttachment, 8> storageAttachments;
wgpu::RenderPassPixelLocalStorage pls;
wgpu::RenderPassColorAttachment colorAttachment;
wgpu::RenderPassDescriptor rpDesc;
};
class PixelLocalStorageTest : public ValidationTest {
protected:
std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
// Test only the non-coherent version, and assume that the same validation code paths are
// taken for the coherent path.
return {wgpu::FeatureName::PixelLocalStorageNonCoherent};
}
void InitializePLSRenderPass(ComboTestPLSRenderPassDescriptor* desc) {
// Set up a single storage attachment.
wgpu::TextureDescriptor storageDesc;
storageDesc.size = {1, 1};
storageDesc.format = wgpu::TextureFormat::R32Uint;
storageDesc.usage = wgpu::TextureUsage::StorageAttachment;
wgpu::Texture storage = device.CreateTexture(&storageDesc);
desc->storageAttachments[0].storage = storage.CreateView();
desc->storageAttachments[0].offset = 0;
desc->storageAttachments[0].loadOp = wgpu::LoadOp::Load;
desc->storageAttachments[0].storeOp = wgpu::StoreOp::Store;
desc->pls.totalPixelLocalStorageSize = 4;
desc->pls.storageAttachmentCount = 1;
desc->pls.storageAttachments = desc->storageAttachments.data();
// Add at least one color attachment to make the render pass valid if there's no storage
// attachment.
wgpu::TextureDescriptor colorDesc;
colorDesc.size = {1, 1};
colorDesc.format = kColorAttachmentFormat;
colorDesc.usage = wgpu::TextureUsage::RenderAttachment;
wgpu::Texture color = device.CreateTexture(&colorDesc);
desc->colorAttachment.view = color.CreateView();
desc->colorAttachment.loadOp = wgpu::LoadOp::Load;
desc->colorAttachment.storeOp = wgpu::StoreOp::Store;
desc->rpDesc.nextInChain = &desc->pls;
desc->rpDesc.colorAttachmentCount = 1;
desc->rpDesc.colorAttachments = &desc->colorAttachment;
}
void RecordRenderPass(const wgpu::RenderPassDescriptor* desc,
wgpu::RenderPipeline pipeline = {}) {
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(desc);
if (pipeline) {
pass.SetPipeline(pipeline);
}
pass.End();
encoder.Finish();
}
void RecordPLSRenderPass(const PLSSpec& spec, wgpu::RenderPipeline pipeline = {}) {
ComboTestPLSRenderPassDescriptor desc;
InitializePLSRenderPass(&desc);
// Convert the PLSSpec to a RenderPassPLS
for (size_t i = 0; i < spec.attachments.size(); i++) {
wgpu::TextureDescriptor tDesc;
tDesc.size = {1, 1};
tDesc.format = spec.attachments[i].format;
tDesc.usage = wgpu::TextureUsage::StorageAttachment;
wgpu::Texture texture = device.CreateTexture(&tDesc);
desc.storageAttachments[i].storage = texture.CreateView();
desc.storageAttachments[i].offset = spec.attachments[i].offset;
desc.storageAttachments[i].loadOp = wgpu::LoadOp::Load;
desc.storageAttachments[i].storeOp = wgpu::StoreOp::Store;
}
desc.pls.totalPixelLocalStorageSize = spec.totalSize;
desc.pls.storageAttachmentCount = spec.attachments.size();
// Add the PLS if needed and record the render pass.
if (!spec.active) {
desc.rpDesc.nextInChain = nullptr;
}
RecordRenderPass(&desc.rpDesc, pipeline);
}
wgpu::PipelineLayout MakePipelineLayout(const PLSSpec& spec) {
// Convert the PLSSpec to a PipelineLayoutPLS
std::vector<wgpu::PipelineLayoutStorageAttachment> storageAttachments;
for (const auto& attachmentSpec : spec.attachments) {
wgpu::PipelineLayoutStorageAttachment attachment;
attachment.format = attachmentSpec.format;
attachment.offset = attachmentSpec.offset;
storageAttachments.push_back(attachment);
}
wgpu::PipelineLayoutPixelLocalStorage pls;
pls.totalPixelLocalStorageSize = spec.totalSize;
pls.storageAttachmentCount = storageAttachments.size();
pls.storageAttachments = storageAttachments.data();
// Add the PLS if needed and make the pipeline layout.
wgpu::PipelineLayoutDescriptor plDesc;
plDesc.bindGroupLayoutCount = 0;
if (spec.active) {
plDesc.nextInChain = &pls;
}
return device.CreatePipelineLayout(&plDesc);
}
wgpu::RenderPipeline MakePipeline(const PLSSpec& spec) {
std::vector<const char*> plsTypes;
plsTypes.resize(spec.totalSize / kPLSSlotByteSize, "u32");
for (const auto& attachment : spec.attachments) {
switch (attachment.format) {
case wgpu::TextureFormat::R32Uint:
plsTypes[attachment.offset / kPLSSlotByteSize] = "u32";
break;
case wgpu::TextureFormat::R32Sint:
plsTypes[attachment.offset / kPLSSlotByteSize] = "i32";
break;
case wgpu::TextureFormat::R32Float:
plsTypes[attachment.offset / kPLSSlotByteSize] = "f32";
break;
default:
DAWN_UNREACHABLE();
}
}
bool outputPLS = spec.active && !plsTypes.empty();
std::ostringstream fsStream;
fsStream << "enable chromium_experimental_pixel_local;\n";
if (outputPLS) {
fsStream << "struct PLS {\n";
for (size_t i = 0; i < plsTypes.size(); i++) {
fsStream << " a" << i << " : " << plsTypes[i] << ",\n";
}
fsStream << "}\n";
fsStream << "var<pixel_local> pls : PLS;\n";
}
fsStream << "@fragment fn fs() -> @location(0) u32 {\n";
if (outputPLS) {
fsStream << " _ = pls;\n";
}
fsStream << " return 0u;\n";
fsStream << "}\n";
utils::ComboRenderPipelineDescriptor desc;
desc.layout = MakePipelineLayout(spec);
desc.cFragment.module = utils::CreateShaderModule(device, fsStream.str().c_str());
desc.vertex.module = utils::CreateShaderModule(device, R"(
@vertex fn vs() -> @builtin(position) vec4f {
return vec4f();
}
)");
desc.cTargets[0].format = kColorAttachmentFormat;
return device.CreateRenderPipeline(&desc);
}
void CheckPLSStateMatching(const PLSSpec& rpSpec, const PLSSpec& pipelineSpec, bool success) {
wgpu::RenderPipeline pipeline = MakePipeline(pipelineSpec);
if (success) {
RecordPLSRenderPass(rpSpec, pipeline);
} else {
ASSERT_DEVICE_ERROR(RecordPLSRenderPass(rpSpec, pipeline));
}
}
void TestFragmentAndLayoutCompat(const PLSSpec& layoutSpec,
absl::string_view fs,
bool success) {
TestFragmentAndLayoutCompat(MakePipelineLayout(layoutSpec), fs, success);
}
void TestFragmentAndLayoutCompat(const wgpu::PipelineLayout& layout,
absl::string_view fs,
bool success) {
wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, fs.data());
wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
@vertex fn vs() -> @builtin(position) vec4f {
return vec4f();
}
)");
utils::ComboRenderPipelineDescriptor desc;
desc.layout = layout;
desc.cFragment.module = fsModule;
desc.vertex.module = vsModule;
desc.cTargets[0].format = kColorAttachmentFormat;
desc.cTargets[0].writeMask = wgpu::ColorWriteMask::None;
if (success) {
device.CreateRenderPipeline(&desc);
} else {
ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&desc));
}
}
static constexpr wgpu::TextureFormat kColorAttachmentFormat = wgpu::TextureFormat::R32Uint;
};
// Check that it is possible to use the WGSL extension when the device extension is enabled.
TEST_F(PixelLocalStorageTest, WGSLExtensionAllowed) {
utils::CreateShaderModule(device, R"(
enable chromium_experimental_pixel_local;
)");
}
// Check that StorageAttachment textures must be one of the supported formats.
TEST_F(PixelLocalStorageTest, TextureFormatMustSupportStorageAttachment) {
for (wgpu::TextureFormat format : utils::kAllTextureFormats) {
wgpu::TextureDescriptor desc;
desc.size = {1, 1};
desc.format = format;
desc.usage = wgpu::TextureUsage::StorageAttachment;
if (IsStorageAttachmentFormat(format)) {
device.CreateTexture(&desc);
} else {
ASSERT_DEVICE_ERROR(device.CreateTexture(&desc));
}
}
}
// Check that StorageAttachment textures must have a sample count of 1.
TEST_F(PixelLocalStorageTest, TextureMustBeSingleSampled) {
wgpu::TextureDescriptor desc;
desc.size = {1, 1};
desc.format = wgpu::TextureFormat::R32Uint;
desc.usage = wgpu::TextureUsage::StorageAttachment;
// Control case: sampleCount = 1 is valid.
desc.sampleCount = 1;
device.CreateTexture(&desc);
// Error case: sampledCount != 1 is an error.
desc.sampleCount = 4;
ASSERT_DEVICE_ERROR(device.CreateTexture(&desc));
}
// Check that the format in PLS must be one of the enabled ones.
TEST_F(PixelLocalStorageTest, PLSStateFormatMustSupportStorageAttachment) {
for (wgpu::TextureFormat format : utils::kFormatsInCoreSpec) {
PLSSpec spec = {4, {{0, format}}};
// Note that BeginRenderPass is not tested here as a different test checks that the
// StorageAttachment texture must indeed have been created with the StorageAttachment usage.
if (IsStorageAttachmentFormat(format)) {
MakePipelineLayout(spec);
} else {
ASSERT_DEVICE_ERROR(MakePipelineLayout(spec));
}
}
}
// Check that the total size must be a multiple of 4.
TEST_F(PixelLocalStorageTest, PLSStateTotalSizeMultipleOf4) {
// Control case: total size is a multiple of 4.
{
PLSSpec spec = {4, {}};
MakePipelineLayout(spec);
RecordPLSRenderPass(spec);
}
// Control case: total size isn't a multiple of 4.
{
PLSSpec spec = {2, {}};
ASSERT_DEVICE_ERROR(MakePipelineLayout(spec));
ASSERT_DEVICE_ERROR(RecordPLSRenderPass(spec));
}
}
// Check that the total size must be less than 16.
// TODO(dawn:1704): Have a proper limit for totalSize.
TEST_F(PixelLocalStorageTest, PLSStateTotalLessThan16) {
// Control case: total size is 16.
{
PLSSpec spec = {16, {}};
MakePipelineLayout(spec);
RecordPLSRenderPass(spec);
}
// Control case: total size is greater than 16.
{
PLSSpec spec = {20, {}};
ASSERT_DEVICE_ERROR(MakePipelineLayout(spec));
ASSERT_DEVICE_ERROR(RecordPLSRenderPass(spec));
}
}
// Check that the offset of a storage attachment must be a multiple of 4.
TEST_F(PixelLocalStorageTest, PLSStateOffsetMultipleOf4) {
// Control case: offset is a multiple of 4.
{
PLSSpec spec = {8, {{4, wgpu::TextureFormat::R32Uint}}};
MakePipelineLayout(spec);
RecordPLSRenderPass(spec);
}
// Error case: offset isn't a multiple of 4.
{
PLSSpec spec = {8, {{2, wgpu::TextureFormat::R32Uint}}};
ASSERT_DEVICE_ERROR(MakePipelineLayout(spec));
ASSERT_DEVICE_ERROR(RecordPLSRenderPass(spec));
}
}
// Check that the storage attachment is in bounds of the total size.
TEST_F(PixelLocalStorageTest, PLSStateAttachmentInBoundsOfTotalSize) {
// Note that all storage attachment formats are currently 4 byte wide.
// Control case: 0 + 4 <= 4
{
PLSSpec spec = {4, {{0, wgpu::TextureFormat::R32Uint}}};
MakePipelineLayout(spec);
RecordPLSRenderPass(spec);
}
// Error case: 4 + 4 > 4
{
PLSSpec spec = {4, {{4, wgpu::TextureFormat::R32Uint}}};
ASSERT_DEVICE_ERROR(MakePipelineLayout(spec));
ASSERT_DEVICE_ERROR(RecordPLSRenderPass(spec));
}
// Control case: 8 + 4 <= 12
{
PLSSpec spec = {12, {{8, wgpu::TextureFormat::R32Uint}}};
MakePipelineLayout(spec);
RecordPLSRenderPass(spec);
}
// Error case: 12 + 4 > 12
{
PLSSpec spec = {4, {{12, wgpu::TextureFormat::R32Uint}}};
ASSERT_DEVICE_ERROR(MakePipelineLayout(spec));
ASSERT_DEVICE_ERROR(RecordPLSRenderPass(spec));
}
// Check that overflows don't incorrectly pass the validation.
{
PLSSpec spec = {4, {{uint64_t(0) - uint64_t(4), wgpu::TextureFormat::R32Uint}}};
ASSERT_DEVICE_ERROR(MakePipelineLayout(spec));
ASSERT_DEVICE_ERROR(RecordPLSRenderPass(spec));
}
}
// Check that collisions between storage attachments are not allowed.
TEST_F(PixelLocalStorageTest, PLSStateCollisionsDisallowed) {
// Control case: no collisions, all is good!
{
PLSSpec spec = {8, {{0, wgpu::TextureFormat::R32Uint}, {4, wgpu::TextureFormat::R32Uint}}};
MakePipelineLayout(spec);
RecordPLSRenderPass(spec);
}
// Error case: collisions, boo!
{
PLSSpec spec = {8, {{0, wgpu::TextureFormat::R32Uint}, {0, wgpu::TextureFormat::R32Uint}}};
ASSERT_DEVICE_ERROR(MakePipelineLayout(spec));
ASSERT_DEVICE_ERROR(RecordPLSRenderPass(spec));
}
{
PLSSpec spec = {8,
{{0, wgpu::TextureFormat::R32Uint},
{4, wgpu::TextureFormat::R32Uint},
{0, wgpu::TextureFormat::R32Uint}}};
ASSERT_DEVICE_ERROR(MakePipelineLayout(spec));
ASSERT_DEVICE_ERROR(RecordPLSRenderPass(spec));
}
}
// Check that using an error view as storage attachment is an error.
TEST_F(PixelLocalStorageTest, RenderPassStorageAttachmentErrorView) {
ComboTestPLSRenderPassDescriptor desc;
InitializePLSRenderPass(&desc);
wgpu::TextureDescriptor tDesc;
tDesc.size = {1, 1};
tDesc.usage = wgpu::TextureUsage::StorageAttachment;
tDesc.format = wgpu::TextureFormat::R32Uint;
wgpu::Texture t = device.CreateTexture(&tDesc);
wgpu::TextureViewDescriptor viewDesc;
// Control case: valid texture view.
desc.storageAttachments[0].storage = t.CreateView(&viewDesc);
RecordRenderPass(&desc.rpDesc);
// Error case: invalid texture view because of the base array layer.
viewDesc.baseArrayLayer = 10;
ASSERT_DEVICE_ERROR(desc.storageAttachments[0].storage = t.CreateView(&viewDesc));
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
}
// Check that using a multi-subresource view as a storage attachment is an error (layers and levels
// cases).
TEST_F(PixelLocalStorageTest, RenderPassStorageAttachmentSingleSubresource) {
ComboTestPLSRenderPassDescriptor desc;
InitializePLSRenderPass(&desc);
wgpu::TextureDescriptor colorDesc;
colorDesc.size = {2, 2};
colorDesc.usage = wgpu::TextureUsage::RenderAttachment;
colorDesc.format = kColorAttachmentFormat;
// Replace the render pass attachment with a 2x2 texture for mip level testing.
desc.colorAttachment.view = device.CreateTexture(&colorDesc).CreateView();
// Control case: single subresource view.
wgpu::TextureDescriptor tDesc;
tDesc.size = {2, 2};
tDesc.usage = wgpu::TextureUsage::StorageAttachment;
tDesc.format = wgpu::TextureFormat::R32Uint;
desc.storageAttachments[0].storage = device.CreateTexture(&tDesc).CreateView();
RecordRenderPass(&desc.rpDesc);
// Error case: two array layers.
tDesc.size.depthOrArrayLayers = 2;
desc.storageAttachments[0].storage = device.CreateTexture(&tDesc).CreateView();
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
// Error case: two mip levels.
tDesc.size.depthOrArrayLayers = 1;
tDesc.mipLevelCount = 2;
desc.storageAttachments[0].storage = device.CreateTexture(&tDesc).CreateView();
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
}
// Check that the size of storage attachments must match the size of other attachments.
TEST_F(PixelLocalStorageTest, RenderPassStorageAttachmentSizeMustMatch) {
ComboTestPLSRenderPassDescriptor desc;
InitializePLSRenderPass(&desc);
// Explicitly set the color attachment to a 1x1 texture.
wgpu::TextureDescriptor colorDesc;
colorDesc.size = {1, 1};
colorDesc.usage = wgpu::TextureUsage::RenderAttachment;
colorDesc.format = kColorAttachmentFormat;
desc.colorAttachment.view = device.CreateTexture(&colorDesc).CreateView();
// Control case: the storage attachment size matches
wgpu::TextureDescriptor tDesc;
tDesc.size = {1, 1};
tDesc.usage = wgpu::TextureUsage::StorageAttachment;
tDesc.format = wgpu::TextureFormat::R32Uint;
desc.storageAttachments[0].storage = device.CreateTexture(&tDesc).CreateView();
RecordRenderPass(&desc.rpDesc);
// Error case: width doesn't match.
tDesc.size = {2, 1};
desc.storageAttachments[0].storage = device.CreateTexture(&tDesc).CreateView();
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
// Error case: height doesn't match.
tDesc.size = {1, 2};
desc.storageAttachments[0].storage = device.CreateTexture(&tDesc).CreateView();
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
}
// Check that the textures used as storage attachment must have the StorageAttachment TextureUsage.
TEST_F(PixelLocalStorageTest, RenderPassStorageAttachmentUsage) {
ComboTestPLSRenderPassDescriptor desc;
InitializePLSRenderPass(&desc);
// Control case: the storage attachment has the correct usage.
wgpu::TextureDescriptor tDesc;
tDesc.size = {1, 1};
tDesc.usage = wgpu::TextureUsage::StorageAttachment;
tDesc.format = wgpu::TextureFormat::R32Uint;
desc.storageAttachments[0].storage = device.CreateTexture(&tDesc).CreateView();
RecordRenderPass(&desc.rpDesc);
// Error case: the storage attachment doesn't have the usage.
tDesc.usage = wgpu::TextureUsage::RenderAttachment;
desc.storageAttachments[0].storage = device.CreateTexture(&tDesc).CreateView();
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
}
// Check that the same texture subresource cannot be used twice as a storage attachment.
TEST_F(PixelLocalStorageTest, RenderPassSubresourceUsedTwiceAsStorage) {
ComboTestPLSRenderPassDescriptor desc;
InitializePLSRenderPass(&desc);
// Control case: two different subresources for two storage attachments.
wgpu::TextureDescriptor tDesc;
tDesc.size = {1, 1};
tDesc.usage = wgpu::TextureUsage::StorageAttachment;
tDesc.format = wgpu::TextureFormat::R32Uint;
desc.storageAttachments[0].storage = device.CreateTexture(&tDesc).CreateView();
desc.storageAttachments[1].storage = device.CreateTexture(&tDesc).CreateView();
desc.storageAttachments[1].offset = 4;
desc.storageAttachments[1].loadOp = wgpu::LoadOp::Load;
desc.storageAttachments[1].storeOp = wgpu::StoreOp::Store;
desc.pls.storageAttachmentCount = 2;
desc.pls.totalPixelLocalStorageSize = 8;
RecordRenderPass(&desc.rpDesc);
// Error case: the same subresource is used twice as a storage attachment.
desc.storageAttachments[0].storage = desc.storageAttachments[1].storage;
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
}
// Check that the same texture subresource cannot be used twice as a storage and render attachment.
TEST_F(PixelLocalStorageTest, RenderPassSubresourceUsedAsStorageAndRender) {
ComboTestPLSRenderPassDescriptor desc;
InitializePLSRenderPass(&desc);
// Control case: two different subresources for storage and render attachments.
wgpu::TextureDescriptor tDesc;
tDesc.size = {1, 1};
tDesc.usage = wgpu::TextureUsage::StorageAttachment | wgpu::TextureUsage::RenderAttachment;
tDesc.format = kColorAttachmentFormat;
desc.storageAttachments[0].storage = device.CreateTexture(&tDesc).CreateView();
RecordRenderPass(&desc.rpDesc);
// Error case: the same view is used twice, once as storage, once as render attachment.
desc.colorAttachment.view = desc.storageAttachments[0].storage;
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
}
// Check that using a subresource as storage attachment prevents other usages in the render pass.
TEST_F(PixelLocalStorageTest, RenderPassSubresourceUsedInsidePass) {
ComboTestPLSRenderPassDescriptor desc;
InitializePLSRenderPass(&desc);
wgpu::TextureDescriptor tDesc;
tDesc.size = {1, 1};
tDesc.usage = wgpu::TextureUsage::StorageAttachment | wgpu::TextureUsage::TextureBinding;
tDesc.format = wgpu::TextureFormat::R32Uint;
desc.storageAttachments[0].storage = device.CreateTexture(&tDesc).CreateView();
// Control case: the storage attachment is used only as storage attachment.
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&desc.rpDesc);
pass.End();
encoder.Finish();
}
// Error case: the storage attachment is also used as a texture binding in a bind group.
{
wgpu::BindGroupLayout bgl = utils::MakeBindGroupLayout(
device, {{0, wgpu::ShaderStage::Fragment, wgpu::TextureSampleType::Uint}});
wgpu::BindGroup bg =
utils::MakeBindGroup(device, bgl, {{0, desc.storageAttachments[0].storage}});
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&desc.rpDesc);
pass.SetBindGroup(0, bg);
pass.End();
ASSERT_DEVICE_ERROR(encoder.Finish());
}
}
// Check that the load and store op must not be undefined.
TEST_F(PixelLocalStorageTest, RenderPassLoadAndStoreOpNotUndefined) {
ComboTestPLSRenderPassDescriptor desc;
InitializePLSRenderPass(&desc);
// Control case: ops are not undefined.
RecordRenderPass(&desc.rpDesc);
// Error case: LoadOp::Undefined
desc.storageAttachments[0].loadOp = wgpu::LoadOp::Undefined;
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
desc.storageAttachments[0].loadOp = wgpu::LoadOp::Load;
// Error case: StoreOp::Undefined
desc.storageAttachments[0].storeOp = wgpu::StoreOp::Undefined;
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
}
// Check that the clear value, if used, must not have NaNs.
TEST_F(PixelLocalStorageTest, RenderPassClearValueNaNs) {
ComboTestPLSRenderPassDescriptor desc;
InitializePLSRenderPass(&desc);
const float kNaN = std::nan("");
// Check that NaNs are allowed if the loadOp is not Clear.
desc.storageAttachments[0].loadOp = wgpu::LoadOp::Load;
desc.storageAttachments[0].clearValue = {kNaN, kNaN, kNaN, kNaN};
RecordRenderPass(&desc.rpDesc);
// Control case, a non-NaN clear value is allowed.
desc.storageAttachments[0].loadOp = wgpu::LoadOp::Clear;
desc.storageAttachments[0].clearValue = {0, 0, 0, 0};
RecordRenderPass(&desc.rpDesc);
// Error case: NaN in one of the components of clearValue.
desc.storageAttachments[0].clearValue = {kNaN, 0, 0, 0};
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
desc.storageAttachments[0].clearValue = {0, kNaN, 0, 0};
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
desc.storageAttachments[0].clearValue = {0, 0, kNaN, 0};
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
desc.storageAttachments[0].clearValue = {0, 0, 0, kNaN};
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
}
// Check that using a subresource as storage attachment prevents other usages in the render pass.
TEST_F(PixelLocalStorageTest, PixelLocalStorageBarrierRequiresPLS) {
ComboTestPLSRenderPassDescriptor desc;
InitializePLSRenderPass(&desc);
// Control case: there is a PLS, the barrier is allowed.
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&desc.rpDesc);
pass.PixelLocalStorageBarrier();
pass.End();
encoder.Finish();
}
// Error case: there is no PLS (it is unlinked from chained structs), the barrier is not
// allowed.
{
desc.rpDesc.nextInChain = nullptr;
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&desc.rpDesc);
pass.PixelLocalStorageBarrier();
pass.End();
ASSERT_DEVICE_ERROR(encoder.Finish());
}
}
// Check that PLS state differs between no PLS and empty PLS
TEST_F(PixelLocalStorageTest, PLSStateMatching_EmptyPLSVsNoPLS) {
PLSSpec emptyPLS = {0, {}, true};
PLSSpec noPLS = {0, {}, false};
CheckPLSStateMatching(emptyPLS, emptyPLS, true);
CheckPLSStateMatching(noPLS, noPLS, true);
CheckPLSStateMatching(emptyPLS, noPLS, false);
CheckPLSStateMatching(noPLS, emptyPLS, false);
}
// Check that PLS state differs between empty PLS and non-empty PLS with no storage attachments
TEST_F(PixelLocalStorageTest, PLSStateMatching_EmptyPLSVsNotEmpty) {
PLSSpec emptyPLS = {0, {}};
PLSSpec notEmptyPLS = {4, {}};
CheckPLSStateMatching(emptyPLS, emptyPLS, true);
CheckPLSStateMatching(notEmptyPLS, notEmptyPLS, true);
CheckPLSStateMatching(emptyPLS, notEmptyPLS, false);
CheckPLSStateMatching(notEmptyPLS, emptyPLS, false);
}
// Check that PLS state differs between implicit PLS vs storage attachment
TEST_F(PixelLocalStorageTest, PLSStateMatching_AttachmentVsImplicit) {
PLSSpec implicitPLS = {4, {}};
PLSSpec storagePLS = {4, {{0, wgpu::TextureFormat::R32Uint}}};
CheckPLSStateMatching(implicitPLS, implicitPLS, true);
CheckPLSStateMatching(storagePLS, storagePLS, true);
CheckPLSStateMatching(implicitPLS, storagePLS, false);
CheckPLSStateMatching(storagePLS, implicitPLS, false);
}
// Check that PLS state differs between storage attachment formats
TEST_F(PixelLocalStorageTest, PLSStateMatching_Format) {
PLSSpec intPLS = {4, {{0, wgpu::TextureFormat::R32Sint}}};
PLSSpec uintPLS = {4, {{0, wgpu::TextureFormat::R32Uint}}};
CheckPLSStateMatching(intPLS, intPLS, true);
CheckPLSStateMatching(uintPLS, uintPLS, true);
CheckPLSStateMatching(intPLS, uintPLS, false);
CheckPLSStateMatching(uintPLS, intPLS, false);
}
// Check that PLS state are equal even if attachments are specified in different orders
TEST_F(PixelLocalStorageTest, PLSStateMatching_StorageAttachmentOrder) {
PLSSpec pls1 = {8, {{4, wgpu::TextureFormat::R32Uint}, {0, wgpu::TextureFormat::R32Sint}}};
PLSSpec pls2 = {8, {{0, wgpu::TextureFormat::R32Sint}, {4, wgpu::TextureFormat::R32Uint}}};
CheckPLSStateMatching(pls1, pls2, true);
}
// Check that a shader using pixel_local cannot be used for an implicit layout.
TEST_F(PixelLocalStorageTest, ImplicitLayoutDisallowed) {
// Control case: not using a pixel_local block is ok.
TestFragmentAndLayoutCompat(nullptr, R"(
enable chromium_experimental_pixel_local;
@fragment fn fs() {}
)",
true);
// Error case: using a pixel_local block is not ok.
TestFragmentAndLayoutCompat(nullptr, R"(
enable chromium_experimental_pixel_local;
struct PLS { a : u32 }
var<pixel_local> pls : PLS;
@fragment fn fs() {
_ = pls;
}
)",
false);
}
// Check that the FS can have PLS iff the layout has it.
TEST_F(PixelLocalStorageTest, Reflection_PLSPresenceMatches) {
// Control case: both without PLS is ok.
TestFragmentAndLayoutCompat({0, {}, false}, R"(
enable chromium_experimental_pixel_local;
@fragment fn fs() {}
)",
true);
// Control case: both with PLS is ok.
TestFragmentAndLayoutCompat({4, {}}, R"(
enable chromium_experimental_pixel_local;
struct PLS { a : u32 }
var<pixel_local> pls : PLS;
@fragment fn fs() {
_ = pls;
}
)",
true);
// Error case: only shader has PLS
TestFragmentAndLayoutCompat({0, {}, false}, R"(
enable chromium_experimental_pixel_local;
struct PLS { a : u32 }
var<pixel_local> pls : PLS;
@fragment fn fs() {
_ = pls;
}
)",
false);
// Error case: only layout has PLS
TestFragmentAndLayoutCompat({4, {}}, R"(
enable chromium_experimental_pixel_local;
@fragment fn fs() {
}
)",
false);
// Special valid case: shader doesn't have PLS but the layout's PLS is empty
TestFragmentAndLayoutCompat({0, {}}, R"(
enable chromium_experimental_pixel_local;
@fragment fn fs() {
}
)",
true);
}
// Check that layout's total PLS size must match the shader's pixel_local block size.
TEST_F(PixelLocalStorageTest, Reflection_PLSSize) {
// Control case: 8 bytes for both!
TestFragmentAndLayoutCompat({8, {}}, R"(
enable chromium_experimental_pixel_local;
struct PLS {
a : u32,
b : u32,
}
var<pixel_local> pls : PLS;
@fragment fn fs() {
_ = pls;
}
)",
true);
// Error case: shader PLS is 4 bytes smaller.
TestFragmentAndLayoutCompat({8, {}}, R"(
enable chromium_experimental_pixel_local;
struct PLS { a : u32 }
var<pixel_local> pls : PLS;
@fragment fn fs() {
_ = pls;
}
)",
false);
// Error case: layout PLS is 4 bytes smaller.
TestFragmentAndLayoutCompat({4, {}}, R"(
enable chromium_experimental_pixel_local;
struct PLS {
a : u32,
b : u32,
}
var<pixel_local> pls : PLS;
@fragment fn fs() {
_ = pls;
}
)",
false);
}
// Check the validation of the layout's PLS format with the shader types.
TEST_F(PixelLocalStorageTest, Reflection_FormatMatching) {
std::array<wgpu::TextureFormat, 4> testFormats = {
wgpu::TextureFormat::R32Uint, wgpu::TextureFormat::R32Sint, wgpu::TextureFormat::R32Float,
wgpu::TextureFormat::Undefined, // No storageAttachment.
};
std::array<std::string, 3> shaderTypes = {"f32", "i32", "u32"};
for (wgpu::TextureFormat format : testFormats) {
for (const std::string& type : shaderTypes) {
PLSSpec spec = {4, {}};
if (format != wgpu::TextureFormat::Undefined) {
spec = PLSSpec{4, {{0, format}}};
}
std::string shader = R"(
enable chromium_experimental_pixel_local;
struct PLS { a : )" +
type + R"(}
var<pixel_local> pls : PLS;
@fragment fn fs() {
_ = pls;
})";
// List valid combinations to avoid writing the exact same switch statement as in
// ShaderModule.cpp
bool success = (format == wgpu::TextureFormat::R32Uint && type == "u32") ||
(format == wgpu::TextureFormat::R32Sint && type == "i32") ||
(format == wgpu::TextureFormat::R32Float && type == "f32") ||
(format == wgpu::TextureFormat::Undefined && type == "u32");
TestFragmentAndLayoutCompat(spec, shader, success);
}
}
}
// Check that it is allowed to create render passes with only a storage attachment.
TEST_F(PixelLocalStorageTest, RenderPassOnlyStorageAttachment) {
wgpu::TextureDescriptor tDesc;
tDesc.format = wgpu::TextureFormat::R32Uint;
tDesc.size = {1, 1};
tDesc.usage = wgpu::TextureUsage::StorageAttachment;
wgpu::Texture tex = device.CreateTexture(&tDesc);
wgpu::RenderPassStorageAttachment rpAttachment;
rpAttachment.storage = tex.CreateView();
rpAttachment.offset = 0;
rpAttachment.loadOp = wgpu::LoadOp::Load;
rpAttachment.storeOp = wgpu::StoreOp::Store;
wgpu::RenderPassPixelLocalStorage rpPlsDesc;
rpPlsDesc.totalPixelLocalStorageSize = 4;
rpPlsDesc.storageAttachmentCount = 1;
rpPlsDesc.storageAttachments = &rpAttachment;
wgpu::RenderPassDescriptor rpDesc;
rpDesc.nextInChain = &rpPlsDesc;
rpDesc.colorAttachmentCount = 0;
rpDesc.depthStencilAttachment = nullptr;
// Success case: a render pass with just a storage attachment is valid.
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&rpDesc);
pass.End();
encoder.Finish();
}
// Error case: a render pass with PLS but no attachments is invalid.
{
rpPlsDesc.storageAttachmentCount = 0;
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&rpDesc);
pass.End();
ASSERT_DEVICE_ERROR(encoder.Finish());
}
}
// Check that it is allowed to create render pipelines with only a storage attachment.
TEST_F(PixelLocalStorageTest, RenderPipelineOnlyStorageAttachment) {
wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
enable chromium_experimental_pixel_local;
@vertex fn vs() -> @builtin(position) vec4f {
return vec4f(0, 0, 0, 0.5);
}
struct PLS {
value : u32,
};
var<pixel_local> pls : PLS;
@fragment fn fs() {
pls.value = pls.value + 1;
}
)");
wgpu::PipelineLayoutStorageAttachment plAttachment;
plAttachment.offset = 0;
plAttachment.format = wgpu::TextureFormat::R32Uint;
wgpu::PipelineLayoutPixelLocalStorage plPlsDesc;
plPlsDesc.totalPixelLocalStorageSize = 4;
plPlsDesc.storageAttachmentCount = 1;
plPlsDesc.storageAttachments = &plAttachment;
wgpu::PipelineLayoutDescriptor plDesc;
plDesc.nextInChain = &plPlsDesc;
plDesc.bindGroupLayoutCount = 0;
wgpu::PipelineLayout pl = device.CreatePipelineLayout(&plDesc);
utils::ComboRenderPipelineDescriptor pDesc;
pDesc.layout = pl;
pDesc.vertex.module = module;
pDesc.cFragment.module = module;
pDesc.cFragment.targetCount = 0;
// Success case: a render pipeline with just a storage attachment is valid.
device.CreateRenderPipeline(&pDesc);
// Error case: a render pass with PLS but no attachments is invalid.
plPlsDesc.storageAttachmentCount = 0;
pDesc.layout = device.CreatePipelineLayout(&plDesc);
ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&pDesc));
}
// Check that the size of the render pass is correctly deduced when there is only a storage
// attachment. Use the SetViewport validation to check this.
TEST_F(PixelLocalStorageTest, RenderPassSizeDetectionWithOnlyStorageAttachment) {
wgpu::TextureDescriptor tDesc;
tDesc.format = wgpu::TextureFormat::R32Uint;
tDesc.size = {7, 11};
tDesc.usage = wgpu::TextureUsage::StorageAttachment;
wgpu::Texture tex = device.CreateTexture(&tDesc);
wgpu::RenderPassStorageAttachment rpAttachment;
rpAttachment.storage = tex.CreateView();
rpAttachment.offset = 0;
rpAttachment.loadOp = wgpu::LoadOp::Load;
rpAttachment.storeOp = wgpu::StoreOp::Store;
wgpu::RenderPassPixelLocalStorage rpPlsDesc;
rpPlsDesc.totalPixelLocalStorageSize = 4;
rpPlsDesc.storageAttachmentCount = 1;
rpPlsDesc.storageAttachments = &rpAttachment;
wgpu::RenderPassDescriptor rpDesc;
rpDesc.nextInChain = &rpPlsDesc;
rpDesc.colorAttachmentCount = 0;
rpDesc.depthStencilAttachment = nullptr;
// Success case: viewport is exactly the size of the render pass.
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&rpDesc);
pass.SetViewport(0, 0, tDesc.size.width, tDesc.size.height, 0.0, 1.0);
pass.End();
encoder.Finish();
}
// Error case: viewport width is larger than the render pass's.
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&rpDesc);
pass.SetViewport(0, 0, tDesc.size.width + 1, tDesc.size.height, 0.0, 1.0);
pass.End();
ASSERT_DEVICE_ERROR(encoder.Finish());
}
// Error case: viewport width is larger than the render pass's.
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&rpDesc);
pass.SetViewport(0, 0, tDesc.size.width, tDesc.size.height + 1, 0.0, 1.0);
pass.End();
ASSERT_DEVICE_ERROR(encoder.Finish());
}
}
class PixelLocalStorageAndRenderToSingleSampledTest : public PixelLocalStorageTest {
protected:
std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
return {wgpu::FeatureName::PixelLocalStorageNonCoherent,
wgpu::FeatureName::MSAARenderToSingleSampled};
}
};
// Check that PLS + MSAA render to single sampled is not allowed
TEST_F(PixelLocalStorageAndRenderToSingleSampledTest, CombinationIsNotAllowed) {
ComboTestPLSRenderPassDescriptor desc;
InitializePLSRenderPass(&desc);
// Control case: no MSAA render to single sampled.
RecordRenderPass(&desc.rpDesc);
// Error case: MSAA render to single sampled is added to the color attachment.
wgpu::DawnRenderPassColorAttachmentRenderToSingleSampled msaaRenderToSingleSampledDesc;
msaaRenderToSingleSampledDesc.implicitSampleCount = 4;
desc.colorAttachment.nextInChain = &msaaRenderToSingleSampledDesc;
ASSERT_DEVICE_ERROR(RecordRenderPass(&desc.rpDesc));
}
class PixelLocalStorageAndTransientAttachmentTest : public PixelLocalStorageTest {
std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
return {wgpu::FeatureName::PixelLocalStorageNonCoherent,
wgpu::FeatureName::TransientAttachments};
}
};
// Check that a transient + storage attachment is allowed.
TEST_F(PixelLocalStorageAndTransientAttachmentTest, TransientStorageAttachment) {
wgpu::TextureDescriptor desc;
desc.size = {1, 1};
desc.format = wgpu::TextureFormat::R32Uint;
desc.usage = wgpu::TextureUsage::StorageAttachment | wgpu::TextureUsage::TransientAttachment;
device.CreateTexture(&desc);
desc.usage |= wgpu::TextureUsage::RenderAttachment;
device.CreateTexture(&desc);
}
// TODO(dawn:1704): Add tests for limits
// TODO(dawn:1704): Add tests for load/store op validation with transient.
// TODO(dawn:1704): Allow multisampled storage attachments
} // anonymous namespace
} // namespace dawn