+const VkFormat compatibleFormats8Bit[] =
+{
+ VK_FORMAT_R4G4_UNORM_PACK8,
+ VK_FORMAT_R8_UNORM,
+ VK_FORMAT_R8_SNORM,
+ VK_FORMAT_R8_USCALED,
+ VK_FORMAT_R8_SSCALED,
+ VK_FORMAT_R8_UINT,
+ VK_FORMAT_R8_SINT,
+ VK_FORMAT_R8_SRGB,
+
+ VK_FORMAT_UNDEFINED
+};
+const VkFormat compatibleFormats16Bit[] =
+{
+ VK_FORMAT_R4G4B4A4_UNORM_PACK16,
+ VK_FORMAT_B4G4R4A4_UNORM_PACK16,
+ VK_FORMAT_R5G6B5_UNORM_PACK16,
+ VK_FORMAT_B5G6R5_UNORM_PACK16,
+ VK_FORMAT_R5G5B5A1_UNORM_PACK16,
+ VK_FORMAT_B5G5R5A1_UNORM_PACK16,
+ VK_FORMAT_A1R5G5B5_UNORM_PACK16,
+ VK_FORMAT_R8G8_UNORM,
+ VK_FORMAT_R8G8_SNORM,
+ VK_FORMAT_R8G8_USCALED,
+ VK_FORMAT_R8G8_SSCALED,
+ VK_FORMAT_R8G8_UINT,
+ VK_FORMAT_R8G8_SINT,
+ VK_FORMAT_R8G8_SRGB,
+ VK_FORMAT_R16_UNORM,
+ VK_FORMAT_R16_SNORM,
+ VK_FORMAT_R16_USCALED,
+ VK_FORMAT_R16_SSCALED,
+ VK_FORMAT_R16_UINT,
+ VK_FORMAT_R16_SINT,
+ VK_FORMAT_R16_SFLOAT,
+
+ VK_FORMAT_UNDEFINED
+};
+const VkFormat compatibleFormats24Bit[] =
+{
+ VK_FORMAT_R8G8B8_UNORM,
+ VK_FORMAT_R8G8B8_SNORM,
+ VK_FORMAT_R8G8B8_USCALED,
+ VK_FORMAT_R8G8B8_SSCALED,
+ VK_FORMAT_R8G8B8_UINT,
+ VK_FORMAT_R8G8B8_SINT,
+ VK_FORMAT_R8G8B8_SRGB,
+ VK_FORMAT_B8G8R8_UNORM,
+ VK_FORMAT_B8G8R8_SNORM,
+ VK_FORMAT_B8G8R8_USCALED,
+ VK_FORMAT_B8G8R8_SSCALED,
+ VK_FORMAT_B8G8R8_UINT,
+ VK_FORMAT_B8G8R8_SINT,
+ VK_FORMAT_B8G8R8_SRGB,
+
+ VK_FORMAT_UNDEFINED
+};
+const VkFormat compatibleFormats32Bit[] =
+{
+ VK_FORMAT_R8G8B8A8_UNORM,
+ VK_FORMAT_R8G8B8A8_SNORM,
+ VK_FORMAT_R8G8B8A8_USCALED,
+ VK_FORMAT_R8G8B8A8_SSCALED,
+ VK_FORMAT_R8G8B8A8_UINT,
+ VK_FORMAT_R8G8B8A8_SINT,
+ VK_FORMAT_R8G8B8A8_SRGB,
+ VK_FORMAT_B8G8R8A8_UNORM,
+ VK_FORMAT_B8G8R8A8_SNORM,
+ VK_FORMAT_B8G8R8A8_USCALED,
+ VK_FORMAT_B8G8R8A8_SSCALED,
+ VK_FORMAT_B8G8R8A8_UINT,
+ VK_FORMAT_B8G8R8A8_SINT,
+ VK_FORMAT_B8G8R8A8_SRGB,
+ VK_FORMAT_A8B8G8R8_UNORM_PACK32,
+ VK_FORMAT_A8B8G8R8_SNORM_PACK32,
+ VK_FORMAT_A8B8G8R8_USCALED_PACK32,
+ VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
+ VK_FORMAT_A8B8G8R8_UINT_PACK32,
+ VK_FORMAT_A8B8G8R8_SINT_PACK32,
+ VK_FORMAT_A8B8G8R8_SRGB_PACK32,
+ VK_FORMAT_A2R10G10B10_UNORM_PACK32,
+ VK_FORMAT_A2R10G10B10_SNORM_PACK32,
+ VK_FORMAT_A2R10G10B10_USCALED_PACK32,
+ VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
+ VK_FORMAT_A2R10G10B10_UINT_PACK32,
+ VK_FORMAT_A2R10G10B10_SINT_PACK32,
+ VK_FORMAT_A2B10G10R10_UNORM_PACK32,
+ VK_FORMAT_A2B10G10R10_SNORM_PACK32,
+ VK_FORMAT_A2B10G10R10_USCALED_PACK32,
+ VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
+ VK_FORMAT_A2B10G10R10_UINT_PACK32,
+ VK_FORMAT_A2B10G10R10_SINT_PACK32,
+ VK_FORMAT_R16G16_UNORM,
+ VK_FORMAT_R16G16_SNORM,
+ VK_FORMAT_R16G16_USCALED,
+ VK_FORMAT_R16G16_SSCALED,
+ VK_FORMAT_R16G16_UINT,
+ VK_FORMAT_R16G16_SINT,
+ VK_FORMAT_R16G16_SFLOAT,
+ VK_FORMAT_R32_UINT,
+ VK_FORMAT_R32_SINT,
+ VK_FORMAT_R32_SFLOAT,
+
+ VK_FORMAT_UNDEFINED
+};
+const VkFormat compatibleFormats48Bit[] =
+{
+ VK_FORMAT_R16G16B16_UNORM,
+ VK_FORMAT_R16G16B16_SNORM,
+ VK_FORMAT_R16G16B16_USCALED,
+ VK_FORMAT_R16G16B16_SSCALED,
+ VK_FORMAT_R16G16B16_UINT,
+ VK_FORMAT_R16G16B16_SINT,
+ VK_FORMAT_R16G16B16_SFLOAT,
+
+ VK_FORMAT_UNDEFINED
+};
+const VkFormat compatibleFormats64Bit[] =
+{
+ VK_FORMAT_R16G16B16A16_UNORM,
+ VK_FORMAT_R16G16B16A16_SNORM,
+ VK_FORMAT_R16G16B16A16_USCALED,
+ VK_FORMAT_R16G16B16A16_SSCALED,
+ VK_FORMAT_R16G16B16A16_UINT,
+ VK_FORMAT_R16G16B16A16_SINT,
+ VK_FORMAT_R16G16B16A16_SFLOAT,
+ VK_FORMAT_R32G32_UINT,
+ VK_FORMAT_R32G32_SINT,
+ VK_FORMAT_R32G32_SFLOAT,
+ VK_FORMAT_R64_UINT,
+ VK_FORMAT_R64_SINT,
+ VK_FORMAT_R64_SFLOAT,
+
+ VK_FORMAT_UNDEFINED
+};
+const VkFormat compatibleFormats96Bit[] =
+{
+ VK_FORMAT_R32G32B32_UINT,
+ VK_FORMAT_R32G32B32_SINT,
+ VK_FORMAT_R32G32B32_SFLOAT,
+
+ VK_FORMAT_UNDEFINED
+};
+const VkFormat compatibleFormats128Bit[] =
+{
+ VK_FORMAT_R32G32B32A32_UINT,
+ VK_FORMAT_R32G32B32A32_SINT,
+ VK_FORMAT_R32G32B32A32_SFLOAT,
+ VK_FORMAT_R64G64_UINT,
+ VK_FORMAT_R64G64_SINT,
+ VK_FORMAT_R64G64_SFLOAT,
+
+ VK_FORMAT_UNDEFINED
+};
+const VkFormat compatibleFormats192Bit[] =
+{
+ VK_FORMAT_R64G64B64_UINT,
+ VK_FORMAT_R64G64B64_SINT,
+ VK_FORMAT_R64G64B64_SFLOAT,
+
+ VK_FORMAT_UNDEFINED
+};
+const VkFormat compatibleFormats256Bit[] =
+{
+ VK_FORMAT_R64G64B64A64_UINT,
+ VK_FORMAT_R64G64B64A64_SINT,
+ VK_FORMAT_R64G64B64A64_SFLOAT,
+
+ VK_FORMAT_UNDEFINED
+};
+
+const VkFormat* colorImageFormatsToTest[] =
+{
+ compatibleFormats8Bit,
+ compatibleFormats16Bit,
+ compatibleFormats24Bit,
+ compatibleFormats32Bit,
+ compatibleFormats48Bit,
+ compatibleFormats64Bit,
+ compatibleFormats96Bit,
+ compatibleFormats128Bit,
+ compatibleFormats192Bit,
+ compatibleFormats256Bit,
+};
+
+const VkFormat dedicatedAllocationImageToImageFormatsToTest[] =
+{
+ // From compatibleFormats8Bit
+ VK_FORMAT_R4G4_UNORM_PACK8,
+ VK_FORMAT_R8_SRGB,
+
+ // From compatibleFormats16Bit
+ VK_FORMAT_R4G4B4A4_UNORM_PACK16,
+ VK_FORMAT_R16_SFLOAT,
+
+ // From compatibleFormats24Bit
+ VK_FORMAT_R8G8B8_UNORM,
+ VK_FORMAT_B8G8R8_SRGB,
+
+ // From compatibleFormats32Bit
+ VK_FORMAT_R8G8B8A8_UNORM,
+ VK_FORMAT_R32_SFLOAT,
+
+ // From compatibleFormats48Bit
+ VK_FORMAT_R16G16B16_UNORM,
+ VK_FORMAT_R16G16B16_SFLOAT,
+
+ // From compatibleFormats64Bit
+ VK_FORMAT_R16G16B16A16_UNORM,
+ VK_FORMAT_R64_SFLOAT,
+
+ // From compatibleFormats96Bit
+ VK_FORMAT_R32G32B32_UINT,
+ VK_FORMAT_R32G32B32_SFLOAT,
+
+ // From compatibleFormats128Bit
+ VK_FORMAT_R32G32B32A32_UINT,
+ VK_FORMAT_R64G64_SFLOAT,
+
+ // From compatibleFormats192Bit
+ VK_FORMAT_R64G64B64_UINT,
+ VK_FORMAT_R64G64B64_SFLOAT,
+
+ // From compatibleFormats256Bit
+ VK_FORMAT_R64G64B64A64_UINT,
+ VK_FORMAT_R64G64B64A64_SFLOAT,
+};
+
+void addImageToImageAllFormatsColorTests (tcu::TestCaseGroup* group, AllocationKind allocationKind)
+{
+ TestParams params;
+ params.src.image.imageType = VK_IMAGE_TYPE_2D;
+ params.src.image.extent = defaultExtent;
+ params.dst.image.imageType = VK_IMAGE_TYPE_2D;
+ params.dst.image.extent = defaultExtent;
+ params.allocationKind = allocationKind;
+
+ for (deInt32 i = 0; i < defaultSize; i += defaultFourthSize)
+ {
+ const VkImageCopy testCopy =
+ {
+ defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
+ {0, 0, 0}, // VkOffset3D srcOffset;
+ defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
+ {i, defaultSize - i - defaultFourthSize, 0}, // VkOffset3D dstOffset;
+ {defaultFourthSize, defaultFourthSize, 1}, // VkExtent3D extent;
+ };
+
+ CopyRegion imageCopy;
+ imageCopy.imageCopy = testCopy;
+
+ params.regions.push_back(imageCopy);
+ }
+
+ if (allocationKind == ALLOCATION_KIND_DEDICATED)
+ {
+ const int numOfColorImageFormatsToTestFilter = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
+ for (int compatibleFormatsIndex = 0; compatibleFormatsIndex < numOfColorImageFormatsToTestFilter; ++compatibleFormatsIndex)
+ dedicatedAllocationImageToImageFormatsToTestSet.insert(dedicatedAllocationImageToImageFormatsToTest[compatibleFormatsIndex]);
+ }
+
+ const int numOfColorImageFormatsToTest = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
+ for (int compatibleFormatsIndex = 0; compatibleFormatsIndex < numOfColorImageFormatsToTest; ++compatibleFormatsIndex)
+ {
+ const VkFormat* compatibleFormats = colorImageFormatsToTest[compatibleFormatsIndex];
+ for (int srcFormatIndex = 0; compatibleFormats[srcFormatIndex] != VK_FORMAT_UNDEFINED; ++srcFormatIndex)
+ {
+ params.src.image.format = compatibleFormats[srcFormatIndex];
+ if (!isSupportedByFramework(params.src.image.format))
+ continue;
+
+ CopyColorTestParams testParams;
+ testParams.params = params;
+ testParams.compatibleFormats = compatibleFormats;
+
+ const std::string description = "Copy from source format " + getFormatCaseName(params.src.image.format);
+ addTestGroup(group, getFormatCaseName(params.src.image.format), description, addImageToImageAllFormatsColorSrcFormatTests, testParams);
+ }
+ }
+}
+
+void addImageToImageAllFormatsDepthStencilFormatsTests (tcu::TestCaseGroup* group, TestParams params)
+{
+ const VkImageLayout copySrcLayouts[] =
+ {
+ VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+ VK_IMAGE_LAYOUT_GENERAL
+ };
+ const VkImageLayout copyDstLayouts[] =
+ {
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+ VK_IMAGE_LAYOUT_GENERAL
+ };
+
+ for (int srcLayoutNdx = 0u; srcLayoutNdx < DE_LENGTH_OF_ARRAY(copySrcLayouts); ++srcLayoutNdx)
+ {
+ params.src.image.operationLayout = copySrcLayouts[srcLayoutNdx];
+ for (int dstLayoutNdx = 0u; dstLayoutNdx < DE_LENGTH_OF_ARRAY(copyDstLayouts); ++dstLayoutNdx)
+ {
+ params.dst.image.operationLayout = copyDstLayouts[dstLayoutNdx];
+
+ const std::string testName = getImageLayoutCaseName(params.src.image.operationLayout) + "_" +
+ getImageLayoutCaseName(params.dst.image.operationLayout);
+ const std::string description = "From layout " + getImageLayoutCaseName(params.src.image.operationLayout) +
+ " to " + getImageLayoutCaseName(params.dst.image.operationLayout);
+ group->addChild(new CopyImageToImageTestCase(group->getTestContext(), testName, description, params));
+ }
+ }
+}
+
+void addImageToImageAllFormatsDepthStencilTests (tcu::TestCaseGroup* group, AllocationKind allocationKind)
+{
+ const VkFormat depthAndStencilFormats[] =
+ {
+ VK_FORMAT_D16_UNORM,
+ VK_FORMAT_X8_D24_UNORM_PACK32,
+ VK_FORMAT_D32_SFLOAT,
+ VK_FORMAT_S8_UINT,
+ VK_FORMAT_D16_UNORM_S8_UINT,
+ VK_FORMAT_D24_UNORM_S8_UINT,
+ VK_FORMAT_D32_SFLOAT_S8_UINT,
+ };
+
+ for (int compatibleFormatsIndex = 0; compatibleFormatsIndex < DE_LENGTH_OF_ARRAY(depthAndStencilFormats); ++compatibleFormatsIndex)
+ {
+ TestParams params;
+ params.src.image.imageType = VK_IMAGE_TYPE_2D;
+ params.dst.image.imageType = VK_IMAGE_TYPE_2D;
+ params.src.image.extent = defaultExtent;
+ params.dst.image.extent = defaultExtent;
+ params.src.image.format = depthAndStencilFormats[compatibleFormatsIndex];
+ params.dst.image.format = params.src.image.format;
+ params.allocationKind = allocationKind;
+
+ const VkImageSubresourceLayers defaultDepthSourceLayer = { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 0u, 1u };
+ const VkImageSubresourceLayers defaultStencilSourceLayer = { VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 0u, 1u };
+
+ for (deInt32 i = 0; i < defaultSize; i += defaultFourthSize)
+ {
+ CopyRegion copyRegion;
+ const VkOffset3D srcOffset = {0, 0, 0};
+ const VkOffset3D dstOffset = {i, defaultSize - i - defaultFourthSize, 0};
+ const VkExtent3D extent = {defaultFourthSize, defaultFourthSize, 1};
+
+ if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
+ {
+ const VkImageCopy testCopy =
+ {
+ defaultDepthSourceLayer, // VkImageSubresourceLayers srcSubresource;
+ srcOffset, // VkOffset3D srcOffset;
+ defaultDepthSourceLayer, // VkImageSubresourceLayers dstSubresource;
+ dstOffset, // VkOffset3D dstOffset;
+ extent, // VkExtent3D extent;
+ };
+
+ copyRegion.imageCopy = testCopy;
+ params.regions.push_back(copyRegion);
+ }
+ if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
+ {
+ const VkImageCopy testCopy =
+ {
+ defaultStencilSourceLayer, // VkImageSubresourceLayers srcSubresource;
+ srcOffset, // VkOffset3D srcOffset;
+ defaultStencilSourceLayer, // VkImageSubresourceLayers dstSubresource;
+ dstOffset, // VkOffset3D dstOffset;
+ extent, // VkExtent3D extent;
+ };
+
+ copyRegion.imageCopy = testCopy;
+ params.regions.push_back(copyRegion);
+ }
+ }
+
+ const std::string testName = getFormatCaseName(params.src.image.format) + "_" + getFormatCaseName(params.dst.image.format);
+ const std::string description = "Copy from " + getFormatCaseName(params.src.image.format) + " to " + getFormatCaseName(params.dst.image.format);
+ addTestGroup(group, testName, description, addImageToImageAllFormatsDepthStencilFormatsTests, params);
+ }
+}
+
+void addImageToImageAllFormatsTests (tcu::TestCaseGroup* group, AllocationKind allocationKind)
+{
+ addTestGroup(group, "color", "Copy image to image with color formats", addImageToImageAllFormatsColorTests, allocationKind);
+ addTestGroup(group, "depth_stencil", "Copy image to image with depth/stencil formats", addImageToImageAllFormatsDepthStencilTests, allocationKind);
+}
+
+void addImageToImage3dImagesTests (tcu::TestCaseGroup* group, AllocationKind allocationKind)
+{
+ tcu::TestContext& testCtx = group->getTestContext();
+
+ {
+ TestParams params3DTo2D;
+ const deUint32 slicesLayers = 16u;
+ params3DTo2D.src.image.imageType = VK_IMAGE_TYPE_3D;
+ params3DTo2D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
+ params3DTo2D.src.image.extent = defaultHalfExtent;
+ params3DTo2D.src.image.extent.depth = slicesLayers;
+ params3DTo2D.src.image.operationLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+ params3DTo2D.dst.image.imageType = VK_IMAGE_TYPE_2D;
+ params3DTo2D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
+ params3DTo2D.dst.image.extent = defaultHalfExtent;
+ params3DTo2D.dst.image.extent.depth = slicesLayers;
+ params3DTo2D.dst.image.operationLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+ params3DTo2D.allocationKind = allocationKind;
+
+ for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
+ {
+ const VkImageSubresourceLayers sourceLayer =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // uint32_t mipLevel;
+ 0u, // uint32_t baseArrayLayer;
+ 1u // uint32_t layerCount;
+ };
+
+ const VkImageSubresourceLayers destinationLayer =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // uint32_t mipLevel;
+ slicesLayersNdx, // uint32_t baseArrayLayer;
+ 1u // uint32_t layerCount;
+ };
+
+ const VkImageCopy testCopy =
+ {
+ sourceLayer, // VkImageSubresourceLayers srcSubresource;
+ {0, 0, (deInt32)slicesLayersNdx}, // VkOffset3D srcOffset;
+ destinationLayer, // VkImageSubresourceLayers dstSubresource;
+ {0, 0, 0}, // VkOffset3D dstOffset;
+ defaultHalfExtent, // VkExtent3D extent;
+ };
+
+ CopyRegion imageCopy;
+ imageCopy.imageCopy = testCopy;
+
+ params3DTo2D.regions.push_back(imageCopy);
+ }
+ group->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_by_slices", "copy 2d layers to 3d slices one by one", params3DTo2D));
+ }
+
+ {
+ TestParams params2DTo3D;
+ const deUint32 slicesLayers = 16u;
+ params2DTo3D.src.image.imageType = VK_IMAGE_TYPE_2D;
+ params2DTo3D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
+ params2DTo3D.src.image.extent = defaultHalfExtent;
+ params2DTo3D.src.image.extent.depth = slicesLayers;
+ params2DTo3D.src.image.operationLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+ params2DTo3D.dst.image.imageType = VK_IMAGE_TYPE_3D;
+ params2DTo3D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
+ params2DTo3D.dst.image.extent = defaultHalfExtent;
+ params2DTo3D.dst.image.extent.depth = slicesLayers;
+ params2DTo3D.dst.image.operationLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+ params2DTo3D.allocationKind = allocationKind;
+
+ for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
+ {
+ const VkImageSubresourceLayers sourceLayer =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // uint32_t mipLevel;
+ slicesLayersNdx, // uint32_t baseArrayLayer;
+ 1u // uint32_t layerCount;
+ };
+
+ const VkImageSubresourceLayers destinationLayer =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // uint32_t mipLevel;
+ 0u, // uint32_t baseArrayLayer;
+ 1u // uint32_t layerCount;
+ };
+
+ const VkImageCopy testCopy =
+ {
+ sourceLayer, // VkImageSubresourceLayers srcSubresource;
+ {0, 0, 0}, // VkOffset3D srcOffset;
+ destinationLayer, // VkImageSubresourceLayers dstSubresource;
+ {0, 0, (deInt32)slicesLayersNdx}, // VkOffset3D dstOffset;
+ defaultHalfExtent, // VkExtent3D extent;
+ };
+
+ CopyRegion imageCopy;
+ imageCopy.imageCopy = testCopy;
+
+ params2DTo3D.regions.push_back(imageCopy);
+ }
+
+ group->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_by_layers", "copy 3d slices to 2d layers one by one", params2DTo3D));
+ }
+
+ {
+ TestParams params3DTo2D;
+ const deUint32 slicesLayers = 16u;
+ params3DTo2D.src.image.imageType = VK_IMAGE_TYPE_3D;
+ params3DTo2D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
+ params3DTo2D.src.image.extent = defaultHalfExtent;
+ params3DTo2D.src.image.extent.depth = slicesLayers;
+ params3DTo2D.src.image.operationLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+ params3DTo2D.dst.image.imageType = VK_IMAGE_TYPE_2D;
+ params3DTo2D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
+ params3DTo2D.dst.image.extent = defaultHalfExtent;
+ params3DTo2D.dst.image.extent.depth = slicesLayers;
+ params3DTo2D.dst.image.operationLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+ params3DTo2D.allocationKind = allocationKind;
+
+ {
+ const VkImageSubresourceLayers sourceLayer =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // uint32_t mipLevel;
+ 0u, // uint32_t baseArrayLayer;
+ 1u // uint32_t layerCount;
+ };
+
+ const VkImageSubresourceLayers destinationLayer =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // uint32_t mipLevel;
+ 0, // uint32_t baseArrayLayer;
+ slicesLayers // uint32_t layerCount;
+ };
+
+ const VkImageCopy testCopy =
+ {
+ sourceLayer, // VkImageSubresourceLayers srcSubresource;
+ {0, 0, 0}, // VkOffset3D srcOffset;
+ destinationLayer, // VkImageSubresourceLayers dstSubresource;
+ {0, 0, 0}, // VkOffset3D dstOffset;
+ params3DTo2D.src.image.extent // VkExtent3D extent;
+ };
+
+ CopyRegion imageCopy;
+ imageCopy.imageCopy = testCopy;
+
+ params3DTo2D.regions.push_back(imageCopy);
+ }
+ group->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_whole", "copy 3d slices to 2d layers all at once", params3DTo2D));
+ }
+
+ {
+ TestParams params2DTo3D;
+ const deUint32 slicesLayers = 16u;
+ params2DTo3D.src.image.imageType = VK_IMAGE_TYPE_2D;
+ params2DTo3D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
+ params2DTo3D.src.image.extent = defaultHalfExtent;
+ params2DTo3D.src.image.extent.depth = slicesLayers;
+ params2DTo3D.src.image.operationLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+ params2DTo3D.dst.image.imageType = VK_IMAGE_TYPE_3D;
+ params2DTo3D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
+ params2DTo3D.dst.image.extent = defaultHalfExtent;
+ params2DTo3D.dst.image.extent.depth = slicesLayers;
+ params2DTo3D.dst.image.operationLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+ params2DTo3D.allocationKind = allocationKind;
+
+ {
+ const VkImageSubresourceLayers sourceLayer =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // uint32_t mipLevel;
+ 0u, // uint32_t baseArrayLayer;
+ slicesLayers // uint32_t layerCount;
+ };
+
+ const VkImageSubresourceLayers destinationLayer =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // uint32_t mipLevel;
+ 0u, // uint32_t baseArrayLayer;
+ 1u // uint32_t layerCount;
+ };
+
+ const VkImageCopy testCopy =
+ {
+ sourceLayer, // VkImageSubresourceLayers srcSubresource;
+ {0, 0, 0}, // VkOffset3D srcOffset;
+ destinationLayer, // VkImageSubresourceLayers dstSubresource;
+ {0, 0, 0}, // VkOffset3D dstOffset;
+ params2DTo3D.dst.image.extent, // VkExtent3D extent;
+ };
+
+ CopyRegion imageCopy;
+ imageCopy.imageCopy = testCopy;
+
+ params2DTo3D.regions.push_back(imageCopy);
+ }
+
+ group->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_whole", "copy 2d layers to 3d slices all at once", params2DTo3D));
+ }
+
+ {
+ TestParams params3DTo2D;
+ const deUint32 slicesLayers = 16u;
+ params3DTo2D.src.image.imageType = VK_IMAGE_TYPE_3D;
+ params3DTo2D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
+ params3DTo2D.src.image.extent = defaultHalfExtent;
+ params3DTo2D.src.image.extent.depth = slicesLayers;
+ params3DTo2D.src.image.operationLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+ params3DTo2D.dst.image.imageType = VK_IMAGE_TYPE_2D;
+ params3DTo2D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
+ params3DTo2D.dst.image.extent = defaultHalfExtent;
+ params3DTo2D.dst.image.extent.depth = slicesLayers;
+ params3DTo2D.dst.image.operationLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+ params3DTo2D.allocationKind = allocationKind;
+
+ const deUint32 regionWidth = defaultHalfExtent.width / slicesLayers -1;
+ const deUint32 regionHeight = defaultHalfExtent.height / slicesLayers -1 ;
+
+ for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
+ {
+ const VkImageSubresourceLayers sourceLayer =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // uint32_t mipLevel;
+ 0u, // uint32_t baseArrayLayer;
+ 1u // uint32_t layerCount;
+ };
+
+ const VkImageSubresourceLayers destinationLayer =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // uint32_t mipLevel;
+ slicesLayersNdx, // uint32_t baseArrayLayer;
+ 1u // uint32_t layerCount;
+ };
+
+
+ const VkImageCopy testCopy =
+ {
+ sourceLayer, // VkImageSubresourceLayers srcSubresource;
+ {0, (deInt32)(regionHeight*slicesLayersNdx), (deInt32)slicesLayersNdx}, // VkOffset3D srcOffset;
+ destinationLayer, // VkImageSubresourceLayers dstSubresource;
+ {(deInt32)(regionWidth*slicesLayersNdx), 0, 0}, // VkOffset3D dstOffset;
+ {
+ (defaultHalfExtent.width - regionWidth*slicesLayersNdx),
+ (defaultHalfExtent.height - regionHeight*slicesLayersNdx),
+ 1
+ } // VkExtent3D extent;
+ };
+
+ CopyRegion imageCopy;
+ imageCopy.imageCopy = testCopy;
+ params3DTo2D.regions.push_back(imageCopy);
+ }
+ group->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_regions", "copy 3d slices regions to 2d layers", params3DTo2D));
+ }
+
+ {
+ TestParams params2DTo3D;
+ const deUint32 slicesLayers = 16u;
+ params2DTo3D.src.image.imageType = VK_IMAGE_TYPE_2D;
+ params2DTo3D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
+ params2DTo3D.src.image.extent = defaultHalfExtent;
+ params2DTo3D.src.image.extent.depth = slicesLayers;
+ params2DTo3D.src.image.operationLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+ params2DTo3D.dst.image.imageType = VK_IMAGE_TYPE_3D;
+ params2DTo3D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
+ params2DTo3D.dst.image.extent = defaultHalfExtent;
+ params2DTo3D.dst.image.extent.depth = slicesLayers;
+ params2DTo3D.dst.image.operationLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+ params2DTo3D.allocationKind = allocationKind;
+
+ const deUint32 regionWidth = defaultHalfExtent.width / slicesLayers -1;
+ const deUint32 regionHeight = defaultHalfExtent.height / slicesLayers -1 ;
+
+ for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
+ {
+ const VkImageSubresourceLayers sourceLayer =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // uint32_t mipLevel;
+ slicesLayersNdx, // uint32_t baseArrayLayer;
+ 1u // uint32_t layerCount;
+ };
+
+ const VkImageSubresourceLayers destinationLayer =
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // uint32_t mipLevel;
+ 0u, // uint32_t baseArrayLayer;
+ 1u // uint32_t layerCount;
+ };
+
+ const VkImageCopy testCopy =
+ {
+ sourceLayer, // VkImageSubresourceLayers srcSubresource;
+ {(deInt32)(regionWidth*slicesLayersNdx), 0, 0}, // VkOffset3D srcOffset;
+ destinationLayer, // VkImageSubresourceLayers dstSubresource;
+ {0, (deInt32)(regionHeight*slicesLayersNdx), (deInt32)(slicesLayersNdx)}, // VkOffset3D dstOffset;
+ {
+ defaultHalfExtent.width - regionWidth*slicesLayersNdx,
+ defaultHalfExtent.height - regionHeight*slicesLayersNdx,
+ 1
+ } // VkExtent3D extent;
+ };
+
+ CopyRegion imageCopy;
+ imageCopy.imageCopy = testCopy;
+
+ params2DTo3D.regions.push_back(imageCopy);
+ }
+
+ group->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_regions", "copy 2d layers regions to 3d slices", params2DTo3D));
+ }
+}
+
+void addImageToImageTests (tcu::TestCaseGroup* group, AllocationKind allocationKind)
+{
+ addTestGroup(group, "simple_tests", "Copy from image to image simple tests", addImageToImageSimpleTests, allocationKind);
+ addTestGroup(group, "all_formats", "Copy from image to image with all compatible formats", addImageToImageAllFormatsTests, allocationKind);
+ addTestGroup(group, "3d_images", "Coping operations on 3d images", addImageToImage3dImagesTests, allocationKind);
+}
+
+void addImageToBufferTests (tcu::TestCaseGroup* group, AllocationKind allocationKind)
+{
+ tcu::TestContext& testCtx = group->getTestContext();
+
+ {
+ TestParams params;
+ params.src.image.imageType = VK_IMAGE_TYPE_2D;
+ params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
+ params.src.image.extent = defaultExtent;
+ params.src.image.operationLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+ params.dst.buffer.size = defaultSize * defaultSize;
+ params.allocationKind = allocationKind;
+
+ const VkBufferImageCopy bufferImageCopy =
+ {
+ 0u, // VkDeviceSize bufferOffset;
+ 0u, // uint32_t bufferRowLength;