Home | History | Annotate | Download | only in vulkan 
      1 /*-------------------------------------------------------------------------
      2  * Vulkan Conformance Tests
      3  * ------------------------
      4  *
      5  * Copyright (c) 2015 Google Inc.
      6  *
      7  * Licensed under the Apache License, Version 2.0 (the "License");
      8  * you may not use this file except in compliance with the License.
      9  * You may obtain a copy of the License at
     10  *
     11  *      http://www.apache.org/licenses/LICENSE-2.0
     12  *
     13  * Unless required by applicable law or agreed to in writing, software
     14  * distributed under the License is distributed on an "AS IS" BASIS,
     15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     16  * See the License for the specific language governing permissions and
     17  * limitations under the License.
     18  *
     19  *//*!
     20  * \file
     21  * \brief RenderPass tests
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "vktRenderPassTests.hpp"
     25 
     26 #include "vktTestCaseUtil.hpp"
     27 
     28 #include "vkDefs.hpp"
     29 #include "vkDeviceUtil.hpp"
     30 #include "vkImageUtil.hpp"
     31 #include "vkMemUtil.hpp"
     32 #include "vkPlatform.hpp"
     33 #include "vkPrograms.hpp"
     34 #include "vkQueryUtil.hpp"
     35 #include "vkRef.hpp"
     36 #include "vkRefUtil.hpp"
     37 #include "vkStrUtil.hpp"
     38 #include "vkTypeUtil.hpp"
     39 
     40 #include "tcuTestLog.hpp"
     41 #include "tcuResultCollector.hpp"
     42 #include "tcuFormatUtil.hpp"
     43 #include "tcuTextureUtil.hpp"
     44 #include "tcuFloat.hpp"
     45 #include "tcuMaybe.hpp"
     46 #include "tcuVectorUtil.hpp"
     47 
     48 #include "deUniquePtr.hpp"
     49 #include "deSharedPtr.hpp"
     50 #include "deStringUtil.hpp"
     51 #include "deSTLUtil.hpp"
     52 #include "deRandom.hpp"
     53 
     54 #include <limits>
     55 
     56 using namespace vk;
     57 
     58 using tcu::Maybe;
     59 using tcu::nothing;
     60 using tcu::just;
     61 using tcu::TestLog;
     62 using tcu::Vec2;
     63 using tcu::IVec2;
     64 using tcu::UVec2;
     65 using tcu::IVec4;
     66 using tcu::UVec4;
     67 using tcu::Vec4;
     68 using tcu::BVec4;
     69 using tcu::ConstPixelBufferAccess;
     70 using tcu::PixelBufferAccess;
     71 
     72 using de::UniquePtr;
     73 
     74 using std::vector;
     75 using std::string;
     76 
     77 namespace vkt
     78 {
     79 namespace
     80 {
     81 enum
     82 {
     83 	STENCIL_VALUE = 84u,
     84 	// Limit integer values that are representable as floats
     85 	MAX_INTEGER_VALUE = ((1u<<22u)-1u)
     86 };
     87 
     88 // Utility functions using flattened structs
     89 Move<VkFence> createFence (const DeviceInterface& vk, VkDevice device, VkFenceCreateFlags flags)
     90 {
     91 	const VkFenceCreateInfo pCreateInfo =
     92 	{
     93 		VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
     94 		DE_NULL,
     95 
     96 		flags
     97 	};
     98 	return createFence(vk, device, &pCreateInfo);
     99 }
    100 
    101 Move<VkFramebuffer> createFramebuffer (const DeviceInterface&	vk,
    102 									   VkDevice					device,
    103 									   VkFramebufferCreateFlags	pCreateInfo_flags,
    104 									   VkRenderPass				pCreateInfo_renderPass,
    105 									   deUint32					pCreateInfo_attachmentCount,
    106 									   const VkImageView*		pCreateInfo_pAttachments,
    107 									   deUint32					pCreateInfo_width,
    108 									   deUint32					pCreateInfo_height,
    109 									   deUint32					pCreateInfo_layers)
    110 {
    111 	const VkFramebufferCreateInfo pCreateInfo =
    112 	{
    113 		VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
    114 		DE_NULL,
    115 		pCreateInfo_flags,
    116 		pCreateInfo_renderPass,
    117 		pCreateInfo_attachmentCount,
    118 		pCreateInfo_pAttachments,
    119 		pCreateInfo_width,
    120 		pCreateInfo_height,
    121 		pCreateInfo_layers,
    122 	};
    123 	return createFramebuffer(vk, device, &pCreateInfo);
    124 }
    125 
    126 Move<VkImage> createImage (const DeviceInterface&	vk,
    127 						   VkDevice					device,
    128 						   VkImageCreateFlags		pCreateInfo_flags,
    129 						   VkImageType				pCreateInfo_imageType,
    130 						   VkFormat					pCreateInfo_format,
    131 						   VkExtent3D				pCreateInfo_extent,
    132 						   deUint32					pCreateInfo_mipLevels,
    133 						   deUint32					pCreateInfo_arrayLayers,
    134 						   VkSampleCountFlagBits	pCreateInfo_samples,
    135 						   VkImageTiling			pCreateInfo_tiling,
    136 						   VkImageUsageFlags		pCreateInfo_usage,
    137 						   VkSharingMode			pCreateInfo_sharingMode,
    138 						   deUint32					pCreateInfo_queueFamilyCount,
    139 						   const deUint32*			pCreateInfo_pQueueFamilyIndices,
    140 						   VkImageLayout			pCreateInfo_initialLayout)
    141 {
    142 	const VkImageCreateInfo pCreateInfo =
    143 	{
    144 		VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
    145 		DE_NULL,
    146 		pCreateInfo_flags,
    147 		pCreateInfo_imageType,
    148 		pCreateInfo_format,
    149 		pCreateInfo_extent,
    150 		pCreateInfo_mipLevels,
    151 		pCreateInfo_arrayLayers,
    152 		pCreateInfo_samples,
    153 		pCreateInfo_tiling,
    154 		pCreateInfo_usage,
    155 		pCreateInfo_sharingMode,
    156 		pCreateInfo_queueFamilyCount,
    157 		pCreateInfo_pQueueFamilyIndices,
    158 		pCreateInfo_initialLayout
    159 	};
    160 	return createImage(vk, device, &pCreateInfo);
    161 }
    162 
    163 void bindBufferMemory (const DeviceInterface& vk, VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset)
    164 {
    165 	VK_CHECK(vk.bindBufferMemory(device, buffer, mem, memOffset));
    166 }
    167 
    168 void bindImageMemory (const DeviceInterface& vk, VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset)
    169 {
    170 	VK_CHECK(vk.bindImageMemory(device, image, mem, memOffset));
    171 }
    172 
    173 Move<VkImageView> createImageView (const DeviceInterface&	vk,
    174 									VkDevice				device,
    175 									VkImageViewCreateFlags	pCreateInfo_flags,
    176 									VkImage					pCreateInfo_image,
    177 									VkImageViewType			pCreateInfo_viewType,
    178 									VkFormat				pCreateInfo_format,
    179 									VkComponentMapping		pCreateInfo_components,
    180 									VkImageSubresourceRange	pCreateInfo_subresourceRange)
    181 {
    182 	const VkImageViewCreateInfo pCreateInfo =
    183 	{
    184 		VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
    185 		DE_NULL,
    186 		pCreateInfo_flags,
    187 		pCreateInfo_image,
    188 		pCreateInfo_viewType,
    189 		pCreateInfo_format,
    190 		pCreateInfo_components,
    191 		pCreateInfo_subresourceRange,
    192 	};
    193 	return createImageView(vk, device, &pCreateInfo);
    194 }
    195 
    196 Move<VkBuffer> createBuffer (const DeviceInterface&	vk,
    197 							 VkDevice				device,
    198 							 VkBufferCreateFlags	pCreateInfo_flags,
    199 							 VkDeviceSize			pCreateInfo_size,
    200 							 VkBufferUsageFlags		pCreateInfo_usage,
    201 							 VkSharingMode			pCreateInfo_sharingMode,
    202 							 deUint32				pCreateInfo_queueFamilyCount,
    203 							 const deUint32*		pCreateInfo_pQueueFamilyIndices)
    204 {
    205 	const VkBufferCreateInfo pCreateInfo =
    206 	{
    207 		VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
    208 		DE_NULL,
    209 		pCreateInfo_flags,
    210 		pCreateInfo_size,
    211 		pCreateInfo_usage,
    212 		pCreateInfo_sharingMode,
    213 		pCreateInfo_queueFamilyCount,
    214 		pCreateInfo_pQueueFamilyIndices,
    215 	};
    216 	return createBuffer(vk, device, &pCreateInfo);
    217 }
    218 
    219 Move<VkCommandPool> createCommandPool (const DeviceInterface&	vk,
    220 									   VkDevice					device,
    221 									   VkCommandPoolCreateFlags	pCreateInfo_flags,
    222 									   deUint32					pCreateInfo_queueFamilyIndex)
    223 {
    224 	const VkCommandPoolCreateInfo pCreateInfo =
    225 	{
    226 		VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
    227 		DE_NULL,
    228 		pCreateInfo_flags,
    229 		pCreateInfo_queueFamilyIndex,
    230 	};
    231 	return createCommandPool(vk, device, &pCreateInfo);
    232 }
    233 
    234 void cmdBeginRenderPass (const DeviceInterface&	vk,
    235 						 VkCommandBuffer		cmdBuffer,
    236 						 VkRenderPass			pRenderPassBegin_renderPass,
    237 						 VkFramebuffer			pRenderPassBegin_framebuffer,
    238 						 VkRect2D				pRenderPassBegin_renderArea,
    239 						 deUint32				pRenderPassBegin_clearValueCount,
    240 						 const VkClearValue*	pRenderPassBegin_pAttachmentClearValues,
    241 						 VkSubpassContents		contents)
    242 {
    243 	const VkRenderPassBeginInfo pRenderPassBegin =
    244 	{
    245 		VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
    246 		DE_NULL,
    247 		pRenderPassBegin_renderPass,
    248 		pRenderPassBegin_framebuffer,
    249 		pRenderPassBegin_renderArea,
    250 		pRenderPassBegin_clearValueCount,
    251 		pRenderPassBegin_pAttachmentClearValues,
    252 	};
    253 	vk.cmdBeginRenderPass(cmdBuffer, &pRenderPassBegin, contents);
    254 }
    255 
    256 Move<VkCommandBuffer> allocateCommandBuffer (const DeviceInterface&	vk,
    257 											 VkDevice				device,
    258 											 VkCommandPool			pCreateInfo_commandPool,
    259 											 VkCommandBufferLevel	pCreateInfo_level)
    260 {
    261 	const VkCommandBufferAllocateInfo pAllocateInfo =
    262 	{
    263 		VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
    264 		DE_NULL,
    265 		pCreateInfo_commandPool,
    266 		pCreateInfo_level,
    267 		1u,												// bufferCount
    268 	};
    269 	return allocateCommandBuffer(vk, device, &pAllocateInfo);
    270 }
    271 
    272 void beginCommandBuffer (const DeviceInterface&			vk,
    273 						 VkCommandBuffer				cmdBuffer,
    274 						 VkCommandBufferUsageFlags		pBeginInfo_flags,
    275 						 VkRenderPass					pInheritanceInfo_renderPass,
    276 						 deUint32						pInheritanceInfo_subpass,
    277 						 VkFramebuffer					pInheritanceInfo_framebuffer,
    278 						 VkBool32						pInheritanceInfo_occlusionQueryEnable,
    279 						 VkQueryControlFlags			pInheritanceInfo_queryFlags,
    280 						 VkQueryPipelineStatisticFlags	pInheritanceInfo_pipelineStatistics)
    281 {
    282 	const VkCommandBufferInheritanceInfo	pInheritanceInfo	=
    283 	{
    284 		VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
    285 		DE_NULL,
    286 		pInheritanceInfo_renderPass,
    287 		pInheritanceInfo_subpass,
    288 		pInheritanceInfo_framebuffer,
    289 		pInheritanceInfo_occlusionQueryEnable,
    290 		pInheritanceInfo_queryFlags,
    291 		pInheritanceInfo_pipelineStatistics,
    292 	};
    293 	const VkCommandBufferBeginInfo			pBeginInfo			=
    294 	{
    295 		VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
    296 		DE_NULL,
    297 		pBeginInfo_flags,
    298 		&pInheritanceInfo,
    299 	};
    300 	VK_CHECK(vk.beginCommandBuffer(cmdBuffer, &pBeginInfo));
    301 }
    302 
    303 void endCommandBuffer (const DeviceInterface& vk, VkCommandBuffer cmdBuffer)
    304 {
    305 	VK_CHECK(vk.endCommandBuffer(cmdBuffer));
    306 }
    307 
    308 void queueSubmit (const DeviceInterface& vk, VkQueue queue, deUint32 cmdBufferCount, const VkCommandBuffer* pCmdBuffers, VkFence fence)
    309 {
    310 	const VkSubmitInfo submitInfo =
    311 	{
    312 		VK_STRUCTURE_TYPE_SUBMIT_INFO,
    313 		DE_NULL,
    314 		0u,								// waitSemaphoreCount
    315 		(const VkSemaphore*)DE_NULL,	// pWaitSemaphores
    316 		(const VkPipelineStageFlags*)DE_NULL,
    317 		cmdBufferCount,					// commandBufferCount
    318 		pCmdBuffers,
    319 		0u,								// signalSemaphoreCount
    320 		(const VkSemaphore*)DE_NULL,	// pSignalSemaphores
    321 	};
    322 	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence));
    323 }
    324 
    325 void waitForFences (const DeviceInterface& vk, VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout)
    326 {
    327 	VK_CHECK(vk.waitForFences(device, fenceCount, pFences, waitAll, timeout));
    328 }
    329 
    330 VkImageAspectFlags getImageAspectFlags (VkFormat vkFormat)
    331 {
    332 	const tcu::TextureFormat format = mapVkFormat(vkFormat);
    333 
    334 	DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 21);
    335 
    336 	switch (format.order)
    337 	{
    338 		case tcu::TextureFormat::DS:
    339 			return VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_DEPTH_BIT;
    340 
    341 		case tcu::TextureFormat::D:
    342 			return VK_IMAGE_ASPECT_DEPTH_BIT;
    343 
    344 		case tcu::TextureFormat::S:
    345 			return VK_IMAGE_ASPECT_STENCIL_BIT;
    346 
    347 		default:
    348 			return VK_IMAGE_ASPECT_COLOR_BIT;
    349 	}
    350 }
    351 
    352 VkAccessFlags getAllMemoryReadFlags (void)
    353 {
    354 	return VK_ACCESS_TRANSFER_READ_BIT
    355 		   | VK_ACCESS_UNIFORM_READ_BIT
    356 		   | VK_ACCESS_HOST_READ_BIT
    357 		   | VK_ACCESS_INDEX_READ_BIT
    358 		   | VK_ACCESS_SHADER_READ_BIT
    359 		   | VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT
    360 		   | VK_ACCESS_INDIRECT_COMMAND_READ_BIT
    361 		   | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
    362 		   | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT
    363 		   | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
    364 }
    365 
    366 VkAccessFlags getAllMemoryWriteFlags (void)
    367 {
    368 	return VK_ACCESS_TRANSFER_WRITE_BIT
    369 		   | VK_ACCESS_HOST_WRITE_BIT
    370 		   | VK_ACCESS_SHADER_WRITE_BIT
    371 		   | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
    372 		   | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
    373 }
    374 
    375 VkAccessFlags getMemoryFlagsForLayout (const VkImageLayout layout)
    376 {
    377 	switch (layout)
    378 	{
    379 		case VK_IMAGE_LAYOUT_GENERAL:							return getAllMemoryReadFlags() | getAllMemoryWriteFlags();
    380 		case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:			return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
    381 		case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:	return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
    382 		case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:	return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
    383 		case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:			return VK_ACCESS_SHADER_READ_BIT;
    384 		case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:				return VK_ACCESS_TRANSFER_READ_BIT;
    385 		case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:				return VK_ACCESS_TRANSFER_WRITE_BIT;
    386 
    387 		default:
    388 			return (VkAccessFlags)0;
    389 	}
    390 }
    391 
    392 VkPipelineStageFlags getAllPipelineStageFlags (void)
    393 {
    394 	return VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
    395 		   | VK_PIPELINE_STAGE_TRANSFER_BIT
    396 		   | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
    397 		   | VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
    398 		   | VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
    399 		   | VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
    400 		   | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
    401 		   | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
    402 		   | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
    403 		   | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
    404 		   | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
    405 		   | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
    406 		   | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
    407 }
    408 
    409 class AttachmentReference
    410 {
    411 public:
    412 					AttachmentReference		(deUint32		attachment,
    413 											 VkImageLayout	layout)
    414 		: m_attachment	(attachment)
    415 		, m_layout		(layout)
    416 	{
    417 	}
    418 
    419 	deUint32		getAttachment			(void) const { return m_attachment;	}
    420 	VkImageLayout	getImageLayout			(void) const { return m_layout;		}
    421 
    422 private:
    423 	deUint32		m_attachment;
    424 	VkImageLayout	m_layout;
    425 };
    426 
    427 class Subpass
    428 {
    429 public:
    430 										Subpass						(VkPipelineBindPoint				pipelineBindPoint,
    431 																	 VkSubpassDescriptionFlags			flags,
    432 																	 const vector<AttachmentReference>&	inputAttachments,
    433 																	 const vector<AttachmentReference>&	colorAttachments,
    434 																	 const vector<AttachmentReference>&	resolveAttachments,
    435 																	 AttachmentReference				depthStencilAttachment,
    436 																	 const vector<AttachmentReference>&	preserveAttachments)
    437 		: m_pipelineBindPoint		(pipelineBindPoint)
    438 		, m_flags					(flags)
    439 		, m_inputAttachments		(inputAttachments)
    440 		, m_colorAttachments		(colorAttachments)
    441 		, m_resolveAttachments		(resolveAttachments)
    442 		, m_depthStencilAttachment	(depthStencilAttachment)
    443 		, m_preserveAttachments		(preserveAttachments)
    444 	{
    445 	}
    446 
    447 	VkPipelineBindPoint					getPipelineBindPoint		(void) const { return m_pipelineBindPoint;		}
    448 	VkSubpassDescriptionFlags			getFlags					(void) const { return m_flags;					}
    449 	const vector<AttachmentReference>&	getInputAttachments			(void) const { return m_inputAttachments;		}
    450 	const vector<AttachmentReference>&	getColorAttachments			(void) const { return m_colorAttachments;		}
    451 	const vector<AttachmentReference>&	getResolveAttachments		(void) const { return m_resolveAttachments;		}
    452 	const AttachmentReference&			getDepthStencilAttachment	(void) const { return m_depthStencilAttachment;	}
    453 	const vector<AttachmentReference>&	getPreserveAttachments		(void) const { return m_preserveAttachments;	}
    454 
    455 private:
    456 	VkPipelineBindPoint					m_pipelineBindPoint;
    457 	VkSubpassDescriptionFlags			m_flags;
    458 
    459 	vector<AttachmentReference>			m_inputAttachments;
    460 	vector<AttachmentReference>			m_colorAttachments;
    461 	vector<AttachmentReference>			m_resolveAttachments;
    462 	AttachmentReference					m_depthStencilAttachment;
    463 
    464 	vector<AttachmentReference>			m_preserveAttachments;
    465 };
    466 
    467 class SubpassDependency
    468 {
    469 public:
    470 							SubpassDependency	(deUint32				srcPass,
    471 												 deUint32				dstPass,
    472 
    473 												 VkPipelineStageFlags	srcStageMask,
    474 												 VkPipelineStageFlags	dstStageMask,
    475 
    476 												 VkAccessFlags			outputMask,
    477 												 VkAccessFlags			inputMask,
    478 
    479 												 VkDependencyFlags		flags)
    480 		: m_srcPass			(srcPass)
    481 		, m_dstPass			(dstPass)
    482 
    483 		, m_srcStageMask	(srcStageMask)
    484 		, m_dstStageMask	(dstStageMask)
    485 
    486 		, m_outputMask		(outputMask)
    487 		, m_inputMask		(inputMask)
    488 		, m_flags			(flags)
    489 	{
    490 	}
    491 
    492 	deUint32				getSrcPass			(void) const { return m_srcPass;		}
    493 	deUint32				getDstPass			(void) const { return m_dstPass;		}
    494 
    495 	VkPipelineStageFlags	getSrcStageMask		(void) const { return m_srcStageMask;	}
    496 	VkPipelineStageFlags	getDstStageMask		(void) const { return m_dstStageMask;	}
    497 
    498 	VkAccessFlags			getOutputMask		(void) const { return m_outputMask;		}
    499 	VkAccessFlags			getInputMask		(void) const { return m_inputMask;		}
    500 
    501 	VkDependencyFlags		getFlags			(void) const { return m_flags;		}
    502 
    503 private:
    504 	deUint32				m_srcPass;
    505 	deUint32				m_dstPass;
    506 
    507 	VkPipelineStageFlags	m_srcStageMask;
    508 	VkPipelineStageFlags	m_dstStageMask;
    509 
    510 	VkAccessFlags			m_outputMask;
    511 	VkAccessFlags			m_inputMask;
    512 	VkDependencyFlags		m_flags;
    513 };
    514 
    515 class Attachment
    516 {
    517 public:
    518 						Attachment			(VkFormat				format,
    519 											 VkSampleCountFlagBits	samples,
    520 
    521 											 VkAttachmentLoadOp		loadOp,
    522 											 VkAttachmentStoreOp	storeOp,
    523 
    524 											 VkAttachmentLoadOp		stencilLoadOp,
    525 											 VkAttachmentStoreOp	stencilStoreOp,
    526 
    527 											 VkImageLayout			initialLayout,
    528 											 VkImageLayout			finalLayout)
    529 		: m_format			(format)
    530 		, m_samples			(samples)
    531 
    532 		, m_loadOp			(loadOp)
    533 		, m_storeOp			(storeOp)
    534 
    535 		, m_stencilLoadOp	(stencilLoadOp)
    536 		, m_stencilStoreOp	(stencilStoreOp)
    537 
    538 		, m_initialLayout	(initialLayout)
    539 		, m_finalLayout		(finalLayout)
    540 	{
    541 	}
    542 
    543 	VkFormat				getFormat			(void) const { return m_format;			}
    544 	VkSampleCountFlagBits	getSamples			(void) const { return m_samples;		}
    545 
    546 	VkAttachmentLoadOp		getLoadOp			(void) const { return m_loadOp;			}
    547 	VkAttachmentStoreOp		getStoreOp			(void) const { return m_storeOp;		}
    548 
    549 
    550 	VkAttachmentLoadOp		getStencilLoadOp	(void) const { return m_stencilLoadOp;	}
    551 	VkAttachmentStoreOp		getStencilStoreOp	(void) const { return m_stencilStoreOp;	}
    552 
    553 	VkImageLayout			getInitialLayout	(void) const { return m_initialLayout;	}
    554 	VkImageLayout			getFinalLayout		(void) const { return m_finalLayout;	}
    555 
    556 private:
    557 	VkFormat				m_format;
    558 	VkSampleCountFlagBits	m_samples;
    559 
    560 	VkAttachmentLoadOp		m_loadOp;
    561 	VkAttachmentStoreOp		m_storeOp;
    562 
    563 	VkAttachmentLoadOp		m_stencilLoadOp;
    564 	VkAttachmentStoreOp		m_stencilStoreOp;
    565 
    566 	VkImageLayout			m_initialLayout;
    567 	VkImageLayout			m_finalLayout;
    568 };
    569 
    570 class RenderPass
    571 {
    572 public:
    573 										RenderPass		(const vector<Attachment>&			attachments,
    574 														 const vector<Subpass>&				subpasses,
    575 														 const vector<SubpassDependency>&	dependencies)
    576 		: m_attachments		(attachments)
    577 		, m_subpasses		(subpasses)
    578 		, m_dependencies	(dependencies)
    579 	{
    580 	}
    581 
    582 	const vector<Attachment>&			getAttachments	(void) const { return m_attachments;	}
    583 	const vector<Subpass>&				getSubpasses	(void) const { return m_subpasses;		}
    584 	const vector<SubpassDependency>&	getDependencies	(void) const { return m_dependencies;	}
    585 
    586 private:
    587 	const vector<Attachment>			m_attachments;
    588 	const vector<Subpass>				m_subpasses;
    589 	const vector<SubpassDependency>		m_dependencies;
    590 };
    591 
    592 struct TestConfig
    593 {
    594 	enum RenderTypes
    595 	{
    596 		RENDERTYPES_NONE	= 0,
    597 		RENDERTYPES_CLEAR	= (1<<1),
    598 		RENDERTYPES_DRAW	= (1<<2)
    599 	};
    600 
    601 	enum CommandBufferTypes
    602 	{
    603 		COMMANDBUFFERTYPES_INLINE		= (1<<0),
    604 		COMMANDBUFFERTYPES_SECONDARY	= (1<<1)
    605 	};
    606 
    607 	enum ImageMemory
    608 	{
    609 		IMAGEMEMORY_STRICT		= (1<<0),
    610 		IMAGEMEMORY_LAZY		= (1<<1)
    611 	};
    612 
    613 	TestConfig (const RenderPass&	renderPass_,
    614 				RenderTypes			renderTypes_,
    615 				CommandBufferTypes	commandBufferTypes_,
    616 				ImageMemory			imageMemory_,
    617 				const UVec2&		targetSize_,
    618 				const UVec2&		renderPos_,
    619 				const UVec2&		renderSize_,
    620 				deUint32			seed_)
    621 		: renderPass			(renderPass_)
    622 		, renderTypes			(renderTypes_)
    623 		, commandBufferTypes	(commandBufferTypes_)
    624 		, imageMemory			(imageMemory_)
    625 		, targetSize			(targetSize_)
    626 		, renderPos				(renderPos_)
    627 		, renderSize			(renderSize_)
    628 		, seed					(seed_)
    629 	{
    630 	}
    631 
    632 	RenderPass			renderPass;
    633 	RenderTypes			renderTypes;
    634 	CommandBufferTypes	commandBufferTypes;
    635 	ImageMemory			imageMemory;
    636 	UVec2				targetSize;
    637 	UVec2				renderPos;
    638 	UVec2				renderSize;
    639 	deUint32			seed;
    640 };
    641 
    642 TestConfig::RenderTypes operator| (TestConfig::RenderTypes a, TestConfig::RenderTypes b)
    643 {
    644 	return (TestConfig::RenderTypes)(((deUint32)a) | ((deUint32)b));
    645 }
    646 
    647 TestConfig::CommandBufferTypes operator| (TestConfig::CommandBufferTypes a, TestConfig::CommandBufferTypes b)
    648 {
    649 	return (TestConfig::CommandBufferTypes)(((deUint32)a) | ((deUint32)b));
    650 }
    651 
    652 TestConfig::ImageMemory operator| (TestConfig::ImageMemory a, TestConfig::ImageMemory b)
    653 {
    654 	return (TestConfig::ImageMemory)(((deUint32)a) | ((deUint32)b));
    655 }
    656 
    657 void logRenderPassInfo (TestLog&			log,
    658 						const RenderPass&	renderPass)
    659 {
    660 	const tcu::ScopedLogSection section (log, "RenderPass", "RenderPass");
    661 
    662 	{
    663 		const tcu::ScopedLogSection	attachmentsSection	(log, "Attachments", "Attachments");
    664 		const vector<Attachment>&	attachments			= renderPass.getAttachments();
    665 
    666 		for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
    667 		{
    668 			const tcu::ScopedLogSection	attachmentSection	(log, "Attachment" + de::toString(attachmentNdx), "Attachment " + de::toString(attachmentNdx));
    669 			const Attachment&			attachment			= attachments[attachmentNdx];
    670 
    671 			log << TestLog::Message << "Format: " << attachment.getFormat() << TestLog::EndMessage;
    672 			log << TestLog::Message << "Samples: " << attachment.getSamples() << TestLog::EndMessage;
    673 
    674 			log << TestLog::Message << "LoadOp: " << attachment.getLoadOp() << TestLog::EndMessage;
    675 			log << TestLog::Message << "StoreOp: " << attachment.getStoreOp() << TestLog::EndMessage;
    676 
    677 			log << TestLog::Message << "StencilLoadOp: " << attachment.getStencilLoadOp() << TestLog::EndMessage;
    678 			log << TestLog::Message << "StencilStoreOp: " << attachment.getStencilStoreOp() << TestLog::EndMessage;
    679 
    680 			log << TestLog::Message << "InitialLayout: " << attachment.getInitialLayout() << TestLog::EndMessage;
    681 			log << TestLog::Message << "FinalLayout: " << attachment.getFinalLayout() << TestLog::EndMessage;
    682 		}
    683 	}
    684 
    685 	{
    686 		const tcu::ScopedLogSection	subpassesSection	(log, "Subpasses", "Subpasses");
    687 		const vector<Subpass>&		subpasses			= renderPass.getSubpasses();
    688 
    689 		for (size_t subpassNdx = 0; subpassNdx < subpasses.size(); subpassNdx++)
    690 		{
    691 			const tcu::ScopedLogSection			subpassSection		(log, "Subpass" + de::toString(subpassNdx), "Subpass " + de::toString(subpassNdx));
    692 			const Subpass&						subpass				= subpasses[subpassNdx];
    693 
    694 			const vector<AttachmentReference>&	inputAttachments	= subpass.getInputAttachments();
    695 			const vector<AttachmentReference>&	colorAttachments	= subpass.getColorAttachments();
    696 			const vector<AttachmentReference>&	resolveAttachments	= subpass.getResolveAttachments();
    697 			const vector<AttachmentReference>&	preserveAttachments	= subpass.getPreserveAttachments();
    698 
    699 			if (!inputAttachments.empty())
    700 			{
    701 				const tcu::ScopedLogSection		inputAttachmentsSection	(log, "Inputs", "Inputs");
    702 
    703 				for (size_t inputNdx = 0; inputNdx < inputAttachments.size(); inputNdx++)
    704 				{
    705 					const tcu::ScopedLogSection		inputAttachmentSection	(log, "Input" + de::toString(inputNdx), "Input " + de::toString(inputNdx));
    706 					const AttachmentReference&		inputAttachment			= inputAttachments[inputNdx];
    707 
    708 					log << TestLog::Message << "Attachment: " << inputAttachment.getAttachment() << TestLog::EndMessage;
    709 					log << TestLog::Message << "Layout: " << inputAttachment.getImageLayout() << TestLog::EndMessage;
    710 				}
    711 			}
    712 
    713 			if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED)
    714 			{
    715 				const tcu::ScopedLogSection		depthStencilAttachmentSection	(log, "DepthStencil", "DepthStencil");
    716 				const AttachmentReference&		depthStencilAttachment			= subpass.getDepthStencilAttachment();
    717 
    718 				log << TestLog::Message << "Attachment: " << depthStencilAttachment.getAttachment() << TestLog::EndMessage;
    719 				log << TestLog::Message << "Layout: " << depthStencilAttachment.getImageLayout() << TestLog::EndMessage;
    720 			}
    721 
    722 			if (!colorAttachments.empty())
    723 			{
    724 				const tcu::ScopedLogSection		colorAttachmentsSection	(log, "Colors", "Colors");
    725 
    726 				for (size_t colorNdx = 0; colorNdx < colorAttachments.size(); colorNdx++)
    727 				{
    728 					const tcu::ScopedLogSection		colorAttachmentSection	(log, "Color" + de::toString(colorNdx), "Color " + de::toString(colorNdx));
    729 					const AttachmentReference&		colorAttachment			= colorAttachments[colorNdx];
    730 
    731 					log << TestLog::Message << "Attachment: " << colorAttachment.getAttachment() << TestLog::EndMessage;
    732 					log << TestLog::Message << "Layout: " << colorAttachment.getImageLayout() << TestLog::EndMessage;
    733 				}
    734 			}
    735 
    736 			if (!resolveAttachments.empty())
    737 			{
    738 				const tcu::ScopedLogSection		resolveAttachmentsSection	(log, "Resolves", "Resolves");
    739 
    740 				for (size_t resolveNdx = 0; resolveNdx < resolveAttachments.size(); resolveNdx++)
    741 				{
    742 					const tcu::ScopedLogSection		resolveAttachmentSection	(log, "Resolve" + de::toString(resolveNdx), "Resolve " + de::toString(resolveNdx));
    743 					const AttachmentReference&		resolveAttachment			= resolveAttachments[resolveNdx];
    744 
    745 					log << TestLog::Message << "Attachment: " << resolveAttachment.getAttachment() << TestLog::EndMessage;
    746 					log << TestLog::Message << "Layout: " << resolveAttachment.getImageLayout() << TestLog::EndMessage;
    747 				}
    748 			}
    749 
    750 			if (!preserveAttachments.empty())
    751 			{
    752 				const tcu::ScopedLogSection		preserveAttachmentsSection	(log, "Preserves", "Preserves");
    753 
    754 				for (size_t preserveNdx = 0; preserveNdx < preserveAttachments.size(); preserveNdx++)
    755 				{
    756 					const tcu::ScopedLogSection		preserveAttachmentSection	(log, "Preserve" + de::toString(preserveNdx), "Preserve " + de::toString(preserveNdx));
    757 					const AttachmentReference&		preserveAttachment			= preserveAttachments[preserveNdx];
    758 
    759 					log << TestLog::Message << "Attachment: " << preserveAttachment.getAttachment() << TestLog::EndMessage;
    760 					log << TestLog::Message << "Layout: " << preserveAttachment.getImageLayout() << TestLog::EndMessage;
    761 				}
    762 			}
    763 		}
    764 
    765 	}
    766 
    767 	if (!renderPass.getDependencies().empty())
    768 	{
    769 		const tcu::ScopedLogSection	dependenciesSection	(log, "Dependencies", "Dependencies");
    770 
    771 		for (size_t depNdx = 0; depNdx < renderPass.getDependencies().size(); depNdx++)
    772 		{
    773 			const tcu::ScopedLogSection	dependencySection	(log, "Dependency" + de::toString(depNdx), "Dependency " + de::toString(depNdx));
    774 			const SubpassDependency&	dep					= renderPass.getDependencies()[depNdx];
    775 
    776 			log << TestLog::Message << "Source: " << dep.getSrcPass() << TestLog::EndMessage;
    777 			log << TestLog::Message << "Destination: " << dep.getDstPass() << TestLog::EndMessage;
    778 
    779 			log << TestLog::Message << "Source Stage Mask: " << dep.getSrcStageMask() << TestLog::EndMessage;
    780 			log << TestLog::Message << "Destination Stage Mask: " << dep.getDstStageMask() << TestLog::EndMessage;
    781 
    782 			log << TestLog::Message << "Input Mask: " << dep.getInputMask() << TestLog::EndMessage;
    783 			log << TestLog::Message << "Output Mask: " << dep.getOutputMask() << TestLog::EndMessage;
    784 			log << TestLog::Message << "Dependency Flags: " << getDependencyFlagsStr(dep.getFlags()) << TestLog::EndMessage;
    785 		}
    786 	}
    787 }
    788 
    789 std::string clearColorToString (VkFormat vkFormat, VkClearColorValue value)
    790 {
    791 	const tcu::TextureFormat		format			= mapVkFormat(vkFormat);
    792 	const tcu::TextureChannelClass	channelClass	= tcu::getTextureChannelClass(format.type);
    793 	const tcu::BVec4				channelMask		= tcu::getTextureFormatChannelMask(format);
    794 
    795 	std::ostringstream				stream;
    796 
    797 	stream << "(";
    798 
    799 	switch (channelClass)
    800 	{
    801 		case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
    802 			for (int i = 0; i < 4; i++)
    803 			{
    804 				if (i > 0)
    805 					stream << ", ";
    806 
    807 				if (channelMask[i])
    808 					stream << value.int32[i];
    809 				else
    810 					stream << "Undef";
    811 			}
    812 			break;
    813 
    814 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
    815 			for (int i = 0; i < 4; i++)
    816 			{
    817 				if (i > 0)
    818 					stream << ", ";
    819 
    820 				if (channelMask[i])
    821 					stream << value.uint32[i];
    822 				else
    823 					stream << "Undef";
    824 			}
    825 			break;
    826 
    827 		case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
    828 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
    829 		case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
    830 			for (int i = 0; i < 4; i++)
    831 			{
    832 				if (i > 0)
    833 					stream << ", ";
    834 
    835 				if (channelMask[i])
    836 					stream << value.float32[i];
    837 				else
    838 					stream << "Undef";
    839 			}
    840 			break;
    841 
    842 		default:
    843 			DE_FATAL("Unknown channel class");
    844 	}
    845 
    846 	stream << ")";
    847 
    848 	return stream.str();
    849 }
    850 
    851 std::string clearValueToString (VkFormat vkFormat, VkClearValue value)
    852 {
    853 	const tcu::TextureFormat	format	= mapVkFormat(vkFormat);
    854 
    855 	if (tcu::hasStencilComponent(format.order) || tcu::hasDepthComponent(format.order))
    856 	{
    857 		std::ostringstream stream;
    858 
    859 		stream << "(";
    860 
    861 		if (tcu::hasStencilComponent(format.order))
    862 			stream << "stencil: " << value.depthStencil.stencil;
    863 
    864 		if (tcu::hasStencilComponent(format.order) && tcu::hasDepthComponent(format.order))
    865 			stream << ", ";
    866 
    867 		if (tcu::hasDepthComponent(format.order))
    868 			stream << "depth: " << value.depthStencil.depth;
    869 
    870 		stream << ")";
    871 
    872 		return stream.str();
    873 	}
    874 	else
    875 		return clearColorToString(vkFormat, value.color);
    876 }
    877 
    878 VkClearColorValue randomColorClearValue (const Attachment& attachment, de::Random& rng)
    879 {
    880 	const float						clearNan		= tcu::Float32::nan().asFloat();
    881 	const tcu::TextureFormat		format			= mapVkFormat(attachment.getFormat());
    882 	const tcu::TextureChannelClass	channelClass	= tcu::getTextureChannelClass(format.type);
    883 	const tcu::BVec4				channelMask		= tcu::getTextureFormatChannelMask(format);
    884 	VkClearColorValue				clearColor;
    885 
    886 	switch (channelClass)
    887 	{
    888 		case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
    889 		{
    890 			const tcu::IVec4 valueMin = tcu::getFormatMinIntValue(format);
    891 			const tcu::IVec4 valueMax = tcu::getFormatMaxIntValue(format);
    892 
    893 			for (int ndx = 0; ndx < 4; ndx++)
    894 			{
    895 				if (!channelMask[ndx])
    896 					clearColor.int32[ndx] = std::numeric_limits<deInt32>::min();
    897 				else
    898 					clearColor.uint32[ndx] = rng.getInt(valueMin[ndx], valueMax[ndx]);
    899 			}
    900 			break;
    901 		}
    902 
    903 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
    904 		{
    905 			const UVec4 valueMax = tcu::getFormatMaxUintValue(format);
    906 
    907 			for (int ndx = 0; ndx < 4; ndx++)
    908 			{
    909 				if (!channelMask[ndx])
    910 					clearColor.uint32[ndx] = std::numeric_limits<deUint32>::max();
    911 				else
    912 					clearColor.uint32[ndx] = rng.getUint32() % valueMax[ndx];
    913 			}
    914 			break;
    915 		}
    916 
    917 		case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
    918 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
    919 		case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
    920 		{
    921 			const tcu::TextureFormatInfo	formatInfo		= tcu::getTextureFormatInfo(format);
    922 
    923 			for (int ndx = 0; ndx < 4; ndx++)
    924 			{
    925 				if (!channelMask[ndx])
    926 					clearColor.float32[ndx] = clearNan;
    927 				else
    928 					clearColor.float32[ndx] = formatInfo.valueMin[ndx] + rng.getFloat() * (formatInfo.valueMax[ndx] - formatInfo.valueMin[ndx]);
    929 			}
    930 			break;
    931 		}
    932 
    933 		default:
    934 			DE_FATAL("Unknown channel class");
    935 	}
    936 
    937 	return clearColor;
    938 }
    939 
    940 VkAttachmentDescription createAttachmentDescription (const Attachment& attachment)
    941 {
    942 	const VkAttachmentDescription attachmentDescription =
    943 	{
    944 		0,											// flags
    945 
    946 		attachment.getFormat(),						// format
    947 		attachment.getSamples(),					// samples
    948 
    949 		attachment.getLoadOp(),						// loadOp
    950 		attachment.getStoreOp(),					// storeOp
    951 
    952 		attachment.getStencilLoadOp(),				// stencilLoadOp
    953 		attachment.getStencilStoreOp(),				// stencilStoreOp
    954 
    955 		attachment.getInitialLayout(),				// initialLayout
    956 		attachment.getFinalLayout(),				// finalLayout
    957 	};
    958 
    959 	return attachmentDescription;
    960 }
    961 
    962 VkAttachmentReference createAttachmentReference (const AttachmentReference& referenceInfo)
    963 {
    964 	const VkAttachmentReference reference =
    965 	{
    966 		referenceInfo.getAttachment(),	// attachment;
    967 		referenceInfo.getImageLayout()	// layout;
    968 	};
    969 
    970 	return reference;
    971 }
    972 
    973 VkSubpassDescription createSubpassDescription (const Subpass&					subpass,
    974 											   vector<VkAttachmentReference>*	attachmentReferenceLists,
    975 											   vector<deUint32>*				preserveAttachmentReferences)
    976 {
    977 	vector<VkAttachmentReference>&	inputAttachmentReferences			= attachmentReferenceLists[0];
    978 	vector<VkAttachmentReference>&	colorAttachmentReferences			= attachmentReferenceLists[1];
    979 	vector<VkAttachmentReference>&	resolveAttachmentReferences			= attachmentReferenceLists[2];
    980 	vector<VkAttachmentReference>&	depthStencilAttachmentReferences	= attachmentReferenceLists[3];
    981 
    982 	for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
    983 		colorAttachmentReferences.push_back(createAttachmentReference(subpass.getColorAttachments()[attachmentNdx]));
    984 
    985 	for (size_t attachmentNdx = 0; attachmentNdx < subpass.getInputAttachments().size(); attachmentNdx++)
    986 		inputAttachmentReferences.push_back(createAttachmentReference(subpass.getInputAttachments()[attachmentNdx]));
    987 
    988 	for (size_t attachmentNdx = 0; attachmentNdx < subpass.getResolveAttachments().size(); attachmentNdx++)
    989 		resolveAttachmentReferences.push_back(createAttachmentReference(subpass.getResolveAttachments()[attachmentNdx]));
    990 
    991 	depthStencilAttachmentReferences.push_back(createAttachmentReference(subpass.getDepthStencilAttachment()));
    992 
    993 	for (size_t attachmentNdx = 0; attachmentNdx < subpass.getPreserveAttachments().size(); attachmentNdx++)
    994 		preserveAttachmentReferences->push_back(subpass.getPreserveAttachments()[attachmentNdx].getAttachment());
    995 
    996 	DE_ASSERT(resolveAttachmentReferences.empty() || colorAttachmentReferences.size() == resolveAttachmentReferences.size());
    997 
    998 	{
    999 		const VkSubpassDescription subpassDescription =
   1000 		{
   1001 			subpass.getFlags(),																		// flags;
   1002 			subpass.getPipelineBindPoint(),															// pipelineBindPoint;
   1003 
   1004 			(deUint32)inputAttachmentReferences.size(),												// inputCount;
   1005 			inputAttachmentReferences.empty() ? DE_NULL : &inputAttachmentReferences[0],			// inputAttachments;
   1006 
   1007 			(deUint32)colorAttachmentReferences.size(),												// colorCount;
   1008 			colorAttachmentReferences.empty() ? DE_NULL :  &colorAttachmentReferences[0],			// colorAttachments;
   1009 			resolveAttachmentReferences.empty() ? DE_NULL : &resolveAttachmentReferences[0],		// resolveAttachments;
   1010 
   1011 			&depthStencilAttachmentReferences[0],													// pDepthStencilAttachment;
   1012 			(deUint32)preserveAttachmentReferences->size(),											// preserveCount;
   1013 			preserveAttachmentReferences->empty() ? DE_NULL : &(*preserveAttachmentReferences)[0]	// preserveAttachments;
   1014 		};
   1015 
   1016 		return subpassDescription;
   1017 	}
   1018 }
   1019 
   1020 VkSubpassDependency createSubpassDependency	(const SubpassDependency& dependencyInfo)
   1021 {
   1022 	const VkSubpassDependency dependency =
   1023 	{
   1024 		dependencyInfo.getSrcPass(),			// srcSubpass;
   1025 		dependencyInfo.getDstPass(),			// destSubpass;
   1026 
   1027 		dependencyInfo.getSrcStageMask(),		// srcStageMask;
   1028 		dependencyInfo.getDstStageMask(),		// destStageMask;
   1029 
   1030 		dependencyInfo.getOutputMask(),			// outputMask;
   1031 		dependencyInfo.getInputMask(),			// inputMask;
   1032 
   1033 		dependencyInfo.getFlags()				// dependencyFlags;
   1034 	};
   1035 
   1036 	return dependency;
   1037 }
   1038 
   1039 Move<VkRenderPass> createRenderPass (const DeviceInterface&	vk,
   1040 									 VkDevice				device,
   1041 									 const RenderPass&		renderPassInfo)
   1042 {
   1043 	const size_t							perSubpassAttachmentReferenceLists = 4;
   1044 	vector<VkAttachmentDescription>			attachments;
   1045 	vector<VkSubpassDescription>			subpasses;
   1046 	vector<VkSubpassDependency>				dependencies;
   1047 	vector<vector<VkAttachmentReference> >	attachmentReferenceLists(renderPassInfo.getSubpasses().size() * perSubpassAttachmentReferenceLists);
   1048 	vector<vector<deUint32> >				preserveAttachments(renderPassInfo.getSubpasses().size());
   1049 
   1050 	for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
   1051 		attachments.push_back(createAttachmentDescription(renderPassInfo.getAttachments()[attachmentNdx]));
   1052 
   1053 	for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); subpassNdx++)
   1054 		subpasses.push_back(createSubpassDescription(renderPassInfo.getSubpasses()[subpassNdx], &(attachmentReferenceLists[subpassNdx * perSubpassAttachmentReferenceLists]), &preserveAttachments[subpassNdx]));
   1055 
   1056 	for (size_t depNdx = 0; depNdx < renderPassInfo.getDependencies().size(); depNdx++)
   1057 		dependencies.push_back(createSubpassDependency(renderPassInfo.getDependencies()[depNdx]));
   1058 
   1059 	{
   1060 		const VkRenderPassCreateInfo	createInfo	=
   1061 		{
   1062 			VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
   1063 			DE_NULL,
   1064 			(VkRenderPassCreateFlags)0u,
   1065 			(deUint32)attachments.size(),
   1066 			(attachments.empty() ? DE_NULL : &attachments[0]),
   1067 			(deUint32)subpasses.size(),
   1068 			(subpasses.empty() ? DE_NULL : &subpasses[0]),
   1069 			(deUint32)dependencies.size(),
   1070 			(dependencies.empty() ? DE_NULL : &dependencies[0])
   1071 		};
   1072 
   1073 		return createRenderPass(vk, device, &createInfo);
   1074 	}
   1075 }
   1076 
   1077 Move<VkFramebuffer> createFramebuffer (const DeviceInterface&		vk,
   1078 									   VkDevice						device,
   1079 									   VkRenderPass					renderPass,
   1080 									   const UVec2&					size,
   1081 									   const vector<VkImageView>&	attachments)
   1082 {
   1083 	return createFramebuffer(vk, device, 0u, renderPass, (deUint32)attachments.size(), attachments.empty() ? DE_NULL : &attachments[0], size.x(), size.y(), 1u);
   1084 }
   1085 
   1086 Move<VkImage> createAttachmentImage (const DeviceInterface&	vk,
   1087 									 VkDevice				device,
   1088 									 deUint32				queueIndex,
   1089 									 const UVec2&			size,
   1090 									 VkFormat				format,
   1091 									 VkSampleCountFlagBits	samples,
   1092 									 VkImageUsageFlags		usageFlags,
   1093 									 VkImageLayout			layout)
   1094 {
   1095 	const VkExtent3D size_					= { size.x(), size.y(), 1u };
   1096 	VkImageUsageFlags targetUsageFlags		= 0;
   1097 	const tcu::TextureFormat textureFormat	= mapVkFormat(format);
   1098 
   1099 	if (tcu::hasDepthComponent(textureFormat.order) || tcu::hasStencilComponent(textureFormat.order))
   1100 	{
   1101 		targetUsageFlags |= vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
   1102 	}
   1103 	else
   1104 	{
   1105 		targetUsageFlags |= vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
   1106 	}
   1107 
   1108 	return createImage(vk, device,
   1109 					   (VkImageCreateFlags)0,
   1110 					   VK_IMAGE_TYPE_2D,
   1111 					   format,
   1112 					   size_,
   1113 					   1u /* mipLevels */,
   1114 					   1u /* arraySize */,
   1115 					   samples,
   1116 					   VK_IMAGE_TILING_OPTIMAL,
   1117 					   usageFlags | targetUsageFlags,
   1118 					   VK_SHARING_MODE_EXCLUSIVE,
   1119 					   1,
   1120 					   &queueIndex,
   1121 					   layout);
   1122 }
   1123 
   1124 de::MovePtr<Allocation> createImageMemory (const DeviceInterface&	vk,
   1125 										   VkDevice					device,
   1126 										   Allocator&				allocator,
   1127 										   VkImage					image,
   1128 										   bool						lazy)
   1129 {
   1130 	de::MovePtr<Allocation> allocation (allocator.allocate(getImageMemoryRequirements(vk, device, image), lazy ? MemoryRequirement::LazilyAllocated : MemoryRequirement::Any));
   1131 	bindImageMemory(vk, device, image, allocation->getMemory(), allocation->getOffset());
   1132 	return allocation;
   1133 }
   1134 
   1135 Move<VkImageView> createImageAttachmentView (const DeviceInterface&	vk,
   1136 											 VkDevice				device,
   1137 											 VkImage				image,
   1138 											 VkFormat				format,
   1139 											 VkImageAspectFlags		aspect)
   1140 {
   1141 	const VkImageSubresourceRange range =
   1142 	{
   1143 		aspect,
   1144 		0,
   1145 		1,
   1146 		0,
   1147 		1
   1148 	};
   1149 
   1150 	return createImageView(vk, device, 0u, image, VK_IMAGE_VIEW_TYPE_2D, format, makeComponentMappingRGBA(), range);
   1151 }
   1152 
   1153 VkClearValue randomClearValue (const Attachment& attachment, de::Random& rng)
   1154 {
   1155 	const float					clearNan	= tcu::Float32::nan().asFloat();
   1156 	const tcu::TextureFormat	format		= mapVkFormat(attachment.getFormat());
   1157 
   1158 	if (tcu::hasStencilComponent(format.order) || tcu::hasDepthComponent(format.order))
   1159 	{
   1160 		VkClearValue clearValue;
   1161 
   1162 		clearValue.depthStencil.depth	= clearNan;
   1163 		clearValue.depthStencil.stencil	= 255;
   1164 
   1165 		if (tcu::hasStencilComponent(format.order))
   1166 			clearValue.depthStencil.stencil	= rng.getInt(0, 255);
   1167 
   1168 		if (tcu::hasDepthComponent(format.order))
   1169 			clearValue.depthStencil.depth	= rng.getFloat();
   1170 
   1171 		return clearValue;
   1172 	}
   1173 	else
   1174 	{
   1175 		VkClearValue clearValue;
   1176 
   1177 		clearValue.color = randomColorClearValue(attachment, rng);
   1178 
   1179 		return clearValue;
   1180 	}
   1181 }
   1182 
   1183 class AttachmentResources
   1184 {
   1185 public:
   1186 	AttachmentResources (const DeviceInterface&		vk,
   1187 						 VkDevice					device,
   1188 						 Allocator&					allocator,
   1189 						 deUint32					queueIndex,
   1190 						 const UVec2&				size,
   1191 						 const Attachment&			attachmentInfo,
   1192 						 VkImageUsageFlags			usageFlags)
   1193 		: m_image			(createAttachmentImage(vk, device, queueIndex, size, attachmentInfo.getFormat(), attachmentInfo.getSamples(), usageFlags, VK_IMAGE_LAYOUT_UNDEFINED))
   1194 		, m_imageMemory		(createImageMemory(vk, device, allocator, *m_image, ((usageFlags & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) != 0)))
   1195 		, m_attachmentView	(createImageAttachmentView(vk, device, *m_image, attachmentInfo.getFormat(), getImageAspectFlags(attachmentInfo.getFormat())))
   1196 	{
   1197 		if ((usageFlags & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) == 0)
   1198 		{
   1199 			const tcu::TextureFormat format = mapVkFormat(attachmentInfo.getFormat());
   1200 
   1201 			if (tcu::hasDepthComponent(format.order) && tcu::hasStencilComponent(format.order))
   1202 			{
   1203 				const tcu::TextureFormat	depthFormat		= getDepthCopyFormat(attachmentInfo.getFormat());
   1204 				const tcu::TextureFormat	stencilFormat	= getStencilCopyFormat(attachmentInfo.getFormat());
   1205 
   1206 				m_bufferSize			= size.x() * size.y() * depthFormat.getPixelSize();
   1207 				m_secondaryBufferSize	= size.x() * size.y() * stencilFormat.getPixelSize();
   1208 
   1209 				m_buffer				= createBuffer(vk, device, 0, m_bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_SHARING_MODE_EXCLUSIVE, 1, &queueIndex);
   1210 				m_bufferMemory			= allocator.allocate(getBufferMemoryRequirements(vk, device, *m_buffer), MemoryRequirement::HostVisible);
   1211 
   1212 				bindBufferMemory(vk, device, *m_buffer, m_bufferMemory->getMemory(), m_bufferMemory->getOffset());
   1213 
   1214 				m_secondaryBuffer		= createBuffer(vk, device, 0, m_secondaryBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_SHARING_MODE_EXCLUSIVE, 1, &queueIndex);
   1215 				m_secondaryBufferMemory	= allocator.allocate(getBufferMemoryRequirements(vk, device, *m_secondaryBuffer), MemoryRequirement::HostVisible);
   1216 
   1217 				bindBufferMemory(vk, device, *m_secondaryBuffer, m_secondaryBufferMemory->getMemory(), m_secondaryBufferMemory->getOffset());
   1218 			}
   1219 			else
   1220 			{
   1221 				m_bufferSize	= size.x() * size.y() * format.getPixelSize();
   1222 
   1223 				m_buffer		= createBuffer(vk, device, 0, m_bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_SHARING_MODE_EXCLUSIVE, 1, &queueIndex);
   1224 				m_bufferMemory	= allocator.allocate(getBufferMemoryRequirements(vk, device, *m_buffer), MemoryRequirement::HostVisible);
   1225 
   1226 				bindBufferMemory(vk, device, *m_buffer, m_bufferMemory->getMemory(), m_bufferMemory->getOffset());
   1227 			}
   1228 		}
   1229 	}
   1230 
   1231 	~AttachmentResources (void)
   1232 	{
   1233 	}
   1234 
   1235 	VkImageView getAttachmentView (void) const
   1236 	{
   1237 		return *m_attachmentView;
   1238 	}
   1239 
   1240 	VkImage getImage (void) const
   1241 	{
   1242 		return *m_image;
   1243 	}
   1244 
   1245 	VkBuffer getBuffer (void) const
   1246 	{
   1247 		DE_ASSERT(*m_buffer != DE_NULL);
   1248 		return *m_buffer;
   1249 	}
   1250 
   1251 	VkDeviceSize getBufferSize (void) const
   1252 	{
   1253 		DE_ASSERT(*m_buffer != DE_NULL);
   1254 		return m_bufferSize;
   1255 	}
   1256 
   1257 	const Allocation& getResultMemory (void) const
   1258 	{
   1259 		DE_ASSERT(m_bufferMemory);
   1260 		return *m_bufferMemory;
   1261 	}
   1262 
   1263 	VkBuffer getSecondaryBuffer (void) const
   1264 	{
   1265 		DE_ASSERT(*m_secondaryBuffer != DE_NULL);
   1266 		return *m_secondaryBuffer;
   1267 	}
   1268 
   1269 	VkDeviceSize getSecondaryBufferSize (void) const
   1270 	{
   1271 		DE_ASSERT(*m_secondaryBuffer != DE_NULL);
   1272 		return m_secondaryBufferSize;
   1273 	}
   1274 
   1275 	const Allocation& getSecondaryResultMemory (void) const
   1276 	{
   1277 		DE_ASSERT(m_secondaryBufferMemory);
   1278 		return *m_secondaryBufferMemory;
   1279 	}
   1280 
   1281 private:
   1282 	const Unique<VkImage>			m_image;
   1283 	const UniquePtr<Allocation>		m_imageMemory;
   1284 	const Unique<VkImageView>		m_attachmentView;
   1285 
   1286 	Move<VkBuffer>					m_buffer;
   1287 	VkDeviceSize					m_bufferSize;
   1288 	de::MovePtr<Allocation>			m_bufferMemory;
   1289 
   1290 	Move<VkBuffer>					m_secondaryBuffer;
   1291 	VkDeviceSize					m_secondaryBufferSize;
   1292 	de::MovePtr<Allocation>			m_secondaryBufferMemory;
   1293 };
   1294 
   1295 void uploadBufferData (const DeviceInterface&	vk,
   1296 					   VkDevice					device,
   1297 					   const Allocation&		memory,
   1298 					   size_t					size,
   1299 					   const void*				data)
   1300 {
   1301 	const VkMappedMemoryRange range =
   1302 	{
   1303 		VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,	// sType;
   1304 		DE_NULL,								// pNext;
   1305 		memory.getMemory(),						// mem;
   1306 		memory.getOffset(),						// offset;
   1307 		(VkDeviceSize)size						// size;
   1308 	};
   1309 	void* const ptr = memory.getHostPtr();
   1310 
   1311 	deMemcpy(ptr, data, size);
   1312 	VK_CHECK(vk.flushMappedMemoryRanges(device, 1, &range));
   1313 }
   1314 
   1315 VkImageAspectFlagBits getPrimaryImageAspect (tcu::TextureFormat::ChannelOrder order)
   1316 {
   1317 	DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 21);
   1318 
   1319 	switch (order)
   1320 	{
   1321 		case tcu::TextureFormat::D:
   1322 		case tcu::TextureFormat::DS:
   1323 			return VK_IMAGE_ASPECT_DEPTH_BIT;
   1324 
   1325 		case tcu::TextureFormat::S:
   1326 			return VK_IMAGE_ASPECT_STENCIL_BIT;
   1327 
   1328 		default:
   1329 			return VK_IMAGE_ASPECT_COLOR_BIT;
   1330 	}
   1331 }
   1332 
   1333 class RenderQuad
   1334 {
   1335 public:
   1336 	RenderQuad (const Vec4& posA, const Vec4& posB)
   1337 		: m_vertices(6)
   1338 	{
   1339 		m_vertices[0] = posA;
   1340 		m_vertices[1] = Vec4(posA[0], posB[1], posA[2], posA[3]);
   1341 		m_vertices[2] = posB;
   1342 
   1343 		m_vertices[3] = posB;
   1344 		m_vertices[4] = Vec4(posB[0], posA[1], posB[2], posA[3]);
   1345 		m_vertices[5] = posA;
   1346 	}
   1347 
   1348 	const Vec4&		getCornerA			(void) const
   1349 	{
   1350 		return m_vertices[0];
   1351 	}
   1352 
   1353 	const Vec4&		getCornerB			(void) const
   1354 	{
   1355 		return m_vertices[2];
   1356 	}
   1357 
   1358 	const void*		getVertexPointer	(void) const
   1359 	{
   1360 		return &m_vertices[0];
   1361 	}
   1362 
   1363 	size_t			getVertexDataSize	(void) const
   1364 	{
   1365 		return sizeof(Vec4) * m_vertices.size();
   1366 	}
   1367 
   1368 private:
   1369 	vector<Vec4>	m_vertices;
   1370 };
   1371 
   1372 class ColorClear
   1373 {
   1374 public:
   1375 	ColorClear	(const UVec2&				offset,
   1376 				 const UVec2&				size,
   1377 				 const VkClearColorValue&	color)
   1378 		: m_offset	(offset)
   1379 		, m_size	(size)
   1380 		, m_color	(color)
   1381 	{
   1382 	}
   1383 
   1384 	const UVec2&				getOffset		(void) const { return m_offset;		}
   1385 	const UVec2&				getSize			(void) const { return m_size;		}
   1386 	const VkClearColorValue&	getColor		(void) const { return m_color;		}
   1387 
   1388 private:
   1389 	UVec2				m_offset;
   1390 	UVec2				m_size;
   1391 	VkClearColorValue	m_color;
   1392 };
   1393 
   1394 class DepthStencilClear
   1395 {
   1396 public:
   1397 	DepthStencilClear	(const UVec2&				offset,
   1398 						 const UVec2&				size,
   1399 						 float						depth,
   1400 						 deUint32					stencil)
   1401 		: m_offset	(offset)
   1402 		, m_size	(size)
   1403 		, m_depth	(depth)
   1404 		, m_stencil	(stencil)
   1405 	{
   1406 	}
   1407 
   1408 	const UVec2&		getOffset		(void) const { return m_offset;		}
   1409 	const UVec2&		getSize			(void) const { return m_size;		}
   1410 	float				getDepth		(void) const { return m_depth;		}
   1411 	deUint32			getStencil		(void) const { return m_stencil;	}
   1412 
   1413 private:
   1414 	UVec2				m_offset;
   1415 	UVec2				m_size;
   1416 
   1417 	float				m_depth;
   1418 	deUint32			m_stencil;
   1419 };
   1420 
   1421 class SubpassRenderInfo
   1422 {
   1423 public:
   1424 	SubpassRenderInfo	(const RenderPass&					renderPass,
   1425 						 deUint32							subpassIndex,
   1426 
   1427 						 bool								isSecondary_,
   1428 
   1429 						 const UVec2&						viewportOffset,
   1430 						 const UVec2&						viewportSize,
   1431 
   1432 						 const Maybe<RenderQuad>&			renderQuad,
   1433 						 const vector<ColorClear>&			colorClears,
   1434 						 const Maybe<DepthStencilClear>&	depthStencilClear)
   1435 		: m_viewportOffset		(viewportOffset)
   1436 		, m_viewportSize		(viewportSize)
   1437 		, m_subpassIndex		(subpassIndex)
   1438 		, m_isSecondary			(isSecondary_)
   1439 		, m_flags				(renderPass.getSubpasses()[subpassIndex].getFlags())
   1440 		, m_renderQuad			(renderQuad)
   1441 		, m_colorClears			(colorClears)
   1442 		, m_depthStencilClear	(depthStencilClear)
   1443 		, m_colorAttachments	(renderPass.getSubpasses()[subpassIndex].getColorAttachments())
   1444 	{
   1445 		for (deUint32 attachmentNdx = 0; attachmentNdx < (deUint32)m_colorAttachments.size(); attachmentNdx++)
   1446 			m_colorAttachmentInfo.push_back(renderPass.getAttachments()[m_colorAttachments[attachmentNdx].getAttachment()]);
   1447 
   1448 		if (renderPass.getSubpasses()[subpassIndex].getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED)
   1449 		{
   1450 			m_depthStencilAttachment		= tcu::just(renderPass.getSubpasses()[subpassIndex].getDepthStencilAttachment());
   1451 			m_depthStencilAttachmentInfo	= tcu::just(renderPass.getAttachments()[renderPass.getSubpasses()[subpassIndex].getDepthStencilAttachment().getAttachment()]);
   1452 		}
   1453 	}
   1454 
   1455 	const UVec2&						getViewportOffset				(void) const { return m_viewportOffset;		}
   1456 	const UVec2&						getViewportSize					(void) const { return m_viewportSize;		}
   1457 
   1458 	deUint32							getSubpassIndex					(void) const { return m_subpassIndex;		}
   1459 	bool								isSecondary						(void) const { return m_isSecondary;		}
   1460 
   1461 	const Maybe<RenderQuad>&			getRenderQuad					(void) const { return m_renderQuad;			}
   1462 	const vector<ColorClear>&			getColorClears					(void) const { return m_colorClears;		}
   1463 	const Maybe<DepthStencilClear>&		getDepthStencilClear			(void) const { return m_depthStencilClear;	}
   1464 
   1465 	deUint32							getColorAttachmentCount			(void) const { return (deUint32)m_colorAttachments.size(); }
   1466 	VkImageLayout						getColorAttachmentLayout		(deUint32 attachmentNdx) const { return m_colorAttachments[attachmentNdx].getImageLayout(); }
   1467 	deUint32							getColorAttachmentIndex			(deUint32 attachmentNdx) const { return m_colorAttachments[attachmentNdx].getAttachment(); }
   1468 	const Attachment&					getColorAttachment				(deUint32 attachmentNdx) const { return m_colorAttachmentInfo[attachmentNdx]; }
   1469 	Maybe<VkImageLayout>				getDepthStencilAttachmentLayout	(void) const { return m_depthStencilAttachment ? tcu::just(m_depthStencilAttachment->getImageLayout()) : tcu::nothing<VkImageLayout>(); }
   1470 	Maybe<deUint32>						getDepthStencilAttachmentIndex	(void) const { return m_depthStencilAttachment ? tcu::just(m_depthStencilAttachment->getAttachment()) : tcu::nothing<deUint32>(); };
   1471 	const Maybe<Attachment>&			getDepthStencilAttachment		(void) const { return m_depthStencilAttachmentInfo; }
   1472 	VkSubpassDescriptionFlags			getSubpassFlags					(void) const { return m_flags; }
   1473 private:
   1474 	UVec2								m_viewportOffset;
   1475 	UVec2								m_viewportSize;
   1476 
   1477 	deUint32							m_subpassIndex;
   1478 	bool								m_isSecondary;
   1479 	VkSubpassDescriptionFlags			m_flags;
   1480 
   1481 	Maybe<RenderQuad>					m_renderQuad;
   1482 	vector<ColorClear>					m_colorClears;
   1483 	Maybe<DepthStencilClear>			m_depthStencilClear;
   1484 
   1485 	vector<AttachmentReference>			m_colorAttachments;
   1486 	vector<Attachment>					m_colorAttachmentInfo;
   1487 
   1488 	Maybe<AttachmentReference>			m_depthStencilAttachment;
   1489 	Maybe<Attachment>					m_depthStencilAttachmentInfo;
   1490 };
   1491 
   1492 Move<VkPipeline> createSubpassPipeline (const DeviceInterface&		vk,
   1493 										VkDevice					device,
   1494 										VkRenderPass				renderPass,
   1495 										VkShaderModule				vertexShaderModule,
   1496 										VkShaderModule				fragmentShaderModule,
   1497 										VkPipelineLayout			pipelineLayout,
   1498 										const SubpassRenderInfo&	renderInfo)
   1499 {
   1500 	const VkSpecializationInfo emptyShaderSpecializations =
   1501 	{
   1502 		0u,			// mapEntryCount
   1503 		DE_NULL,	// pMap
   1504 		0u,			// dataSize
   1505 		DE_NULL,	// pData
   1506 	};
   1507 
   1508 	Maybe<VkSampleCountFlagBits>				rasterSamples;
   1509 	vector<VkPipelineColorBlendAttachmentState>	attachmentBlendStates;
   1510 
   1511 	for (deUint32 attachmentNdx = 0; attachmentNdx < renderInfo.getColorAttachmentCount(); attachmentNdx++)
   1512 	{
   1513 		const Attachment&			attachment		= renderInfo.getColorAttachment(attachmentNdx);
   1514 
   1515 		DE_ASSERT(!rasterSamples || *rasterSamples == attachment.getSamples());
   1516 
   1517 		rasterSamples = attachment.getSamples();
   1518 
   1519 		{
   1520 			const VkPipelineColorBlendAttachmentState	attachmentBlendState =
   1521 			{
   1522 				VK_FALSE,																								// blendEnable
   1523 				VK_BLEND_FACTOR_SRC_ALPHA,																				// srcBlendColor
   1524 				VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,																	// destBlendColor
   1525 				VK_BLEND_OP_ADD,																						// blendOpColor
   1526 				VK_BLEND_FACTOR_ONE,																					// srcBlendAlpha
   1527 				VK_BLEND_FACTOR_ONE,																					// destBlendAlpha
   1528 				VK_BLEND_OP_ADD,																						// blendOpAlpha
   1529 				VK_COLOR_COMPONENT_R_BIT|VK_COLOR_COMPONENT_G_BIT|VK_COLOR_COMPONENT_B_BIT|VK_COLOR_COMPONENT_A_BIT,	// channelWriteMask
   1530 			};
   1531 
   1532 			attachmentBlendStates.push_back(attachmentBlendState);
   1533 		}
   1534 	}
   1535 
   1536 	if (renderInfo.getDepthStencilAttachment())
   1537 	{
   1538 		const Attachment& attachment = *renderInfo.getDepthStencilAttachment();
   1539 
   1540 		DE_ASSERT(!rasterSamples || *rasterSamples == attachment.getSamples());
   1541 		rasterSamples = attachment.getSamples();
   1542 	}
   1543 
   1544 	// If there are no attachment use single sample
   1545 	if (!rasterSamples)
   1546 		rasterSamples = VK_SAMPLE_COUNT_1_BIT;
   1547 
   1548 	const VkPipelineShaderStageCreateInfo shaderStages[2] =
   1549 	{
   1550 		{
   1551 			VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,	// sType
   1552 			DE_NULL,												// pNext
   1553 			(VkPipelineShaderStageCreateFlags)0u,
   1554 			VK_SHADER_STAGE_VERTEX_BIT,								// stage
   1555 			vertexShaderModule,										// shader
   1556 			"main",
   1557 			&emptyShaderSpecializations
   1558 		},
   1559 		{
   1560 			VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,	// sType
   1561 			DE_NULL,												// pNext
   1562 			(VkPipelineShaderStageCreateFlags)0u,
   1563 			VK_SHADER_STAGE_FRAGMENT_BIT,							// stage
   1564 			fragmentShaderModule,									// shader
   1565 			"main",
   1566 			&emptyShaderSpecializations
   1567 		}
   1568 	};
   1569 	const VkVertexInputBindingDescription vertexBinding =
   1570 	{
   1571 		0u,															// binding
   1572 		(deUint32)sizeof(tcu::Vec4),								// strideInBytes
   1573 		VK_VERTEX_INPUT_RATE_VERTEX,								// stepRate
   1574 	};
   1575 	const VkVertexInputAttributeDescription vertexAttrib =
   1576 	{
   1577 		0u,															// location
   1578 		0u,															// binding
   1579 		VK_FORMAT_R32G32B32A32_SFLOAT,								// format
   1580 		0u,															// offsetInBytes
   1581 	};
   1582 	const VkPipelineVertexInputStateCreateInfo vertexInputState =
   1583 	{
   1584 		VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,	//	sType
   1585 		DE_NULL,													//	pNext
   1586 		(VkPipelineVertexInputStateCreateFlags)0u,
   1587 		1u,															//	bindingCount
   1588 		&vertexBinding,												//	pVertexBindingDescriptions
   1589 		1u,															//	attributeCount
   1590 		&vertexAttrib,												//	pVertexAttributeDescriptions
   1591 	};
   1592 	const VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
   1593 	{
   1594 		VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,	// sType
   1595 		DE_NULL,														// pNext
   1596 		(VkPipelineInputAssemblyStateCreateFlags)0u,
   1597 		VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,							// topology
   1598 		VK_FALSE,														// primitiveRestartEnable
   1599 	};
   1600 	const VkViewport viewport =
   1601 	{
   1602 		(float)renderInfo.getViewportOffset().x(),	(float)renderInfo.getViewportOffset().y(),
   1603 		(float)renderInfo.getViewportSize().x(),	(float)renderInfo.getViewportSize().y(),
   1604 		0.0f, 1.0f
   1605 	};
   1606 	const VkRect2D scissor =
   1607 	{
   1608 		{ (deInt32)renderInfo.getViewportOffset().x(),	(deInt32)renderInfo.getViewportOffset().y() },
   1609 		{ renderInfo.getViewportSize().x(),				renderInfo.getViewportSize().y() }
   1610 	};
   1611 	const VkPipelineViewportStateCreateInfo viewportState =
   1612 	{
   1613 		VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
   1614 		DE_NULL,
   1615 		(VkPipelineViewportStateCreateFlags)0u,
   1616 		1u,
   1617 		&viewport,
   1618 		1u,
   1619 		&scissor
   1620 	};
   1621 	const VkPipelineRasterizationStateCreateInfo rasterState =
   1622 	{
   1623 		VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,		// sType
   1624 		DE_NULL,														// pNext
   1625 		(VkPipelineRasterizationStateCreateFlags)0u,
   1626 		VK_TRUE,														// depthClipEnable
   1627 		VK_FALSE,														// rasterizerDiscardEnable
   1628 		VK_POLYGON_MODE_FILL,											// fillMode
   1629 		VK_CULL_MODE_NONE,												// cullMode
   1630 		VK_FRONT_FACE_COUNTER_CLOCKWISE,								// frontFace
   1631 		VK_FALSE,														// depthBiasEnable
   1632 		0.0f,															// depthBias
   1633 		0.0f,															// depthBiasClamp
   1634 		0.0f,															// slopeScaledDepthBias
   1635 		1.0f															// lineWidth
   1636 	};
   1637 	const VkPipelineMultisampleStateCreateInfo multisampleState =
   1638 	{
   1639 		VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,		// sType
   1640 		DE_NULL,														// pNext
   1641 		(VkPipelineMultisampleStateCreateFlags)0u,
   1642 		*rasterSamples,													// rasterSamples
   1643 		VK_FALSE,														// sampleShadingEnable
   1644 		0.0f,															// minSampleShading
   1645 		DE_NULL,														// pSampleMask
   1646 		VK_FALSE,														// alphaToCoverageEnable
   1647 		VK_FALSE,														// alphaToOneEnable
   1648 	};
   1649 	const VkPipelineDepthStencilStateCreateInfo depthStencilState =
   1650 	{
   1651 		VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,	// sType
   1652 		DE_NULL,													// pNext
   1653 		(VkPipelineDepthStencilStateCreateFlags)0u,
   1654 		VK_TRUE,													// depthTestEnable
   1655 		VK_TRUE,													// depthWriteEnable
   1656 		VK_COMPARE_OP_ALWAYS,										// depthCompareOp
   1657 		VK_FALSE,													// depthBoundsEnable
   1658 		VK_TRUE,													// stencilTestEnable
   1659 		{
   1660 			VK_STENCIL_OP_REPLACE,									// stencilFailOp
   1661 			VK_STENCIL_OP_REPLACE,									// stencilPassOp
   1662 			VK_STENCIL_OP_REPLACE,									// stencilDepthFailOp
   1663 			VK_COMPARE_OP_ALWAYS,									// stencilCompareOp
   1664 			~0u,													// stencilCompareMask
   1665 			~0u,													// stencilWriteMask
   1666 			STENCIL_VALUE											// stencilReference
   1667 		},															// front
   1668 		{
   1669 			VK_STENCIL_OP_REPLACE,									// stencilFailOp
   1670 			VK_STENCIL_OP_REPLACE,									// stencilPassOp
   1671 			VK_STENCIL_OP_REPLACE,									// stencilDepthFailOp
   1672 			VK_COMPARE_OP_ALWAYS,									// stencilCompareOp
   1673 			~0u,													// stencilCompareMask
   1674 			~0u,													// stencilWriteMask
   1675 			STENCIL_VALUE											// stencilReference
   1676 		},															// back
   1677 
   1678 		0.0f,														// minDepthBounds;
   1679 		1.0f														// maxDepthBounds;
   1680 	};
   1681 	const VkPipelineColorBlendStateCreateInfo blendState =
   1682 	{
   1683 		VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,			// sType
   1684 		DE_NULL,															// pNext
   1685 		(VkPipelineColorBlendStateCreateFlags)0u,
   1686 		VK_FALSE,															// logicOpEnable
   1687 		VK_LOGIC_OP_COPY,													// logicOp
   1688 		(deUint32)attachmentBlendStates.size(),								// attachmentCount
   1689 		attachmentBlendStates.empty() ? DE_NULL : &attachmentBlendStates[0],// pAttachments
   1690 		{ 0.0f, 0.0f, 0.0f, 0.0f }											// blendConst
   1691 	};
   1692 	const VkGraphicsPipelineCreateInfo createInfo =
   1693 	{
   1694 		VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,		// sType
   1695 		DE_NULL,												// pNext
   1696 		(VkPipelineCreateFlags)0u,
   1697 
   1698 		2,														// stageCount
   1699 		shaderStages,											// pStages
   1700 
   1701 		&vertexInputState,										// pVertexInputState
   1702 		&inputAssemblyState,									// pInputAssemblyState
   1703 		DE_NULL,												// pTessellationState
   1704 		&viewportState,											// pViewportState
   1705 		&rasterState,											// pRasterState
   1706 		&multisampleState,										// pMultisampleState
   1707 		&depthStencilState,										// pDepthStencilState
   1708 		&blendState,											// pColorBlendState
   1709 		(const VkPipelineDynamicStateCreateInfo*)DE_NULL,		// pDynamicState
   1710 		pipelineLayout,											// layout
   1711 
   1712 		renderPass,												// renderPass
   1713 		renderInfo.getSubpassIndex(),							// subpass
   1714 		DE_NULL,												// basePipelineHandle
   1715 		0u														// basePipelineIndex
   1716 	};
   1717 
   1718 	return createGraphicsPipeline(vk, device, DE_NULL, &createInfo);
   1719 }
   1720 
   1721 class SubpassRenderer
   1722 {
   1723 public:
   1724 	SubpassRenderer (Context&					context,
   1725 					 const DeviceInterface&		vk,
   1726 					 VkDevice					device,
   1727 					 Allocator&					allocator,
   1728 					 VkRenderPass				renderPass,
   1729 					 VkFramebuffer				framebuffer,
   1730 					 VkCommandPool				commandBufferPool,
   1731 					 deUint32					queueFamilyIndex,
   1732 					 const SubpassRenderInfo&	renderInfo)
   1733 		: m_renderInfo	(renderInfo)
   1734 	{
   1735 		const deUint32 subpassIndex = renderInfo.getSubpassIndex();
   1736 
   1737 		if (renderInfo.getRenderQuad())
   1738 		{
   1739 			const RenderQuad&					renderQuad				= *renderInfo.getRenderQuad();
   1740 			const VkPipelineLayoutCreateInfo	pipelineLayoutParams	=
   1741 			{
   1742 				VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,	// sType;
   1743 				DE_NULL,										// pNext;
   1744 				(vk::VkPipelineLayoutCreateFlags)0,
   1745 				0u,												// descriptorSetCount;
   1746 				DE_NULL,										// pSetLayouts;
   1747 				0u,												// pushConstantRangeCount;
   1748 				DE_NULL,										// pPushConstantRanges;
   1749 			};
   1750 
   1751 			m_vertexShaderModule	= createShaderModule(vk, device, context.getBinaryCollection().get(de::toString(subpassIndex) + "-vert"), 0u);
   1752 			m_fragmentShaderModule	= createShaderModule(vk, device, context.getBinaryCollection().get(de::toString(subpassIndex) + "-frag"), 0u);
   1753 			m_pipelineLayout		= createPipelineLayout(vk, device, &pipelineLayoutParams);
   1754 			m_pipeline				= createSubpassPipeline(vk, device, renderPass, *m_vertexShaderModule, *m_fragmentShaderModule, *m_pipelineLayout, m_renderInfo);
   1755 
   1756 			m_vertexBuffer			= createBuffer(vk, device, 0u, (VkDeviceSize)renderQuad.getVertexDataSize(), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_SHARING_MODE_EXCLUSIVE, 1u, &queueFamilyIndex);
   1757 			m_vertexBufferMemory	= allocator.allocate(getBufferMemoryRequirements(vk, device, *m_vertexBuffer), MemoryRequirement::HostVisible);
   1758 
   1759 			bindBufferMemory(vk, device, *m_vertexBuffer, m_vertexBufferMemory->getMemory(), m_vertexBufferMemory->getOffset());
   1760 			uploadBufferData(vk, device, *m_vertexBufferMemory, renderQuad.getVertexDataSize(), renderQuad.getVertexPointer());
   1761 		}
   1762 
   1763 		if (renderInfo.isSecondary())
   1764 		{
   1765 			m_commandBuffer = allocateCommandBuffer(vk, device, commandBufferPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
   1766 
   1767 			beginCommandBuffer(vk, *m_commandBuffer, vk::VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, renderPass, subpassIndex, framebuffer, VK_FALSE, (VkQueryControlFlags)0, (VkQueryPipelineStatisticFlags)0);
   1768 			pushRenderCommands(vk, *m_commandBuffer);
   1769 			endCommandBuffer(vk, *m_commandBuffer);
   1770 		}
   1771 	}
   1772 
   1773 	bool isSecondary (void) const
   1774 	{
   1775 		return m_commandBuffer;
   1776 	}
   1777 
   1778 	VkCommandBuffer getCommandBuffer (void) const
   1779 	{
   1780 		DE_ASSERT(isSecondary());
   1781 		return *m_commandBuffer;
   1782 	}
   1783 
   1784 	void pushRenderCommands (const DeviceInterface&		vk,
   1785 							 VkCommandBuffer			commandBuffer)
   1786 	{
   1787 		if (!m_renderInfo.getColorClears().empty())
   1788 		{
   1789 			const vector<ColorClear>&	colorClears	(m_renderInfo.getColorClears());
   1790 
   1791 			for (deUint32 attachmentNdx = 0; attachmentNdx < m_renderInfo.getColorAttachmentCount(); attachmentNdx++)
   1792 			{
   1793 				const ColorClear&		colorClear	= colorClears[attachmentNdx];
   1794 				const VkClearAttachment	attachment	=
   1795 				{
   1796 					VK_IMAGE_ASPECT_COLOR_BIT,
   1797 					attachmentNdx,
   1798 					makeClearValue(colorClear.getColor()),
   1799 				};
   1800 				const VkClearRect		rect		=
   1801 				{
   1802 					{
   1803 						{ (deInt32)colorClear.getOffset().x(),	(deInt32)colorClear.getOffset().y()	},
   1804 						{ colorClear.getSize().x(),				colorClear.getSize().y()			}
   1805 					},					// rect
   1806 					0u,					// baseArrayLayer
   1807 					1u,					// layerCount
   1808 				};
   1809 
   1810 				vk.cmdClearAttachments(commandBuffer, 1u, &attachment, 1u, &rect);
   1811 			}
   1812 		}
   1813 
   1814 		if (m_renderInfo.getDepthStencilClear())
   1815 		{
   1816 			const DepthStencilClear&		depthStencilClear	= *m_renderInfo.getDepthStencilClear();
   1817 			const deUint32					attachmentNdx		= m_renderInfo.getColorAttachmentCount();
   1818 			tcu::TextureFormat				format				= mapVkFormat(m_renderInfo.getDepthStencilAttachment()->getFormat());
   1819 			const VkClearAttachment			attachment			=
   1820 			{
   1821 				(VkImageAspectFlags)((hasDepthComponent(format.order) ? VK_IMAGE_ASPECT_DEPTH_BIT : 0)
   1822 					| (hasStencilComponent(format.order) ? VK_IMAGE_ASPECT_STENCIL_BIT : 0)),
   1823 				attachmentNdx,
   1824 				makeClearValueDepthStencil(depthStencilClear.getDepth(), depthStencilClear.getStencil())
   1825 			};
   1826 			const VkClearRect				rect				=
   1827 			{
   1828 				{
   1829 					{ (deInt32)depthStencilClear.getOffset().x(),	(deInt32)depthStencilClear.getOffset().y()	},
   1830 					{ depthStencilClear.getSize().x(),				depthStencilClear.getSize().y()				}
   1831 				},							// rect
   1832 				0u,							// baseArrayLayer
   1833 				1u,							// layerCount
   1834 			};
   1835 
   1836 			vk.cmdClearAttachments(commandBuffer, 1u, &attachment, 1u, &rect);
   1837 		}
   1838 
   1839 		if (m_renderInfo.getRenderQuad())
   1840 		{
   1841 			const VkDeviceSize	offset			= 0;
   1842 			const VkBuffer		vertexBuffer	= *m_vertexBuffer;
   1843 
   1844 			vk.cmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
   1845 			vk.cmdBindVertexBuffers(commandBuffer, 0u, 1u, &vertexBuffer, &offset);
   1846 			vk.cmdDraw(commandBuffer, 6u, 1u, 0u, 0u);
   1847 		}
   1848 	}
   1849 
   1850 private:
   1851 	const SubpassRenderInfo				m_renderInfo;
   1852 	Move<VkCommandBuffer>				m_commandBuffer;
   1853 	Move<VkPipeline>					m_pipeline;
   1854 	Move<VkPipelineLayout>				m_pipelineLayout;
   1855 
   1856 	Move<VkShaderModule>				m_vertexShaderModule;
   1857 
   1858 	Move<VkShaderModule>				m_fragmentShaderModule;
   1859 
   1860 	Move<VkBuffer>						m_vertexBuffer;
   1861 	de::MovePtr<Allocation>				m_vertexBufferMemory;
   1862 };
   1863 
   1864 void pushImageInitializationCommands (const DeviceInterface&								vk,
   1865 									  VkCommandBuffer										commandBuffer,
   1866 									  const vector<Attachment>&								attachmentInfo,
   1867 									  const vector<de::SharedPtr<AttachmentResources> >&	attachmentResources,
   1868 									  deUint32												queueIndex,
   1869 									  const vector<Maybe<VkClearValue> >&					clearValues)
   1870 {
   1871 	{
   1872 		vector<VkImageMemoryBarrier>	initializeLayouts;
   1873 
   1874 		for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
   1875 		{
   1876 			if (!clearValues[attachmentNdx])
   1877 				continue;
   1878 
   1879 			const VkImageMemoryBarrier barrier =
   1880 			{
   1881 				VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,							// sType;
   1882 				DE_NULL,														// pNext;
   1883 
   1884 				(VkAccessFlags)0,												// srcAccessMask
   1885 				getAllMemoryReadFlags() | VK_ACCESS_TRANSFER_WRITE_BIT,			// dstAccessMask
   1886 
   1887 				VK_IMAGE_LAYOUT_UNDEFINED,										// oldLayout
   1888 				VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,							// newLayout;
   1889 
   1890 				queueIndex,														// srcQueueFamilyIndex;
   1891 				queueIndex,														// destQueueFamilyIndex;
   1892 
   1893 				attachmentResources[attachmentNdx]->getImage(),					// image;
   1894 				{																// subresourceRange;
   1895 					getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()),		// aspect;
   1896 					0,																	// baseMipLevel;
   1897 					1,																	// mipLevels;
   1898 					0,																	// baseArraySlice;
   1899 					1																	// arraySize;
   1900 				}
   1901 			};
   1902 
   1903 			initializeLayouts.push_back(barrier);
   1904 		}
   1905 
   1906 		if (!initializeLayouts.empty())
   1907 			vk.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
   1908 								  VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0,
   1909 								  0, (const VkMemoryBarrier*)DE_NULL,
   1910 								  0, (const VkBufferMemoryBarrier*)DE_NULL,
   1911 								  (deUint32)initializeLayouts.size(), &initializeLayouts[0]);
   1912 	}
   1913 
   1914 	for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
   1915 	{
   1916 		if (!clearValues[attachmentNdx])
   1917 			continue;
   1918 
   1919 		const tcu::TextureFormat format = mapVkFormat(attachmentInfo[attachmentNdx].getFormat());
   1920 
   1921 		if (hasStencilComponent(format.order) || hasDepthComponent(format.order))
   1922 		{
   1923 			const float						clearNan		= tcu::Float32::nan().asFloat();
   1924 			const float						clearDepth		= hasDepthComponent(format.order) ? clearValues[attachmentNdx]->depthStencil.depth : clearNan;
   1925 			const deUint32					clearStencil	= hasStencilComponent(format.order) ? clearValues[attachmentNdx]->depthStencil.stencil : ~0u;
   1926 			const VkClearDepthStencilValue	depthStencil	=
   1927 			{
   1928 				clearDepth,
   1929 				clearStencil
   1930 			};
   1931 			const VkImageSubresourceRange range =
   1932 			{
   1933 				(VkImageAspectFlags)((hasDepthComponent(format.order) ? VK_IMAGE_ASPECT_DEPTH_BIT : 0)
   1934 									 | (hasStencilComponent(format.order) ? VK_IMAGE_ASPECT_STENCIL_BIT : 0)),
   1935 				0,
   1936 				1,
   1937 				0,
   1938 				1
   1939 			};
   1940 
   1941 			vk.cmdClearDepthStencilImage(commandBuffer, attachmentResources[attachmentNdx]->getImage(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &depthStencil, 1, &range);
   1942 		}
   1943 		else
   1944 		{
   1945 			const VkImageSubresourceRange	range		=
   1946 			{
   1947 				VK_IMAGE_ASPECT_COLOR_BIT,				// aspectMask;
   1948 				0,										// baseMipLevel;
   1949 				1,										// mipLevels;
   1950 				0,										// baseArrayLayer;
   1951 				1										// layerCount;
   1952 			};
   1953 			const VkClearColorValue			clearColor	= clearValues[attachmentNdx]->color;
   1954 
   1955 			vk.cmdClearColorImage(commandBuffer, attachmentResources[attachmentNdx]->getImage(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColor, 1, &range);
   1956 		}
   1957 	}
   1958 
   1959 	{
   1960 		vector<VkImageMemoryBarrier>	renderPassLayouts;
   1961 
   1962 		for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
   1963 		{
   1964 			const VkImageLayout			oldLayout = clearValues[attachmentNdx] ? VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED;
   1965 			const VkImageMemoryBarrier	barrier   =
   1966 			{
   1967 				VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,					// sType;
   1968 				DE_NULL,												// pNext;
   1969 
   1970 				(oldLayout != VK_IMAGE_LAYOUT_UNDEFINED ? getAllMemoryWriteFlags() : (VkAccessFlags)0),					// srcAccessMask
   1971 				getAllMemoryReadFlags() | getMemoryFlagsForLayout(attachmentInfo[attachmentNdx].getInitialLayout()),	// dstAccessMask
   1972 
   1973 				oldLayout,												// oldLayout
   1974 				attachmentInfo[attachmentNdx].getInitialLayout(),		// newLayout;
   1975 
   1976 				queueIndex,												// srcQueueFamilyIndex;
   1977 				queueIndex,												// destQueueFamilyIndex;
   1978 
   1979 				attachmentResources[attachmentNdx]->getImage(),			// image;
   1980 				{														// subresourceRange;
   1981 					getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()),		// aspect;
   1982 					0,																	// baseMipLevel;
   1983 					1,																	// mipLevels;
   1984 					0,																	// baseArraySlice;
   1985 					1																	// arraySize;
   1986 				}
   1987 			};
   1988 
   1989 			renderPassLayouts.push_back(barrier);
   1990 		}
   1991 
   1992 		if (!renderPassLayouts.empty())
   1993 			vk.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
   1994 								  VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0,
   1995 								  0, (const VkMemoryBarrier*)DE_NULL,
   1996 								  0, (const VkBufferMemoryBarrier*)DE_NULL,
   1997 								  (deUint32)renderPassLayouts.size(), &renderPassLayouts[0]);
   1998 	}
   1999 }
   2000 
   2001 void pushRenderPassCommands (const DeviceInterface&								vk,
   2002 							 VkCommandBuffer									commandBuffer,
   2003 							 VkRenderPass										renderPass,
   2004 							 VkFramebuffer										framebuffer,
   2005 							 const vector<de::SharedPtr<SubpassRenderer> >&		subpassRenderers,
   2006 							 const UVec2&										renderPos,
   2007 							 const UVec2&										renderSize,
   2008 							 const vector<Maybe<VkClearValue> >&				renderPassClearValues,
   2009 							 TestConfig::RenderTypes							render)
   2010 {
   2011 	const float				clearNan				= tcu::Float32::nan().asFloat();
   2012 	vector<VkClearValue>	attachmentClearValues;
   2013 
   2014 	for (size_t attachmentNdx = 0; attachmentNdx < renderPassClearValues.size(); attachmentNdx++)
   2015 	{
   2016 		if (renderPassClearValues[attachmentNdx])
   2017 			attachmentClearValues.push_back(*renderPassClearValues[attachmentNdx]);
   2018 		else
   2019 			attachmentClearValues.push_back(makeClearValueColorF32(clearNan, clearNan, clearNan, clearNan));
   2020 	}
   2021 
   2022 	{
   2023 		const VkRect2D renderArea =
   2024 		{
   2025 			{ (deInt32)renderPos.x(),	(deInt32)renderPos.y()	},
   2026 			{ renderSize.x(),			renderSize.y()			}
   2027 		};
   2028 
   2029 		for (size_t subpassNdx = 0; subpassNdx < subpassRenderers.size(); subpassNdx++)
   2030 		{
   2031 			const VkSubpassContents	contents = subpassRenderers[subpassNdx]->isSecondary() ? VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS : VK_SUBPASS_CONTENTS_INLINE;
   2032 
   2033 			if (subpassNdx == 0)
   2034 				cmdBeginRenderPass(vk, commandBuffer, renderPass, framebuffer, renderArea, (deUint32)attachmentClearValues.size(), attachmentClearValues.empty() ? DE_NULL : &attachmentClearValues[0], contents);
   2035 			else
   2036 				vk.cmdNextSubpass(commandBuffer, contents);
   2037 
   2038 			if (render)
   2039 			{
   2040 				if (contents == VK_SUBPASS_CONTENTS_INLINE)
   2041 				{
   2042 					subpassRenderers[subpassNdx]->pushRenderCommands(vk, commandBuffer);
   2043 				}
   2044 				else if (contents == VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS)
   2045 				{
   2046 					const VkCommandBuffer cmd = subpassRenderers[subpassNdx]->getCommandBuffer();
   2047 					vk.cmdExecuteCommands(commandBuffer, 1, &cmd);
   2048 				}
   2049 				else
   2050 					DE_FATAL("Invalid contents");
   2051 			}
   2052 		}
   2053 
   2054 		vk.cmdEndRenderPass(commandBuffer);
   2055 	}
   2056 }
   2057 
   2058 void pushReadImagesToBuffers (const DeviceInterface&								vk,
   2059 							  VkCommandBuffer										commandBuffer,
   2060 							  deUint32												queueIndex,
   2061 
   2062 							  const vector<de::SharedPtr<AttachmentResources> >&	attachmentResources,
   2063 							  const vector<Attachment>&								attachmentInfo,
   2064 							  const vector<bool>&									isLazy,
   2065 
   2066 							  const UVec2&											targetSize)
   2067 {
   2068 	{
   2069 		vector<VkImageMemoryBarrier>	imageBarriers;
   2070 
   2071 		for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
   2072 		{
   2073 			if (isLazy[attachmentNdx])
   2074 				continue;
   2075 
   2076 			const VkImageLayout			oldLayout	= attachmentInfo[attachmentNdx].getFinalLayout();
   2077 			const VkImageMemoryBarrier	barrier		=
   2078 			{
   2079 				VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,							// sType
   2080 				DE_NULL,														// pNext
   2081 
   2082 				getAllMemoryWriteFlags() | getMemoryFlagsForLayout(oldLayout),	// srcAccessMask
   2083 				getAllMemoryReadFlags(),										// dstAccessMask
   2084 
   2085 				oldLayout,														// oldLayout
   2086 				VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,							// newLayout
   2087 
   2088 				queueIndex,														// srcQueueFamilyIndex
   2089 				queueIndex,														// destQueueFamilyIndex
   2090 
   2091 				attachmentResources[attachmentNdx]->getImage(),					// image
   2092 				{																// subresourceRange
   2093 					getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()),		// aspect;
   2094 					0,																	// baseMipLevel
   2095 					1,																	// mipLevels
   2096 					0,																	// baseArraySlice
   2097 					1																	// arraySize
   2098 				}
   2099 			};
   2100 
   2101 			imageBarriers.push_back(barrier);
   2102 		}
   2103 
   2104 		if (!imageBarriers.empty())
   2105 			vk.cmdPipelineBarrier(commandBuffer,
   2106 								  getAllPipelineStageFlags(),
   2107 								  getAllPipelineStageFlags(),
   2108 								  (VkDependencyFlags)0,
   2109 								  0, (const VkMemoryBarrier*)DE_NULL,
   2110 								  0, (const VkBufferMemoryBarrier*)DE_NULL,
   2111 								  (deUint32)imageBarriers.size(), &imageBarriers[0]);
   2112 	}
   2113 
   2114 	for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
   2115 	{
   2116 		if (isLazy[attachmentNdx])
   2117 			continue;
   2118 
   2119 		const tcu::TextureFormat::ChannelOrder	order	= mapVkFormat(attachmentInfo[attachmentNdx].getFormat()).order;
   2120 		const VkBufferImageCopy					rect	=
   2121 		{
   2122 			0, // bufferOffset
   2123 			0, // bufferRowLength
   2124 			0, // bufferImageHeight
   2125 			{							// imageSubresource
   2126 				getPrimaryImageAspect(mapVkFormat(attachmentInfo[attachmentNdx].getFormat()).order),	// aspect
   2127 				0,						// mipLevel
   2128 				0,						// arraySlice
   2129 				1						// arraySize
   2130 			},
   2131 			{ 0, 0, 0 },				// imageOffset
   2132 			{ targetSize.x(), targetSize.y(), 1u }		// imageExtent
   2133 		};
   2134 
   2135 		vk.cmdCopyImageToBuffer(commandBuffer, attachmentResources[attachmentNdx]->getImage(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, attachmentResources[attachmentNdx]->getBuffer(), 1, &rect);
   2136 
   2137 		if (tcu::TextureFormat::DS == order)
   2138 		{
   2139 			const VkBufferImageCopy stencilRect =
   2140 			{
   2141 				0, // bufferOffset
   2142 				0, // bufferRowLength
   2143 				0, // bufferImageHeight
   2144 				{									// imageSubresource
   2145 					VK_IMAGE_ASPECT_STENCIL_BIT,	// aspect
   2146 					0,								// mipLevel
   2147 					0,								// arraySlice
   2148 					1						// arraySize
   2149 				},
   2150 				{ 0, 0, 0 },				// imageOffset
   2151 				{ targetSize.x(), targetSize.y(), 1u }		// imageExtent
   2152 			};
   2153 
   2154 			vk.cmdCopyImageToBuffer(commandBuffer, attachmentResources[attachmentNdx]->getImage(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, attachmentResources[attachmentNdx]->getSecondaryBuffer(), 1, &stencilRect);
   2155 		}
   2156 	}
   2157 
   2158 	{
   2159 		vector<VkBufferMemoryBarrier>	bufferBarriers;
   2160 
   2161 		for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
   2162 		{
   2163 			if (isLazy[attachmentNdx])
   2164 				continue;
   2165 
   2166 			const tcu::TextureFormat::ChannelOrder	order			= mapVkFormat(attachmentInfo[attachmentNdx].getFormat()).order;
   2167 			const VkBufferMemoryBarrier				bufferBarrier	=
   2168 			{
   2169 				VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
   2170 				DE_NULL,
   2171 
   2172 				getAllMemoryWriteFlags(),
   2173 				getAllMemoryReadFlags(),
   2174 
   2175 				queueIndex,
   2176 				queueIndex,
   2177 
   2178 				attachmentResources[attachmentNdx]->getBuffer(),
   2179 				0,
   2180 				attachmentResources[attachmentNdx]->getBufferSize()
   2181 			};
   2182 
   2183 			bufferBarriers.push_back(bufferBarrier);
   2184 
   2185 			if (tcu::TextureFormat::DS == order)
   2186 			{
   2187 				const VkBufferMemoryBarrier secondaryBufferBarrier =
   2188 				{
   2189 					VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
   2190 					DE_NULL,
   2191 
   2192 					getAllMemoryWriteFlags(),
   2193 					getAllMemoryReadFlags(),
   2194 
   2195 					queueIndex,
   2196 					queueIndex,
   2197 
   2198 					attachmentResources[attachmentNdx]->getSecondaryBuffer(),
   2199 					0,
   2200 					attachmentResources[attachmentNdx]->getSecondaryBufferSize()
   2201 				};
   2202 
   2203 				bufferBarriers.push_back(secondaryBufferBarrier);
   2204 			}
   2205 		}
   2206 
   2207 		if (!bufferBarriers.empty())
   2208 			vk.cmdPipelineBarrier(commandBuffer,
   2209 								  getAllPipelineStageFlags(),
   2210 								  getAllPipelineStageFlags(),
   2211 								  (VkDependencyFlags)0,
   2212 								  0, (const VkMemoryBarrier*)DE_NULL,
   2213 								  (deUint32)bufferBarriers.size(), &bufferBarriers[0],
   2214 								  0, (const VkImageMemoryBarrier*)DE_NULL);
   2215 	}
   2216 }
   2217 
   2218 void clear (const PixelBufferAccess& access, const VkClearValue& value)
   2219 {
   2220 	const tcu::TextureFormat&	format	= access.getFormat();
   2221 
   2222 	if (tcu::hasDepthComponent(format.order) || tcu::hasStencilComponent(format.order))
   2223 	{
   2224 		if (tcu::hasDepthComponent(format.order))
   2225 			tcu::clearDepth(access, value.depthStencil.depth);
   2226 
   2227 		if (tcu::hasStencilComponent(format.order))
   2228 			tcu::clearStencil(access, value.depthStencil.stencil);
   2229 	}
   2230 	else
   2231 	{
   2232 		if (tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_FLOATING_POINT
   2233 				|| tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT
   2234 				|| tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT)
   2235 		{
   2236 			const tcu::Vec4		color	(value.color.float32[0],
   2237 										 value.color.float32[1],
   2238 										 value.color.float32[2],
   2239 										 value.color.float32[3]);
   2240 
   2241 			if (tcu::isSRGB(format))
   2242 				tcu::clear(access, tcu::linearToSRGB(color));
   2243 			else
   2244 				tcu::clear(access, color);
   2245 		}
   2246 		else if (tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER)
   2247 		{
   2248 			const tcu::UVec4	color	(value.color.uint32[0],
   2249 										 value.color.uint32[1],
   2250 										 value.color.uint32[2],
   2251 										 value.color.uint32[3]);
   2252 
   2253 			tcu::clear(access, color);
   2254 		}
   2255 		else if (tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER)
   2256 		{
   2257 			const tcu::IVec4	color	(value.color.int32[0],
   2258 										 value.color.int32[1],
   2259 										 value.color.int32[2],
   2260 										 value.color.int32[3]);
   2261 
   2262 			tcu::clear(access, color);
   2263 		}
   2264 		else
   2265 			DE_FATAL("Unknown channel class");
   2266 	}
   2267 }
   2268 
   2269 Vec4 computeUvs (const IVec2& posA, const IVec2& posB, const IVec2& pos)
   2270 {
   2271 	const float u = de::clamp((float)(pos.x() - posA.x()) / (float)(posB.x() - posA.x()), 0.0f, 1.0f);
   2272 	const float v = de::clamp((float)(pos.y() - posA.y()) / (float)(posB.y() - posA.y()), 0.0f, 1.0f);
   2273 
   2274 	return Vec4(u, v, u * v, (u + v) / 2.0f);
   2275 }
   2276 
   2277 void renderReferenceImages (vector<tcu::TextureLevel>&			referenceAttachments,
   2278 							const RenderPass&					renderPassInfo,
   2279 							const UVec2&						targetSize,
   2280 							const vector<Maybe<VkClearValue> >&	imageClearValues,
   2281 							const vector<Maybe<VkClearValue> >&	renderPassClearValues,
   2282 							const vector<SubpassRenderInfo>&	subpassRenderInfo,
   2283 							const UVec2&						renderPos,
   2284 							const UVec2&						renderSize)
   2285 {
   2286 	const vector<Subpass>&	subpasses		= renderPassInfo.getSubpasses();
   2287 	vector<bool>			attachmentUsed	(renderPassInfo.getAttachments().size(), false);
   2288 
   2289 	referenceAttachments.resize(renderPassInfo.getAttachments().size());
   2290 
   2291 	for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
   2292 	{
   2293 		const Attachment				attachment					= renderPassInfo.getAttachments()[attachmentNdx];
   2294 		const tcu::TextureFormat		format						= mapVkFormat(attachment.getFormat());
   2295 		const tcu::TextureFormatInfo	textureInfo					= tcu::getTextureFormatInfo(format);
   2296 		tcu::TextureLevel&				reference					= referenceAttachments[attachmentNdx];
   2297 		const bool						isDepthOrStencilAttachment	= hasDepthComponent(format.order) || hasStencilComponent(format.order);
   2298 
   2299 		reference = tcu::TextureLevel(format, targetSize.x(), targetSize.y());
   2300 
   2301 		if (imageClearValues[attachmentNdx])
   2302 			clear(reference.getAccess(), *imageClearValues[attachmentNdx]);
   2303 		else
   2304 		{
   2305 			// Fill with grid if image contentst are undefined before renderpass
   2306 			if (isDepthOrStencilAttachment)
   2307 			{
   2308 				if (tcu::hasDepthComponent(format.order))
   2309 					tcu::fillWithGrid(tcu::getEffectiveDepthStencilAccess(reference.getAccess(), tcu::Sampler::MODE_DEPTH), 2, textureInfo.valueMin, textureInfo.valueMax);
   2310 
   2311 				if (tcu::hasStencilComponent(format.order))
   2312 					tcu::fillWithGrid(tcu::getEffectiveDepthStencilAccess(reference.getAccess(), tcu::Sampler::MODE_STENCIL), 2, textureInfo.valueMin, textureInfo.valueMax);
   2313 			}
   2314 			else
   2315 				tcu::fillWithGrid(reference.getAccess(), 2, textureInfo.valueMin, textureInfo.valueMax);
   2316 		}
   2317 	}
   2318 
   2319 	for (size_t subpassNdx = 0; subpassNdx < subpasses.size(); subpassNdx++)
   2320 	{
   2321 		const Subpass&						subpass				= subpasses[subpassNdx];
   2322 		const SubpassRenderInfo&			renderInfo			= subpassRenderInfo[subpassNdx];
   2323 		const vector<AttachmentReference>&	colorAttachments	= subpass.getColorAttachments();
   2324 
   2325 		// Apply load op if attachment was used for the first time
   2326 		for (size_t attachmentNdx = 0; attachmentNdx < colorAttachments.size(); attachmentNdx++)
   2327 		{
   2328 			const deUint32 attachmentIndex = colorAttachments[attachmentNdx].getAttachment();
   2329 
   2330 			if (!attachmentUsed[attachmentIndex])
   2331 			{
   2332 				const Attachment&	attachment	= renderPassInfo.getAttachments()[attachmentIndex];
   2333 				tcu::TextureLevel&	reference	= referenceAttachments[attachmentIndex];
   2334 
   2335 				DE_ASSERT(!tcu::hasDepthComponent(reference.getFormat().order));
   2336 				DE_ASSERT(!tcu::hasStencilComponent(reference.getFormat().order));
   2337 
   2338 				if (attachment.getLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
   2339 					clear(tcu::getSubregion(reference.getAccess(), renderPos.x(), renderPos.y(), renderSize.x(), renderSize.y()), *renderPassClearValues[attachmentIndex]);
   2340 				else if (attachment.getLoadOp() == VK_ATTACHMENT_LOAD_OP_DONT_CARE)
   2341 				{
   2342 					const tcu::TextureFormatInfo textureInfo = tcu::getTextureFormatInfo(reference.getFormat());
   2343 
   2344 					tcu::fillWithGrid(tcu::getSubregion(reference.getAccess(), renderPos.x(), renderPos.y(), renderSize.x(), renderSize.y()), 2, textureInfo.valueMin, textureInfo.valueMax);
   2345 				}
   2346 
   2347 				attachmentUsed[attachmentIndex] = true;
   2348 			}
   2349 		}
   2350 
   2351 		// Apply load op to depth/stencil attachment if it was used for the first time
   2352 		if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED && !attachmentUsed[subpass.getDepthStencilAttachment().getAttachment()])
   2353 		{
   2354 			const deUint32 attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
   2355 
   2356 			// Apply load op if attachment was used for the first time
   2357 			if (!attachmentUsed[attachmentIndex])
   2358 			{
   2359 				const Attachment&	attachment	= renderPassInfo.getAttachments()[attachmentIndex];
   2360 				tcu::TextureLevel&	reference		= referenceAttachments[attachmentIndex];
   2361 
   2362 				if (tcu::hasDepthComponent(reference.getFormat().order))
   2363 				{
   2364 					if (attachment.getLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
   2365 						clear(tcu::getSubregion(tcu::getEffectiveDepthStencilAccess(reference.getAccess(), tcu::Sampler::MODE_DEPTH), renderPos.x(), renderPos.y(), renderSize.x(), renderSize.y()), *renderPassClearValues[attachmentIndex]);
   2366 					else if (attachment.getLoadOp() == VK_ATTACHMENT_LOAD_OP_DONT_CARE)
   2367 					{
   2368 						const tcu::TextureFormatInfo textureInfo = tcu::getTextureFormatInfo(reference.getFormat());
   2369 
   2370 						tcu::fillWithGrid(tcu::getSubregion(tcu::getEffectiveDepthStencilAccess(reference.getAccess(), tcu::Sampler::MODE_DEPTH), renderPos.x(), renderPos.y(), renderSize.x(), renderSize.y()), 2, textureInfo.valueMin, textureInfo.valueMax);
   2371 					}
   2372 				}
   2373 
   2374 				if (tcu::hasStencilComponent(reference.getFormat().order))
   2375 				{
   2376 					if (attachment.getStencilLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
   2377 						clear(tcu::getSubregion(tcu::getEffectiveDepthStencilAccess(reference.getAccess(), tcu::Sampler::MODE_STENCIL), renderPos.x(), renderPos.y(), renderSize.x(), renderSize.y()), *renderPassClearValues[attachmentIndex]);
   2378 					else if (attachment.getStencilLoadOp() == VK_ATTACHMENT_LOAD_OP_DONT_CARE)
   2379 					{
   2380 						const tcu::TextureFormatInfo textureInfo = tcu::getTextureFormatInfo(reference.getFormat());
   2381 
   2382 						tcu::fillWithGrid(tcu::getSubregion(tcu::getEffectiveDepthStencilAccess(reference.getAccess(), tcu::Sampler::MODE_STENCIL), renderPos.x(), renderPos.y(), renderSize.x(), renderSize.y()), 2, textureInfo.valueMin, textureInfo.valueMax);
   2383 					}
   2384 				}
   2385 			}
   2386 
   2387 			attachmentUsed[attachmentIndex] = true;
   2388 		}
   2389 
   2390 		for (size_t colorClearNdx = 0; colorClearNdx < renderInfo.getColorClears().size(); colorClearNdx++)
   2391 		{
   2392 			const ColorClear&	colorClear	= renderInfo.getColorClears()[colorClearNdx];
   2393 			const UVec2			offset		= colorClear.getOffset();
   2394 			const UVec2			size		= colorClear.getSize();
   2395 			tcu::TextureLevel&	reference	= referenceAttachments[subpass.getColorAttachments()[colorClearNdx].getAttachment()];
   2396 			VkClearValue		value;
   2397 
   2398 			value.color = colorClear.getColor();
   2399 
   2400 			clear(tcu::getSubregion(reference.getAccess(), offset.x(), offset.y(), 0, size.x(), size.y(), 1), value);
   2401 		}
   2402 
   2403 		if (renderInfo.getDepthStencilClear())
   2404 		{
   2405 			const DepthStencilClear&	dsClear		= *renderInfo.getDepthStencilClear();
   2406 			const UVec2					offset		= dsClear.getOffset();
   2407 			const UVec2					size		= dsClear.getSize();
   2408 			tcu::TextureLevel&			reference	= referenceAttachments[subpass.getDepthStencilAttachment().getAttachment()];
   2409 
   2410 			if (tcu::hasDepthComponent(reference.getFormat().order))
   2411 				clearDepth(tcu::getSubregion(reference.getAccess(), offset.x(), offset.y(), 0, size.x(), size.y(), 1), dsClear.getDepth());
   2412 
   2413 			if (tcu::hasStencilComponent(reference.getFormat().order))
   2414 				clearStencil(tcu::getSubregion(reference.getAccess(), offset.x(), offset.y(), 0, size.x(), size.y(), 1), dsClear.getStencil());
   2415 		}
   2416 
   2417 		if (renderInfo.getRenderQuad())
   2418 		{
   2419 			const RenderQuad&	renderQuad	= *renderInfo.getRenderQuad();
   2420 			const Vec4			posA		= renderQuad.getCornerA();
   2421 			const Vec4			posB		= renderQuad.getCornerB();
   2422 			const Vec2			origin		= Vec2((float)renderInfo.getViewportOffset().x(), (float)renderInfo.getViewportOffset().y()) + Vec2((float)renderInfo.getViewportSize().x(), (float)renderInfo.getViewportSize().y()) / Vec2(2.0f);
   2423 			const Vec2			p			= Vec2((float)renderInfo.getViewportSize().x(), (float)renderInfo.getViewportSize().y()) / Vec2(2.0f);
   2424 			const IVec2			posAI		((deInt32)(origin.x() + (p.x() * posA.x())),
   2425 											 (deInt32)(origin.y() + (p.y() * posA.y())));
   2426 			const IVec2			posBI		((deInt32)(origin.x() + (p.x() * posB.x())),
   2427 											 (deInt32)(origin.y() + (p.y() * posB.y())));
   2428 
   2429 			for (size_t attachmentRefNdx = 0; attachmentRefNdx < subpass.getColorAttachments().size(); attachmentRefNdx++)
   2430 			{
   2431 				const Attachment				attachment			= renderPassInfo.getAttachments()[subpass.getColorAttachments()[attachmentRefNdx].getAttachment()];
   2432 				const tcu::TextureFormatInfo	textureInfo			= tcu::getTextureFormatInfo(mapVkFormat(attachment.getFormat()));
   2433 				tcu::TextureLevel&				referenceTexture	= referenceAttachments[subpass.getColorAttachments()[attachmentRefNdx].getAttachment()];
   2434 				const bool						srgb				= tcu::isSRGB(referenceTexture.getFormat());
   2435 				const PixelBufferAccess	reference			= referenceTexture.getAccess();
   2436 				const float						clampMin			= (float)(-MAX_INTEGER_VALUE);
   2437 				const float						clampMax			= (float)(MAX_INTEGER_VALUE);
   2438 				const Vec4						valueMax			(de::clamp(textureInfo.valueMax[0], clampMin, clampMax),
   2439 																	 de::clamp(textureInfo.valueMax[1], clampMin, clampMax),
   2440 																	 de::clamp(textureInfo.valueMax[2], clampMin, clampMax),
   2441 																	 de::clamp(textureInfo.valueMax[3], clampMin, clampMax));
   2442 
   2443 				const Vec4						valueMin			(de::clamp(textureInfo.valueMin[0], clampMin, clampMax),
   2444 																	 de::clamp(textureInfo.valueMin[1], clampMin, clampMax),
   2445 																	 de::clamp(textureInfo.valueMin[2], clampMin, clampMax),
   2446 																	 de::clamp(textureInfo.valueMin[3], clampMin, clampMax));
   2447 
   2448 				DE_ASSERT(posAI.x() < posBI.x());
   2449 				DE_ASSERT(posAI.y() < posBI.y());
   2450 
   2451 				for (int y = posAI.y(); y <= (int)posBI.y(); y++)
   2452 				for (int x = posAI.x(); x <= (int)posBI.x(); x++)
   2453 				{
   2454 					const Vec4	uvs		= computeUvs(posAI, posBI, IVec2(x, y));
   2455 					const Vec4	color	= valueMax * uvs + valueMin * (Vec4(1.0f) - uvs);
   2456 
   2457 					if (srgb)
   2458 						reference.setPixel(tcu::linearToSRGB(color), x, y);
   2459 					else
   2460 						reference.setPixel(color, x, y);
   2461 				}
   2462 			}
   2463 
   2464 			if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED)
   2465 			{
   2466 				tcu::TextureLevel&				referenceTexture	= referenceAttachments[subpass.getDepthStencilAttachment().getAttachment()];
   2467 				const PixelBufferAccess	reference			= referenceTexture.getAccess();
   2468 
   2469 				DE_ASSERT(posAI.x() < posBI.x());
   2470 				DE_ASSERT(posAI.y() < posBI.y());
   2471 
   2472 				for (int y = posAI.y(); y <= (int)posBI.y(); y++)
   2473 				for (int x = posAI.x(); x <= (int)posBI.x(); x++)
   2474 				{
   2475 					const Vec4 uvs = computeUvs(posAI, posBI, IVec2(x, y));
   2476 
   2477 					if (tcu::hasDepthComponent(reference.getFormat().order))
   2478 						reference.setPixDepth(uvs.x(), x, y);
   2479 
   2480 					if (tcu::hasStencilComponent(reference.getFormat().order))
   2481 						reference.setPixStencil(STENCIL_VALUE, x, y);
   2482 				}
   2483 			}
   2484 		}
   2485 	}
   2486 
   2487 	// Mark all attachments that were used but not stored as undefined
   2488 	for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
   2489 	{
   2490 		const Attachment				attachment	= renderPassInfo.getAttachments()[attachmentNdx];
   2491 		const tcu::TextureFormat		format		= mapVkFormat(attachment.getFormat());
   2492 		const tcu::TextureFormatInfo	textureInfo	= tcu::getTextureFormatInfo(format);
   2493 		tcu::TextureLevel&				reference	= referenceAttachments[attachmentNdx];
   2494 
   2495 		if (attachmentUsed[attachmentNdx] && renderPassInfo.getAttachments()[attachmentNdx].getStoreOp() == VK_ATTACHMENT_STORE_OP_DONT_CARE)
   2496 			tcu::fillWithGrid(tcu::getSubregion(reference.getAccess(), renderPos.x(), renderPos.y(), renderSize.x(), renderSize.y()), 2, textureInfo.valueMin, textureInfo.valueMax);
   2497 	}
   2498 }
   2499 
   2500 Maybe<deUint32> findColorAttachment (const Subpass&				subpass,
   2501 									 deUint32					attachmentIndex)
   2502 {
   2503 	for (size_t colorAttachmentNdx = 0; colorAttachmentNdx < subpass.getColorAttachments().size(); colorAttachmentNdx++)
   2504 	{
   2505 		if (subpass.getColorAttachments()[colorAttachmentNdx].getAttachment() == attachmentIndex)
   2506 			return tcu::just((deUint32)colorAttachmentNdx);
   2507 	}
   2508 
   2509 	return tcu::nothing<deUint32>();
   2510 }
   2511 
   2512 int calcFloatDiff (float a, float b)
   2513 {
   2514 	const deUint32		au		= tcu::Float32(a).bits();
   2515 	const deUint32		bu		= tcu::Float32(b).bits();
   2516 
   2517 	const bool			asign	= (au & (0x1u << 31u)) != 0u;
   2518 	const bool			bsign	= (bu & (0x1u << 31u)) != 0u;
   2519 
   2520 	const deUint32		avalue	= (au & ((0x1u << 31u) - 1u));
   2521 	const deUint32		bvalue	= (bu & ((0x1u << 31u) - 1u));
   2522 
   2523 	if (asign != bsign)
   2524 		return avalue + bvalue + 1u;
   2525 	else if (avalue < bvalue)
   2526 		return bvalue - avalue;
   2527 	else
   2528 		return avalue - bvalue;
   2529 }
   2530 
   2531 bool comparePixelToDepthClearValue (const ConstPixelBufferAccess&	access,
   2532 									int								x,
   2533 									int								y,
   2534 									float							ref)
   2535 {
   2536 	const tcu::TextureFormat		format			= tcu::getEffectiveDepthStencilTextureFormat(access.getFormat(), tcu::Sampler::MODE_DEPTH);
   2537 	const tcu::TextureChannelClass	channelClass	= tcu::getTextureChannelClass(format.type);
   2538 
   2539 	switch (channelClass)
   2540 	{
   2541 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
   2542 		case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
   2543 		{
   2544 			const int	bitDepth	= tcu::getTextureFormatBitDepth(format).x();
   2545 			const float	depth		= access.getPixDepth(x, y);
   2546 			const float	threshold	= 2.0f / (float)((1 << bitDepth) - 1);
   2547 
   2548 			return deFloatAbs(depth - ref) <= threshold;
   2549 		}
   2550 
   2551 		case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
   2552 		{
   2553 			const float	depth			= access.getPixDepth(x, y);
   2554 			const int	mantissaBits	= tcu::getTextureFormatMantissaBitDepth(format).x();
   2555 			const int	threshold		= 10 * 1 << (23 - mantissaBits);
   2556 
   2557 			DE_ASSERT(mantissaBits <= 23);
   2558 
   2559 			return calcFloatDiff(depth, ref) <= threshold;
   2560 		}
   2561 
   2562 		default:
   2563 			DE_FATAL("Invalid channel class");
   2564 			return false;
   2565 	}
   2566 }
   2567 
   2568 bool comparePixelToStencilClearValue (const ConstPixelBufferAccess&	access,
   2569 									  int							x,
   2570 									  int							y,
   2571 									  deUint32						ref)
   2572 {
   2573 	const deUint32 stencil = access.getPixStencil(x, y);
   2574 
   2575 	return stencil == ref;
   2576 }
   2577 
   2578 bool comparePixelToColorClearValue (const ConstPixelBufferAccess&	access,
   2579 									int								x,
   2580 									int								y,
   2581 									const VkClearColorValue&		ref)
   2582 {
   2583 	const tcu::TextureFormat		format			= access.getFormat();
   2584 	const tcu::TextureChannelClass	channelClass	= tcu::getTextureChannelClass(format.type);
   2585 	const BVec4						channelMask		= tcu::getTextureFormatChannelMask(format);
   2586 
   2587 	switch (channelClass)
   2588 	{
   2589 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
   2590 		case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
   2591 		{
   2592 			const IVec4	bitDepth	(tcu::getTextureFormatBitDepth(format));
   2593 			const Vec4	resColor	(access.getPixel(x, y));
   2594 			const Vec4	refColor	(ref.float32[0],
   2595 									 ref.float32[1],
   2596 									 ref.float32[2],
   2597 									 ref.float32[3]);
   2598 			const Vec4	threshold	(bitDepth[0] > 0 ? 20.0f / (float)((1 << bitDepth[0]) - 1) : 1.0f,
   2599 									 bitDepth[1] > 0 ? 20.0f / (float)((1 << bitDepth[1]) - 1) : 1.0f,
   2600 									 bitDepth[2] > 0 ? 20.0f / (float)((1 << bitDepth[2]) - 1) : 1.0f,
   2601 									 bitDepth[3] > 0 ? 20.0f / (float)((1 << bitDepth[3]) - 1) : 1.0f);
   2602 
   2603 			if (tcu::isSRGB(access.getFormat()))
   2604 				return !(tcu::anyNotEqual(tcu::logicalAnd(lessThanEqual(tcu::absDiff(resColor, tcu::linearToSRGB(refColor)), threshold), channelMask), channelMask));
   2605 			else
   2606 				return !(tcu::anyNotEqual(tcu::logicalAnd(lessThanEqual(tcu::absDiff(resColor, refColor), threshold), channelMask), channelMask));
   2607 		}
   2608 
   2609 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
   2610 		{
   2611 			const UVec4	resColor	(access.getPixelUint(x, y));
   2612 			const UVec4	refColor	(ref.uint32[0],
   2613 									 ref.uint32[1],
   2614 									 ref.uint32[2],
   2615 									 ref.uint32[3]);
   2616 			const UVec4	threshold	(1);
   2617 
   2618 			return !(tcu::anyNotEqual(tcu::logicalAnd(lessThanEqual(tcu::absDiff(resColor, refColor), threshold), channelMask), channelMask));
   2619 		}
   2620 
   2621 		case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
   2622 		{
   2623 			const IVec4	resColor	(access.getPixelInt(x, y));
   2624 			const IVec4	refColor	(ref.int32[0],
   2625 									 ref.int32[1],
   2626 									 ref.int32[2],
   2627 									 ref.int32[3]);
   2628 			const IVec4	threshold	(1);
   2629 
   2630 			return !(tcu::anyNotEqual(tcu::logicalAnd(lessThanEqual(tcu::absDiff(resColor, refColor), threshold), channelMask), channelMask));
   2631 		}
   2632 
   2633 		case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
   2634 		{
   2635 			const Vec4	resColor		(access.getPixel(x, y));
   2636 			const Vec4	refColor		(ref.float32[0],
   2637 										 ref.float32[1],
   2638 										 ref.float32[2],
   2639 										 ref.float32[3]);
   2640 			const IVec4	mantissaBits	(tcu::getTextureFormatMantissaBitDepth(format));
   2641 			const IVec4	threshold		(10 * IVec4(1) << (23 - mantissaBits));
   2642 
   2643 			DE_ASSERT(tcu::allEqual(greaterThanEqual(threshold, IVec4(0)), BVec4(true)));
   2644 
   2645 			for (int ndx = 0; ndx < 4; ndx++)
   2646 			{
   2647 				if (calcFloatDiff(resColor[ndx], refColor[ndx]) > threshold[ndx] && channelMask[ndx])
   2648 					return false;
   2649 			}
   2650 
   2651 			return true;
   2652 		}
   2653 
   2654 		default:
   2655 			DE_FATAL("Invalid channel class");
   2656 			return false;
   2657 	}
   2658 }
   2659 
   2660 class PixelStatus
   2661 {
   2662 public:
   2663 	enum Status
   2664 	{
   2665 		STATUS_UNDEFINED	= 0,
   2666 		STATUS_OK			= 1,
   2667 		STATUS_FAIL			= 2,
   2668 
   2669 		STATUS_LAST
   2670 	};
   2671 
   2672 			PixelStatus			(Status color, Status depth, Status stencil)
   2673 				: m_status	((deUint8)((color << COLOR_OFFSET)
   2674 					| (depth << DEPTH_OFFSET)
   2675 					| (stencil << STENCIL_OFFSET)))
   2676 	{
   2677 	}
   2678 
   2679 	Status	getColorStatus		(void) const { return (Status)((m_status & COLOR_MASK) >> COLOR_OFFSET); }
   2680 	Status	getDepthStatus		(void) const { return (Status)((m_status & DEPTH_MASK) >> DEPTH_OFFSET); }
   2681 	Status	getStencilStatus	(void) const { return (Status)((m_status & STENCIL_MASK) >> STENCIL_OFFSET); }
   2682 
   2683 	void	setColorStatus		(Status status)
   2684 	{
   2685 		DE_ASSERT(getColorStatus() == STATUS_UNDEFINED);
   2686 		m_status |= (deUint8)(status << COLOR_OFFSET);
   2687 	}
   2688 
   2689 	void	setDepthStatus		(Status status)
   2690 	{
   2691 		DE_ASSERT(getDepthStatus() == STATUS_UNDEFINED);
   2692 		m_status |= (deUint8)(status << DEPTH_OFFSET);
   2693 	}
   2694 
   2695 	void	setStencilStatus	(Status status)
   2696 	{
   2697 		DE_ASSERT(getStencilStatus() == STATUS_UNDEFINED);
   2698 		m_status |= (deUint8)(status << STENCIL_OFFSET);
   2699 	}
   2700 
   2701 private:
   2702 	enum
   2703 	{
   2704 		COLOR_OFFSET	= 0,
   2705 		DEPTH_OFFSET	= 2,
   2706 		STENCIL_OFFSET	= 4,
   2707 
   2708 		COLOR_MASK		= (3<<COLOR_OFFSET),
   2709 		DEPTH_MASK		= (3<<DEPTH_OFFSET),
   2710 		STENCIL_MASK	= (3<<STENCIL_OFFSET),
   2711 	};
   2712 	deUint8	m_status;
   2713 };
   2714 
   2715 void checkDepthRenderQuad (const ConstPixelBufferAccess&	result,
   2716 						   const IVec2&						posA,
   2717 						   const IVec2&						posB,
   2718 						   vector<PixelStatus>&				status)
   2719 {
   2720 	for (int y = posA.y(); y <= posB.y(); y++)
   2721 	for (int x = posA.x(); x <= posB.x(); x++)
   2722 	{
   2723 		PixelStatus& pixelStatus = status[x + y * result.getWidth()];
   2724 
   2725 		if (pixelStatus.getDepthStatus() == PixelStatus::STATUS_UNDEFINED)
   2726 		{
   2727 			const Vec4	minUvs		= computeUvs(posA, posB, IVec2(x-1, y-1));
   2728 			const Vec4	maxUvs		= computeUvs(posA, posB, IVec2(x+1, y+1));
   2729 			const bool	softCheck	= std::abs(x - posA.x()) <= 1 || std::abs(x - posB.x()) <= 1
   2730 									|| std::abs(y - posA.y()) <= 1 || std::abs(y - posB.y()) <= 1;
   2731 			const float	resDepth	= result.getPixDepth(x, y);
   2732 
   2733 			if (resDepth >= minUvs.x() && resDepth <= maxUvs.x())
   2734 				pixelStatus.setDepthStatus(PixelStatus::STATUS_OK);
   2735 			else if (!softCheck)
   2736 				pixelStatus.setDepthStatus(PixelStatus::STATUS_FAIL);
   2737 		}
   2738 	}
   2739 }
   2740 
   2741 void checkStencilRenderQuad (const ConstPixelBufferAccess&		result,
   2742 							 const IVec2&						posA,
   2743 							 const IVec2&						posB,
   2744 							 vector<PixelStatus>&				status)
   2745 {
   2746 	for (int y = posA.y(); y <= posB.y(); y++)
   2747 	for (int x = posA.x(); x <= posB.x(); x++)
   2748 	{
   2749 		PixelStatus& pixelStatus = status[x + y * result.getWidth()];
   2750 
   2751 		if (pixelStatus.getStencilStatus() == PixelStatus::STATUS_UNDEFINED)
   2752 		{
   2753 			const bool	softCheck	= std::abs(x - posA.x()) <= 1 || std::abs(x - posB.x()) <= 1
   2754 									|| std::abs(y - posA.y()) <= 1 || std::abs(y - posB.y()) <= 1;
   2755 
   2756 			if (result.getPixStencil(x, y) == STENCIL_VALUE)
   2757 				pixelStatus.setStencilStatus(PixelStatus::STATUS_OK);
   2758 			else if (!softCheck)
   2759 				pixelStatus.setStencilStatus(PixelStatus::STATUS_FAIL);
   2760 		}
   2761 	}
   2762 }
   2763 
   2764 void checkColorRenderQuad (const ConstPixelBufferAccess&	result,
   2765 						   const IVec2&						posA,
   2766 						   const IVec2&						posB,
   2767 						   vector<PixelStatus>&				status)
   2768 {
   2769 	const tcu::TextureFormat&		format				= result.getFormat();
   2770 	const bool						srgb				= tcu::isSRGB(format);
   2771 	const tcu::TextureChannelClass	channelClass		= tcu::getTextureChannelClass(format.type);
   2772 	const tcu::TextureFormatInfo	textureInfo			= tcu::getTextureFormatInfo(format);
   2773 	const float						clampMin			= (float)(-MAX_INTEGER_VALUE);
   2774 	const float						clampMax			= (float)(MAX_INTEGER_VALUE);
   2775 	const Vec4						valueMax			(de::clamp(textureInfo.valueMax[0], clampMin, clampMax),
   2776 														 de::clamp(textureInfo.valueMax[1], clampMin, clampMax),
   2777 														 de::clamp(textureInfo.valueMax[2], clampMin, clampMax),
   2778 														 de::clamp(textureInfo.valueMax[3], clampMin, clampMax));
   2779 
   2780 	const Vec4						valueMin			(de::clamp(textureInfo.valueMin[0], clampMin, clampMax),
   2781 														 de::clamp(textureInfo.valueMin[1], clampMin, clampMax),
   2782 														 de::clamp(textureInfo.valueMin[2], clampMin, clampMax),
   2783 														 de::clamp(textureInfo.valueMin[3], clampMin, clampMax));
   2784 	const BVec4						channelMask			= tcu::getTextureFormatChannelMask(format);
   2785 
   2786 	IVec4						formatBitDepths = tcu::getTextureFormatBitDepth(format);
   2787 	Vec4						threshold = Vec4(1.0f) / Vec4((float)(1 << formatBitDepths.x()),
   2788 																(float)(1 << formatBitDepths.y()),
   2789 																(float)(1 << formatBitDepths.z()),
   2790 																(float)(1 << formatBitDepths.w()));
   2791 
   2792 	switch (channelClass)
   2793 	{
   2794 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
   2795 		case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
   2796 		case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
   2797 		{
   2798 			for (int y = posA.y(); y <= posB.y(); y++)
   2799 			for (int x = posA.x(); x <= posB.x(); x++)
   2800 			{
   2801 				PixelStatus& pixelStatus = status[x + y * result.getWidth()];
   2802 
   2803 				if (pixelStatus.getColorStatus() == PixelStatus::STATUS_UNDEFINED)
   2804 				{
   2805 					const Vec4	minDiff		= Vec4(1.0f) / (IVec4(1) << tcu::getTextureFormatMantissaBitDepth(format)).cast<float>();
   2806 					const Vec4	minUvs		= computeUvs(posA, posB, IVec2(x-1, y-1));
   2807 					const Vec4	maxUvs		= computeUvs(posA, posB, IVec2(x+1, y+1));
   2808 					const bool	softCheck	= std::abs(x - posA.x()) <= 1 || std::abs(x - posB.x()) <= 1
   2809 											|| std::abs(y - posA.y()) <= 1 || std::abs(y - posB.y()) <= 1;
   2810 
   2811 					const Vec4	resColor	(result.getPixel(x, y));
   2812 
   2813 					Vec4	minRefColor	= srgb ? tcu::linearToSRGB(valueMax * minUvs + valueMin * (Vec4(1.0f) - minUvs))
   2814 											 : valueMax * minUvs + valueMin * (Vec4(1.0f) - minUvs) - threshold;
   2815 					Vec4	maxRefColor	= srgb ? tcu::linearToSRGB(valueMax * maxUvs + valueMin * (Vec4(1.0f) - maxUvs))
   2816 											 : valueMax * maxUvs + valueMin * (Vec4(1.0f) - maxUvs) + threshold;
   2817 
   2818 					// Take into account rounding and quantization
   2819 					if (channelClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT)
   2820 					{
   2821 						minRefColor = tcu::min(minRefColor * (Vec4(1.0f) - minDiff), minRefColor * (Vec4(1.0f) + minDiff));
   2822 						maxRefColor = tcu::max(maxRefColor * (Vec4(1.0f) - minDiff), maxRefColor * (Vec4(1.0f) + minDiff));
   2823 					}
   2824 					else
   2825 					{
   2826 						minRefColor = minRefColor - minDiff;
   2827 						maxRefColor = maxRefColor + minDiff;
   2828 					}
   2829 
   2830 					DE_ASSERT(minRefColor[0] <= maxRefColor[0]);
   2831 					DE_ASSERT(minRefColor[1] <= maxRefColor[1]);
   2832 					DE_ASSERT(minRefColor[2] <= maxRefColor[2]);
   2833 					DE_ASSERT(minRefColor[3] <= maxRefColor[3]);
   2834 
   2835 					if (tcu::anyNotEqual(tcu::logicalAnd(
   2836 											tcu::logicalAnd(greaterThanEqual(resColor, minRefColor),
   2837 															lessThanEqual(resColor, maxRefColor)),
   2838 											channelMask), channelMask))
   2839 					{
   2840 						if (!softCheck)
   2841 							pixelStatus.setColorStatus(PixelStatus::STATUS_FAIL);
   2842 					}
   2843 					else
   2844 						pixelStatus.setColorStatus(PixelStatus::STATUS_OK);
   2845 				}
   2846 			}
   2847 
   2848 			break;
   2849 		}
   2850 
   2851 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
   2852 		{
   2853 			for (int y = posA.y(); y <= posB.y(); y++)
   2854 			for (int x = posA.x(); x <= posB.x(); x++)
   2855 			{
   2856 				PixelStatus& pixelStatus = status[x + y * result.getWidth()];
   2857 
   2858 				if (pixelStatus.getColorStatus() == PixelStatus::STATUS_UNDEFINED)
   2859 				{
   2860 					const Vec4	minUvs			= computeUvs(posA, posB, IVec2(x-1, y-1));
   2861 					const Vec4	maxUvs			= computeUvs(posA, posB, IVec2(x+1, y+1));
   2862 					const bool	softCheck		= std::abs(x - posA.x()) <= 1 || std::abs(x - posB.x()) <= 1
   2863 												|| std::abs(y - posA.y()) <= 1 || std::abs(y - posB.y()) <= 1;
   2864 
   2865 					const UVec4	resColor		(result.getPixelUint(x, y));
   2866 
   2867 					const Vec4	minRefColorF	= valueMax * minUvs + valueMin * (Vec4(1.0f) - minUvs);
   2868 					const Vec4	maxRefColorF	= valueMax * maxUvs + valueMin * (Vec4(1.0f) - maxUvs);
   2869 
   2870 					const UVec4	minRefColor		(minRefColorF.asUint());
   2871 					const UVec4	maxRefColor		(maxRefColorF.asUint());
   2872 
   2873 					DE_ASSERT(minRefColor[0] <= maxRefColor[0]);
   2874 					DE_ASSERT(minRefColor[1] <= maxRefColor[1]);
   2875 					DE_ASSERT(minRefColor[2] <= maxRefColor[2]);
   2876 					DE_ASSERT(minRefColor[3] <= maxRefColor[3]);
   2877 
   2878 					if (tcu::anyNotEqual(tcu::logicalAnd(
   2879 											tcu::logicalAnd(greaterThanEqual(resColor, minRefColor),
   2880 															lessThanEqual(resColor, maxRefColor)),
   2881 											channelMask), channelMask))
   2882 					{
   2883 						if (!softCheck)
   2884 							pixelStatus.setColorStatus(PixelStatus::STATUS_FAIL);
   2885 					}
   2886 					else
   2887 						pixelStatus.setColorStatus(PixelStatus::STATUS_OK);
   2888 				}
   2889 			}
   2890 
   2891 			break;
   2892 		}
   2893 
   2894 		case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
   2895 		{
   2896 			for (int y = posA.y(); y <= posB.y(); y++)
   2897 			for (int x = posA.x(); x <= posB.x(); x++)
   2898 			{
   2899 				PixelStatus& pixelStatus = status[x + y * result.getWidth()];
   2900 
   2901 				if (pixelStatus.getColorStatus() == PixelStatus::STATUS_UNDEFINED)
   2902 				{
   2903 					const Vec4	minUvs			= computeUvs(posA, posB, IVec2(x-1, y-1));
   2904 					const Vec4	maxUvs			= computeUvs(posA, posB, IVec2(x+1, y+1));
   2905 					const bool	softCheck		= std::abs(x - posA.x()) <= 1 || std::abs(x - posB.x()) <= 1
   2906 												|| std::abs(y - posA.y()) <= 1 || std::abs(y - posB.y()) <= 1;
   2907 
   2908 					const IVec4	resColor		(result.getPixelInt(x, y));
   2909 
   2910 					const Vec4	minRefColorF	= valueMax * minUvs + valueMin * (Vec4(1.0f) - minUvs);
   2911 					const Vec4	maxRefColorF	= valueMax * maxUvs + valueMin * (Vec4(1.0f) - maxUvs);
   2912 
   2913 					const IVec4	minRefColor		(minRefColorF.asInt());
   2914 					const IVec4	maxRefColor		(maxRefColorF.asInt());
   2915 
   2916 					DE_ASSERT(minRefColor[0] <= maxRefColor[0]);
   2917 					DE_ASSERT(minRefColor[1] <= maxRefColor[1]);
   2918 					DE_ASSERT(minRefColor[2] <= maxRefColor[2]);
   2919 					DE_ASSERT(minRefColor[3] <= maxRefColor[3]);
   2920 
   2921 					if (tcu::anyNotEqual(tcu::logicalAnd(
   2922 											tcu::logicalAnd(greaterThanEqual(resColor, minRefColor),
   2923 															lessThanEqual(resColor, maxRefColor)),
   2924 											channelMask), channelMask))
   2925 					{
   2926 						if (!softCheck)
   2927 							pixelStatus.setColorStatus(PixelStatus::STATUS_FAIL);
   2928 					}
   2929 					else
   2930 						pixelStatus.setColorStatus(PixelStatus::STATUS_OK);
   2931 				}
   2932 			}
   2933 
   2934 			break;
   2935 		}
   2936 
   2937 		default:
   2938 			DE_FATAL("Invalid channel class");
   2939 	}
   2940 }
   2941 
   2942 void checkColorClear (const ConstPixelBufferAccess&	result,
   2943 					  const UVec2&					offset,
   2944 					  const UVec2&					size,
   2945 					  vector<PixelStatus>&			status,
   2946 					  const VkClearColorValue&		color)
   2947 {
   2948 	DE_ASSERT(offset.x() + size.x() <= (deUint32)result.getWidth());
   2949 	DE_ASSERT(offset.y() + size.y() <= (deUint32)result.getHeight());
   2950 
   2951 	DE_ASSERT(result.getWidth() * result.getHeight() == (int)status.size());
   2952 
   2953 	for (int y = offset.y(); y < (int)(offset.y() + size.y()); y++)
   2954 	for (int x = offset.x(); x < (int)(offset.x() + size.x()); x++)
   2955 	{
   2956 		PixelStatus& pixelStatus = status[x + y * result.getWidth()];
   2957 
   2958 		DE_ASSERT(x + y * result.getWidth() < (int)status.size());
   2959 
   2960 		if (pixelStatus.getColorStatus() == PixelStatus::STATUS_UNDEFINED)
   2961 		{
   2962 			if (comparePixelToColorClearValue(result, x, y, color))
   2963 				pixelStatus.setColorStatus(PixelStatus::STATUS_OK);
   2964 			else
   2965 				pixelStatus.setColorStatus(PixelStatus::STATUS_FAIL);
   2966 		}
   2967 	}
   2968 }
   2969 
   2970 void checkDepthClear (const ConstPixelBufferAccess&	result,
   2971 					  const UVec2&					offset,
   2972 					  const UVec2&					size,
   2973 					  vector<PixelStatus>&			status,
   2974 					  float							depth)
   2975 {
   2976 	for (int y = offset.y(); y < (int)(offset.y() + size.y()); y++)
   2977 	for (int x = offset.x(); x < (int)(offset.x() + size.x()); x++)
   2978 	{
   2979 		PixelStatus&	pixelStatus	= status[x + y * result.getWidth()];
   2980 
   2981 		if (pixelStatus.getDepthStatus() == PixelStatus::STATUS_UNDEFINED)
   2982 		{
   2983 			if (comparePixelToDepthClearValue(result, x, y, depth))
   2984 				pixelStatus.setDepthStatus(PixelStatus::STATUS_OK);
   2985 			else
   2986 				pixelStatus.setDepthStatus(PixelStatus::STATUS_FAIL);
   2987 		}
   2988 	}
   2989 }
   2990 
   2991 void checkStencilClear (const ConstPixelBufferAccess&	result,
   2992 						const UVec2&					offset,
   2993 						const UVec2&					size,
   2994 						vector<PixelStatus>&			status,
   2995 						deUint32						stencil)
   2996 {
   2997 	for (int y = offset.y(); y < (int)(offset.y() + size.y()); y++)
   2998 	for (int x = offset.x(); x < (int)(offset.x() + size.x()); x++)
   2999 	{
   3000 		PixelStatus&	pixelStatus	= status[x + y * result.getWidth()];
   3001 
   3002 		if (pixelStatus.getStencilStatus() == PixelStatus::STATUS_UNDEFINED)
   3003 		{
   3004 			if (comparePixelToStencilClearValue(result, x, y, stencil))
   3005 				pixelStatus.setStencilStatus(PixelStatus::STATUS_OK);
   3006 			else
   3007 				pixelStatus.setStencilStatus(PixelStatus::STATUS_FAIL);
   3008 		}
   3009 	}
   3010 }
   3011 
   3012 bool verifyAttachment (const ConstPixelBufferAccess&		result,
   3013 					   const Maybe<ConstPixelBufferAccess>&	secondaryResult,
   3014 					   const RenderPass&					renderPassInfo,
   3015 					   const Maybe<VkClearValue>&			renderPassClearValue,
   3016 					   const Maybe<VkClearValue>&			imageClearValue,
   3017 					   const vector<Subpass>&				subpasses,
   3018 					   const vector<SubpassRenderInfo>&		subpassRenderInfo,
   3019 					   const PixelBufferAccess&				errorImage,
   3020 					   deUint32								attachmentIndex,
   3021 					   const UVec2&							renderPos,
   3022 					   const UVec2&							renderSize)
   3023 {
   3024 	const tcu::TextureFormat&		format				= result.getFormat();
   3025 	const bool						hasDepth			= tcu::hasDepthComponent(format.order);
   3026 	const bool						hasStencil			= tcu::hasStencilComponent(format.order);
   3027 	const bool						isColorFormat		= !hasDepth && !hasStencil;
   3028 	const PixelStatus				initialStatus		(isColorFormat ? PixelStatus::STATUS_UNDEFINED : PixelStatus::STATUS_OK,
   3029 														 hasDepth ? PixelStatus::STATUS_UNDEFINED : PixelStatus::STATUS_OK,
   3030 														 hasStencil ? PixelStatus::STATUS_UNDEFINED : PixelStatus::STATUS_OK);
   3031 
   3032 	bool							attachmentIsUsed	= false;
   3033 	vector<PixelStatus>				status				(result.getWidth() * result.getHeight(), initialStatus);
   3034 	tcu::clear(errorImage, Vec4(0.0f, 1.0f, 0.0f, 1.0f));
   3035 
   3036 	// Check if attachment is used
   3037 	for (int subpassNdx = 0; subpassNdx < (int)subpasses.size(); subpassNdx++)
   3038 	{
   3039 		const Subpass&			subpass			= subpasses[subpassNdx];
   3040 		const Maybe<deUint32>	attachmentNdx	= findColorAttachment(subpass, attachmentIndex);
   3041 
   3042 		if (attachmentNdx || subpass.getDepthStencilAttachment().getAttachment() == attachmentIndex)
   3043 			attachmentIsUsed = true;
   3044 	}
   3045 
   3046 	// Set all pixels that have undefined values to OK
   3047 	if (attachmentIsUsed && (((isColorFormat || hasDepth) && renderPassInfo.getAttachments()[attachmentIndex].getStoreOp() == VK_ATTACHMENT_STORE_OP_DONT_CARE)
   3048 							|| (hasStencil && renderPassInfo.getAttachments()[attachmentIndex].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_DONT_CARE)))
   3049 	{
   3050 		for(int y = renderPos.y(); y < (int)(renderPos.y() + renderSize.y()); y++)
   3051 		for(int x = renderPos.x(); x < (int)(renderPos.x() + renderSize.x()); x++)
   3052 		{
   3053 			PixelStatus& pixelStatus = status[x + y * result.getWidth()];
   3054 
   3055 			if (isColorFormat && renderPassInfo.getAttachments()[attachmentIndex].getStoreOp() == VK_ATTACHMENT_STORE_OP_DONT_CARE)
   3056 				pixelStatus.setColorStatus(PixelStatus::STATUS_OK);
   3057 			else
   3058 			{
   3059 				if (hasDepth && renderPassInfo.getAttachments()[attachmentIndex].getStoreOp() == VK_ATTACHMENT_STORE_OP_DONT_CARE)
   3060 					pixelStatus.setDepthStatus(PixelStatus::STATUS_OK);
   3061 
   3062 				if (hasStencil && renderPassInfo.getAttachments()[attachmentIndex].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_DONT_CARE)
   3063 					pixelStatus.setStencilStatus(PixelStatus::STATUS_OK);
   3064 			}
   3065 		}
   3066 	}
   3067 
   3068 	// Check renderpass rendering results
   3069 	if (renderPassInfo.getAttachments()[attachmentIndex].getStoreOp() == VK_ATTACHMENT_STORE_OP_STORE
   3070 		|| (hasStencil && renderPassInfo.getAttachments()[attachmentIndex].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_STORE))
   3071 	{
   3072 		// Check subpass rendering results
   3073 		for (int subpassNdx = (int)subpasses.size() - 1; subpassNdx >= 0; subpassNdx--)
   3074 		{
   3075 			const Subpass&				subpass			= subpasses[subpassNdx];
   3076 			const SubpassRenderInfo&	renderInfo		= subpassRenderInfo[subpassNdx];
   3077 			const Maybe<deUint32>		attachmentNdx	= findColorAttachment(subpass, attachmentIndex);
   3078 
   3079 			// Check rendered quad
   3080 			if (renderInfo.getRenderQuad() && (attachmentNdx || subpass.getDepthStencilAttachment().getAttachment() == attachmentIndex))
   3081 			{
   3082 				const RenderQuad&	renderQuad	= *renderInfo.getRenderQuad();
   3083 				const Vec4			posA		= renderQuad.getCornerA();
   3084 				const Vec4			posB		= renderQuad.getCornerB();
   3085 				const Vec2			origin		= Vec2((float)renderInfo.getViewportOffset().x(), (float)renderInfo.getViewportOffset().y()) + Vec2((float)renderInfo.getViewportSize().x(), (float)renderInfo.getViewportSize().y()) / Vec2(2.0f);
   3086 				const Vec2			p			= Vec2((float)renderInfo.getViewportSize().x(), (float)renderInfo.getViewportSize().y()) / Vec2(2.0f);
   3087 				const IVec2			posAI		((deInt32)(origin.x() + (p.x() * posA.x())),
   3088 												 (deInt32)(origin.y() + (p.y() * posA.y())));
   3089 				const IVec2			posBI		((deInt32)(origin.x() + (p.x() * posB.x())),
   3090 												 (deInt32)(origin.y() + (p.y() * posB.y())));
   3091 
   3092 				if (isColorFormat)
   3093 					checkColorRenderQuad(result, posAI, posBI, status);
   3094 				else
   3095 				{
   3096 					if (hasDepth)
   3097 						checkDepthRenderQuad(result, posAI, posBI, status);
   3098 
   3099 					if (hasDepth && hasStencil)
   3100 						checkStencilRenderQuad(*secondaryResult, posAI, posBI, status);
   3101 					else if (hasStencil)
   3102 						checkStencilRenderQuad(result, posAI, posBI, status);
   3103 				}
   3104 			}
   3105 
   3106 			// Check color attachment clears
   3107 			if (attachmentNdx && !renderInfo.getColorClears().empty())
   3108 			{
   3109 				const ColorClear& clear = renderInfo.getColorClears()[*attachmentNdx];
   3110 
   3111 				checkColorClear(result, clear.getOffset(), clear.getSize(), status, clear.getColor());
   3112 			}
   3113 
   3114 			// Check depth/stencil attachment clears
   3115 			if (subpass.getDepthStencilAttachment().getAttachment() == attachmentIndex && renderInfo.getDepthStencilClear())
   3116 			{
   3117 				const DepthStencilClear clear = *renderInfo.getDepthStencilClear();
   3118 
   3119 				if (hasDepth)
   3120 					checkDepthClear(result, clear.getOffset(), clear.getSize(), status, clear.getDepth());
   3121 
   3122 				if (hasDepth && hasStencil)
   3123 					checkStencilClear(*secondaryResult, clear.getOffset(), clear.getSize(), status, clear.getStencil());
   3124 				else if (hasStencil)
   3125 					checkStencilClear(result, clear.getOffset(), clear.getSize(), status, clear.getStencil());
   3126 			}
   3127 		}
   3128 
   3129 		// Check renderpas clear results
   3130 		if (attachmentIsUsed && renderPassClearValue)
   3131 		{
   3132 			if (isColorFormat)
   3133 			{
   3134 				if (renderPassInfo.getAttachments()[attachmentIndex].getLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
   3135 					checkColorClear(result, renderPos, renderSize, status, renderPassClearValue->color);
   3136 			}
   3137 			else
   3138 			{
   3139 				if (hasDepth && renderPassInfo.getAttachments()[attachmentIndex].getLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
   3140 					checkDepthClear(result, renderPos, renderSize, status, renderPassClearValue->depthStencil.depth);
   3141 
   3142 				if (hasDepth && hasStencil && renderPassInfo.getAttachments()[attachmentIndex].getStencilLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
   3143 					checkStencilClear(*secondaryResult, renderPos, renderSize, status, renderPassClearValue->depthStencil.stencil);
   3144 				else if (hasStencil && renderPassInfo.getAttachments()[attachmentIndex].getStencilLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
   3145 					checkStencilClear(result, renderPos, renderSize, status, renderPassClearValue->depthStencil.stencil);
   3146 			}
   3147 		}
   3148 	}
   3149 
   3150 	// Set all pixels that have undefined values fater renderpass to OK
   3151 	if (attachmentIsUsed && (((isColorFormat || hasDepth) && renderPassInfo.getAttachments()[attachmentIndex].getLoadOp() == VK_ATTACHMENT_LOAD_OP_DONT_CARE)
   3152 							|| (hasStencil && renderPassInfo.getAttachments()[attachmentIndex].getStencilLoadOp() == VK_ATTACHMENT_LOAD_OP_DONT_CARE)))
   3153 	{
   3154 		for(int y = renderPos.y(); y < (int)(renderPos.y() + renderSize.y()); y++)
   3155 		for(int x = renderPos.x(); x < (int)(renderPos.x() + renderSize.x()); x++)
   3156 		{
   3157 			PixelStatus& pixelStatus = status[x + y * result.getWidth()];
   3158 
   3159 			if (pixelStatus.getColorStatus() == PixelStatus::STATUS_UNDEFINED
   3160 				&& isColorFormat && renderPassInfo.getAttachments()[attachmentIndex].getLoadOp() == VK_ATTACHMENT_LOAD_OP_DONT_CARE)
   3161 				pixelStatus.setColorStatus(PixelStatus::STATUS_OK);
   3162 			else
   3163 			{
   3164 				if (pixelStatus.getDepthStatus() == PixelStatus::STATUS_UNDEFINED
   3165 					&& hasDepth && renderPassInfo.getAttachments()[attachmentIndex].getLoadOp() == VK_ATTACHMENT_LOAD_OP_DONT_CARE)
   3166 					pixelStatus.setDepthStatus(PixelStatus::STATUS_OK);
   3167 
   3168 				if (pixelStatus.getStencilStatus() == PixelStatus::STATUS_UNDEFINED
   3169 					&& hasStencil && renderPassInfo.getAttachments()[attachmentIndex].getStencilLoadOp() == VK_ATTACHMENT_LOAD_OP_DONT_CARE)
   3170 					pixelStatus.setStencilStatus(PixelStatus::STATUS_OK);
   3171 			}
   3172 		}
   3173 	}
   3174 
   3175 	if (imageClearValue)
   3176 	{
   3177 		if (isColorFormat)
   3178 			checkColorClear(result, UVec2(0, 0), UVec2(result.getWidth(), result.getHeight()), status, imageClearValue->color);
   3179 		else
   3180 		{
   3181 			if (hasDepth)
   3182 				checkDepthClear(result, UVec2(0, 0), UVec2(result.getWidth(), result.getHeight()), status, imageClearValue->depthStencil.depth);
   3183 
   3184 			if (hasDepth && hasStencil)
   3185 				checkStencilClear(*secondaryResult, UVec2(0, 0), UVec2(secondaryResult->getWidth(), result.getHeight()), status, imageClearValue->depthStencil.stencil);
   3186 			else if (hasStencil)
   3187 				checkStencilClear(result, UVec2(0, 0), UVec2(result.getWidth(), result.getHeight()), status, imageClearValue->depthStencil.stencil);
   3188 		}
   3189 	}
   3190 
   3191 	{
   3192 		bool isOk = true;
   3193 
   3194 		for(int y = 0; y < result.getHeight(); y++)
   3195 		for(int x = 0; x < result.getWidth(); x++)
   3196 		{
   3197 			const PixelStatus& pixelStatus = status[x + y * result.getWidth()];
   3198 
   3199 			if (isColorFormat)
   3200 			{
   3201 				if (pixelStatus.getColorStatus() != PixelStatus::STATUS_OK)
   3202 				{
   3203 					if (pixelStatus.getColorStatus() == PixelStatus::STATUS_UNDEFINED)
   3204 						errorImage.setPixel(Vec4(1.0f, 1.0f, 0.0f, 1.0f), x, y);
   3205 					else if (pixelStatus.getColorStatus() == PixelStatus::STATUS_FAIL)
   3206 						errorImage.setPixel(Vec4(1.0f, 0.0f, 0.0f, 1.0f), x, y);
   3207 
   3208 					isOk = false;
   3209 				}
   3210 			}
   3211 			else
   3212 			{
   3213 				if (hasDepth && pixelStatus.getDepthStatus() != PixelStatus::STATUS_OK)
   3214 				{
   3215 					errorImage.setPixel(Vec4(1.0f, 0.0f, 0.0f, 1.0f), x, y);
   3216 					isOk = false;
   3217 				}
   3218 
   3219 				if (hasStencil && pixelStatus.getStencilStatus() != PixelStatus::STATUS_OK)
   3220 				{
   3221 					errorImage.setPixel(Vec4(1.0f, 0.0f, 0.0f, 1.0f), x, y);
   3222 					isOk = false;
   3223 				}
   3224 			}
   3225 		}
   3226 
   3227 		return isOk;
   3228 	}
   3229 }
   3230 
   3231 bool logAndVerifyImages (TestLog&											log,
   3232 						 const DeviceInterface&								vk,
   3233 						 VkDevice											device,
   3234 						 const vector<de::SharedPtr<AttachmentResources> >&	attachmentResources,
   3235 						 const vector<bool>&								attachmentIsLazy,
   3236 						 const RenderPass&									renderPassInfo,
   3237 						 const vector<Maybe<VkClearValue> >&				renderPassClearValues,
   3238 						 const vector<Maybe<VkClearValue> >&				imageClearValues,
   3239 						 const vector<SubpassRenderInfo>&					subpassRenderInfo,
   3240 						 const UVec2&										targetSize,
   3241 						 const TestConfig&									config)
   3242 {
   3243 	vector<tcu::TextureLevel>	referenceAttachments;
   3244 	bool						isOk					= true;
   3245 
   3246 	log << TestLog::Message << "Reference images fill undefined pixels with grid pattern." << TestLog::EndMessage;
   3247 
   3248 	renderReferenceImages(referenceAttachments, renderPassInfo, targetSize, imageClearValues, renderPassClearValues, subpassRenderInfo, config.renderPos, config.renderSize);
   3249 
   3250 	for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
   3251 	{
   3252 		if (!attachmentIsLazy[attachmentNdx])
   3253 		{
   3254 			const Attachment			attachment		= renderPassInfo.getAttachments()[attachmentNdx];
   3255 			const tcu::TextureFormat	format			= mapVkFormat(attachment.getFormat());
   3256 
   3257 			if (tcu::hasDepthComponent(format.order) && tcu::hasStencilComponent(format.order))
   3258 			{
   3259 				const tcu::TextureFormat	depthFormat		= getDepthCopyFormat(attachment.getFormat());
   3260 				const VkDeviceSize			depthBufferSize	= targetSize.x() * targetSize.y() * depthFormat.getPixelSize();
   3261 				void* const					depthPtr		= attachmentResources[attachmentNdx]->getResultMemory().getHostPtr();
   3262 
   3263 				const tcu::TextureFormat	stencilFormat		= getStencilCopyFormat(attachment.getFormat());
   3264 				const VkDeviceSize			stencilBufferSize	= targetSize.x() * targetSize.y() * stencilFormat.getPixelSize();
   3265 				void* const					stencilPtr			= attachmentResources[attachmentNdx]->getSecondaryResultMemory().getHostPtr();
   3266 
   3267 				const VkMappedMemoryRange	ranges[] =
   3268 				{
   3269 					{
   3270 						VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,								// sType;
   3271 						DE_NULL,															// pNext;
   3272 						attachmentResources[attachmentNdx]->getResultMemory().getMemory(),	// mem;
   3273 						attachmentResources[attachmentNdx]->getResultMemory().getOffset(),	// offset;
   3274 						depthBufferSize														// size;
   3275 					},
   3276 					{
   3277 						VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,										// sType;
   3278 						DE_NULL,																	// pNext;
   3279 						attachmentResources[attachmentNdx]->getSecondaryResultMemory().getMemory(),	// mem;
   3280 						attachmentResources[attachmentNdx]->getSecondaryResultMemory().getOffset(),	// offset;
   3281 						stencilBufferSize															// size;
   3282 					}
   3283 				};
   3284 				VK_CHECK(vk.invalidateMappedMemoryRanges(device, 2u, ranges));
   3285 
   3286 				{
   3287 					const ConstPixelBufferAccess	depthAccess		(depthFormat, targetSize.x(), targetSize.y(), 1, depthPtr);
   3288 					const ConstPixelBufferAccess	stencilAccess	(stencilFormat, targetSize.x(), targetSize.y(), 1, stencilPtr);
   3289 					tcu::TextureLevel				errorImage		(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), targetSize.x(), targetSize.y());
   3290 
   3291 					log << TestLog::Image("Attachment" + de::toString(attachmentNdx) + "Depth", "Attachment " + de::toString(attachmentNdx) + " Depth", depthAccess);
   3292 					log << TestLog::Image("Attachment" + de::toString(attachmentNdx) + "Stencil", "Attachment " + de::toString(attachmentNdx) + " Stencil", stencilAccess);
   3293 
   3294 					log << TestLog::Image("AttachmentReference" + de::toString(attachmentNdx), "Attachment reference " + de::toString(attachmentNdx), referenceAttachments[attachmentNdx].getAccess());
   3295 
   3296 					if ((renderPassInfo.getAttachments()[attachmentNdx].getStoreOp() == VK_ATTACHMENT_STORE_OP_STORE || renderPassInfo.getAttachments()[attachmentNdx].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_STORE)
   3297 						&& !verifyAttachment(depthAccess, tcu::just(stencilAccess), renderPassInfo, renderPassClearValues[attachmentNdx], imageClearValues[attachmentNdx], renderPassInfo.getSubpasses(), subpassRenderInfo, errorImage.getAccess(), (deUint32)attachmentNdx, config.renderPos, config.renderSize))
   3298 					{
   3299 						log << TestLog::Image("AttachmentError" + de::toString(attachmentNdx), "Attachment Error " + de::toString(attachmentNdx), errorImage.getAccess());
   3300 						isOk = false;
   3301 					}
   3302 				}
   3303 			}
   3304 			else
   3305 			{
   3306 				const VkDeviceSize			bufferSize	= targetSize.x() * targetSize.y() * format.getPixelSize();
   3307 				void* const					ptr			= attachmentResources[attachmentNdx]->getResultMemory().getHostPtr();
   3308 
   3309 				const VkMappedMemoryRange	range	=
   3310 				{
   3311 					VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,								// sType;
   3312 					DE_NULL,															// pNext;
   3313 					attachmentResources[attachmentNdx]->getResultMemory().getMemory(),	// mem;
   3314 					attachmentResources[attachmentNdx]->getResultMemory().getOffset(),	// offset;
   3315 					bufferSize															// size;
   3316 				};
   3317 				VK_CHECK(vk.invalidateMappedMemoryRanges(device, 1u, &range));
   3318 
   3319 				{
   3320 					const ConstPixelBufferAccess	access		(format, targetSize.x(), targetSize.y(), 1, ptr);
   3321 					tcu::TextureLevel				errorImage	(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), targetSize.x(), targetSize.y());
   3322 
   3323 					log << TestLog::Image("Attachment" + de::toString(attachmentNdx), "Attachment " + de::toString(attachmentNdx), access);
   3324 					log << TestLog::Image("AttachmentReference" + de::toString(attachmentNdx), "Attachment reference " + de::toString(attachmentNdx), referenceAttachments[attachmentNdx].getAccess());
   3325 
   3326 					if ((renderPassInfo.getAttachments()[attachmentNdx].getStoreOp() == VK_ATTACHMENT_STORE_OP_STORE || renderPassInfo.getAttachments()[attachmentNdx].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_STORE)
   3327 						&& !verifyAttachment(access, tcu::nothing<ConstPixelBufferAccess>(), renderPassInfo, renderPassClearValues[attachmentNdx], imageClearValues[attachmentNdx], renderPassInfo.getSubpasses(), subpassRenderInfo, errorImage.getAccess(), (deUint32)attachmentNdx, config.renderPos, config.renderSize))
   3328 					{
   3329 						log << TestLog::Image("AttachmentError" + de::toString(attachmentNdx), "Attachment Error " + de::toString(attachmentNdx), errorImage.getAccess());
   3330 						isOk = false;
   3331 					}
   3332 				}
   3333 			}
   3334 		}
   3335 	}
   3336 
   3337 	return isOk;
   3338 }
   3339 
   3340 std::string getAttachmentType (VkFormat vkFormat)
   3341 {
   3342 	const tcu::TextureFormat		format			= mapVkFormat(vkFormat);
   3343 	const tcu::TextureChannelClass	channelClass	= tcu::getTextureChannelClass(format.type);
   3344 
   3345 	switch (channelClass)
   3346 	{
   3347 		case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
   3348 			return "ivec4";
   3349 
   3350 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
   3351 			return "uvec4";
   3352 
   3353 		case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
   3354 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
   3355 		case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
   3356 			return "vec4";
   3357 
   3358 		default:
   3359 			DE_FATAL("Unknown channel class");
   3360 			return "";
   3361 	}
   3362 }
   3363 
   3364 void createTestShaders (SourceCollections& dst, TestConfig config)
   3365 {
   3366 	if (config.renderTypes & TestConfig::RENDERTYPES_DRAW)
   3367 	{
   3368 		const vector<Subpass>&	subpasses	= config.renderPass.getSubpasses();
   3369 
   3370 		for (size_t subpassNdx = 0; subpassNdx < subpasses.size(); subpassNdx++)
   3371 		{
   3372 			const Subpass&		subpass		= subpasses[subpassNdx];
   3373 			std::ostringstream	vertexShader;
   3374 			std::ostringstream	fragmentShader;
   3375 
   3376 			vertexShader << "#version 310 es\n"
   3377 						 << "layout(location = 0) in highp vec4 a_position;\n"
   3378 						 << "layout(location = 0) out highp vec2 v_color;\n"
   3379 						 << "void main (void) {\n"
   3380 						 << "\thighp float a = 0.5 + a_position.x;\n"
   3381 						 << "\thighp float b = 0.5 + a_position.y;\n"
   3382 						 << "\tv_color = vec2(a, b);\n"
   3383 						 << "\tgl_Position = a_position;\n"
   3384 						 << "}\n";
   3385 
   3386 			fragmentShader << "#version 310 es\n"
   3387 						   << "layout(location = 0) in highp vec2 v_color;\n";
   3388 
   3389 			for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
   3390 			{
   3391 				const std::string attachmentType = getAttachmentType(config.renderPass.getAttachments()[subpass.getColorAttachments()[attachmentNdx].getAttachment()].getFormat());
   3392 				fragmentShader << "layout(location = " << attachmentNdx << ") out highp " << attachmentType << " o_color" << attachmentNdx << ";\n";
   3393 			}
   3394 
   3395 			fragmentShader	<< "void main (void) {\n"
   3396 							<< "\thighp vec4 scale = vec4(v_color.x, v_color.y, v_color.x * v_color.y, (v_color.x + v_color.y) / 2.0);\n";
   3397 
   3398 			for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
   3399 			{
   3400 				const tcu::TextureFormat		format			= mapVkFormat(config.renderPass.getAttachments()[subpass.getColorAttachments()[attachmentNdx].getAttachment()].getFormat());
   3401 				const tcu::TextureFormatInfo	formatInfo		= tcu::getTextureFormatInfo(format);
   3402 				const float						clampMin		= (float)(-MAX_INTEGER_VALUE);
   3403 				const float						clampMax		= (float)(MAX_INTEGER_VALUE);
   3404 				const Vec4						valueMax		(de::clamp(formatInfo.valueMax[0], clampMin, clampMax),
   3405 																 de::clamp(formatInfo.valueMax[1], clampMin, clampMax),
   3406 																 de::clamp(formatInfo.valueMax[2], clampMin, clampMax),
   3407 																 de::clamp(formatInfo.valueMax[3], clampMin, clampMax));
   3408 
   3409 				const Vec4						valueMin		(de::clamp(formatInfo.valueMin[0], clampMin, clampMax),
   3410 																 de::clamp(formatInfo.valueMin[1], clampMin, clampMax),
   3411 																 de::clamp(formatInfo.valueMin[2], clampMin, clampMax),
   3412 																 de::clamp(formatInfo.valueMin[3], clampMin, clampMax));
   3413 				const std::string				attachmentType	= getAttachmentType(config.renderPass.getAttachments()[subpass.getColorAttachments()[attachmentNdx].getAttachment()].getFormat());
   3414 
   3415 				fragmentShader << "\to_color" << attachmentNdx << " = " << attachmentType << "(vec4" << valueMin << " + vec4" << (valueMax - valueMin)  << " * scale);\n";
   3416 			}
   3417 
   3418 			fragmentShader << "}\n";
   3419 
   3420 			dst.glslSources.add(de::toString(subpassNdx) + "-vert") << glu::VertexSource(vertexShader.str());
   3421 			dst.glslSources.add(de::toString(subpassNdx) + "-frag") << glu::FragmentSource(fragmentShader.str());
   3422 		}
   3423 	}
   3424 }
   3425 
   3426 void initializeAttachmentIsLazy (vector<bool>& attachmentIsLazy, const vector<Attachment>& attachments, TestConfig::ImageMemory imageMemory)
   3427 {
   3428 	bool lastAttachmentWasLazy = false;
   3429 
   3430 	for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
   3431 	{
   3432 		if (attachments[attachmentNdx].getLoadOp() != VK_ATTACHMENT_LOAD_OP_LOAD
   3433 			&& attachments[attachmentNdx].getStoreOp() != VK_ATTACHMENT_STORE_OP_STORE
   3434 			&& attachments[attachmentNdx].getStencilLoadOp() != VK_ATTACHMENT_LOAD_OP_LOAD
   3435 			&& attachments[attachmentNdx].getStencilStoreOp() != VK_ATTACHMENT_STORE_OP_STORE)
   3436 		{
   3437 			if (imageMemory == TestConfig::IMAGEMEMORY_LAZY || (imageMemory & TestConfig::IMAGEMEMORY_LAZY && !lastAttachmentWasLazy))
   3438 			{
   3439 				attachmentIsLazy.push_back(true);
   3440 				lastAttachmentWasLazy = true;
   3441 			}
   3442 			else if (imageMemory & TestConfig::IMAGEMEMORY_STRICT)
   3443 			{
   3444 				attachmentIsLazy.push_back(false);
   3445 				lastAttachmentWasLazy = false;
   3446 			}
   3447 			else
   3448 				DE_FATAL("Unknown imageMemory");
   3449 		}
   3450 		else
   3451 			attachmentIsLazy.push_back(false);
   3452 	}
   3453 }
   3454 
   3455 enum AttachmentRefType
   3456 {
   3457 	ATTACHMENTREFTYPE_COLOR,
   3458 	ATTACHMENTREFTYPE_DEPTH_STENCIL,
   3459 	ATTACHMENTREFTYPE_INPUT,
   3460 	ATTACHMENTREFTYPE_RESOLVE,
   3461 };
   3462 
   3463 VkImageUsageFlags getImageUsageFromLayout(VkImageLayout layout)
   3464 {
   3465 	switch (layout)
   3466 	{
   3467 		case VK_IMAGE_LAYOUT_GENERAL:
   3468 		case VK_IMAGE_LAYOUT_PREINITIALIZED:
   3469 			return 0;
   3470 		case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
   3471 			return VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
   3472 		case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
   3473 		case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
   3474 			return VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
   3475 		case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
   3476 			return VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
   3477 		case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
   3478 			return VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
   3479 		case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
   3480 			return VK_IMAGE_USAGE_TRANSFER_DST_BIT;
   3481 		default:
   3482 			DE_FATAL("Unexpected image layout");
   3483 			return 0;
   3484 	}
   3485 }
   3486 
   3487 void getImageUsageFromAttachmentReferences(vector<VkImageUsageFlags>& attachmentImageUsage, AttachmentRefType refType, size_t count, const AttachmentReference* references)
   3488 {
   3489 	for (size_t referenceNdx = 0; referenceNdx < count; ++referenceNdx)
   3490 	{
   3491 		const deUint32 attachment = references[referenceNdx].getAttachment();
   3492 
   3493 		if (attachment != VK_ATTACHMENT_UNUSED)
   3494 		{
   3495 			VkImageUsageFlags usage;
   3496 
   3497 			switch (refType)
   3498 			{
   3499 				case ATTACHMENTREFTYPE_COLOR:
   3500 				case ATTACHMENTREFTYPE_RESOLVE:
   3501 					usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
   3502 					break;
   3503 				case ATTACHMENTREFTYPE_DEPTH_STENCIL:
   3504 					usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
   3505 					break;
   3506 				case ATTACHMENTREFTYPE_INPUT:
   3507 					usage = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
   3508 					break;
   3509 				default:
   3510 					DE_FATAL("Unexpected attachment reference type");
   3511 					usage = 0;
   3512 					break;
   3513 			}
   3514 
   3515 			attachmentImageUsage[attachment] |= usage;
   3516 		}
   3517 	}
   3518 }
   3519 
   3520 void getImageUsageFromAttachmentReferences(vector<VkImageUsageFlags>& attachmentImageUsage, AttachmentRefType refType, const vector<AttachmentReference>& references)
   3521 {
   3522 	if (!references.empty())
   3523 	{
   3524 		getImageUsageFromAttachmentReferences(attachmentImageUsage, refType, references.size(), &references[0]);
   3525 	}
   3526 }
   3527 
   3528 void initializeAttachmentImageUsage (Context &context, vector<VkImageUsageFlags>& attachmentImageUsage, const RenderPass& renderPassInfo, const vector<bool>& attachmentIsLazy, const vector<Maybe<VkClearValue> >& clearValues)
   3529 {
   3530 	attachmentImageUsage.resize(renderPassInfo.getAttachments().size(), VkImageUsageFlags(0));
   3531 
   3532 	for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); ++subpassNdx)
   3533 	{
   3534 		const Subpass& subpass = renderPassInfo.getSubpasses()[subpassNdx];
   3535 
   3536 		getImageUsageFromAttachmentReferences(attachmentImageUsage, ATTACHMENTREFTYPE_COLOR, subpass.getColorAttachments());
   3537 		getImageUsageFromAttachmentReferences(attachmentImageUsage, ATTACHMENTREFTYPE_DEPTH_STENCIL, 1, &subpass.getDepthStencilAttachment());
   3538 		getImageUsageFromAttachmentReferences(attachmentImageUsage, ATTACHMENTREFTYPE_INPUT, subpass.getInputAttachments());
   3539 		getImageUsageFromAttachmentReferences(attachmentImageUsage, ATTACHMENTREFTYPE_RESOLVE, subpass.getResolveAttachments());
   3540 	}
   3541 
   3542 	for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
   3543 	{
   3544 		const Attachment& attachment = renderPassInfo.getAttachments()[attachmentNdx];
   3545 
   3546 		const VkFormatProperties		formatProperties = getPhysicalDeviceFormatProperties(context.getInstanceInterface(), context.getPhysicalDevice(), attachment.getFormat());
   3547 		const VkFormatFeatureFlags		supportedFeatures = formatProperties.optimalTilingFeatures;
   3548 
   3549 		if ((supportedFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0)
   3550 			attachmentImageUsage[attachmentNdx] |= VK_IMAGE_USAGE_SAMPLED_BIT;
   3551 
   3552 		if ((supportedFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) != 0)
   3553 			attachmentImageUsage[attachmentNdx] |= VK_IMAGE_USAGE_STORAGE_BIT;
   3554 
   3555 		attachmentImageUsage[attachmentNdx] |= getImageUsageFromLayout(attachment.getInitialLayout());
   3556 		attachmentImageUsage[attachmentNdx] |= getImageUsageFromLayout(attachment.getFinalLayout());
   3557 
   3558 		if (!attachmentIsLazy[attachmentNdx])
   3559 		{
   3560 			if (clearValues[attachmentNdx])
   3561 				attachmentImageUsage[attachmentNdx] |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
   3562 
   3563 			attachmentImageUsage[attachmentNdx] |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
   3564 		}
   3565 	}
   3566 }
   3567 
   3568 void initializeSubpassIsSecondary (vector<bool>& subpassIsSecondary, const vector<Subpass>& subpasses, TestConfig::CommandBufferTypes commandBuffer)
   3569 {
   3570 	bool lastSubpassWasSecondary = false;
   3571 
   3572 	for (size_t subpassNdx = 0; subpassNdx < subpasses.size(); subpassNdx++)
   3573 	{
   3574 		if (commandBuffer == TestConfig::COMMANDBUFFERTYPES_SECONDARY || (commandBuffer & TestConfig::COMMANDBUFFERTYPES_SECONDARY && !lastSubpassWasSecondary))
   3575 		{
   3576 			subpassIsSecondary.push_back(true);
   3577 			lastSubpassWasSecondary = true;
   3578 		}
   3579 		else if (commandBuffer & TestConfig::COMMANDBUFFERTYPES_INLINE)
   3580 		{
   3581 			subpassIsSecondary.push_back(false);
   3582 			lastSubpassWasSecondary = false;
   3583 		}
   3584 		else
   3585 			DE_FATAL("Unknown commandBuffer");
   3586 	}
   3587 }
   3588 
   3589 void initializeImageClearValues (de::Random& rng, vector<Maybe<VkClearValue> >& clearValues, const vector<Attachment>& attachments, const vector<bool>& isLazy)
   3590 {
   3591 	for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
   3592 	{
   3593 		if (!isLazy[attachmentNdx])
   3594 			clearValues.push_back(just(randomClearValue(attachments[attachmentNdx], rng)));
   3595 		else
   3596 			clearValues.push_back(nothing<VkClearValue>());
   3597 	}
   3598 }
   3599 
   3600 void initializeRenderPassClearValues (de::Random& rng, vector<Maybe<VkClearValue> >& clearValues, const vector<Attachment>& attachments)
   3601 {
   3602 	for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
   3603 	{
   3604 		if (attachments[attachmentNdx].getLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR
   3605 			|| attachments[attachmentNdx].getStencilLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
   3606 		{
   3607 			clearValues.push_back(just(randomClearValue(attachments[attachmentNdx], rng)));
   3608 		}
   3609 		else
   3610 			clearValues.push_back(nothing<VkClearValue>());
   3611 	}
   3612 }
   3613 
   3614 void initializeSubpassClearValues (de::Random& rng, vector<vector<VkClearColorValue> >& clearValues, const RenderPass& renderPass)
   3615 {
   3616 	clearValues.resize(renderPass.getSubpasses().size());
   3617 
   3618 	for (size_t subpassNdx = 0; subpassNdx < renderPass.getSubpasses().size(); subpassNdx++)
   3619 	{
   3620 		const Subpass&						subpass				= renderPass.getSubpasses()[subpassNdx];
   3621 		const vector<AttachmentReference>&	colorAttachments	= subpass.getColorAttachments();
   3622 
   3623 		clearValues[subpassNdx].resize(colorAttachments.size());
   3624 
   3625 		for (size_t attachmentRefNdx = 0; attachmentRefNdx < colorAttachments.size(); attachmentRefNdx++)
   3626 		{
   3627 			const AttachmentReference&	attachmentRef	= colorAttachments[attachmentRefNdx];
   3628 			const Attachment&			attachment		= renderPass.getAttachments()[attachmentRef.getAttachment()];
   3629 
   3630 			clearValues[subpassNdx][attachmentRefNdx] = randomColorClearValue(attachment, rng);
   3631 		}
   3632 	}
   3633 }
   3634 
   3635 void logSubpassRenderInfo (TestLog&					log,
   3636 						   const SubpassRenderInfo&	info)
   3637 {
   3638 	log << TestLog::Message << "Viewport, offset: " << info.getViewportOffset() << ", size: " << info.getViewportSize() << TestLog::EndMessage;
   3639 
   3640 	if (info.isSecondary())
   3641 		log << TestLog::Message << "Subpass uses secondary command buffers" << TestLog::EndMessage;
   3642 	else
   3643 		log << TestLog::Message << "Subpass uses inlined commands" << TestLog::EndMessage;
   3644 
   3645 	for (deUint32 attachmentNdx = 0; attachmentNdx < info.getColorClears().size(); attachmentNdx++)
   3646 	{
   3647 		const ColorClear&	colorClear	= info.getColorClears()[attachmentNdx];
   3648 
   3649 		log << TestLog::Message << "Clearing color attachment " << attachmentNdx
   3650 			<< ". Offset: " << colorClear.getOffset()
   3651 			<< ", Size: " << colorClear.getSize()
   3652 			<< ", Color: " << clearColorToString(info.getColorAttachment(attachmentNdx).getFormat(), colorClear.getColor()) << TestLog::EndMessage;
   3653 	}
   3654 
   3655 	if (info.getDepthStencilClear())
   3656 	{
   3657 		const DepthStencilClear&	depthStencilClear	= *info.getDepthStencilClear();
   3658 
   3659 		log << TestLog::Message << "Clearing depth stencil attachment"
   3660 			<< ". Offset: " << depthStencilClear.getOffset()
   3661 			<< ", Size: " << depthStencilClear.getSize()
   3662 			<< ", Depth: " << depthStencilClear.getDepth()
   3663 			<< ", Stencil: " << depthStencilClear.getStencil() << TestLog::EndMessage;
   3664 	}
   3665 
   3666 	if (info.getRenderQuad())
   3667 	{
   3668 		const RenderQuad&	renderQuad	= *info.getRenderQuad();
   3669 
   3670 		log << TestLog::Message << "Rendering gradient quad to " << renderQuad.getCornerA() << " -> " << renderQuad.getCornerB() << TestLog::EndMessage;
   3671 	}
   3672 }
   3673 
   3674 void logTestCaseInfo (TestLog&									log,
   3675 					  const TestConfig&							config,
   3676 					  const vector<bool>&						attachmentIsLazy,
   3677 					  const vector<Maybe<VkClearValue> >&		imageClearValues,
   3678 					  const vector<Maybe<VkClearValue> >&		renderPassClearValues,
   3679 					  const vector<SubpassRenderInfo>&			subpassRenderInfo)
   3680 {
   3681 	const RenderPass&	renderPass	= config.renderPass;
   3682 
   3683 	logRenderPassInfo(log, renderPass);
   3684 
   3685 	DE_ASSERT(attachmentIsLazy.size() == renderPass.getAttachments().size());
   3686 	DE_ASSERT(imageClearValues.size() == renderPass.getAttachments().size());
   3687 	DE_ASSERT(renderPassClearValues.size() == renderPass.getAttachments().size());
   3688 
   3689 	log << TestLog::Message << "TargetSize: " << config.targetSize << TestLog::EndMessage;
   3690 	log << TestLog::Message << "Render area, Offset: " << config.renderPos << ", Size: " << config.renderSize << TestLog::EndMessage;
   3691 
   3692 	for (size_t attachmentNdx = 0; attachmentNdx < attachmentIsLazy.size(); attachmentNdx++)
   3693 	{
   3694 		const tcu::ScopedLogSection	section	(log, "Attachment" + de::toString(attachmentNdx), "Attachment " + de::toString(attachmentNdx));
   3695 
   3696 		if (attachmentIsLazy[attachmentNdx])
   3697 			log << TestLog::Message << "Is lazy." << TestLog::EndMessage;
   3698 
   3699 		if (imageClearValues[attachmentNdx])
   3700 			log << TestLog::Message << "Image is cleared to " << clearValueToString(renderPass.getAttachments()[attachmentNdx].getFormat(), *imageClearValues[attachmentNdx]) << " before rendering." << TestLog::EndMessage;
   3701 
   3702 		if (renderPass.getAttachments()[attachmentNdx].getLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR && renderPassClearValues[attachmentNdx])
   3703 			log << TestLog::Message << "Attachment is cleared to " << clearValueToString(renderPass.getAttachments()[attachmentNdx].getFormat(), *renderPassClearValues[attachmentNdx]) << " in the beginning of the render pass." << TestLog::EndMessage;
   3704 	}
   3705 
   3706 	for (size_t subpassNdx = 0; subpassNdx < renderPass.getSubpasses().size(); subpassNdx++)
   3707 	{
   3708 		const tcu::ScopedLogSection section (log, "Subpass" + de::toString(subpassNdx), "Subpass " + de::toString(subpassNdx));
   3709 
   3710 		logSubpassRenderInfo(log, subpassRenderInfo[subpassNdx]);
   3711 	}
   3712 }
   3713 
   3714 void initializeSubpassRenderInfo (vector<SubpassRenderInfo>& renderInfos, de::Random& rng, const RenderPass& renderPass, const TestConfig& config)
   3715 {
   3716 	const TestConfig::CommandBufferTypes	commandBuffer			= config.commandBufferTypes;
   3717 	const vector<Subpass>&					subpasses				= renderPass.getSubpasses();
   3718 	bool									lastSubpassWasSecondary	= false;
   3719 
   3720 	for (deUint32 subpassNdx = 0; subpassNdx < (deUint32)subpasses.size(); subpassNdx++)
   3721 	{
   3722 		const Subpass&				subpass				= subpasses[subpassNdx];
   3723 		const bool					subpassIsSecondary	= commandBuffer == TestConfig::COMMANDBUFFERTYPES_SECONDARY
   3724 														|| (commandBuffer & TestConfig::COMMANDBUFFERTYPES_SECONDARY && !lastSubpassWasSecondary) ? true : false;
   3725 		const UVec2					viewportSize		((config.renderSize * UVec2(2)) / UVec2(3));
   3726 		const UVec2					viewportOffset		(config.renderPos.x() + (subpassNdx % 2) * (config.renderSize.x() / 3),
   3727 														 config.renderPos.y() + ((subpassNdx / 2) % 2) * (config.renderSize.y() / 3));
   3728 
   3729 		vector<ColorClear>			colorClears;
   3730 		Maybe<DepthStencilClear>	depthStencilClear;
   3731 		Maybe<RenderQuad>			renderQuad;
   3732 
   3733 		lastSubpassWasSecondary		= subpassIsSecondary;
   3734 
   3735 		if (config.renderTypes & TestConfig::RENDERTYPES_CLEAR)
   3736 		{
   3737 			const vector<AttachmentReference>&	colorAttachments	= subpass.getColorAttachments();
   3738 
   3739 			for (size_t attachmentRefNdx = 0; attachmentRefNdx < colorAttachments.size(); attachmentRefNdx++)
   3740 			{
   3741 				const AttachmentReference&	attachmentRef	= colorAttachments[attachmentRefNdx];
   3742 				const Attachment&			attachment		= renderPass.getAttachments()[attachmentRef.getAttachment()];
   3743 				const UVec2					size			((viewportSize * UVec2(2)) / UVec2(3));
   3744 				const UVec2					offset			(viewportOffset.x() + ((deUint32)attachmentRefNdx % 2u) * (viewportSize.x() / 3u),
   3745 															 viewportOffset.y() + (((deUint32)attachmentRefNdx / 2u) % 2u) * (viewportSize.y() / 3u));
   3746 				const VkClearColorValue		color			= randomColorClearValue(attachment, rng);
   3747 
   3748 				colorClears.push_back(ColorClear(offset, size, color));
   3749 			}
   3750 
   3751 			if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED)
   3752 			{
   3753 				const Attachment&	attachment		= renderPass.getAttachments()[subpass.getDepthStencilAttachment().getAttachment()];
   3754 				const UVec2			size			((viewportSize * UVec2(2)) / UVec2(3));
   3755 				const UVec2			offset			(viewportOffset.x() + ((deUint32)colorAttachments.size() % 2u) * (viewportSize.x() / 3u),
   3756 													 viewportOffset.y() + (((deUint32)colorAttachments.size() / 2u) % 2u) * (viewportSize.y() / 3u));
   3757 				const VkClearValue	value			= randomClearValue(attachment, rng);
   3758 
   3759 				depthStencilClear = tcu::just(DepthStencilClear(offset, size, value.depthStencil.depth, value.depthStencil.stencil));
   3760 			}
   3761 		}
   3762 
   3763 		if (config.renderTypes & TestConfig::RENDERTYPES_DRAW)
   3764 		{
   3765 			// (-0.5,-0.5) - (0.5,0.5) rounded to pixel edges
   3766 			const float x = (float)(viewportSize.x() / 4) / (float)(viewportSize.x() / 2);
   3767 			const float y = (float)(viewportSize.y() / 4) / (float)(viewportSize.y() / 2);
   3768 			renderQuad = tcu::just(RenderQuad(tcu::Vec4(-x, -y, 0.0f, 1.0f), tcu::Vec4(x, y, 1.0f, 1.0f)));
   3769 		}
   3770 
   3771 		renderInfos.push_back(SubpassRenderInfo(renderPass, subpassNdx, subpassIsSecondary, viewportOffset, viewportSize, renderQuad, colorClears, depthStencilClear));
   3772 	}
   3773 }
   3774 
   3775 void checkTextureFormatSupport (TestLog&					log,
   3776 								const InstanceInterface&	vk,
   3777 								VkPhysicalDevice			device,
   3778 								const vector<Attachment>&	attachments)
   3779 {
   3780 	bool supported = true;
   3781 
   3782 	for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
   3783 	{
   3784 		const Attachment&			attachment					= attachments[attachmentNdx];
   3785 		const tcu::TextureFormat	format						= mapVkFormat(attachment.getFormat());
   3786 		const bool					isDepthOrStencilAttachment	= hasDepthComponent(format.order) || hasStencilComponent(format.order);
   3787 		const VkFormatFeatureFlags	flags						= isDepthOrStencilAttachment? VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT : VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;
   3788 		VkFormatProperties			properties;
   3789 
   3790 		vk.getPhysicalDeviceFormatProperties(device, attachment.getFormat(), &properties);
   3791 
   3792 		if ((properties.optimalTilingFeatures & flags) != flags)
   3793 		{
   3794 			supported = false;
   3795 			log << TestLog::Message << "Format: " << attachment.getFormat() << " not supported as " << (isDepthOrStencilAttachment ? "depth stencil attachment" : "color attachment") << TestLog::EndMessage;
   3796 		}
   3797 	}
   3798 
   3799 	if (!supported)
   3800 		TCU_THROW(NotSupportedError, "Format not supported");
   3801 }
   3802 
   3803 tcu::TestStatus renderPassTest (Context& context, TestConfig config)
   3804 {
   3805 	const UVec2							targetSize			= config.targetSize;
   3806 	const UVec2							renderPos			= config.renderPos;
   3807 	const UVec2							renderSize			= config.renderSize;
   3808 	const RenderPass&					renderPassInfo		= config.renderPass;
   3809 
   3810 	TestLog&							log					= context.getTestContext().getLog();
   3811 	de::Random							rng					(config.seed);
   3812 
   3813 	vector<bool>						attachmentIsLazy;
   3814 	vector<VkImageUsageFlags>			attachmentImageUsage;
   3815 	vector<Maybe<VkClearValue> >		imageClearValues;
   3816 	vector<Maybe<VkClearValue> >		renderPassClearValues;
   3817 
   3818 	vector<bool>						subpassIsSecondary;
   3819 	vector<SubpassRenderInfo>			subpassRenderInfo;
   3820 	vector<vector<VkClearColorValue> >	subpassColorClearValues;
   3821 
   3822 	initializeAttachmentIsLazy(attachmentIsLazy, renderPassInfo.getAttachments(), config.imageMemory);
   3823 	initializeImageClearValues(rng, imageClearValues, renderPassInfo.getAttachments(), attachmentIsLazy);
   3824 	initializeAttachmentImageUsage(context, attachmentImageUsage, renderPassInfo, attachmentIsLazy, imageClearValues);
   3825 	initializeRenderPassClearValues(rng, renderPassClearValues, renderPassInfo.getAttachments());
   3826 
   3827 	initializeSubpassIsSecondary(subpassIsSecondary, renderPassInfo.getSubpasses(), config.commandBufferTypes);
   3828 	initializeSubpassClearValues(rng, subpassColorClearValues, renderPassInfo);
   3829 	initializeSubpassRenderInfo(subpassRenderInfo, rng, renderPassInfo, config);
   3830 
   3831 	logTestCaseInfo(log, config, attachmentIsLazy, imageClearValues, renderPassClearValues, subpassRenderInfo);
   3832 
   3833 	checkTextureFormatSupport(log, context.getInstanceInterface(), context.getPhysicalDevice(), config.renderPass.getAttachments());
   3834 
   3835 	{
   3836 		const vk::VkPhysicalDeviceProperties properties = vk::getPhysicalDeviceProperties(context.getInstanceInterface(), context.getPhysicalDevice());
   3837 
   3838 		log << TestLog::Message << "Max color attachments: " << properties.limits.maxColorAttachments << TestLog::EndMessage;
   3839 
   3840 		for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); subpassNdx++)
   3841 		{
   3842 			 if (renderPassInfo.getSubpasses()[subpassNdx].getColorAttachments().size() > (size_t)properties.limits.maxColorAttachments)
   3843 				 TCU_THROW(NotSupportedError, "Subpass uses more than maxColorAttachments.");
   3844 		}
   3845 	}
   3846 
   3847 	{
   3848 		const VkDevice								device								= context.getDevice();
   3849 		const DeviceInterface&						vk									= context.getDeviceInterface();
   3850 		const VkQueue								queue								= context.getUniversalQueue();
   3851 		const deUint32								queueIndex							= context.getUniversalQueueFamilyIndex();
   3852 		Allocator&									allocator							= context.getDefaultAllocator();
   3853 
   3854 		const Unique<VkRenderPass>					renderPass							(createRenderPass(vk, device, renderPassInfo));
   3855 		const Unique<VkCommandPool>					commandBufferPool					(createCommandPool(vk, device, queueIndex, 0));
   3856 		const Unique<VkCommandBuffer>				initializeImagesCommandBuffer		(allocateCommandBuffer(vk, device, *commandBufferPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
   3857 		const Unique<VkCommandBuffer>				renderCommandBuffer					(allocateCommandBuffer(vk, device, *commandBufferPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
   3858 		const Unique<VkCommandBuffer>				readImagesToBuffersCommandBuffer	(allocateCommandBuffer(vk, device, *commandBufferPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
   3859 
   3860 		vector<de::SharedPtr<AttachmentResources> >	attachmentResources;
   3861 		vector<de::SharedPtr<SubpassRenderer> >		subpassRenderers;
   3862 		vector<VkImageView>							attachmentViews;
   3863 
   3864 		for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
   3865 		{
   3866 			const Attachment&	attachmentInfo	= renderPassInfo.getAttachments()[attachmentNdx];
   3867 
   3868 			attachmentResources.push_back(de::SharedPtr<AttachmentResources>(new AttachmentResources(vk, device, allocator, queueIndex, targetSize, attachmentInfo, attachmentImageUsage[attachmentNdx])));
   3869 			attachmentViews.push_back(attachmentResources[attachmentNdx]->getAttachmentView());
   3870 		}
   3871 
   3872 		beginCommandBuffer(vk, *initializeImagesCommandBuffer, (VkCommandBufferUsageFlags)0, DE_NULL, 0, DE_NULL, VK_FALSE, (VkQueryControlFlags)0, (VkQueryPipelineStatisticFlags)0);
   3873 		pushImageInitializationCommands(vk, *initializeImagesCommandBuffer, renderPassInfo.getAttachments(), attachmentResources, queueIndex, imageClearValues);
   3874 		endCommandBuffer(vk, *initializeImagesCommandBuffer);
   3875 
   3876 		{
   3877 			const Unique<VkFramebuffer> framebuffer (createFramebuffer(vk, device, *renderPass, targetSize, attachmentViews));
   3878 
   3879 			for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); subpassNdx++)
   3880 				subpassRenderers.push_back(de::SharedPtr<SubpassRenderer>(new SubpassRenderer(context, vk, device, allocator, *renderPass, *framebuffer, *commandBufferPool, queueIndex, subpassRenderInfo[subpassNdx])));
   3881 
   3882 			beginCommandBuffer(vk, *renderCommandBuffer, (VkCommandBufferUsageFlags)0, DE_NULL, 0, DE_NULL, VK_FALSE, (VkQueryControlFlags)0, (VkQueryPipelineStatisticFlags)0);
   3883 			pushRenderPassCommands(vk, *renderCommandBuffer, *renderPass, *framebuffer, subpassRenderers, renderPos, renderSize, renderPassClearValues, config.renderTypes);
   3884 			endCommandBuffer(vk, *renderCommandBuffer);
   3885 
   3886 			beginCommandBuffer(vk, *readImagesToBuffersCommandBuffer, (VkCommandBufferUsageFlags)0, DE_NULL, 0, DE_NULL, VK_FALSE, (VkQueryControlFlags)0, (VkQueryPipelineStatisticFlags)0);
   3887 			pushReadImagesToBuffers(vk, *readImagesToBuffersCommandBuffer, queueIndex, attachmentResources, renderPassInfo.getAttachments(), attachmentIsLazy, targetSize);
   3888 			endCommandBuffer(vk, *readImagesToBuffersCommandBuffer);
   3889 			{
   3890 				const VkCommandBuffer commandBuffers[] =
   3891 				{
   3892 					*initializeImagesCommandBuffer,
   3893 					*renderCommandBuffer,
   3894 					*readImagesToBuffersCommandBuffer
   3895 				};
   3896 				const Unique<VkFence>	fence		(createFence(vk, device, 0u));
   3897 
   3898 				queueSubmit(vk, queue, DE_LENGTH_OF_ARRAY(commandBuffers), commandBuffers, *fence);
   3899 				waitForFences(vk, device, 1, &fence.get(), VK_TRUE, ~0ull);
   3900 			}
   3901 		}
   3902 
   3903 		if (logAndVerifyImages(log, vk, device, attachmentResources, attachmentIsLazy, renderPassInfo, renderPassClearValues, imageClearValues, subpassRenderInfo, targetSize, config))
   3904 			return tcu::TestStatus::pass("Pass");
   3905 		else
   3906 			return tcu::TestStatus::fail("Result verification failed");
   3907 	}
   3908 }
   3909 
   3910 static const VkFormat s_coreColorFormats[] =
   3911 {
   3912 	VK_FORMAT_R5G6B5_UNORM_PACK16,
   3913 	VK_FORMAT_R8_UNORM,
   3914 	VK_FORMAT_R8_SNORM,
   3915 	VK_FORMAT_R8_UINT,
   3916 	VK_FORMAT_R8_SINT,
   3917 	VK_FORMAT_R8G8_UNORM,
   3918 	VK_FORMAT_R8G8_SNORM,
   3919 	VK_FORMAT_R8G8_UINT,
   3920 	VK_FORMAT_R8G8_SINT,
   3921 	VK_FORMAT_R8G8B8A8_UNORM,
   3922 	VK_FORMAT_R8G8B8A8_SNORM,
   3923 	VK_FORMAT_R8G8B8A8_UINT,
   3924 	VK_FORMAT_R8G8B8A8_SINT,
   3925 	VK_FORMAT_R8G8B8A8_SRGB,
   3926 	VK_FORMAT_A8B8G8R8_UNORM_PACK32,
   3927 	VK_FORMAT_A8B8G8R8_SNORM_PACK32,
   3928 	VK_FORMAT_A8B8G8R8_UINT_PACK32,
   3929 	VK_FORMAT_A8B8G8R8_SINT_PACK32,
   3930 	VK_FORMAT_A8B8G8R8_SRGB_PACK32,
   3931 	VK_FORMAT_B8G8R8A8_UNORM,
   3932 	VK_FORMAT_B8G8R8A8_SRGB,
   3933 	VK_FORMAT_A2R10G10B10_UNORM_PACK32,
   3934 	VK_FORMAT_A2B10G10R10_UNORM_PACK32,
   3935 	VK_FORMAT_A2B10G10R10_UINT_PACK32,
   3936 	VK_FORMAT_R16_UNORM,
   3937 	VK_FORMAT_R16_SNORM,
   3938 	VK_FORMAT_R16_UINT,
   3939 	VK_FORMAT_R16_SINT,
   3940 	VK_FORMAT_R16_SFLOAT,
   3941 	VK_FORMAT_R16G16_UNORM,
   3942 	VK_FORMAT_R16G16_SNORM,
   3943 	VK_FORMAT_R16G16_UINT,
   3944 	VK_FORMAT_R16G16_SINT,
   3945 	VK_FORMAT_R16G16_SFLOAT,
   3946 	VK_FORMAT_R16G16B16A16_UNORM,
   3947 	VK_FORMAT_R16G16B16A16_SNORM,
   3948 	VK_FORMAT_R16G16B16A16_UINT,
   3949 	VK_FORMAT_R16G16B16A16_SINT,
   3950 	VK_FORMAT_R16G16B16A16_SFLOAT,
   3951 	VK_FORMAT_R32_UINT,
   3952 	VK_FORMAT_R32_SINT,
   3953 	VK_FORMAT_R32_SFLOAT,
   3954 	VK_FORMAT_R32G32_UINT,
   3955 	VK_FORMAT_R32G32_SINT,
   3956 	VK_FORMAT_R32G32_SFLOAT,
   3957 	VK_FORMAT_R32G32B32A32_UINT,
   3958 	VK_FORMAT_R32G32B32A32_SINT,
   3959 	VK_FORMAT_R32G32B32A32_SFLOAT
   3960 };
   3961 
   3962 static const VkFormat s_coreDepthStencilFormats[] =
   3963 {
   3964 	VK_FORMAT_D16_UNORM,
   3965 
   3966 	VK_FORMAT_X8_D24_UNORM_PACK32,
   3967 	VK_FORMAT_D32_SFLOAT,
   3968 
   3969 	VK_FORMAT_D24_UNORM_S8_UINT,
   3970 	VK_FORMAT_D32_SFLOAT_S8_UINT
   3971 };
   3972 
   3973 de::MovePtr<tcu::TestCaseGroup> createAttachmentTestCaseGroup (tcu::TestContext& testCtx)
   3974 {
   3975 	const deUint32 attachmentCounts[] = { 1, 3, 4, 8 };
   3976 	const VkAttachmentLoadOp loadOps[] =
   3977 	{
   3978 		VK_ATTACHMENT_LOAD_OP_LOAD,
   3979 		VK_ATTACHMENT_LOAD_OP_CLEAR,
   3980 		VK_ATTACHMENT_LOAD_OP_DONT_CARE
   3981 	};
   3982 
   3983 	const VkAttachmentStoreOp storeOps[] =
   3984 	{
   3985 		VK_ATTACHMENT_STORE_OP_STORE,
   3986 		VK_ATTACHMENT_STORE_OP_DONT_CARE
   3987 	};
   3988 
   3989 	const VkImageLayout initialAndFinalColorLayouts[] =
   3990 	{
   3991 		VK_IMAGE_LAYOUT_GENERAL,
   3992 		VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
   3993 		VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
   3994 		VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
   3995 		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
   3996 	};
   3997 
   3998 	const VkImageLayout initialAndFinalDepthStencilLayouts[] =
   3999 	{
   4000 		VK_IMAGE_LAYOUT_GENERAL,
   4001 		VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
   4002 		VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
   4003 		VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
   4004 		VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
   4005 		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
   4006 	};
   4007 
   4008 	const VkImageLayout subpassLayouts[] =
   4009 	{
   4010 		VK_IMAGE_LAYOUT_GENERAL,
   4011 		VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
   4012 	};
   4013 
   4014 	const VkImageLayout depthStencilLayouts[] =
   4015 	{
   4016 		VK_IMAGE_LAYOUT_GENERAL,
   4017 		VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
   4018 	};
   4019 
   4020 	const TestConfig::RenderTypes renderCommands[] =
   4021 	{
   4022 		TestConfig::RENDERTYPES_NONE,
   4023 		TestConfig::RENDERTYPES_CLEAR,
   4024 		TestConfig::RENDERTYPES_DRAW,
   4025 		TestConfig::RENDERTYPES_CLEAR|TestConfig::RENDERTYPES_DRAW,
   4026 	};
   4027 
   4028 	const TestConfig::CommandBufferTypes commandBuffers[] =
   4029 	{
   4030 		TestConfig::COMMANDBUFFERTYPES_INLINE,
   4031 		TestConfig::COMMANDBUFFERTYPES_SECONDARY,
   4032 		TestConfig::COMMANDBUFFERTYPES_INLINE|TestConfig::COMMANDBUFFERTYPES_SECONDARY
   4033 	};
   4034 
   4035 	const TestConfig::ImageMemory imageMemories[] =
   4036 	{
   4037 		TestConfig::IMAGEMEMORY_STRICT,
   4038 		TestConfig::IMAGEMEMORY_LAZY,
   4039 		TestConfig::IMAGEMEMORY_STRICT|TestConfig::IMAGEMEMORY_LAZY
   4040 	};
   4041 
   4042 	const UVec2 targetSizes[] =
   4043 	{
   4044 		UVec2(64, 64),
   4045 		UVec2(63, 65)
   4046 	};
   4047 
   4048 	const UVec2 renderPositions[] =
   4049 	{
   4050 		UVec2(0, 0),
   4051 		UVec2(3, 17)
   4052 	};
   4053 
   4054 	const UVec2 renderSizes[] =
   4055 	{
   4056 		UVec2(32, 32),
   4057 		UVec2(60, 47)
   4058 	};
   4059 
   4060 	de::Random rng (1433774382u);
   4061 	de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "attachment", "Attachment format and count tests with load and store ops and image layouts"));
   4062 
   4063 	for (size_t attachmentCountNdx = 0; attachmentCountNdx < DE_LENGTH_OF_ARRAY(attachmentCounts); attachmentCountNdx++)
   4064 	{
   4065 		const deUint32					attachmentCount			= attachmentCounts[attachmentCountNdx];
   4066 		const deUint32					testCaseCount			= (attachmentCount == 1 ? 100 : 200);
   4067 		de::MovePtr<tcu::TestCaseGroup>	attachmentCountGroup	(new tcu::TestCaseGroup(testCtx, de::toString(attachmentCount).c_str(), de::toString(attachmentCount).c_str()));
   4068 
   4069 		for (size_t testCaseNdx = 0; testCaseNdx < testCaseCount; testCaseNdx++)
   4070 		{
   4071 			const bool					useDepthStencil		= rng.getBool();
   4072 			VkImageLayout				depthStencilLayout	= VK_IMAGE_LAYOUT_GENERAL;
   4073 			vector<Attachment>			attachments;
   4074 			vector<AttachmentReference>	colorAttachmentReferences;
   4075 
   4076 			for (size_t attachmentNdx = 0; attachmentNdx < attachmentCount; attachmentNdx++)
   4077 			{
   4078 				const VkSampleCountFlagBits	sampleCount		= VK_SAMPLE_COUNT_1_BIT;
   4079 				const VkFormat				format			= rng.choose<VkFormat>(DE_ARRAY_BEGIN(s_coreColorFormats), DE_ARRAY_END(s_coreColorFormats));
   4080 				const VkAttachmentLoadOp	loadOp			= rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
   4081 				const VkAttachmentStoreOp	storeOp			= rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
   4082 
   4083 				const VkImageLayout			initialLayout	= rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
   4084 				const VkImageLayout			finalizeLayout	= rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
   4085 				const VkImageLayout			subpassLayout	= rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts));
   4086 
   4087 				const VkAttachmentLoadOp	stencilLoadOp	= rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
   4088 				const VkAttachmentStoreOp	stencilStoreOp	= rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
   4089 
   4090 				attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalizeLayout));
   4091 				colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
   4092 			}
   4093 
   4094 			if (useDepthStencil)
   4095 			{
   4096 				const VkSampleCountFlagBits	sampleCount			= VK_SAMPLE_COUNT_1_BIT;
   4097 				const VkFormat				format				= rng.choose<VkFormat>(DE_ARRAY_BEGIN(s_coreDepthStencilFormats), DE_ARRAY_END(s_coreDepthStencilFormats));
   4098 				const VkAttachmentLoadOp	loadOp				= rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
   4099 				const VkAttachmentStoreOp	storeOp				= rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
   4100 
   4101 				const VkImageLayout			initialLayout		= rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalDepthStencilLayouts), DE_ARRAY_END(initialAndFinalDepthStencilLayouts));
   4102 				const VkImageLayout			finalizeLayout		= rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalDepthStencilLayouts), DE_ARRAY_END(initialAndFinalDepthStencilLayouts));
   4103 
   4104 				const VkAttachmentLoadOp	stencilLoadOp		= rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
   4105 				const VkAttachmentStoreOp	stencilStoreOp		= rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
   4106 
   4107 				depthStencilLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(depthStencilLayouts), DE_ARRAY_END(depthStencilLayouts));
   4108 				attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalizeLayout));
   4109 			}
   4110 
   4111 			{
   4112 				const TestConfig::RenderTypes			render			= rng.choose<TestConfig::RenderTypes>(DE_ARRAY_BEGIN(renderCommands), DE_ARRAY_END(renderCommands));
   4113 				const TestConfig::CommandBufferTypes	commandBuffer	= rng.choose<TestConfig::CommandBufferTypes>(DE_ARRAY_BEGIN(commandBuffers), DE_ARRAY_END(commandBuffers));
   4114 				const TestConfig::ImageMemory			imageMemory		= rng.choose<TestConfig::ImageMemory>(DE_ARRAY_BEGIN(imageMemories), DE_ARRAY_END(imageMemories));
   4115 				const vector<Subpass>					subpasses		(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u, vector<AttachmentReference>(), colorAttachmentReferences, vector<AttachmentReference>(), AttachmentReference((useDepthStencil ? (deUint32)(attachments.size() - 1) : VK_ATTACHMENT_UNUSED), depthStencilLayout), vector<AttachmentReference>()));
   4116 				const vector<SubpassDependency>			deps;
   4117 
   4118 				const string							testCaseName	= de::toString(attachmentCountNdx * testCaseCount + testCaseNdx);
   4119 				const RenderPass						renderPass		(attachments, subpasses, deps);
   4120 				const UVec2								targetSize		= rng.choose<UVec2>(DE_ARRAY_BEGIN(targetSizes), DE_ARRAY_END(targetSizes));
   4121 				const UVec2								renderPos		= rng.choose<UVec2>(DE_ARRAY_BEGIN(renderPositions), DE_ARRAY_END(renderPositions));
   4122 				const UVec2								renderSize		= rng.choose<UVec2>(DE_ARRAY_BEGIN(renderSizes), DE_ARRAY_END(renderSizes));
   4123 
   4124 				addFunctionCaseWithPrograms<TestConfig>(attachmentCountGroup.get(), testCaseName.c_str(), testCaseName.c_str(), createTestShaders, renderPassTest, TestConfig(renderPass, render, commandBuffer, imageMemory, targetSize, renderPos, renderSize, 1293809));
   4125 			}
   4126 		}
   4127 
   4128 		group->addChild(attachmentCountGroup.release());
   4129 	}
   4130 
   4131 	return group;
   4132 }
   4133 
   4134 de::MovePtr<tcu::TestCaseGroup> createAttachmentAllocationTestGroup (tcu::TestContext& testCtx)
   4135 {
   4136 	const deUint32 attachmentCounts[] = { 4, 8 };
   4137 	const VkAttachmentLoadOp loadOps[] =
   4138 	{
   4139 		VK_ATTACHMENT_LOAD_OP_LOAD,
   4140 		VK_ATTACHMENT_LOAD_OP_CLEAR,
   4141 		VK_ATTACHMENT_LOAD_OP_DONT_CARE
   4142 	};
   4143 
   4144 	const VkAttachmentStoreOp storeOps[] =
   4145 	{
   4146 		VK_ATTACHMENT_STORE_OP_STORE,
   4147 		VK_ATTACHMENT_STORE_OP_DONT_CARE
   4148 	};
   4149 
   4150 	const VkImageLayout initialAndFinalColorLayouts[] =
   4151 	{
   4152 		VK_IMAGE_LAYOUT_GENERAL,
   4153 		VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
   4154 		VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
   4155 		VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
   4156 		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
   4157 	};
   4158 
   4159 	const VkImageLayout subpassLayouts[] =
   4160 	{
   4161 		VK_IMAGE_LAYOUT_GENERAL,
   4162 		VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
   4163 	};
   4164 
   4165 	enum AllocationType
   4166 	{
   4167 		// Each pass uses one more attachmen than previous one
   4168 		ALLOCATIONTYPE_GROW,
   4169 		// Each pass uses one less attachment than previous one
   4170 		ALLOCATIONTYPE_SHRINK,
   4171 		// Each pass drops one attachment and picks up new one
   4172 		ALLOCATIONTYPE_ROLL,
   4173 		// Start by growing and end by shrinking
   4174 		ALLOCATIONTYPE_GROW_SHRINK
   4175 	};
   4176 
   4177 	const AllocationType allocationTypes[] =
   4178 	{
   4179 		ALLOCATIONTYPE_GROW,
   4180 		ALLOCATIONTYPE_SHRINK,
   4181 		ALLOCATIONTYPE_ROLL,
   4182 		ALLOCATIONTYPE_GROW_SHRINK
   4183 	};
   4184 
   4185 	const char* const allocationTypeStr[] =
   4186 	{
   4187 		"grow",
   4188 		"shrink",
   4189 		"roll",
   4190 		"grow_shrink"
   4191 	};
   4192 
   4193 	const TestConfig::RenderTypes renderCommands[] =
   4194 	{
   4195 		TestConfig::RENDERTYPES_NONE,
   4196 		TestConfig::RENDERTYPES_CLEAR,
   4197 		TestConfig::RENDERTYPES_DRAW,
   4198 		TestConfig::RENDERTYPES_CLEAR|TestConfig::RENDERTYPES_DRAW,
   4199 	};
   4200 
   4201 	const TestConfig::CommandBufferTypes commandBuffers[] =
   4202 	{
   4203 		TestConfig::COMMANDBUFFERTYPES_INLINE,
   4204 		TestConfig::COMMANDBUFFERTYPES_SECONDARY,
   4205 		TestConfig::COMMANDBUFFERTYPES_INLINE|TestConfig::COMMANDBUFFERTYPES_SECONDARY
   4206 	};
   4207 
   4208 	const TestConfig::ImageMemory imageMemories[] =
   4209 	{
   4210 		TestConfig::IMAGEMEMORY_STRICT,
   4211 		TestConfig::IMAGEMEMORY_LAZY,
   4212 		TestConfig::IMAGEMEMORY_STRICT|TestConfig::IMAGEMEMORY_LAZY
   4213 	};
   4214 
   4215 	const UVec2 targetSizes[] =
   4216 	{
   4217 		UVec2(64, 64),
   4218 		UVec2(63, 65)
   4219 	};
   4220 
   4221 	const UVec2 renderPositions[] =
   4222 	{
   4223 		UVec2(0, 0),
   4224 		UVec2(3, 17)
   4225 	};
   4226 
   4227 	const UVec2 renderSizes[] =
   4228 	{
   4229 		UVec2(32, 32),
   4230 		UVec2(60, 47)
   4231 	};
   4232 
   4233 	de::MovePtr<tcu::TestCaseGroup>	group	(new tcu::TestCaseGroup(testCtx, "attachment_allocation", "Attachment allocation tests"));
   4234 	de::Random						rng		(3700649827u);
   4235 
   4236 	for (size_t allocationTypeNdx = 0; allocationTypeNdx < DE_LENGTH_OF_ARRAY(allocationTypes); allocationTypeNdx++)
   4237 	{
   4238 		const AllocationType			allocationType		= allocationTypes[allocationTypeNdx];
   4239 		const size_t					testCaseCount		= 100;
   4240 		de::MovePtr<tcu::TestCaseGroup>	allocationTypeGroup	(new tcu::TestCaseGroup(testCtx, allocationTypeStr[allocationTypeNdx], allocationTypeStr[allocationTypeNdx]));
   4241 
   4242 		for (size_t testCaseNdx = 0; testCaseNdx < testCaseCount; testCaseNdx++)
   4243 		{
   4244 			const deUint32		attachmentCount	= rng.choose<deUint32>(DE_ARRAY_BEGIN(attachmentCounts), DE_ARRAY_END(attachmentCounts));
   4245 			vector<Attachment>	attachments;
   4246 			vector<Subpass>		subpasses;
   4247 
   4248 			for (size_t attachmentNdx = 0; attachmentNdx < attachmentCount; attachmentNdx++)
   4249 			{
   4250 				const VkSampleCountFlagBits	sampleCount		= VK_SAMPLE_COUNT_1_BIT;
   4251 				const VkFormat				format			= rng.choose<VkFormat>(DE_ARRAY_BEGIN(s_coreColorFormats), DE_ARRAY_END(s_coreColorFormats));
   4252 				const VkAttachmentLoadOp	loadOp			= rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
   4253 				const VkAttachmentStoreOp	storeOp			= rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
   4254 
   4255 				const VkImageLayout			initialLayout	= rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
   4256 				const VkImageLayout			finalizeLayout	= rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
   4257 
   4258 				const VkAttachmentLoadOp	stencilLoadOp	= rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
   4259 				const VkAttachmentStoreOp	stencilStoreOp	= rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
   4260 
   4261 				attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalizeLayout));
   4262 			}
   4263 
   4264 			if (allocationType == ALLOCATIONTYPE_GROW)
   4265 			{
   4266 				for (size_t subpassNdx = 0; subpassNdx < attachmentCount; subpassNdx++)
   4267 				{
   4268 					vector<AttachmentReference>	colorAttachmentReferences;
   4269 
   4270 					for (size_t attachmentNdx = 0; attachmentNdx < subpassNdx + 1; attachmentNdx++)
   4271 					{
   4272 						const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts));
   4273 
   4274 						colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
   4275 					}
   4276 
   4277 					subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u, vector<AttachmentReference>(), colorAttachmentReferences, vector<AttachmentReference>(), AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL), vector<AttachmentReference>()));
   4278 				}
   4279 			}
   4280 			else if (allocationType == ALLOCATIONTYPE_SHRINK)
   4281 			{
   4282 				for (size_t subpassNdx = 0; subpassNdx < attachmentCount; subpassNdx++)
   4283 				{
   4284 					vector<AttachmentReference>	colorAttachmentReferences;
   4285 
   4286 					for (size_t attachmentNdx = 0; attachmentNdx < (attachmentCount - subpassNdx); attachmentNdx++)
   4287 					{
   4288 						const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts));
   4289 
   4290 						colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
   4291 					}
   4292 
   4293 					subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u, vector<AttachmentReference>(), colorAttachmentReferences, vector<AttachmentReference>(), AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL), vector<AttachmentReference>()));
   4294 				}
   4295 			}
   4296 			else if (allocationType == ALLOCATIONTYPE_ROLL)
   4297 			{
   4298 				for (size_t subpassNdx = 0; subpassNdx < attachmentCount / 2; subpassNdx++)
   4299 				{
   4300 					vector<AttachmentReference>	colorAttachmentReferences;
   4301 
   4302 					for (size_t attachmentNdx = 0; attachmentNdx < attachmentCount / 2; attachmentNdx++)
   4303 					{
   4304 						const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts));
   4305 
   4306 						colorAttachmentReferences.push_back(AttachmentReference((deUint32)(subpassNdx + attachmentNdx), subpassLayout));
   4307 					}
   4308 
   4309 					subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u, vector<AttachmentReference>(), colorAttachmentReferences, vector<AttachmentReference>(), AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL), vector<AttachmentReference>()));
   4310 				}
   4311 			}
   4312 			else if (allocationType == ALLOCATIONTYPE_GROW_SHRINK)
   4313 			{
   4314 				for (size_t subpassNdx = 0; subpassNdx < attachmentCount; subpassNdx++)
   4315 				{
   4316 					vector<AttachmentReference>	colorAttachmentReferences;
   4317 
   4318 					for (size_t attachmentNdx = 0; attachmentNdx < subpassNdx + 1; attachmentNdx++)
   4319 					{
   4320 						const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts));
   4321 
   4322 						colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
   4323 					}
   4324 
   4325 					subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u, vector<AttachmentReference>(), colorAttachmentReferences, vector<AttachmentReference>(), AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL), vector<AttachmentReference>()));
   4326 				}
   4327 
   4328 				for (size_t subpassNdx = 0; subpassNdx < attachmentCount; subpassNdx++)
   4329 				{
   4330 					vector<AttachmentReference>	colorAttachmentReferences;
   4331 
   4332 					for (size_t attachmentNdx = 0; attachmentNdx < (attachmentCount - subpassNdx); attachmentNdx++)
   4333 					{
   4334 						const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts));
   4335 
   4336 						colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
   4337 					}
   4338 
   4339 					subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u, vector<AttachmentReference>(), colorAttachmentReferences, vector<AttachmentReference>(), AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL), vector<AttachmentReference>()));
   4340 				}
   4341 			}
   4342 			else
   4343 				DE_FATAL("Unknown allocation type");
   4344 
   4345 			{
   4346 				const TestConfig::RenderTypes			render			= rng.choose<TestConfig::RenderTypes>(DE_ARRAY_BEGIN(renderCommands), DE_ARRAY_END(renderCommands));
   4347 				const TestConfig::CommandBufferTypes	commandBuffer	= rng.choose<TestConfig::CommandBufferTypes>(DE_ARRAY_BEGIN(commandBuffers), DE_ARRAY_END(commandBuffers));
   4348 				const TestConfig::ImageMemory			imageMemory		= rng.choose<TestConfig::ImageMemory>(DE_ARRAY_BEGIN(imageMemories), DE_ARRAY_END(imageMemories));
   4349 
   4350 				const string							testCaseName	= de::toString(testCaseNdx);
   4351 				const UVec2								targetSize		= rng.choose<UVec2>(DE_ARRAY_BEGIN(targetSizes), DE_ARRAY_END(targetSizes));
   4352 				const UVec2								renderPos		= rng.choose<UVec2>(DE_ARRAY_BEGIN(renderPositions), DE_ARRAY_END(renderPositions));
   4353 				const UVec2								renderSize		= rng.choose<UVec2>(DE_ARRAY_BEGIN(renderSizes), DE_ARRAY_END(renderSizes));
   4354 
   4355 				vector<SubpassDependency>				deps;
   4356 
   4357 				for (size_t subpassNdx = 0; subpassNdx < subpasses.size() - 1; subpassNdx++)
   4358 				{
   4359 					const bool byRegion				= rng.getBool();
   4360 					deps.push_back(SubpassDependency((deUint32)subpassNdx, (deUint32)subpassNdx + 1,
   4361 													 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
   4362 														| VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
   4363 														| VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
   4364 														| VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
   4365 
   4366 													 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
   4367 														| VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
   4368 														| VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
   4369 														| VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
   4370 
   4371 													 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
   4372 													 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, // \todo [pyry] Correct?
   4373 
   4374 													 byRegion ? (VkBool32)VK_TRUE : (VkBool32)VK_FALSE));
   4375 				}
   4376 
   4377 				const RenderPass					renderPass		(attachments, subpasses, deps);
   4378 
   4379 				addFunctionCaseWithPrograms<TestConfig>(allocationTypeGroup.get(), testCaseName.c_str(), testCaseName.c_str(), createTestShaders, renderPassTest, TestConfig(renderPass, render, commandBuffer, imageMemory, targetSize, renderPos, renderSize, 80329));
   4380 			}
   4381 		}
   4382 
   4383 		group->addChild(allocationTypeGroup.release());
   4384 	}
   4385 
   4386 	return group;
   4387 }
   4388 
   4389 de::MovePtr<tcu::TestCaseGroup> createSimpleTestGroup (tcu::TestContext& testCtx)
   4390 {
   4391 	const UVec2						targetSize	(64, 64);
   4392 	const UVec2						renderPos	(0, 0);
   4393 	const UVec2						renderSize	(64, 64);
   4394 	de::MovePtr<tcu::TestCaseGroup>	group		(new tcu::TestCaseGroup(testCtx, "simple", "Simple basic render pass tests"));
   4395 
   4396 	// color
   4397 	{
   4398 		const RenderPass	renderPass	(vector<Attachment>(1, Attachment(VK_FORMAT_R8G8B8A8_UNORM,
   4399 																		  VK_SAMPLE_COUNT_1_BIT,
   4400 																		  VK_ATTACHMENT_LOAD_OP_CLEAR,
   4401 																		  VK_ATTACHMENT_STORE_OP_STORE,
   4402 																		  VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   4403 																		  VK_ATTACHMENT_STORE_OP_DONT_CARE,
   4404 																		  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
   4405 																		  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
   4406 										 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
   4407 																	0u,
   4408 																	vector<AttachmentReference>(),
   4409 																	vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
   4410 																	vector<AttachmentReference>(),
   4411 																	AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
   4412 																	vector<AttachmentReference>())),
   4413 										 vector<SubpassDependency>());
   4414 
   4415 		addFunctionCaseWithPrograms<TestConfig>(group.get(), "color", "Single color attachment case.", createTestShaders, renderPassTest, TestConfig(renderPass, TestConfig::RENDERTYPES_DRAW, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239));
   4416 	}
   4417 
   4418 	// depth
   4419 	{
   4420 		const RenderPass	renderPass	(vector<Attachment>(1, Attachment(VK_FORMAT_X8_D24_UNORM_PACK32,
   4421 																		  VK_SAMPLE_COUNT_1_BIT,
   4422 																		  VK_ATTACHMENT_LOAD_OP_CLEAR,
   4423 																		  VK_ATTACHMENT_STORE_OP_STORE,
   4424 																		  VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   4425 																		  VK_ATTACHMENT_STORE_OP_DONT_CARE,
   4426 																		  VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
   4427 																		  VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
   4428 										 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
   4429 																	0u,
   4430 																	vector<AttachmentReference>(),
   4431 																	vector<AttachmentReference>(),
   4432 																	vector<AttachmentReference>(),
   4433 																	AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
   4434 																	vector<AttachmentReference>())),
   4435 										 vector<SubpassDependency>());
   4436 
   4437 		addFunctionCaseWithPrograms<TestConfig>(group.get(), "depth", "Single depth attachment case.", createTestShaders, renderPassTest, TestConfig(renderPass, TestConfig::RENDERTYPES_DRAW, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239));
   4438 	}
   4439 
   4440 	// stencil
   4441 	{
   4442 		const RenderPass	renderPass	(vector<Attachment>(1, Attachment(VK_FORMAT_S8_UINT,
   4443 																		  VK_SAMPLE_COUNT_1_BIT,
   4444 																		  VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   4445 																		  VK_ATTACHMENT_STORE_OP_DONT_CARE,
   4446 																		  VK_ATTACHMENT_LOAD_OP_CLEAR,
   4447 																		  VK_ATTACHMENT_STORE_OP_STORE,
   4448 																		  VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
   4449 																		  VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
   4450 										 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
   4451 																	0u,
   4452 																	vector<AttachmentReference>(),
   4453 																	vector<AttachmentReference>(),
   4454 																	vector<AttachmentReference>(),
   4455 																	AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
   4456 																	vector<AttachmentReference>())),
   4457 										 vector<SubpassDependency>());
   4458 
   4459 		addFunctionCaseWithPrograms<TestConfig>(group.get(), "stencil", "Single stencil attachment case.", createTestShaders, renderPassTest, TestConfig(renderPass, TestConfig::RENDERTYPES_DRAW, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239));
   4460 	}
   4461 
   4462 	// depth_stencil
   4463 	{
   4464 		const RenderPass	renderPass	(vector<Attachment>(1, Attachment(VK_FORMAT_D24_UNORM_S8_UINT,
   4465 																		  VK_SAMPLE_COUNT_1_BIT,
   4466 																		  VK_ATTACHMENT_LOAD_OP_CLEAR,
   4467 																		  VK_ATTACHMENT_STORE_OP_STORE,
   4468 																		  VK_ATTACHMENT_LOAD_OP_CLEAR,
   4469 																		  VK_ATTACHMENT_STORE_OP_STORE,
   4470 																		  VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
   4471 																		  VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
   4472 										 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
   4473 																	0u,
   4474 																	vector<AttachmentReference>(),
   4475 																	vector<AttachmentReference>(),
   4476 																	vector<AttachmentReference>(),
   4477 																	AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
   4478 																	vector<AttachmentReference>())),
   4479 										 vector<SubpassDependency>());
   4480 
   4481 		addFunctionCaseWithPrograms<TestConfig>(group.get(), "depth_stencil", "Single depth stencil attachment case.", createTestShaders, renderPassTest, TestConfig(renderPass, TestConfig::RENDERTYPES_DRAW, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239));
   4482 	}
   4483 
   4484 	// color_depth
   4485 	{
   4486 		const Attachment	attachments[] =
   4487 		{
   4488 			Attachment(VK_FORMAT_R8G8B8A8_UNORM,
   4489 					   VK_SAMPLE_COUNT_1_BIT,
   4490 					   VK_ATTACHMENT_LOAD_OP_CLEAR,
   4491 					   VK_ATTACHMENT_STORE_OP_STORE,
   4492 					   VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   4493 					   VK_ATTACHMENT_STORE_OP_DONT_CARE,
   4494 					   VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
   4495 					   VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL),
   4496 			Attachment(VK_FORMAT_X8_D24_UNORM_PACK32,
   4497 					   VK_SAMPLE_COUNT_1_BIT,
   4498 					   VK_ATTACHMENT_LOAD_OP_CLEAR,
   4499 					   VK_ATTACHMENT_STORE_OP_STORE,
   4500 					   VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   4501 					   VK_ATTACHMENT_STORE_OP_DONT_CARE,
   4502 					   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
   4503 					   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
   4504 		};
   4505 
   4506 		const RenderPass	renderPass	(vector<Attachment>(DE_ARRAY_BEGIN(attachments), DE_ARRAY_END(attachments)),
   4507 										 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
   4508 																	0u,
   4509 																	vector<AttachmentReference>(),
   4510 																	vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
   4511 																	vector<AttachmentReference>(),
   4512 																	AttachmentReference(1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
   4513 																	vector<AttachmentReference>())),
   4514 										 vector<SubpassDependency>());
   4515 
   4516 		addFunctionCaseWithPrograms<TestConfig>(group.get(), "color_depth", "Color and depth attachment case.", createTestShaders, renderPassTest, TestConfig(renderPass, TestConfig::RENDERTYPES_DRAW, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239));
   4517 	}
   4518 
   4519 	// color_stencil
   4520 	{
   4521 		const Attachment	attachments[] =
   4522 		{
   4523 			Attachment(VK_FORMAT_R8G8B8A8_UNORM,
   4524 					   VK_SAMPLE_COUNT_1_BIT,
   4525 					   VK_ATTACHMENT_LOAD_OP_CLEAR,
   4526 					   VK_ATTACHMENT_STORE_OP_STORE,
   4527 					   VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   4528 					   VK_ATTACHMENT_STORE_OP_DONT_CARE,
   4529 					   VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
   4530 					   VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL),
   4531 			Attachment(VK_FORMAT_S8_UINT,
   4532 					   VK_SAMPLE_COUNT_1_BIT,
   4533 					   VK_ATTACHMENT_LOAD_OP_CLEAR,
   4534 					   VK_ATTACHMENT_STORE_OP_STORE,
   4535 					   VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   4536 					   VK_ATTACHMENT_STORE_OP_DONT_CARE,
   4537 					   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
   4538 					   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
   4539 		};
   4540 
   4541 		const RenderPass	renderPass	(vector<Attachment>(DE_ARRAY_BEGIN(attachments), DE_ARRAY_END(attachments)),
   4542 										 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
   4543 																	0u,
   4544 																	vector<AttachmentReference>(),
   4545 																	vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
   4546 																	vector<AttachmentReference>(),
   4547 																	AttachmentReference(1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
   4548 																	vector<AttachmentReference>())),
   4549 										 vector<SubpassDependency>());
   4550 
   4551 
   4552 		addFunctionCaseWithPrograms<TestConfig>(group.get(), "color_stencil", "Color and stencil attachment case.", createTestShaders, renderPassTest, TestConfig(renderPass, TestConfig::RENDERTYPES_DRAW, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239));
   4553 	}
   4554 
   4555 	// color_depth_stencil
   4556 	{
   4557 		const Attachment	attachments[] =
   4558 		{
   4559 			Attachment(VK_FORMAT_R8G8B8A8_UNORM,
   4560 					   VK_SAMPLE_COUNT_1_BIT,
   4561 					   VK_ATTACHMENT_LOAD_OP_CLEAR,
   4562 					   VK_ATTACHMENT_STORE_OP_STORE,
   4563 					   VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   4564 					   VK_ATTACHMENT_STORE_OP_DONT_CARE,
   4565 					   VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
   4566 					   VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL),
   4567 			Attachment(VK_FORMAT_D24_UNORM_S8_UINT,
   4568 					   VK_SAMPLE_COUNT_1_BIT,
   4569 					   VK_ATTACHMENT_LOAD_OP_CLEAR,
   4570 					   VK_ATTACHMENT_STORE_OP_STORE,
   4571 					   VK_ATTACHMENT_LOAD_OP_CLEAR,
   4572 					   VK_ATTACHMENT_STORE_OP_STORE,
   4573 					   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
   4574 					   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
   4575 		};
   4576 
   4577 		const RenderPass	renderPass	(vector<Attachment>(DE_ARRAY_BEGIN(attachments), DE_ARRAY_END(attachments)),
   4578 										 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
   4579 																	0u,
   4580 																	vector<AttachmentReference>(),
   4581 																	vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
   4582 																	vector<AttachmentReference>(),
   4583 																	AttachmentReference(1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
   4584 																	vector<AttachmentReference>())),
   4585 										 vector<SubpassDependency>());
   4586 
   4587 		addFunctionCaseWithPrograms<TestConfig>(group.get(), "color_depth_stencil", "Color, depth and stencil attachment case.", createTestShaders, renderPassTest, TestConfig(renderPass, TestConfig::RENDERTYPES_DRAW, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239));
   4588 	}
   4589 
   4590 	return group;
   4591 }
   4592 
   4593 std::string formatToName (VkFormat format)
   4594 {
   4595 	const std::string	formatStr	= de::toString(format);
   4596 	const std::string	prefix		= "VK_FORMAT_";
   4597 
   4598 	DE_ASSERT(formatStr.substr(0, prefix.length()) == prefix);
   4599 
   4600 	return de::toLower(formatStr.substr(prefix.length()));
   4601 }
   4602 
   4603 de::MovePtr<tcu::TestCaseGroup> createFormatTestGroup(tcu::TestContext& testCtx)
   4604 {
   4605 	de::MovePtr<tcu::TestCaseGroup>	group	(new tcu::TestCaseGroup(testCtx, "formats", "Tests for different image formats."));
   4606 
   4607 	const UVec2 targetSize	(64, 64);
   4608 	const UVec2 renderPos	(0, 0);
   4609 	const UVec2 renderSize	(64, 64);
   4610 
   4611 	const struct
   4612 	{
   4613 		const char* const			str;
   4614 		const VkAttachmentLoadOp	op;
   4615 	} loadOps[] =
   4616 	{
   4617 		{ "clear",		VK_ATTACHMENT_LOAD_OP_CLEAR		},
   4618 		{ "load",		VK_ATTACHMENT_LOAD_OP_LOAD		},
   4619 		{ "dont_care",	VK_ATTACHMENT_LOAD_OP_DONT_CARE	}
   4620 	};
   4621 
   4622 	const struct
   4623 	{
   4624 		 const char* const				str;
   4625 		 const TestConfig::RenderTypes	types;
   4626 	} renderTypes[] =
   4627 	{
   4628 		{ "clear",		TestConfig::RENDERTYPES_CLEAR								},
   4629 		{ "draw",		TestConfig::RENDERTYPES_DRAW								},
   4630 		{ "clear_draw",	TestConfig::RENDERTYPES_CLEAR|TestConfig::RENDERTYPES_DRAW	}
   4631 	};
   4632 
   4633 	// Color formats
   4634 	for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_coreColorFormats); formatNdx++)
   4635 	{
   4636 		const VkFormat					format		= s_coreColorFormats[formatNdx];
   4637 		de::MovePtr<tcu::TestCaseGroup>	formatGroup	(new tcu::TestCaseGroup(testCtx, formatToName(format).c_str(), de::toString(format).c_str()));
   4638 
   4639 		for (size_t loadOpNdx = 0; loadOpNdx < DE_LENGTH_OF_ARRAY(loadOps); loadOpNdx++)
   4640 		{
   4641 			const VkAttachmentLoadOp		loadOp	= loadOps[loadOpNdx].op;
   4642 			de::MovePtr<tcu::TestCaseGroup>	loadOpGroup	(new tcu::TestCaseGroup(testCtx, loadOps[loadOpNdx].str, loadOps[loadOpNdx].str));
   4643 
   4644 			for (size_t renderTypeNdx = 0; renderTypeNdx < DE_LENGTH_OF_ARRAY(renderTypes); renderTypeNdx++)
   4645 			{
   4646 				const RenderPass	renderPass	(vector<Attachment>(1, Attachment(format,
   4647 																				  VK_SAMPLE_COUNT_1_BIT,
   4648 																				  loadOp,
   4649 																				  VK_ATTACHMENT_STORE_OP_STORE,
   4650 																				  VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   4651 																				  VK_ATTACHMENT_STORE_OP_DONT_CARE,
   4652 																				  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
   4653 																				  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
   4654 												 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
   4655 																			0u,
   4656 																			vector<AttachmentReference>(),
   4657 																			vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
   4658 																			vector<AttachmentReference>(),
   4659 																			AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
   4660 																			vector<AttachmentReference>())),
   4661 												 vector<SubpassDependency>());
   4662 
   4663 				addFunctionCaseWithPrograms<TestConfig>(loadOpGroup.get(), renderTypes[renderTypeNdx].str, renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, TestConfig(renderPass, renderTypes[renderTypeNdx].types, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239));
   4664 			}
   4665 
   4666 			formatGroup->addChild(loadOpGroup.release());
   4667 		}
   4668 
   4669 		group->addChild(formatGroup.release());
   4670 	}
   4671 
   4672 	// Depth stencil formats
   4673 	for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_coreDepthStencilFormats); formatNdx++)
   4674 	{
   4675 		const VkFormat					vkFormat		= s_coreDepthStencilFormats[formatNdx];
   4676 		de::MovePtr<tcu::TestCaseGroup>	formatGroup	(new tcu::TestCaseGroup(testCtx, formatToName(vkFormat).c_str(), de::toString(vkFormat).c_str()));
   4677 
   4678 		for (size_t loadOpNdx = 0; loadOpNdx < DE_LENGTH_OF_ARRAY(loadOps); loadOpNdx++)
   4679 		{
   4680 			const VkAttachmentLoadOp		loadOp	= loadOps[loadOpNdx].op;
   4681 			de::MovePtr<tcu::TestCaseGroup>	loadOpGroup	(new tcu::TestCaseGroup(testCtx, loadOps[loadOpNdx].str, loadOps[loadOpNdx].str));
   4682 
   4683 			for (size_t renderTypeNdx = 0; renderTypeNdx < DE_LENGTH_OF_ARRAY(renderTypes); renderTypeNdx++)
   4684 			{
   4685 				const tcu::TextureFormat	format				= mapVkFormat(vkFormat);
   4686 				const bool					isStencilAttachment	= hasStencilComponent(format.order);
   4687 				const bool					isDepthAttachment	= hasDepthComponent(format.order);
   4688 				const RenderPass			renderPass			(vector<Attachment>(1, Attachment(vkFormat,
   4689 																				  VK_SAMPLE_COUNT_1_BIT,
   4690 																				  isDepthAttachment ? loadOp : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   4691 																				  isDepthAttachment ? VK_ATTACHMENT_STORE_OP_STORE :VK_ATTACHMENT_STORE_OP_DONT_CARE,
   4692 																				  isStencilAttachment ? loadOp : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   4693 																				  isStencilAttachment ? VK_ATTACHMENT_STORE_OP_STORE :VK_ATTACHMENT_STORE_OP_DONT_CARE,
   4694 																				  VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
   4695 																				  VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
   4696 												 vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
   4697 																			0u,
   4698 																			vector<AttachmentReference>(),
   4699 																			vector<AttachmentReference>(),
   4700 																			vector<AttachmentReference>(),
   4701 																			AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
   4702 																			vector<AttachmentReference>())),
   4703 												 vector<SubpassDependency>());
   4704 
   4705 				addFunctionCaseWithPrograms<TestConfig>(loadOpGroup.get(), renderTypes[renderTypeNdx].str, renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, TestConfig(renderPass, renderTypes[renderTypeNdx].types, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239));
   4706 			}
   4707 
   4708 			formatGroup->addChild(loadOpGroup.release());
   4709 		}
   4710 
   4711 		group->addChild(formatGroup.release());
   4712 	}
   4713 
   4714 	return group;
   4715 }
   4716 
   4717 } // anonymous
   4718 
   4719 tcu::TestCaseGroup* createRenderPassTests (tcu::TestContext& testCtx)
   4720 {
   4721 	de::MovePtr<tcu::TestCaseGroup>	renderpassTests	(new tcu::TestCaseGroup(testCtx, "renderpass", "RenderPass Tests"));
   4722 
   4723 	renderpassTests->addChild(createSimpleTestGroup(testCtx).release());
   4724 	renderpassTests->addChild(createFormatTestGroup(testCtx).release());
   4725 	renderpassTests->addChild(createAttachmentTestCaseGroup(testCtx).release());
   4726 	renderpassTests->addChild(createAttachmentAllocationTestGroup(testCtx).release());
   4727 
   4728 	return renderpassTests.release();
   4729 }
   4730 
   4731 } // vkt
   4732