| // Copyright 2019 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. |
| |
| #include "tests/DawnTest.h" |
| |
| #include "common/Assert.h" |
| #include "utils/ComboRenderPipelineDescriptor.h" |
| #include "utils/WGPUHelpers.h" |
| |
| class MultisampledRenderingTest : public DawnTest { |
| protected: |
| void SetUp() override { |
| DawnTest::SetUp(); |
| |
| InitTexturesForTest(); |
| } |
| |
| void InitTexturesForTest() { |
| mMultisampledColorTexture = CreateTextureForOutputAttachment(kColorFormat, kSampleCount); |
| mMultisampledColorView = mMultisampledColorTexture.CreateView(); |
| mResolveTexture = CreateTextureForOutputAttachment(kColorFormat, 1); |
| mResolveView = mResolveTexture.CreateView(); |
| |
| mDepthStencilTexture = CreateTextureForOutputAttachment(kDepthStencilFormat, kSampleCount); |
| mDepthStencilView = mDepthStencilTexture.CreateView(); |
| } |
| |
| wgpu::RenderPipeline CreateRenderPipelineWithOneOutputForTest(bool testDepth) { |
| const char* kFsOneOutputWithDepth = |
| R"(#version 450 |
| layout(location = 0) out vec4 fragColor; |
| layout (std140, set = 0, binding = 0) uniform uBuffer { |
| vec4 color; |
| float depth; |
| }; |
| void main() { |
| fragColor = color; |
| gl_FragDepth = depth; |
| })"; |
| |
| const char* kFsOneOutputWithoutDepth = |
| R"(#version 450 |
| layout(location = 0) out vec4 fragColor; |
| layout (std140, set = 0, binding = 0) uniform uBuffer { |
| vec4 color; |
| }; |
| void main() { |
| fragColor = color; |
| })"; |
| |
| const char* fs = testDepth ? kFsOneOutputWithDepth : kFsOneOutputWithoutDepth; |
| |
| |
| return CreateRenderPipelineForTest(fs, 1, testDepth); |
| } |
| |
| wgpu::RenderPipeline CreateRenderPipelineWithTwoOutputsForTest() { |
| const char* kFsTwoOutputs = |
| R"(#version 450 |
| layout(location = 0) out vec4 fragColor1; |
| layout(location = 1) out vec4 fragColor2; |
| layout (std140, set = 0, binding = 0) uniform uBuffer { |
| vec4 color1; |
| vec4 color2; |
| }; |
| void main() { |
| fragColor1 = color1; |
| fragColor2 = color2; |
| })"; |
| |
| return CreateRenderPipelineForTest(kFsTwoOutputs, 2, false); |
| } |
| |
| wgpu::Texture CreateTextureForOutputAttachment(wgpu::TextureFormat format, |
| uint32_t sampleCount, |
| uint32_t mipLevelCount = 1, |
| uint32_t arrayLayerCount = 1) { |
| wgpu::TextureDescriptor descriptor; |
| descriptor.dimension = wgpu::TextureDimension::e2D; |
| descriptor.size.width = kWidth << (mipLevelCount - 1); |
| descriptor.size.height = kHeight << (mipLevelCount - 1); |
| descriptor.size.depth = arrayLayerCount; |
| descriptor.sampleCount = sampleCount; |
| descriptor.format = format; |
| descriptor.mipLevelCount = mipLevelCount; |
| descriptor.usage = wgpu::TextureUsage::OutputAttachment | wgpu::TextureUsage::CopySrc; |
| return device.CreateTexture(&descriptor); |
| } |
| |
| void EncodeRenderPassForTest(wgpu::CommandEncoder commandEncoder, |
| const wgpu::RenderPassDescriptor& renderPass, |
| const wgpu::RenderPipeline& pipeline, |
| const float* uniformData, |
| uint32_t uniformDataSize) { |
| wgpu::Buffer uniformBuffer = utils::CreateBufferFromData( |
| device, uniformData, uniformDataSize, wgpu::BufferUsage::Uniform); |
| wgpu::BindGroup bindGroup = utils::MakeBindGroup(device, pipeline.GetBindGroupLayout(0), |
| {{0, uniformBuffer, 0, uniformDataSize}}); |
| |
| wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPass); |
| renderPassEncoder.SetPipeline(pipeline); |
| renderPassEncoder.SetBindGroup(0, bindGroup); |
| renderPassEncoder.Draw(3); |
| renderPassEncoder.EndPass(); |
| } |
| |
| utils::ComboRenderPassDescriptor CreateComboRenderPassDescriptorForTest( |
| std::initializer_list<wgpu::TextureView> colorViews, |
| std::initializer_list<wgpu::TextureView> resolveTargetViews, |
| wgpu::LoadOp colorLoadOp, |
| wgpu::LoadOp depthStencilLoadOp, |
| bool hasDepthStencilAttachment) { |
| ASSERT(colorViews.size() == resolveTargetViews.size()); |
| |
| constexpr wgpu::Color kClearColor = {0.0f, 0.0f, 0.0f, 0.0f}; |
| constexpr float kClearDepth = 1.0f; |
| |
| utils::ComboRenderPassDescriptor renderPass(colorViews); |
| uint32_t i = 0; |
| for (const wgpu::TextureView& resolveTargetView : resolveTargetViews) { |
| renderPass.cColorAttachments[i].loadOp = colorLoadOp; |
| renderPass.cColorAttachments[i].clearColor = kClearColor; |
| renderPass.cColorAttachments[i].resolveTarget = resolveTargetView; |
| ++i; |
| } |
| |
| renderPass.cDepthStencilAttachmentInfo.clearDepth = kClearDepth; |
| renderPass.cDepthStencilAttachmentInfo.depthLoadOp = depthStencilLoadOp; |
| |
| if (hasDepthStencilAttachment) { |
| renderPass.cDepthStencilAttachmentInfo.attachment = mDepthStencilView; |
| renderPass.depthStencilAttachment = &renderPass.cDepthStencilAttachmentInfo; |
| } |
| |
| return renderPass; |
| } |
| |
| void VerifyResolveTarget(const wgpu::Color& inputColor, |
| wgpu::Texture resolveTexture, |
| uint32_t mipmapLevel = 0, |
| uint32_t arrayLayer = 0) { |
| constexpr float kMSAACoverage = 0.5f; |
| |
| // In this test we only check the pixel in the middle of the texture. |
| constexpr uint32_t kMiddleX = (kWidth - 1) / 2; |
| constexpr uint32_t kMiddleY = (kHeight - 1) / 2; |
| |
| RGBA8 expectedColor; |
| expectedColor.r = static_cast<uint8_t>(0xFF * inputColor.r * kMSAACoverage); |
| expectedColor.g = static_cast<uint8_t>(0xFF * inputColor.g * kMSAACoverage); |
| expectedColor.b = static_cast<uint8_t>(0xFF * inputColor.b * kMSAACoverage); |
| expectedColor.a = static_cast<uint8_t>(0xFF * inputColor.a * kMSAACoverage); |
| |
| EXPECT_TEXTURE_RGBA8_EQ(&expectedColor, resolveTexture, kMiddleX, kMiddleY, 1, 1, |
| mipmapLevel, arrayLayer); |
| } |
| |
| constexpr static uint32_t kWidth = 3; |
| constexpr static uint32_t kHeight = 3; |
| constexpr static uint32_t kSampleCount = 4; |
| constexpr static wgpu::TextureFormat kColorFormat = wgpu::TextureFormat::RGBA8Unorm; |
| constexpr static wgpu::TextureFormat kDepthStencilFormat = |
| wgpu::TextureFormat::Depth24PlusStencil8; |
| |
| wgpu::Texture mMultisampledColorTexture; |
| wgpu::TextureView mMultisampledColorView; |
| wgpu::Texture mResolveTexture; |
| wgpu::TextureView mResolveView; |
| wgpu::Texture mDepthStencilTexture; |
| wgpu::TextureView mDepthStencilView; |
| |
| private: |
| wgpu::RenderPipeline CreateRenderPipelineForTest(const char* fs, |
| uint32_t numColorAttachments, |
| bool hasDepthStencilAttachment) { |
| utils::ComboRenderPipelineDescriptor pipelineDescriptor(device); |
| |
| // Draw a bottom-right triangle. In standard 4xMSAA pattern, for the pixels on diagonal, |
| // only two of the samples will be touched. |
| const char* vs = |
| R"(#version 450 |
| const vec2 pos[3] = vec2[3](vec2(-1.f, 1.f), vec2(1.f, 1.f), vec2(1.f, -1.f)); |
| void main() { |
| gl_Position = vec4(pos[gl_VertexIndex], 0.0, 1.0); |
| })"; |
| pipelineDescriptor.vertexStage.module = |
| utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, vs); |
| |
| pipelineDescriptor.cFragmentStage.module = |
| utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, fs); |
| |
| if (hasDepthStencilAttachment) { |
| pipelineDescriptor.cDepthStencilState.format = kDepthStencilFormat; |
| pipelineDescriptor.cDepthStencilState.depthWriteEnabled = true; |
| pipelineDescriptor.cDepthStencilState.depthCompare = wgpu::CompareFunction::Less; |
| pipelineDescriptor.depthStencilState = &pipelineDescriptor.cDepthStencilState; |
| } |
| |
| pipelineDescriptor.sampleCount = kSampleCount; |
| |
| pipelineDescriptor.colorStateCount = numColorAttachments; |
| for (uint32_t i = 0; i < numColorAttachments; ++i) { |
| pipelineDescriptor.cColorStates[i].format = kColorFormat; |
| } |
| |
| wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&pipelineDescriptor); |
| return pipeline; |
| } |
| }; |
| |
| // Test using one multisampled color attachment with resolve target can render correctly. |
| TEST_P(MultisampledRenderingTest, ResolveInto2DTexture) { |
| constexpr bool kTestDepth = false; |
| wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); |
| wgpu::RenderPipeline pipeline = CreateRenderPipelineWithOneOutputForTest(kTestDepth); |
| |
| constexpr wgpu::Color kGreen = {0.0f, 0.8f, 0.0f, 0.8f}; |
| constexpr uint32_t kSize = sizeof(kGreen); |
| |
| // Draw a green triangle. |
| { |
| utils::ComboRenderPassDescriptor renderPass = CreateComboRenderPassDescriptorForTest( |
| {mMultisampledColorView}, {mResolveView}, wgpu::LoadOp::Clear, wgpu::LoadOp::Clear, |
| kTestDepth); |
| |
| EncodeRenderPassForTest(commandEncoder, renderPass, pipeline, &kGreen.r, kSize); |
| } |
| |
| wgpu::CommandBuffer commandBuffer = commandEncoder.Finish(); |
| queue.Submit(1, &commandBuffer); |
| |
| VerifyResolveTarget(kGreen, mResolveTexture); |
| } |
| |
| // Test that a single-layer multisampled texture view can be created and resolved from. |
| TEST_P(MultisampledRenderingTest, ResolveFromSingleLayerArrayInto2DTexture) { |
| constexpr bool kTestDepth = false; |
| wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); |
| wgpu::RenderPipeline pipeline = CreateRenderPipelineWithOneOutputForTest(kTestDepth); |
| |
| constexpr wgpu::Color kGreen = {0.0f, 0.8f, 0.0f, 0.8f}; |
| constexpr uint32_t kSize = sizeof(kGreen); |
| |
| // Draw a green triangle. |
| { |
| wgpu::TextureViewDescriptor desc = {}; |
| desc.dimension = wgpu::TextureViewDimension::e2DArray; |
| desc.arrayLayerCount = 1; |
| |
| utils::ComboRenderPassDescriptor renderPass = CreateComboRenderPassDescriptorForTest( |
| {mMultisampledColorTexture.CreateView(&desc)}, {mResolveView}, wgpu::LoadOp::Clear, |
| wgpu::LoadOp::Clear, kTestDepth); |
| |
| EncodeRenderPassForTest(commandEncoder, renderPass, pipeline, &kGreen.r, kSize); |
| } |
| |
| wgpu::CommandBuffer commandBuffer = commandEncoder.Finish(); |
| queue.Submit(1, &commandBuffer); |
| |
| VerifyResolveTarget(kGreen, mResolveTexture); |
| } |
| |
| // Test multisampled rendering with depth test works correctly. |
| TEST_P(MultisampledRenderingTest, MultisampledRenderingWithDepthTest) { |
| constexpr bool kTestDepth = true; |
| wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); |
| wgpu::RenderPipeline pipeline = CreateRenderPipelineWithOneOutputForTest(kTestDepth); |
| |
| constexpr wgpu::Color kGreen = {0.0f, 0.8f, 0.0f, 0.8f}; |
| constexpr wgpu::Color kRed = {0.8f, 0.0f, 0.0f, 0.8f}; |
| |
| // In first render pass we draw a green triangle with depth value == 0.2f. |
| { |
| utils::ComboRenderPassDescriptor renderPass = |
| CreateComboRenderPassDescriptorForTest({mMultisampledColorView}, {mResolveView}, |
| wgpu::LoadOp::Clear, wgpu::LoadOp::Clear, true); |
| std::array<float, 5> kUniformData = {kGreen.r, kGreen.g, kGreen.b, kGreen.a, // Color |
| 0.2f}; // depth |
| constexpr uint32_t kSize = sizeof(kUniformData); |
| EncodeRenderPassForTest(commandEncoder, renderPass, pipeline, kUniformData.data(), kSize); |
| } |
| |
| // In second render pass we draw a red triangle with depth value == 0.5f. |
| // This red triangle should not be displayed because it is behind the green one that is drawn in |
| // the last render pass. |
| { |
| utils::ComboRenderPassDescriptor renderPass = CreateComboRenderPassDescriptorForTest( |
| {mMultisampledColorView}, {mResolveView}, wgpu::LoadOp::Load, wgpu::LoadOp::Load, |
| kTestDepth); |
| |
| std::array<float, 8> kUniformData = {kRed.r, kRed.g, kRed.b, kRed.a, // color |
| 0.5f}; // depth |
| constexpr uint32_t kSize = sizeof(kUniformData); |
| EncodeRenderPassForTest(commandEncoder, renderPass, pipeline, kUniformData.data(), kSize); |
| } |
| |
| wgpu::CommandBuffer commandBuffer = commandEncoder.Finish(); |
| queue.Submit(1, &commandBuffer); |
| |
| // The color of the pixel in the middle of mResolveTexture should be green if MSAA resolve runs |
| // correctly with depth test. |
| VerifyResolveTarget(kGreen, mResolveTexture); |
| } |
| |
| // Test rendering into a multisampled color attachment and doing MSAA resolve in another render pass |
| // works correctly. |
| TEST_P(MultisampledRenderingTest, ResolveInAnotherRenderPass) { |
| constexpr bool kTestDepth = false; |
| wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); |
| wgpu::RenderPipeline pipeline = CreateRenderPipelineWithOneOutputForTest(kTestDepth); |
| |
| constexpr wgpu::Color kGreen = {0.0f, 0.8f, 0.0f, 0.8f}; |
| constexpr uint32_t kSize = sizeof(kGreen); |
| |
| // In first render pass we draw a green triangle and do not set the resolve target. |
| { |
| utils::ComboRenderPassDescriptor renderPass = CreateComboRenderPassDescriptorForTest( |
| {mMultisampledColorView}, {nullptr}, wgpu::LoadOp::Clear, wgpu::LoadOp::Clear, |
| kTestDepth); |
| |
| EncodeRenderPassForTest(commandEncoder, renderPass, pipeline, &kGreen.r, kSize); |
| } |
| |
| // In second render pass we ony do MSAA resolve with no draw call. |
| { |
| utils::ComboRenderPassDescriptor renderPass = CreateComboRenderPassDescriptorForTest( |
| {mMultisampledColorView}, {mResolveView}, wgpu::LoadOp::Load, wgpu::LoadOp::Load, |
| kTestDepth); |
| |
| wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPass); |
| renderPassEncoder.EndPass(); |
| } |
| |
| wgpu::CommandBuffer commandBuffer = commandEncoder.Finish(); |
| queue.Submit(1, &commandBuffer); |
| |
| VerifyResolveTarget(kGreen, mResolveTexture); |
| } |
| |
| // Test doing MSAA resolve into multiple resolve targets works correctly. |
| TEST_P(MultisampledRenderingTest, ResolveIntoMultipleResolveTargets) { |
| wgpu::TextureView multisampledColorView2 = |
| CreateTextureForOutputAttachment(kColorFormat, kSampleCount).CreateView(); |
| wgpu::Texture resolveTexture2 = CreateTextureForOutputAttachment(kColorFormat, 1); |
| wgpu::TextureView resolveView2 = resolveTexture2.CreateView(); |
| |
| wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); |
| wgpu::RenderPipeline pipeline = CreateRenderPipelineWithTwoOutputsForTest(); |
| |
| constexpr wgpu::Color kGreen = {0.0f, 0.8f, 0.0f, 0.8f}; |
| constexpr wgpu::Color kRed = {0.8f, 0.0f, 0.0f, 0.8f}; |
| constexpr bool kTestDepth = false; |
| |
| // Draw a red triangle to the first color attachment, and a blue triangle to the second color |
| // attachment, and do MSAA resolve on two render targets in one render pass. |
| { |
| utils::ComboRenderPassDescriptor renderPass = CreateComboRenderPassDescriptorForTest( |
| {mMultisampledColorView, multisampledColorView2}, {mResolveView, resolveView2}, |
| wgpu::LoadOp::Clear, wgpu::LoadOp::Clear, kTestDepth); |
| |
| std::array<float, 8> kUniformData = {kRed.r, kRed.g, kRed.b, kRed.a, // color1 |
| kGreen.r, kGreen.g, kGreen.b, kGreen.a}; // color2 |
| constexpr uint32_t kSize = sizeof(kUniformData); |
| EncodeRenderPassForTest(commandEncoder, renderPass, pipeline, kUniformData.data(), kSize); |
| } |
| |
| wgpu::CommandBuffer commandBuffer = commandEncoder.Finish(); |
| queue.Submit(1, &commandBuffer); |
| |
| VerifyResolveTarget(kRed, mResolveTexture); |
| VerifyResolveTarget(kGreen, resolveTexture2); |
| } |
| |
| // Test doing MSAA resolve on one multisampled texture twice works correctly. |
| TEST_P(MultisampledRenderingTest, ResolveOneMultisampledTextureTwice) { |
| constexpr bool kTestDepth = false; |
| wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); |
| wgpu::RenderPipeline pipeline = CreateRenderPipelineWithOneOutputForTest(kTestDepth); |
| |
| constexpr wgpu::Color kGreen = {0.0f, 0.8f, 0.0f, 0.8f}; |
| constexpr uint32_t kSize = sizeof(kGreen); |
| |
| wgpu::Texture resolveTexture2 = CreateTextureForOutputAttachment(kColorFormat, 1); |
| |
| // In first render pass we draw a green triangle and specify mResolveView as the resolve target. |
| { |
| utils::ComboRenderPassDescriptor renderPass = CreateComboRenderPassDescriptorForTest( |
| {mMultisampledColorView}, {mResolveView}, wgpu::LoadOp::Clear, wgpu::LoadOp::Clear, |
| kTestDepth); |
| |
| EncodeRenderPassForTest(commandEncoder, renderPass, pipeline, &kGreen.r, kSize); |
| } |
| |
| // In second render pass we do MSAA resolve into resolveTexture2. |
| { |
| wgpu::TextureView resolveView2 = resolveTexture2.CreateView(); |
| utils::ComboRenderPassDescriptor renderPass = CreateComboRenderPassDescriptorForTest( |
| {mMultisampledColorView}, {resolveView2}, wgpu::LoadOp::Load, wgpu::LoadOp::Load, |
| kTestDepth); |
| |
| wgpu::RenderPassEncoder renderPassEncoder = commandEncoder.BeginRenderPass(&renderPass); |
| renderPassEncoder.EndPass(); |
| } |
| |
| wgpu::CommandBuffer commandBuffer = commandEncoder.Finish(); |
| queue.Submit(1, &commandBuffer); |
| |
| VerifyResolveTarget(kGreen, mResolveTexture); |
| VerifyResolveTarget(kGreen, resolveTexture2); |
| } |
| |
| // Test using a layer of a 2D texture as resolve target works correctly. |
| TEST_P(MultisampledRenderingTest, ResolveIntoOneMipmapLevelOf2DTexture) { |
| // TODO(dawn:462): Investigate backend validation failure. |
| DAWN_SKIP_TEST_IF(IsD3D12() && IsBackendValidationEnabled()); |
| |
| constexpr uint32_t kBaseMipLevel = 2; |
| |
| wgpu::TextureViewDescriptor textureViewDescriptor; |
| textureViewDescriptor.dimension = wgpu::TextureViewDimension::e2D; |
| textureViewDescriptor.format = kColorFormat; |
| textureViewDescriptor.baseArrayLayer = 0; |
| textureViewDescriptor.arrayLayerCount = 1; |
| textureViewDescriptor.mipLevelCount = 1; |
| textureViewDescriptor.baseMipLevel = kBaseMipLevel; |
| |
| wgpu::Texture resolveTexture = |
| CreateTextureForOutputAttachment(kColorFormat, 1, kBaseMipLevel + 1, 1); |
| wgpu::TextureView resolveView = resolveTexture.CreateView(&textureViewDescriptor); |
| |
| wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); |
| constexpr wgpu::Color kGreen = {0.0f, 0.8f, 0.0f, 0.8f}; |
| constexpr uint32_t kSize = sizeof(kGreen); |
| constexpr bool kTestDepth = false; |
| |
| // Draw a green triangle and do MSAA resolve. |
| { |
| utils::ComboRenderPassDescriptor renderPass = CreateComboRenderPassDescriptorForTest( |
| {mMultisampledColorView}, {resolveView}, wgpu::LoadOp::Clear, wgpu::LoadOp::Clear, |
| kTestDepth); |
| wgpu::RenderPipeline pipeline = CreateRenderPipelineWithOneOutputForTest(kTestDepth); |
| |
| EncodeRenderPassForTest(commandEncoder, renderPass, pipeline, &kGreen.r, kSize); |
| } |
| |
| wgpu::CommandBuffer commandBuffer = commandEncoder.Finish(); |
| queue.Submit(1, &commandBuffer); |
| |
| VerifyResolveTarget(kGreen, resolveTexture, kBaseMipLevel, 0); |
| } |
| |
| // Test using a level or a layer of a 2D array texture as resolve target works correctly. |
| TEST_P(MultisampledRenderingTest, ResolveInto2DArrayTexture) { |
| // TODO(dawn:462): Investigate backend validation failure. |
| DAWN_SKIP_TEST_IF(IsD3D12() && IsBackendValidationEnabled()); |
| |
| wgpu::TextureView multisampledColorView2 = |
| CreateTextureForOutputAttachment(kColorFormat, kSampleCount).CreateView(); |
| |
| wgpu::TextureViewDescriptor baseTextureViewDescriptor; |
| baseTextureViewDescriptor.dimension = wgpu::TextureViewDimension::e2D; |
| baseTextureViewDescriptor.format = kColorFormat; |
| baseTextureViewDescriptor.arrayLayerCount = 1; |
| baseTextureViewDescriptor.mipLevelCount = 1; |
| |
| // Create resolveTexture1 with only 1 mipmap level. |
| constexpr uint32_t kBaseArrayLayer1 = 2; |
| constexpr uint32_t kBaseMipLevel1 = 0; |
| wgpu::Texture resolveTexture1 = |
| CreateTextureForOutputAttachment(kColorFormat, 1, kBaseMipLevel1 + 1, kBaseArrayLayer1 + 1); |
| wgpu::TextureViewDescriptor resolveViewDescriptor1 = baseTextureViewDescriptor; |
| resolveViewDescriptor1.baseArrayLayer = kBaseArrayLayer1; |
| resolveViewDescriptor1.baseMipLevel = kBaseMipLevel1; |
| wgpu::TextureView resolveView1 = resolveTexture1.CreateView(&resolveViewDescriptor1); |
| |
| // Create resolveTexture2 with (kBaseMipLevel2 + 1) mipmap levels and resolve into its last |
| // mipmap level. |
| constexpr uint32_t kBaseArrayLayer2 = 5; |
| constexpr uint32_t kBaseMipLevel2 = 3; |
| wgpu::Texture resolveTexture2 = |
| CreateTextureForOutputAttachment(kColorFormat, 1, kBaseMipLevel2 + 1, kBaseArrayLayer2 + 1); |
| wgpu::TextureViewDescriptor resolveViewDescriptor2 = baseTextureViewDescriptor; |
| resolveViewDescriptor2.baseArrayLayer = kBaseArrayLayer2; |
| resolveViewDescriptor2.baseMipLevel = kBaseMipLevel2; |
| wgpu::TextureView resolveView2 = resolveTexture2.CreateView(&resolveViewDescriptor2); |
| |
| wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder(); |
| wgpu::RenderPipeline pipeline = CreateRenderPipelineWithTwoOutputsForTest(); |
| |
| constexpr wgpu::Color kGreen = {0.0f, 0.8f, 0.0f, 0.8f}; |
| constexpr wgpu::Color kRed = {0.8f, 0.0f, 0.0f, 0.8f}; |
| constexpr bool kTestDepth = false; |
| |
| // Draw a red triangle to the first color attachment, and a green triangle to the second color |
| // attachment, and do MSAA resolve on two render targets in one render pass. |
| { |
| utils::ComboRenderPassDescriptor renderPass = CreateComboRenderPassDescriptorForTest( |
| {mMultisampledColorView, multisampledColorView2}, {resolveView1, resolveView2}, |
| wgpu::LoadOp::Clear, wgpu::LoadOp::Clear, kTestDepth); |
| |
| std::array<float, 8> kUniformData = {kRed.r, kRed.g, kRed.b, kRed.a, // color1 |
| kGreen.r, kGreen.g, kGreen.b, kGreen.a}; // color2 |
| constexpr uint32_t kSize = sizeof(kUniformData); |
| EncodeRenderPassForTest(commandEncoder, renderPass, pipeline, kUniformData.data(), kSize); |
| } |
| |
| wgpu::CommandBuffer commandBuffer = commandEncoder.Finish(); |
| queue.Submit(1, &commandBuffer); |
| |
| VerifyResolveTarget(kRed, resolveTexture1, kBaseMipLevel1, kBaseArrayLayer1); |
| VerifyResolveTarget(kGreen, resolveTexture2, kBaseMipLevel2, kBaseArrayLayer2); |
| } |
| |
| DAWN_INSTANTIATE_TEST(MultisampledRenderingTest, |
| D3D12Backend(), |
| D3D12Backend({}, {"use_d3d12_resource_heap_tier2"}), |
| D3D12Backend({}, {"use_d3d12_render_pass"}), |
| MetalBackend(), |
| OpenGLBackend(), |
| VulkanBackend(), |
| MetalBackend({"emulate_store_and_msaa_resolve"}), |
| MetalBackend({"always_resolve_into_zero_level_and_layer"}), |
| MetalBackend({"always_resolve_into_zero_level_and_layer", |
| "emulate_store_and_msaa_resolve"})); |
