| /*------------------------------------------------------------------------ |
| * Vulkan Conformance Tests |
| * ------------------------ |
| * |
| * Copyright (c) 2018 Google Inc. |
| * Copyright (c) 2018 The Khronos Group Inc. |
| * Copyright (c) 2016 Samsung Electronics Co., Ltd. |
| * Copyright (c) 2014 The Android Open Source Project |
| * |
| * 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. |
| * |
| *//*! |
| * \file |
| * \brief Texture swizzle tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "vktTextureSwizzleTests.hpp" |
| |
| #include "vkImageUtil.hpp" |
| #include "vktTestGroupUtil.hpp" |
| #include "vktTextureTestUtil.hpp" |
| |
| namespace vkt |
| { |
| namespace texture |
| { |
| namespace |
| { |
| |
| using namespace vk; |
| using namespace glu::TextureTestUtil; |
| using namespace texture::util; |
| |
| using std::string; |
| using std::vector; |
| using tcu::TestLog; |
| |
| bool isDefaultComponentMapping (VkComponentMapping mapping) |
| { |
| if ((mapping.r == VK_COMPONENT_SWIZZLE_R || mapping.r == VK_COMPONENT_SWIZZLE_IDENTITY) && |
| (mapping.g == VK_COMPONENT_SWIZZLE_G || mapping.g == VK_COMPONENT_SWIZZLE_IDENTITY) && |
| (mapping.b == VK_COMPONENT_SWIZZLE_B || mapping.b == VK_COMPONENT_SWIZZLE_IDENTITY) && |
| (mapping.a == VK_COMPONENT_SWIZZLE_A || mapping.a == VK_COMPONENT_SWIZZLE_IDENTITY)) |
| return true; |
| else |
| return false; |
| } |
| |
| template <typename INSTANCE_TYPE> |
| class SwizzleTestCase : public TextureTestCase<INSTANCE_TYPE> |
| { |
| public: |
| SwizzleTestCase (tcu::TestContext& context, const std::string& name, const std::string& description, const typename INSTANCE_TYPE::ParameterType& testParameters) |
| : TextureTestCase<INSTANCE_TYPE> (context, name, description, testParameters) |
| {} |
| |
| virtual void initPrograms (vk::SourceCollections& programCollection) const |
| { |
| initializePrograms(programCollection, |
| this->m_testsParameters.texCoordPrecision, |
| this->m_testsParameters.programs, |
| this->m_testsParameters.texCoordSwizzle); |
| } |
| }; |
| |
| struct Swizzle2DTestParameters : public Texture2DTestCaseParameters |
| { |
| Swizzle2DTestParameters (void); |
| TextureBinding::ImageBackingMode backingMode; |
| vk::VkComponentMapping componentMapping; |
| const char* texCoordSwizzle; |
| const deUint8* texCoordMapping; |
| }; |
| |
| Swizzle2DTestParameters::Swizzle2DTestParameters (void) |
| : componentMapping (makeComponentMappingRGBA()) |
| , texCoordSwizzle (DE_NULL) |
| , texCoordMapping (DE_NULL) |
| { |
| } |
| |
| class Swizzle2DTestInstance : public TestInstance |
| { |
| public: |
| typedef Swizzle2DTestParameters ParameterType; |
| |
| Swizzle2DTestInstance (Context& context, |
| const ParameterType& testParameters); |
| tcu::TestStatus iterate (void); |
| |
| private: |
| Swizzle2DTestInstance (const Swizzle2DTestInstance& other); |
| Swizzle2DTestInstance& operator= (const Swizzle2DTestInstance& other); |
| |
| const ParameterType& m_testParameters; |
| const tcu::TextureFormat m_format; |
| const tcu::CompressedTexFormat m_compressedFormat; |
| TestTexture2DSp m_texture; |
| TextureRenderer m_renderer; |
| }; |
| |
| Swizzle2DTestInstance::Swizzle2DTestInstance (Context& context, |
| const ParameterType& testParameters) |
| : TestInstance (context) |
| , m_testParameters (testParameters) |
| , m_format (isCompressedFormat(m_testParameters.format) |
| ? tcu::TextureFormat() // Unused |
| : mapVkFormat(testParameters.format)) |
| , m_compressedFormat (isCompressedFormat(m_testParameters.format) |
| ? mapVkCompressedFormat(testParameters.format) |
| : tcu::CompressedTexFormat()) // Unused |
| , m_texture (TestTexture2DSp(isCompressedFormat(m_testParameters.format) |
| ? new pipeline::TestTexture2D(m_compressedFormat, testParameters.width, testParameters.height) |
| : new pipeline::TestTexture2D(m_format, testParameters.width, testParameters.height))) |
| , m_renderer (context, testParameters.sampleCount, testParameters.width, testParameters.height, testParameters.componentMapping) |
| { |
| m_renderer.add2DTexture(m_texture, testParameters.backingMode); |
| } |
| |
| tcu::TestStatus Swizzle2DTestInstance::iterate (void) |
| { |
| tcu::TestLog& log = m_context.getTestContext().getLog(); |
| const pipeline::TestTexture2D& texture = m_renderer.get2DTexture(0); |
| const tcu::TextureFormat textureFormat = texture.getTextureFormat(); |
| const float lookupScale = tcu::getTextureFormatInfo(textureFormat).lookupScale[0]; |
| const float lookupBias = tcu::getTextureFormatInfo(textureFormat).lookupBias[0]; |
| |
| ReferenceParams sampleParams (TEXTURETYPE_2D); |
| tcu::Surface rendered (m_renderer.getRenderWidth(), m_renderer.getRenderHeight()); |
| vector<float> texCoord; |
| |
| // Params for reference |
| sampleParams.sampler = util::createSampler(m_testParameters.wrapS, m_testParameters.wrapT, m_testParameters.minFilter, m_testParameters.magFilter); |
| sampleParams.samplerType = isCompressedFormat(m_testParameters.format) ? SAMPLERTYPE_FLOAT : getSamplerType(m_format); |
| sampleParams.lodMode = LODMODE_EXACT; |
| sampleParams.colorBias = tcu::Vec4(lookupBias); |
| sampleParams.colorScale = tcu::Vec4(lookupScale); |
| |
| if (sampleParams.colorBias != tcu::Vec4(0.0f)) |
| sampleParams.flags = RenderParams::USE_BIAS; |
| |
| log << TestLog::Message << "Compare reference value = " << sampleParams.ref << TestLog::EndMessage; |
| log << TestLog::Message << "Lookup scale = " << lookupScale << TestLog::EndMessage; |
| log << TestLog::Message << "Lookup bias = " << lookupBias << TestLog::EndMessage; |
| |
| computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f)); |
| m_renderer.renderQuad(rendered, 0, &texCoord[0], sampleParams); |
| |
| const tcu::IVec4 formatBitDepth = getTextureFormatBitDepth(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM)); |
| const tcu::PixelFormat pixelFormat (formatBitDepth[0], formatBitDepth[1], formatBitDepth[2], formatBitDepth[3]); |
| tcu::Surface referenceFrame (m_renderer.getRenderWidth(), m_renderer.getRenderHeight()); |
| |
| // Render reference (based on sampleTextureNonProjected in gluTextureTestUtil.cpp) |
| { |
| std::vector<tcu::ConstPixelBufferAccess> storage; |
| const tcu::Texture2DView src = getEffectiveTextureView(m_texture->getTexture(), storage, sampleParams.sampler); |
| const tcu::SurfaceAccess dst = tcu::SurfaceAccess(referenceFrame, pixelFormat); |
| |
| const tcu::IVec2 dstSize = tcu::IVec2(dst.getWidth(), dst.getHeight()); |
| const tcu::IVec2 srcSize = tcu::IVec2(src.getWidth(), src.getHeight()); |
| |
| const float lodBias = (sampleParams.flags & ReferenceParams::USE_BIAS) ? sampleParams.bias : 0.0f; |
| const tcu::Vec4 sq = tcu::Vec4(texCoord[0+0], texCoord[2+0], texCoord[4+0], texCoord[6+0]); |
| const tcu::Vec4 tq = tcu::Vec4(texCoord[0+1], texCoord[2+1], texCoord[4+1], texCoord[6+1]); |
| |
| tcu::Vec3 tri[2][2] = |
| { |
| { sq.swizzle(0, 1, 2), sq.swizzle(3, 2, 1) }, |
| { tq.swizzle(0, 1, 2), tq.swizzle(3, 2, 1) } |
| }; |
| |
| // Swizzle texture coordinates |
| if (m_testParameters.texCoordMapping) |
| { |
| const tcu::Vec3 swz[2][2] = |
| { |
| { tri[m_testParameters.texCoordMapping[0]][0], tri[m_testParameters.texCoordMapping[0]][1] }, |
| { tri[m_testParameters.texCoordMapping[1]][0], tri[m_testParameters.texCoordMapping[1]][1] } |
| }; |
| |
| memcpy(tri, swz, sizeof(tri)); |
| } |
| |
| // Coordinates and lod per triangle |
| const tcu::Vec3 triS[2] = { tri[0][0], tri[0][1] }; |
| const tcu::Vec3 triT[2] = { tri[1][0], tri[1][1] }; |
| const float triLod[2] = { de::clamp(computeNonProjectedTriLod(sampleParams.lodMode, dstSize, srcSize, triS[0], triT[0]) + lodBias, sampleParams.minLod, sampleParams.maxLod), |
| de::clamp(computeNonProjectedTriLod(sampleParams.lodMode, dstSize, srcSize, triS[1], triT[1]) + lodBias, sampleParams.minLod, sampleParams.maxLod) }; |
| |
| for (int y = 0; y < dstSize.y(); y++) |
| for (int x = 0; x < dstSize.x(); x++) |
| { |
| const float yf = ((float)y + 0.5f) / (float)dstSize.y(); |
| const float xf = ((float)x + 0.5f) / (float)dstSize.x(); |
| |
| const int triNdx = xf + yf >= 1.0f ? 1 : 0; // Top left fill rule |
| const float triX = triNdx ? 1.0f-xf : xf; |
| const float triY = triNdx ? 1.0f-yf : yf; |
| |
| const float s = triangleInterpolate(triS[triNdx].x(), triS[triNdx].y(), triS[triNdx].z(), triX, triY); |
| const float t = triangleInterpolate(triT[triNdx].x(), triT[triNdx].y(), triT[triNdx].z(), triX, triY); |
| const float lod = triLod[triNdx]; |
| |
| dst.setPixel(src.sample(sampleParams.sampler, s, t, lod) * sampleParams.colorScale + sampleParams.colorBias, x, y); |
| } |
| } |
| |
| // Reference component mapping swizzle |
| if (!isDefaultComponentMapping(m_testParameters.componentMapping)) |
| { |
| tcu::Surface swzSurface = referenceFrame; |
| const tcu::IVec4 bitDepth = getTextureFormatBitDepth(isCompressedFormat(m_testParameters.format) |
| ? getUncompressedFormat(m_compressedFormat) |
| : m_format); |
| const deUint8 one = deUint8(255.0f * (lookupScale + lookupBias)); |
| const deUint8 zero = deUint8(255.0f * lookupBias); |
| |
| const VkComponentSwizzle swizzle[] = |
| { |
| m_testParameters.componentMapping.r, |
| m_testParameters.componentMapping.g, |
| m_testParameters.componentMapping.b, |
| m_testParameters.componentMapping.a |
| }; |
| |
| log << TestLog::Message << "Format bit depth = " << bitDepth << TestLog::EndMessage; |
| log << TestLog::Message << "One = " << int(one) << TestLog::EndMessage; |
| log << TestLog::Message << "Zero = " << int(zero) << TestLog::EndMessage; |
| |
| for (int y = 0; y < m_testParameters.height; y++) |
| for (int x = 0; x < m_testParameters.width; x++) |
| { |
| const tcu::RGBA original = referenceFrame.getPixel(x, y); |
| tcu::IVec4 swizzled = original.toIVec(); |
| |
| for (int ndx = 0; ndx < 4; ndx++) |
| { |
| switch (swizzle[ndx]) |
| { |
| case VK_COMPONENT_SWIZZLE_ZERO: |
| swizzled[ndx] = zero; |
| break; |
| case VK_COMPONENT_SWIZZLE_ONE: |
| swizzled[ndx] = one; |
| break; |
| case VK_COMPONENT_SWIZZLE_R: |
| swizzled[ndx] = bitDepth[0] ? original.getRed() : zero; |
| break; |
| case VK_COMPONENT_SWIZZLE_G: |
| swizzled[ndx] = bitDepth[1] ? original.getGreen() : zero; |
| break; |
| case VK_COMPONENT_SWIZZLE_B: |
| swizzled[ndx] = bitDepth[2] ? original.getBlue() : zero; |
| break; |
| case VK_COMPONENT_SWIZZLE_A: |
| swizzled[ndx] = bitDepth[3] ? original.getAlpha() : one; |
| break; |
| default: |
| DE_ASSERT(swizzle[ndx] == VK_COMPONENT_SWIZZLE_IDENTITY); |
| } |
| } |
| |
| swzSurface.setPixel(x, y, tcu::RGBA(swizzled.x(), swizzled.y(), swizzled.z(), swizzled.w())); |
| } |
| |
| referenceFrame = swzSurface; |
| } |
| |
| // Compare and log |
| const tcu::RGBA threshold = pixelFormat.getColorThreshold() + tcu::RGBA(2, 2, 2, 2); |
| const bool isOk = compareImages(log, referenceFrame, rendered, threshold); |
| |
| return isOk ? tcu::TestStatus::pass("Pass") : tcu::TestStatus::fail("Image verification failed"); |
| } |
| |
| void populateTextureSwizzleTests (tcu::TestCaseGroup* textureSwizzleTests) |
| { |
| tcu::TestContext& testCtx = textureSwizzleTests->getTestContext(); |
| |
| static const struct{ |
| const VkFormat format; |
| const Program program; |
| } formats2D[] = |
| { |
| { VK_FORMAT_R4G4_UNORM_PACK8, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R4G4B4A4_UNORM_PACK16, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R5G6B5_UNORM_PACK16, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R5G5B5A1_UNORM_PACK16, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R8_UNORM, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R8_SNORM, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R8_USCALED, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R8_SSCALED, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R8_UINT, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R8_SINT, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R8_SRGB, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R8G8_UNORM, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R8G8_SNORM, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R8G8_USCALED, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R8G8_SSCALED, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R8G8_UINT, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R8G8_SINT, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R8G8_SRGB, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R8G8B8_UNORM, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R8G8B8_SNORM, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R8G8B8_USCALED, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R8G8B8_SSCALED, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R8G8B8_UINT, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R8G8B8_SINT, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R8G8B8_SRGB, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R8G8B8A8_UNORM, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R8G8B8A8_SNORM, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R8G8B8A8_USCALED, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R8G8B8A8_SSCALED, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R8G8B8A8_UINT, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R8G8B8A8_SINT, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R8G8B8A8_SRGB, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_A2R10G10B10_UNORM_PACK32, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_A2R10G10B10_UINT_PACK32, PROGRAM_2D_UINT }, |
| { VK_FORMAT_A2B10G10R10_USCALED_PACK32, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R16_UNORM, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R16_SNORM, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R16_USCALED, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R16_SSCALED, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R16_UINT, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R16_SINT, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R16_SFLOAT, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R16G16_UNORM, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R16G16_SNORM, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R16G16_USCALED, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R16G16_SSCALED, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R16G16_UINT, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R16G16_SINT, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R16G16_SFLOAT, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R16G16B16_UNORM, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R16G16B16_SNORM, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R16G16B16_USCALED, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R16G16B16_SSCALED, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R16G16B16_UINT, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R16G16B16_SINT, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R16G16B16_SFLOAT, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R16G16B16A16_UNORM, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_R16G16B16A16_SNORM, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R16G16B16A16_USCALED, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R16G16B16A16_SSCALED, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R16G16B16A16_UINT, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R16G16B16A16_SINT, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R16G16B16A16_SFLOAT, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R32_UINT, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R32_SINT, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R32_SFLOAT, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R32G32_UINT, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R32G32_SINT, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R32G32_SFLOAT, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R32G32B32_UINT, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R32G32B32_SINT, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R32G32B32_SFLOAT, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_R32G32B32A32_UINT, PROGRAM_2D_UINT }, |
| { VK_FORMAT_R32G32B32A32_SINT, PROGRAM_2D_INT_BIAS }, |
| { VK_FORMAT_R32G32B32A32_SFLOAT, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_B10G11R11_UFLOAT_PACK32, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_B4G4R4A4_UNORM_PACK16, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_B5G5R5A1_UNORM_PACK16, PROGRAM_2D_FLOAT }, |
| |
| // Compressed formats |
| { VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_EAC_R11_UNORM_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_EAC_R11_SNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_EAC_R11G11_UNORM_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_EAC_R11G11_SNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_4x4_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_4x4_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ASTC_5x4_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_5x4_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ASTC_5x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_5x5_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ASTC_6x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_6x5_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ASTC_6x6_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_6x6_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ASTC_8x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_8x5_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ASTC_8x6_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_8x6_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ASTC_8x8_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_8x8_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ASTC_10x5_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_10x5_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ASTC_10x6_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_10x6_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ASTC_10x8_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_10x8_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ASTC_10x10_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_10x10_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ASTC_12x10_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_12x10_SRGB_BLOCK, PROGRAM_2D_FLOAT }, |
| { VK_FORMAT_ASTC_12x12_UNORM_BLOCK, PROGRAM_2D_FLOAT_BIAS }, |
| { VK_FORMAT_ASTC_12x12_SRGB_BLOCK, PROGRAM_2D_FLOAT } |
| }; |
| |
| static const struct { |
| const char* name; |
| const deUint32 width; |
| const deUint32 height; |
| } sizes2D[] = |
| { |
| { "pot", 128, 64, }, |
| { "npot", 51, 65 }, |
| }; |
| |
| static const struct { |
| const char* name; |
| const TextureBinding::ImageBackingMode backingMode; |
| } backingModes[] = |
| { |
| { "", TextureBinding::IMAGE_BACKING_MODE_REGULAR }, |
| { "_sparse", TextureBinding::IMAGE_BACKING_MODE_SPARSE } |
| }; |
| |
| static const struct { |
| const char* name; |
| const VkComponentMapping componentMapping; |
| } componentMappings[] = |
| { |
| { "zzzz", {VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ZERO} }, |
| { "oooo", {VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_ONE} }, |
| { "rrrr", {VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_R} }, |
| { "gggg", {VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_G} }, |
| { "bbbb", {VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_B} }, |
| { "aaaa", {VK_COMPONENT_SWIZZLE_A, VK_COMPONENT_SWIZZLE_A, VK_COMPONENT_SWIZZLE_A, VK_COMPONENT_SWIZZLE_A} } |
| }; |
| |
| static const struct { |
| const char* swizzle; |
| const deUint8 mapping[2]; |
| } texCoordSwizzles2d[] = |
| { |
| { "yx", { 1, 0 } }, |
| { "xx", { 0, 0 } }, |
| { "yy", { 1, 1 } } |
| }; |
| |
| de::MovePtr<tcu::TestCaseGroup> groupCompMap (new tcu::TestCaseGroup(testCtx, "component_mapping", "Component mapping swizzles")); |
| de::MovePtr<tcu::TestCaseGroup> groupTexCoord (new tcu::TestCaseGroup(testCtx, "texture_coordinate", "Texture coordinate swizzles")); |
| |
| // 2D Component mapping swizzles |
| for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes2D); sizeNdx++) |
| for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats2D); formatNdx++) |
| for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); backingNdx++) |
| for (int mappingNdx = 0; mappingNdx < DE_LENGTH_OF_ARRAY(componentMappings); mappingNdx++) |
| { |
| const string formatStr = de::toString(getFormatStr(formats2D[formatNdx].format)); |
| const string caseDesc = formatStr + ", TEXTURETYPE_2D"; |
| const string caseName = de::toLower(formatStr.substr(10)) + "_2d" |
| + "_" + sizes2D[sizeNdx].name |
| + backingModes[backingNdx].name |
| + "_" + componentMappings[mappingNdx].name; |
| |
| Swizzle2DTestParameters testParameters; |
| testParameters.format = formats2D[formatNdx].format; |
| testParameters.backingMode = backingModes[backingNdx].backingMode; |
| testParameters.componentMapping = componentMappings[mappingNdx].componentMapping; |
| testParameters.width = sizes2D[sizeNdx].width; |
| testParameters.height = sizes2D[sizeNdx].height; |
| testParameters.minFilter = tcu::Sampler::NEAREST; |
| testParameters.magFilter = tcu::Sampler::NEAREST; |
| testParameters.programs.push_back(formats2D[formatNdx].program); |
| |
| groupCompMap->addChild(new SwizzleTestCase<Swizzle2DTestInstance>(testCtx, caseName.c_str(), caseDesc.c_str(), testParameters)); |
| } |
| |
| // 2D Texture coordinate swizzles |
| for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes2D); sizeNdx++) |
| for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats2D); formatNdx++) |
| for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); backingNdx++) |
| for (int swizzleNdx = 0; swizzleNdx < DE_LENGTH_OF_ARRAY(texCoordSwizzles2d); swizzleNdx++) |
| { |
| const string formatStr = de::toString(getFormatStr(formats2D[formatNdx].format)); |
| const string caseDesc = formatStr + ", TEXTURETYPE_2D"; |
| const string caseName = de::toLower(formatStr.substr(10)) + "_2d" |
| + "_" + sizes2D[sizeNdx].name |
| + backingModes[backingNdx].name |
| + "_" + texCoordSwizzles2d[swizzleNdx].swizzle; |
| |
| Swizzle2DTestParameters testParameters; |
| testParameters.format = formats2D[formatNdx].format; |
| testParameters.backingMode = backingModes[backingNdx].backingMode; |
| testParameters.componentMapping = makeComponentMappingRGBA(); |
| testParameters.texCoordSwizzle = texCoordSwizzles2d[swizzleNdx].swizzle; |
| testParameters.texCoordMapping = texCoordSwizzles2d[swizzleNdx].mapping; |
| testParameters.width = sizes2D[sizeNdx].width; |
| testParameters.height = sizes2D[sizeNdx].height; |
| testParameters.minFilter = tcu::Sampler::NEAREST; |
| testParameters.magFilter = tcu::Sampler::NEAREST; |
| testParameters.programs.push_back(formats2D[formatNdx].program); |
| |
| groupTexCoord->addChild(new SwizzleTestCase<Swizzle2DTestInstance>(testCtx, caseName.c_str(), caseDesc.c_str(), testParameters)); |
| } |
| |
| textureSwizzleTests->addChild(groupCompMap.release()); |
| textureSwizzleTests->addChild(groupTexCoord.release()); |
| } |
| |
| } // anonymous |
| |
| tcu::TestCaseGroup* createTextureSwizzleTests (tcu::TestContext& testCtx) |
| { |
| return createTestGroup(testCtx, "swizzle", "Texture swizzle tests.", populateTextureSwizzleTests); |
| } |
| |
| } // texture |
| } // vkt |