src/tests/end2end/TextureSubresourceTests.cpp - dawn - Git at Google

 // 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 "tests/DawnTest.h"

 #include "utils/ComboRenderPipelineDescriptor.h"
 #include "utils/WGPUHelpers.h"

 class TextureSubresourceTest : public DawnTest {
   public:
     static constexpr uint32_t kSize = 4u;
     static constexpr wgpu::TextureFormat kFormat = wgpu::TextureFormat::RGBA8Unorm;

     wgpu::Texture CreateTexture(uint32_t mipLevelCount,
                                 uint32_t arrayLayerCount,
                                 wgpu::TextureUsage usage) {
         wgpu::TextureDescriptor texDesc;
         texDesc.dimension = wgpu::TextureDimension::e2D;
         texDesc.size = {kSize, kSize, arrayLayerCount};
         texDesc.sampleCount = 1;
         texDesc.mipLevelCount = mipLevelCount;
         texDesc.usage = usage;
         texDesc.format = kFormat;
         return device.CreateTexture(&texDesc);
     }

     wgpu::TextureView CreateTextureView(wgpu::Texture texture,
                                         uint32_t baseMipLevel,
                                         uint32_t baseArrayLayer) {
         wgpu::TextureViewDescriptor viewDesc;
         viewDesc.format = kFormat;
         viewDesc.baseArrayLayer = baseArrayLayer;
         viewDesc.arrayLayerCount = 1;
         viewDesc.baseMipLevel = baseMipLevel;
         viewDesc.mipLevelCount = 1;
         viewDesc.dimension = wgpu::TextureViewDimension::e2D;
         return texture.CreateView(&viewDesc);
     }

     void DrawTriangle(const wgpu::TextureView& view) {
         wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
             [[stage(vertex)]]
             fn main([[builtin(vertex_index)]] VertexIndex : u32) -> [[builtin(position)]] vec4<f32> {
                 let pos : array<vec2<f32>, 3> = array<vec2<f32>, 3>(
                     vec2<f32>(-1.0,  1.0),
                     vec2<f32>(-1.0, -1.0),
                     vec2<f32>( 1.0, -1.0));

                 return vec4<f32>(pos[VertexIndex], 0.0, 1.0);
             })");

         wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
             [[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> {
                 return vec4<f32>(1.0, 0.0, 0.0, 1.0);
             })");

         utils::ComboRenderPipelineDescriptor2 descriptor;
         descriptor.vertex.module = vsModule;
         descriptor.cFragment.module = fsModule;
         descriptor.primitive.topology = wgpu::PrimitiveTopology::TriangleList;
         descriptor.cTargets[0].format = kFormat;

         wgpu::RenderPipeline rp = device.CreateRenderPipeline2(&descriptor);

         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();

         utils::ComboRenderPassDescriptor renderPassDesc({view});
         renderPassDesc.cColorAttachments[0].clearColor = {0.0f, 0.0f, 0.0f, 1.0f};
         wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPassDesc);
         pass.SetPipeline(rp);
         pass.Draw(3);
         pass.EndPass();
         wgpu::CommandBuffer commands = encoder.Finish();
         queue.Submit(1, &commands);
     }

     void SampleAndDraw(const wgpu::TextureView& samplerView, const wgpu::TextureView& renderView) {
         wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
             [[stage(vertex)]]
             fn main([[builtin(vertex_index)]] VertexIndex : u32) -> [[builtin(position)]] vec4<f32> {
                 let pos : array<vec2<f32>, 6> = array<vec2<f32>, 6>(
                     vec2<f32>(-1.0, -1.0),
                     vec2<f32>( 1.0,  1.0),
                     vec2<f32>(-1.0,  1.0),
                     vec2<f32>(-1.0, -1.0),
                     vec2<f32>( 1.0, -1.0),
                     vec2<f32>( 1.0,  1.0));

                 return vec4<f32>(pos[VertexIndex], 0.0, 1.0);
             })");

         wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
             [[group(0), binding(0)]] var samp : sampler;
             [[group(0), binding(1)]] var tex : texture_2d<f32>;

             [[stage(fragment)]]
             fn main([[builtin(position)]] FragCoord : vec4<f32>) -> [[location(0)]] vec4<f32> {
                 return textureSample(tex, samp, FragCoord.xy / vec2<f32>(4.0, 4.0));
             })");

         utils::ComboRenderPipelineDescriptor2 descriptor;
         descriptor.vertex.module = vsModule;
         descriptor.cFragment.module = fsModule;
         descriptor.primitive.topology = wgpu::PrimitiveTopology::TriangleList;
         descriptor.cTargets[0].format = kFormat;

         wgpu::Sampler sampler = device.CreateSampler();

         wgpu::RenderPipeline rp = device.CreateRenderPipeline2(&descriptor);
         wgpu::BindGroupLayout bgl = rp.GetBindGroupLayout(0);
         wgpu::BindGroup bindGroup =
             utils::MakeBindGroup(device, bgl, {{0, sampler}, {1, samplerView}});

         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();

         utils::ComboRenderPassDescriptor renderPassDesc({renderView});
         renderPassDesc.cColorAttachments[0].clearColor = {0.0f, 0.0f, 0.0f, 1.0f};
         wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPassDesc);
         pass.SetPipeline(rp);
         pass.SetBindGroup(0, bindGroup);
         pass.Draw(6);
         pass.EndPass();
         wgpu::CommandBuffer commands = encoder.Finish();
         queue.Submit(1, &commands);
     }
 };

 // Test different mipmap levels
 TEST_P(TextureSubresourceTest, MipmapLevelsTest) {
     // TODO(crbug.com/dawn/593): This test requires glTextureView, which is unsupported on GLES.
     DAWN_SKIP_TEST_IF(IsOpenGLES());

     // Create a texture with 2 mipmap levels and 1 layer
     wgpu::Texture texture =
         CreateTexture(2, 1,
                       wgpu::TextureUsage::Sampled | wgpu::TextureUsage::RenderAttachment |
                           wgpu::TextureUsage::CopySrc);

     // Create two views on different mipmap levels.
     wgpu::TextureView samplerView = CreateTextureView(texture, 0, 0);
     wgpu::TextureView renderView = CreateTextureView(texture, 1, 0);

     // Draw a red triangle at the bottom-left half
     DrawTriangle(samplerView);

     // Sample from one subresource and draw into another subresource in the same texture
     SampleAndDraw(samplerView, renderView);

     // Verify that pixel at bottom-left corner is red, while pixel at top-right corner is background
     // black in render view (mip level 1).
     RGBA8 topRight = RGBA8::kBlack;
     RGBA8 bottomLeft = RGBA8::kRed;
     EXPECT_TEXTURE_EQ(&topRight, texture, {kSize / 2 - 1, 0}, {1, 1}, 1);
     EXPECT_TEXTURE_EQ(&bottomLeft, texture, {0, kSize / 2 - 1}, {1, 1}, 1);
 }

 // Test different array layers
 TEST_P(TextureSubresourceTest, ArrayLayersTest) {
     // TODO(crbug.com/dawn/593): This test requires glTextureView, which is unsupported on GLES.
     DAWN_SKIP_TEST_IF(IsOpenGLES());
     // Create a texture with 1 mipmap level and 2 layers
     wgpu::Texture texture =
         CreateTexture(1, 2,
                       wgpu::TextureUsage::Sampled | wgpu::TextureUsage::RenderAttachment |
                           wgpu::TextureUsage::CopySrc);

     // Create two views on different layers
     wgpu::TextureView samplerView = CreateTextureView(texture, 0, 0);
     wgpu::TextureView renderView = CreateTextureView(texture, 0, 1);

     // Draw a red triangle at the bottom-left half
     DrawTriangle(samplerView);

     // Sample from one subresource and draw into another subresource in the same texture
     SampleAndDraw(samplerView, renderView);

     // Verify that pixel at bottom-left corner is red, while pixel at top-right corner is background
     // black in render view (array layer 1).
     RGBA8 topRight = RGBA8::kBlack;
     RGBA8 bottomLeft = RGBA8::kRed;
     EXPECT_TEXTURE_EQ(&topRight, texture, {kSize - 1, 0, 1}, {1, 1});
     EXPECT_TEXTURE_EQ(&bottomLeft, texture, {0, kSize - 1, 1}, {1, 1});
 }

 // TODO (yunchao.he@intel.com):
 // * add tests for storage texture and sampler across miplevel or
 // arraylayer dimensions in the same texture
 //
 // * add tests for copy operation upon texture subresource if needed
 //
 // * add tests for clear operation upon texture subresource if needed

 DAWN_INSTANTIATE_TEST(TextureSubresourceTest,
                       D3D12Backend(),
                       MetalBackend(),
                       OpenGLBackend(),
                       OpenGLESBackend(),
                       VulkanBackend());
	// 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 "tests/DawnTest.h"

	#include "utils/ComboRenderPipelineDescriptor.h"
	#include "utils/WGPUHelpers.h"

	class TextureSubresourceTest : public DawnTest {
	public:
	static constexpr uint32_t kSize = 4u;
	static constexpr wgpu::TextureFormat kFormat = wgpu::TextureFormat::RGBA8Unorm;

	wgpu::Texture CreateTexture(uint32_t mipLevelCount,
	uint32_t arrayLayerCount,
	wgpu::TextureUsage usage) {
	wgpu::TextureDescriptor texDesc;
	texDesc.dimension = wgpu::TextureDimension::e2D;
	texDesc.size = {kSize, kSize, arrayLayerCount};
	texDesc.sampleCount = 1;
	texDesc.mipLevelCount = mipLevelCount;
	texDesc.usage = usage;
	texDesc.format = kFormat;
	return device.CreateTexture(&texDesc);
	}

	wgpu::TextureView CreateTextureView(wgpu::Texture texture,
	uint32_t baseMipLevel,
	uint32_t baseArrayLayer) {
	wgpu::TextureViewDescriptor viewDesc;
	viewDesc.format = kFormat;
	viewDesc.baseArrayLayer = baseArrayLayer;
	viewDesc.arrayLayerCount = 1;
	viewDesc.baseMipLevel = baseMipLevel;
	viewDesc.mipLevelCount = 1;
	viewDesc.dimension = wgpu::TextureViewDimension::e2D;
	return texture.CreateView(&viewDesc);
	}

	void DrawTriangle(const wgpu::TextureView& view) {
	wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
	[[stage(vertex)]]
	fn main([[builtin(vertex_index)]] VertexIndex : u32) -> [[builtin(position)]] vec4<f32> {
	let pos : array<vec2<f32>, 3> = array<vec2<f32>, 3>(
	vec2<f32>(-1.0, 1.0),
	vec2<f32>(-1.0, -1.0),
	vec2<f32>( 1.0, -1.0));

	return vec4<f32>(pos[VertexIndex], 0.0, 1.0);
	})");

	wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
	[[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> {
	return vec4<f32>(1.0, 0.0, 0.0, 1.0);
	})");

	utils::ComboRenderPipelineDescriptor2 descriptor;
	descriptor.vertex.module = vsModule;
	descriptor.cFragment.module = fsModule;
	descriptor.primitive.topology = wgpu::PrimitiveTopology::TriangleList;
	descriptor.cTargets[0].format = kFormat;

	wgpu::RenderPipeline rp = device.CreateRenderPipeline2(&descriptor);

	wgpu::CommandEncoder encoder = device.CreateCommandEncoder();

	utils::ComboRenderPassDescriptor renderPassDesc({view});
	renderPassDesc.cColorAttachments[0].clearColor = {0.0f, 0.0f, 0.0f, 1.0f};
	wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPassDesc);
	pass.SetPipeline(rp);
	pass.Draw(3);
	pass.EndPass();
	wgpu::CommandBuffer commands = encoder.Finish();
	queue.Submit(1, &commands);
	}

	void SampleAndDraw(const wgpu::TextureView& samplerView, const wgpu::TextureView& renderView) {
	wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
	[[stage(vertex)]]
	fn main([[builtin(vertex_index)]] VertexIndex : u32) -> [[builtin(position)]] vec4<f32> {
	let pos : array<vec2<f32>, 6> = array<vec2<f32>, 6>(
	vec2<f32>(-1.0, -1.0),
	vec2<f32>( 1.0, 1.0),
	vec2<f32>(-1.0, 1.0),
	vec2<f32>(-1.0, -1.0),
	vec2<f32>( 1.0, -1.0),
	vec2<f32>( 1.0, 1.0));

	return vec4<f32>(pos[VertexIndex], 0.0, 1.0);
	})");

	wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
	[[group(0), binding(0)]] var samp : sampler;
	[[group(0), binding(1)]] var tex : texture_2d<f32>;

	[[stage(fragment)]]
	fn main([[builtin(position)]] FragCoord : vec4<f32>) -> [[location(0)]] vec4<f32> {
	return textureSample(tex, samp, FragCoord.xy / vec2<f32>(4.0, 4.0));
	})");

	utils::ComboRenderPipelineDescriptor2 descriptor;
	descriptor.vertex.module = vsModule;
	descriptor.cFragment.module = fsModule;
	descriptor.primitive.topology = wgpu::PrimitiveTopology::TriangleList;
	descriptor.cTargets[0].format = kFormat;

	wgpu::Sampler sampler = device.CreateSampler();

	wgpu::RenderPipeline rp = device.CreateRenderPipeline2(&descriptor);
	wgpu::BindGroupLayout bgl = rp.GetBindGroupLayout(0);
	wgpu::BindGroup bindGroup =
	utils::MakeBindGroup(device, bgl, {{0, sampler}, {1, samplerView}});

	wgpu::CommandEncoder encoder = device.CreateCommandEncoder();

	utils::ComboRenderPassDescriptor renderPassDesc({renderView});
	renderPassDesc.cColorAttachments[0].clearColor = {0.0f, 0.0f, 0.0f, 1.0f};
	wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPassDesc);
	pass.SetPipeline(rp);
	pass.SetBindGroup(0, bindGroup);
	pass.Draw(6);
	pass.EndPass();
	wgpu::CommandBuffer commands = encoder.Finish();
	queue.Submit(1, &commands);
	}
	};

	// Test different mipmap levels
	TEST_P(TextureSubresourceTest, MipmapLevelsTest) {
	// TODO(crbug.com/dawn/593): This test requires glTextureView, which is unsupported on GLES.
	DAWN_SKIP_TEST_IF(IsOpenGLES());

	// Create a texture with 2 mipmap levels and 1 layer
	wgpu::Texture texture =
	CreateTexture(2, 1,
	wgpu::TextureUsage::Sampled \| wgpu::TextureUsage::RenderAttachment \|
	wgpu::TextureUsage::CopySrc);

	// Create two views on different mipmap levels.
	wgpu::TextureView samplerView = CreateTextureView(texture, 0, 0);
	wgpu::TextureView renderView = CreateTextureView(texture, 1, 0);

	// Draw a red triangle at the bottom-left half
	DrawTriangle(samplerView);

	// Sample from one subresource and draw into another subresource in the same texture
	SampleAndDraw(samplerView, renderView);

	// Verify that pixel at bottom-left corner is red, while pixel at top-right corner is background
	// black in render view (mip level 1).
	RGBA8 topRight = RGBA8::kBlack;
	RGBA8 bottomLeft = RGBA8::kRed;
	EXPECT_TEXTURE_EQ(&topRight, texture, {kSize / 2 - 1, 0}, {1, 1}, 1);
	EXPECT_TEXTURE_EQ(&bottomLeft, texture, {0, kSize / 2 - 1}, {1, 1}, 1);
	}

	// Test different array layers
	TEST_P(TextureSubresourceTest, ArrayLayersTest) {
	// TODO(crbug.com/dawn/593): This test requires glTextureView, which is unsupported on GLES.
	DAWN_SKIP_TEST_IF(IsOpenGLES());
	// Create a texture with 1 mipmap level and 2 layers
	wgpu::Texture texture =
	CreateTexture(1, 2,
	wgpu::TextureUsage::Sampled \| wgpu::TextureUsage::RenderAttachment \|
	wgpu::TextureUsage::CopySrc);

	// Create two views on different layers
	wgpu::TextureView samplerView = CreateTextureView(texture, 0, 0);
	wgpu::TextureView renderView = CreateTextureView(texture, 0, 1);

	// Draw a red triangle at the bottom-left half
	DrawTriangle(samplerView);

	// Sample from one subresource and draw into another subresource in the same texture
	SampleAndDraw(samplerView, renderView);

	// Verify that pixel at bottom-left corner is red, while pixel at top-right corner is background
	// black in render view (array layer 1).
	RGBA8 topRight = RGBA8::kBlack;
	RGBA8 bottomLeft = RGBA8::kRed;
	EXPECT_TEXTURE_EQ(&topRight, texture, {kSize - 1, 0, 1}, {1, 1});
	EXPECT_TEXTURE_EQ(&bottomLeft, texture, {0, kSize - 1, 1}, {1, 1});
	}

	// TODO (yunchao.he@intel.com):
	// * add tests for storage texture and sampler across miplevel or
	// arraylayer dimensions in the same texture
	//
	// * add tests for copy operation upon texture subresource if needed
	//
	// * add tests for clear operation upon texture subresource if needed

	DAWN_INSTANTIATE_TEST(TextureSubresourceTest,
	D3D12Backend(),
	MetalBackend(),
	OpenGLBackend(),
	OpenGLESBackend(),
	VulkanBackend());