blob: b78fb790638d527445b6b76d7f9012f952b25604 [file] [log] [blame]
// Copyright 2020 The Dawn Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// This file contains test for deprecated parts of Dawn's API while following WebGPU's evolution.
// It contains test for the "old" behavior that will be deleted once users are migrated, tests that
// a deprecation warning is emitted when the "old" behavior is used, and tests that an error is
// emitted when both the old and the new behavior are used (when applicable).
#include "tests/DawnTest.h"
#include "common/Constants.h"
#include "common/VertexFormatUtils.h"
#include "utils/ComboRenderPipelineDescriptor.h"
#include "utils/WGPUHelpers.h"
#include <cmath>
class DeprecationTests : public DawnTest {
protected:
void SetUp() override {
DawnTest::SetUp();
// Skip when validation is off because warnings might be emitted during validation calls
DAWN_SKIP_TEST_IF(HasToggleEnabled("skip_validation"));
}
};
// Test that SetIndexBufferWithFormat is deprecated.
TEST_P(DeprecationTests, SetIndexBufferWithFormat) {
wgpu::BufferDescriptor bufferDesc;
bufferDesc.size = 4;
bufferDesc.usage = wgpu::BufferUsage::Index;
wgpu::Buffer indexBuffer = device.CreateBuffer(&bufferDesc);
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1);
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
EXPECT_DEPRECATION_WARNING(
pass.SetIndexBufferWithFormat(indexBuffer, wgpu::IndexFormat::Uint32));
pass.EndPass();
}
// Test that SetBlendColor is deprecated.
TEST_P(DeprecationTests, SetSetBlendColor) {
wgpu::Color blendColor{1.0, 0.0, 0.0, 1.0};
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1);
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
EXPECT_DEPRECATION_WARNING(pass.SetBlendColor(&blendColor));
pass.EndPass();
}
// Test that setting attachment rather than view for render pass color and depth/stencil attachments
// is deprecated.
TEST_P(DeprecationTests, SetAttachmentDescriptorAttachment) {
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1);
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass;
// Check that using .attachment with color attachments gives the warning.
wgpu::RenderPassColorAttachmentDescriptor* colorAttachment =
&renderPass.renderPassInfo.cColorAttachments[0];
colorAttachment->attachment = colorAttachment->view;
colorAttachment->view = nullptr;
EXPECT_DEPRECATION_WARNING(pass = encoder.BeginRenderPass(&renderPass.renderPassInfo));
pass.EndPass();
colorAttachment->view = colorAttachment->attachment;
colorAttachment->attachment = nullptr;
// Check that using .attachment with depth/stencil attachments gives the warning.
wgpu::TextureDescriptor descriptor;
descriptor.dimension = wgpu::TextureDimension::e2D;
descriptor.size = {1, 1, 1};
descriptor.sampleCount = 1;
descriptor.format = wgpu::TextureFormat::Depth24PlusStencil8;
descriptor.mipLevelCount = 1;
descriptor.usage = wgpu::TextureUsage::RenderAttachment;
wgpu::Texture depthStencil = device.CreateTexture(&descriptor);
wgpu::RenderPassDepthStencilAttachmentDescriptor* depthAttachment =
&renderPass.renderPassInfo.cDepthStencilAttachmentInfo;
renderPass.renderPassInfo.depthStencilAttachment = depthAttachment;
depthAttachment->attachment = depthStencil.CreateView();
EXPECT_DEPRECATION_WARNING(pass = encoder.BeginRenderPass(&renderPass.renderPassInfo));
pass.EndPass();
}
// Test that BindGroupLayoutEntry cannot have a type if buffer, sampler, texture, or storageTexture
// are defined.
TEST_P(DeprecationTests, BindGroupLayoutEntryTypeConflict) {
wgpu::BindGroupLayoutEntry binding;
binding.binding = 0;
binding.visibility = wgpu::ShaderStage::Vertex;
wgpu::BindGroupLayoutDescriptor descriptor;
descriptor.entryCount = 1;
descriptor.entries = &binding;
// Succeeds with only a type.
binding.type = wgpu::BindingType::UniformBuffer;
EXPECT_DEPRECATION_WARNING(device.CreateBindGroupLayout(&descriptor));
binding.type = wgpu::BindingType::Undefined;
// Succeeds with only a buffer.type.
binding.buffer.type = wgpu::BufferBindingType::Uniform;
device.CreateBindGroupLayout(&descriptor);
// Fails when both type and a buffer.type are specified.
binding.type = wgpu::BindingType::UniformBuffer;
ASSERT_DEVICE_ERROR(device.CreateBindGroupLayout(&descriptor));
binding.buffer.type = wgpu::BufferBindingType::Undefined;
binding.type = wgpu::BindingType::Undefined;
// Succeeds with only a sampler.type.
binding.sampler.type = wgpu::SamplerBindingType::Filtering;
device.CreateBindGroupLayout(&descriptor);
// Fails when both type and a sampler.type are specified.
binding.type = wgpu::BindingType::Sampler;
ASSERT_DEVICE_ERROR(device.CreateBindGroupLayout(&descriptor));
binding.sampler.type = wgpu::SamplerBindingType::Undefined;
binding.type = wgpu::BindingType::Undefined;
// Succeeds with only a texture.sampleType.
binding.texture.sampleType = wgpu::TextureSampleType::Float;
device.CreateBindGroupLayout(&descriptor);
// Fails when both type and a texture.sampleType are specified.
binding.type = wgpu::BindingType::SampledTexture;
ASSERT_DEVICE_ERROR(device.CreateBindGroupLayout(&descriptor));
binding.texture.sampleType = wgpu::TextureSampleType::Undefined;
binding.type = wgpu::BindingType::Undefined;
// Succeeds with only a storageTexture.access.
binding.storageTexture.access = wgpu::StorageTextureAccess::ReadOnly;
binding.storageTexture.format = wgpu::TextureFormat::RGBA8Unorm;
device.CreateBindGroupLayout(&descriptor);
// Fails when both type and a storageTexture.access are specified.
binding.type = wgpu::BindingType::ReadonlyStorageTexture;
ASSERT_DEVICE_ERROR(device.CreateBindGroupLayout(&descriptor));
}
// Test that the deprecated BGLEntry path correctly handles the defaulting of viewDimension.
// This is a regression test for crbug.com/dawn/620
TEST_P(DeprecationTests, BindGroupLayoutEntryViewDimensionDefaulting) {
wgpu::BindGroupLayoutEntry binding;
binding.binding = 0;
binding.visibility = wgpu::ShaderStage::Vertex;
binding.type = wgpu::BindingType::SampledTexture;
wgpu::BindGroupLayoutDescriptor bglDesc;
bglDesc.entryCount = 1;
bglDesc.entries = &binding;
wgpu::BindGroupLayout bgl;
// Check that the default viewDimension is 2D.
{
binding.viewDimension = wgpu::TextureViewDimension::Undefined;
EXPECT_DEPRECATION_WARNING(bgl = device.CreateBindGroupLayout(&bglDesc));
wgpu::TextureDescriptor desc;
desc.usage = wgpu::TextureUsage::Sampled;
desc.size = {1, 1, 1};
desc.format = wgpu::TextureFormat::RGBA8Unorm;
desc.dimension = wgpu::TextureDimension::e2D;
wgpu::Texture texture = device.CreateTexture(&desc);
// Success, the default is 2D and we give it a 2D view.
utils::MakeBindGroup(device, bgl, {{0, texture.CreateView()}});
}
// Check that setting a non-default viewDimension works.
{
binding.viewDimension = wgpu::TextureViewDimension::e2DArray;
EXPECT_DEPRECATION_WARNING(bgl = device.CreateBindGroupLayout(&bglDesc));
wgpu::TextureDescriptor desc;
desc.usage = wgpu::TextureUsage::Sampled;
desc.size = {1, 1, 4};
desc.format = wgpu::TextureFormat::RGBA8Unorm;
desc.dimension = wgpu::TextureDimension::e2D;
wgpu::Texture texture = device.CreateTexture(&desc);
// Success, the view will be 2DArray and the BGL expects a 2DArray.
utils::MakeBindGroup(device, bgl, {{0, texture.CreateView()}});
}
}
// Test Device::GetDefaultQueue deprecation.
TEST_P(DeprecationTests, GetDefaultQueueDeprecation) {
// Using GetDefaultQueue emits a warning.
wgpu::Queue deprecatedQueue;
EXPECT_DEPRECATION_WARNING(deprecatedQueue = device.GetDefaultQueue());
// Using GetQueue doesn't emit a warning.
wgpu::Queue queue = device.GetQueue();
// Both objects are the same, even with dawn_wire.
EXPECT_EQ(deprecatedQueue.Get(), queue.Get());
}
// Test that fences are deprecated.
TEST_P(DeprecationTests, CreateFence) {
EXPECT_DEPRECATION_WARNING(queue.CreateFence());
}
// Test GPUExtent3D.depth deprecation in TextureDescriptor.size
TEST_P(DeprecationTests, GPUExtent3DDepthDeprecationTextureDescriptor) {
wgpu::TextureDescriptor kBaseDesc;
kBaseDesc.usage = wgpu::TextureUsage::Sampled;
kBaseDesc.size.width = 1;
kBaseDesc.size.height = 1;
kBaseDesc.format = wgpu::TextureFormat::RGBA8Unorm;
kBaseDesc.dimension = wgpu::TextureDimension::e2D;
{
// Valid: default
wgpu::TextureDescriptor desc = kBaseDesc;
wgpu::Texture texture;
texture = device.CreateTexture(&desc);
}
{
// Warning: use deprecated depth but still valid
wgpu::TextureDescriptor desc = kBaseDesc;
desc.mipLevelCount = 2;
desc.size.width = 2;
desc.size.height = 2;
desc.size.depth = 2;
wgpu::Texture texture;
EXPECT_DEPRECATION_WARNING(texture = device.CreateTexture(&desc));
}
{
// Warning: use deprecated depth
// Error: use deprecated depth and the descriptor is invalid
// because 2D texture with depth == 0 is not allowed
// This is to verify the deprecated depth is picked up by the implementation.
wgpu::TextureDescriptor desc = kBaseDesc;
desc.size.depth = 0;
wgpu::Texture texture;
ASSERT_DEVICE_ERROR(EXPECT_DEPRECATION_WARNING(texture = device.CreateTexture(&desc)));
}
{
// Error: use both deprecated depth and depthOrArrayLayers
wgpu::TextureDescriptor desc = kBaseDesc;
desc.size.depth = 2;
desc.size.depthOrArrayLayers = 2;
wgpu::Texture texture;
ASSERT_DEVICE_ERROR(texture = device.CreateTexture(&desc));
}
{
// Valid: use updated depthOrArrayLayers
wgpu::TextureDescriptor desc = kBaseDesc;
desc.mipLevelCount = 2;
desc.size.width = 2;
desc.size.height = 2;
desc.size.depthOrArrayLayers = 2;
wgpu::Texture texture;
texture = device.CreateTexture(&desc);
}
{
// Error: use updated depthOrArrayLayers and the descriptor is invalid
// because 2D texture with depthOrArrayLayers == 0 is not allowed
wgpu::TextureDescriptor desc = kBaseDesc;
desc.size.depthOrArrayLayers = 0;
wgpu::Texture texture;
ASSERT_DEVICE_ERROR(texture = device.CreateTexture(&desc));
}
}
// Test GPUExtent3D.depth deprecation in CopyBufferToTexture, CopyTextureToBuffer, and
// CopyTextureToTexture
TEST_P(DeprecationTests, GPUExtent3DDepthDeprecationCopy) {
wgpu::BufferDescriptor bufferDesc;
bufferDesc.size = 4 * 256;
bufferDesc.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
wgpu::Buffer srcBuffer = device.CreateBuffer(&bufferDesc);
wgpu::TextureDescriptor dstTextureDesc;
dstTextureDesc.usage = wgpu::TextureUsage::CopyDst;
dstTextureDesc.size.width = 4;
dstTextureDesc.size.height = 4;
dstTextureDesc.size.depthOrArrayLayers = 1;
dstTextureDesc.format = wgpu::TextureFormat::RGBA8Unorm;
dstTextureDesc.dimension = wgpu::TextureDimension::e2D;
wgpu::Texture dstTexture = device.CreateTexture(&dstTextureDesc);
wgpu::TextureDescriptor srcTextureDesc = dstTextureDesc;
srcTextureDesc.usage = wgpu::TextureUsage::CopySrc;
wgpu::Texture srcTexture = device.CreateTexture(&srcTextureDesc);
wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(srcBuffer, 0, 256, 4);
wgpu::ImageCopyTexture imageCopyDstTexture =
utils::CreateImageCopyTexture(dstTexture, 0, {0, 0, 0}, wgpu::TextureAspect::All);
wgpu::ImageCopyTexture imageCopySrcTexture =
utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::All);
wgpu::Extent3D kBaseExtent3D;
kBaseExtent3D.width = 4;
kBaseExtent3D.height = 4;
{
// Valid: default
wgpu::Extent3D extent3D = kBaseExtent3D;
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyDstTexture, &extent3D);
encoder.CopyTextureToBuffer(&imageCopySrcTexture, &imageCopyBuffer, &extent3D);
encoder.CopyTextureToTexture(&imageCopySrcTexture, &imageCopyDstTexture, &extent3D);
encoder.Finish();
}
{
// Warning: empty copy use deprecated depth == 0 but still valid
wgpu::Extent3D extent3D = kBaseExtent3D;
extent3D.width = 0;
extent3D.height = 0;
extent3D.depth = 0;
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
EXPECT_DEPRECATION_WARNING(
encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyDstTexture, &extent3D));
EXPECT_DEPRECATION_WARNING(
encoder.CopyTextureToBuffer(&imageCopySrcTexture, &imageCopyBuffer, &extent3D));
EXPECT_DEPRECATION_WARNING(
encoder.CopyTextureToTexture(&imageCopySrcTexture, &imageCopyDstTexture, &extent3D));
encoder.Finish();
}
{
// Warning: use deprecated depth
// Error: depth > 1
// This is to verify the deprecated depth is picked up by the implementation.
wgpu::Extent3D extent3D = kBaseExtent3D;
extent3D.depth = 2;
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
EXPECT_DEPRECATION_WARNING(
encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyDstTexture, &extent3D));
ASSERT_DEVICE_ERROR(encoder.Finish());
}
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
EXPECT_DEPRECATION_WARNING(
encoder.CopyTextureToBuffer(&imageCopySrcTexture, &imageCopyBuffer, &extent3D));
ASSERT_DEVICE_ERROR(encoder.Finish());
}
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
EXPECT_DEPRECATION_WARNING(encoder.CopyTextureToTexture(
&imageCopySrcTexture, &imageCopyDstTexture, &extent3D));
ASSERT_DEVICE_ERROR(encoder.Finish());
}
}
{
// Error: use both deprecated depth and depthOrArrayLayers
wgpu::Extent3D extent3D = kBaseExtent3D;
extent3D.width = 0;
extent3D.height = 0;
extent3D.depth = 0;
extent3D.depthOrArrayLayers = 0;
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyDstTexture, &extent3D);
ASSERT_DEVICE_ERROR(encoder.Finish());
}
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
encoder.CopyTextureToBuffer(&imageCopySrcTexture, &imageCopyBuffer, &extent3D);
ASSERT_DEVICE_ERROR(encoder.Finish());
}
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
encoder.CopyTextureToTexture(&imageCopySrcTexture, &imageCopyDstTexture, &extent3D);
ASSERT_DEVICE_ERROR(encoder.Finish());
}
}
{
// Valid: use updated depthOrArrayLayers
wgpu::Extent3D extent3D = kBaseExtent3D;
extent3D.width = 0;
extent3D.height = 0;
extent3D.depthOrArrayLayers = 0;
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyDstTexture, &extent3D);
encoder.CopyTextureToBuffer(&imageCopySrcTexture, &imageCopyBuffer, &extent3D);
encoder.CopyTextureToTexture(&imageCopySrcTexture, &imageCopyDstTexture, &extent3D);
encoder.Finish();
}
{
// Error: use updated depthOrArrayLayers and is invalid
wgpu::Extent3D extent3D = kBaseExtent3D;
extent3D.depthOrArrayLayers = 2;
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyDstTexture, &extent3D);
ASSERT_DEVICE_ERROR(encoder.Finish());
}
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
encoder.CopyTextureToBuffer(&imageCopySrcTexture, &imageCopyBuffer, &extent3D);
ASSERT_DEVICE_ERROR(encoder.Finish());
}
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
encoder.CopyTextureToTexture(&imageCopySrcTexture, &imageCopyDstTexture, &extent3D);
ASSERT_DEVICE_ERROR(encoder.Finish());
}
}
}
// Test GPUExtent3D.depth deprecation in WriteTexture
TEST_P(DeprecationTests, GPUExtent3DDepthDeprecationWriteTexture) {
wgpu::TextureDescriptor dstTextureDesc;
dstTextureDesc.usage = wgpu::TextureUsage::CopyDst;
dstTextureDesc.size.width = 4;
dstTextureDesc.size.height = 4;
dstTextureDesc.size.depthOrArrayLayers = 1;
dstTextureDesc.format = wgpu::TextureFormat::RGBA8Unorm;
dstTextureDesc.dimension = wgpu::TextureDimension::e2D;
wgpu::Texture dstTexture = device.CreateTexture(&dstTextureDesc);
size_t dataSize = 4 * 256;
std::vector<uint8_t> data(dataSize);
wgpu::TextureDataLayout textureDataLayout;
textureDataLayout.offset = 0;
textureDataLayout.bytesPerRow = 256;
textureDataLayout.rowsPerImage = 4;
wgpu::ImageCopyTexture imageCopyDstTexture =
utils::CreateImageCopyTexture(dstTexture, 0, {0, 0, 0}, wgpu::TextureAspect::All);
wgpu::Extent3D kBaseExtent3D;
kBaseExtent3D.width = 4;
kBaseExtent3D.height = 4;
{
// Valid: default
wgpu::Extent3D extent3D = kBaseExtent3D;
wgpu::Queue queue = device.GetQueue();
queue.WriteTexture(&imageCopyDstTexture, data.data(), dataSize, &textureDataLayout,
&extent3D);
}
{
// Warning: use deprecated depth == 0 but still valid
wgpu::Extent3D extent3D = kBaseExtent3D;
extent3D.width = 0;
extent3D.height = 0;
extent3D.depth = 0;
wgpu::Queue queue = device.GetQueue();
EXPECT_DEPRECATION_WARNING(queue.WriteTexture(&imageCopyDstTexture, data.data(), dataSize,
&textureDataLayout, &extent3D));
}
{
// Warning: use deprecated depth
// Error: depth > 1 for 2D textures
// This is to verify the deprecated depth is picked up by the implementation.
wgpu::Extent3D extent3D = kBaseExtent3D;
extent3D.depth = 2;
wgpu::Queue queue = device.GetQueue();
ASSERT_DEVICE_ERROR(EXPECT_DEPRECATION_WARNING(queue.WriteTexture(
&imageCopyDstTexture, data.data(), dataSize, &textureDataLayout, &extent3D)));
}
{
// Error: use both deprecated depth and depthOrArrayLayers
wgpu::Extent3D extent3D = kBaseExtent3D;
extent3D.width = 0;
extent3D.height = 0;
extent3D.depth = 0;
extent3D.depthOrArrayLayers = 0;
wgpu::Queue queue = device.GetQueue();
ASSERT_DEVICE_ERROR(queue.WriteTexture(&imageCopyDstTexture, data.data(), dataSize,
&textureDataLayout, &extent3D));
}
{
// Valid: use updated depthOrArrayLayers
wgpu::Extent3D extent3D = kBaseExtent3D;
extent3D.width = 0;
extent3D.height = 0;
extent3D.depthOrArrayLayers = 0;
wgpu::Queue queue = device.GetQueue();
queue.WriteTexture(&imageCopyDstTexture, data.data(), dataSize, &textureDataLayout,
&extent3D);
}
{
// Error: use updated depthOrArrayLayers and depthOrArrayLayers > 1 for 2D textures
wgpu::Extent3D extent3D = kBaseExtent3D;
extent3D.depthOrArrayLayers = 2;
wgpu::Queue queue = device.GetQueue();
ASSERT_DEVICE_ERROR(queue.WriteTexture(&imageCopyDstTexture, data.data(), dataSize,
&textureDataLayout, &extent3D));
}
}
DAWN_INSTANTIATE_TEST(DeprecationTests,
D3D12Backend(),
MetalBackend(),
NullBackend(),
OpenGLBackend(),
OpenGLESBackend(),
VulkanBackend());
class ImageCopyBufferDeprecationTests : public DeprecationTests {
protected:
wgpu::ImageCopyTexture MakeImageCopyTexture() {
wgpu::TextureDescriptor desc = {};
desc.usage = wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::CopyDst;
desc.dimension = wgpu::TextureDimension::e2D;
desc.size = {1, 1, 2};
desc.format = wgpu::TextureFormat::RGBA8Unorm;
wgpu::ImageCopyTexture copy;
copy.texture = device.CreateTexture(&desc);
copy.origin = {0, 0, 1};
return copy;
}
wgpu::Extent3D copySize = {1, 1, 1};
};
// Tests that deprecated vertex formats properly raise a deprecation warning when used
class VertexFormatDeprecationTests : public DeprecationTests {
protected:
// Runs the test
void DoTest(const wgpu::VertexFormat vertexFormat, bool deprecated) {
std::string attribute = "[[location(0)]] var<in> a : ";
attribute += dawn::GetWGSLVertexFormatType(vertexFormat);
attribute += ";";
std::string attribAccess = dawn::VertexFormatNumComponents(vertexFormat) > 1
? "vec4<f32>(f32(a.x), 0.0, 0.0, 1.0)"
: "vec4<f32>(f32(a), 0.0, 0.0, 1.0)";
wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, (attribute + R"(
[[stage(vertex)]] fn main() -> [[builtin(position)]] vec4<f32> {
return )" + attribAccess + R"(;
}
)")
.c_str());
wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> {
return vec4<f32>(1.0, 1.0, 1.0, 1.0);
}
)");
utils::ComboRenderPipelineDescriptor2 descriptor;
descriptor.vertex.module = vsModule;
descriptor.cFragment.module = fsModule;
descriptor.primitive.topology = wgpu::PrimitiveTopology::PointList;
descriptor.vertex.bufferCount = 1;
descriptor.cBuffers[0].arrayStride = 32;
descriptor.cBuffers[0].attributeCount = 1;
descriptor.cAttributes[0].format = vertexFormat;
descriptor.cAttributes[0].offset = 0;
descriptor.cAttributes[0].shaderLocation = 0;
descriptor.cTargets[0].format = utils::BasicRenderPass::kDefaultColorFormat;
if (deprecated) {
EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline2(&descriptor));
} else {
device.CreateRenderPipeline2(&descriptor);
}
}
};
TEST_P(VertexFormatDeprecationTests, NewVertexFormats) {
// Using the new vertex formats does not emit a warning.
for (auto& format : dawn::kAllVertexFormats) {
DoTest(format, false);
}
}
TEST_P(VertexFormatDeprecationTests, DeprecatedVertexFormats) {
// Using deprecated vertex formats does emit a warning.
for (auto& format : dawn::kAllDeprecatedVertexFormats) {
DoTest(format, true);
}
}
DAWN_INSTANTIATE_TEST(VertexFormatDeprecationTests,
D3D12Backend(),
MetalBackend(),
NullBackend(),
OpenGLBackend(),
OpenGLESBackend(),
VulkanBackend());
// Tests that deprecated blend factors properly raise a deprecation warning when used
class BlendFactorDeprecationTests : public DeprecationTests {
protected:
// Runs the test
void DoTest(const wgpu::BlendFactor blendFactor, bool deprecated) {
wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[stage(vertex)]] fn main() -> [[builtin(position)]] vec4<f32> {
return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}
)");
wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> {
return vec4<f32>(1.0, 1.0, 1.0, 1.0);
}
)");
utils::ComboRenderPipelineDescriptor2 descriptor;
descriptor.vertex.module = vsModule;
descriptor.cFragment.module = fsModule;
descriptor.cTargets[0].blend = &descriptor.cBlends[0];
descriptor.cBlends[0].color.srcFactor = blendFactor;
if (deprecated) {
EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline2(&descriptor));
} else {
device.CreateRenderPipeline2(&descriptor);
}
descriptor.cBlends[0].color.srcFactor = wgpu::BlendFactor::One;
descriptor.cBlends[0].color.dstFactor = blendFactor;
if (deprecated) {
EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline2(&descriptor));
} else {
device.CreateRenderPipeline2(&descriptor);
}
descriptor.cBlends[0].color.dstFactor = wgpu::BlendFactor::Zero;
descriptor.cBlends[0].alpha.srcFactor = blendFactor;
if (deprecated) {
EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline2(&descriptor));
} else {
device.CreateRenderPipeline2(&descriptor);
}
descriptor.cBlends[0].alpha.srcFactor = wgpu::BlendFactor::One;
descriptor.cBlends[0].alpha.dstFactor = blendFactor;
if (deprecated) {
EXPECT_DEPRECATION_WARNING(device.CreateRenderPipeline2(&descriptor));
} else {
device.CreateRenderPipeline2(&descriptor);
}
descriptor.cBlends[0].alpha.dstFactor = wgpu::BlendFactor::Zero;
}
};
static constexpr std::array<wgpu::BlendFactor, 13> kBlendFactors = {
wgpu::BlendFactor::Zero,
wgpu::BlendFactor::One,
wgpu::BlendFactor::Src,
wgpu::BlendFactor::OneMinusSrc,
wgpu::BlendFactor::SrcAlpha,
wgpu::BlendFactor::OneMinusSrcAlpha,
wgpu::BlendFactor::Dst,
wgpu::BlendFactor::OneMinusDst,
wgpu::BlendFactor::DstAlpha,
wgpu::BlendFactor::OneMinusDstAlpha,
wgpu::BlendFactor::SrcAlphaSaturated,
wgpu::BlendFactor::Constant,
wgpu::BlendFactor::OneMinusConstant,
};
TEST_P(BlendFactorDeprecationTests, CurrentBlendFactors) {
// Using the new blend factors does not emit a warning.
for (auto& format : kBlendFactors) {
DoTest(format, false);
}
}
static constexpr std::array<wgpu::BlendFactor, 6> kDeprecatedBlendFactors = {
wgpu::BlendFactor::SrcColor, wgpu::BlendFactor::OneMinusSrcColor,
wgpu::BlendFactor::DstColor, wgpu::BlendFactor::OneMinusDstColor,
wgpu::BlendFactor::BlendColor, wgpu::BlendFactor::OneMinusBlendColor,
};
TEST_P(BlendFactorDeprecationTests, DeprecatedBlendFactors) {
// Using deprecated blend factors does emit a warning.
for (auto& format : kDeprecatedBlendFactors) {
DoTest(format, true);
}
}
DAWN_INSTANTIATE_TEST(BlendFactorDeprecationTests,
D3D12Backend(),
MetalBackend(),
NullBackend(),
OpenGLBackend(),
OpenGLESBackend(),
VulkanBackend());