1/* WARNING: This is auto-generated file. Do not modify, since changes will
2 * be lost! Modify the generating script instead.
3 */
4struct VkApplicationInfo
5{
6	VkStructureType	sType;
7	const void*		pNext;
8	const char*		pApplicationName;
9	deUint32		applicationVersion;
10	const char*		pEngineName;
11	deUint32		engineVersion;
12	deUint32		apiVersion;
13};
14
15struct VkInstanceCreateInfo
16{
17	VkStructureType				sType;
18	const void*					pNext;
19	VkInstanceCreateFlags		flags;
20	const VkApplicationInfo*	pApplicationInfo;
21	deUint32					enabledLayerCount;
22	const char* const*			ppEnabledLayerNames;
23	deUint32					enabledExtensionCount;
24	const char* const*			ppEnabledExtensionNames;
25};
26
27struct VkAllocationCallbacks
28{
29	void*									pUserData;
30	PFN_vkAllocationFunction				pfnAllocation;
31	PFN_vkReallocationFunction				pfnReallocation;
32	PFN_vkFreeFunction						pfnFree;
33	PFN_vkInternalAllocationNotification	pfnInternalAllocation;
34	PFN_vkInternalFreeNotification			pfnInternalFree;
35};
36
37struct VkPhysicalDeviceFeatures
38{
39	VkBool32	robustBufferAccess;
40	VkBool32	fullDrawIndexUint32;
41	VkBool32	imageCubeArray;
42	VkBool32	independentBlend;
43	VkBool32	geometryShader;
44	VkBool32	tessellationShader;
45	VkBool32	sampleRateShading;
46	VkBool32	dualSrcBlend;
47	VkBool32	logicOp;
48	VkBool32	multiDrawIndirect;
49	VkBool32	drawIndirectFirstInstance;
50	VkBool32	depthClamp;
51	VkBool32	depthBiasClamp;
52	VkBool32	fillModeNonSolid;
53	VkBool32	depthBounds;
54	VkBool32	wideLines;
55	VkBool32	largePoints;
56	VkBool32	alphaToOne;
57	VkBool32	multiViewport;
58	VkBool32	samplerAnisotropy;
59	VkBool32	textureCompressionETC2;
60	VkBool32	textureCompressionASTC_LDR;
61	VkBool32	textureCompressionBC;
62	VkBool32	occlusionQueryPrecise;
63	VkBool32	pipelineStatisticsQuery;
64	VkBool32	vertexPipelineStoresAndAtomics;
65	VkBool32	fragmentStoresAndAtomics;
66	VkBool32	shaderTessellationAndGeometryPointSize;
67	VkBool32	shaderImageGatherExtended;
68	VkBool32	shaderStorageImageExtendedFormats;
69	VkBool32	shaderStorageImageMultisample;
70	VkBool32	shaderStorageImageReadWithoutFormat;
71	VkBool32	shaderStorageImageWriteWithoutFormat;
72	VkBool32	shaderUniformBufferArrayDynamicIndexing;
73	VkBool32	shaderSampledImageArrayDynamicIndexing;
74	VkBool32	shaderStorageBufferArrayDynamicIndexing;
75	VkBool32	shaderStorageImageArrayDynamicIndexing;
76	VkBool32	shaderClipDistance;
77	VkBool32	shaderCullDistance;
78	VkBool32	shaderFloat64;
79	VkBool32	shaderInt64;
80	VkBool32	shaderInt16;
81	VkBool32	shaderResourceResidency;
82	VkBool32	shaderResourceMinLod;
83	VkBool32	sparseBinding;
84	VkBool32	sparseResidencyBuffer;
85	VkBool32	sparseResidencyImage2D;
86	VkBool32	sparseResidencyImage3D;
87	VkBool32	sparseResidency2Samples;
88	VkBool32	sparseResidency4Samples;
89	VkBool32	sparseResidency8Samples;
90	VkBool32	sparseResidency16Samples;
91	VkBool32	sparseResidencyAliased;
92	VkBool32	variableMultisampleRate;
93	VkBool32	inheritedQueries;
94};
95
96struct VkFormatProperties
97{
98	VkFormatFeatureFlags	linearTilingFeatures;
99	VkFormatFeatureFlags	optimalTilingFeatures;
100	VkFormatFeatureFlags	bufferFeatures;
101};
102
103struct VkExtent3D
104{
105	deUint32	width;
106	deUint32	height;
107	deUint32	depth;
108};
109
110struct VkImageFormatProperties
111{
112	VkExtent3D			maxExtent;
113	deUint32			maxMipLevels;
114	deUint32			maxArrayLayers;
115	VkSampleCountFlags	sampleCounts;
116	VkDeviceSize		maxResourceSize;
117};
118
119struct VkPhysicalDeviceLimits
120{
121	deUint32			maxImageDimension1D;
122	deUint32			maxImageDimension2D;
123	deUint32			maxImageDimension3D;
124	deUint32			maxImageDimensionCube;
125	deUint32			maxImageArrayLayers;
126	deUint32			maxTexelBufferElements;
127	deUint32			maxUniformBufferRange;
128	deUint32			maxStorageBufferRange;
129	deUint32			maxPushConstantsSize;
130	deUint32			maxMemoryAllocationCount;
131	deUint32			maxSamplerAllocationCount;
132	VkDeviceSize		bufferImageGranularity;
133	VkDeviceSize		sparseAddressSpaceSize;
134	deUint32			maxBoundDescriptorSets;
135	deUint32			maxPerStageDescriptorSamplers;
136	deUint32			maxPerStageDescriptorUniformBuffers;
137	deUint32			maxPerStageDescriptorStorageBuffers;
138	deUint32			maxPerStageDescriptorSampledImages;
139	deUint32			maxPerStageDescriptorStorageImages;
140	deUint32			maxPerStageDescriptorInputAttachments;
141	deUint32			maxPerStageResources;
142	deUint32			maxDescriptorSetSamplers;
143	deUint32			maxDescriptorSetUniformBuffers;
144	deUint32			maxDescriptorSetUniformBuffersDynamic;
145	deUint32			maxDescriptorSetStorageBuffers;
146	deUint32			maxDescriptorSetStorageBuffersDynamic;
147	deUint32			maxDescriptorSetSampledImages;
148	deUint32			maxDescriptorSetStorageImages;
149	deUint32			maxDescriptorSetInputAttachments;
150	deUint32			maxVertexInputAttributes;
151	deUint32			maxVertexInputBindings;
152	deUint32			maxVertexInputAttributeOffset;
153	deUint32			maxVertexInputBindingStride;
154	deUint32			maxVertexOutputComponents;
155	deUint32			maxTessellationGenerationLevel;
156	deUint32			maxTessellationPatchSize;
157	deUint32			maxTessellationControlPerVertexInputComponents;
158	deUint32			maxTessellationControlPerVertexOutputComponents;
159	deUint32			maxTessellationControlPerPatchOutputComponents;
160	deUint32			maxTessellationControlTotalOutputComponents;
161	deUint32			maxTessellationEvaluationInputComponents;
162	deUint32			maxTessellationEvaluationOutputComponents;
163	deUint32			maxGeometryShaderInvocations;
164	deUint32			maxGeometryInputComponents;
165	deUint32			maxGeometryOutputComponents;
166	deUint32			maxGeometryOutputVertices;
167	deUint32			maxGeometryTotalOutputComponents;
168	deUint32			maxFragmentInputComponents;
169	deUint32			maxFragmentOutputAttachments;
170	deUint32			maxFragmentDualSrcAttachments;
171	deUint32			maxFragmentCombinedOutputResources;
172	deUint32			maxComputeSharedMemorySize;
173	deUint32			maxComputeWorkGroupCount[3];
174	deUint32			maxComputeWorkGroupInvocations;
175	deUint32			maxComputeWorkGroupSize[3];
176	deUint32			subPixelPrecisionBits;
177	deUint32			subTexelPrecisionBits;
178	deUint32			mipmapPrecisionBits;
179	deUint32			maxDrawIndexedIndexValue;
180	deUint32			maxDrawIndirectCount;
181	float				maxSamplerLodBias;
182	float				maxSamplerAnisotropy;
183	deUint32			maxViewports;
184	deUint32			maxViewportDimensions[2];
185	float				viewportBoundsRange[2];
186	deUint32			viewportSubPixelBits;
187	deUintptr			minMemoryMapAlignment;
188	VkDeviceSize		minTexelBufferOffsetAlignment;
189	VkDeviceSize		minUniformBufferOffsetAlignment;
190	VkDeviceSize		minStorageBufferOffsetAlignment;
191	deInt32				minTexelOffset;
192	deUint32			maxTexelOffset;
193	deInt32				minTexelGatherOffset;
194	deUint32			maxTexelGatherOffset;
195	float				minInterpolationOffset;
196	float				maxInterpolationOffset;
197	deUint32			subPixelInterpolationOffsetBits;
198	deUint32			maxFramebufferWidth;
199	deUint32			maxFramebufferHeight;
200	deUint32			maxFramebufferLayers;
201	VkSampleCountFlags	framebufferColorSampleCounts;
202	VkSampleCountFlags	framebufferDepthSampleCounts;
203	VkSampleCountFlags	framebufferStencilSampleCounts;
204	VkSampleCountFlags	framebufferNoAttachmentsSampleCounts;
205	deUint32			maxColorAttachments;
206	VkSampleCountFlags	sampledImageColorSampleCounts;
207	VkSampleCountFlags	sampledImageIntegerSampleCounts;
208	VkSampleCountFlags	sampledImageDepthSampleCounts;
209	VkSampleCountFlags	sampledImageStencilSampleCounts;
210	VkSampleCountFlags	storageImageSampleCounts;
211	deUint32			maxSampleMaskWords;
212	VkBool32			timestampComputeAndGraphics;
213	float				timestampPeriod;
214	deUint32			maxClipDistances;
215	deUint32			maxCullDistances;
216	deUint32			maxCombinedClipAndCullDistances;
217	deUint32			discreteQueuePriorities;
218	float				pointSizeRange[2];
219	float				lineWidthRange[2];
220	float				pointSizeGranularity;
221	float				lineWidthGranularity;
222	VkBool32			strictLines;
223	VkBool32			standardSampleLocations;
224	VkDeviceSize		optimalBufferCopyOffsetAlignment;
225	VkDeviceSize		optimalBufferCopyRowPitchAlignment;
226	VkDeviceSize		nonCoherentAtomSize;
227};
228
229struct VkPhysicalDeviceSparseProperties
230{
231	VkBool32	residencyStandard2DBlockShape;
232	VkBool32	residencyStandard2DMultisampleBlockShape;
233	VkBool32	residencyStandard3DBlockShape;
234	VkBool32	residencyAlignedMipSize;
235	VkBool32	residencyNonResidentStrict;
236};
237
238struct VkPhysicalDeviceProperties
239{
240	deUint32							apiVersion;
241	deUint32							driverVersion;
242	deUint32							vendorID;
243	deUint32							deviceID;
244	VkPhysicalDeviceType				deviceType;
245	char								deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
246	deUint8								pipelineCacheUUID[VK_UUID_SIZE];
247	VkPhysicalDeviceLimits				limits;
248	VkPhysicalDeviceSparseProperties	sparseProperties;
249};
250
251struct VkQueueFamilyProperties
252{
253	VkQueueFlags	queueFlags;
254	deUint32		queueCount;
255	deUint32		timestampValidBits;
256	VkExtent3D		minImageTransferGranularity;
257};
258
259struct VkMemoryType
260{
261	VkMemoryPropertyFlags	propertyFlags;
262	deUint32				heapIndex;
263};
264
265struct VkMemoryHeap
266{
267	VkDeviceSize		size;
268	VkMemoryHeapFlags	flags;
269};
270
271struct VkPhysicalDeviceMemoryProperties
272{
273	deUint32		memoryTypeCount;
274	VkMemoryType	memoryTypes[VK_MAX_MEMORY_TYPES];
275	deUint32		memoryHeapCount;
276	VkMemoryHeap	memoryHeaps[VK_MAX_MEMORY_HEAPS];
277};
278
279struct VkDeviceQueueCreateInfo
280{
281	VkStructureType				sType;
282	const void*					pNext;
283	VkDeviceQueueCreateFlags	flags;
284	deUint32					queueFamilyIndex;
285	deUint32					queueCount;
286	const float*				pQueuePriorities;
287};
288
289struct VkDeviceCreateInfo
290{
291	VkStructureType					sType;
292	const void*						pNext;
293	VkDeviceCreateFlags				flags;
294	deUint32						queueCreateInfoCount;
295	const VkDeviceQueueCreateInfo*	pQueueCreateInfos;
296	deUint32						enabledLayerCount;
297	const char* const*				ppEnabledLayerNames;
298	deUint32						enabledExtensionCount;
299	const char* const*				ppEnabledExtensionNames;
300	const VkPhysicalDeviceFeatures*	pEnabledFeatures;
301};
302
303struct VkExtensionProperties
304{
305	char		extensionName[VK_MAX_EXTENSION_NAME_SIZE];
306	deUint32	specVersion;
307};
308
309struct VkLayerProperties
310{
311	char		layerName[VK_MAX_EXTENSION_NAME_SIZE];
312	deUint32	specVersion;
313	deUint32	implementationVersion;
314	char		description[VK_MAX_DESCRIPTION_SIZE];
315};
316
317struct VkSubmitInfo
318{
319	VkStructureType				sType;
320	const void*					pNext;
321	deUint32					waitSemaphoreCount;
322	const VkSemaphore*			pWaitSemaphores;
323	const VkPipelineStageFlags*	pWaitDstStageMask;
324	deUint32					commandBufferCount;
325	const VkCommandBuffer*		pCommandBuffers;
326	deUint32					signalSemaphoreCount;
327	const VkSemaphore*			pSignalSemaphores;
328};
329
330struct VkMemoryAllocateInfo
331{
332	VkStructureType	sType;
333	const void*		pNext;
334	VkDeviceSize	allocationSize;
335	deUint32		memoryTypeIndex;
336};
337
338struct VkMappedMemoryRange
339{
340	VkStructureType	sType;
341	const void*		pNext;
342	VkDeviceMemory	memory;
343	VkDeviceSize	offset;
344	VkDeviceSize	size;
345};
346
347struct VkMemoryRequirements
348{
349	VkDeviceSize	size;
350	VkDeviceSize	alignment;
351	deUint32		memoryTypeBits;
352};
353
354struct VkSparseImageFormatProperties
355{
356	VkImageAspectFlags			aspectMask;
357	VkExtent3D					imageGranularity;
358	VkSparseImageFormatFlags	flags;
359};
360
361struct VkSparseImageMemoryRequirements
362{
363	VkSparseImageFormatProperties	formatProperties;
364	deUint32						imageMipTailFirstLod;
365	VkDeviceSize					imageMipTailSize;
366	VkDeviceSize					imageMipTailOffset;
367	VkDeviceSize					imageMipTailStride;
368};
369
370struct VkSparseMemoryBind
371{
372	VkDeviceSize			resourceOffset;
373	VkDeviceSize			size;
374	VkDeviceMemory			memory;
375	VkDeviceSize			memoryOffset;
376	VkSparseMemoryBindFlags	flags;
377};
378
379struct VkSparseBufferMemoryBindInfo
380{
381	VkBuffer					buffer;
382	deUint32					bindCount;
383	const VkSparseMemoryBind*	pBinds;
384};
385
386struct VkSparseImageOpaqueMemoryBindInfo
387{
388	VkImage						image;
389	deUint32					bindCount;
390	const VkSparseMemoryBind*	pBinds;
391};
392
393struct VkImageSubresource
394{
395	VkImageAspectFlags	aspectMask;
396	deUint32			mipLevel;
397	deUint32			arrayLayer;
398};
399
400struct VkOffset3D
401{
402	deInt32	x;
403	deInt32	y;
404	deInt32	z;
405};
406
407struct VkSparseImageMemoryBind
408{
409	VkImageSubresource		subresource;
410	VkOffset3D				offset;
411	VkExtent3D				extent;
412	VkDeviceMemory			memory;
413	VkDeviceSize			memoryOffset;
414	VkSparseMemoryBindFlags	flags;
415};
416
417struct VkSparseImageMemoryBindInfo
418{
419	VkImage							image;
420	deUint32						bindCount;
421	const VkSparseImageMemoryBind*	pBinds;
422};
423
424struct VkBindSparseInfo
425{
426	VkStructureType								sType;
427	const void*									pNext;
428	deUint32									waitSemaphoreCount;
429	const VkSemaphore*							pWaitSemaphores;
430	deUint32									bufferBindCount;
431	const VkSparseBufferMemoryBindInfo*			pBufferBinds;
432	deUint32									imageOpaqueBindCount;
433	const VkSparseImageOpaqueMemoryBindInfo*	pImageOpaqueBinds;
434	deUint32									imageBindCount;
435	const VkSparseImageMemoryBindInfo*			pImageBinds;
436	deUint32									signalSemaphoreCount;
437	const VkSemaphore*							pSignalSemaphores;
438};
439
440struct VkFenceCreateInfo
441{
442	VkStructureType		sType;
443	const void*			pNext;
444	VkFenceCreateFlags	flags;
445};
446
447struct VkSemaphoreCreateInfo
448{
449	VkStructureType			sType;
450	const void*				pNext;
451	VkSemaphoreCreateFlags	flags;
452};
453
454struct VkEventCreateInfo
455{
456	VkStructureType		sType;
457	const void*			pNext;
458	VkEventCreateFlags	flags;
459};
460
461struct VkQueryPoolCreateInfo
462{
463	VkStructureType					sType;
464	const void*						pNext;
465	VkQueryPoolCreateFlags			flags;
466	VkQueryType						queryType;
467	deUint32						queryCount;
468	VkQueryPipelineStatisticFlags	pipelineStatistics;
469};
470
471struct VkBufferCreateInfo
472{
473	VkStructureType		sType;
474	const void*			pNext;
475	VkBufferCreateFlags	flags;
476	VkDeviceSize		size;
477	VkBufferUsageFlags	usage;
478	VkSharingMode		sharingMode;
479	deUint32			queueFamilyIndexCount;
480	const deUint32*		pQueueFamilyIndices;
481};
482
483struct VkBufferViewCreateInfo
484{
485	VkStructureType			sType;
486	const void*				pNext;
487	VkBufferViewCreateFlags	flags;
488	VkBuffer				buffer;
489	VkFormat				format;
490	VkDeviceSize			offset;
491	VkDeviceSize			range;
492};
493
494struct VkImageCreateInfo
495{
496	VkStructureType			sType;
497	const void*				pNext;
498	VkImageCreateFlags		flags;
499	VkImageType				imageType;
500	VkFormat				format;
501	VkExtent3D				extent;
502	deUint32				mipLevels;
503	deUint32				arrayLayers;
504	VkSampleCountFlagBits	samples;
505	VkImageTiling			tiling;
506	VkImageUsageFlags		usage;
507	VkSharingMode			sharingMode;
508	deUint32				queueFamilyIndexCount;
509	const deUint32*			pQueueFamilyIndices;
510	VkImageLayout			initialLayout;
511};
512
513struct VkSubresourceLayout
514{
515	VkDeviceSize	offset;
516	VkDeviceSize	size;
517	VkDeviceSize	rowPitch;
518	VkDeviceSize	arrayPitch;
519	VkDeviceSize	depthPitch;
520};
521
522struct VkComponentMapping
523{
524	VkComponentSwizzle	r;
525	VkComponentSwizzle	g;
526	VkComponentSwizzle	b;
527	VkComponentSwizzle	a;
528};
529
530struct VkImageSubresourceRange
531{
532	VkImageAspectFlags	aspectMask;
533	deUint32			baseMipLevel;
534	deUint32			levelCount;
535	deUint32			baseArrayLayer;
536	deUint32			layerCount;
537};
538
539struct VkImageViewCreateInfo
540{
541	VkStructureType			sType;
542	const void*				pNext;
543	VkImageViewCreateFlags	flags;
544	VkImage					image;
545	VkImageViewType			viewType;
546	VkFormat				format;
547	VkComponentMapping		components;
548	VkImageSubresourceRange	subresourceRange;
549};
550
551struct VkShaderModuleCreateInfo
552{
553	VkStructureType				sType;
554	const void*					pNext;
555	VkShaderModuleCreateFlags	flags;
556	deUintptr					codeSize;
557	const deUint32*				pCode;
558};
559
560struct VkPipelineCacheCreateInfo
561{
562	VkStructureType				sType;
563	const void*					pNext;
564	VkPipelineCacheCreateFlags	flags;
565	deUintptr					initialDataSize;
566	const void*					pInitialData;
567};
568
569struct VkSpecializationMapEntry
570{
571	deUint32	constantID;
572	deUint32	offset;
573	deUintptr	size;
574};
575
576struct VkSpecializationInfo
577{
578	deUint32						mapEntryCount;
579	const VkSpecializationMapEntry*	pMapEntries;
580	deUintptr						dataSize;
581	const void*						pData;
582};
583
584struct VkPipelineShaderStageCreateInfo
585{
586	VkStructureType						sType;
587	const void*							pNext;
588	VkPipelineShaderStageCreateFlags	flags;
589	VkShaderStageFlagBits				stage;
590	VkShaderModule						module;
591	const char*							pName;
592	const VkSpecializationInfo*			pSpecializationInfo;
593};
594
595struct VkVertexInputBindingDescription
596{
597	deUint32			binding;
598	deUint32			stride;
599	VkVertexInputRate	inputRate;
600};
601
602struct VkVertexInputAttributeDescription
603{
604	deUint32	location;
605	deUint32	binding;
606	VkFormat	format;
607	deUint32	offset;
608};
609
610struct VkPipelineVertexInputStateCreateInfo
611{
612	VkStructureType								sType;
613	const void*									pNext;
614	VkPipelineVertexInputStateCreateFlags		flags;
615	deUint32									vertexBindingDescriptionCount;
616	const VkVertexInputBindingDescription*		pVertexBindingDescriptions;
617	deUint32									vertexAttributeDescriptionCount;
618	const VkVertexInputAttributeDescription*	pVertexAttributeDescriptions;
619};
620
621struct VkPipelineInputAssemblyStateCreateInfo
622{
623	VkStructureType							sType;
624	const void*								pNext;
625	VkPipelineInputAssemblyStateCreateFlags	flags;
626	VkPrimitiveTopology						topology;
627	VkBool32								primitiveRestartEnable;
628};
629
630struct VkPipelineTessellationStateCreateInfo
631{
632	VkStructureType							sType;
633	const void*								pNext;
634	VkPipelineTessellationStateCreateFlags	flags;
635	deUint32								patchControlPoints;
636};
637
638struct VkViewport
639{
640	float	x;
641	float	y;
642	float	width;
643	float	height;
644	float	minDepth;
645	float	maxDepth;
646};
647
648struct VkOffset2D
649{
650	deInt32	x;
651	deInt32	y;
652};
653
654struct VkExtent2D
655{
656	deUint32	width;
657	deUint32	height;
658};
659
660struct VkRect2D
661{
662	VkOffset2D	offset;
663	VkExtent2D	extent;
664};
665
666struct VkPipelineViewportStateCreateInfo
667{
668	VkStructureType						sType;
669	const void*							pNext;
670	VkPipelineViewportStateCreateFlags	flags;
671	deUint32							viewportCount;
672	const VkViewport*					pViewports;
673	deUint32							scissorCount;
674	const VkRect2D*						pScissors;
675};
676
677struct VkPipelineRasterizationStateCreateInfo
678{
679	VkStructureType							sType;
680	const void*								pNext;
681	VkPipelineRasterizationStateCreateFlags	flags;
682	VkBool32								depthClampEnable;
683	VkBool32								rasterizerDiscardEnable;
684	VkPolygonMode							polygonMode;
685	VkCullModeFlags							cullMode;
686	VkFrontFace								frontFace;
687	VkBool32								depthBiasEnable;
688	float									depthBiasConstantFactor;
689	float									depthBiasClamp;
690	float									depthBiasSlopeFactor;
691	float									lineWidth;
692};
693
694struct VkPipelineMultisampleStateCreateInfo
695{
696	VkStructureType							sType;
697	const void*								pNext;
698	VkPipelineMultisampleStateCreateFlags	flags;
699	VkSampleCountFlagBits					rasterizationSamples;
700	VkBool32								sampleShadingEnable;
701	float									minSampleShading;
702	const VkSampleMask*						pSampleMask;
703	VkBool32								alphaToCoverageEnable;
704	VkBool32								alphaToOneEnable;
705};
706
707struct VkStencilOpState
708{
709	VkStencilOp	failOp;
710	VkStencilOp	passOp;
711	VkStencilOp	depthFailOp;
712	VkCompareOp	compareOp;
713	deUint32	compareMask;
714	deUint32	writeMask;
715	deUint32	reference;
716};
717
718struct VkPipelineDepthStencilStateCreateInfo
719{
720	VkStructureType							sType;
721	const void*								pNext;
722	VkPipelineDepthStencilStateCreateFlags	flags;
723	VkBool32								depthTestEnable;
724	VkBool32								depthWriteEnable;
725	VkCompareOp								depthCompareOp;
726	VkBool32								depthBoundsTestEnable;
727	VkBool32								stencilTestEnable;
728	VkStencilOpState						front;
729	VkStencilOpState						back;
730	float									minDepthBounds;
731	float									maxDepthBounds;
732};
733
734struct VkPipelineColorBlendAttachmentState
735{
736	VkBool32				blendEnable;
737	VkBlendFactor			srcColorBlendFactor;
738	VkBlendFactor			dstColorBlendFactor;
739	VkBlendOp				colorBlendOp;
740	VkBlendFactor			srcAlphaBlendFactor;
741	VkBlendFactor			dstAlphaBlendFactor;
742	VkBlendOp				alphaBlendOp;
743	VkColorComponentFlags	colorWriteMask;
744};
745
746struct VkPipelineColorBlendStateCreateInfo
747{
748	VkStructureType								sType;
749	const void*									pNext;
750	VkPipelineColorBlendStateCreateFlags		flags;
751	VkBool32									logicOpEnable;
752	VkLogicOp									logicOp;
753	deUint32									attachmentCount;
754	const VkPipelineColorBlendAttachmentState*	pAttachments;
755	float										blendConstants[4];
756};
757
758struct VkPipelineDynamicStateCreateInfo
759{
760	VkStructureType						sType;
761	const void*							pNext;
762	VkPipelineDynamicStateCreateFlags	flags;
763	deUint32							dynamicStateCount;
764	const VkDynamicState*				pDynamicStates;
765};
766
767struct VkGraphicsPipelineCreateInfo
768{
769	VkStructureType									sType;
770	const void*										pNext;
771	VkPipelineCreateFlags							flags;
772	deUint32										stageCount;
773	const VkPipelineShaderStageCreateInfo*			pStages;
774	const VkPipelineVertexInputStateCreateInfo*		pVertexInputState;
775	const VkPipelineInputAssemblyStateCreateInfo*	pInputAssemblyState;
776	const VkPipelineTessellationStateCreateInfo*	pTessellationState;
777	const VkPipelineViewportStateCreateInfo*		pViewportState;
778	const VkPipelineRasterizationStateCreateInfo*	pRasterizationState;
779	const VkPipelineMultisampleStateCreateInfo*		pMultisampleState;
780	const VkPipelineDepthStencilStateCreateInfo*	pDepthStencilState;
781	const VkPipelineColorBlendStateCreateInfo*		pColorBlendState;
782	const VkPipelineDynamicStateCreateInfo*			pDynamicState;
783	VkPipelineLayout								layout;
784	VkRenderPass									renderPass;
785	deUint32										subpass;
786	VkPipeline										basePipelineHandle;
787	deInt32											basePipelineIndex;
788};
789
790struct VkComputePipelineCreateInfo
791{
792	VkStructureType					sType;
793	const void*						pNext;
794	VkPipelineCreateFlags			flags;
795	VkPipelineShaderStageCreateInfo	stage;
796	VkPipelineLayout				layout;
797	VkPipeline						basePipelineHandle;
798	deInt32							basePipelineIndex;
799};
800
801struct VkPushConstantRange
802{
803	VkShaderStageFlags	stageFlags;
804	deUint32			offset;
805	deUint32			size;
806};
807
808struct VkPipelineLayoutCreateInfo
809{
810	VkStructureType					sType;
811	const void*						pNext;
812	VkPipelineLayoutCreateFlags		flags;
813	deUint32						setLayoutCount;
814	const VkDescriptorSetLayout*	pSetLayouts;
815	deUint32						pushConstantRangeCount;
816	const VkPushConstantRange*		pPushConstantRanges;
817};
818
819struct VkSamplerCreateInfo
820{
821	VkStructureType			sType;
822	const void*				pNext;
823	VkSamplerCreateFlags	flags;
824	VkFilter				magFilter;
825	VkFilter				minFilter;
826	VkSamplerMipmapMode		mipmapMode;
827	VkSamplerAddressMode	addressModeU;
828	VkSamplerAddressMode	addressModeV;
829	VkSamplerAddressMode	addressModeW;
830	float					mipLodBias;
831	VkBool32				anisotropyEnable;
832	float					maxAnisotropy;
833	VkBool32				compareEnable;
834	VkCompareOp				compareOp;
835	float					minLod;
836	float					maxLod;
837	VkBorderColor			borderColor;
838	VkBool32				unnormalizedCoordinates;
839};
840
841struct VkDescriptorSetLayoutBinding
842{
843	deUint32			binding;
844	VkDescriptorType	descriptorType;
845	deUint32			descriptorCount;
846	VkShaderStageFlags	stageFlags;
847	const VkSampler*	pImmutableSamplers;
848};
849
850struct VkDescriptorSetLayoutCreateInfo
851{
852	VkStructureType						sType;
853	const void*							pNext;
854	VkDescriptorSetLayoutCreateFlags	flags;
855	deUint32							bindingCount;
856	const VkDescriptorSetLayoutBinding*	pBindings;
857};
858
859struct VkDescriptorPoolSize
860{
861	VkDescriptorType	type;
862	deUint32			descriptorCount;
863};
864
865struct VkDescriptorPoolCreateInfo
866{
867	VkStructureType				sType;
868	const void*					pNext;
869	VkDescriptorPoolCreateFlags	flags;
870	deUint32					maxSets;
871	deUint32					poolSizeCount;
872	const VkDescriptorPoolSize*	pPoolSizes;
873};
874
875struct VkDescriptorSetAllocateInfo
876{
877	VkStructureType					sType;
878	const void*						pNext;
879	VkDescriptorPool				descriptorPool;
880	deUint32						descriptorSetCount;
881	const VkDescriptorSetLayout*	pSetLayouts;
882};
883
884struct VkDescriptorImageInfo
885{
886	VkSampler		sampler;
887	VkImageView		imageView;
888	VkImageLayout	imageLayout;
889};
890
891struct VkDescriptorBufferInfo
892{
893	VkBuffer		buffer;
894	VkDeviceSize	offset;
895	VkDeviceSize	range;
896};
897
898struct VkWriteDescriptorSet
899{
900	VkStructureType					sType;
901	const void*						pNext;
902	VkDescriptorSet					dstSet;
903	deUint32						dstBinding;
904	deUint32						dstArrayElement;
905	deUint32						descriptorCount;
906	VkDescriptorType				descriptorType;
907	const VkDescriptorImageInfo*	pImageInfo;
908	const VkDescriptorBufferInfo*	pBufferInfo;
909	const VkBufferView*				pTexelBufferView;
910};
911
912struct VkCopyDescriptorSet
913{
914	VkStructureType	sType;
915	const void*		pNext;
916	VkDescriptorSet	srcSet;
917	deUint32		srcBinding;
918	deUint32		srcArrayElement;
919	VkDescriptorSet	dstSet;
920	deUint32		dstBinding;
921	deUint32		dstArrayElement;
922	deUint32		descriptorCount;
923};
924
925struct VkFramebufferCreateInfo
926{
927	VkStructureType				sType;
928	const void*					pNext;
929	VkFramebufferCreateFlags	flags;
930	VkRenderPass				renderPass;
931	deUint32					attachmentCount;
932	const VkImageView*			pAttachments;
933	deUint32					width;
934	deUint32					height;
935	deUint32					layers;
936};
937
938struct VkAttachmentDescription
939{
940	VkAttachmentDescriptionFlags	flags;
941	VkFormat						format;
942	VkSampleCountFlagBits			samples;
943	VkAttachmentLoadOp				loadOp;
944	VkAttachmentStoreOp				storeOp;
945	VkAttachmentLoadOp				stencilLoadOp;
946	VkAttachmentStoreOp				stencilStoreOp;
947	VkImageLayout					initialLayout;
948	VkImageLayout					finalLayout;
949};
950
951struct VkAttachmentReference
952{
953	deUint32		attachment;
954	VkImageLayout	layout;
955};
956
957struct VkSubpassDescription
958{
959	VkSubpassDescriptionFlags		flags;
960	VkPipelineBindPoint				pipelineBindPoint;
961	deUint32						inputAttachmentCount;
962	const VkAttachmentReference*	pInputAttachments;
963	deUint32						colorAttachmentCount;
964	const VkAttachmentReference*	pColorAttachments;
965	const VkAttachmentReference*	pResolveAttachments;
966	const VkAttachmentReference*	pDepthStencilAttachment;
967	deUint32						preserveAttachmentCount;
968	const deUint32*					pPreserveAttachments;
969};
970
971struct VkSubpassDependency
972{
973	deUint32				srcSubpass;
974	deUint32				dstSubpass;
975	VkPipelineStageFlags	srcStageMask;
976	VkPipelineStageFlags	dstStageMask;
977	VkAccessFlags			srcAccessMask;
978	VkAccessFlags			dstAccessMask;
979	VkDependencyFlags		dependencyFlags;
980};
981
982struct VkRenderPassCreateInfo
983{
984	VkStructureType					sType;
985	const void*						pNext;
986	VkRenderPassCreateFlags			flags;
987	deUint32						attachmentCount;
988	const VkAttachmentDescription*	pAttachments;
989	deUint32						subpassCount;
990	const VkSubpassDescription*		pSubpasses;
991	deUint32						dependencyCount;
992	const VkSubpassDependency*		pDependencies;
993};
994
995struct VkCommandPoolCreateInfo
996{
997	VkStructureType				sType;
998	const void*					pNext;
999	VkCommandPoolCreateFlags	flags;
1000	deUint32					queueFamilyIndex;
1001};
1002
1003struct VkCommandBufferAllocateInfo
1004{
1005	VkStructureType			sType;
1006	const void*				pNext;
1007	VkCommandPool			commandPool;
1008	VkCommandBufferLevel	level;
1009	deUint32				commandBufferCount;
1010};
1011
1012struct VkCommandBufferInheritanceInfo
1013{
1014	VkStructureType					sType;
1015	const void*						pNext;
1016	VkRenderPass					renderPass;
1017	deUint32						subpass;
1018	VkFramebuffer					framebuffer;
1019	VkBool32						occlusionQueryEnable;
1020	VkQueryControlFlags				queryFlags;
1021	VkQueryPipelineStatisticFlags	pipelineStatistics;
1022};
1023
1024struct VkCommandBufferBeginInfo
1025{
1026	VkStructureType							sType;
1027	const void*								pNext;
1028	VkCommandBufferUsageFlags				flags;
1029	const VkCommandBufferInheritanceInfo*	pInheritanceInfo;
1030};
1031
1032struct VkBufferCopy
1033{
1034	VkDeviceSize	srcOffset;
1035	VkDeviceSize	dstOffset;
1036	VkDeviceSize	size;
1037};
1038
1039struct VkImageSubresourceLayers
1040{
1041	VkImageAspectFlags	aspectMask;
1042	deUint32			mipLevel;
1043	deUint32			baseArrayLayer;
1044	deUint32			layerCount;
1045};
1046
1047struct VkImageCopy
1048{
1049	VkImageSubresourceLayers	srcSubresource;
1050	VkOffset3D					srcOffset;
1051	VkImageSubresourceLayers	dstSubresource;
1052	VkOffset3D					dstOffset;
1053	VkExtent3D					extent;
1054};
1055
1056struct VkImageBlit
1057{
1058	VkImageSubresourceLayers	srcSubresource;
1059	VkOffset3D					srcOffsets[2];
1060	VkImageSubresourceLayers	dstSubresource;
1061	VkOffset3D					dstOffsets[2];
1062};
1063
1064struct VkBufferImageCopy
1065{
1066	VkDeviceSize				bufferOffset;
1067	deUint32					bufferRowLength;
1068	deUint32					bufferImageHeight;
1069	VkImageSubresourceLayers	imageSubresource;
1070	VkOffset3D					imageOffset;
1071	VkExtent3D					imageExtent;
1072};
1073
1074union VkClearColorValue
1075{
1076	float		float32[4];
1077	deInt32		int32[4];
1078	deUint32	uint32[4];
1079};
1080
1081struct VkClearDepthStencilValue
1082{
1083	float		depth;
1084	deUint32	stencil;
1085};
1086
1087union VkClearValue
1088{
1089	VkClearColorValue			color;
1090	VkClearDepthStencilValue	depthStencil;
1091};
1092
1093struct VkClearAttachment
1094{
1095	VkImageAspectFlags	aspectMask;
1096	deUint32			colorAttachment;
1097	VkClearValue		clearValue;
1098};
1099
1100struct VkClearRect
1101{
1102	VkRect2D	rect;
1103	deUint32	baseArrayLayer;
1104	deUint32	layerCount;
1105};
1106
1107struct VkImageResolve
1108{
1109	VkImageSubresourceLayers	srcSubresource;
1110	VkOffset3D					srcOffset;
1111	VkImageSubresourceLayers	dstSubresource;
1112	VkOffset3D					dstOffset;
1113	VkExtent3D					extent;
1114};
1115
1116struct VkMemoryBarrier
1117{
1118	VkStructureType	sType;
1119	const void*		pNext;
1120	VkAccessFlags	srcAccessMask;
1121	VkAccessFlags	dstAccessMask;
1122};
1123
1124struct VkBufferMemoryBarrier
1125{
1126	VkStructureType	sType;
1127	const void*		pNext;
1128	VkAccessFlags	srcAccessMask;
1129	VkAccessFlags	dstAccessMask;
1130	deUint32		srcQueueFamilyIndex;
1131	deUint32		dstQueueFamilyIndex;
1132	VkBuffer		buffer;
1133	VkDeviceSize	offset;
1134	VkDeviceSize	size;
1135};
1136
1137struct VkImageMemoryBarrier
1138{
1139	VkStructureType			sType;
1140	const void*				pNext;
1141	VkAccessFlags			srcAccessMask;
1142	VkAccessFlags			dstAccessMask;
1143	VkImageLayout			oldLayout;
1144	VkImageLayout			newLayout;
1145	deUint32				srcQueueFamilyIndex;
1146	deUint32				dstQueueFamilyIndex;
1147	VkImage					image;
1148	VkImageSubresourceRange	subresourceRange;
1149};
1150
1151struct VkRenderPassBeginInfo
1152{
1153	VkStructureType		sType;
1154	const void*			pNext;
1155	VkRenderPass		renderPass;
1156	VkFramebuffer		framebuffer;
1157	VkRect2D			renderArea;
1158	deUint32			clearValueCount;
1159	const VkClearValue*	pClearValues;
1160};
1161
1162struct VkDispatchIndirectCommand
1163{
1164	deUint32	x;
1165	deUint32	y;
1166	deUint32	z;
1167};
1168
1169struct VkDrawIndexedIndirectCommand
1170{
1171	deUint32	indexCount;
1172	deUint32	instanceCount;
1173	deUint32	firstIndex;
1174	deInt32		vertexOffset;
1175	deUint32	firstInstance;
1176};
1177
1178struct VkDrawIndirectCommand
1179{
1180	deUint32	vertexCount;
1181	deUint32	instanceCount;
1182	deUint32	firstVertex;
1183	deUint32	firstInstance;
1184};
1185
1186struct VkSurfaceCapabilitiesKHR
1187{
1188	deUint32						minImageCount;
1189	deUint32						maxImageCount;
1190	VkExtent2D						currentExtent;
1191	VkExtent2D						minImageExtent;
1192	VkExtent2D						maxImageExtent;
1193	deUint32						maxImageArrayLayers;
1194	VkSurfaceTransformFlagsKHR		supportedTransforms;
1195	VkSurfaceTransformFlagBitsKHR	currentTransform;
1196	VkCompositeAlphaFlagsKHR		supportedCompositeAlpha;
1197	VkImageUsageFlags				supportedUsageFlags;
1198};
1199
1200struct VkSurfaceFormatKHR
1201{
1202	VkFormat		format;
1203	VkColorSpaceKHR	colorSpace;
1204};
1205
1206struct VkSwapchainCreateInfoKHR
1207{
1208	VkStructureType					sType;
1209	const void*						pNext;
1210	VkSwapchainCreateFlagsKHR		flags;
1211	VkSurfaceKHR					surface;
1212	deUint32						minImageCount;
1213	VkFormat						imageFormat;
1214	VkColorSpaceKHR					imageColorSpace;
1215	VkExtent2D						imageExtent;
1216	deUint32						imageArrayLayers;
1217	VkImageUsageFlags				imageUsage;
1218	VkSharingMode					imageSharingMode;
1219	deUint32						queueFamilyIndexCount;
1220	const deUint32*					pQueueFamilyIndices;
1221	VkSurfaceTransformFlagBitsKHR	preTransform;
1222	VkCompositeAlphaFlagBitsKHR		compositeAlpha;
1223	VkPresentModeKHR				presentMode;
1224	VkBool32						clipped;
1225	VkSwapchainKHR					oldSwapchain;
1226};
1227
1228struct VkPresentInfoKHR
1229{
1230	VkStructureType			sType;
1231	const void*				pNext;
1232	deUint32				waitSemaphoreCount;
1233	const VkSemaphore*		pWaitSemaphores;
1234	deUint32				swapchainCount;
1235	const VkSwapchainKHR*	pSwapchains;
1236	const deUint32*			pImageIndices;
1237	VkResult*				pResults;
1238};
1239
1240struct VkDisplayPropertiesKHR
1241{
1242	VkDisplayKHR				display;
1243	const char*					displayName;
1244	VkExtent2D					physicalDimensions;
1245	VkExtent2D					physicalResolution;
1246	VkSurfaceTransformFlagsKHR	supportedTransforms;
1247	VkBool32					planeReorderPossible;
1248	VkBool32					persistentContent;
1249};
1250
1251struct VkDisplayModeParametersKHR
1252{
1253	VkExtent2D	visibleRegion;
1254	deUint32	refreshRate;
1255};
1256
1257struct VkDisplayModePropertiesKHR
1258{
1259	VkDisplayModeKHR			displayMode;
1260	VkDisplayModeParametersKHR	parameters;
1261};
1262
1263struct VkDisplayModeCreateInfoKHR
1264{
1265	VkStructureType				sType;
1266	const void*					pNext;
1267	VkDisplayModeCreateFlagsKHR	flags;
1268	VkDisplayModeParametersKHR	parameters;
1269};
1270
1271struct VkDisplayPlaneCapabilitiesKHR
1272{
1273	VkDisplayPlaneAlphaFlagsKHR	supportedAlpha;
1274	VkOffset2D					minSrcPosition;
1275	VkOffset2D					maxSrcPosition;
1276	VkExtent2D					minSrcExtent;
1277	VkExtent2D					maxSrcExtent;
1278	VkOffset2D					minDstPosition;
1279	VkOffset2D					maxDstPosition;
1280	VkExtent2D					minDstExtent;
1281	VkExtent2D					maxDstExtent;
1282};
1283
1284struct VkDisplayPlanePropertiesKHR
1285{
1286	VkDisplayKHR	currentDisplay;
1287	deUint32		currentStackIndex;
1288};
1289
1290struct VkDisplaySurfaceCreateInfoKHR
1291{
1292	VkStructureType					sType;
1293	const void*						pNext;
1294	VkDisplaySurfaceCreateFlagsKHR	flags;
1295	VkDisplayModeKHR				displayMode;
1296	deUint32						planeIndex;
1297	deUint32						planeStackIndex;
1298	VkSurfaceTransformFlagBitsKHR	transform;
1299	float							globalAlpha;
1300	VkDisplayPlaneAlphaFlagBitsKHR	alphaMode;
1301	VkExtent2D						imageExtent;
1302};
1303
1304struct VkDisplayPresentInfoKHR
1305{
1306	VkStructureType	sType;
1307	const void*		pNext;
1308	VkRect2D		srcRect;
1309	VkRect2D		dstRect;
1310	VkBool32		persistent;
1311};
1312
1313struct VkXlibSurfaceCreateInfoKHR
1314{
1315	VkStructureType				sType;
1316	const void*					pNext;
1317	VkXlibSurfaceCreateFlagsKHR	flags;
1318	pt::XlibDisplayPtr			dpy;
1319	pt::XlibWindow				window;
1320};
1321
1322struct VkXcbSurfaceCreateInfoKHR
1323{
1324	VkStructureType				sType;
1325	const void*					pNext;
1326	VkXcbSurfaceCreateFlagsKHR	flags;
1327	pt::XcbConnectionPtr		connection;
1328	pt::XcbWindow				window;
1329};
1330
1331struct VkWaylandSurfaceCreateInfoKHR
1332{
1333	VkStructureType					sType;
1334	const void*						pNext;
1335	VkWaylandSurfaceCreateFlagsKHR	flags;
1336	pt::WaylandDisplayPtr			display;
1337	pt::WaylandSurfacePtr			surface;
1338};
1339
1340struct VkMirSurfaceCreateInfoKHR
1341{
1342	VkStructureType				sType;
1343	const void*					pNext;
1344	VkMirSurfaceCreateFlagsKHR	flags;
1345	pt::MirConnectionPtr		connection;
1346	pt::MirSurfacePtr			mirSurface;
1347};
1348
1349struct VkAndroidSurfaceCreateInfoKHR
1350{
1351	VkStructureType					sType;
1352	const void*						pNext;
1353	VkAndroidSurfaceCreateFlagsKHR	flags;
1354	pt::AndroidNativeWindowPtr		window;
1355};
1356
1357struct VkWin32SurfaceCreateInfoKHR
1358{
1359	VkStructureType					sType;
1360	const void*						pNext;
1361	VkWin32SurfaceCreateFlagsKHR	flags;
1362	pt::Win32InstanceHandle			hinstance;
1363	pt::Win32WindowHandle			hwnd;
1364};
1365
1366struct VkDebugReportCallbackCreateInfoEXT
1367{
1368	VkStructureType					sType;
1369	const void*						pNext;
1370	VkDebugReportFlagsEXT			flags;
1371	PFN_vkDebugReportCallbackEXT	pfnCallback;
1372	void*							pUserData;
1373};
1374
1375