From: Pyry Haulos Date: Thu, 10 Sep 2015 17:06:01 +0000 (-0700) Subject: Merge Google and Khronos branches X-Git-Tag: upstream/0.1.0~812^2~604 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=1c74f9b8877b4dd8db711cb8362a5f43048b9bd7;p=platform%2Fupstream%2FVK-GL-CTS.git Merge Google and Khronos branches Change-Id: I293012b71a0f994ce7301b8171d3bf031d0bdbf2 --- 1c74f9b8877b4dd8db711cb8362a5f43048b9bd7 diff --cc external/vulkancts/framework/vulkan/vkImageUtil.cpp index ab76fd0,c05645d..015577a --- a/external/vulkancts/framework/vulkan/vkImageUtil.cpp +++ b/external/vulkancts/framework/vulkan/vkImageUtil.cpp @@@ -1,9 -1,8 +1,10 @@@ - /*------------------------------------------------------------------------ - * Vulkan Conformance Tests - * ------------------------ + /*------------------------------------------------------------------------- + * Vulkan CTS Framework + * -------------------- * + * Copyright (c) 2015 The Khronos Group Inc. + * Copyright (c) 2015 Imagination Technologies Ltd. + * Copyright (c) 2015 Google Inc. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and/or associated documentation files (the @@@ -34,286 -33,201 +35,326 @@@ *//*--------------------------------------------------------------------*/ #include "vkImageUtil.hpp" - #include "vkMemUtil.hpp" - #include "vkQueryUtil.hpp" - #include "vkRefUtil.hpp" +#include "tcuTextureUtil.hpp" namespace vk { -using tcu::TextureFormat; +bool isFloatFormat (VkFormat format) +{ + return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_FLOATING_POINT; +} + +bool isUnormFormat (VkFormat format) +{ + return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; +} + +bool isSnormFormat (VkFormat format) +{ + return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT; +} + +bool isIntFormat (VkFormat format) +{ + return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER; +} + +bool isUintFormat (VkFormat format) +{ + return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER; +} + +bool isDepthStencilFormat (VkFormat format) +{ + const tcu::TextureFormat tcuFormat = mapVkFormat(format); + return tcuFormat.order == tcu::TextureFormat::D || tcuFormat.order == tcu::TextureFormat::S || tcuFormat.order == tcu::TextureFormat::DS; +} + +bool isCompressedFormat (VkFormat format) +{ + switch (format) + { + case VK_FORMAT_BC1_RGBA_SRGB: + case VK_FORMAT_BC1_RGBA_UNORM: + case VK_FORMAT_BC1_RGB_SRGB: + case VK_FORMAT_BC1_RGB_UNORM: + case VK_FORMAT_BC2_UNORM: + case VK_FORMAT_BC2_SRGB: + case VK_FORMAT_BC3_UNORM: + case VK_FORMAT_BC3_SRGB: + case VK_FORMAT_BC4_UNORM: + case VK_FORMAT_BC4_SNORM: + case VK_FORMAT_BC5_UNORM: + case VK_FORMAT_BC5_SNORM: + case VK_FORMAT_BC6H_UFLOAT: + case VK_FORMAT_BC6H_SFLOAT: + case VK_FORMAT_BC7_UNORM: + case VK_FORMAT_BC7_SRGB: + case VK_FORMAT_ETC2_R8G8B8_UNORM: + case VK_FORMAT_ETC2_R8G8B8A1_UNORM: + case VK_FORMAT_ETC2_R8G8B8A8_UNORM: + case VK_FORMAT_EAC_R11_UNORM: + case VK_FORMAT_EAC_R11_SNORM: + case VK_FORMAT_EAC_R11G11_UNORM: + case VK_FORMAT_EAC_R11G11_SNORM: + case VK_FORMAT_ASTC_4x4_UNORM: + case VK_FORMAT_ASTC_4x4_SRGB: + case VK_FORMAT_ASTC_5x4_UNORM: + case VK_FORMAT_ASTC_5x4_SRGB: + case VK_FORMAT_ASTC_5x5_UNORM: + case VK_FORMAT_ASTC_5x5_SRGB: + case VK_FORMAT_ASTC_6x5_UNORM: + case VK_FORMAT_ASTC_6x5_SRGB: + case VK_FORMAT_ASTC_6x6_UNORM: + case VK_FORMAT_ASTC_6x6_SRGB: + case VK_FORMAT_ASTC_8x5_UNORM: + case VK_FORMAT_ASTC_8x5_SRGB: + case VK_FORMAT_ASTC_8x6_UNORM: + case VK_FORMAT_ASTC_8x6_SRGB: + case VK_FORMAT_ASTC_8x8_UNORM: + case VK_FORMAT_ASTC_8x8_SRGB: + case VK_FORMAT_ASTC_10x5_UNORM: + case VK_FORMAT_ASTC_10x5_SRGB: + case VK_FORMAT_ASTC_10x6_UNORM: + case VK_FORMAT_ASTC_10x6_SRGB: + case VK_FORMAT_ASTC_10x8_UNORM: + case VK_FORMAT_ASTC_10x8_SRGB: + case VK_FORMAT_ASTC_10x10_UNORM: + case VK_FORMAT_ASTC_10x10_SRGB: + case VK_FORMAT_ASTC_12x10_UNORM: + case VK_FORMAT_ASTC_12x10_SRGB: + case VK_FORMAT_ASTC_12x12_UNORM: + case VK_FORMAT_ASTC_12x12_SRGB: + return true; + default: + break; + } + return false; +} + VkFormat mapTextureFormat (const tcu::TextureFormat& format) + { + DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST < (1<<16)); + DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELTYPE_LAST < (1<<16)); + + #define PACK_FMT(ORDER, TYPE) ((int(ORDER) << 16) | int(TYPE)) + #define FMT_CASE(ORDER, TYPE) PACK_FMT(tcu::TextureFormat::ORDER, tcu::TextureFormat::TYPE) + + switch (PACK_FMT(format.order, format.type)) + { + case FMT_CASE(RGB, UNORM_SHORT_565): return VK_FORMAT_R5G6B5_UNORM; + case FMT_CASE(RGBA, UNORM_SHORT_5551): return VK_FORMAT_R5G5B5A1_UNORM; + + case FMT_CASE(R, UNORM_INT8): return VK_FORMAT_R8_UNORM; + case FMT_CASE(R, SNORM_INT8): return VK_FORMAT_R8_SNORM; + case FMT_CASE(R, UNSIGNED_INT8): return VK_FORMAT_R8_UINT; + case FMT_CASE(R, SIGNED_INT8): return VK_FORMAT_R8_SINT; + case FMT_CASE(sR, UNORM_INT8): return VK_FORMAT_R8_SRGB; + + case FMT_CASE(RG, UNORM_INT8): return VK_FORMAT_R8G8_UNORM; + case FMT_CASE(RG, SNORM_INT8): return VK_FORMAT_R8G8_SNORM; + case FMT_CASE(RG, UNSIGNED_INT8): return VK_FORMAT_R8G8_UINT; + case FMT_CASE(RG, SIGNED_INT8): return VK_FORMAT_R8G8_SINT; + case FMT_CASE(sRG, SIGNED_INT8): return VK_FORMAT_R8G8_SRGB; + + case FMT_CASE(RGB, UNORM_INT8): return VK_FORMAT_R8G8B8_UNORM; + case FMT_CASE(RGB, SNORM_INT8): return VK_FORMAT_R8G8B8_SNORM; + case FMT_CASE(RGB, UNSIGNED_INT8): return VK_FORMAT_R8G8B8_UINT; + case FMT_CASE(RGB, SIGNED_INT8): return VK_FORMAT_R8G8B8_SINT; + case FMT_CASE(sRGB, SNORM_INT8): return VK_FORMAT_R8G8B8_SRGB; + + case FMT_CASE(RGBA, UNORM_INT8): return VK_FORMAT_R8G8B8A8_UNORM; + case FMT_CASE(RGBA, SNORM_INT8): return VK_FORMAT_R8G8B8A8_SNORM; + case FMT_CASE(RGBA, UNSIGNED_INT8): return VK_FORMAT_R8G8B8A8_UINT; + case FMT_CASE(RGBA, SIGNED_INT8): return VK_FORMAT_R8G8B8A8_SINT; + case FMT_CASE(sRGBA, SNORM_INT8): return VK_FORMAT_R8G8B8A8_SRGB; + + case FMT_CASE(RGBA, UNORM_INT_1010102_REV): return VK_FORMAT_R10G10B10A2_UNORM; + case FMT_CASE(RGBA, UNSIGNED_INT_1010102_REV): return VK_FORMAT_R10G10B10A2_UINT; + + case FMT_CASE(R, UNORM_INT16): return VK_FORMAT_R16_UNORM; + case FMT_CASE(R, SNORM_INT16): return VK_FORMAT_R16_SNORM; + case FMT_CASE(R, UNSIGNED_INT16): return VK_FORMAT_R16_UINT; + case FMT_CASE(R, SIGNED_INT16): return VK_FORMAT_R16_SINT; + case FMT_CASE(R, HALF_FLOAT): return VK_FORMAT_R16_SFLOAT; + + case FMT_CASE(RG, UNORM_INT16): return VK_FORMAT_R16G16_UNORM; + case FMT_CASE(RG, SNORM_INT16): return VK_FORMAT_R16G16_SNORM; + case FMT_CASE(RG, UNSIGNED_INT16): return VK_FORMAT_R16G16_UINT; + case FMT_CASE(RG, SIGNED_INT16): return VK_FORMAT_R16G16_SINT; + case FMT_CASE(RG, HALF_FLOAT): return VK_FORMAT_R16G16_SFLOAT; + + case FMT_CASE(RGB, UNORM_INT16): return VK_FORMAT_R16G16B16_UNORM; + case FMT_CASE(RGB, SNORM_INT16): return VK_FORMAT_R16G16B16_SNORM; + case FMT_CASE(RGB, UNSIGNED_INT16): return VK_FORMAT_R16G16B16_UINT; + case FMT_CASE(RGB, SIGNED_INT16): return VK_FORMAT_R16G16B16_SINT; + case FMT_CASE(RGB, HALF_FLOAT): return VK_FORMAT_R16G16B16_SFLOAT; + + case FMT_CASE(RGBA, UNORM_INT16): return VK_FORMAT_R16G16B16A16_UNORM; + case FMT_CASE(RGBA, SNORM_INT16): return VK_FORMAT_R16G16B16A16_SNORM; + case FMT_CASE(RGBA, UNSIGNED_INT16): return VK_FORMAT_R16G16B16A16_UINT; + case FMT_CASE(RGBA, SIGNED_INT16): return VK_FORMAT_R16G16B16A16_SINT; + case FMT_CASE(RGBA, HALF_FLOAT): return VK_FORMAT_R16G16B16A16_SFLOAT; + + case FMT_CASE(R, UNSIGNED_INT32): return VK_FORMAT_R32_UINT; + case FMT_CASE(R, SIGNED_INT32): return VK_FORMAT_R32_SINT; + case FMT_CASE(R, FLOAT): return VK_FORMAT_R32_SFLOAT; + + case FMT_CASE(RG, UNSIGNED_INT32): return VK_FORMAT_R32G32_UINT; + case FMT_CASE(RG, SIGNED_INT32): return VK_FORMAT_R32G32_SINT; + case FMT_CASE(RG, FLOAT): return VK_FORMAT_R32G32_SFLOAT; + + case FMT_CASE(RGB, UNSIGNED_INT32): return VK_FORMAT_R32G32B32_UINT; + case FMT_CASE(RGB, SIGNED_INT32): return VK_FORMAT_R32G32B32_SINT; + case FMT_CASE(RGB, FLOAT): return VK_FORMAT_R32G32B32_SFLOAT; + + case FMT_CASE(RGBA, UNSIGNED_INT32): return VK_FORMAT_R32G32B32A32_UINT; + case FMT_CASE(RGBA, SIGNED_INT32): return VK_FORMAT_R32G32B32A32_SINT; + case FMT_CASE(RGBA, FLOAT): return VK_FORMAT_R32G32B32A32_SFLOAT; + + case FMT_CASE(RGB, UNSIGNED_INT_11F_11F_10F_REV): return VK_FORMAT_R11G11B10_UFLOAT; + case FMT_CASE(RGB, UNSIGNED_INT_999_E5_REV): return VK_FORMAT_R9G9B9E5_UFLOAT; + + case FMT_CASE(D, UNORM_INT16): return VK_FORMAT_D16_UNORM; + case FMT_CASE(D, UNORM_INT24): return VK_FORMAT_D24_UNORM; + case FMT_CASE(D, FLOAT): return VK_FORMAT_D32_SFLOAT; + + case FMT_CASE(S, UNSIGNED_INT8): return VK_FORMAT_S8_UINT; + case FMT_CASE(DS, FLOAT_UNSIGNED_INT_24_8_REV): return VK_FORMAT_D24_UNORM_S8_UINT; + + case FMT_CASE(BGRA, UNORM_SHORT_4444): return VK_FORMAT_B4G4R4A4_UNORM; + case FMT_CASE(BGRA, UNORM_SHORT_5551): return VK_FORMAT_B5G5R5A1_UNORM; + default: + TCU_THROW(InternalError, "Unknown texture format"); + } + + #undef PACK_FMT + #undef FMT_CASE + } + tcu::TextureFormat mapVkFormat (VkFormat format) { + using tcu::TextureFormat; + switch (format) { - case VK_FORMAT_R5G6B5_UNORM: - return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_SHORT_565); - - case VK_FORMAT_R5G5B5A1_UNORM: - return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_5551); - - /* R8 */ - case VK_FORMAT_R8_UNORM: - return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT8); - case VK_FORMAT_R8_SNORM: - return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT8); - case VK_FORMAT_R8_UINT: - case VK_FORMAT_R8_USCALED: - return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT8); - case VK_FORMAT_R8_SINT: - case VK_FORMAT_R8_SSCALED: - return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT8); - - /* R8G8 */ - case VK_FORMAT_R8G8_UNORM: - return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT8); - case VK_FORMAT_R8G8_SNORM: - return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT8); - case VK_FORMAT_R8G8_UINT: - case VK_FORMAT_R8G8_USCALED: - return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT8); - case VK_FORMAT_R8G8_SINT: - case VK_FORMAT_R8G8_SSCALED: - return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT8); - - /* R8G8B8 */ - case VK_FORMAT_R8G8B8_UNORM: - return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8); - case VK_FORMAT_R8G8B8_SNORM: - return TextureFormat(TextureFormat::RGB, TextureFormat::SNORM_INT8); - case VK_FORMAT_R8G8B8_UINT: - case VK_FORMAT_R8G8B8_USCALED: - return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT8); - case VK_FORMAT_R8G8B8_SINT: - case VK_FORMAT_R8G8B8_SSCALED: - return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT8); - case VK_FORMAT_R8G8B8_SRGB: - return TextureFormat(TextureFormat::sRGB, TextureFormat::UNORM_INT8); - - /* R8G8B8A8 */ - case VK_FORMAT_R8G8B8A8_UNORM: - return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8); - case VK_FORMAT_R8G8B8A8_SNORM: - return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT8); - case VK_FORMAT_R8G8B8A8_UINT: - case VK_FORMAT_R8G8B8A8_USCALED: - return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8); - case VK_FORMAT_R8G8B8A8_SINT: - case VK_FORMAT_R8G8B8A8_SSCALED: - return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8); - case VK_FORMAT_R8G8B8A8_SRGB: - return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8); - - /* R10G10B10A2 */ - case VK_FORMAT_R10G10B10A2_UNORM: - return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT_1010102_REV); - case VK_FORMAT_R10G10B10A2_UINT: - case VK_FORMAT_R10G10B10A2_USCALED: - return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT_1010102_REV); - - /* R16 */ - case VK_FORMAT_R16_UNORM: - return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT16); - case VK_FORMAT_R16_SNORM: - return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT16); - case VK_FORMAT_R16_UINT: - case VK_FORMAT_R16_USCALED: - return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT16); - case VK_FORMAT_R16_SINT: - case VK_FORMAT_R16_SSCALED: - return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT16); - case VK_FORMAT_R16_SFLOAT: - return TextureFormat(TextureFormat::R, TextureFormat::HALF_FLOAT); - - /* R16G16 */ - case VK_FORMAT_R16G16_UNORM: - return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT16); - case VK_FORMAT_R16G16_SNORM: - return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT16); - case VK_FORMAT_R16G16_UINT: - case VK_FORMAT_R16G16_USCALED: - return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT16); - case VK_FORMAT_R16G16_SINT: - case VK_FORMAT_R16G16_SSCALED: - return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT16); - case VK_FORMAT_R16G16_SFLOAT: - return TextureFormat(TextureFormat::RG, TextureFormat::HALF_FLOAT); - - /* R16G16B16 */ - case VK_FORMAT_R16G16B16_UNORM: - return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT16); - case VK_FORMAT_R16G16B16_SNORM: - return TextureFormat(TextureFormat::RGB, TextureFormat::SNORM_INT16); - case VK_FORMAT_R16G16B16_UINT: - case VK_FORMAT_R16G16B16_USCALED: - return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT16); - case VK_FORMAT_R16G16B16_SINT: - case VK_FORMAT_R16G16B16_SSCALED: - return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT16); - case VK_FORMAT_R16G16B16_SFLOAT: - return TextureFormat(TextureFormat::RGB, TextureFormat::HALF_FLOAT); - - /* R16G16B16A16 */ - case VK_FORMAT_R16G16B16A16_UNORM: - return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT16); - case VK_FORMAT_R16G16B16A16_SNORM: - return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT16); - case VK_FORMAT_R16G16B16A16_UINT: - case VK_FORMAT_R16G16B16A16_USCALED: - return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT16); - case VK_FORMAT_R16G16B16A16_SINT: - case VK_FORMAT_R16G16B16A16_SSCALED: - return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT16); - case VK_FORMAT_R16G16B16A16_SFLOAT: - return TextureFormat(TextureFormat::RGBA, TextureFormat::HALF_FLOAT); - - /* R32 */ - case VK_FORMAT_R32_UINT: - return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT32); - case VK_FORMAT_R32_SINT: - return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT32); - case VK_FORMAT_R32_SFLOAT: - return TextureFormat(TextureFormat::R, TextureFormat::FLOAT); - - /* R32G32 */ - case VK_FORMAT_R32G32_UINT: - return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT32); - case VK_FORMAT_R32G32_SINT: - return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT32); - case VK_FORMAT_R32G32_SFLOAT: - return TextureFormat(TextureFormat::RG, TextureFormat::FLOAT); - - /* R32G32B32 */ - case VK_FORMAT_R32G32B32_UINT: - return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT32); - case VK_FORMAT_R32G32B32_SINT: - return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT32); - case VK_FORMAT_R32G32B32_SFLOAT: - return TextureFormat(TextureFormat::RGB, TextureFormat::FLOAT); - - /* R32G32B32A32 */ - case VK_FORMAT_R32G32B32A32_UINT: - return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32); - case VK_FORMAT_R32G32B32A32_SINT: - return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT32); - case VK_FORMAT_R32G32B32A32_SFLOAT: - return TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT); - - /* D/S */ - case VK_FORMAT_D16_UNORM: - return TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT16); - case VK_FORMAT_D24_UNORM: - return TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT24); - case VK_FORMAT_D32_SFLOAT: - return TextureFormat(TextureFormat::D, TextureFormat::FLOAT); - case VK_FORMAT_D16_UNORM_S8_UINT: - return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_16_8); - case VK_FORMAT_D24_UNORM_S8_UINT: - return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_24_8); - case VK_FORMAT_D32_SFLOAT_S8_UINT: - return TextureFormat(TextureFormat::DS, TextureFormat::FLOAT_UNSIGNED_INT_8); - case VK_FORMAT_S8_UINT: - return TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8); ++ case VK_FORMAT_R4G4_UNORM: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_SHORT_4444); ++ case VK_FORMAT_R4G4B4A4_UNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_4444); + case VK_FORMAT_R5G6B5_UNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_SHORT_565); + case VK_FORMAT_R5G5B5A1_UNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_5551); + + case VK_FORMAT_R8_UNORM: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT8); + case VK_FORMAT_R8_SNORM: return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT8); ++ case VK_FORMAT_R8_USCALED: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT8); ++ case VK_FORMAT_R8_SSCALED: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT8); + case VK_FORMAT_R8_UINT: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT8); + case VK_FORMAT_R8_SINT: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT8); + case VK_FORMAT_R8_SRGB: return TextureFormat(TextureFormat::sR, TextureFormat::UNORM_INT8); + + case VK_FORMAT_R8G8_UNORM: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT8); + case VK_FORMAT_R8G8_SNORM: return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT8); ++ case VK_FORMAT_R8G8_USCALED: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT8); ++ case VK_FORMAT_R8G8_SSCALED: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT8); + case VK_FORMAT_R8G8_UINT: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT8); + case VK_FORMAT_R8G8_SINT: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT8); - case VK_FORMAT_R8G8_SRGB: return TextureFormat(TextureFormat::sRG, TextureFormat::SIGNED_INT8); ++ case VK_FORMAT_R8G8_SRGB: return TextureFormat(TextureFormat::sRG, TextureFormat::UNORM_INT8); + + case VK_FORMAT_R8G8B8_UNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8); + case VK_FORMAT_R8G8B8_SNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::SNORM_INT8); ++ case VK_FORMAT_R8G8B8_USCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT8); ++ case VK_FORMAT_R8G8B8_SSCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT8); + case VK_FORMAT_R8G8B8_UINT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT8); + case VK_FORMAT_R8G8B8_SINT: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT8); - case VK_FORMAT_R8G8B8_SRGB: return TextureFormat(TextureFormat::sRGB, TextureFormat::SNORM_INT8); ++ case VK_FORMAT_R8G8B8_SRGB: return TextureFormat(TextureFormat::sRGB, TextureFormat::UNORM_INT8); + + case VK_FORMAT_R8G8B8A8_UNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8); + case VK_FORMAT_R8G8B8A8_SNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT8); ++ case VK_FORMAT_R8G8B8A8_USCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8); ++ case VK_FORMAT_R8G8B8A8_SSCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8); + case VK_FORMAT_R8G8B8A8_UINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8); + case VK_FORMAT_R8G8B8A8_SINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8); - case VK_FORMAT_R8G8B8A8_SRGB: return TextureFormat(TextureFormat::sRGBA, TextureFormat::SNORM_INT8); ++ case VK_FORMAT_R8G8B8A8_SRGB: return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8); + + case VK_FORMAT_R10G10B10A2_UNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT_1010102_REV); + case VK_FORMAT_R10G10B10A2_UINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT_1010102_REV); ++ case VK_FORMAT_R10G10B10A2_USCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT_1010102_REV); + + case VK_FORMAT_R16_UNORM: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT16); + case VK_FORMAT_R16_SNORM: return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT16); ++ case VK_FORMAT_R16_USCALED: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT16); ++ case VK_FORMAT_R16_SSCALED: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT16); + case VK_FORMAT_R16_UINT: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT16); + case VK_FORMAT_R16_SINT: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT16); + case VK_FORMAT_R16_SFLOAT: return TextureFormat(TextureFormat::R, TextureFormat::HALF_FLOAT); + + case VK_FORMAT_R16G16_UNORM: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT16); + case VK_FORMAT_R16G16_SNORM: return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT16); ++ case VK_FORMAT_R16G16_USCALED: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT16); ++ case VK_FORMAT_R16G16_SSCALED: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT16); + case VK_FORMAT_R16G16_UINT: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT16); + case VK_FORMAT_R16G16_SINT: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT16); + case VK_FORMAT_R16G16_SFLOAT: return TextureFormat(TextureFormat::RG, TextureFormat::HALF_FLOAT); + + case VK_FORMAT_R16G16B16_UNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT16); + case VK_FORMAT_R16G16B16_SNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::SNORM_INT16); ++ case VK_FORMAT_R16G16B16_USCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT16); ++ case VK_FORMAT_R16G16B16_SSCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT16); + case VK_FORMAT_R16G16B16_UINT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT16); + case VK_FORMAT_R16G16B16_SINT: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT16); + case VK_FORMAT_R16G16B16_SFLOAT: return TextureFormat(TextureFormat::RGB, TextureFormat::HALF_FLOAT); + + case VK_FORMAT_R16G16B16A16_UNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT16); + case VK_FORMAT_R16G16B16A16_SNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT16); ++ case VK_FORMAT_R16G16B16A16_USCALED:return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT16); ++ case VK_FORMAT_R16G16B16A16_SSCALED:return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT16); + case VK_FORMAT_R16G16B16A16_UINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT16); + case VK_FORMAT_R16G16B16A16_SINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT16); + case VK_FORMAT_R16G16B16A16_SFLOAT: return TextureFormat(TextureFormat::RGBA, TextureFormat::HALF_FLOAT); + + case VK_FORMAT_R32_UINT: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT32); + case VK_FORMAT_R32_SINT: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT32); + case VK_FORMAT_R32_SFLOAT: return TextureFormat(TextureFormat::R, TextureFormat::FLOAT); + + case VK_FORMAT_R32G32_UINT: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT32); + case VK_FORMAT_R32G32_SINT: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT32); + case VK_FORMAT_R32G32_SFLOAT: return TextureFormat(TextureFormat::RG, TextureFormat::FLOAT); + + case VK_FORMAT_R32G32B32_UINT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT32); + case VK_FORMAT_R32G32B32_SINT: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT32); + case VK_FORMAT_R32G32B32_SFLOAT: return TextureFormat(TextureFormat::RGB, TextureFormat::FLOAT); + + case VK_FORMAT_R32G32B32A32_UINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32); + case VK_FORMAT_R32G32B32A32_SINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT32); + case VK_FORMAT_R32G32B32A32_SFLOAT: return TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT); + + case VK_FORMAT_R11G11B10_UFLOAT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT_11F_11F_10F_REV); + case VK_FORMAT_R9G9B9E5_UFLOAT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT_999_E5_REV); + + case VK_FORMAT_D16_UNORM: return TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT16); + case VK_FORMAT_D24_UNORM: return TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT24); + case VK_FORMAT_D32_SFLOAT: return TextureFormat(TextureFormat::D, TextureFormat::FLOAT); + + case VK_FORMAT_S8_UINT: return TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8); - case VK_FORMAT_D24_UNORM_S8_UINT: return TextureFormat(TextureFormat::DS, TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV); ++ ++ // \note There is no standard interleaved memory layout for DS formats; buffer-image copies ++ // will always operate on either D or S aspect only. See Khronos bug 12998 ++ case VK_FORMAT_D16_UNORM_S8_UINT: return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_16_8); ++ case VK_FORMAT_D24_UNORM_S8_UINT: return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_24_8); ++ case VK_FORMAT_D32_SFLOAT_S8_UINT: return TextureFormat(TextureFormat::DS, TextureFormat::FLOAT_UNSIGNED_INT_8); + + case VK_FORMAT_B4G4R4A4_UNORM: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_SHORT_4444); + case VK_FORMAT_B5G5R5A1_UNORM: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_SHORT_5551); ++ ++ case VK_FORMAT_R4G4_USCALED: ++ case VK_FORMAT_R4G4B4A4_USCALED: ++ case VK_FORMAT_R5G6B5_USCALED: ++ case VK_FORMAT_R5G5B5A1_USCALED: ++ DE_FATAL("Format not implemented"); ++ default: - break; + TCU_THROW(InternalError, "Unknown image format"); } - - return TextureFormat(TextureFormat::CHANNELORDER_LAST, TextureFormat::CHANNELTYPE_LAST); } } // vk diff --cc external/vulkancts/framework/vulkan/vkImageUtil.hpp index 9632670,3916765..d399d0c --- a/external/vulkancts/framework/vulkan/vkImageUtil.hpp +++ b/external/vulkancts/framework/vulkan/vkImageUtil.hpp @@@ -1,11 -1,10 +1,12 @@@ #ifndef _VKIMAGEUTIL_HPP #define _VKIMAGEUTIL_HPP - /*------------------------------------------------------------------------ - * Vulkan Conformance Tests - * ------------------------ + /*------------------------------------------------------------------------- + * Vulkan CTS Framework + * -------------------- * + * Copyright (c) 2015 The Khronos Group Inc. + * Copyright (c) 2015 Imagination Technologies Ltd. + * Copyright (c) 2015 Google Inc. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and/or associated documentation files (the @@@ -32,28 -31,18 +33,25 @@@ * *//*! * \file - * \brief Image utilities. + * \brief Utilities for images. *//*--------------------------------------------------------------------*/ - #include "tcuDefs.hpp" #include "vkDefs.hpp" - #include "vkPlatform.hpp" - #include "vkMemUtil.hpp" - #include "vkRef.hpp" - #include "tcuTexture.hpp" namespace vk { - bool isFloatFormat (VkFormat format); - bool isUnormFormat (VkFormat format); - bool isSnormFormat (VkFormat format); - bool isIntFormat (VkFormat format); - bool isUintFormat (VkFormat format); - bool isDepthStencilFormat (VkFormat format); - bool isCompressedFormat (VkFormat format); -VkFormat mapTextureFormat (const tcu::TextureFormat& format); -tcu::TextureFormat mapVkFormat (VkFormat format); ++bool isFloatFormat (VkFormat format); ++bool isUnormFormat (VkFormat format); ++bool isSnormFormat (VkFormat format); ++bool isIntFormat (VkFormat format); ++bool isUintFormat (VkFormat format); ++bool isDepthStencilFormat (VkFormat format); ++bool isCompressedFormat (VkFormat format); + - tcu::TextureFormat mapVkFormat (VkFormat format); ++tcu::TextureFormat mapVkFormat (VkFormat format); ++VkFormat mapTextureFormat (const tcu::TextureFormat& format); } // vk diff --cc external/vulkancts/modules/vulkan/pipeline/vktPipelineDepthTests.cpp index d81dfd0,0000000..6685160 mode 100644,000000..100644 --- a/external/vulkancts/modules/vulkan/pipeline/vktPipelineDepthTests.cpp +++ b/external/vulkancts/modules/vulkan/pipeline/vktPipelineDepthTests.cpp @@@ -1,1103 -1,0 +1,1103 @@@ +/*------------------------------------------------------------------------ + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2015 The Khronos Group Inc. + * Copyright (c) 2015 Imagination Technologies Ltd. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice(s) and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * The Materials are Confidential Information as defined by the + * Khronos Membership Agreement until designated non-confidential by Khronos, + * at which point this condition clause shall be removed. + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + * + *//*! + * \file + * \brief Depth Tests + *//*--------------------------------------------------------------------*/ + +#include "vktPipelineDepthTests.hpp" +#include "vktPipelineClearUtil.hpp" +#include "vktPipelineImageUtil.hpp" +#include "vktPipelineVertexUtil.hpp" +#include "vktPipelineReferenceRenderer.hpp" +#include "vktTestCase.hpp" +#include "vktTestCaseUtil.hpp" +#include "vkImageUtil.hpp" +#include "vkMemUtil.hpp" +#include "vkPrograms.hpp" +#include "vkQueryUtil.hpp" +#include "vkRef.hpp" +#include "vkRefUtil.hpp" +#include "tcuImageCompare.hpp" +#include "deUniquePtr.hpp" +#include "deMemory.h" + +#include +#include + +namespace vkt +{ +namespace pipeline +{ + +using namespace vk; + +namespace +{ + +bool isSupportedDepthStencilFormat (const InstanceInterface& instanceInterface, VkPhysicalDevice device, VkFormat format) +{ + VkFormatProperties formatProps; + + VK_CHECK(instanceInterface.getPhysicalDeviceFormatProperties(device, format, &formatProps)); + - return formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; ++ return (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0u; +} + +tcu::TestStatus testSupportsDepthStencilFormat (Context& context, VkFormat format) +{ + DE_ASSERT(vk::isDepthStencilFormat(format)); + + if (isSupportedDepthStencilFormat(context.getInstanceInterface(), context.getPhysicalDevice(), format)) + return tcu::TestStatus::pass("Format can be used in depth/stencil attachment"); + else + return tcu::TestStatus::fail("Unsupported depth/stencil attachment format"); +} + +tcu::TestStatus testSupportsAtLeastOneDepthStencilFormat (Context& context, const std::vector formats) +{ + std::ostringstream supportedFormatsMsg; + bool pass = false; + + DE_ASSERT(!formats.empty()); + + for (size_t formatNdx = 0; formatNdx < formats.size(); formatNdx++) + { + const VkFormat format = formats[formatNdx]; + + DE_ASSERT(vk::isDepthStencilFormat(format)); + + if (isSupportedDepthStencilFormat(context.getInstanceInterface(), context.getPhysicalDevice(), format)) + { + pass = true; + supportedFormatsMsg << vk::getFormatName(format); + + if (formatNdx < formats.size() - 1) + supportedFormatsMsg << ", "; + } + } + + if (pass) + return tcu::TestStatus::pass(std::string("Supported depth/stencil formats: ") + supportedFormatsMsg.str()); + else + return tcu::TestStatus::fail("All depth/stencil formats are unsupported"); +} + +class DepthTest : public vkt::TestCase +{ +public: + enum + { + QUAD_COUNT = 4 + }; + + static const float quadDepths[QUAD_COUNT]; + + DepthTest (tcu::TestContext& testContext, + const std::string& name, + const std::string& description, + const VkFormat depthFormat, + const VkCompareOp depthCompareOps[QUAD_COUNT]); + virtual ~DepthTest (void); - virtual void initPrograms (SourceCollection& programCollection) const; ++ virtual void initPrograms (SourceCollections& programCollection) const; + virtual TestInstance* createInstance (Context& context) const; + +private: + const VkFormat m_depthFormat; + VkCompareOp m_depthCompareOps[QUAD_COUNT]; +}; + +class DepthTestInstance : public vkt::TestInstance +{ +public: + DepthTestInstance (Context& context, const VkFormat depthFormat, const VkCompareOp depthCompareOps[DepthTest::QUAD_COUNT]); + virtual ~DepthTestInstance (void); + virtual tcu::TestStatus iterate (void); + +private: + tcu::TestStatus verifyImage (void); + +private: + VkCompareOp m_depthCompareOps[DepthTest::QUAD_COUNT]; + const tcu::IVec2 m_renderSize; + const VkFormat m_colorFormat; + const VkFormat m_depthFormat; + + Move m_colorImage; + de::MovePtr m_colorImageAlloc; + Move m_depthImage; + de::MovePtr m_depthImageAlloc; + Move m_colorAttachmentView; + Move m_depthAttachmentView; + Move m_renderPass; + Move m_framebuffer; + + Move m_vertexShaderModule; + Move m_fragmentShaderModule; + Move m_vertexShader; + Move m_fragmentShader; + + Move m_vertexBuffer; + std::vector m_vertices; + de::MovePtr m_vertexBufferAlloc; + + Move m_pipelineLayout; + Move m_graphicsPipelines[DepthTest::QUAD_COUNT]; + + Move m_cmdPool; + Move m_cmdBuffer; + + Move m_viewportState; + Move m_rasterState; + Move m_colorBlendState; + Move m_depthStencilState; + + Move m_fence; +}; + +const float DepthTest::quadDepths[QUAD_COUNT] = +{ + 0.1f, + 0.0f, + 0.3f, + 0.2f +}; + +DepthTest::DepthTest (tcu::TestContext& testContext, + const std::string& name, + const std::string& description, + const VkFormat depthFormat, + const VkCompareOp depthCompareOps[QUAD_COUNT]) + : vkt::TestCase (testContext, name, description) + , m_depthFormat (depthFormat) +{ + deMemcpy(m_depthCompareOps, depthCompareOps, sizeof(VkCompareOp) * QUAD_COUNT); +} + +DepthTest::~DepthTest (void) +{ +} + +TestInstance* DepthTest::createInstance (Context& context) const +{ + return new DepthTestInstance(context, m_depthFormat, m_depthCompareOps); +} + - void DepthTest::initPrograms (SourceCollection& programCollection) const ++void DepthTest::initPrograms (SourceCollections& programCollection) const +{ - programCollection.add("color_vert") << glu::VertexSource( ++ programCollection.glslSources.add("color_vert") << glu::VertexSource( + "#version 310 es\n" + "layout(location = 0) in vec4 position;\n" + "layout(location = 1) in vec4 color;\n" + "layout(location = 0) out highp vec4 vtxColor;\n" + "void main (void)\n" + "{\n" + " gl_Position = position;\n" + " vtxColor = color;\n" + "}\n"); + - programCollection.add("color_frag") << glu::FragmentSource( ++ programCollection.glslSources.add("color_frag") << glu::FragmentSource( + "#version 310 es\n" + "layout(location = 0) in highp vec4 vtxColor;\n" + "layout(location = 0) out highp vec4 fragColor;\n" + "void main (void)\n" + "{\n" + " fragColor = vtxColor;\n" + "}\n"); +} + +DepthTestInstance::DepthTestInstance (Context& context, + const VkFormat depthFormat, + const VkCompareOp depthCompareOps[DepthTest::QUAD_COUNT]) + : vkt::TestInstance (context) + , m_renderSize (32, 32) + , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM) + , m_depthFormat (depthFormat) +{ + const DeviceInterface& vk = context.getDeviceInterface(); + const VkDevice vkDevice = context.getDevice(); + const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex(); + SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice())); + + // Copy depth operators + deMemcpy(m_depthCompareOps, depthCompareOps, sizeof(VkCompareOp) * DepthTest::QUAD_COUNT); + + // Create color image + { + const VkImageCreateInfo colorImageParams = + { + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + VK_IMAGE_TYPE_2D, // VkImageType imageType; + m_colorFormat, // VkFormat format; + { m_renderSize.x(), m_renderSize.y(), 1u }, // VkExtent3D extent; + 1u, // deUint32 mipLevels; + 1u, // deUint32 arraySize; + 1u, // deUint32 samples; + VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling; + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, // VkImageUsageFlags usage; + 0u, // VkImageCreateFlags flags; + VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; + 1u, // deUint32 queueFamilyCount; + &queueFamilyIndex // const deUint32* pQueueFamilyIndices; + }; + + m_colorImage = createImage(vk, vkDevice, &colorImageParams); + + // Allocate and bind color image memory + m_colorImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_colorImage), MemoryRequirement::Any); + VK_CHECK(vk.bindImageMemory(vkDevice, *m_colorImage, m_colorImageAlloc->getMemory(), m_colorImageAlloc->getOffset())); + } + + // Create depth image + { + // Check format support + if (!isSupportedDepthStencilFormat(context.getInstanceInterface(), context.getPhysicalDevice(), m_depthFormat)) + throw tcu::NotSupportedError(std::string("Unsupported depth/stencil format: ") + getFormatName(m_depthFormat)); + + const VkImageCreateInfo depthImageParams = + { + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + VK_IMAGE_TYPE_2D, // VkImageType imageType; + m_depthFormat, // VkFormat format; + { m_renderSize.x(), m_renderSize.y(), 1u }, // VkExtent3D extent; + 1u, // deUint32 mipLevels; + 1u, // deUint32 arraySize; + 1u, // deUint32 samples; + VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling; + VK_IMAGE_USAGE_DEPTH_STENCIL_BIT, // VkImageUsageFlags usage; + 0u, // VkImageCreateFlags flags; + VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; + 1u, // deUint32 queueFamilyCount; + &queueFamilyIndex // const deUint32* pQueueFamilyIndices; + }; + + m_depthImage = createImage(vk, vkDevice, &depthImageParams); + + // Allocate and bind depth image memory + m_depthImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_depthImage), MemoryRequirement::Any); + VK_CHECK(vk.bindImageMemory(vkDevice, *m_depthImage, m_depthImageAlloc->getMemory(), m_depthImageAlloc->getOffset())); + } + + // Create color attachment view + { + const VkAttachmentViewCreateInfo colorAttachmentViewParams = + { + VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, // VkStructureType sType; + DE_NULL, // constvoid* pNext; + *m_colorImage, // VkImage image; + m_colorFormat, // VkFormat format; + 0u, // deUint32 mipLevel; + 0u, // deUint32 baseArraySlice; + 1u, // deUint32 arraySize; + 0u // VkAttachmentViewCreateFlags flags; + }; + + m_colorAttachmentView = createAttachmentView(vk, vkDevice, &colorAttachmentViewParams); + } + + // Create depth attachment view + { + const VkAttachmentViewCreateInfo depthAttachmentViewParams = + { + VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, // VkStructureType sType; + DE_NULL, // constvoid* pNext; + *m_depthImage, // VkImage image; + m_depthFormat, // VkFormat format; + 0u, // deUint32 mipLevel; + 0u, // deUint32 baseArraySlice; + 1u, // deUint32 arraySize; + 0u // VkAttachmentViewCreateFlags flags; + }; + + m_depthAttachmentView = createAttachmentView(vk, vkDevice, &depthAttachmentViewParams); + } + + // Create render pass + { + const VkAttachmentDescription colorAttachmentDescription = + { + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, // VkStructureType sType; + DE_NULL, // const void* pNext; + m_colorFormat, // VkFormat format; + 1u, // deUint32 samples; + VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp; + VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp; + VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp; + VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp; + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout; + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout; + }; + + const VkAttachmentDescription depthAttachmentDescription = + { + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, // VkStructureType sType; + DE_NULL, // const void* pNext; + m_depthFormat, // VkFormat format; + 1u, // deUint32 samples; + VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp; + VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp; + VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp; + VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp; + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout; + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout; + }; + + const VkAttachmentDescription attachments[2] = + { + colorAttachmentDescription, + depthAttachmentDescription + }; + + const VkAttachmentReference colorAttachmentReference = + { + 0u, // deUint32 attachment; + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout; + }; + + const VkAttachmentReference depthAttachmentReference = + { + 1u, // deUint32 attachment; + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // VkImageLayout layout; + }; + + const VkSubpassDescription subpassDescription = + { + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION, // VkStructureType sType; + DE_NULL, // constvoid* pNext; + VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint; + 0u, // VkSubpassDescriptionFlags flags; + 0u, // deUint32 inputCount; + DE_NULL, // constVkAttachmentReference* inputAttachments; + 1u, // deUint32 colorCount; + &colorAttachmentReference, // constVkAttachmentReference* colorAttachments; + DE_NULL, // constVkAttachmentReference* resolveAttachments; + depthAttachmentReference, // VkAttachmentReference depthStencilAttachment; + 0u, // deUint32 preserveCount; + DE_NULL // constVkAttachmentReference* preserveAttachments; + }; + + const VkRenderPassCreateInfo renderPassParams = + { + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 2u, // deUint32 attachmentCount; + attachments, // const VkAttachmentDescription* pAttachments; + 1u, // deUint32 subpassCount; + &subpassDescription, // const VkSubpassDescription* pSubpasses; + 0u, // deUint32 dependencyCount; + DE_NULL // const VkSubpassDependency* pDependencies; + }; + + m_renderPass = createRenderPass(vk, vkDevice, &renderPassParams); + } + + // Create framebuffer + { + const VkAttachmentBindInfo attachmentBindInfos[2] = + { + { *m_colorAttachmentView, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL }, + { *m_depthAttachmentView, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL } + }; + + const VkFramebufferCreateInfo framebufferParams = + { + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + *m_renderPass, // VkRenderPass renderPass; + 2u, // deUint32 attachmentCount; + attachmentBindInfos, // const VkAttachmentBindInfo* pAttachments; + (deUint32)m_renderSize.x(), // deUint32 width; + (deUint32)m_renderSize.y(), // deUint32 height; + 1u // deUint32 layers; + }; + + m_framebuffer = createFramebuffer(vk, vkDevice, &framebufferParams); + } + + // Create pipeline layout + { + const VkPipelineLayoutCreateInfo pipelineLayoutParams = + { + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // deUint32 descriptorSetCount; + DE_NULL, // const VkDescriptorSetLayout* pSetLayouts; + 0u, // deUint32 pushConstantRangeCount; + DE_NULL // const VkPushConstantRange* pPushConstantRanges; + }; + + m_pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams); + } + + // Create shaders + { + m_vertexShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("color_vert"), 0); + m_fragmentShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("color_frag"), 0); + + const VkShaderCreateInfo vertexShaderParams = + { + VK_STRUCTURE_TYPE_SHADER_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + *m_vertexShaderModule, // VkShaderModule module; + "main", // const char* pName; + 0u // VkShaderCreateFlags flags; + }; + + const VkShaderCreateInfo fragmentShaderParams = + { + VK_STRUCTURE_TYPE_SHADER_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + *m_fragmentShaderModule, // VkShaderModule module; + "main", // const char* pName; + 0u // VkShaderCreateFlags flags; + }; + + m_vertexShader = createShader(vk, vkDevice, &vertexShaderParams); + m_fragmentShader = createShader(vk, vkDevice, &fragmentShaderParams); + } + + // Create pipeline + { + const VkPipelineShaderStageCreateInfo shaderStageParams[2] = + { + { + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + VK_SHADER_STAGE_VERTEX, // VkShaderStage stage; + *m_vertexShader, // VkShader shader; + DE_NULL // const VkSpecializationInfo* pSpecializationInfo; + }, + { + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + VK_SHADER_STAGE_FRAGMENT, // VkShaderStage stage; + *m_fragmentShader, // VkShader shader; + DE_NULL // const VkSpecializationInfo* pSpecializationInfo; + } + }; + + const VkVertexInputBindingDescription vertexInputBindingDescription = + { + 0u, // deUint32 binding; + sizeof(Vertex4RGBA), // deUint32 strideInBytes; + VK_VERTEX_INPUT_STEP_RATE_VERTEX // VkVertexInputStepRate stepRate; + }; + + const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] = + { + { + 0u, // deUint32 location; + 0u, // deUint32 binding; + VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format; + 0u // deUint32 offsetInBytes; + }, + { + 1u, // deUint32 location; + 0u, // deUint32 binding; + VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format; + DE_OFFSET_OF(Vertex4RGBA, color), // deUint32 offsetInBytes; + } + }; + + const VkPipelineVertexInputStateCreateInfo vertexInputStateParams = + { + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 1u, // deUint32 bindingCount; + &vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions; + 2u, // deUint32 attributeCount; + vertexInputAttributeDescriptions // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; + }; + + const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams = + { + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology; + false // VkBool32 primitiveRestartEnable; + }; + + const VkPipelineViewportStateCreateInfo viewportStateParams = + { + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 1u // deUint32 viewportCount; + }; + + const VkPipelineRasterStateCreateInfo rasterStateParams = + { + VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + false, // VkBool32 depthClipEnable; + false, // VkBool32 rasterizerDiscardEnable; + VK_FILL_MODE_SOLID, // VkFillMode fillMode; + VK_CULL_MODE_NONE, // VkCullMode cullMode; + VK_FRONT_FACE_CCW // VkFrontFace frontFace; + }; + + const VkPipelineColorBlendAttachmentState colorBlendAttachmentState = + { + false, // VkBool32 blendEnable; + VK_BLEND_ONE, // VkBlend srcBlendColor; + VK_BLEND_ZERO, // VkBlend destBlendColor; + VK_BLEND_OP_ADD, // VkBlendOp blendOpColor; + VK_BLEND_ONE, // VkBlend srcBlendAlpha; + VK_BLEND_ZERO, // VkBlend destBlendAlpha; + VK_BLEND_OP_ADD, // VkBlendOp blendOpAlpha; + VK_CHANNEL_R_BIT | VK_CHANNEL_G_BIT | VK_CHANNEL_B_BIT | VK_CHANNEL_A_BIT // VkChannelFlags channelWriteMask; + }; + + const VkPipelineColorBlendStateCreateInfo colorBlendStateParams = + { + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + false, // VkBool32 alphaToCoverageEnable; + false, // VkBool32 logicOpEnable; + VK_LOGIC_OP_COPY, // VkLogicOp logicOp; + 1u, // deUint32 attachmentCount; + &colorBlendAttachmentState // const VkPipelineColorBlendAttachmentState* pAttachments; + }; + + const VkPipelineMultisampleStateCreateInfo multisampleStateParams = + { + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 1u, // deUint32 rasterSamples; + false, // VkBool32 sampleShadingEnable; + 0.0f, // float minSampleShading; + ~((VkSampleMask)0) // VkSampleMask sampleMask; + }; + + VkPipelineDepthStencilStateCreateInfo depthStencilStateParams = + { + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + true, // VkBool32 depthTestEnable; + true, // VkBool32 depthWriteEnable; + VK_COMPARE_OP_LESS, // VkCompareOp depthCompareOp; + false, // VkBool32 depthBoundsEnable; + false, // VkBool32 stencilTestEnable; + // VkStencilOpState front; + { + VK_STENCIL_OP_KEEP, // VkStencilOp stencilFailOp; + VK_STENCIL_OP_KEEP, // VkStencilOp stencilPassOp; + VK_STENCIL_OP_KEEP, // VkStencilOp stencilDepthFailOp; + VK_COMPARE_OP_NEVER // VkCompareOp stencilCompareOp; + }, + // VkStencilOpState back; + { + VK_STENCIL_OP_KEEP, // VkStencilOp stencilFailOp; + VK_STENCIL_OP_KEEP, // VkStencilOp stencilPassOp; + VK_STENCIL_OP_KEEP, // VkStencilOp stencilDepthFailOp; + VK_COMPARE_OP_NEVER // VkCompareOp stencilCompareOp; + } + }; + + const VkGraphicsPipelineCreateInfo graphicsPipelineParams = + { + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 2u, // deUint32 stageCount; + shaderStageParams, // const VkPipelineShaderStageCreateInfo* pStages; + &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState; + &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState; + &rasterStateParams, // const VkPipelineRasterStateCreateInfo* pRasterState; + &multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + &depthStencilStateParams, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + 0u, // VkPipelineCreateFlags flags; + *m_pipelineLayout, // VkPipelineLayout layout; + *m_renderPass, // VkRenderPass renderPass; + 0u, // deUint32 subpass; + 0u, // VkPipeline basePipelineHandle; + 0u // deInt32 basePipelineIndex; + }; + + for (int quadNdx = 0; quadNdx < DepthTest::QUAD_COUNT; quadNdx++) + { + depthStencilStateParams.depthCompareOp = depthCompareOps[quadNdx]; + m_graphicsPipelines[quadNdx] = createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams); + } + } + + // Create dynamic states + { + const VkViewport viewport = + { + 0.0f, // float originX; + 0.0f, // float originY; + (float)m_renderSize.x(), // float width; + (float)m_renderSize.y(), // float height; + 0.0f, // float minDepth; + 1.0f // float maxDepth; + }; + + const VkRect2D scissor = + { + { 0, 0 }, // VkOffset2D offset; + { m_renderSize.x(), m_renderSize.y() } // VkExtent2D extent; + }; + + const VkDynamicViewportStateCreateInfo viewportStateParams = + { + VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 1, // deUint32 viewportAndScissorCount; + &viewport, // const VkViewport* pViewports; + &scissor // const VkRect2D* pScissors; + }; + + const VkDynamicRasterStateCreateInfo rasterStateParams = + { + VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0.0f, // float depthBias; + 0.0f, // float depthBiasClamp; + 0.0f, // float slopeScaledDepthBias; + 1.0f, // float lineWidth; + }; + + const VkDynamicColorBlendStateCreateInfo colorBlendStateParams = + { + VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConst[4]; + }; + + const VkDynamicDepthStencilStateCreateInfo depthStencilStateParams = + { + VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0.0f, // float minDepthBounds; + 1.0f, // float maxDepthBounds; + 0x0, // deUint32 stencilReadMask; + 0x0, // deUint32 stencilWriteMask; + 0x0, // deUint32 stencilFrontRef; + 0x0 // deUint32 stencilBackRef; + }; + + m_viewportState = createDynamicViewportState(vk, vkDevice, &viewportStateParams); + m_rasterState = createDynamicRasterState(vk, vkDevice, &rasterStateParams); + m_colorBlendState = createDynamicColorBlendState(vk, vkDevice, &colorBlendStateParams); + m_depthStencilState = createDynamicDepthStencilState(vk, vkDevice, &depthStencilStateParams); + } + + // Create vertex buffer + { + const VkBufferCreateInfo vertexBufferParams = + { + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 1024u, // VkDeviceSize size; + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // VkBufferUsageFlags usage; + 0u, // VkBufferCreateFlags flags; + VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; + 1u, // deUint32 queueFamilyCount; + &queueFamilyIndex // const deUint32* pQueueFamilyIndices; + }; + + m_vertices = createOverlappingQuads(); + m_vertexBuffer = createBuffer(vk, vkDevice, &vertexBufferParams); + m_vertexBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_vertexBuffer), MemoryRequirement::HostVisible); + + VK_CHECK(vk.bindBufferMemory(vkDevice, *m_vertexBuffer, m_vertexBufferAlloc->getMemory(), m_vertexBufferAlloc->getOffset())); + + // Adjust depths + for (int quadNdx = 0; quadNdx < DepthTest::QUAD_COUNT; quadNdx++) + for (int vertexNdx = 0; vertexNdx < 6; vertexNdx++) + m_vertices[quadNdx * 6 + vertexNdx].position.z() = DepthTest::quadDepths[quadNdx]; + + // Load vertices into vertex buffer + + const VkMappedMemoryRange flushRange = + { + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, // VkStructureType sType; + DE_NULL, // const void* pNext; + m_vertexBufferAlloc->getMemory(), // VkDeviceMemory mem; + m_vertexBufferAlloc->getOffset(), // VkDeviceSize offset; + vertexBufferParams.size // VkDeviceSize size; + }; + + void* bufferPtr; + VK_CHECK(vk.mapMemory(vkDevice, m_vertexBufferAlloc->getMemory(), m_vertexBufferAlloc->getOffset(), vertexBufferParams.size, 0, &bufferPtr)); + deMemcpy(bufferPtr, m_vertices.data(), m_vertices.size() * sizeof(Vertex4RGBA)); + vk.flushMappedMemoryRanges(vkDevice, 1, &flushRange); + VK_CHECK(vk.unmapMemory(vkDevice, m_vertexBufferAlloc->getMemory())); + } + + // Create command pool + { + const VkCmdPoolCreateInfo cmdPoolParams = + { + VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + queueFamilyIndex, // deUint32 queueFamilyIndex; + VK_CMD_POOL_CREATE_TRANSIENT_BIT // VkCmdPoolCreateFlags flags; + }; + + m_cmdPool = createCommandPool(vk, vkDevice, &cmdPoolParams); + } + + // Create command buffer + { + const VkCmdBufferCreateInfo cmdBufferParams = + { + VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + *m_cmdPool, // VkCmdPool cmdPool; + VK_CMD_BUFFER_LEVEL_PRIMARY, // VkCmdBufferLevel level; + 0u // VkCmdBufferCreateFlags flags; + }; + + const VkCmdBufferBeginInfo cmdBufferBeginInfo = + { + VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // VkCmdBufferOptimizeFlags flags; + DE_NULL, // VkRenderPass renderPass; + DE_NULL // VkFramebuffer framebuffer; + }; + + const VkClearValue attachmentClearValues[2] = + { + defaultClearValue(m_colorFormat), + defaultClearValue(m_depthFormat), + }; + + const VkRenderPassBeginInfo renderPassBeginInfo = + { + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + *m_renderPass, // VkRenderPass renderPass; + *m_framebuffer, // VkFramebuffer framebuffer; + { { 0, 0 }, { m_renderSize.x(), m_renderSize.y()} }, // VkRect2D renderArea; + 2, // deUint32 attachmentCount; + attachmentClearValues // const VkClearValue* pAttachmentClearValues; + }; + + m_cmdBuffer = createCommandBuffer(vk, vkDevice, &cmdBufferParams); + + VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo)); + vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_RENDER_PASS_CONTENTS_INLINE); + + vk.cmdBindDynamicViewportState(*m_cmdBuffer, *m_viewportState); + vk.cmdBindDynamicRasterState(*m_cmdBuffer, *m_rasterState); + vk.cmdBindDynamicColorBlendState(*m_cmdBuffer, *m_colorBlendState); + vk.cmdBindDynamicDepthStencilState(*m_cmdBuffer, *m_depthStencilState); + + const VkDeviceSize quadOffset = (m_vertices.size() / DepthTest::QUAD_COUNT) * sizeof(Vertex4RGBA); + + for (int quadNdx = 0; quadNdx < DepthTest::QUAD_COUNT; quadNdx++) + { + VkDeviceSize vertexBufferOffset = quadOffset * quadNdx; + + vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipelines[quadNdx]); + vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &m_vertexBuffer.get(), &vertexBufferOffset); + vk.cmdDraw(*m_cmdBuffer, 0, (deUint32)(m_vertices.size() / DepthTest::QUAD_COUNT), 0, 1); + } + + vk.cmdEndRenderPass(*m_cmdBuffer); + VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer)); + } + + // Create fence + { + const VkFenceCreateInfo fenceParams = + { + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u // VkFenceCreateFlags flags; + }; + + m_fence = createFence(vk, vkDevice, &fenceParams); + } +} + +DepthTestInstance::~DepthTestInstance (void) +{ +} + +tcu::TestStatus DepthTestInstance::iterate (void) +{ + const DeviceInterface& vk = m_context.getDeviceInterface(); + const VkDevice vkDevice = m_context.getDevice(); + const VkQueue queue = m_context.getUniversalQueue(); + + VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get())); + VK_CHECK(vk.queueSubmit(queue, 1, &m_cmdBuffer.get(), *m_fence)); + VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity*/)); + + return verifyImage(); +} + +tcu::TestStatus DepthTestInstance::verifyImage (void) +{ + const tcu::TextureFormat tcuColorFormat = mapVkFormat(m_colorFormat); + const tcu::TextureFormat tcuDepthFormat = mapVkFormat(m_depthFormat); + const ColorVertexShader vertexShader; + const ColorFragmentShader fragmentShader (tcuColorFormat, tcuDepthFormat); + const rr::Program program (&vertexShader, &fragmentShader); + ReferenceRenderer refRenderer (m_renderSize.x(), m_renderSize.y(), 1, tcuColorFormat, tcuDepthFormat, &program); + bool compareOk = false; + + // Render reference image + { + for (int quadNdx = 0; quadNdx < DepthTest::QUAD_COUNT; quadNdx++) + { + // Set depth state + rr::RenderState renderState(refRenderer.getViewportState()); + renderState.fragOps.depthTestEnabled = true; + renderState.fragOps.depthFunc = mapVkCompareOp(m_depthCompareOps[quadNdx]); + + refRenderer.draw(renderState, + rr::PRIMITIVETYPE_TRIANGLES, + std::vector(m_vertices.begin() + quadNdx * 6, + m_vertices.begin() + (quadNdx + 1) * 6)); + } + } + + // Compare result with reference image + { + const DeviceInterface& vk = m_context.getDeviceInterface(); + const VkDevice vkDevice = m_context.getDevice(); + const VkQueue queue = m_context.getUniversalQueue(); + const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); + SimpleAllocator allocator (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice())); + de::MovePtr result = readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *m_colorImage, m_colorFormat, m_renderSize); + + compareOk = tcu::intThresholdPositionDeviationCompare(m_context.getTestContext().getLog(), + "IntImageCompare", + "Image comparison", + refRenderer.getAccess(), + result->getAccess(), + tcu::UVec4(2, 2, 2, 2), + tcu::IVec3(1, 1, 0), + true, + tcu::COMPARE_LOG_EVERYTHING); + } + + if (compareOk) + return tcu::TestStatus::pass("Result image matches reference"); + else + return tcu::TestStatus::fail("Image mismatch"); +} + +std::string getCompareOpsName (const VkCompareOp quadDepthOps[DepthTest::QUAD_COUNT]) +{ + std::ostringstream name; + + for (int quadNdx = 0; quadNdx < DepthTest::QUAD_COUNT; quadNdx++) + { + name << getCompareOpName(quadDepthOps[quadNdx]); + + if (quadNdx < DepthTest::QUAD_COUNT - 1) + name << "_"; + } + + return name.str(); +} + +std::string getCompareOpsDescription (const VkCompareOp quadDepthOps[DepthTest::QUAD_COUNT]) +{ + std::ostringstream desc; + desc << "Draws " << DepthTest::QUAD_COUNT << " quads with depth compare ops: "; + + for (int quadNdx = 0; quadNdx < DepthTest::QUAD_COUNT; quadNdx++) + { + desc << getCompareOpName(quadDepthOps[quadNdx]) << " at depth " << DepthTest::quadDepths[quadNdx]; + + if (quadNdx < DepthTest::QUAD_COUNT - 1) + desc << ", "; + } + return desc.str(); +} + + +} // anonymous + +tcu::TestCaseGroup* createDepthTests (tcu::TestContext& testCtx) +{ + const VkFormat depthFormats[] = + { + VK_FORMAT_D16_UNORM, + VK_FORMAT_D24_UNORM, + VK_FORMAT_D32_SFLOAT, + VK_FORMAT_D16_UNORM_S8_UINT, + VK_FORMAT_D24_UNORM_S8_UINT, + VK_FORMAT_D32_SFLOAT_S8_UINT + }; + + // Each entry configures the depth compare operators of QUAD_COUNT quads. + // All entries cover pair-wise combinations of compare operators. + const VkCompareOp depthOps[][DepthTest::QUAD_COUNT] = + { + { VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_NOT_EQUAL }, + { VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_GREATER }, + { VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_LESS_EQUAL }, + { VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_GREATER_EQUAL }, + { VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_ALWAYS }, + { VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_LESS, VK_COMPARE_OP_LESS, VK_COMPARE_OP_LESS }, + { VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_NEVER }, + { VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_EQUAL }, + { VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_LESS }, + { VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_NOT_EQUAL }, + { VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_GREATER }, + { VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_LESS, VK_COMPARE_OP_LESS_EQUAL }, + { VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_EQUAL }, + { VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_LESS, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_ALWAYS }, + { VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_GREATER_EQUAL }, + { VK_COMPARE_OP_GREATER, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_LESS }, + { VK_COMPARE_OP_GREATER, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_ALWAYS }, + { VK_COMPARE_OP_GREATER, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_GREATER }, + { VK_COMPARE_OP_GREATER, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_NOT_EQUAL }, + { VK_COMPARE_OP_GREATER, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_GREATER_EQUAL }, + { VK_COMPARE_OP_GREATER, VK_COMPARE_OP_LESS, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_NEVER }, + { VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_GREATER }, + { VK_COMPARE_OP_GREATER, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_LESS_EQUAL }, + { VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_NOT_EQUAL }, + { VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_GREATER_EQUAL }, + { VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_LESS_EQUAL }, + { VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_LESS }, + { VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_LESS, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_EQUAL }, + { VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_LESS, VK_COMPARE_OP_NEVER }, + { VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_LESS_EQUAL }, + { VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_LESS, VK_COMPARE_OP_EQUAL }, + { VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_LESS }, + { VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_ALWAYS }, + { VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_LESS, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_GREATER_EQUAL }, + { VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_NEVER }, + { VK_COMPARE_OP_LESS, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_LESS, VK_COMPARE_OP_GREATER_EQUAL }, + { VK_COMPARE_OP_LESS, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_LESS_EQUAL }, + { VK_COMPARE_OP_LESS, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_NEVER }, + { VK_COMPARE_OP_LESS, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_EQUAL }, + { VK_COMPARE_OP_LESS, VK_COMPARE_OP_LESS, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_NOT_EQUAL }, + { VK_COMPARE_OP_LESS, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_ALWAYS }, + { VK_COMPARE_OP_NEVER, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_ALWAYS }, + { VK_COMPARE_OP_LESS, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_LESS }, + { VK_COMPARE_OP_NEVER, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_EQUAL }, + { VK_COMPARE_OP_NEVER, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_LESS, VK_COMPARE_OP_GREATER }, + { VK_COMPARE_OP_NEVER, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_NOT_EQUAL }, + { VK_COMPARE_OP_NEVER, VK_COMPARE_OP_LESS, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_LESS_EQUAL }, + { VK_COMPARE_OP_NEVER, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_GREATER_EQUAL }, + { VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_NEVER }, + { VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_LESS }, + { VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_LESS, VK_COMPARE_OP_ALWAYS }, + { VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_GREATER }, + { VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_EQUAL }, + { VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_NOT_EQUAL }, + { VK_COMPARE_OP_NEVER, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_LESS }, + { VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_NEVER }, + { VK_COMPARE_OP_GREATER, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_LESS, VK_COMPARE_OP_NOT_EQUAL }, + { VK_COMPARE_OP_GREATER, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_EQUAL }, + { VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_LESS_EQUAL }, + { VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_GREATER }, + { VK_COMPARE_OP_NEVER, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_NEVER }, + { VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_LESS, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_GREATER }, + { VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_NOT_EQUAL }, + { VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_ALWAYS }, + { VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_GREATER }, + { VK_COMPARE_OP_LESS, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_LESS, VK_COMPARE_OP_GREATER }, + { VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_GREATER_EQUAL }, + { VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_LESS_EQUAL }, + { VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_LESS }, + { VK_COMPARE_OP_GREATER_EQUAL, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_NEVER }, + { VK_COMPARE_OP_LESS, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_EQUAL }, + { VK_COMPARE_OP_NEVER, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_GREATER_EQUAL }, + { VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_ALWAYS }, + { VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_LESS_EQUAL, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_GREATER } + }; + + de::MovePtr depthTests (new tcu::TestCaseGroup(testCtx, "depth", "Depth tests")); + + // Tests for format features + { + de::MovePtr formatFeaturesTests (new tcu::TestCaseGroup(testCtx, "format_features", "Checks depth format features")); + + // Formats that must be supported in all implementations + addFunctionCase(formatFeaturesTests.get(), + "support_d16_unorm", + "Tests if VK_FORMAT_D16_UNORM is supported as depth/stencil attachment format", + testSupportsDepthStencilFormat, + VK_FORMAT_D16_UNORM); + + // Sets where at least one of the formats must be supported + const VkFormat depthOnlyFormats[] = { VK_FORMAT_D24_UNORM, VK_FORMAT_D32_SFLOAT }; + const VkFormat depthStencilFormats[] = { VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D32_SFLOAT_S8_UINT }; + + addFunctionCase(formatFeaturesTests.get(), + "support_d24_unorm_or_d32_sfloat", + "Tests if any of VK_FORMAT_D24_UNORM or VK_FORMAT_D32_SFLOAT are supported as depth/stencil attachment format", + testSupportsAtLeastOneDepthStencilFormat, + std::vector(depthOnlyFormats, depthOnlyFormats + DE_LENGTH_OF_ARRAY(depthOnlyFormats))); + + addFunctionCase(formatFeaturesTests.get(), + "support_d24_unorm_s8_uint_or_d32_sfloat_s8_uint", + "Tests if any of VK_FORMAT_D24_UNORM_S8_UINT or VK_FORMAT_D32_SFLOAT_S8_UINT are supported as depth/stencil attachment format", + testSupportsAtLeastOneDepthStencilFormat, + std::vector(depthStencilFormats, depthStencilFormats + DE_LENGTH_OF_ARRAY(depthStencilFormats))); + + depthTests->addChild(formatFeaturesTests.release()); + } + + // Tests for format and compare operators + { + de::MovePtr formatTests (new tcu::TestCaseGroup(testCtx, "format", "Uses different depth formats")); + + for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(depthFormats); formatNdx++) + { + de::MovePtr formatTest (new tcu::TestCaseGroup(testCtx, + getFormatName(depthFormats[formatNdx]), + (std::string("Uses format ") + getFormatName(depthFormats[formatNdx])).c_str())); + de::MovePtr compareOpsTests (new tcu::TestCaseGroup(testCtx, "compare_ops", "Combines depth compare operators")); + + for (size_t opsNdx = 0; opsNdx < DE_LENGTH_OF_ARRAY(depthOps); opsNdx++) + { + compareOpsTests->addChild(new DepthTest(testCtx, + getCompareOpsName(depthOps[opsNdx]), + getCompareOpsDescription(depthOps[opsNdx]), + depthFormats[formatNdx], + depthOps[opsNdx])); + } + formatTest->addChild(compareOpsTests.release()); + formatTests->addChild(formatTest.release()); + } + depthTests->addChild(formatTests.release()); + } + + return depthTests.release(); +} + +} // pipeline +} // vkt diff --cc framework/common/tcuTextureUtil.cpp index d878fbb,f11778e..6463e28 --- a/framework/common/tcuTextureUtil.cpp +++ b/framework/common/tcuTextureUtil.cpp @@@ -238,10 -264,10 +268,10 @@@ ConstPixelBufferAccess flipYAccess (con return ConstPixelBufferAccess(access.getFormat(), access.getSize(), pitch, (deUint8*)access.getDataPtr() + offsetToLast); } - static Vec2 getChannelValueRange (TextureFormat::ChannelType channelType) + static Vec2 getFloatChannelValueRange (TextureFormat::ChannelType channelType) { // make sure this table is updated if format table is updated - DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 27); + DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 29); float cMin = 0.0f; float cMax = 0.0f;