• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*------------------------------------------------------------------------
2  * Vulkan Conformance Tests
3  * ------------------------
4  *
5  * Copyright (c) 2016 The Khronos Group 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 Image Tests Utility Classes
22  *//*--------------------------------------------------------------------*/
23 
24 #include "vktImageTestsUtil.hpp"
25 #include "vkQueryUtil.hpp"
26 #include "vkTypeUtil.hpp"
27 #include "tcuTextureUtil.hpp"
28 
29 using namespace vk;
30 
31 namespace vkt
32 {
33 namespace image
34 {
35 
Buffer(const DeviceInterface & vk,const VkDevice device,Allocator & allocator,const VkBufferCreateInfo & bufferCreateInfo,const MemoryRequirement memoryRequirement)36 Buffer::Buffer (const DeviceInterface&		vk,
37 				const VkDevice				device,
38 				Allocator&					allocator,
39 				const VkBufferCreateInfo&	bufferCreateInfo,
40 				const MemoryRequirement		memoryRequirement)
41 {
42 	m_buffer = createBuffer(vk, device, &bufferCreateInfo);
43 	m_allocation = allocator.allocate(getBufferMemoryRequirements(vk, device, *m_buffer), memoryRequirement);
44 	VK_CHECK(vk.bindBufferMemory(device, *m_buffer, m_allocation->getMemory(), m_allocation->getOffset()));
45 }
46 
Image(const DeviceInterface & vk,const VkDevice device,Allocator & allocator,const VkImageCreateInfo & imageCreateInfo,const MemoryRequirement memoryRequirement)47 Image::Image (const DeviceInterface&	vk,
48 			  const VkDevice			device,
49 			  Allocator&				allocator,
50 			  const VkImageCreateInfo&	imageCreateInfo,
51 			  const MemoryRequirement	memoryRequirement)
52 {
53 	m_image = createImage(vk, device, &imageCreateInfo);
54 	m_allocation = allocator.allocate(getImageMemoryRequirements(vk, device, *m_image), memoryRequirement);
55 	VK_CHECK(vk.bindImageMemory(device, *m_image, m_allocation->getMemory(), m_allocation->getOffset()));
56 }
57 
58 struct CompressedFormatParameters
59 {
60 	VkFormat	format;
61 	deUint32	blockBytes;
62 	deUint32	blockWidth;
63 	deUint32	blockHeight;
64 };
65 
66 CompressedFormatParameters	compressedFormatParameters[VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_BC1_RGB_UNORM_BLOCK + 1]	=
67 {
68 	{ VK_FORMAT_BC1_RGB_UNORM_BLOCK,		8,	4,	4 },
69 	{ VK_FORMAT_BC1_RGB_SRGB_BLOCK,			8,	4,	4 },
70 	{ VK_FORMAT_BC1_RGBA_UNORM_BLOCK,		8,	4,	4 },
71 	{ VK_FORMAT_BC1_RGBA_SRGB_BLOCK,		8,	4,	4 },
72 	{ VK_FORMAT_BC2_UNORM_BLOCK,			16,	4,	4 },
73 	{ VK_FORMAT_BC2_SRGB_BLOCK,				16,	4,	4 },
74 	{ VK_FORMAT_BC3_UNORM_BLOCK,			16,	4,	4 },
75 	{ VK_FORMAT_BC3_SRGB_BLOCK,				16,	4,	4 },
76 	{ VK_FORMAT_BC4_UNORM_BLOCK,			8,	4,	4 },
77 	{ VK_FORMAT_BC4_SNORM_BLOCK,			8,	4,	4 },
78 	{ VK_FORMAT_BC5_UNORM_BLOCK,			16,	4,	4 },
79 	{ VK_FORMAT_BC5_SNORM_BLOCK,			16,	4,	4 },
80 	{ VK_FORMAT_BC6H_UFLOAT_BLOCK,			16,	4,	4 },
81 	{ VK_FORMAT_BC6H_SFLOAT_BLOCK,			16,	4,	4 },
82 	{ VK_FORMAT_BC7_UNORM_BLOCK,			16,	4,	4 },
83 	{ VK_FORMAT_BC7_SRGB_BLOCK,				16,	4,	4 },
84 	{ VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,	8,	4,	4 },
85 	{ VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,		8,	4,	4 },
86 	{ VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,	8,	4,	4 },
87 	{ VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,	8,	4,	4 },
88 	{ VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,	16,	4,	4 },
89 	{ VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,	16,	4,	4 },
90 	{ VK_FORMAT_EAC_R11_UNORM_BLOCK,		8,	4,	4 },
91 	{ VK_FORMAT_EAC_R11_SNORM_BLOCK,		8,	4,	4 },
92 	{ VK_FORMAT_EAC_R11G11_UNORM_BLOCK,		16,	4,	4 },
93 	{ VK_FORMAT_EAC_R11G11_SNORM_BLOCK,		16,	4,	4 },
94 	{ VK_FORMAT_ASTC_4x4_UNORM_BLOCK,		16,	4,	4 },
95 	{ VK_FORMAT_ASTC_4x4_SRGB_BLOCK,		16,	4,	4 },
96 	{ VK_FORMAT_ASTC_5x4_UNORM_BLOCK,		16,	5,	4 },
97 	{ VK_FORMAT_ASTC_5x4_SRGB_BLOCK,		16,	5,	4 },
98 	{ VK_FORMAT_ASTC_5x5_UNORM_BLOCK,		16,	5,	5 },
99 	{ VK_FORMAT_ASTC_5x5_SRGB_BLOCK,		16,	5,	5 },
100 	{ VK_FORMAT_ASTC_6x5_UNORM_BLOCK,		16,	6,	5 },
101 	{ VK_FORMAT_ASTC_6x5_SRGB_BLOCK,		16,	6,	5 },
102 	{ VK_FORMAT_ASTC_6x6_UNORM_BLOCK,		16,	6,	6 },
103 	{ VK_FORMAT_ASTC_6x6_SRGB_BLOCK,		16,	6,	6 },
104 	{ VK_FORMAT_ASTC_8x5_UNORM_BLOCK,		16,	8,	5 },
105 	{ VK_FORMAT_ASTC_8x5_SRGB_BLOCK,		16,	8,	5 },
106 	{ VK_FORMAT_ASTC_8x6_UNORM_BLOCK,		16,	8,	6 },
107 	{ VK_FORMAT_ASTC_8x6_SRGB_BLOCK,		16,	8,	6 },
108 	{ VK_FORMAT_ASTC_8x8_UNORM_BLOCK,		16,	8,	8 },
109 	{ VK_FORMAT_ASTC_8x8_SRGB_BLOCK,		16,	8,	8 },
110 	{ VK_FORMAT_ASTC_10x5_UNORM_BLOCK,		16,	10,	5 },
111 	{ VK_FORMAT_ASTC_10x5_SRGB_BLOCK,		16,	10,	5 },
112 	{ VK_FORMAT_ASTC_10x6_UNORM_BLOCK,		16,	10,	6 },
113 	{ VK_FORMAT_ASTC_10x6_SRGB_BLOCK,		16,	10,	6 },
114 	{ VK_FORMAT_ASTC_10x8_UNORM_BLOCK,		16,	10,	8 },
115 	{ VK_FORMAT_ASTC_10x8_SRGB_BLOCK,		16,	10,	8 },
116 	{ VK_FORMAT_ASTC_10x10_UNORM_BLOCK,		16,	10,	10 },
117 	{ VK_FORMAT_ASTC_10x10_SRGB_BLOCK,		16,	10,	10 },
118 	{ VK_FORMAT_ASTC_12x10_UNORM_BLOCK,		16,	12,	10 },
119 	{ VK_FORMAT_ASTC_12x10_SRGB_BLOCK,		16,	12,	10 },
120 	{ VK_FORMAT_ASTC_12x12_UNORM_BLOCK,		16,	12,	12 },
121 	{ VK_FORMAT_ASTC_12x12_SRGB_BLOCK,		16,	12,	12 },
122 };
123 
getBlockSizeInBytes(const VkFormat compressedFormat)124 deUint32 getBlockSizeInBytes(const VkFormat compressedFormat)
125 {
126 	deUint32 formatNdx = static_cast<deUint32>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
127 
128 	DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
129 	DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
130 
131 	return compressedFormatParameters[formatNdx].blockBytes;
132 }
133 
getBlockWidth(const VkFormat compressedFormat)134 deUint32 getBlockWidth(const VkFormat compressedFormat)
135 {
136 	deUint32 formatNdx = static_cast<deUint32>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
137 
138 	DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
139 	DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
140 
141 	return compressedFormatParameters[formatNdx].blockWidth;
142 }
143 
getBlockHeight(const VkFormat compressedFormat)144 deUint32 getBlockHeight(const VkFormat compressedFormat)
145 {
146 	deUint32 formatNdx = static_cast<deUint32>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
147 
148 	DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
149 	DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
150 
151 	return compressedFormatParameters[formatNdx].blockHeight;
152 }
153 
getShaderGridSize(const ImageType imageType,const tcu::UVec3 & imageSize)154 tcu::UVec3 getShaderGridSize (const ImageType imageType, const tcu::UVec3& imageSize)
155 {
156 	switch (imageType)
157 	{
158 		case IMAGE_TYPE_1D:
159 		case IMAGE_TYPE_BUFFER:
160 			return tcu::UVec3(imageSize.x(), 1u, 1u);
161 
162 		case IMAGE_TYPE_1D_ARRAY:
163 			return tcu::UVec3(imageSize.x(), imageSize.z(), 1u);
164 
165 		case IMAGE_TYPE_2D:
166 			return tcu::UVec3(imageSize.x(), imageSize.y(), 1u);
167 
168 		case IMAGE_TYPE_2D_ARRAY:
169 		case IMAGE_TYPE_3D:
170 			return tcu::UVec3(imageSize.x(), imageSize.y(), imageSize.z());
171 
172 		case IMAGE_TYPE_CUBE:
173 			return tcu::UVec3(imageSize.x(), imageSize.y(), 6u);
174 
175 		case IMAGE_TYPE_CUBE_ARRAY:
176 			return tcu::UVec3(imageSize.x(), imageSize.y(), 6u * imageSize.z());
177 
178 		default:
179 			DE_FATAL("Unknown image type");
180 			return tcu::UVec3(1u, 1u, 1u);
181 	}
182 }
183 
getLayerSize(const ImageType imageType,const tcu::UVec3 & imageSize)184 tcu::UVec3 getLayerSize (const ImageType imageType, const tcu::UVec3& imageSize)
185 {
186 	switch (imageType)
187 	{
188 		case IMAGE_TYPE_1D:
189 		case IMAGE_TYPE_1D_ARRAY:
190 		case IMAGE_TYPE_BUFFER:
191 			return tcu::UVec3(imageSize.x(), 1u, 1u);
192 
193 		case IMAGE_TYPE_2D:
194 		case IMAGE_TYPE_2D_ARRAY:
195 		case IMAGE_TYPE_CUBE:
196 		case IMAGE_TYPE_CUBE_ARRAY:
197 			return tcu::UVec3(imageSize.x(), imageSize.y(), 1u);
198 
199 		case IMAGE_TYPE_3D:
200 			return tcu::UVec3(imageSize.x(), imageSize.y(), imageSize.z());
201 
202 		default:
203 			DE_FATAL("Unknown image type");
204 			return tcu::UVec3(1u, 1u, 1u);
205 	}
206 }
207 
getNumLayers(const ImageType imageType,const tcu::UVec3 & imageSize)208 deUint32 getNumLayers (const ImageType imageType, const tcu::UVec3& imageSize)
209 {
210 	switch (imageType)
211 	{
212 		case IMAGE_TYPE_1D:
213 		case IMAGE_TYPE_2D:
214 		case IMAGE_TYPE_3D:
215 		case IMAGE_TYPE_BUFFER:
216 			return 1u;
217 
218 		case IMAGE_TYPE_1D_ARRAY:
219 		case IMAGE_TYPE_2D_ARRAY:
220 			return imageSize.z();
221 
222 		case IMAGE_TYPE_CUBE:
223 			return 6u;
224 
225 		case IMAGE_TYPE_CUBE_ARRAY:
226 			return imageSize.z() * 6u;
227 
228 		default:
229 			DE_FATAL("Unknown image type");
230 			return 0u;
231 	}
232 }
233 
getNumPixels(const ImageType imageType,const tcu::UVec3 & imageSize)234 deUint32 getNumPixels (const ImageType imageType, const tcu::UVec3& imageSize)
235 {
236 	const tcu::UVec3 gridSize = getShaderGridSize(imageType, imageSize);
237 
238 	return gridSize.x() * gridSize.y() * gridSize.z();
239 }
240 
getDimensions(const ImageType imageType)241 deUint32 getDimensions (const ImageType imageType)
242 {
243 	switch (imageType)
244 	{
245 		case IMAGE_TYPE_1D:
246 		case IMAGE_TYPE_BUFFER:
247 			return 1u;
248 
249 		case IMAGE_TYPE_1D_ARRAY:
250 		case IMAGE_TYPE_2D:
251 			return 2u;
252 
253 		case IMAGE_TYPE_2D_ARRAY:
254 		case IMAGE_TYPE_CUBE:
255 		case IMAGE_TYPE_CUBE_ARRAY:
256 		case IMAGE_TYPE_3D:
257 			return 3u;
258 
259 		default:
260 			DE_FATAL("Unknown image type");
261 			return 0u;
262 	}
263 }
264 
getLayerDimensions(const ImageType imageType)265 deUint32 getLayerDimensions (const ImageType imageType)
266 {
267 	switch (imageType)
268 	{
269 		case IMAGE_TYPE_1D:
270 		case IMAGE_TYPE_BUFFER:
271 		case IMAGE_TYPE_1D_ARRAY:
272 			return 1u;
273 
274 		case IMAGE_TYPE_2D:
275 		case IMAGE_TYPE_2D_ARRAY:
276 		case IMAGE_TYPE_CUBE:
277 		case IMAGE_TYPE_CUBE_ARRAY:
278 			return 2u;
279 
280 		case IMAGE_TYPE_3D:
281 			return 3u;
282 
283 		default:
284 			DE_FATAL("Unknown image type");
285 			return 0u;
286 	}
287 }
288 
makeBufferCreateInfo(const VkDeviceSize bufferSize,const VkBufferUsageFlags usage)289 VkBufferCreateInfo makeBufferCreateInfo (const VkDeviceSize			bufferSize,
290 										 const VkBufferUsageFlags	usage)
291 {
292 	const VkBufferCreateInfo bufferCreateInfo =
293 	{
294 		VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,	// VkStructureType		sType;
295 		DE_NULL,								// const void*			pNext;
296 		0u,										// VkBufferCreateFlags	flags;
297 		bufferSize,								// VkDeviceSize			size;
298 		usage,									// VkBufferUsageFlags	usage;
299 		VK_SHARING_MODE_EXCLUSIVE,				// VkSharingMode		sharingMode;
300 		0u,										// deUint32				queueFamilyIndexCount;
301 		DE_NULL,								// const deUint32*		pQueueFamilyIndices;
302 	};
303 	return bufferCreateInfo;
304 }
305 
makeBufferImageCopy(const VkExtent3D extent,const deUint32 arraySize)306 VkBufferImageCopy makeBufferImageCopy (const VkExtent3D extent,
307 									   const deUint32	arraySize)
308 {
309 	const VkBufferImageCopy copyParams =
310 	{
311 		0ull,																		//	VkDeviceSize				bufferOffset;
312 		0u,																			//	deUint32					bufferRowLength;
313 		0u,																			//	deUint32					bufferImageHeight;
314 		makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, arraySize),	//	VkImageSubresourceLayers	imageSubresource;
315 		makeOffset3D(0, 0, 0),														//	VkOffset3D					imageOffset;
316 		extent,																		//	VkExtent3D					imageExtent;
317 	};
318 	return copyParams;
319 }
320 
makePipelineLayout(const DeviceInterface & vk,const VkDevice device,const VkDescriptorSetLayout descriptorSetLayout)321 Move<VkPipelineLayout> makePipelineLayout (const DeviceInterface&		vk,
322 										   const VkDevice				device,
323 										   const VkDescriptorSetLayout	descriptorSetLayout)
324 {
325 	const VkPipelineLayoutCreateInfo pipelineLayoutParams =
326 	{
327 		VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,		// VkStructureType					sType;
328 		DE_NULL,											// const void*						pNext;
329 		0u,													// VkPipelineLayoutCreateFlags		flags;
330 		1u,													// deUint32							setLayoutCount;
331 		&descriptorSetLayout,								// const VkDescriptorSetLayout*		pSetLayouts;
332 		0u,													// deUint32							pushConstantRangeCount;
333 		DE_NULL,											// const VkPushConstantRange*		pPushConstantRanges;
334 	};
335 	return createPipelineLayout(vk, device, &pipelineLayoutParams);
336 }
337 
makeComputePipeline(const DeviceInterface & vk,const VkDevice device,const VkPipelineLayout pipelineLayout,const VkShaderModule shaderModule)338 Move<VkPipeline> makeComputePipeline (const DeviceInterface&	vk,
339 									  const VkDevice			device,
340 									  const VkPipelineLayout	pipelineLayout,
341 									  const VkShaderModule		shaderModule)
342 {
343 	const VkPipelineShaderStageCreateInfo pipelineShaderStageParams =
344 	{
345 		VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,	// VkStructureType						sType;
346 		DE_NULL,												// const void*							pNext;
347 		0u,														// VkPipelineShaderStageCreateFlags		flags;
348 		VK_SHADER_STAGE_COMPUTE_BIT,							// VkShaderStageFlagBits				stage;
349 		shaderModule,											// VkShaderModule						module;
350 		"main",													// const char*							pName;
351 		DE_NULL,												// const VkSpecializationInfo*			pSpecializationInfo;
352 	};
353 	const VkComputePipelineCreateInfo pipelineCreateInfo =
354 	{
355 		VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,		// VkStructureType					sType;
356 		DE_NULL,											// const void*						pNext;
357 		0u,													// VkPipelineCreateFlags			flags;
358 		pipelineShaderStageParams,							// VkPipelineShaderStageCreateInfo	stage;
359 		pipelineLayout,										// VkPipelineLayout					layout;
360 		DE_NULL,											// VkPipeline						basePipelineHandle;
361 		0,													// deInt32							basePipelineIndex;
362 	};
363 	return createComputePipeline(vk, device, DE_NULL , &pipelineCreateInfo);
364 }
365 
makeGraphicsPipeline(const DeviceInterface & vk,const VkDevice device,const VkPipelineLayout pipelineLayout,const VkRenderPass renderPass,const VkShaderModule vertexModule,const VkShaderModule fragmentModule,const VkExtent2D renderSize,const deUint32 colorAttachmentCount,const bool dynamicSize)366 Move<VkPipeline> makeGraphicsPipeline (const DeviceInterface&	vk,
367 									   const VkDevice			device,
368 									   const VkPipelineLayout	pipelineLayout,
369 									   const VkRenderPass		renderPass,
370 									   const VkShaderModule		vertexModule,
371 									   const VkShaderModule		fragmentModule,
372 									   const VkExtent2D			renderSize,
373 									   const deUint32			colorAttachmentCount,
374 									   const bool				dynamicSize)
375 {
376 	const VkFormat	vertexFormatPosition		= VK_FORMAT_R32G32B32A32_SFLOAT;
377 	const deUint32	vertexSizePosition			= tcu::getPixelSize(mapVkFormat(vertexFormatPosition));
378 	const deUint32	vertexBufferOffsetPosition	= 0u;
379 	const deUint32	vertexDataStride			= vertexSizePosition;
380 
381 	const VkVertexInputBindingDescription vertexBinding =
382 	{
383 		0u,																// deUint32										binding;
384 		vertexDataStride,												// deUint32										stride;
385 		VK_VERTEX_INPUT_RATE_VERTEX										// VkVertexInputRate							inputRate;
386 	};
387 
388 	const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[] =
389 	{
390 		// position
391 		{
392 			0u,															// deUint32										location;
393 			0u,															// deUint32										binding;
394 			vertexFormatPosition,										// VkFormat										format;
395 			vertexBufferOffsetPosition,									// deUint32										offset;
396 		},
397 	};
398 
399 	const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo =
400 	{
401 		VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,		// VkStructureType								sType;
402 		DE_NULL,														// const void*									pNext;
403 		(VkPipelineVertexInputStateCreateFlags)0,						// VkPipelineVertexInputStateCreateFlags		flags;
404 		1u,																// uint32_t										vertexBindingDescriptionCount;
405 		&vertexBinding,													// const VkVertexInputBindingDescription*		pVertexBindingDescriptions;
406 		DE_LENGTH_OF_ARRAY(vertexInputAttributeDescriptions),			// uint32_t										vertexAttributeDescriptionCount;
407 		vertexInputAttributeDescriptions,								// const VkVertexInputAttributeDescription*		pVertexAttributeDescriptions;
408 	};
409 
410 	const VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateInfo =
411 	{
412 		VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,	// VkStructureType								sType;
413 		DE_NULL,														// const void*									pNext;
414 		(VkPipelineInputAssemblyStateCreateFlags)0,						// VkPipelineInputAssemblyStateCreateFlags		flags;
415 		VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,							// VkPrimitiveTopology							topology;
416 		VK_FALSE,														// VkBool32										primitiveRestartEnable;
417 	};
418 
419 	const VkViewport viewport =
420 	{
421 		0.0f,															// float										originX;
422 		0.0f,															// float										originY;
423 		(float)renderSize.width,										// float										width;
424 		(float)renderSize.height,										// float										height;
425 		0.0f,															// float										minDepth;
426 		1.0f															// float										maxDepth;
427 	};
428 
429 	const VkRect2D scissor =
430 	{
431 		{ 0u, 0u },														// VkOffset2D									offset;
432 		renderSize														// VkExtent2D									extent;
433 	};
434 
435 	const VkPipelineViewportStateCreateInfo pipelineViewportStateInfo =
436 	{
437 		VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,			// VkStructureType								sType;
438 		DE_NULL,														// const void*									pNext;
439 		(VkPipelineViewportStateCreateFlags)0,							// VkPipelineViewportStateCreateFlags			flags;
440 		1u,																// uint32_t										viewportCount;
441 		&viewport, // dynamic state										// const VkViewport*							pViewports;
442 		1u,																// uint32_t										scissorCount;
443 		&scissor, // dynamic state										// const VkRect2D*								pScissors;
444 	};
445 
446 	const VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateInfo =
447 	{
448 		VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,		// VkStructureType								sType;
449 		DE_NULL,														// const void*									pNext;
450 		(VkPipelineRasterizationStateCreateFlags)0,						// VkPipelineRasterizationStateCreateFlags		flags;
451 		VK_FALSE,														// VkBool32										depthClampEnable;
452 		VK_FALSE,														// VkBool32										rasterizerDiscardEnable;
453 		VK_POLYGON_MODE_FILL,											// VkPolygonMode								polygonMode;
454 		VK_CULL_MODE_NONE,												// VkCullModeFlags								cullMode;
455 		VK_FRONT_FACE_COUNTER_CLOCKWISE,								// VkFrontFace									frontFace;
456 		VK_FALSE,														// VkBool32										depthBiasEnable;
457 		0.0f,															// float										depthBiasConstantFactor;
458 		0.0f,															// float										depthBiasClamp;
459 		0.0f,															// float										depthBiasSlopeFactor;
460 		1.0f,															// float										lineWidth;
461 	};
462 
463 	const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateInfo =
464 	{
465 		VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,		// VkStructureType								sType;
466 		DE_NULL,														// const void*									pNext;
467 		(VkPipelineMultisampleStateCreateFlags)0,						// VkPipelineMultisampleStateCreateFlags		flags;
468 		VK_SAMPLE_COUNT_1_BIT,											// VkSampleCountFlagBits						rasterizationSamples;
469 		VK_FALSE,														// VkBool32										sampleShadingEnable;
470 		0.0f,															// float										minSampleShading;
471 		DE_NULL,														// const VkSampleMask*							pSampleMask;
472 		VK_FALSE,														// VkBool32										alphaToCoverageEnable;
473 		VK_FALSE														// VkBool32										alphaToOneEnable;
474 	};
475 
476 	const VkColorComponentFlags					colorComponentsAll			= VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
477 	const VkPipelineColorBlendAttachmentState	colorBlendAttachmentState	=
478 	{
479 		VK_FALSE,														// VkBool32										blendEnable;
480 		VK_BLEND_FACTOR_ONE,											// VkBlendFactor								srcColorBlendFactor;
481 		VK_BLEND_FACTOR_ZERO,											// VkBlendFactor								dstColorBlendFactor;
482 		VK_BLEND_OP_ADD,												// VkBlendOp									colorBlendOp;
483 		VK_BLEND_FACTOR_ONE,											// VkBlendFactor								srcAlphaBlendFactor;
484 		VK_BLEND_FACTOR_ZERO,											// VkBlendFactor								dstAlphaBlendFactor;
485 		VK_BLEND_OP_ADD,												// VkBlendOp									alphaBlendOp;
486 		colorComponentsAll,												// VkColorComponentFlags						colorWriteMask;
487 	};
488 	std::vector<VkPipelineColorBlendAttachmentState> colorAttachments(colorAttachmentCount, colorBlendAttachmentState);
489 
490 	const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo =
491 	{
492 		VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,		// VkStructureType								sType;
493 		DE_NULL,														// const void*									pNext;
494 		(VkPipelineColorBlendStateCreateFlags)0,						// VkPipelineColorBlendStateCreateFlags			flags;
495 		VK_FALSE,														// VkBool32										logicOpEnable;
496 		VK_LOGIC_OP_COPY,												// VkLogicOp									logicOp;
497 		(deUint32)colorAttachments.size(),								// deUint32										attachmentCount;
498 		colorAttachments.size() != 0 ? &colorAttachments[0] : DE_NULL,	// const VkPipelineColorBlendAttachmentState*	pAttachments;
499 		{ 0.0f, 0.0f, 0.0f, 0.0f },										// float										blendConstants[4];
500 	};
501 
502 	const VkPipelineShaderStageCreateInfo pShaderStages[] =
503 	{
504 		{
505 			VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,		// VkStructureType								sType;
506 			DE_NULL,													// const void*									pNext;
507 			(VkPipelineShaderStageCreateFlags)0,						// VkPipelineShaderStageCreateFlags				flags;
508 			VK_SHADER_STAGE_VERTEX_BIT,									// VkShaderStageFlagBits						stage;
509 			vertexModule,												// VkShaderModule								module;
510 			"main",														// const char*									pName;
511 			DE_NULL,													// const VkSpecializationInfo*					pSpecializationInfo;
512 		},
513 		{
514 			VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,		// VkStructureType								sType;
515 			DE_NULL,													// const void*									pNext;
516 			(VkPipelineShaderStageCreateFlags)0,						// VkPipelineShaderStageCreateFlags				flags;
517 			VK_SHADER_STAGE_FRAGMENT_BIT,								// VkShaderStageFlagBits						stage;
518 			fragmentModule,												// VkShaderModule								module;
519 			"main",														// const char*									pName;
520 			DE_NULL,													// const VkSpecializationInfo*					pSpecializationInfo;
521 		}
522 	};
523 	const deUint32 numActiveShaderStages = DE_LENGTH_OF_ARRAY(pShaderStages);
524 
525 	const VkDynamicState dynamicStates[] =
526 	{
527 		VK_DYNAMIC_STATE_VIEWPORT,
528 		VK_DYNAMIC_STATE_SCISSOR,
529 	};
530 
531 	const VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo =
532 	{
533 		VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,			// VkStructureType									sType;
534 		DE_NULL,														// const void*										pNext;
535 		(VkPipelineDynamicStateCreateFlags)0,							// VkPipelineDynamicStateCreateFlags				flags;
536 		DE_LENGTH_OF_ARRAY(dynamicStates),								// deUint32											dynamicStateCount;
537 		dynamicStates,													// const VkDynamicState*							pDynamicStates;
538 	};
539 
540 	const VkGraphicsPipelineCreateInfo graphicsPipelineInfo =
541 	{
542 		VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,				// VkStructureType									sType;
543 		DE_NULL,														// const void*										pNext;
544 		(VkPipelineCreateFlags)0,										// VkPipelineCreateFlags							flags;
545 		numActiveShaderStages,											// deUint32											stageCount;
546 		pShaderStages,													// const VkPipelineShaderStageCreateInfo*			pStages;
547 		&vertexInputStateInfo,											// const VkPipelineVertexInputStateCreateInfo*		pVertexInputState;
548 		&pipelineInputAssemblyStateInfo,								// const VkPipelineInputAssemblyStateCreateInfo*	pInputAssemblyState;
549 		DE_NULL,														// const VkPipelineTessellationStateCreateInfo*		pTessellationState;
550 		&pipelineViewportStateInfo,										// const VkPipelineViewportStateCreateInfo*			pViewportState;
551 		&pipelineRasterizationStateInfo,								// const VkPipelineRasterizationStateCreateInfo*	pRasterizationState;
552 		&pipelineMultisampleStateInfo,									// const VkPipelineMultisampleStateCreateInfo*		pMultisampleState;
553 		DE_NULL,														// const VkPipelineDepthStencilStateCreateInfo*		pDepthStencilState;
554 		&pipelineColorBlendStateInfo,									// const VkPipelineColorBlendStateCreateInfo*		pColorBlendState;
555 		dynamicSize ? &dynamicStateCreateInfo : DE_NULL,				// const VkPipelineDynamicStateCreateInfo*			pDynamicState;
556 		pipelineLayout,													// VkPipelineLayout									layout;
557 		renderPass,														// VkRenderPass										renderPass;
558 		0u,																// deUint32											subpass;
559 		DE_NULL,														// VkPipeline										basePipelineHandle;
560 		0,																// deInt32											basePipelineIndex;
561 	};
562 
563 	return createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineInfo);
564 }
565 
566 //! A single-subpass render pass.
makeRenderPass(const DeviceInterface & vk,const VkDevice device,const VkFormat inputFormat,const VkFormat colorFormat)567 Move<VkRenderPass> makeRenderPass (const DeviceInterface&	vk,
568 								   const VkDevice			device,
569 								   const VkFormat			inputFormat,
570 								   const VkFormat			colorFormat)
571 {
572 	const VkAttachmentReference		inputAttachmentRef			=
573 	{
574 		0u,															// deUint32			attachment;
575 		VK_IMAGE_LAYOUT_GENERAL										// VkImageLayout	layout;
576 	};
577 
578 	const VkAttachmentReference		colorAttachmentRef			=
579 	{
580 		1u,															// deUint32			attachment;
581 		VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL					// VkImageLayout	layout;
582 	};
583 
584 	const VkSubpassDescription		subpassDescription			=
585 	{
586 		(VkSubpassDescriptionFlags)0,								// VkSubpassDescriptionFlags		flags;
587 		VK_PIPELINE_BIND_POINT_GRAPHICS,							// VkPipelineBindPoint				pipelineBindPoint;
588 		1u,															// deUint32							inputAttachmentCount;
589 		&inputAttachmentRef,										// const VkAttachmentReference*		pInputAttachments;
590 		1u,															// deUint32							colorAttachmentCount;
591 		&colorAttachmentRef,										// const VkAttachmentReference*		pColorAttachments;
592 		DE_NULL,													// const VkAttachmentReference*		pResolveAttachments;
593 		DE_NULL,													// const VkAttachmentReference*		pDepthStencilAttachment;
594 		0u,															// deUint32							preserveAttachmentCount;
595 		DE_NULL														// const deUint32*					pPreserveAttachments;
596 	};
597 
598 	const VkAttachmentDescription	attachmentsDescriptions[]	=
599 	{
600 		//inputAttachmentDescription,
601 		{
602 			(VkAttachmentDescriptionFlags)0,						// VkAttachmentDescriptionFlags		flags;
603 			inputFormat,											// VkFormat							format;
604 			VK_SAMPLE_COUNT_1_BIT,									// VkSampleCountFlagBits			samples;
605 			VK_ATTACHMENT_LOAD_OP_LOAD,								// VkAttachmentLoadOp				loadOp;
606 			VK_ATTACHMENT_STORE_OP_DONT_CARE,						// VkAttachmentStoreOp				storeOp;
607 			VK_ATTACHMENT_LOAD_OP_DONT_CARE,						// VkAttachmentLoadOp				stencilLoadOp;
608 			VK_ATTACHMENT_STORE_OP_DONT_CARE,						// VkAttachmentStoreOp				stencilStoreOp;
609 			VK_IMAGE_LAYOUT_GENERAL,								// VkImageLayout					initialLayout;
610 			VK_IMAGE_LAYOUT_GENERAL,								// VkImageLayout					finalLayout;
611 		},
612 		//colorAttachmentDescription
613 		{
614 			(VkAttachmentDescriptionFlags)0,						// VkAttachmentDescriptionFlags		flags;
615 			colorFormat,											// VkFormat							format;
616 			VK_SAMPLE_COUNT_1_BIT,									// VkSampleCountFlagBits			samples;
617 			VK_ATTACHMENT_LOAD_OP_CLEAR,							// VkAttachmentLoadOp				loadOp;
618 			VK_ATTACHMENT_STORE_OP_STORE,							// VkAttachmentStoreOp				storeOp;
619 			VK_ATTACHMENT_LOAD_OP_DONT_CARE,						// VkAttachmentLoadOp				stencilLoadOp;
620 			VK_ATTACHMENT_STORE_OP_DONT_CARE,						// VkAttachmentStoreOp				stencilStoreOp;
621 			VK_IMAGE_LAYOUT_UNDEFINED,								// VkImageLayout					initialLayout;
622 			VK_IMAGE_LAYOUT_GENERAL,								// VkImageLayout					finalLayout;
623 		}
624 	};
625 
626 	const VkRenderPassCreateInfo	renderPassInfo				=
627 	{
628 		VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,					// VkStructureType					sType;
629 		DE_NULL,													// const void*						pNext;
630 		(VkRenderPassCreateFlags)0,									// VkRenderPassCreateFlags			flags;
631 		DE_LENGTH_OF_ARRAY(attachmentsDescriptions),				// deUint32							attachmentCount;
632 		attachmentsDescriptions,									// const VkAttachmentDescription*	pAttachments;
633 		1u,															// deUint32							subpassCount;
634 		&subpassDescription,										// const VkSubpassDescription*		pSubpasses;
635 		0u,															// deUint32							dependencyCount;
636 		DE_NULL														// const VkSubpassDependency*		pDependencies;
637 	};
638 
639 	return createRenderPass(vk, device, &renderPassInfo);
640 }
641 
642 //! A single-subpass render pass.
makeRenderPass(const DeviceInterface & vk,const VkDevice device)643 Move<VkRenderPass> makeRenderPass (const DeviceInterface&	vk,
644 								   const VkDevice			device)
645 {
646 	const VkSubpassDescription		subpassDescription			=
647 	{
648 		(VkSubpassDescriptionFlags)0,								// VkSubpassDescriptionFlags		flags;
649 		VK_PIPELINE_BIND_POINT_GRAPHICS,							// VkPipelineBindPoint				pipelineBindPoint;
650 		0u,															// deUint32							inputAttachmentCount;
651 		DE_NULL,													// const VkAttachmentReference*		pInputAttachments;
652 		0u,															// deUint32							colorAttachmentCount;
653 		DE_NULL,													// const VkAttachmentReference*		pColorAttachments;
654 		DE_NULL,													// const VkAttachmentReference*		pResolveAttachments;
655 		DE_NULL,													// const VkAttachmentReference*		pDepthStencilAttachment;
656 		0u,															// deUint32							preserveAttachmentCount;
657 		DE_NULL														// const deUint32*					pPreserveAttachments;
658 	};
659 
660 	const VkRenderPassCreateInfo	renderPassInfo				=
661 	{
662 		VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,					// VkStructureType					sType;
663 		DE_NULL,													// const void*						pNext;
664 		(VkRenderPassCreateFlags)0,									// VkRenderPassCreateFlags			flags;
665 		0,															// deUint32							attachmentCount;
666 		DE_NULL,													// const VkAttachmentDescription*	pAttachments;
667 		1u,															// deUint32							subpassCount;
668 		&subpassDescription,										// const VkSubpassDescription*		pSubpasses;
669 		0u,															// deUint32							dependencyCount;
670 		DE_NULL														// const VkSubpassDependency*		pDependencies;
671 	};
672 
673 	return createRenderPass(vk, device, &renderPassInfo);
674 }
675 
makeBufferView(const DeviceInterface & vk,const VkDevice vkDevice,const VkBuffer buffer,const VkFormat format,const VkDeviceSize offset,const VkDeviceSize size)676 Move<VkBufferView> makeBufferView (const DeviceInterface&	vk,
677 								   const VkDevice			vkDevice,
678 								   const VkBuffer			buffer,
679 								   const VkFormat			format,
680 								   const VkDeviceSize		offset,
681 								   const VkDeviceSize		size)
682 {
683 	const VkBufferViewCreateInfo bufferViewParams =
684 	{
685 		VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,	// VkStructureType			sType;
686 		DE_NULL,									// const void*				pNext;
687 		0u,											// VkBufferViewCreateFlags	flags;
688 		buffer,										// VkBuffer					buffer;
689 		format,										// VkFormat					format;
690 		offset,										// VkDeviceSize				offset;
691 		size,										// VkDeviceSize				range;
692 	};
693 	return createBufferView(vk, vkDevice, &bufferViewParams);
694 }
695 
makeImageView(const DeviceInterface & vk,const VkDevice vkDevice,const VkImage image,const VkImageViewType imageViewType,const VkFormat format,const VkImageSubresourceRange subresourceRange,const VkImageViewUsageCreateInfoKHR * ImageUsageCreateInfoKHR)696 Move<VkImageView> makeImageView (const DeviceInterface&					vk,
697 								 const VkDevice							vkDevice,
698 								 const VkImage							image,
699 								 const VkImageViewType					imageViewType,
700 								 const VkFormat							format,
701 								 const VkImageSubresourceRange			subresourceRange,
702 								 const VkImageViewUsageCreateInfoKHR*	ImageUsageCreateInfoKHR)
703 {
704 	const VkImageViewCreateInfo imageViewParams =
705 	{
706 		VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,		// VkStructureType			sType;
707 		ImageUsageCreateInfoKHR,						// const void*				pNext;
708 		0u,												// VkImageViewCreateFlags	flags;
709 		image,											// VkImage					image;
710 		imageViewType,									// VkImageViewType			viewType;
711 		format,											// VkFormat					format;
712 		makeComponentMappingRGBA(),						// VkComponentMapping		components;
713 		subresourceRange,								// VkImageSubresourceRange	subresourceRange;
714 	};
715 	return createImageView(vk, vkDevice, &imageViewParams);
716 }
717 
makeDescriptorSet(const DeviceInterface & vk,const VkDevice device,const VkDescriptorPool descriptorPool,const VkDescriptorSetLayout setLayout)718 Move<VkDescriptorSet> makeDescriptorSet (const DeviceInterface&			vk,
719 										 const VkDevice					device,
720 										 const VkDescriptorPool			descriptorPool,
721 										 const VkDescriptorSetLayout	setLayout)
722 {
723 	const VkDescriptorSetAllocateInfo allocateParams =
724 	{
725 		VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,		// VkStructureType				sType;
726 		DE_NULL,											// const void*					pNext;
727 		descriptorPool,										// VkDescriptorPool				descriptorPool;
728 		1u,													// deUint32						setLayoutCount;
729 		&setLayout,											// const VkDescriptorSetLayout*	pSetLayouts;
730 	};
731 	return allocateDescriptorSet(vk, device, &allocateParams);
732 }
733 
makeBufferMemoryBarrier(const VkAccessFlags srcAccessMask,const VkAccessFlags dstAccessMask,const VkBuffer buffer,const VkDeviceSize offset,const VkDeviceSize bufferSizeBytes)734 VkBufferMemoryBarrier makeBufferMemoryBarrier (const VkAccessFlags	srcAccessMask,
735 											   const VkAccessFlags	dstAccessMask,
736 											   const VkBuffer		buffer,
737 											   const VkDeviceSize	offset,
738 											   const VkDeviceSize	bufferSizeBytes)
739 {
740 	const VkBufferMemoryBarrier barrier =
741 	{
742 		VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,	// VkStructureType	sType;
743 		DE_NULL,									// const void*		pNext;
744 		srcAccessMask,								// VkAccessFlags	srcAccessMask;
745 		dstAccessMask,								// VkAccessFlags	dstAccessMask;
746 		VK_QUEUE_FAMILY_IGNORED,					// deUint32			srcQueueFamilyIndex;
747 		VK_QUEUE_FAMILY_IGNORED,					// deUint32			destQueueFamilyIndex;
748 		buffer,										// VkBuffer			buffer;
749 		offset,										// VkDeviceSize		offset;
750 		bufferSizeBytes,							// VkDeviceSize		size;
751 	};
752 	return barrier;
753 }
754 
makeImageMemoryBarrier(const VkAccessFlags srcAccessMask,const VkAccessFlags dstAccessMask,const VkImageLayout oldLayout,const VkImageLayout newLayout,const VkImage image,const VkImageSubresourceRange subresourceRange)755 VkImageMemoryBarrier makeImageMemoryBarrier	(const VkAccessFlags			srcAccessMask,
756 											 const VkAccessFlags			dstAccessMask,
757 											 const VkImageLayout			oldLayout,
758 											 const VkImageLayout			newLayout,
759 											 const VkImage					image,
760 											 const VkImageSubresourceRange	subresourceRange)
761 {
762 	const VkImageMemoryBarrier barrier =
763 	{
764 		VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,			// VkStructureType			sType;
765 		DE_NULL,										// const void*				pNext;
766 		srcAccessMask,									// VkAccessFlags			outputMask;
767 		dstAccessMask,									// VkAccessFlags			inputMask;
768 		oldLayout,										// VkImageLayout			oldLayout;
769 		newLayout,										// VkImageLayout			newLayout;
770 		VK_QUEUE_FAMILY_IGNORED,						// deUint32					srcQueueFamilyIndex;
771 		VK_QUEUE_FAMILY_IGNORED,						// deUint32					destQueueFamilyIndex;
772 		image,											// VkImage					image;
773 		subresourceRange,								// VkImageSubresourceRange	subresourceRange;
774 	};
775 	return barrier;
776 }
777 
makeImageViewUsageCreateInfo(const VkImageUsageFlags imageUsageFlags)778 VkImageViewUsageCreateInfoKHR makeImageViewUsageCreateInfo (const VkImageUsageFlags imageUsageFlags)
779 {
780 	VkImageViewUsageCreateInfoKHR imageViewUsageCreateInfoKHR =
781 	{
782 		VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR,	//VkStructureType		sType;
783 		DE_NULL,											//const void*			pNext;
784 		imageUsageFlags,									//VkImageUsageFlags		usage;
785 	};
786 
787 	return imageViewUsageCreateInfoKHR;
788 }
789 
makeSamplerCreateInfo()790 VkSamplerCreateInfo makeSamplerCreateInfo ()
791 {
792 	const VkSamplerCreateInfo defaultSamplerParams =
793 	{
794 		VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,		// VkStructureType			sType;
795 		DE_NULL,									// const void*				pNext;
796 		0u,											// VkSamplerCreateFlags		flags;
797 		VK_FILTER_NEAREST,							// VkFilter					magFilter;
798 		VK_FILTER_NEAREST,							// VkFilter					minFilter;
799 		VK_SAMPLER_MIPMAP_MODE_NEAREST,				// VkSamplerMipmapMode		mipmapMode;
800 		VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,		// VkSamplerAddressMode		addressModeU;
801 		VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,		// VkSamplerAddressMode		addressModeV;
802 		VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,		// VkSamplerAddressMode		addressModeW;
803 		0.0f,										// float					mipLodBias;
804 		VK_FALSE,									// VkBool32					anisotropyEnable;
805 		1.0f,										// float					maxAnisotropy;
806 		VK_FALSE,									// VkBool32					compareEnable;
807 		VK_COMPARE_OP_NEVER,						// VkCompareOp				compareOp;
808 		0.0f,										// float					minLod;
809 		0.25f,										// float					maxLod;
810 		VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,	// VkBorderColor			borderColor;
811 		VK_FALSE									// VkBool32					unnormalizedCoordinates;
812 	};
813 
814 	return defaultSamplerParams;
815 }
816 
beginCommandBuffer(const DeviceInterface & vk,const VkCommandBuffer commandBuffer)817 void beginCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
818 {
819 	const VkCommandBufferBeginInfo commandBufBeginParams =
820 	{
821 		VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,	// VkStructureType					sType;
822 		DE_NULL,										// const void*						pNext;
823 		0u,												// VkCommandBufferUsageFlags		flags;
824 		(const VkCommandBufferInheritanceInfo*)DE_NULL,
825 	};
826 	VK_CHECK(vk.beginCommandBuffer(commandBuffer, &commandBufBeginParams));
827 }
endCommandBuffer(const DeviceInterface & vk,const VkCommandBuffer commandBuffer)828 void endCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
829 {
830 	VK_CHECK(vk.endCommandBuffer(commandBuffer));
831 }
832 
submitCommandsAndWait(const DeviceInterface & vk,const VkDevice device,const VkQueue queue,const VkCommandBuffer commandBuffer)833 void submitCommandsAndWait (const DeviceInterface&	vk,
834 							const VkDevice			device,
835 							const VkQueue			queue,
836 							const VkCommandBuffer	commandBuffer)
837 {
838 	const Unique<VkFence> fence(createFence(vk, device));
839 
840 	const VkSubmitInfo submitInfo =
841 	{
842 		VK_STRUCTURE_TYPE_SUBMIT_INFO,			// VkStructureType				sType;
843 		DE_NULL,								// const void*					pNext;
844 		0u,										// deUint32						waitSemaphoreCount;
845 		DE_NULL,								// const VkSemaphore*			pWaitSemaphores;
846 		(const VkPipelineStageFlags*)DE_NULL,	// const VkPipelineStageFlags*	pWaitDstStageMask;
847 		1u,										// deUint32						commandBufferCount;
848 		&commandBuffer,							// const VkCommandBuffer*		pCommandBuffers;
849 		0u,										// deUint32						signalSemaphoreCount;
850 		DE_NULL,								// const VkSemaphore*			pSignalSemaphores;
851 	};
852 
853 	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
854 	VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
855 }
856 
getCompressedImageResolutionInBlocks(const vk::VkFormat format,const tcu::UVec3 & size)857 tcu::UVec3 getCompressedImageResolutionInBlocks (const vk::VkFormat format, const tcu::UVec3& size)
858 {
859 	deUint32	blockWidth	= getBlockWidth(format);
860 	deUint32	blockHeight	= getBlockHeight(format);
861 
862 	DE_ASSERT(size[2] == 1);
863 	DE_ASSERT(blockWidth != 0 && blockHeight != 0);
864 
865 	deUint32	widthInBlocks	= (size[0] + blockWidth - 1) / blockWidth;
866 	deUint32	heightInBlocks	= (size[1] + blockHeight - 1) / blockHeight;
867 
868 	return tcu::UVec3(widthInBlocks, heightInBlocks, 1);
869 }
870 
getCompressedImageResolutionBlockCeil(const vk::VkFormat format,const tcu::UVec3 & size)871 tcu::UVec3 getCompressedImageResolutionBlockCeil (const vk::VkFormat format, const tcu::UVec3& size)
872 {
873 	deUint32	blockWidth	= getBlockWidth(format);
874 	deUint32	blockHeight	= getBlockHeight(format);
875 
876 	DE_ASSERT(size[2] == 1);
877 	DE_ASSERT(blockWidth != 0 && blockHeight != 0);
878 
879 	deUint32	widthInBlocks	= (size[0] + blockWidth - 1) / blockWidth;
880 	deUint32	heightInBlocks	= (size[1] + blockHeight - 1) / blockHeight;
881 
882 	return tcu::UVec3(blockWidth * widthInBlocks, blockHeight * heightInBlocks, 1);
883 }
884 
getCompressedImageSizeInBytes(const vk::VkFormat format,const tcu::UVec3 & size)885 VkDeviceSize getCompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size)
886 {
887 	tcu::UVec3		sizeInBlocks	= getCompressedImageResolutionInBlocks(format, size);
888 	deUint32		blockBytes		= getBlockSizeInBytes(format);
889 	VkDeviceSize	sizeBytes		= sizeInBlocks[0] * sizeInBlocks[1] * sizeInBlocks[2] * blockBytes;
890 
891 	return sizeBytes;
892 }
893 
getUncompressedImageSizeInBytes(const vk::VkFormat format,const tcu::UVec3 & size)894 VkDeviceSize getUncompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size)
895 {
896 	const tcu::IVec3	sizeAsIVec3	= tcu::IVec3((int)size.x(), (int)size.y(), (int)size.z());
897 	const VkDeviceSize	sizeBytes	= getImageSizeBytes(sizeAsIVec3, format);
898 
899 	return sizeBytes;
900 }
901 
mapImageType(const ImageType imageType)902 VkImageType	mapImageType (const ImageType imageType)
903 {
904 	switch (imageType)
905 	{
906 		case IMAGE_TYPE_1D:
907 		case IMAGE_TYPE_1D_ARRAY:
908 		case IMAGE_TYPE_BUFFER:
909 			return VK_IMAGE_TYPE_1D;
910 
911 		case IMAGE_TYPE_2D:
912 		case IMAGE_TYPE_2D_ARRAY:
913 		case IMAGE_TYPE_CUBE:
914 		case IMAGE_TYPE_CUBE_ARRAY:
915 			return VK_IMAGE_TYPE_2D;
916 
917 		case IMAGE_TYPE_3D:
918 			return VK_IMAGE_TYPE_3D;
919 
920 		default:
921 			DE_ASSERT(false);
922 			return VK_IMAGE_TYPE_LAST;
923 	}
924 }
925 
mapImageViewType(const ImageType imageType)926 VkImageViewType	mapImageViewType (const ImageType imageType)
927 {
928 	switch (imageType)
929 	{
930 		case IMAGE_TYPE_1D:			return VK_IMAGE_VIEW_TYPE_1D;
931 		case IMAGE_TYPE_1D_ARRAY:	return VK_IMAGE_VIEW_TYPE_1D_ARRAY;
932 		case IMAGE_TYPE_2D:			return VK_IMAGE_VIEW_TYPE_2D;
933 		case IMAGE_TYPE_2D_ARRAY:	return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
934 		case IMAGE_TYPE_3D:			return VK_IMAGE_VIEW_TYPE_3D;
935 		case IMAGE_TYPE_CUBE:		return VK_IMAGE_VIEW_TYPE_CUBE;
936 		case IMAGE_TYPE_CUBE_ARRAY:	return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
937 
938 		default:
939 			DE_ASSERT(false);
940 			return VK_IMAGE_VIEW_TYPE_LAST;
941 	}
942 }
943 
getImageTypeName(const ImageType imageType)944 std::string getImageTypeName (const ImageType imageType)
945 {
946 	switch (imageType)
947 	{
948 		case IMAGE_TYPE_1D:			return "1d";
949 		case IMAGE_TYPE_1D_ARRAY:	return "1d_array";
950 		case IMAGE_TYPE_2D:			return "2d";
951 		case IMAGE_TYPE_2D_ARRAY:	return "2d_array";
952 		case IMAGE_TYPE_3D:			return "3d";
953 		case IMAGE_TYPE_CUBE:		return "cube";
954 		case IMAGE_TYPE_CUBE_ARRAY:	return "cube_array";
955 		case IMAGE_TYPE_BUFFER:		return "buffer";
956 
957 		default:
958 			DE_ASSERT(false);
959 			return "";
960 	}
961 }
962 
getShaderImageType(const tcu::TextureFormat & format,const ImageType imageType,const bool multisample)963 std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType, const bool multisample)
964 {
965 	std::string formatPart = tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" :
966 							 tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER   ? "i" : "";
967 
968 	std::string imageTypePart;
969 	if (multisample)
970 	{
971 		switch (imageType)
972 		{
973 			case IMAGE_TYPE_2D:			imageTypePart = "2DMS";			break;
974 			case IMAGE_TYPE_2D_ARRAY:	imageTypePart = "2DMSArray";	break;
975 
976 			default:
977 				DE_ASSERT(false);
978 		}
979 	}
980 	else
981 	{
982 		switch (imageType)
983 		{
984 			case IMAGE_TYPE_1D:			imageTypePart = "1D";			break;
985 			case IMAGE_TYPE_1D_ARRAY:	imageTypePart = "1DArray";		break;
986 			case IMAGE_TYPE_2D:			imageTypePart = "2D";			break;
987 			case IMAGE_TYPE_2D_ARRAY:	imageTypePart = "2DArray";		break;
988 			case IMAGE_TYPE_3D:			imageTypePart = "3D";			break;
989 			case IMAGE_TYPE_CUBE:		imageTypePart = "Cube";			break;
990 			case IMAGE_TYPE_CUBE_ARRAY:	imageTypePart = "CubeArray";	break;
991 			case IMAGE_TYPE_BUFFER:		imageTypePart = "Buffer";		break;
992 
993 			default:
994 				DE_ASSERT(false);
995 		}
996 	}
997 
998 	return formatPart + "image" + imageTypePart;
999 }
1000 
getShaderImageFormatQualifier(const tcu::TextureFormat & format)1001 std::string getShaderImageFormatQualifier (const tcu::TextureFormat& format)
1002 {
1003 	const char* orderPart;
1004 	const char* typePart;
1005 
1006 	switch (format.order)
1007 	{
1008 		case tcu::TextureFormat::R:		orderPart = "r";	break;
1009 		case tcu::TextureFormat::RG:	orderPart = "rg";	break;
1010 		case tcu::TextureFormat::RGB:	orderPart = "rgb";	break;
1011 		case tcu::TextureFormat::RGBA:	orderPart = "rgba";	break;
1012 
1013 		default:
1014 			DE_ASSERT(false);
1015 			orderPart = DE_NULL;
1016 	}
1017 
1018 	switch (format.type)
1019 	{
1020 		case tcu::TextureFormat::FLOAT:				typePart = "32f";		break;
1021 		case tcu::TextureFormat::HALF_FLOAT:		typePart = "16f";		break;
1022 
1023 		case tcu::TextureFormat::UNSIGNED_INT32:	typePart = "32ui";		break;
1024 		case tcu::TextureFormat::UNSIGNED_INT16:	typePart = "16ui";		break;
1025 		case tcu::TextureFormat::UNSIGNED_INT8:		typePart = "8ui";		break;
1026 
1027 		case tcu::TextureFormat::SIGNED_INT32:		typePart = "32i";		break;
1028 		case tcu::TextureFormat::SIGNED_INT16:		typePart = "16i";		break;
1029 		case tcu::TextureFormat::SIGNED_INT8:		typePart = "8i";		break;
1030 
1031 		case tcu::TextureFormat::UNORM_INT16:		typePart = "16";		break;
1032 		case tcu::TextureFormat::UNORM_INT8:		typePart = "8";			break;
1033 
1034 		case tcu::TextureFormat::SNORM_INT16:		typePart = "16_snorm";	break;
1035 		case tcu::TextureFormat::SNORM_INT8:		typePart = "8_snorm";	break;
1036 
1037 		default:
1038 			DE_ASSERT(false);
1039 			typePart = DE_NULL;
1040 	}
1041 
1042 	return std::string() + orderPart + typePart;
1043 }
1044 
getGlslSamplerType(const tcu::TextureFormat & format,VkImageViewType type)1045 std::string getGlslSamplerType (const tcu::TextureFormat& format, VkImageViewType type)
1046 {
1047 	const char* typePart	= DE_NULL;
1048 	const char* formatPart	= tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" :
1049 							  tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER   ? "i" : "";
1050 
1051 	switch (type)
1052 	{
1053 		case VK_IMAGE_VIEW_TYPE_1D:			typePart = "sampler1D";			break;
1054 		case VK_IMAGE_VIEW_TYPE_1D_ARRAY:	typePart = "sampler1DArray";	break;
1055 		case VK_IMAGE_VIEW_TYPE_2D:			typePart = "sampler2D";			break;
1056 		case VK_IMAGE_VIEW_TYPE_2D_ARRAY:	typePart = "sampler2DArray";	break;
1057 		case VK_IMAGE_VIEW_TYPE_3D:			typePart = "sampler3D";			break;
1058 		case VK_IMAGE_VIEW_TYPE_CUBE:		typePart = "samplerCube";		break;
1059 		case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:	typePart = "samplerCubeArray";	break;
1060 
1061 		default:
1062 			DE_FATAL("Unknown image view type");
1063 			break;
1064 	}
1065 
1066 	return std::string(formatPart) + typePart;
1067 }
1068 
1069 
getGlslInputFormatType(const vk::VkFormat format)1070 const char* getGlslInputFormatType (const vk::VkFormat format)
1071 {
1072 	switch (format)
1073 	{
1074 		// 64-bit
1075 		case VK_FORMAT_R16G16B16A16_UNORM:		return "subpassInput";
1076 		case VK_FORMAT_R16G16B16A16_SNORM:		return "subpassInput";
1077 		case VK_FORMAT_R16G16B16A16_USCALED:	return "subpassInput";
1078 		case VK_FORMAT_R16G16B16A16_SSCALED:	return "subpassInput";
1079 		case VK_FORMAT_R16G16B16A16_UINT:		return "usubpassInput";
1080 		case VK_FORMAT_R16G16B16A16_SINT:		return "isubpassInput";
1081 		case VK_FORMAT_R16G16B16A16_SFLOAT:		return "subpassInput";
1082 		case VK_FORMAT_R32G32_UINT:				return "usubpassInput";
1083 		case VK_FORMAT_R32G32_SINT:				return "isubpassInput";
1084 		case VK_FORMAT_R32G32_SFLOAT:			return "subpassInput";
1085 		// TODO: case VK_FORMAT_R64_UINT:		return "usubpassInput";
1086 		// TODO: case VK_FORMAT_R64_SINT:		return "isubpassInput";
1087 		// TODO: case VK_FORMAT_R64_SFLOAT:		return "subpassInput";
1088 
1089 		// 128-bit
1090 		case VK_FORMAT_R32G32B32A32_UINT:		return "usubpassInput";
1091 		case VK_FORMAT_R32G32B32A32_SINT:		return "isubpassInput";
1092 		case VK_FORMAT_R32G32B32A32_SFLOAT:		return "subpassInput";
1093 		// TODO: case VK_FORMAT_R64G64_UINT:	return "usubpassInput";
1094 		// TODO: case VK_FORMAT_R64G64_SINT:	return "isubpassInput";
1095 		// TODO: case VK_FORMAT_R64G64_SFLOAT:	return "subpassInput";
1096 
1097 		default:	TCU_THROW(InternalError, "Unknown format");
1098 	}
1099 }
1100 
getGlslFormatType(const vk::VkFormat format)1101 const char* getGlslFormatType (const vk::VkFormat format)
1102 {
1103 	switch (format)
1104 	{
1105 		// 64-bit
1106 		case VK_FORMAT_R16G16B16A16_UNORM:		return "vec4";
1107 		case VK_FORMAT_R16G16B16A16_SNORM:		return "vec4";
1108 		case VK_FORMAT_R16G16B16A16_USCALED:	return "vec4";
1109 		case VK_FORMAT_R16G16B16A16_SSCALED:	return "vec4";
1110 		case VK_FORMAT_R16G16B16A16_UINT:		return "uvec4";
1111 		case VK_FORMAT_R16G16B16A16_SINT:		return "ivec4";
1112 		case VK_FORMAT_R16G16B16A16_SFLOAT:		return "vec4";
1113 		case VK_FORMAT_R32G32_UINT:				return "uvec2";
1114 		case VK_FORMAT_R32G32_SINT:				return "ivec2";
1115 		case VK_FORMAT_R32G32_SFLOAT:			return "vec2";
1116 		// TODO: case VK_FORMAT_R64_UINT:		return "uint64";
1117 		// TODO: case VK_FORMAT_R64_SINT:		return "int64";
1118 		// TODO: case VK_FORMAT_R64_SFLOAT:		return "double";
1119 
1120 		// 128-bit
1121 		case VK_FORMAT_R32G32B32A32_UINT:		return "uvec4";
1122 		case VK_FORMAT_R32G32B32A32_SINT:		return "ivec4";
1123 		case VK_FORMAT_R32G32B32A32_SFLOAT:		return "vec4";
1124 		// TODO: case VK_FORMAT_R64G64_UINT:	return "ulvec2";
1125 		// TODO: case VK_FORMAT_R64G64_SINT:	return "ilvec2";
1126 		// TODO: case VK_FORMAT_R64G64_SFLOAT:	return "dvec2";
1127 
1128 		default:	TCU_THROW(InternalError, "Unknown format");
1129 	}
1130 }
1131 
getGlslAttachmentType(const vk::VkFormat format)1132 const char* getGlslAttachmentType (const vk::VkFormat format)
1133 {
1134 	const tcu::TextureFormat		textureFormat	= mapVkFormat(format);
1135 	const tcu::TextureChannelClass	channelClass	= tcu::getTextureChannelClass(textureFormat.type);
1136 
1137 	switch (channelClass)
1138 	{
1139 		case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
1140 			return "ivec4";
1141 
1142 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
1143 			return "uvec4";
1144 
1145 		case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
1146 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
1147 		case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
1148 			return "vec4";
1149 
1150 		default:
1151 			DE_FATAL("Unknown channel class");
1152 			return "";
1153 	}
1154 }
1155 
getGlslInputAttachmentType(const vk::VkFormat format)1156 const char* getGlslInputAttachmentType (const vk::VkFormat format)
1157 {
1158 	const tcu::TextureFormat		textureFormat	= mapVkFormat(format);
1159 	const tcu::TextureChannelClass	channelClass	= tcu::getTextureChannelClass(textureFormat.type);
1160 
1161 	switch (channelClass)
1162 	{
1163 		case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
1164 			return "isubpassInput";
1165 
1166 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
1167 			return "usubpassInput";
1168 
1169 		case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
1170 		case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
1171 		case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
1172 			return "subpassInput";
1173 
1174 		default:
1175 			DE_FATAL("Unknown channel class");
1176 			return "";
1177 	}
1178 }
1179 
isPackedType(const vk::VkFormat format)1180 bool isPackedType (const vk::VkFormat format)
1181 {
1182 	const tcu::TextureFormat	textureFormat	= mapVkFormat(format);
1183 
1184 	DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELTYPE_LAST == 40);
1185 
1186 	switch (textureFormat.type)
1187 	{
1188 		case tcu::TextureFormat::UNORM_BYTE_44:
1189 		case tcu::TextureFormat::UNORM_SHORT_565:
1190 		case tcu::TextureFormat::UNORM_SHORT_555:
1191 		case tcu::TextureFormat::UNORM_SHORT_4444:
1192 		case tcu::TextureFormat::UNORM_SHORT_5551:
1193 		case tcu::TextureFormat::UNORM_SHORT_1555:
1194 		case tcu::TextureFormat::UNORM_INT_101010:
1195 		case tcu::TextureFormat::SNORM_INT_1010102_REV:
1196 		case tcu::TextureFormat::UNORM_INT_1010102_REV:
1197 		case tcu::TextureFormat::UNSIGNED_BYTE_44:
1198 		case tcu::TextureFormat::UNSIGNED_SHORT_565:
1199 		case tcu::TextureFormat::UNSIGNED_SHORT_4444:
1200 		case tcu::TextureFormat::UNSIGNED_SHORT_5551:
1201 		case tcu::TextureFormat::SIGNED_INT_1010102_REV:
1202 		case tcu::TextureFormat::UNSIGNED_INT_1010102_REV:
1203 		case tcu::TextureFormat::UNSIGNED_INT_11F_11F_10F_REV:
1204 		case tcu::TextureFormat::UNSIGNED_INT_999_E5_REV:
1205 		case tcu::TextureFormat::UNSIGNED_INT_16_8_8:
1206 		case tcu::TextureFormat::UNSIGNED_INT_24_8:
1207 		case tcu::TextureFormat::UNSIGNED_INT_24_8_REV:
1208 			return true;
1209 
1210 		default:
1211 			return false;
1212 	}
1213 }
1214 
isComponentSwizzled(const vk::VkFormat format)1215 bool isComponentSwizzled (const vk::VkFormat format)
1216 {
1217 	const tcu::TextureFormat	textureFormat	= mapVkFormat(format);
1218 
1219 	DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 21);
1220 
1221 	switch (textureFormat.order)
1222 	{
1223 		case tcu::TextureFormat::ARGB:
1224 		case tcu::TextureFormat::BGR:
1225 		case tcu::TextureFormat::BGRA:
1226 		case tcu::TextureFormat::sBGR:
1227 		case tcu::TextureFormat::sBGRA:
1228 			return true;
1229 
1230 		default:
1231 			return false;
1232 	}
1233 }
1234 
getNumUsedChannels(const vk::VkFormat format)1235 int getNumUsedChannels (const vk::VkFormat format)
1236 {
1237 	// make sure this function will be checked if type table is updated
1238 	DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 21);
1239 
1240 	const tcu::TextureFormat	textureFormat	= mapVkFormat(format);
1241 
1242 	return getNumUsedChannels(textureFormat.order);
1243 }
1244 
getFormatShortString(const VkFormat format)1245 std::string getFormatShortString (const VkFormat format)
1246 {
1247 	const std::string fullName = getFormatName(format);
1248 
1249 	DE_ASSERT(de::beginsWith(fullName, "VK_FORMAT_"));
1250 
1251 	return de::toLower(fullName.substr(10));
1252 }
1253 
createFullscreenQuad(void)1254 std::vector<tcu::Vec4> createFullscreenQuad (void)
1255 {
1256 	const tcu::Vec4 lowerLeftVertex		(-1.0f,	-1.0f,	0.0f,	1.0f);
1257 	const tcu::Vec4 upperLeftVertex		(-1.0f,	1.0f,	0.0f,	1.0f);
1258 	const tcu::Vec4 lowerRightVertex	(1.0f,	-1.0f,	0.0f,	1.0f);
1259 	const tcu::Vec4 upperRightVertex	(1.0f,	1.0f,	0.0f,	1.0f);
1260 
1261 	const tcu::Vec4 vertices[6] =
1262 	{
1263 		lowerLeftVertex,
1264 		lowerRightVertex,
1265 		upperLeftVertex,
1266 
1267 		upperLeftVertex,
1268 		lowerRightVertex,
1269 		upperRightVertex
1270 	};
1271 
1272 	return std::vector<tcu::Vec4>(vertices, vertices + DE_LENGTH_OF_ARRAY(vertices));
1273 }
1274 
makeBufferImageCopy(const deUint32 imageWidth,const deUint32 imageHeight,const deUint32 mipLevel,const deUint32 layer)1275 vk::VkBufferImageCopy makeBufferImageCopy (const deUint32 imageWidth, const deUint32 imageHeight, const deUint32 mipLevel, const deUint32 layer)
1276 {
1277 	const VkBufferImageCopy	copyParams	=
1278 	{
1279 		(VkDeviceSize)0u,						// bufferOffset
1280 		imageWidth,								// bufferRowLength
1281 		imageHeight,							// bufferImageHeight
1282 		{
1283 			VK_IMAGE_ASPECT_COLOR_BIT,				// aspectMask
1284 			mipLevel,								// mipLevel
1285 			layer,									// baseArrayLayer
1286 			1u,										// layerCount
1287 		},										// imageSubresource
1288 		{ 0u, 0u, 0u },							// imageOffset
1289 		{
1290 			imageWidth,
1291 			imageHeight,
1292 			1u
1293 		}										// imageExtent
1294 	};
1295 
1296 	return copyParams;
1297 }
1298 
makeBufferImageCopy(const deUint32 imageWidth,const deUint32 imageHeight,const deUint32 mipLevel,const deUint32 layer,const deUint32 bufferRowLength,const deUint32 bufferImageHeight)1299 vk::VkBufferImageCopy makeBufferImageCopy (const deUint32 imageWidth, const deUint32 imageHeight, const deUint32 mipLevel, const deUint32 layer, const deUint32 bufferRowLength, const deUint32 bufferImageHeight)
1300 {
1301 	const VkBufferImageCopy	copyParams	=
1302 	{
1303 		(VkDeviceSize)0u,						// bufferOffset
1304 		bufferRowLength,						// bufferRowLength
1305 		bufferImageHeight,						// bufferImageHeight
1306 		{
1307 			VK_IMAGE_ASPECT_COLOR_BIT,				// aspectMask
1308 			mipLevel,								// mipLevel
1309 			layer,									// baseArrayLayer
1310 			1u,										// layerCount
1311 		},										// imageSubresource
1312 		{ 0u, 0u, 0u },							// imageOffset
1313 		{
1314 			imageWidth,
1315 			imageHeight,
1316 			1u
1317 		}										// imageExtent
1318 	};
1319 
1320 	return copyParams;
1321 }
1322 
beginRenderPass(const DeviceInterface & vk,const VkCommandBuffer commandBuffer,const VkRenderPass renderPass,const VkFramebuffer framebuffer,const VkExtent2D & renderSize)1323 void beginRenderPass (const DeviceInterface&	vk,
1324 					  const VkCommandBuffer		commandBuffer,
1325 					  const VkRenderPass		renderPass,
1326 					  const VkFramebuffer		framebuffer,
1327 					  const VkExtent2D&			renderSize)
1328 {
1329 	const VkClearValue			clearValues[]		=
1330 	{
1331 		makeClearValueColorF32(0.0, 0.0, 0.0, 0.0),
1332 		makeClearValueColorF32(0.0, 0.0, 0.0, 0.0),
1333 	};
1334 	const VkRect2D				renderArea			=
1335 	{
1336 		{0, 0},											// VkOffset2D				offset;
1337 		renderSize,										// VkExtent2D				extent;
1338 	};
1339 	const VkRenderPassBeginInfo	renderPassBeginInfo =
1340 	{
1341 		VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,		// VkStructureType			sType;
1342 		DE_NULL,										// const void*				pNext;
1343 		renderPass,										// VkRenderPass				renderPass;
1344 		framebuffer,									// VkFramebuffer			framebuffer;
1345 		renderArea,										// VkRect2D					renderArea;
1346 		DE_LENGTH_OF_ARRAY(clearValues),				// uint32_t					clearValueCount;
1347 		clearValues,									// const VkClearValue*		pClearValues;
1348 	};
1349 
1350 	vk.cmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
1351 }
1352 
makeFramebuffer(const DeviceInterface & vk,const VkDevice device,const VkRenderPass renderPass,const deUint32 attachmentCount,const VkImageView * pAttachments,const VkExtent2D & size,const deUint32 layersCount)1353 Move<VkFramebuffer> makeFramebuffer (const DeviceInterface&	vk,
1354 									 const VkDevice			device,
1355 									 const VkRenderPass		renderPass,
1356 									 const deUint32			attachmentCount,
1357 									 const VkImageView*		pAttachments,
1358 									 const VkExtent2D&		size,
1359 									 const deUint32			layersCount)
1360 {
1361 	const vk::VkFramebufferCreateInfo framebufferInfo =
1362 	{
1363 		VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,		// VkStructureType			sType;
1364 		DE_NULL,										// const void*				pNext;
1365 		(VkFramebufferCreateFlags)0,					// VkFramebufferCreateFlags	flags;
1366 		renderPass,										// VkRenderPass				renderPass;
1367 		attachmentCount,								// uint32_t					attachmentCount;
1368 		pAttachments,									// const VkImageView*		pAttachments;
1369 		static_cast<deUint32>(size.width),				// uint32_t					width;
1370 		static_cast<deUint32>(size.height),				// uint32_t					height;
1371 		layersCount,									// uint32_t					layers;
1372 	};
1373 
1374 	return createFramebuffer(vk, device, &framebufferInfo);
1375 }
1376 
makeScissor(const deUint32 width,const deUint32 height)1377 VkRect2D makeScissor (const deUint32	width,
1378 					  const deUint32	height)
1379 {
1380 	const VkRect2D scissor =
1381 	{
1382 		{ 0u, 0u },			// VkOffset2D	offset;
1383 		{ width, height }	// VkExtent2D	extent;
1384 	};
1385 
1386 	return scissor;
1387 }
1388 
1389 } // image
1390 } // vkt
1391