From: Boris Zanin Date: Mon, 30 Sep 2019 12:22:24 +0000 (+0200) Subject: Test multiple overlapping cube maps X-Git-Tag: upstream/1.3.5~1737 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=c6e107d67a46ddb4739efdbf590c17744035a688;p=platform%2Fupstream%2FVK-GL-CTS.git Test multiple overlapping cube maps Test cube map images containing multiple overlapping cube maps. Add tests: * dEQP-VK.image.misaligned_cube.* Components: vulkan VK-GL-CTS issue: 1889 Change-Id: I24eeba1eea1513e51cc3c4cd0b23d18e3ce8234d --- diff --git a/AndroidGen.mk b/AndroidGen.mk index ec75627..f5bc02a 100644 --- a/AndroidGen.mk +++ b/AndroidGen.mk @@ -159,6 +159,7 @@ LOCAL_SRC_FILES := \ external/vulkancts/modules/vulkan/image/vktImageCompressionTranscodingSupport.cpp \ external/vulkancts/modules/vulkan/image/vktImageLoadStoreTests.cpp \ external/vulkancts/modules/vulkan/image/vktImageLoadStoreUtil.cpp \ + external/vulkancts/modules/vulkan/image/vktImageMisalignedCubeTests.cpp \ external/vulkancts/modules/vulkan/image/vktImageMultisampleLoadStoreTests.cpp \ external/vulkancts/modules/vulkan/image/vktImageMutableTests.cpp \ external/vulkancts/modules/vulkan/image/vktImageQualifiersTests.cpp \ diff --git a/android/cts/master/vk-master.txt b/android/cts/master/vk-master.txt index 061c853..5bea6ae 100644 --- a/android/cts/master/vk-master.txt +++ b/android/cts/master/vk-master.txt @@ -387597,6 +387597,11 @@ dEQP-VK.image.extend_operands_spirv1p4.r8_sint_matching_extend dEQP-VK.image.extend_operands_spirv1p4.r8_sint_force_sign_extend dEQP-VK.image.extend_operands_spirv1p4.r8_sint_relaxed_matching_extend dEQP-VK.image.extend_operands_spirv1p4.r8_sint_relaxed_force_sign_extend +dEQP-VK.image.misaligned_cube.7 +dEQP-VK.image.misaligned_cube.8 +dEQP-VK.image.misaligned_cube.9 +dEQP-VK.image.misaligned_cube.10 +dEQP-VK.image.misaligned_cube.11 dEQP-VK.wsi.android.surface.create dEQP-VK.wsi.android.surface.create_custom_allocator dEQP-VK.wsi.android.surface.create_simulate_oom diff --git a/external/vulkancts/modules/vulkan/image/CMakeLists.txt b/external/vulkancts/modules/vulkan/image/CMakeLists.txt index 8845883..d4e32b1 100644 --- a/external/vulkancts/modules/vulkan/image/CMakeLists.txt +++ b/external/vulkancts/modules/vulkan/image/CMakeLists.txt @@ -25,6 +25,8 @@ set(DEQP_VK_IMAGE_SRCS vktImageLoadStoreUtil.hpp vktImageTranscodingSupportTests.cpp vktImageTranscodingSupportTests.hpp + vktImageMisalignedCubeTests.cpp + vktImageMisalignedCubeTests.hpp ) set(DEQP_VK_IMAGE_LIBS diff --git a/external/vulkancts/modules/vulkan/image/vktImageMisalignedCubeTests.cpp b/external/vulkancts/modules/vulkan/image/vktImageMisalignedCubeTests.cpp new file mode 100644 index 0000000..bbe97a7 --- /dev/null +++ b/external/vulkancts/modules/vulkan/image/vktImageMisalignedCubeTests.cpp @@ -0,0 +1,390 @@ +/*------------------------------------------------------------------------ + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2019 The Khronos Group Inc. + * Copyright (c) 2019 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 Cube image with misaligned baseArrayLayer tests + *//*--------------------------------------------------------------------*/ + +#include "vktImageMisalignedCubeTests.hpp" +#include "vktTestCaseUtil.hpp" +#include "vktImageTestsUtil.hpp" +#include "vktImageTexture.hpp" + +#include "vkDefs.hpp" +#include "vkRef.hpp" +#include "vkRefUtil.hpp" +#include "vkPlatform.hpp" +#include "vkPrograms.hpp" +#include "vkMemUtil.hpp" +#include "vkBarrierUtil.hpp" +#include "vkBuilderUtil.hpp" +#include "vkImageUtil.hpp" +#include "vkCmdUtil.hpp" +#include "vkObjUtil.hpp" +#include "vkTypeUtil.hpp" + +#include "deUniquePtr.hpp" +#include "deStringUtil.hpp" +#include "deMath.h" + +#include + +using namespace vk; + +namespace vkt +{ +namespace image +{ +namespace +{ + +inline VkImageCreateInfo makeImageCreateInfo (const tcu::IVec3& size, const VkFormat format) +{ + const VkImageUsageFlags usage = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; + const VkImageCreateInfo imageParams = + { + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, // VkImageCreateFlags flags; + VK_IMAGE_TYPE_2D, // VkImageType imageType; + format, // VkFormat format; + makeExtent3D(size.x(), size.y(), 1u), // VkExtent3D extent; + 1u, // deUint32 mipLevels; + (deUint32)size.z(), // deUint32 arrayLayers; + VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; + VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling; + usage, // VkImageUsageFlags usage; + VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; + 0u, // deUint32 queueFamilyIndexCount; + DE_NULL, // const deUint32* pQueueFamilyIndices; + VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout; + }; + + return imageParams; +} + +void fillBuffer (const DeviceInterface& vk, const VkDevice device, const Allocation& alloc, const VkDeviceSize offset, const VkDeviceSize size, const VkFormat format, const tcu::Vec4& color) +{ + const tcu::TextureFormat textureFormat = mapVkFormat(format); + const deUint32 colorPixelSize = static_cast(tcu::getPixelSize(textureFormat)); + tcu::TextureLevel colorPixelBuffer (textureFormat, 1, 1); + tcu::PixelBufferAccess colorPixel (colorPixelBuffer); + + colorPixel.setPixel(color, 0, 0); + + const deUint8* src = static_cast(colorPixel.getDataPtr()); + deUint8* dstBase = static_cast(alloc.getHostPtr()); + deUint8* dst = &dstBase[offset]; + + for (deUint32 pixelPos = 0; pixelPos < size; pixelPos += colorPixelSize) + deMemcpy(&dst[pixelPos], src, colorPixelSize); + + flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset() + offset, size); +} + +VkBufferImageCopy makeBufferImageCopy (const vk::VkDeviceSize& bufferOffset, + const vk::VkImageSubresourceLayers& imageSubresource, + const vk::VkOffset3D& imageOffset, + const vk::VkExtent3D& imageExtent) +{ + const VkBufferImageCopy copyParams = + { + bufferOffset, // VkDeviceSize bufferOffset; + 0u, // deUint32 bufferRowLength; + 0u, // deUint32 bufferImageHeight; + imageSubresource, // VkImageSubresourceLayers imageSubresource; + imageOffset, // VkOffset3D imageOffset; + imageExtent, // VkExtent3D imageExtent; + }; + return copyParams; +} + +//! Interpret the memory as IVec4 +inline tcu::Vec4 readVec4 (const void* const data, const deUint32 ndx) +{ + const float* const p = reinterpret_cast(data); + const deUint32 ofs = 4 * ndx; + + return tcu::Vec4(p[ofs+0], p[ofs+1], p[ofs+2], p[ofs+3]); +} + +class MisalignedCubeTestInstance : public TestInstance +{ +public: + MisalignedCubeTestInstance (Context& context, + const tcu::IVec3& size, + const VkFormat format); + tcu::TestStatus iterate (void); + +private: + const tcu::IVec3& m_size; + const VkFormat m_format; +}; + +MisalignedCubeTestInstance::MisalignedCubeTestInstance (Context& context, const tcu::IVec3& size, const VkFormat format) + : TestInstance (context) + , m_size (size) + , m_format (format) +{ +} + +tcu::TestStatus MisalignedCubeTestInstance::iterate (void) +{ + DE_ASSERT(de::inRange(m_size.z(), 6, 16)); + DE_ASSERT(m_format == VK_FORMAT_R8G8B8A8_UNORM); + + const DeviceInterface& vk = m_context.getDeviceInterface(); + const VkDevice device = m_context.getDevice(); + Allocator& allocator = m_context.getDefaultAllocator(); + const VkQueue queue = m_context.getUniversalQueue(); + const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); + const deUint32 numLayers = m_size.z(); + const deUint32 cube0LayerStart = 0; + const deUint32 cube1LayerStart = numLayers - 6u; + const VkDeviceSize resultBufferSizeBytes = 2 * 6 * 4 * sizeof(float); // vec4[6] in shader + const VkExtent3D imageExtent = makeExtent3D(m_size.x(), m_size.y(), 1u); + const deUint32 pixelSize = static_cast(tcu::getPixelSize(mapVkFormat(m_format))); + const deUint32 layerSize = imageExtent.width * imageExtent.height * pixelSize; + const float eps = 1.0f / float(2 * 256); + + const VkBufferCreateInfo resultBufferCreateInfo = makeBufferCreateInfo(resultBufferSizeBytes, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT); + de::MovePtr resultBuffer = de::MovePtr(new Buffer(vk, device, allocator, resultBufferCreateInfo, MemoryRequirement::HostVisible)); + const Allocation& resultBufferAlloc = resultBuffer->getAllocation(); + const VkImageCreateInfo imageCreateInfo = makeImageCreateInfo(m_size, m_format); + de::MovePtr image = de::MovePtr(new Image(vk, device, allocator, imageCreateInfo, MemoryRequirement::Any)); + const VkImageSubresourceRange imageSubresourceRange0 = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, cube0LayerStart, 6u); + Move imageView0 = makeImageView(vk, device, image->get(), VK_IMAGE_VIEW_TYPE_CUBE, m_format, imageSubresourceRange0); + const VkImageSubresourceRange imageSubresourceRange1 = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, cube1LayerStart, 6u); + Move imageView1 = makeImageView(vk, device, image->get(), VK_IMAGE_VIEW_TYPE_CUBE, m_format, imageSubresourceRange1); + + Move descriptorSetLayout = DescriptorSetLayoutBuilder() + .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT) + .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT) + .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT) + .build(vk, device); + Move descriptorPool = DescriptorPoolBuilder() + .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) + .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) + .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) + .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u); + Move descriptorSet = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout); + const VkDescriptorImageInfo descriptorImageInfo0 = makeDescriptorImageInfo(DE_NULL, *imageView0, VK_IMAGE_LAYOUT_GENERAL); + const VkDescriptorImageInfo descriptorImageInfo1 = makeDescriptorImageInfo(DE_NULL, *imageView1, VK_IMAGE_LAYOUT_GENERAL); + const VkDescriptorBufferInfo descriptorBufferInfo = makeDescriptorBufferInfo(resultBuffer->get(), 0ull, resultBufferSizeBytes); + + const Move shaderModule = createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0); + const Move pipelineLayout = makePipelineLayout(vk, device, *descriptorSetLayout); + const Move pipeline = makeComputePipeline(vk, device, *pipelineLayout, *shaderModule); + const Move cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex); + const Move cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY); + + const VkDeviceSize clearBufferSize = layerSize * numLayers; + const Move clearBuffer = makeBuffer(vk, device, clearBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT); + const de::MovePtr clearBufferAlloc = bindBuffer(vk, device, allocator, *clearBuffer, MemoryRequirement::HostVisible); + const VkImageSubresourceRange clearSubresRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, numLayers); + const VkImageMemoryBarrier clearBarrier = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, + VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + image->get(), clearSubresRange); + const VkImageMemoryBarrier preShaderImageBarrier = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, + image->get(), clearSubresRange); + const VkBufferMemoryBarrier postShaderBarrier = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, + resultBuffer->get(), 0ull, VK_WHOLE_SIZE); + bool result = true; + + DescriptorSetUpdateBuilder() + .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfo0) + .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfo1) + .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(2u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descriptorBufferInfo) + .update(vk, device); + + beginCommandBuffer(vk, *cmdBuffer); + + vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline); + vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &*descriptorSet, 0u, DE_NULL); + + vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &clearBarrier); + + // Clear layers with predefined values + for (deUint32 layerNdx = 0; layerNdx < numLayers; ++layerNdx) + { + const float componentValue = float(16 * layerNdx) / 255.0f; + const tcu::Vec4 clearColor = tcu::Vec4(componentValue, componentValue, componentValue, 1.0f); + const VkDeviceSize bufferOffset = layerNdx * layerSize; + const VkImageSubresourceLayers imageSubresource = makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, layerNdx, 1u); + const VkBufferImageCopy bufferImageCopyRegion = makeBufferImageCopy(bufferOffset, imageSubresource, makeOffset3D(0u, 0u, 0u), imageExtent); + + fillBuffer(vk, device, *clearBufferAlloc, bufferOffset, layerSize, m_format, clearColor); + + vk.cmdCopyBufferToImage(*cmdBuffer, *clearBuffer, image->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &bufferImageCopyRegion); + } + + vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &preShaderImageBarrier); + + vk.cmdDispatch(*cmdBuffer, 1, 1, 1); + + vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0, 0, DE_NULL, 1, &postShaderBarrier, 0, DE_NULL); + + endCommandBuffer(vk, *cmdBuffer); + + submitCommandsAndWait(vk, device, queue, *cmdBuffer); + + invalidateAlloc(vk, device, resultBufferAlloc); + + // Check cube 0 + for (deUint32 layerNdx = 0; layerNdx < 6; ++layerNdx) + { + const deUint32 layerUsed = cube0LayerStart + layerNdx; + const float componentValue = float(16 * layerUsed) / 255.0f; + const tcu::Vec4 expectedColor = tcu::Vec4(componentValue, componentValue, componentValue, 1.0f);; + const tcu::Vec4 resultColor = readVec4(resultBufferAlloc.getHostPtr(), layerNdx); + const tcu::Vec4 delta = expectedColor - resultColor; + + if (deFloatAbs(delta.x()) > eps || deFloatAbs(delta.y()) > eps || deFloatAbs(delta.z()) > eps || deFloatAbs(delta.w()) > eps) + result = false; + } + + // Check cube 1 + for (deUint32 layerNdx = 0; layerNdx < 6; ++layerNdx) + { + const deUint32 layerUsed = cube1LayerStart + layerNdx; + const float componentValue = float(16 * layerUsed) / 255.0f; + const tcu::Vec4 expectedColor = tcu::Vec4(componentValue, componentValue, componentValue, 1.0f);; + const tcu::Vec4 resultColor = readVec4(resultBufferAlloc.getHostPtr(), layerNdx + 6u); + const tcu::Vec4 delta = expectedColor - resultColor; + + if (deFloatAbs(delta.x()) > eps || deFloatAbs(delta.y()) > eps || deFloatAbs(delta.z()) > eps || deFloatAbs(delta.w()) > eps) + result = false; + } + + if (result) + return tcu::TestStatus::pass("pass"); + else + return tcu::TestStatus::fail("fail"); +} + +class MisalignedCubeTest : public TestCase +{ +public: + MisalignedCubeTest (tcu::TestContext& testCtx, + const std::string& name, + const std::string& description, + const tcu::IVec3& size, + const VkFormat format); + + void initPrograms (SourceCollections& programCollection) const; + TestInstance* createInstance (Context& context) const; + +private: + const tcu::IVec3 m_size; + const VkFormat m_format; +}; + +MisalignedCubeTest::MisalignedCubeTest (tcu::TestContext& testCtx, + const std::string& name, + const std::string& description, + const tcu::IVec3& size, + const VkFormat format) + : TestCase (testCtx, name, description) + , m_size (size) + , m_format (format) +{ +} + +void MisalignedCubeTest::initPrograms (SourceCollections& programCollection) const +{ + const std::string formatQualifierStr = getShaderImageFormatQualifier(mapVkFormat(m_format)); + + std::ostringstream src; + src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n" + << "\n" + << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" + << "layout (binding = 0, " << formatQualifierStr << ") " << "readonly uniform highp imageCube u_cubeImage0;\n" + << "layout (binding = 1, " << formatQualifierStr << ") " << "readonly uniform highp imageCube u_cubeImage1;\n" + << "layout (binding = 2) writeonly buffer Output\n" + << "{\n" + << " vec4 cube0_color0;\n" + << " vec4 cube0_color1;\n" + << " vec4 cube0_color2;\n" + << " vec4 cube0_color3;\n" + << " vec4 cube0_color4;\n" + << " vec4 cube0_color5;\n" + << " vec4 cube1_color0;\n" + << " vec4 cube1_color1;\n" + << " vec4 cube1_color2;\n" + << " vec4 cube1_color3;\n" + << " vec4 cube1_color4;\n" + << " vec4 cube1_color5;\n" + << "} sb_out;\n" + << "\n" + << "void main (void)\n" + << "{\n" + << " sb_out.cube0_color0 = imageLoad(u_cubeImage0, ivec3(1, 1, 0));\n" + << " sb_out.cube0_color1 = imageLoad(u_cubeImage0, ivec3(1, 1, 1));\n" + << " sb_out.cube0_color2 = imageLoad(u_cubeImage0, ivec3(1, 1, 2));\n" + << " sb_out.cube0_color3 = imageLoad(u_cubeImage0, ivec3(1, 1, 3));\n" + << " sb_out.cube0_color4 = imageLoad(u_cubeImage0, ivec3(1, 1, 4));\n" + << " sb_out.cube0_color5 = imageLoad(u_cubeImage0, ivec3(1, 1, 5));\n" + << " sb_out.cube1_color0 = imageLoad(u_cubeImage1, ivec3(1, 1, 0));\n" + << " sb_out.cube1_color1 = imageLoad(u_cubeImage1, ivec3(1, 1, 1));\n" + << " sb_out.cube1_color2 = imageLoad(u_cubeImage1, ivec3(1, 1, 2));\n" + << " sb_out.cube1_color3 = imageLoad(u_cubeImage1, ivec3(1, 1, 3));\n" + << " sb_out.cube1_color4 = imageLoad(u_cubeImage1, ivec3(1, 1, 4));\n" + << " sb_out.cube1_color5 = imageLoad(u_cubeImage1, ivec3(1, 1, 5));\n" + << "}\n"; + + programCollection.glslSources.add("comp") << glu::ComputeSource(src.str()); +} + +TestInstance* MisalignedCubeTest::createInstance (Context& context) const +{ + return new MisalignedCubeTestInstance(context, m_size, m_format); +} + +//! Base sizes used to generate actual imager sizes in the test. +static const tcu::IVec3 s_baseImageSizes[] = +{ + tcu::IVec3(16, 16, 7), + tcu::IVec3(16, 16, 8), + tcu::IVec3(16, 16, 9), + tcu::IVec3(16, 16, 10), + tcu::IVec3(16, 16, 11), +}; + +} // anonymous ns + +tcu::TestCaseGroup* createMisalignedCubeTests (tcu::TestContext& testCtx) +{ + de::MovePtr testGroup(new tcu::TestCaseGroup(testCtx, "misaligned_cube", "Cube image with misaligned baseArrayLayer test cases")); + + const VkFormat format = VK_FORMAT_R8G8B8A8_UNORM; + + for (int imageSizeNdx = 0; imageSizeNdx < DE_LENGTH_OF_ARRAY(s_baseImageSizes); ++imageSizeNdx) + { + const tcu::IVec3 size = s_baseImageSizes[imageSizeNdx]; + + testGroup->addChild(new MisalignedCubeTest(testCtx, de::toString(size.z()), "", size, format)); + } + + return testGroup.release(); +} + +} // image +} // vkt diff --git a/external/vulkancts/modules/vulkan/image/vktImageMisalignedCubeTests.hpp b/external/vulkancts/modules/vulkan/image/vktImageMisalignedCubeTests.hpp new file mode 100644 index 0000000..9fb303d --- /dev/null +++ b/external/vulkancts/modules/vulkan/image/vktImageMisalignedCubeTests.hpp @@ -0,0 +1,39 @@ +#ifndef _VKTIMAGEMISALIGNEDCUBETESTS_HPP +#define _VKTIMAGEMISALIGNEDCUBETESTS_HPP +/*------------------------------------------------------------------------ + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2019 The Khronos Group Inc. + * + * 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 Cube image with misaligned baseArrayLayer tests + *//*--------------------------------------------------------------------*/ + +#include "tcuDefs.hpp" +#include "vktTestCase.hpp" + +namespace vkt +{ +namespace image +{ + +tcu::TestCaseGroup* createMisalignedCubeTests (tcu::TestContext& testCtx); + +} // image +} // vkt + +#endif // _VKTIMAGEMISALIGNEDCUBETESTS_HPP diff --git a/external/vulkancts/modules/vulkan/image/vktImageTests.cpp b/external/vulkancts/modules/vulkan/image/vktImageTests.cpp index 58165f0..223e718 100644 --- a/external/vulkancts/modules/vulkan/image/vktImageTests.cpp +++ b/external/vulkancts/modules/vulkan/image/vktImageTests.cpp @@ -31,6 +31,7 @@ #include "vktImageAtomicOperationTests.hpp" #include "vktImageCompressionTranscodingSupport.hpp" #include "vktImageTranscodingSupportTests.hpp" +#include "vktImageMisalignedCubeTests.hpp" namespace vkt { @@ -56,6 +57,7 @@ void createChildren (tcu::TestCaseGroup* imageTests) imageTests->addChild(createImageCompressionTranscodingTests(testCtx)); imageTests->addChild(createImageTranscodingSupportTests(testCtx)); imageTests->addChild(createImageExtendOperandsTests(testCtx)); + imageTests->addChild(createMisalignedCubeTests(testCtx)); } } // anonymous diff --git a/external/vulkancts/mustpass/master/vk-default-no-waivers.txt b/external/vulkancts/mustpass/master/vk-default-no-waivers.txt index 91420c3..413f88f 100644 --- a/external/vulkancts/mustpass/master/vk-default-no-waivers.txt +++ b/external/vulkancts/mustpass/master/vk-default-no-waivers.txt @@ -387614,6 +387614,11 @@ dEQP-VK.image.extend_operands_spirv1p4.r8_sint_matching_extend dEQP-VK.image.extend_operands_spirv1p4.r8_sint_force_sign_extend dEQP-VK.image.extend_operands_spirv1p4.r8_sint_relaxed_matching_extend dEQP-VK.image.extend_operands_spirv1p4.r8_sint_relaxed_force_sign_extend +dEQP-VK.image.misaligned_cube.7 +dEQP-VK.image.misaligned_cube.8 +dEQP-VK.image.misaligned_cube.9 +dEQP-VK.image.misaligned_cube.10 +dEQP-VK.image.misaligned_cube.11 dEQP-VK.wsi.xlib.surface.create dEQP-VK.wsi.xlib.surface.create_custom_allocator dEQP-VK.wsi.xlib.surface.create_simulate_oom diff --git a/external/vulkancts/mustpass/master/vk-default.txt b/external/vulkancts/mustpass/master/vk-default.txt index aba6a6e..42b991f 100644 --- a/external/vulkancts/mustpass/master/vk-default.txt +++ b/external/vulkancts/mustpass/master/vk-default.txt @@ -387575,6 +387575,11 @@ dEQP-VK.image.extend_operands_spirv1p4.r8_sint_matching_extend dEQP-VK.image.extend_operands_spirv1p4.r8_sint_force_sign_extend dEQP-VK.image.extend_operands_spirv1p4.r8_sint_relaxed_matching_extend dEQP-VK.image.extend_operands_spirv1p4.r8_sint_relaxed_force_sign_extend +dEQP-VK.image.misaligned_cube.7 +dEQP-VK.image.misaligned_cube.8 +dEQP-VK.image.misaligned_cube.9 +dEQP-VK.image.misaligned_cube.10 +dEQP-VK.image.misaligned_cube.11 dEQP-VK.wsi.xlib.surface.create dEQP-VK.wsi.xlib.surface.create_custom_allocator dEQP-VK.wsi.xlib.surface.create_simulate_oom