| // 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 "common/Constants.h" | |
| #include "common/Math.h" | |
| #include "utils/ComboRenderPipelineDescriptor.h" | |
| #include "utils/TestUtils.h" | |
| #include "utils/TextureUtils.h" | |
| #include "utils/WGPUHelpers.h" | |
| namespace { | |
| static constexpr wgpu::TextureFormat kTextureFormat = wgpu::TextureFormat::RGBA8Unorm; | |
| // Set default texture size to single line texture for color conversion tests. | |
| static constexpr uint64_t kDefaultTextureWidth = 10; | |
| static constexpr uint64_t kDefaultTextureHeight = 1; | |
| // Dst texture format copyTextureForBrowser accept | |
| static const wgpu::TextureFormat kDstTextureFormats[] = { | |
| wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureFormat::BGRA8Unorm, | |
| wgpu::TextureFormat::RGBA32Float, wgpu::TextureFormat::RG8Unorm, | |
| wgpu::TextureFormat::RGBA16Float, wgpu::TextureFormat::RG16Float, | |
| wgpu::TextureFormat::RGB10A2Unorm}; | |
| static const wgpu::Origin3D kOrigins[] = {{1, 1}, {1, 2}, {2, 1}}; | |
| static const wgpu::Extent3D kCopySizes[] = {{1, 1}, {2, 1}, {1, 2}, {2, 2}}; | |
| static const wgpu::AlphaOp kAlphaOps[] = {wgpu::AlphaOp::DontChange, wgpu::AlphaOp::Premultiply, | |
| wgpu::AlphaOp::Unpremultiply}; | |
| } // anonymous namespace | |
| class CopyTextureForBrowserTests : public DawnTest { | |
| protected: | |
| struct TextureSpec { | |
| wgpu::Origin3D copyOrigin = {}; | |
| wgpu::Extent3D textureSize = {kDefaultTextureWidth, kDefaultTextureHeight}; | |
| uint32_t level = 0; | |
| wgpu::TextureFormat format = kTextureFormat; | |
| }; | |
| // This fixed source texture data is for color conversion tests. | |
| // The source data can fill a texture in default width and height. | |
| static std::vector<RGBA8> GetFixedSourceTextureData() { | |
| std::vector<RGBA8> sourceTextureData{ | |
| // Take RGBA8Unorm as example: | |
| // R channel has different values | |
| RGBA8(0, 255, 255, 255), // r = 0.0 | |
| RGBA8(102, 255, 255, 255), // r = 0.4 | |
| RGBA8(153, 255, 255, 255), // r = 0.6 | |
| // G channel has different values | |
| RGBA8(255, 0, 255, 255), // g = 0.0 | |
| RGBA8(255, 102, 255, 255), // g = 0.4 | |
| RGBA8(255, 153, 255, 255), // g = 0.6 | |
| // B channel has different values | |
| RGBA8(255, 255, 0, 255), // b = 0.0 | |
| RGBA8(255, 255, 102, 255), // b = 0.4 | |
| RGBA8(255, 255, 153, 255), // b = 0.6 | |
| // A channel set to 0 | |
| RGBA8(255, 255, 255, 0) // a = 0 | |
| }; | |
| return sourceTextureData; | |
| } | |
| enum class TextureCopyRole { | |
| SOURCE, | |
| DEST, | |
| }; | |
| // Source texture contains red pixels and dst texture contains green pixels at start. | |
| static std::vector<RGBA8> GetTextureData(const utils::TextureDataCopyLayout& layout, | |
| TextureCopyRole textureRole, | |
| wgpu::AlphaOp alphaOp = wgpu::AlphaOp::DontChange) { | |
| std::array<uint8_t, 4> alpha = {0, 102, 153, 255}; // 0.0, 0.4, 0.6, 1.0 | |
| std::vector<RGBA8> textureData(layout.texelBlockCount); | |
| for (uint32_t layer = 0; layer < layout.mipSize.depthOrArrayLayers; ++layer) { | |
| const uint32_t sliceOffset = layout.texelBlocksPerImage * layer; | |
| for (uint32_t y = 0; y < layout.mipSize.height; ++y) { | |
| const uint32_t rowOffset = layout.texelBlocksPerRow * y; | |
| for (uint32_t x = 0; x < layout.mipSize.width; ++x) { | |
| // Source textures will have variable pixel data to cover cases like | |
| // flipY. | |
| if (textureRole == TextureCopyRole::SOURCE) { | |
| switch (alphaOp) { | |
| case wgpu::AlphaOp::DontChange: | |
| textureData[sliceOffset + rowOffset + x] = RGBA8( | |
| static_cast<uint8_t>((x + layer * x) % 256), | |
| static_cast<uint8_t>((y + layer * y) % 256), | |
| static_cast<uint8_t>(x % 256), static_cast<uint8_t>(x % 256)); | |
| break; | |
| case wgpu::AlphaOp::Premultiply: | |
| // For premultiply alpha test cases, we expect each channel in dst | |
| // texture will equal to the alpha channel value. | |
| textureData[sliceOffset + rowOffset + x] = RGBA8( | |
| static_cast<uint8_t>(255), static_cast<uint8_t>(255), | |
| static_cast<uint8_t>(255), static_cast<uint8_t>(alpha[x % 4])); | |
| break; | |
| case wgpu::AlphaOp::Unpremultiply: | |
| // For unpremultiply alpha test cases, we expect each channel in dst | |
| // texture will equal to 1.0. | |
| textureData[sliceOffset + rowOffset + x] = | |
| RGBA8(static_cast<uint8_t>(alpha[x % 4]), | |
| static_cast<uint8_t>(alpha[x % 4]), | |
| static_cast<uint8_t>(alpha[x % 4]), | |
| static_cast<uint8_t>(alpha[x % 4])); | |
| break; | |
| default: | |
| UNREACHABLE(); | |
| break; | |
| } | |
| } else { // Dst textures will have be init as `green` to ensure subrect | |
| // copy not cross bound. | |
| textureData[sliceOffset + rowOffset + x] = | |
| RGBA8(static_cast<uint8_t>(0), static_cast<uint8_t>(255), | |
| static_cast<uint8_t>(0), static_cast<uint8_t>(255)); | |
| } | |
| } | |
| } | |
| } | |
| return textureData; | |
| } | |
| void SetUp() override { | |
| DawnTest::SetUp(); | |
| // crbug.com/dawn/948: Tint required for multiple entrypoints in a module. | |
| // CopyTextureForBrowser uses and internal pipeline with a multi-entrypoint | |
| // shader module. | |
| DAWN_TEST_UNSUPPORTED_IF(!HasToggleEnabled("use_tint_generator")); | |
| testPipeline = MakeTestPipeline(); | |
| uint32_t uniformBufferData[] = { | |
| 0, // copy have flipY option | |
| 4, // channelCount | |
| 0, | |
| 0, // uvec2, subrect copy src origin | |
| 0, | |
| 0, // uvec2, subrect copy dst origin | |
| 0, | |
| 0, // uvec2, subrect copy size | |
| static_cast<uint32_t>(wgpu::AlphaOp::DontChange), // AlphaOp: DontChange | |
| }; | |
| wgpu::BufferDescriptor uniformBufferDesc = {}; | |
| uniformBufferDesc.usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Uniform; | |
| uniformBufferDesc.size = sizeof(uniformBufferData); | |
| uniformBuffer = device.CreateBuffer(&uniformBufferDesc); | |
| } | |
| // Do the bit-by-bit comparison between the source and destination texture with GPU (compute | |
| // shader) instead of CPU after executing CopyTextureForBrowser() to avoid the errors caused by | |
| // comparing a value generated on CPU to the one generated on GPU. | |
| wgpu::ComputePipeline MakeTestPipeline() { | |
| wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"( | |
| [[block]] struct Uniforms { | |
| dstTextureFlipY : u32; | |
| channelCount : u32; | |
| srcCopyOrigin : vec2<u32>; | |
| dstCopyOrigin : vec2<u32>; | |
| copySize : vec2<u32>; | |
| alphaOp : u32; | |
| }; | |
| [[block]] struct OutputBuf { | |
| result : array<u32>; | |
| }; | |
| [[group(0), binding(0)]] var src : texture_2d<f32>; | |
| [[group(0), binding(1)]] var dst : texture_2d<f32>; | |
| [[group(0), binding(2)]] var<storage, read_write> output : OutputBuf; | |
| [[group(0), binding(3)]] var<uniform> uniforms : Uniforms; | |
| fn aboutEqual(value : f32, expect : f32) -> bool { | |
| // The value diff should be smaller than the hard coded tolerance. | |
| return abs(value - expect) < 0.001; | |
| } | |
| [[stage(compute), workgroup_size(1, 1, 1)]] | |
| fn main([[builtin(global_invocation_id)]] GlobalInvocationID : vec3<u32>) { | |
| let srcSize = textureDimensions(src); | |
| let dstSize = textureDimensions(dst); | |
| let dstTexCoord = vec2<u32>(GlobalInvocationID.xy); | |
| let nonCoveredColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); // should be green | |
| var success : bool = true; | |
| if (dstTexCoord.x < uniforms.dstCopyOrigin.x || | |
| dstTexCoord.y < uniforms.dstCopyOrigin.y || | |
| dstTexCoord.x >= uniforms.dstCopyOrigin.x + uniforms.copySize.x || | |
| dstTexCoord.y >= uniforms.dstCopyOrigin.y + uniforms.copySize.y) { | |
| success = success && | |
| all(textureLoad(dst, vec2<i32>(dstTexCoord), 0) == nonCoveredColor); | |
| } else { | |
| // Calculate source texture coord. | |
| var srcTexCoord = dstTexCoord - uniforms.dstCopyOrigin + | |
| uniforms.srcCopyOrigin; | |
| // Note that |flipY| equals flip src texture firstly and then do copy from src | |
| // subrect to dst subrect. This helps on blink part to handle some input texture | |
| // which is flipped and need to unpack flip during the copy. | |
| // We need to calculate the expect y coord based on this rule. | |
| if (uniforms.dstTextureFlipY == 1u) { | |
| srcTexCoord.y = u32(srcSize.y) - srcTexCoord.y - 1u; | |
| } | |
| var srcColor = textureLoad(src, vec2<i32>(srcTexCoord), 0); | |
| var dstColor = textureLoad(dst, vec2<i32>(dstTexCoord), 0); | |
| // Expect the dst texture channels should be all equal to alpha value | |
| // after premultiply. | |
| // TODO(crbug.com/1217153): if wgsl support `constexpr` and allow it | |
| // to be case selector, Replace 0u/1u/2u with a constexpr variable with | |
| // meaningful name. | |
| switch(uniforms.alphaOp) { | |
| case 0u: { // AlphaOp: DontChange | |
| break; | |
| } | |
| case 1u: { // AlphaOp: Premultiply | |
| srcColor = vec4<f32>(srcColor.rgb * srcColor.a, srcColor.a); | |
| break; | |
| } | |
| case 2u: { // AlphaOp: Unpremultiply | |
| if (srcColor.a != 0.0) { | |
| srcColor = vec4<f32>(srcColor.rgb / srcColor.a, srcColor.a); | |
| } | |
| break; | |
| } | |
| default: { | |
| break; | |
| } | |
| } | |
| // Not use loop and variable index format to workaround | |
| // crbug.com/tint/638. | |
| if (uniforms.channelCount == 2u) { // All have rg components. | |
| success = success && | |
| aboutEqual(dstColor.r, srcColor.r) && | |
| aboutEqual(dstColor.g, srcColor.g); | |
| } else { | |
| success = success && | |
| aboutEqual(dstColor.r, srcColor.r) && | |
| aboutEqual(dstColor.g, srcColor.g) && | |
| aboutEqual(dstColor.b, srcColor.b) && | |
| aboutEqual(dstColor.a, srcColor.a); | |
| } | |
| } | |
| let outputIndex = GlobalInvocationID.y * u32(dstSize.x) + GlobalInvocationID.x; | |
| if (success) { | |
| output.result[outputIndex] = 1u; | |
| } else { | |
| output.result[outputIndex] = 0u; | |
| } | |
| } | |
| )"); | |
| wgpu::ComputePipelineDescriptor csDesc; | |
| csDesc.compute.module = csModule; | |
| csDesc.compute.entryPoint = "main"; | |
| return device.CreateComputePipeline(&csDesc); | |
| } | |
| static uint32_t GetTextureFormatComponentCount(wgpu::TextureFormat format) { | |
| switch (format) { | |
| case wgpu::TextureFormat::RGBA8Unorm: | |
| case wgpu::TextureFormat::BGRA8Unorm: | |
| case wgpu::TextureFormat::RGB10A2Unorm: | |
| case wgpu::TextureFormat::RGBA16Float: | |
| case wgpu::TextureFormat::RGBA32Float: | |
| return 4; | |
| case wgpu::TextureFormat::RG8Unorm: | |
| case wgpu::TextureFormat::RG16Float: | |
| return 2; | |
| default: | |
| UNREACHABLE(); | |
| } | |
| } | |
| void DoColorConversionTest(const TextureSpec& srcSpec, const TextureSpec& dstSpec) { | |
| DoTest(srcSpec, dstSpec, {kDefaultTextureWidth, kDefaultTextureHeight}, {}, true); | |
| } | |
| void DoTest(const TextureSpec& srcSpec, | |
| const TextureSpec& dstSpec, | |
| const wgpu::Extent3D& copySize = {kDefaultTextureWidth, kDefaultTextureHeight}, | |
| const wgpu::CopyTextureForBrowserOptions options = {}, | |
| bool useFixedTestValue = false) { | |
| // Create and initialize src texture. | |
| wgpu::TextureDescriptor srcDescriptor; | |
| srcDescriptor.size = srcSpec.textureSize; | |
| srcDescriptor.format = srcSpec.format; | |
| srcDescriptor.mipLevelCount = srcSpec.level + 1; | |
| srcDescriptor.usage = wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::CopyDst | | |
| wgpu::TextureUsage::TextureBinding; | |
| wgpu::Texture srcTexture = device.CreateTexture(&srcDescriptor); | |
| const utils::TextureDataCopyLayout srcCopyLayout = | |
| utils::GetTextureDataCopyLayoutForTextureAtLevel( | |
| kTextureFormat, | |
| {srcSpec.textureSize.width, srcSpec.textureSize.height, | |
| copySize.depthOrArrayLayers}, | |
| srcSpec.level); | |
| std::vector<RGBA8> srcTextureArrayCopyData; | |
| if (useFixedTestValue) { // Use fixed value for color conversion tests. | |
| srcTextureArrayCopyData = GetFixedSourceTextureData(); | |
| } else { // For other tests, the input format is always kTextureFormat. | |
| srcTextureArrayCopyData = | |
| GetTextureData(srcCopyLayout, TextureCopyRole::SOURCE, options.alphaOp); | |
| } | |
| wgpu::ImageCopyTexture srcImageTextureInit = | |
| utils::CreateImageCopyTexture(srcTexture, srcSpec.level, {0, 0}); | |
| wgpu::TextureDataLayout srcTextureDataLayout; | |
| srcTextureDataLayout.offset = 0; | |
| srcTextureDataLayout.bytesPerRow = srcCopyLayout.bytesPerRow; | |
| srcTextureDataLayout.rowsPerImage = srcCopyLayout.rowsPerImage; | |
| device.GetQueue().WriteTexture(&srcImageTextureInit, srcTextureArrayCopyData.data(), | |
| srcTextureArrayCopyData.size() * sizeof(RGBA8), | |
| &srcTextureDataLayout, &srcCopyLayout.mipSize); | |
| bool testSubRectCopy = srcSpec.copyOrigin.x > 0 || srcSpec.copyOrigin.y > 0 || | |
| dstSpec.copyOrigin.x > 0 || dstSpec.copyOrigin.y > 0 || | |
| srcSpec.textureSize.width > copySize.width || | |
| srcSpec.textureSize.height > copySize.height || | |
| dstSpec.textureSize.width > copySize.width || | |
| dstSpec.textureSize.height > copySize.height; | |
| // Create and init dst texture. | |
| wgpu::Texture dstTexture; | |
| wgpu::TextureDescriptor dstDescriptor; | |
| dstDescriptor.size = dstSpec.textureSize; | |
| dstDescriptor.format = dstSpec.format; | |
| dstDescriptor.mipLevelCount = dstSpec.level + 1; | |
| dstDescriptor.usage = wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::TextureBinding | | |
| wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc; | |
| dstTexture = device.CreateTexture(&dstDescriptor); | |
| if (testSubRectCopy) { | |
| // For subrect copy tests, dst texture use kTextureFormat always. | |
| const utils::TextureDataCopyLayout dstCopyLayout = | |
| utils::GetTextureDataCopyLayoutForTextureAtLevel( | |
| kTextureFormat, | |
| {dstSpec.textureSize.width, dstSpec.textureSize.height, | |
| copySize.depthOrArrayLayers}, | |
| dstSpec.level); | |
| const std::vector<RGBA8> dstTextureArrayCopyData = | |
| GetTextureData(dstCopyLayout, TextureCopyRole::DEST); | |
| wgpu::TextureDataLayout dstTextureDataLayout; | |
| dstTextureDataLayout.offset = 0; | |
| dstTextureDataLayout.bytesPerRow = dstCopyLayout.bytesPerRow; | |
| dstTextureDataLayout.rowsPerImage = dstCopyLayout.rowsPerImage; | |
| wgpu::ImageCopyTexture dstImageTextureInit = | |
| utils::CreateImageCopyTexture(dstTexture, dstSpec.level, {0, 0}); | |
| device.GetQueue().WriteTexture(&dstImageTextureInit, dstTextureArrayCopyData.data(), | |
| dstTextureArrayCopyData.size() * sizeof(RGBA8), | |
| &dstTextureDataLayout, &dstCopyLayout.mipSize); | |
| } | |
| // Perform the texture to texture copy | |
| wgpu::ImageCopyTexture srcImageCopyTexture = | |
| utils::CreateImageCopyTexture(srcTexture, srcSpec.level, srcSpec.copyOrigin); | |
| wgpu::ImageCopyTexture dstImageCopyTexture = | |
| utils::CreateImageCopyTexture(dstTexture, dstSpec.level, dstSpec.copyOrigin); | |
| device.GetQueue().CopyTextureForBrowser(&srcImageCopyTexture, &dstImageCopyTexture, | |
| ©Size, &options); | |
| // Update uniform buffer based on test config | |
| uint32_t uniformBufferData[] = { | |
| options.flipY, // copy have flipY option | |
| GetTextureFormatComponentCount(dstSpec.format), // channelCount | |
| srcSpec.copyOrigin.x, | |
| srcSpec.copyOrigin.y, // src texture copy origin | |
| dstSpec.copyOrigin.x, | |
| dstSpec.copyOrigin.y, // dst texture copy origin | |
| copySize.width, | |
| copySize.height, // copy size | |
| static_cast<uint32_t>(options.alphaOp) // alphaOp | |
| }; | |
| device.GetQueue().WriteBuffer(uniformBuffer, 0, uniformBufferData, | |
| sizeof(uniformBufferData)); | |
| // Create output buffer to store result | |
| wgpu::BufferDescriptor outputDesc; | |
| outputDesc.size = dstSpec.textureSize.width * dstSpec.textureSize.height * sizeof(uint32_t); | |
| outputDesc.usage = | |
| wgpu::BufferUsage::Storage | wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst; | |
| wgpu::Buffer outputBuffer = device.CreateBuffer(&outputDesc); | |
| // Create texture views for test. | |
| wgpu::TextureViewDescriptor srcTextureViewDesc = {}; | |
| srcTextureViewDesc.baseMipLevel = srcSpec.level; | |
| wgpu::TextureView srcTextureView = srcTexture.CreateView(&srcTextureViewDesc); | |
| wgpu::TextureViewDescriptor dstTextureViewDesc = {}; | |
| dstTextureViewDesc.baseMipLevel = dstSpec.level; | |
| wgpu::TextureView dstTextureView = dstTexture.CreateView(&dstTextureViewDesc); | |
| // Create bind group based on the config. | |
| wgpu::BindGroup bindGroup = utils::MakeBindGroup( | |
| device, testPipeline.GetBindGroupLayout(0), | |
| {{0, srcTextureView}, {1, dstTextureView}, {2, outputBuffer}, {3, uniformBuffer}}); | |
| // Start a pipeline to check pixel value in bit form. | |
| wgpu::CommandEncoder testEncoder = device.CreateCommandEncoder(); | |
| wgpu::CommandBuffer testCommands; | |
| { | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); | |
| pass.SetPipeline(testPipeline); | |
| pass.SetBindGroup(0, bindGroup); | |
| pass.Dispatch(dstSpec.textureSize.width, | |
| dstSpec.textureSize.height); // Verify dst texture content | |
| pass.EndPass(); | |
| testCommands = encoder.Finish(); | |
| } | |
| queue.Submit(1, &testCommands); | |
| std::vector<uint32_t> expectResult(dstSpec.textureSize.width * dstSpec.textureSize.height, | |
| 1); | |
| EXPECT_BUFFER_U32_RANGE_EQ(expectResult.data(), outputBuffer, 0, | |
| dstSpec.textureSize.width * dstSpec.textureSize.height); | |
| } | |
| wgpu::Buffer uniformBuffer; // Uniform buffer to store dst texture meta info. | |
| wgpu::ComputePipeline testPipeline; | |
| }; | |
| // Verify CopyTextureForBrowserTests works with internal pipeline. | |
| // The case do copy without any transform. | |
| TEST_P(CopyTextureForBrowserTests, PassthroughCopy) { | |
| constexpr uint32_t kWidth = 10; | |
| constexpr uint32_t kHeight = 1; | |
| TextureSpec textureSpec; | |
| textureSpec.textureSize = {kWidth, kHeight}; | |
| DoTest(textureSpec, textureSpec, {kWidth, kHeight}); | |
| } | |
| TEST_P(CopyTextureForBrowserTests, VerifyCopyOnXDirection) { | |
| constexpr uint32_t kWidth = 1000; | |
| constexpr uint32_t kHeight = 1; | |
| TextureSpec textureSpec; | |
| textureSpec.textureSize = {kWidth, kHeight}; | |
| DoTest(textureSpec, textureSpec, {kWidth, kHeight}); | |
| } | |
| TEST_P(CopyTextureForBrowserTests, VerifyCopyOnYDirection) { | |
| constexpr uint32_t kWidth = 1; | |
| constexpr uint32_t kHeight = 1000; | |
| TextureSpec textureSpec; | |
| textureSpec.textureSize = {kWidth, kHeight}; | |
| DoTest(textureSpec, textureSpec, {kWidth, kHeight}); | |
| } | |
| TEST_P(CopyTextureForBrowserTests, VerifyCopyFromLargeTexture) { | |
| // TODO(crbug.com/dawn/1070): Flaky VK_DEVICE_LOST | |
| DAWN_SUPPRESS_TEST_IF(IsWindows() && IsVulkan() && IsIntel()); | |
| constexpr uint32_t kWidth = 899; | |
| constexpr uint32_t kHeight = 999; | |
| TextureSpec textureSpec; | |
| textureSpec.textureSize = {kWidth, kHeight}; | |
| DoTest(textureSpec, textureSpec, {kWidth, kHeight}); | |
| } | |
| TEST_P(CopyTextureForBrowserTests, VerifyFlipY) { | |
| constexpr uint32_t kWidth = 901; | |
| constexpr uint32_t kHeight = 1001; | |
| TextureSpec textureSpec; | |
| textureSpec.textureSize = {kWidth, kHeight}; | |
| wgpu::CopyTextureForBrowserOptions options = {}; | |
| options.flipY = true; | |
| DoTest(textureSpec, textureSpec, {kWidth, kHeight}, options); | |
| } | |
| TEST_P(CopyTextureForBrowserTests, VerifyFlipYInSlimTexture) { | |
| constexpr uint32_t kWidth = 1; | |
| constexpr uint32_t kHeight = 1001; | |
| TextureSpec textureSpec; | |
| textureSpec.textureSize = {kWidth, kHeight}; | |
| wgpu::CopyTextureForBrowserOptions options = {}; | |
| options.flipY = true; | |
| DoTest(textureSpec, textureSpec, {kWidth, kHeight}, options); | |
| } | |
| // Verify |CopyTextureForBrowser| doing color conversion correctly when | |
| // the source texture is RGBA8Unorm format. | |
| TEST_P(CopyTextureForBrowserTests, FromRGBA8UnormCopy) { | |
| // Skip OpenGLES backend because it fails on using RGBA8Unorm as | |
| // source texture format. | |
| DAWN_SUPPRESS_TEST_IF(IsOpenGLES()); | |
| for (wgpu::TextureFormat dstFormat : kDstTextureFormats) { | |
| TextureSpec srcTextureSpec = {}; // default format is RGBA8Unorm | |
| TextureSpec dstTextureSpec; | |
| dstTextureSpec.format = dstFormat; | |
| DoColorConversionTest(srcTextureSpec, dstTextureSpec); | |
| } | |
| } | |
| // Verify |CopyTextureForBrowser| doing color conversion correctly when | |
| // the source texture is BGRAUnorm format. | |
| TEST_P(CopyTextureForBrowserTests, FromBGRA8UnormCopy) { | |
| // Skip OpenGLES backend because it fails on using BGRA8Unorm as | |
| // source texture format. | |
| DAWN_SUPPRESS_TEST_IF(IsOpenGLES()); | |
| for (wgpu::TextureFormat dstFormat : kDstTextureFormats) { | |
| TextureSpec srcTextureSpec; | |
| srcTextureSpec.format = wgpu::TextureFormat::BGRA8Unorm; | |
| TextureSpec dstTextureSpec; | |
| dstTextureSpec.format = dstFormat; | |
| DoColorConversionTest(srcTextureSpec, dstTextureSpec); | |
| } | |
| } | |
| // Verify |CopyTextureForBrowser| doing subrect copy. | |
| // Source texture is a full red texture and dst texture is a full | |
| // green texture originally. After the subrect copy, affected part | |
| // in dst texture should be red and other part should remain green. | |
| TEST_P(CopyTextureForBrowserTests, CopySubRect) { | |
| // Tests skip due to crbug.com/dawn/592. | |
| DAWN_SUPPRESS_TEST_IF(IsD3D12() && IsBackendValidationEnabled()); | |
| // Tests skip due to crbug.com/dawn/1104. | |
| DAWN_SUPPRESS_TEST_IF(IsWARP()); | |
| for (wgpu::Origin3D srcOrigin : kOrigins) { | |
| for (wgpu::Origin3D dstOrigin : kOrigins) { | |
| for (wgpu::Extent3D copySize : kCopySizes) { | |
| for (bool flipY : {true, false}) { | |
| TextureSpec srcTextureSpec; | |
| srcTextureSpec.copyOrigin = srcOrigin; | |
| srcTextureSpec.textureSize = {6, 7}; | |
| TextureSpec dstTextureSpec; | |
| dstTextureSpec.copyOrigin = dstOrigin; | |
| dstTextureSpec.textureSize = {8, 5}; | |
| wgpu::CopyTextureForBrowserOptions options = {}; | |
| options.flipY = flipY; | |
| DoTest(srcTextureSpec, dstTextureSpec, copySize, options); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| // Verify |CopyTextureForBrowser| doing alphaOp. | |
| // Test alpha ops: DontChange, Premultiply, Unpremultiply. | |
| TEST_P(CopyTextureForBrowserTests, alphaOp) { | |
| // Skip OpenGLES backend because it fails on using RGBA8Unorm as | |
| // source texture format. | |
| DAWN_SUPPRESS_TEST_IF(IsOpenGLES()); | |
| // Tests skip due to crbug.com/dawn/1104. | |
| DAWN_SUPPRESS_TEST_IF(IsWARP()); | |
| constexpr uint32_t kWidth = 10; | |
| constexpr uint32_t kHeight = 10; | |
| TextureSpec textureSpec; | |
| textureSpec.textureSize = {kWidth, kHeight}; | |
| for (wgpu::AlphaOp alphaOp : kAlphaOps) { | |
| wgpu::CopyTextureForBrowserOptions options = {}; | |
| options.alphaOp = alphaOp; | |
| DoTest(textureSpec, textureSpec, {kWidth, kHeight}, options); | |
| } | |
| } | |
| DAWN_INSTANTIATE_TEST(CopyTextureForBrowserTests, | |
| D3D12Backend(), | |
| MetalBackend(), | |
| OpenGLBackend(), | |
| OpenGLESBackend(), | |
| VulkanBackend()); |