blob: 3e69983d8d56223ed71810c4912293d377f458a9 [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.
#include <cmath>
#include "tests/DawnTest.h"
#include "common/Assert.h"
#include "common/Constants.h"
#include "utils/ComboRenderPipelineDescriptor.h"
#include "utils/WGPUHelpers.h"
constexpr static unsigned int kRTSize = 16;
namespace {
// MipLevel colors, ordering from base level to high level
// each mipmap of the texture is having a different color
// so we can check if the sampler anisotropic filtering is fetching
// from the correct miplevel
const std::array<RGBA8, 3> colors = {RGBA8::kRed, RGBA8::kGreen, RGBA8::kBlue};
} // namespace
class SamplerFilterAnisotropicTest : public DawnTest {
protected:
void SetUp() override {
DawnTest::SetUp();
mRenderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[block]] struct Uniforms {
matrix : mat4x4<f32>;
};
[[location(0)]] var<in> position : vec4<f32>;
[[location(1)]] var<in> uv : vec2<f32>;
[[group(0), binding(2)]] var<uniform> uniforms : Uniforms;
[[builtin(position)]] var<out> Position : vec4<f32>;
[[location(0)]] var<out> fragUV : vec2<f32>;
[[stage(vertex)]] fn main() -> void {
fragUV = uv;
Position = uniforms.matrix * position;
}
)");
wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var sampler0 : sampler;
[[group(0), binding(1)]] var texture0 : texture_2d<f32>;
[[builtin(frag_coord)]] var<in> FragCoord : vec4<f32>;
[[location(0)]] var<in> fragUV: vec2<f32>;
[[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void {
fragColor = textureSample(texture0, sampler0, fragUV);
})");
utils::ComboRenderPipelineDescriptor2 pipelineDescriptor;
pipelineDescriptor.vertex.module = vsModule;
pipelineDescriptor.cFragment.module = fsModule;
pipelineDescriptor.cBuffers[0].attributeCount = 2;
pipelineDescriptor.cAttributes[0].format = wgpu::VertexFormat::Float32x4;
pipelineDescriptor.cAttributes[1].shaderLocation = 1;
pipelineDescriptor.cAttributes[1].offset = 4 * sizeof(float);
pipelineDescriptor.cAttributes[1].format = wgpu::VertexFormat::Float32x2;
pipelineDescriptor.vertex.bufferCount = 1;
pipelineDescriptor.cBuffers[0].arrayStride = 6 * sizeof(float);
pipelineDescriptor.cTargets[0].format = mRenderPass.colorFormat;
mPipeline = device.CreateRenderPipeline2(&pipelineDescriptor);
mBindGroupLayout = mPipeline.GetBindGroupLayout(0);
InitTexture();
}
void InitTexture() {
const uint32_t mipLevelCount = colors.size();
const uint32_t textureWidthLevel0 = 1 << (mipLevelCount - 1);
const uint32_t textureHeightLevel0 = 1 << (mipLevelCount - 1);
wgpu::TextureDescriptor descriptor;
descriptor.dimension = wgpu::TextureDimension::e2D;
descriptor.size.width = textureWidthLevel0;
descriptor.size.height = textureHeightLevel0;
descriptor.size.depthOrArrayLayers = 1;
descriptor.sampleCount = 1;
descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
descriptor.mipLevelCount = mipLevelCount;
descriptor.usage = wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::Sampled;
wgpu::Texture texture = device.CreateTexture(&descriptor);
const uint32_t rowPixels = kTextureBytesPerRowAlignment / sizeof(RGBA8);
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
// Populate each mip level with a different color
for (uint32_t level = 0; level < mipLevelCount; ++level) {
const uint32_t texWidth = textureWidthLevel0 >> level;
const uint32_t texHeight = textureHeightLevel0 >> level;
const RGBA8 color = colors[level];
std::vector<RGBA8> data(rowPixels * texHeight, color);
wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
device, data.data(), data.size() * sizeof(RGBA8), wgpu::BufferUsage::CopySrc);
wgpu::ImageCopyBuffer imageCopyBuffer =
utils::CreateImageCopyBuffer(stagingBuffer, 0, kTextureBytesPerRowAlignment);
wgpu::ImageCopyTexture imageCopyTexture =
utils::CreateImageCopyTexture(texture, level, {0, 0, 0});
wgpu::Extent3D copySize = {texWidth, texHeight, 1};
encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
}
wgpu::CommandBuffer copy = encoder.Finish();
queue.Submit(1, &copy);
mTextureView = texture.CreateView();
}
// void TestFilterAnisotropic(const FilterAnisotropicTestCase& testCase) {
void TestFilterAnisotropic(const uint16_t maxAnisotropy) {
wgpu::Sampler sampler;
{
wgpu::SamplerDescriptor descriptor = {};
descriptor.minFilter = wgpu::FilterMode::Linear;
descriptor.magFilter = wgpu::FilterMode::Linear;
descriptor.mipmapFilter = wgpu::FilterMode::Linear;
descriptor.maxAnisotropy = maxAnisotropy;
sampler = device.CreateSampler(&descriptor);
}
// The transform matrix gives us a slanted plane
// Tweaking happens at: https://jsfiddle.net/t8k7c95o/5/
// You can get an idea of what the test looks like at the url rendered by webgl
std::array<float, 16> transform = {-1.7320507764816284,
1.8322050568049563e-16,
-6.176817699518044e-17,
-6.170640314703498e-17,
-2.1211504944260596e-16,
-1.496108889579773,
0.5043753981590271,
0.5038710236549377,
0,
-43.63650894165039,
-43.232173919677734,
-43.18894577026367,
0,
21.693578720092773,
21.789791107177734,
21.86800193786621};
wgpu::Buffer transformBuffer = utils::CreateBufferFromData(
device, transform.data(), sizeof(transform), wgpu::BufferUsage::Uniform);
wgpu::BindGroup bindGroup = utils::MakeBindGroup(
device, mBindGroupLayout,
{{0, sampler}, {1, mTextureView}, {2, transformBuffer, 0, sizeof(transform)}});
// The plane is scaled on z axis in the transform matrix
// so uv here is also scaled
// vertex attribute layout:
// position : vec4, uv : vec2
const float vertexData[] = {
-0.5, 0.5, -0.5, 1, 0, 0, 0.5, 0.5, -0.5, 1, 1, 0, -0.5, 0.5, 0.5, 1, 0, 50,
-0.5, 0.5, 0.5, 1, 0, 50, 0.5, 0.5, -0.5, 1, 1, 0, 0.5, 0.5, 0.5, 1, 1, 50,
};
wgpu::Buffer vertexBuffer = utils::CreateBufferFromData(
device, vertexData, sizeof(vertexData), wgpu::BufferUsage::Vertex);
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
{
wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&mRenderPass.renderPassInfo);
pass.SetPipeline(mPipeline);
pass.SetBindGroup(0, bindGroup);
pass.SetVertexBuffer(0, vertexBuffer);
pass.Draw(6);
pass.EndPass();
}
wgpu::CommandBuffer commands = encoder.Finish();
queue.Submit(1, &commands);
// https://jsfiddle.net/t8k7c95o/5/
// (x, y) -> (8, [0,15)) full readpixels result on Win10 Nvidia D3D12 GPU
// maxAnisotropy: 1
// 0 - 00 00 00
// 1 - 00 00 ff
// 2 - 00 00 ff
// 3 - 00 00 ff
// 4 - 00 f9 06
// 5 - 00 f9 06
// 6 - f2 0d 00
// 7 - f2 0d 00
// 8 - ff 00 00
// 9 - ff 00 00
// 10 - ff 00 00
// 11 - ff 00 00
// 12 - ff 00 00
// 13 - ff 00 00
// 14 - ff 00 00
// 15 - ff 00 00
// maxAnisotropy: 2
// 0 - 00 00 00
// 1 - 00 00 ff
// 2 - 00 7e 81
// 3 - 00 7e 81
// 4 - ff 00 00
// 5 - ff 00 00
// 6 - ff 00 00
// 7 - ff 00 00
// 8 - ff 00 00
// 9 - ff 00 00
// 10 - ff 00 00
// 11 - ff 00 00
// 12 - ff 00 00
// 13 - ff 00 00
// 14 - ff 00 00
// 15 - ff 00 00
// maxAnisotropy: 16
// 0 - 00 00 00
// 1 - 00 00 ff
// 2 - dd 22 00
// 3 - dd 22 00
// 4 - ff 00 00
// 5 - ff 00 00
// 6 - ff 00 00
// 7 - ff 00 00
// 8 - ff 00 00
// 9 - ff 00 00
// 10 - ff 00 00
// 11 - ff 00 00
// 12 - ff 00 00
// 13 - ff 00 00
// 14 - ff 00 00
// 15 - ff 00 00
if (maxAnisotropy >= 16) {
EXPECT_PIXEL_RGBA8_BETWEEN(colors[0], colors[1], mRenderPass.color, 8, 2);
EXPECT_PIXEL_RGBA8_EQ(colors[0], mRenderPass.color, 8, 6);
} else if (maxAnisotropy == 2) {
EXPECT_PIXEL_RGBA8_BETWEEN(colors[1], colors[2], mRenderPass.color, 8, 2);
EXPECT_PIXEL_RGBA8_EQ(colors[0], mRenderPass.color, 8, 6);
} else if (maxAnisotropy <= 1) {
EXPECT_PIXEL_RGBA8_EQ(colors[2], mRenderPass.color, 8, 2);
EXPECT_PIXEL_RGBA8_BETWEEN(colors[0], colors[1], mRenderPass.color, 8, 6);
}
}
utils::BasicRenderPass mRenderPass;
wgpu::BindGroupLayout mBindGroupLayout;
wgpu::RenderPipeline mPipeline;
wgpu::TextureView mTextureView;
};
TEST_P(SamplerFilterAnisotropicTest, SlantedPlaneMipmap) {
// TODO(crbug.com/tint/691): shader compiles, but output is unexpected
DAWN_SKIP_TEST_IF(IsD3D12() && HasToggleEnabled("use_tint_generator"));
// TODO(crbug.com/dawn/740): Test output is wrong with D3D12 + WARP.
DAWN_SKIP_TEST_IF(IsD3D12() && IsWARP());
DAWN_SKIP_TEST_IF(IsOpenGL() || IsOpenGLES());
const uint16_t maxAnisotropyLists[] = {1, 2, 16, 128};
for (uint16_t t : maxAnisotropyLists) {
TestFilterAnisotropic(t);
}
}
DAWN_INSTANTIATE_TEST(SamplerFilterAnisotropicTest,
D3D12Backend(),
MetalBackend(),
OpenGLBackend(),
OpenGLESBackend(),
VulkanBackend());