blob: 29805d29fbc240afe99e9dd9703c5692e64e6406 [file] [log] [blame] [edit]
// 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/tests/DawnTest.h"
#include "dawn/utils/ComboRenderPipelineDescriptor.h"
#include "dawn/utils/WGPUHelpers.h"
namespace dawn {
namespace {
class FramebufferFetchTests : public DawnTest {
protected:
void SetUp() override {
DawnTest::SetUp();
DAWN_TEST_UNSUPPORTED_IF(!device.HasFeature(wgpu::FeatureName::FramebufferFetch));
}
std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
std::vector<wgpu::FeatureName> requiredFeatures = {};
if (SupportsFeatures({wgpu::FeatureName::FramebufferFetch})) {
requiredFeatures.push_back(wgpu::FeatureName::FramebufferFetch);
}
return requiredFeatures;
}
void InitForSinglePoint(utils::ComboRenderPipelineDescriptor* desc) {
desc->vertex.module = utils::CreateShaderModule(device, R"(
@vertex fn vs() -> @builtin(position) vec4f {
return vec4f(0, 0, 0, 1);
}
)");
desc->primitive.topology = wgpu::PrimitiveTopology::PointList;
}
wgpu::Texture MakeAttachment(wgpu::TextureFormat format,
wgpu::Extent3D size = {1, 1, 1},
uint32_t sampleCount = 1) {
wgpu::TextureDescriptor tDesc;
tDesc.size = size;
tDesc.sampleCount = sampleCount;
tDesc.usage = wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc |
wgpu::TextureUsage::CopyDst;
tDesc.format = format;
return device.CreateTexture(&tDesc);
}
std::string kExt = "enable chromium_experimental_framebuffer_fetch;\n";
};
// A basic test of framebuffer fetch
TEST_P(FramebufferFetchTests, Basic) {
// Pipeline that draw a point at the center that adds one to the attachment.
utils::ComboRenderPipelineDescriptor pDesc;
InitForSinglePoint(&pDesc);
pDesc.cFragment.module = utils::CreateShaderModule(device, kExt + R"(
@fragment fn main(@color(0) in : u32) -> @location(0) u32 {
return in + 1;
}
)");
pDesc.cTargets[0].format = wgpu::TextureFormat::R32Uint;
wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&pDesc);
wgpu::Texture texture = MakeAttachment(wgpu::TextureFormat::R32Uint);
// Draw 10 points with the pipeline on the render target.
utils::ComboRenderPassDescriptor passDesc({texture.CreateView()});
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&passDesc);
pass.SetPipeline(pipeline);
pass.Draw(10);
pass.End();
wgpu::CommandBuffer commands = encoder.Finish();
queue.Submit(1, &commands);
// The 10 points should have successfully used framebuffer fetch to do increment ten times
// without races.
EXPECT_TEXTURE_EQ(uint32_t(10), texture, {0, 0});
}
// Check that it is post-blend framebuffer fetch
TEST_P(FramebufferFetchTests, PostBlend) {
// Pipeline that draw a point at the center that outputs the current attachment value with
// additive blend, so multiplies by two.
utils::ComboRenderPipelineDescriptor pDesc;
InitForSinglePoint(&pDesc);
pDesc.cFragment.module = utils::CreateShaderModule(device, kExt + R"(
@fragment fn main(@color(0) in : vec4f) -> @location(0) vec4f {
return in;
}
)");
pDesc.cTargets[0].format = wgpu::TextureFormat::RGBA8Unorm;
pDesc.cTargets[0].blend = &pDesc.cBlends[0];
pDesc.cBlends[0].color.srcFactor = wgpu::BlendFactor::One;
pDesc.cBlends[0].color.dstFactor = wgpu::BlendFactor::One;
pDesc.cBlends[0].color.operation = wgpu::BlendOperation::Add;
pDesc.cBlends[0].alpha = pDesc.cBlends[0].color;
wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&pDesc);
wgpu::Texture texture = MakeAttachment(wgpu::TextureFormat::RGBA8Unorm);
// Starting with small value, then do *2 4 times.
utils::ComboRenderPassDescriptor passDesc({texture.CreateView()});
passDesc.cColorAttachments[0].loadOp = wgpu::LoadOp::Clear;
passDesc.cColorAttachments[0].clearValue = {1 / 255.0, 2 / 255.0, 3 / 255.0, 4 / 255.0};
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&passDesc);
pass.SetPipeline(pipeline);
pass.Draw(4);
pass.End();
wgpu::CommandBuffer commands = encoder.Finish();
queue.Submit(1, &commands);
// The 10 points should have successfully used framebuffer fetch to do increment ten times
// without races.
EXPECT_TEXTURE_EQ(utils::RGBA8(16, 32, 48, 64), texture, {0, 0});
}
// Check with multiple render attachments
TEST_P(FramebufferFetchTests, MultipleAttachments) {
// Pipeline that draw a point at the center that adds 0/1/2/3 to multiple attachments.
utils::ComboRenderPipelineDescriptor pDesc;
InitForSinglePoint(&pDesc);
pDesc.cFragment.module = utils::CreateShaderModule(device, kExt + R"(
struct Out {
@location(0) out0 : u32,
@location(1) out1 : u32,
@location(2) out2 : u32,
@location(3) out3 : u32,
}
@fragment fn main(
@color(0) in0 : u32,
@color(1) in1 : u32,
@color(2) in2 : u32,
@color(3) in3 : u32,
) -> Out {
var out : Out;
out.out0 = in0 + 0;
out.out1 = in1 + 1;
out.out2 = in2 + 2;
out.out3 = in3 + 3;
return out;
}
)");
pDesc.cFragment.targetCount = 4;
pDesc.cTargets[0].format = wgpu::TextureFormat::R32Uint;
pDesc.cTargets[1].format = wgpu::TextureFormat::R32Uint;
pDesc.cTargets[2].format = wgpu::TextureFormat::R32Uint;
pDesc.cTargets[3].format = wgpu::TextureFormat::R32Uint;
wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&pDesc);
wgpu::Texture texture0 = MakeAttachment(wgpu::TextureFormat::R32Uint);
wgpu::Texture texture1 = MakeAttachment(wgpu::TextureFormat::R32Uint);
wgpu::Texture texture2 = MakeAttachment(wgpu::TextureFormat::R32Uint);
wgpu::Texture texture3 = MakeAttachment(wgpu::TextureFormat::R32Uint);
// Draw 10 points with the pipeline on the render target.
utils::ComboRenderPassDescriptor passDesc({
texture0.CreateView(),
texture1.CreateView(),
texture2.CreateView(),
texture3.CreateView(),
});
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&passDesc);
pass.SetPipeline(pipeline);
pass.Draw(10);
pass.End();
wgpu::CommandBuffer commands = encoder.Finish();
queue.Submit(1, &commands);
// The 10 points should have successfully used framebuffer fetch to do increment ten times
// without races.
EXPECT_TEXTURE_EQ(uint32_t(0), texture0, {0, 0});
EXPECT_TEXTURE_EQ(uint32_t(10), texture1, {0, 0});
EXPECT_TEXTURE_EQ(uint32_t(20), texture2, {0, 0});
EXPECT_TEXTURE_EQ(uint32_t(30), texture3, {0, 0});
}
// Check with multiple render attachments
TEST_P(FramebufferFetchTests, VariousFormats) {
// Pipeline that draw a point at the center that adds / substracts one to attachment of various
// formats.
utils::ComboRenderPipelineDescriptor pDesc;
InitForSinglePoint(&pDesc);
pDesc.cFragment.module = utils::CreateShaderModule(device, kExt + R"(
struct Out {
@location(0) out0 : u32,
@location(1) out1 : i32,
@location(2) out2 : f32,
@location(3) out3 : vec4f,
}
@fragment fn main(
@color(0) in0 : u32,
@color(1) in1 : i32,
@color(2) in2 : f32,
@color(3) in3 : vec4f,
) -> Out {
var out : Out;
out.out0 = in0 + 1;
out.out1 = in1 - 1;
out.out2 = in2 + 1;
out.out3 = in3 + vec4f(1 / 255.0);
return out;
}
)");
pDesc.cFragment.targetCount = 4;
pDesc.cTargets[0].format = wgpu::TextureFormat::R32Uint;
pDesc.cTargets[1].format = wgpu::TextureFormat::R32Sint;
pDesc.cTargets[2].format = wgpu::TextureFormat::R32Float;
pDesc.cTargets[3].format = wgpu::TextureFormat::RGBA8Unorm;
wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&pDesc);
wgpu::Texture texture0 = MakeAttachment(wgpu::TextureFormat::R32Uint);
wgpu::Texture texture1 = MakeAttachment(wgpu::TextureFormat::R32Sint);
wgpu::Texture texture2 = MakeAttachment(wgpu::TextureFormat::R32Float);
wgpu::Texture texture3 = MakeAttachment(wgpu::TextureFormat::RGBA8Unorm);
// Draw 10 points with the pipeline on the render target.
utils::ComboRenderPassDescriptor passDesc({
texture0.CreateView(),
texture1.CreateView(),
texture2.CreateView(),
texture3.CreateView(),
});
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&passDesc);
pass.SetPipeline(pipeline);
pass.Draw(10);
pass.End();
wgpu::CommandBuffer commands = encoder.Finish();
queue.Submit(1, &commands);
// The 10 points should have successfully used framebuffer fetch to do in/decrement ten times
// without races.
EXPECT_TEXTURE_EQ(uint32_t(10), texture0, {0, 0});
EXPECT_TEXTURE_EQ(int32_t(-10), texture1, {0, 0});
EXPECT_TEXTURE_EQ(static_cast<float>(10), texture2, {0, 0});
EXPECT_TEXTURE_EQ(utils::RGBA8(10, 10, 10, 10), texture3, {0, 0});
}
// Tests load and store operations
// LoadOp::Clear and StoreOp::Store are basically always tested by other tests, so this one tests
// LoadOp::Load and StoreOp::Discard
TEST_P(FramebufferFetchTests, LoadAndStoreOpsReallyItsLoadAndDiscard) {
// Pipeline that adds one to the first attachment but also saves it to the second attachment.
utils::ComboRenderPipelineDescriptor pDesc;
InitForSinglePoint(&pDesc);
pDesc.cFragment.module = utils::CreateShaderModule(device, kExt + R"(
struct Out {
@location(0) out0 : u32,
@location(1) out1 : u32,
}
@fragment fn main(@color(0) in0 : u32, @color(1) in1 : u32) -> Out {
var out : Out;
out.out0 = in0 + 1;
out.out1 = out.out0;
return out;
}
)");
pDesc.cFragment.targetCount = 2;
pDesc.cTargets[0].format = wgpu::TextureFormat::R32Uint;
pDesc.cTargets[1].format = wgpu::TextureFormat::R32Uint;
wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&pDesc);
wgpu::Texture texture0 = MakeAttachment(wgpu::TextureFormat::R32Uint);
wgpu::Texture texture1 = MakeAttachment(wgpu::TextureFormat::R32Uint);
// Clear the first attachment to 1789 with a render pass.
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
utils::ComboRenderPassDescriptor clearPassDesc({texture0.CreateView()});
clearPassDesc.cColorAttachments[0].clearValue.r = 1789;
wgpu::RenderPassEncoder clearPass = encoder.BeginRenderPass(&clearPassDesc);
clearPass.End();
// Draw 10 points with the pipeline on the render target.
utils::ComboRenderPassDescriptor passDesc({texture0.CreateView(), texture1.CreateView()});
passDesc.cColorAttachments[0].loadOp = wgpu::LoadOp::Load;
passDesc.cColorAttachments[0].storeOp = wgpu::StoreOp::Discard;
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&passDesc);
pass.SetPipeline(pipeline);
pass.Draw(10);
pass.End();
wgpu::CommandBuffer commands = encoder.Finish();
queue.Submit(1, &commands);
// The first attachment is discard, but it's value of (ten increments + loaded value) is in the
// second attachment.
EXPECT_TEXTURE_EQ(uint32_t(0), texture0, {0, 0});
EXPECT_TEXTURE_EQ(uint32_t(10 + 1789), texture1, {0, 0});
}
// Test the behavior with multisampling.
// Checks that each sample has its own framebuffer fetch by add sample_index to that sample multiple
// times. Checks that any framebuffer fetch forces sample shading, even if all the samples have the
// same value.
TEST_P(FramebufferFetchTests, MultisamplingIsSampleRasterization) {
wgpu::BindGroupLayout bgl = utils::MakeBindGroupLayout(
device, {{0, wgpu::ShaderStage::Fragment, wgpu::BufferBindingType::Storage}});
utils::ComboRenderPipelineDescriptor pDesc;
InitForSinglePoint(&pDesc);
pDesc.layout = utils::MakePipelineLayout(device, {bgl});
pDesc.multisample.count = 4;
pDesc.cTargets[0].format = wgpu::TextureFormat::RGBA8Unorm;
pDesc.cFragment.module = utils::CreateShaderModule(device, kExt + R"(
@group(0) @binding(0) var<storage, read_write> invocationCount : atomic<u32>;
@fragment fn addOne(@color(0) in : vec4f) -> @location(0) vec4f {
atomicAdd(&invocationCount, 1);
return in + vec4(1 / 255.0);
}
@fragment fn addSampleIndex(
@color(0) in : vec4f,
@builtin(sample_index) sampleIndex : u32,
) -> @location(0) vec4f {
atomicAdd(&invocationCount, 1);
var out = in;
out[sampleIndex] += f32(4 * sampleIndex) / 255.0;
return out;
}
)");
pDesc.cFragment.entryPoint = "addOne";
wgpu::RenderPipeline addOnePipeline = device.CreateRenderPipeline(&pDesc);
pDesc.cFragment.entryPoint = "addSampleIndex";
wgpu::RenderPipeline addSampleCountPipeline = device.CreateRenderPipeline(&pDesc);
// Create the buffer that will contain the number of invocations.
wgpu::BufferDescriptor bufDesc;
bufDesc.size = 4;
bufDesc.usage = wgpu::BufferUsage::Storage | wgpu::BufferUsage::CopySrc;
wgpu::Buffer invocationBuffer = device.CreateBuffer(&bufDesc);
wgpu::BindGroup bg = utils::MakeBindGroup(device, bgl, {{0, invocationBuffer}});
wgpu::Texture attachment = MakeAttachment(wgpu::TextureFormat::RGBA8Unorm, {1, 1}, 4);
wgpu::Texture resolve = MakeAttachment(wgpu::TextureFormat::RGBA8Unorm);
// Run the test!!
utils::ComboRenderPassDescriptor passDesc({attachment.CreateView()});
passDesc.cColorAttachments[0].resolveTarget = resolve.CreateView();
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&passDesc);
pass.SetBindGroup(0, bg);
// This FS should use sample shading and run 4 times, adding one each time.
pass.SetPipeline(addOnePipeline);
pass.Draw(1);
// This adds sample_index * 10 to each sample.
pass.SetPipeline(addSampleCountPipeline);
pass.Draw(10);
// This FS should use sample shading and run 4 times, adding one each time.
pass.SetPipeline(addOnePipeline);
pass.Draw(1);
pass.End();
wgpu::CommandBuffer commands = encoder.Finish();
queue.Submit(1, &commands);
EXPECT_BUFFER_U32_EQ(4 + 10 * 4 + 4, invocationBuffer, 0);
EXPECT_TEXTURE_EQ(utils::RGBA8(2 + 0 * 10, 2 + 1 * 10, 2 + 2 * 10, 2 + 3 * 10), resolve,
{0, 0});
}
DAWN_INSTANTIATE_TEST(FramebufferFetchTests, MetalBackend());
} // anonymous namespace
} // namespace dawn