• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 VkPhysicalDeviceSubgroupProperties
1187{
1188	VkStructureType			sType;
1189	void*					pNext;
1190	deUint32				subgroupSize;
1191	VkShaderStageFlags		supportedStages;
1192	VkSubgroupFeatureFlags	supportedOperations;
1193	VkBool32				quadOperationsInAllStages;
1194};
1195
1196struct VkBindBufferMemoryInfo
1197{
1198	VkStructureType	sType;
1199	const void*		pNext;
1200	VkBuffer		buffer;
1201	VkDeviceMemory	memory;
1202	VkDeviceSize	memoryOffset;
1203};
1204
1205struct VkBindImageMemoryInfo
1206{
1207	VkStructureType	sType;
1208	const void*		pNext;
1209	VkImage			image;
1210	VkDeviceMemory	memory;
1211	VkDeviceSize	memoryOffset;
1212};
1213
1214struct VkPhysicalDevice16BitStorageFeatures
1215{
1216	VkStructureType	sType;
1217	void*			pNext;
1218	VkBool32		storageBuffer16BitAccess;
1219	VkBool32		uniformAndStorageBuffer16BitAccess;
1220	VkBool32		storagePushConstant16;
1221	VkBool32		storageInputOutput16;
1222};
1223
1224struct VkMemoryDedicatedRequirements
1225{
1226	VkStructureType	sType;
1227	void*			pNext;
1228	VkBool32		prefersDedicatedAllocation;
1229	VkBool32		requiresDedicatedAllocation;
1230};
1231
1232struct VkMemoryDedicatedAllocateInfo
1233{
1234	VkStructureType	sType;
1235	const void*		pNext;
1236	VkImage			image;
1237	VkBuffer		buffer;
1238};
1239
1240struct VkMemoryAllocateFlagsInfo
1241{
1242	VkStructureType			sType;
1243	const void*				pNext;
1244	VkMemoryAllocateFlags	flags;
1245	deUint32				deviceMask;
1246};
1247
1248struct VkDeviceGroupRenderPassBeginInfo
1249{
1250	VkStructureType	sType;
1251	const void*		pNext;
1252	deUint32		deviceMask;
1253	deUint32		deviceRenderAreaCount;
1254	const VkRect2D*	pDeviceRenderAreas;
1255};
1256
1257struct VkDeviceGroupCommandBufferBeginInfo
1258{
1259	VkStructureType	sType;
1260	const void*		pNext;
1261	deUint32		deviceMask;
1262};
1263
1264struct VkDeviceGroupSubmitInfo
1265{
1266	VkStructureType	sType;
1267	const void*		pNext;
1268	deUint32		waitSemaphoreCount;
1269	const deUint32*	pWaitSemaphoreDeviceIndices;
1270	deUint32		commandBufferCount;
1271	const deUint32*	pCommandBufferDeviceMasks;
1272	deUint32		signalSemaphoreCount;
1273	const deUint32*	pSignalSemaphoreDeviceIndices;
1274};
1275
1276struct VkDeviceGroupBindSparseInfo
1277{
1278	VkStructureType	sType;
1279	const void*		pNext;
1280	deUint32		resourceDeviceIndex;
1281	deUint32		memoryDeviceIndex;
1282};
1283
1284struct VkBindBufferMemoryDeviceGroupInfo
1285{
1286	VkStructureType	sType;
1287	const void*		pNext;
1288	deUint32		deviceIndexCount;
1289	const deUint32*	pDeviceIndices;
1290};
1291
1292struct VkBindImageMemoryDeviceGroupInfo
1293{
1294	VkStructureType	sType;
1295	const void*		pNext;
1296	deUint32		deviceIndexCount;
1297	const deUint32*	pDeviceIndices;
1298	deUint32		SFRRectCount;
1299	const VkRect2D*	pSFRRects;
1300};
1301
1302struct VkPhysicalDeviceGroupProperties
1303{
1304	VkStructureType		sType;
1305	void*				pNext;
1306	deUint32			physicalDeviceCount;
1307	VkPhysicalDevice	physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
1308	VkBool32			subsetAllocation;
1309};
1310
1311struct VkDeviceGroupDeviceCreateInfo
1312{
1313	VkStructureType			sType;
1314	const void*				pNext;
1315	deUint32				physicalDeviceCount;
1316	const VkPhysicalDevice*	pPhysicalDevices;
1317};
1318
1319struct VkBufferMemoryRequirementsInfo2
1320{
1321	VkStructureType	sType;
1322	const void*		pNext;
1323	VkBuffer		buffer;
1324};
1325
1326struct VkImageMemoryRequirementsInfo2
1327{
1328	VkStructureType	sType;
1329	const void*		pNext;
1330	VkImage			image;
1331};
1332
1333struct VkImageSparseMemoryRequirementsInfo2
1334{
1335	VkStructureType	sType;
1336	const void*		pNext;
1337	VkImage			image;
1338};
1339
1340struct VkMemoryRequirements2
1341{
1342	VkStructureType			sType;
1343	void*					pNext;
1344	VkMemoryRequirements	memoryRequirements;
1345};
1346
1347struct VkSparseImageMemoryRequirements2
1348{
1349	VkStructureType					sType;
1350	void*							pNext;
1351	VkSparseImageMemoryRequirements	memoryRequirements;
1352};
1353
1354struct VkPhysicalDeviceFeatures2
1355{
1356	VkStructureType				sType;
1357	void*						pNext;
1358	VkPhysicalDeviceFeatures	features;
1359};
1360
1361struct VkPhysicalDeviceProperties2
1362{
1363	VkStructureType				sType;
1364	void*						pNext;
1365	VkPhysicalDeviceProperties	properties;
1366};
1367
1368struct VkFormatProperties2
1369{
1370	VkStructureType		sType;
1371	void*				pNext;
1372	VkFormatProperties	formatProperties;
1373};
1374
1375struct VkImageFormatProperties2
1376{
1377	VkStructureType			sType;
1378	void*					pNext;
1379	VkImageFormatProperties	imageFormatProperties;
1380};
1381
1382struct VkPhysicalDeviceImageFormatInfo2
1383{
1384	VkStructureType		sType;
1385	const void*			pNext;
1386	VkFormat			format;
1387	VkImageType			type;
1388	VkImageTiling		tiling;
1389	VkImageUsageFlags	usage;
1390	VkImageCreateFlags	flags;
1391};
1392
1393struct VkQueueFamilyProperties2
1394{
1395	VkStructureType			sType;
1396	void*					pNext;
1397	VkQueueFamilyProperties	queueFamilyProperties;
1398};
1399
1400struct VkPhysicalDeviceMemoryProperties2
1401{
1402	VkStructureType						sType;
1403	void*								pNext;
1404	VkPhysicalDeviceMemoryProperties	memoryProperties;
1405};
1406
1407struct VkSparseImageFormatProperties2
1408{
1409	VkStructureType					sType;
1410	void*							pNext;
1411	VkSparseImageFormatProperties	properties;
1412};
1413
1414struct VkPhysicalDeviceSparseImageFormatInfo2
1415{
1416	VkStructureType			sType;
1417	const void*				pNext;
1418	VkFormat				format;
1419	VkImageType				type;
1420	VkSampleCountFlagBits	samples;
1421	VkImageUsageFlags		usage;
1422	VkImageTiling			tiling;
1423};
1424
1425struct VkPhysicalDevicePointClippingProperties
1426{
1427	VkStructureType			sType;
1428	void*					pNext;
1429	VkPointClippingBehavior	pointClippingBehavior;
1430};
1431
1432struct VkInputAttachmentAspectReference
1433{
1434	deUint32			subpass;
1435	deUint32			inputAttachmentIndex;
1436	VkImageAspectFlags	aspectMask;
1437};
1438
1439struct VkRenderPassInputAttachmentAspectCreateInfo
1440{
1441	VkStructureType							sType;
1442	const void*								pNext;
1443	deUint32								aspectReferenceCount;
1444	const VkInputAttachmentAspectReference*	pAspectReferences;
1445};
1446
1447struct VkImageViewUsageCreateInfo
1448{
1449	VkStructureType		sType;
1450	const void*			pNext;
1451	VkImageUsageFlags	usage;
1452};
1453
1454struct VkPipelineTessellationDomainOriginStateCreateInfo
1455{
1456	VkStructureType				sType;
1457	const void*					pNext;
1458	VkTessellationDomainOrigin	domainOrigin;
1459};
1460
1461struct VkRenderPassMultiviewCreateInfo
1462{
1463	VkStructureType	sType;
1464	const void*		pNext;
1465	deUint32		subpassCount;
1466	const deUint32*	pViewMasks;
1467	deUint32		dependencyCount;
1468	const deInt32*	pViewOffsets;
1469	deUint32		correlationMaskCount;
1470	const deUint32*	pCorrelationMasks;
1471};
1472
1473struct VkPhysicalDeviceMultiviewFeatures
1474{
1475	VkStructureType	sType;
1476	void*			pNext;
1477	VkBool32		multiview;
1478	VkBool32		multiviewGeometryShader;
1479	VkBool32		multiviewTessellationShader;
1480};
1481
1482struct VkPhysicalDeviceMultiviewProperties
1483{
1484	VkStructureType	sType;
1485	void*			pNext;
1486	deUint32		maxMultiviewViewCount;
1487	deUint32		maxMultiviewInstanceIndex;
1488};
1489
1490struct VkPhysicalDeviceVariablePointerFeatures
1491{
1492	VkStructureType	sType;
1493	void*			pNext;
1494	VkBool32		variablePointersStorageBuffer;
1495	VkBool32		variablePointers;
1496};
1497
1498struct VkPhysicalDeviceProtectedMemoryFeatures
1499{
1500	VkStructureType	sType;
1501	void*			pNext;
1502	VkBool32		protectedMemory;
1503};
1504
1505struct VkPhysicalDeviceProtectedMemoryProperties
1506{
1507	VkStructureType	sType;
1508	void*			pNext;
1509	VkBool32		protectedNoFault;
1510};
1511
1512struct VkDeviceQueueInfo2
1513{
1514	VkStructureType				sType;
1515	const void*					pNext;
1516	VkDeviceQueueCreateFlags	flags;
1517	deUint32					queueFamilyIndex;
1518	deUint32					queueIndex;
1519};
1520
1521struct VkProtectedSubmitInfo
1522{
1523	VkStructureType	sType;
1524	const void*		pNext;
1525	VkBool32		protectedSubmit;
1526};
1527
1528struct VkSamplerYcbcrConversionCreateInfo
1529{
1530	VkStructureType					sType;
1531	const void*						pNext;
1532	VkFormat						format;
1533	VkSamplerYcbcrModelConversion	ycbcrModel;
1534	VkSamplerYcbcrRange				ycbcrRange;
1535	VkComponentMapping				components;
1536	VkChromaLocation				xChromaOffset;
1537	VkChromaLocation				yChromaOffset;
1538	VkFilter						chromaFilter;
1539	VkBool32						forceExplicitReconstruction;
1540};
1541
1542struct VkSamplerYcbcrConversionInfo
1543{
1544	VkStructureType				sType;
1545	const void*					pNext;
1546	VkSamplerYcbcrConversion	conversion;
1547};
1548
1549struct VkBindImagePlaneMemoryInfo
1550{
1551	VkStructureType			sType;
1552	const void*				pNext;
1553	VkImageAspectFlagBits	planeAspect;
1554};
1555
1556struct VkImagePlaneMemoryRequirementsInfo
1557{
1558	VkStructureType			sType;
1559	const void*				pNext;
1560	VkImageAspectFlagBits	planeAspect;
1561};
1562
1563struct VkPhysicalDeviceSamplerYcbcrConversionFeatures
1564{
1565	VkStructureType	sType;
1566	void*			pNext;
1567	VkBool32		samplerYcbcrConversion;
1568};
1569
1570struct VkSamplerYcbcrConversionImageFormatProperties
1571{
1572	VkStructureType	sType;
1573	void*			pNext;
1574	deUint32		combinedImageSamplerDescriptorCount;
1575};
1576
1577struct VkDescriptorUpdateTemplateEntry
1578{
1579	deUint32			dstBinding;
1580	deUint32			dstArrayElement;
1581	deUint32			descriptorCount;
1582	VkDescriptorType	descriptorType;
1583	deUintptr			offset;
1584	deUintptr			stride;
1585};
1586
1587struct VkDescriptorUpdateTemplateCreateInfo
1588{
1589	VkStructureType							sType;
1590	void*									pNext;
1591	VkDescriptorUpdateTemplateCreateFlags	flags;
1592	deUint32								descriptorUpdateEntryCount;
1593	const VkDescriptorUpdateTemplateEntry*	pDescriptorUpdateEntries;
1594	VkDescriptorUpdateTemplateType			templateType;
1595	VkDescriptorSetLayout					descriptorSetLayout;
1596	VkPipelineBindPoint						pipelineBindPoint;
1597	VkPipelineLayout						pipelineLayout;
1598	deUint32								set;
1599};
1600
1601struct VkExternalMemoryProperties
1602{
1603	VkExternalMemoryFeatureFlags	externalMemoryFeatures;
1604	VkExternalMemoryHandleTypeFlags	exportFromImportedHandleTypes;
1605	VkExternalMemoryHandleTypeFlags	compatibleHandleTypes;
1606};
1607
1608struct VkPhysicalDeviceExternalImageFormatInfo
1609{
1610	VkStructureType						sType;
1611	const void*							pNext;
1612	VkExternalMemoryHandleTypeFlagBits	handleType;
1613};
1614
1615struct VkExternalImageFormatProperties
1616{
1617	VkStructureType				sType;
1618	void*						pNext;
1619	VkExternalMemoryProperties	externalMemoryProperties;
1620};
1621
1622struct VkPhysicalDeviceExternalBufferInfo
1623{
1624	VkStructureType						sType;
1625	const void*							pNext;
1626	VkBufferCreateFlags					flags;
1627	VkBufferUsageFlags					usage;
1628	VkExternalMemoryHandleTypeFlagBits	handleType;
1629};
1630
1631struct VkExternalBufferProperties
1632{
1633	VkStructureType				sType;
1634	void*						pNext;
1635	VkExternalMemoryProperties	externalMemoryProperties;
1636};
1637
1638struct VkPhysicalDeviceIDProperties
1639{
1640	VkStructureType	sType;
1641	void*			pNext;
1642	deUint8			deviceUUID[VK_UUID_SIZE];
1643	deUint8			driverUUID[VK_UUID_SIZE];
1644	deUint8			deviceLUID[VK_LUID_SIZE];
1645	deUint32		deviceNodeMask;
1646	VkBool32		deviceLUIDValid;
1647};
1648
1649struct VkExternalMemoryImageCreateInfo
1650{
1651	VkStructureType					sType;
1652	const void*						pNext;
1653	VkExternalMemoryHandleTypeFlags	handleTypes;
1654};
1655
1656struct VkExternalMemoryBufferCreateInfo
1657{
1658	VkStructureType					sType;
1659	const void*						pNext;
1660	VkExternalMemoryHandleTypeFlags	handleTypes;
1661};
1662
1663struct VkExportMemoryAllocateInfo
1664{
1665	VkStructureType					sType;
1666	const void*						pNext;
1667	VkExternalMemoryHandleTypeFlags	handleTypes;
1668};
1669
1670struct VkPhysicalDeviceExternalFenceInfo
1671{
1672	VkStructureType						sType;
1673	const void*							pNext;
1674	VkExternalFenceHandleTypeFlagBits	handleType;
1675};
1676
1677struct VkExternalFenceProperties
1678{
1679	VkStructureType					sType;
1680	void*							pNext;
1681	VkExternalFenceHandleTypeFlags	exportFromImportedHandleTypes;
1682	VkExternalFenceHandleTypeFlags	compatibleHandleTypes;
1683	VkExternalFenceFeatureFlags		externalFenceFeatures;
1684};
1685
1686struct VkExportFenceCreateInfo
1687{
1688	VkStructureType					sType;
1689	const void*						pNext;
1690	VkExternalFenceHandleTypeFlags	handleTypes;
1691};
1692
1693struct VkExportSemaphoreCreateInfo
1694{
1695	VkStructureType						sType;
1696	const void*							pNext;
1697	VkExternalSemaphoreHandleTypeFlags	handleTypes;
1698};
1699
1700struct VkPhysicalDeviceExternalSemaphoreInfo
1701{
1702	VkStructureType							sType;
1703	const void*								pNext;
1704	VkExternalSemaphoreHandleTypeFlagBits	handleType;
1705};
1706
1707struct VkExternalSemaphoreProperties
1708{
1709	VkStructureType						sType;
1710	void*								pNext;
1711	VkExternalSemaphoreHandleTypeFlags	exportFromImportedHandleTypes;
1712	VkExternalSemaphoreHandleTypeFlags	compatibleHandleTypes;
1713	VkExternalSemaphoreFeatureFlags		externalSemaphoreFeatures;
1714};
1715
1716struct VkPhysicalDeviceMaintenance3Properties
1717{
1718	VkStructureType	sType;
1719	void*			pNext;
1720	deUint32		maxPerSetDescriptors;
1721	VkDeviceSize	maxMemoryAllocationSize;
1722};
1723
1724struct VkDescriptorSetLayoutSupport
1725{
1726	VkStructureType	sType;
1727	void*			pNext;
1728	VkBool32		supported;
1729};
1730
1731struct VkPhysicalDeviceShaderDrawParameterFeatures
1732{
1733	VkStructureType	sType;
1734	void*			pNext;
1735	VkBool32		shaderDrawParameters;
1736};
1737
1738struct VkSurfaceCapabilitiesKHR
1739{
1740	deUint32						minImageCount;
1741	deUint32						maxImageCount;
1742	VkExtent2D						currentExtent;
1743	VkExtent2D						minImageExtent;
1744	VkExtent2D						maxImageExtent;
1745	deUint32						maxImageArrayLayers;
1746	VkSurfaceTransformFlagsKHR		supportedTransforms;
1747	VkSurfaceTransformFlagBitsKHR	currentTransform;
1748	VkCompositeAlphaFlagsKHR		supportedCompositeAlpha;
1749	VkImageUsageFlags				supportedUsageFlags;
1750};
1751
1752struct VkSurfaceFormatKHR
1753{
1754	VkFormat		format;
1755	VkColorSpaceKHR	colorSpace;
1756};
1757
1758struct VkSwapchainCreateInfoKHR
1759{
1760	VkStructureType					sType;
1761	const void*						pNext;
1762	VkSwapchainCreateFlagsKHR		flags;
1763	VkSurfaceKHR					surface;
1764	deUint32						minImageCount;
1765	VkFormat						imageFormat;
1766	VkColorSpaceKHR					imageColorSpace;
1767	VkExtent2D						imageExtent;
1768	deUint32						imageArrayLayers;
1769	VkImageUsageFlags				imageUsage;
1770	VkSharingMode					imageSharingMode;
1771	deUint32						queueFamilyIndexCount;
1772	const deUint32*					pQueueFamilyIndices;
1773	VkSurfaceTransformFlagBitsKHR	preTransform;
1774	VkCompositeAlphaFlagBitsKHR		compositeAlpha;
1775	VkPresentModeKHR				presentMode;
1776	VkBool32						clipped;
1777	VkSwapchainKHR					oldSwapchain;
1778};
1779
1780struct VkPresentInfoKHR
1781{
1782	VkStructureType			sType;
1783	const void*				pNext;
1784	deUint32				waitSemaphoreCount;
1785	const VkSemaphore*		pWaitSemaphores;
1786	deUint32				swapchainCount;
1787	const VkSwapchainKHR*	pSwapchains;
1788	const deUint32*			pImageIndices;
1789	VkResult*				pResults;
1790};
1791
1792struct VkImageSwapchainCreateInfoKHR
1793{
1794	VkStructureType	sType;
1795	const void*		pNext;
1796	VkSwapchainKHR	swapchain;
1797};
1798
1799struct VkBindImageMemorySwapchainInfoKHR
1800{
1801	VkStructureType	sType;
1802	const void*		pNext;
1803	VkSwapchainKHR	swapchain;
1804	deUint32		imageIndex;
1805};
1806
1807struct VkAcquireNextImageInfoKHR
1808{
1809	VkStructureType	sType;
1810	const void*		pNext;
1811	VkSwapchainKHR	swapchain;
1812	deUint64		timeout;
1813	VkSemaphore		semaphore;
1814	VkFence			fence;
1815	deUint32		deviceMask;
1816};
1817
1818struct VkDeviceGroupPresentCapabilitiesKHR
1819{
1820	VkStructureType						sType;
1821	const void*							pNext;
1822	deUint32							presentMask[VK_MAX_DEVICE_GROUP_SIZE];
1823	VkDeviceGroupPresentModeFlagsKHR	modes;
1824};
1825
1826struct VkDeviceGroupPresentInfoKHR
1827{
1828	VkStructureType						sType;
1829	const void*							pNext;
1830	deUint32							swapchainCount;
1831	const deUint32*						pDeviceMasks;
1832	VkDeviceGroupPresentModeFlagBitsKHR	mode;
1833};
1834
1835struct VkDeviceGroupSwapchainCreateInfoKHR
1836{
1837	VkStructureType						sType;
1838	const void*							pNext;
1839	VkDeviceGroupPresentModeFlagsKHR	modes;
1840};
1841
1842struct VkDisplayPropertiesKHR
1843{
1844	VkDisplayKHR				display;
1845	const char*					displayName;
1846	VkExtent2D					physicalDimensions;
1847	VkExtent2D					physicalResolution;
1848	VkSurfaceTransformFlagsKHR	supportedTransforms;
1849	VkBool32					planeReorderPossible;
1850	VkBool32					persistentContent;
1851};
1852
1853struct VkDisplayModeParametersKHR
1854{
1855	VkExtent2D	visibleRegion;
1856	deUint32	refreshRate;
1857};
1858
1859struct VkDisplayModePropertiesKHR
1860{
1861	VkDisplayModeKHR			displayMode;
1862	VkDisplayModeParametersKHR	parameters;
1863};
1864
1865struct VkDisplayModeCreateInfoKHR
1866{
1867	VkStructureType				sType;
1868	const void*					pNext;
1869	VkDisplayModeCreateFlagsKHR	flags;
1870	VkDisplayModeParametersKHR	parameters;
1871};
1872
1873struct VkDisplayPlaneCapabilitiesKHR
1874{
1875	VkDisplayPlaneAlphaFlagsKHR	supportedAlpha;
1876	VkOffset2D					minSrcPosition;
1877	VkOffset2D					maxSrcPosition;
1878	VkExtent2D					minSrcExtent;
1879	VkExtent2D					maxSrcExtent;
1880	VkOffset2D					minDstPosition;
1881	VkOffset2D					maxDstPosition;
1882	VkExtent2D					minDstExtent;
1883	VkExtent2D					maxDstExtent;
1884};
1885
1886struct VkDisplayPlanePropertiesKHR
1887{
1888	VkDisplayKHR	currentDisplay;
1889	deUint32		currentStackIndex;
1890};
1891
1892struct VkDisplaySurfaceCreateInfoKHR
1893{
1894	VkStructureType					sType;
1895	const void*						pNext;
1896	VkDisplaySurfaceCreateFlagsKHR	flags;
1897	VkDisplayModeKHR				displayMode;
1898	deUint32						planeIndex;
1899	deUint32						planeStackIndex;
1900	VkSurfaceTransformFlagBitsKHR	transform;
1901	float							globalAlpha;
1902	VkDisplayPlaneAlphaFlagBitsKHR	alphaMode;
1903	VkExtent2D						imageExtent;
1904};
1905
1906struct VkDisplayPresentInfoKHR
1907{
1908	VkStructureType	sType;
1909	const void*		pNext;
1910	VkRect2D		srcRect;
1911	VkRect2D		dstRect;
1912	VkBool32		persistent;
1913};
1914
1915struct VkXlibSurfaceCreateInfoKHR
1916{
1917	VkStructureType				sType;
1918	const void*					pNext;
1919	VkXlibSurfaceCreateFlagsKHR	flags;
1920	pt::XlibDisplayPtr			dpy;
1921	pt::XlibWindow				window;
1922};
1923
1924struct VkXcbSurfaceCreateInfoKHR
1925{
1926	VkStructureType				sType;
1927	const void*					pNext;
1928	VkXcbSurfaceCreateFlagsKHR	flags;
1929	pt::XcbConnectionPtr		connection;
1930	pt::XcbWindow				window;
1931};
1932
1933struct VkWaylandSurfaceCreateInfoKHR
1934{
1935	VkStructureType					sType;
1936	const void*						pNext;
1937	VkWaylandSurfaceCreateFlagsKHR	flags;
1938	pt::WaylandDisplayPtr			display;
1939	pt::WaylandSurfacePtr			surface;
1940};
1941
1942struct VkMirSurfaceCreateInfoKHR
1943{
1944	VkStructureType				sType;
1945	const void*					pNext;
1946	VkMirSurfaceCreateFlagsKHR	flags;
1947	pt::MirConnectionPtr		connection;
1948	pt::MirSurfacePtr			mirSurface;
1949};
1950
1951struct VkAndroidSurfaceCreateInfoKHR
1952{
1953	VkStructureType					sType;
1954	const void*						pNext;
1955	VkAndroidSurfaceCreateFlagsKHR	flags;
1956	pt::AndroidNativeWindowPtr		window;
1957};
1958
1959struct VkWin32SurfaceCreateInfoKHR
1960{
1961	VkStructureType					sType;
1962	const void*						pNext;
1963	VkWin32SurfaceCreateFlagsKHR	flags;
1964	pt::Win32InstanceHandle			hinstance;
1965	pt::Win32WindowHandle			hwnd;
1966};
1967
1968struct VkImportMemoryWin32HandleInfoKHR
1969{
1970	VkStructureType						sType;
1971	const void*							pNext;
1972	VkExternalMemoryHandleTypeFlagBits	handleType;
1973	pt::Win32Handle						handle;
1974	char*								name;
1975};
1976
1977struct VkExportMemoryWin32HandleInfoKHR
1978{
1979	VkStructureType					sType;
1980	const void*						pNext;
1981	pt::Win32SecurityAttributesPtr	pAttributes;
1982	deUint32						dwAccess;
1983	char*							name;
1984};
1985
1986struct VkMemoryWin32HandlePropertiesKHR
1987{
1988	VkStructureType	sType;
1989	void*			pNext;
1990	deUint32		memoryTypeBits;
1991};
1992
1993struct VkMemoryGetWin32HandleInfoKHR
1994{
1995	VkStructureType						sType;
1996	const void*							pNext;
1997	VkDeviceMemory						memory;
1998	VkExternalMemoryHandleTypeFlagBits	handleType;
1999};
2000
2001struct VkImportMemoryFdInfoKHR
2002{
2003	VkStructureType						sType;
2004	const void*							pNext;
2005	VkExternalMemoryHandleTypeFlagBits	handleType;
2006	int									fd;
2007};
2008
2009struct VkMemoryFdPropertiesKHR
2010{
2011	VkStructureType	sType;
2012	void*			pNext;
2013	deUint32		memoryTypeBits;
2014};
2015
2016struct VkMemoryGetFdInfoKHR
2017{
2018	VkStructureType						sType;
2019	const void*							pNext;
2020	VkDeviceMemory						memory;
2021	VkExternalMemoryHandleTypeFlagBits	handleType;
2022};
2023
2024struct VkWin32KeyedMutexAcquireReleaseInfoKHR
2025{
2026	VkStructureType			sType;
2027	const void*				pNext;
2028	deUint32				acquireCount;
2029	const VkDeviceMemory*	pAcquireSyncs;
2030	const deUint64*			pAcquireKeys;
2031	const deUint32*			pAcquireTimeouts;
2032	deUint32				releaseCount;
2033	const VkDeviceMemory*	pReleaseSyncs;
2034	const deUint64*			pReleaseKeys;
2035};
2036
2037struct VkImportSemaphoreWin32HandleInfoKHR
2038{
2039	VkStructureType							sType;
2040	const void*								pNext;
2041	VkSemaphore								semaphore;
2042	VkSemaphoreImportFlags					flags;
2043	VkExternalSemaphoreHandleTypeFlagBits	handleType;
2044	pt::Win32Handle							handle;
2045	char*									name;
2046};
2047
2048struct VkExportSemaphoreWin32HandleInfoKHR
2049{
2050	VkStructureType					sType;
2051	const void*						pNext;
2052	pt::Win32SecurityAttributesPtr	pAttributes;
2053	deUint32						dwAccess;
2054	char*							name;
2055};
2056
2057struct VkD3D12FenceSubmitInfoKHR
2058{
2059	VkStructureType	sType;
2060	const void*		pNext;
2061	deUint32		waitSemaphoreValuesCount;
2062	const deUint64*	pWaitSemaphoreValues;
2063	deUint32		signalSemaphoreValuesCount;
2064	const deUint64*	pSignalSemaphoreValues;
2065};
2066
2067struct VkSemaphoreGetWin32HandleInfoKHR
2068{
2069	VkStructureType							sType;
2070	const void*								pNext;
2071	VkSemaphore								semaphore;
2072	VkExternalSemaphoreHandleTypeFlagBits	handleType;
2073};
2074
2075struct VkImportSemaphoreFdInfoKHR
2076{
2077	VkStructureType							sType;
2078	const void*								pNext;
2079	VkSemaphore								semaphore;
2080	VkSemaphoreImportFlags					flags;
2081	VkExternalSemaphoreHandleTypeFlagBits	handleType;
2082	int										fd;
2083};
2084
2085struct VkSemaphoreGetFdInfoKHR
2086{
2087	VkStructureType							sType;
2088	const void*								pNext;
2089	VkSemaphore								semaphore;
2090	VkExternalSemaphoreHandleTypeFlagBits	handleType;
2091};
2092
2093struct VkPhysicalDevicePushDescriptorPropertiesKHR
2094{
2095	VkStructureType	sType;
2096	void*			pNext;
2097	deUint32		maxPushDescriptors;
2098};
2099
2100struct VkRectLayerKHR
2101{
2102	VkOffset2D	offset;
2103	VkExtent2D	extent;
2104	deUint32	layer;
2105};
2106
2107struct VkPresentRegionKHR
2108{
2109	deUint32				rectangleCount;
2110	const VkRectLayerKHR*	pRectangles;
2111};
2112
2113struct VkPresentRegionsKHR
2114{
2115	VkStructureType				sType;
2116	const void*					pNext;
2117	deUint32					swapchainCount;
2118	const VkPresentRegionKHR*	pRegions;
2119};
2120
2121struct VkSharedPresentSurfaceCapabilitiesKHR
2122{
2123	VkStructureType		sType;
2124	void*				pNext;
2125	VkImageUsageFlags	sharedPresentSupportedUsageFlags;
2126};
2127
2128struct VkImportFenceWin32HandleInfoKHR
2129{
2130	VkStructureType						sType;
2131	const void*							pNext;
2132	VkFence								fence;
2133	VkFenceImportFlags					flags;
2134	VkExternalFenceHandleTypeFlagBits	handleType;
2135	pt::Win32Handle						handle;
2136	char*								name;
2137};
2138
2139struct VkExportFenceWin32HandleInfoKHR
2140{
2141	VkStructureType					sType;
2142	const void*						pNext;
2143	pt::Win32SecurityAttributesPtr	pAttributes;
2144	deUint32						dwAccess;
2145	char*							name;
2146};
2147
2148struct VkFenceGetWin32HandleInfoKHR
2149{
2150	VkStructureType						sType;
2151	const void*							pNext;
2152	VkFence								fence;
2153	VkExternalFenceHandleTypeFlagBits	handleType;
2154};
2155
2156struct VkImportFenceFdInfoKHR
2157{
2158	VkStructureType						sType;
2159	const void*							pNext;
2160	VkFence								fence;
2161	VkFenceImportFlags					flags;
2162	VkExternalFenceHandleTypeFlagBits	handleType;
2163	int									fd;
2164};
2165
2166struct VkFenceGetFdInfoKHR
2167{
2168	VkStructureType						sType;
2169	const void*							pNext;
2170	VkFence								fence;
2171	VkExternalFenceHandleTypeFlagBits	handleType;
2172};
2173
2174struct VkPhysicalDeviceSurfaceInfo2KHR
2175{
2176	VkStructureType	sType;
2177	const void*		pNext;
2178	VkSurfaceKHR	surface;
2179};
2180
2181struct VkSurfaceCapabilities2KHR
2182{
2183	VkStructureType				sType;
2184	void*						pNext;
2185	VkSurfaceCapabilitiesKHR	surfaceCapabilities;
2186};
2187
2188struct VkSurfaceFormat2KHR
2189{
2190	VkStructureType		sType;
2191	void*				pNext;
2192	VkSurfaceFormatKHR	surfaceFormat;
2193};
2194
2195struct VkImageFormatListCreateInfoKHR
2196{
2197	VkStructureType	sType;
2198	const void*		pNext;
2199	deUint32		viewFormatCount;
2200	const VkFormat*	pViewFormats;
2201};
2202
2203struct VkDebugReportCallbackCreateInfoEXT
2204{
2205	VkStructureType					sType;
2206	const void*						pNext;
2207	VkDebugReportFlagsEXT			flags;
2208	PFN_vkDebugReportCallbackEXT	pfnCallback;
2209	void*							pUserData;
2210};
2211
2212struct VkPipelineRasterizationStateRasterizationOrderAMD
2213{
2214	VkStructureType			sType;
2215	const void*				pNext;
2216	VkRasterizationOrderAMD	rasterizationOrder;
2217};
2218
2219struct VkDebugMarkerObjectNameInfoEXT
2220{
2221	VkStructureType				sType;
2222	const void*					pNext;
2223	VkDebugReportObjectTypeEXT	objectType;
2224	deUint64					object;
2225	const char*					pObjectName;
2226};
2227
2228struct VkDebugMarkerObjectTagInfoEXT
2229{
2230	VkStructureType				sType;
2231	const void*					pNext;
2232	VkDebugReportObjectTypeEXT	objectType;
2233	deUint64					object;
2234	deUint64					tagName;
2235	deUintptr					tagSize;
2236	const void*					pTag;
2237};
2238
2239struct VkDebugMarkerMarkerInfoEXT
2240{
2241	VkStructureType	sType;
2242	const void*		pNext;
2243	const char*		pMarkerName;
2244	float			color[4];
2245};
2246
2247struct VkDedicatedAllocationImageCreateInfoNV
2248{
2249	VkStructureType	sType;
2250	const void*		pNext;
2251	VkBool32		dedicatedAllocation;
2252};
2253
2254struct VkDedicatedAllocationBufferCreateInfoNV
2255{
2256	VkStructureType	sType;
2257	const void*		pNext;
2258	VkBool32		dedicatedAllocation;
2259};
2260
2261struct VkDedicatedAllocationMemoryAllocateInfoNV
2262{
2263	VkStructureType	sType;
2264	const void*		pNext;
2265	VkImage			image;
2266	VkBuffer		buffer;
2267};
2268
2269struct VkTextureLODGatherFormatPropertiesAMD
2270{
2271	VkStructureType	sType;
2272	void*			pNext;
2273	VkBool32		supportsTextureGatherLODBiasAMD;
2274};
2275
2276struct VkExternalImageFormatPropertiesNV
2277{
2278	VkImageFormatProperties				imageFormatProperties;
2279	VkExternalMemoryFeatureFlagsNV		externalMemoryFeatures;
2280	VkExternalMemoryHandleTypeFlagsNV	exportFromImportedHandleTypes;
2281	VkExternalMemoryHandleTypeFlagsNV	compatibleHandleTypes;
2282};
2283
2284struct VkExternalMemoryImageCreateInfoNV
2285{
2286	VkStructureType						sType;
2287	const void*							pNext;
2288	VkExternalMemoryHandleTypeFlagsNV	handleTypes;
2289};
2290
2291struct VkExportMemoryAllocateInfoNV
2292{
2293	VkStructureType						sType;
2294	const void*							pNext;
2295	VkExternalMemoryHandleTypeFlagsNV	handleTypes;
2296};
2297
2298struct VkImportMemoryWin32HandleInfoNV
2299{
2300	VkStructureType						sType;
2301	const void*							pNext;
2302	VkExternalMemoryHandleTypeFlagsNV	handleType;
2303	pt::Win32Handle						handle;
2304};
2305
2306struct VkExportMemoryWin32HandleInfoNV
2307{
2308	VkStructureType					sType;
2309	const void*						pNext;
2310	pt::Win32SecurityAttributesPtr	pAttributes;
2311	deUint32						dwAccess;
2312};
2313
2314struct VkWin32KeyedMutexAcquireReleaseInfoNV
2315{
2316	VkStructureType			sType;
2317	const void*				pNext;
2318	deUint32				acquireCount;
2319	const VkDeviceMemory*	pAcquireSyncs;
2320	const deUint64*			pAcquireKeys;
2321	const deUint32*			pAcquireTimeoutMilliseconds;
2322	deUint32				releaseCount;
2323	const VkDeviceMemory*	pReleaseSyncs;
2324	const deUint64*			pReleaseKeys;
2325};
2326
2327struct VkValidationFlagsEXT
2328{
2329	VkStructureType			sType;
2330	const void*				pNext;
2331	deUint32				disabledValidationCheckCount;
2332	VkValidationCheckEXT*	pDisabledValidationChecks;
2333};
2334
2335struct VkViSurfaceCreateInfoNN
2336{
2337	VkStructureType				sType;
2338	const void*					pNext;
2339	VkViSurfaceCreateFlagsNN	flags;
2340	void*						window;
2341};
2342
2343struct VkDeviceGeneratedCommandsFeaturesNVX
2344{
2345	VkStructureType	sType;
2346	const void*		pNext;
2347	VkBool32		computeBindingPointSupport;
2348};
2349
2350struct VkDeviceGeneratedCommandsLimitsNVX
2351{
2352	VkStructureType	sType;
2353	const void*		pNext;
2354	deUint32		maxIndirectCommandsLayoutTokenCount;
2355	deUint32		maxObjectEntryCounts;
2356	deUint32		minSequenceCountBufferOffsetAlignment;
2357	deUint32		minSequenceIndexBufferOffsetAlignment;
2358	deUint32		minCommandsTokenBufferOffsetAlignment;
2359};
2360
2361struct VkIndirectCommandsTokenNVX
2362{
2363	VkIndirectCommandsTokenTypeNVX	tokenType;
2364	VkBuffer						buffer;
2365	VkDeviceSize					offset;
2366};
2367
2368struct VkIndirectCommandsLayoutTokenNVX
2369{
2370	VkIndirectCommandsTokenTypeNVX	tokenType;
2371	deUint32						bindingUnit;
2372	deUint32						dynamicCount;
2373	deUint32						divisor;
2374};
2375
2376struct VkIndirectCommandsLayoutCreateInfoNVX
2377{
2378	VkStructureType							sType;
2379	const void*								pNext;
2380	VkPipelineBindPoint						pipelineBindPoint;
2381	VkIndirectCommandsLayoutUsageFlagsNVX	flags;
2382	deUint32								tokenCount;
2383	const VkIndirectCommandsLayoutTokenNVX*	pTokens;
2384};
2385
2386struct VkCmdProcessCommandsInfoNVX
2387{
2388	VkStructureType						sType;
2389	const void*							pNext;
2390	VkObjectTableNVX					objectTable;
2391	VkIndirectCommandsLayoutNVX			indirectCommandsLayout;
2392	deUint32							indirectCommandsTokenCount;
2393	const VkIndirectCommandsTokenNVX*	pIndirectCommandsTokens;
2394	deUint32							maxSequencesCount;
2395	VkCommandBuffer						targetCommandBuffer;
2396	VkBuffer							sequencesCountBuffer;
2397	VkDeviceSize						sequencesCountOffset;
2398	VkBuffer							sequencesIndexBuffer;
2399	VkDeviceSize						sequencesIndexOffset;
2400};
2401
2402struct VkCmdReserveSpaceForCommandsInfoNVX
2403{
2404	VkStructureType				sType;
2405	const void*					pNext;
2406	VkObjectTableNVX			objectTable;
2407	VkIndirectCommandsLayoutNVX	indirectCommandsLayout;
2408	deUint32					maxSequencesCount;
2409};
2410
2411struct VkObjectTableCreateInfoNVX
2412{
2413	VkStructureType						sType;
2414	const void*							pNext;
2415	deUint32							objectCount;
2416	const VkObjectEntryTypeNVX*			pObjectEntryTypes;
2417	const deUint32*						pObjectEntryCounts;
2418	const VkObjectEntryUsageFlagsNVX*	pObjectEntryUsageFlags;
2419	deUint32							maxUniformBuffersPerDescriptor;
2420	deUint32							maxStorageBuffersPerDescriptor;
2421	deUint32							maxStorageImagesPerDescriptor;
2422	deUint32							maxSampledImagesPerDescriptor;
2423	deUint32							maxPipelineLayouts;
2424};
2425
2426struct VkObjectTableEntryNVX
2427{
2428	VkObjectEntryTypeNVX		type;
2429	VkObjectEntryUsageFlagsNVX	flags;
2430};
2431
2432struct VkObjectTablePipelineEntryNVX
2433{
2434	VkObjectEntryTypeNVX		type;
2435	VkObjectEntryUsageFlagsNVX	flags;
2436	VkPipeline					pipeline;
2437};
2438
2439struct VkObjectTableDescriptorSetEntryNVX
2440{
2441	VkObjectEntryTypeNVX		type;
2442	VkObjectEntryUsageFlagsNVX	flags;
2443	VkPipelineLayout			pipelineLayout;
2444	VkDescriptorSet				descriptorSet;
2445};
2446
2447struct VkObjectTableVertexBufferEntryNVX
2448{
2449	VkObjectEntryTypeNVX		type;
2450	VkObjectEntryUsageFlagsNVX	flags;
2451	VkBuffer					buffer;
2452};
2453
2454struct VkObjectTableIndexBufferEntryNVX
2455{
2456	VkObjectEntryTypeNVX		type;
2457	VkObjectEntryUsageFlagsNVX	flags;
2458	VkBuffer					buffer;
2459	VkIndexType					indexType;
2460};
2461
2462struct VkObjectTablePushConstantEntryNVX
2463{
2464	VkObjectEntryTypeNVX		type;
2465	VkObjectEntryUsageFlagsNVX	flags;
2466	VkPipelineLayout			pipelineLayout;
2467	VkShaderStageFlags			stageFlags;
2468};
2469
2470struct VkViewportWScalingNV
2471{
2472	float	xcoeff;
2473	float	ycoeff;
2474};
2475
2476struct VkPipelineViewportWScalingStateCreateInfoNV
2477{
2478	VkStructureType				sType;
2479	const void*					pNext;
2480	VkBool32					viewportWScalingEnable;
2481	deUint32					viewportCount;
2482	const VkViewportWScalingNV*	pViewportWScalings;
2483};
2484
2485struct VkSurfaceCapabilities2EXT
2486{
2487	VkStructureType					sType;
2488	void*							pNext;
2489	deUint32						minImageCount;
2490	deUint32						maxImageCount;
2491	VkExtent2D						currentExtent;
2492	VkExtent2D						minImageExtent;
2493	VkExtent2D						maxImageExtent;
2494	deUint32						maxImageArrayLayers;
2495	VkSurfaceTransformFlagsKHR		supportedTransforms;
2496	VkSurfaceTransformFlagBitsKHR	currentTransform;
2497	VkCompositeAlphaFlagsKHR		supportedCompositeAlpha;
2498	VkImageUsageFlags				supportedUsageFlags;
2499	VkSurfaceCounterFlagsEXT		supportedSurfaceCounters;
2500};
2501
2502struct VkDisplayPowerInfoEXT
2503{
2504	VkStructureType			sType;
2505	const void*				pNext;
2506	VkDisplayPowerStateEXT	powerState;
2507};
2508
2509struct VkDeviceEventInfoEXT
2510{
2511	VkStructureType			sType;
2512	const void*				pNext;
2513	VkDeviceEventTypeEXT	deviceEvent;
2514};
2515
2516struct VkDisplayEventInfoEXT
2517{
2518	VkStructureType			sType;
2519	const void*				pNext;
2520	VkDisplayEventTypeEXT	displayEvent;
2521};
2522
2523struct VkSwapchainCounterCreateInfoEXT
2524{
2525	VkStructureType				sType;
2526	const void*					pNext;
2527	VkSurfaceCounterFlagsEXT	surfaceCounters;
2528};
2529
2530struct VkRefreshCycleDurationGOOGLE
2531{
2532	deUint64	refreshDuration;
2533};
2534
2535struct VkPastPresentationTimingGOOGLE
2536{
2537	deUint32	presentID;
2538	deUint64	desiredPresentTime;
2539	deUint64	actualPresentTime;
2540	deUint64	earliestPresentTime;
2541	deUint64	presentMargin;
2542};
2543
2544struct VkPresentTimeGOOGLE
2545{
2546	deUint32	presentID;
2547	deUint64	desiredPresentTime;
2548};
2549
2550struct VkPresentTimesInfoGOOGLE
2551{
2552	VkStructureType				sType;
2553	const void*					pNext;
2554	deUint32					swapchainCount;
2555	const VkPresentTimeGOOGLE*	pTimes;
2556};
2557
2558struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
2559{
2560	VkStructureType	sType;
2561	void*			pNext;
2562	VkBool32		perViewPositionAllComponents;
2563};
2564
2565struct VkViewportSwizzleNV
2566{
2567	VkViewportCoordinateSwizzleNV	x;
2568	VkViewportCoordinateSwizzleNV	y;
2569	VkViewportCoordinateSwizzleNV	z;
2570	VkViewportCoordinateSwizzleNV	w;
2571};
2572
2573struct VkPipelineViewportSwizzleStateCreateInfoNV
2574{
2575	VkStructureType								sType;
2576	const void*									pNext;
2577	VkPipelineViewportSwizzleStateCreateFlagsNV	flags;
2578	deUint32									viewportCount;
2579	const VkViewportSwizzleNV*					pViewportSwizzles;
2580};
2581
2582struct VkPhysicalDeviceDiscardRectanglePropertiesEXT
2583{
2584	VkStructureType	sType;
2585	void*			pNext;
2586	deUint32		maxDiscardRectangles;
2587};
2588
2589struct VkPipelineDiscardRectangleStateCreateInfoEXT
2590{
2591	VkStructureType									sType;
2592	const void*										pNext;
2593	VkPipelineDiscardRectangleStateCreateFlagsEXT	flags;
2594	VkDiscardRectangleModeEXT						discardRectangleMode;
2595	deUint32										discardRectangleCount;
2596	const VkRect2D*									pDiscardRectangles;
2597};
2598
2599struct VkXYColorEXT
2600{
2601	float	x;
2602	float	y;
2603};
2604
2605struct VkHdrMetadataEXT
2606{
2607	VkStructureType	sType;
2608	const void*		pNext;
2609	VkXYColorEXT	displayPrimaryRed;
2610	VkXYColorEXT	displayPrimaryGreen;
2611	VkXYColorEXT	displayPrimaryBlue;
2612	VkXYColorEXT	whitePoint;
2613	float			maxLuminance;
2614	float			minLuminance;
2615	float			maxContentLightLevel;
2616	float			maxFrameAverageLightLevel;
2617};
2618
2619struct VkIOSSurfaceCreateInfoMVK
2620{
2621	VkStructureType				sType;
2622	const void*					pNext;
2623	VkIOSSurfaceCreateFlagsMVK	flags;
2624	const void*					pView;
2625};
2626
2627struct VkMacOSSurfaceCreateInfoMVK
2628{
2629	VkStructureType					sType;
2630	const void*						pNext;
2631	VkMacOSSurfaceCreateFlagsMVK	flags;
2632	const void*						pView;
2633};
2634
2635struct VkSamplerReductionModeCreateInfoEXT
2636{
2637	VkStructureType				sType;
2638	const void*					pNext;
2639	VkSamplerReductionModeEXT	reductionMode;
2640};
2641
2642struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT
2643{
2644	VkStructureType	sType;
2645	void*			pNext;
2646	VkBool32		filterMinmaxSingleComponentFormats;
2647	VkBool32		filterMinmaxImageComponentMapping;
2648};
2649
2650struct VkSampleLocationEXT
2651{
2652	float	x;
2653	float	y;
2654};
2655
2656struct VkSampleLocationsInfoEXT
2657{
2658	VkStructureType				sType;
2659	const void*					pNext;
2660	VkSampleCountFlagBits		sampleLocationsPerPixel;
2661	VkExtent2D					sampleLocationGridSize;
2662	deUint32					sampleLocationsCount;
2663	const VkSampleLocationEXT*	pSampleLocations;
2664};
2665
2666struct VkAttachmentSampleLocationsEXT
2667{
2668	deUint32					attachmentIndex;
2669	VkSampleLocationsInfoEXT	sampleLocationsInfo;
2670};
2671
2672struct VkSubpassSampleLocationsEXT
2673{
2674	deUint32					subpassIndex;
2675	VkSampleLocationsInfoEXT	sampleLocationsInfo;
2676};
2677
2678struct VkRenderPassSampleLocationsBeginInfoEXT
2679{
2680	VkStructureType							sType;
2681	const void*								pNext;
2682	deUint32								attachmentInitialSampleLocationsCount;
2683	const VkAttachmentSampleLocationsEXT*	pAttachmentInitialSampleLocations;
2684	deUint32								postSubpassSampleLocationsCount;
2685	const VkSubpassSampleLocationsEXT*		pSubpassSampleLocations;
2686};
2687
2688struct VkPipelineSampleLocationsStateCreateInfoEXT
2689{
2690	VkStructureType				sType;
2691	const void*					pNext;
2692	VkBool32					sampleLocationsEnable;
2693	VkSampleLocationsInfoEXT	sampleLocationsInfo;
2694};
2695
2696struct VkPhysicalDeviceSampleLocationsPropertiesEXT
2697{
2698	VkStructureType		sType;
2699	void*				pNext;
2700	VkSampleCountFlags	sampleLocationSampleCounts;
2701	VkExtent2D			maxSampleLocationGridSize;
2702	float				sampleLocationCoordinateRange[2];
2703	deUint32			sampleLocationSubPixelBits;
2704	VkBool32			variableSampleLocations;
2705};
2706
2707struct VkMultisamplePropertiesEXT
2708{
2709	VkStructureType	sType;
2710	void*			pNext;
2711	VkExtent2D		maxSampleLocationGridSize;
2712};
2713
2714struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT
2715{
2716	VkStructureType	sType;
2717	void*			pNext;
2718	VkBool32		advancedBlendCoherentOperations;
2719};
2720
2721struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT
2722{
2723	VkStructureType	sType;
2724	void*			pNext;
2725	deUint32		advancedBlendMaxColorAttachments;
2726	VkBool32		advancedBlendIndependentBlend;
2727	VkBool32		advancedBlendNonPremultipliedSrcColor;
2728	VkBool32		advancedBlendNonPremultipliedDstColor;
2729	VkBool32		advancedBlendCorrelatedOverlap;
2730	VkBool32		advancedBlendAllOperations;
2731};
2732
2733struct VkPipelineColorBlendAdvancedStateCreateInfoEXT
2734{
2735	VkStructureType		sType;
2736	const void*			pNext;
2737	VkBool32			srcPremultiplied;
2738	VkBool32			dstPremultiplied;
2739	VkBlendOverlapEXT	blendOverlap;
2740};
2741
2742struct VkPipelineCoverageToColorStateCreateInfoNV
2743{
2744	VkStructureType								sType;
2745	const void*									pNext;
2746	VkPipelineCoverageToColorStateCreateFlagsNV	flags;
2747	VkBool32									coverageToColorEnable;
2748	deUint32									coverageToColorLocation;
2749};
2750
2751struct VkPipelineCoverageModulationStateCreateInfoNV
2752{
2753	VkStructureType									sType;
2754	const void*										pNext;
2755	VkPipelineCoverageModulationStateCreateFlagsNV	flags;
2756	VkCoverageModulationModeNV						coverageModulationMode;
2757	VkBool32										coverageModulationTableEnable;
2758	deUint32										coverageModulationTableCount;
2759	const float*									pCoverageModulationTable;
2760};
2761
2762struct VkValidationCacheCreateInfoEXT
2763{
2764	VkStructureType					sType;
2765	const void*						pNext;
2766	VkValidationCacheCreateFlagsEXT	flags;
2767	deUintptr						initialDataSize;
2768	const void*						pInitialData;
2769};
2770
2771struct VkShaderModuleValidationCacheCreateInfoEXT
2772{
2773	VkStructureType			sType;
2774	const void*				pNext;
2775	VkValidationCacheEXT	validationCache;
2776};
2777
2778struct VkAndroidHardwareBufferUsageANDROID
2779{
2780	VkStructureType	sType;
2781	void*			pNext;
2782	deUint64		androidHardwareBufferUsage;
2783};
2784
2785struct VkAndroidHardwareBufferPropertiesANDROID
2786{
2787	VkStructureType	sType;
2788	void*			pNext;
2789	VkDeviceSize	allocationSize;
2790	deUint32		memoryTypeBits;
2791};
2792
2793struct VkAndroidHardwareBufferFormatPropertiesANDROID
2794{
2795	VkStructureType					sType;
2796	void*							pNext;
2797	VkFormat						format;
2798	deUint64						externalFormat;
2799	VkFormatFeatureFlags			formatFeatures;
2800	VkSamplerYcbcrModelConversion	suggestedYcbcrModel;
2801	VkSamplerYcbcrRange				suggestedYcbcrRange;
2802	VkChromaLocation				suggestedXChromaOffset;
2803	VkChromaLocation				suggestedYChromaOffset;
2804};
2805
2806struct VkImportAndroidHardwareBufferInfoANDROID
2807{
2808	VkStructureType						sType;
2809	const void*							pNext;
2810	struct pt::AndroidHardwareBufferPtr	buffer;
2811};
2812
2813struct VkMemoryGetAndroidHardwareBufferInfoANDROID
2814{
2815	VkStructureType	sType;
2816	void*			pNext;
2817	VkDeviceMemory	memory;
2818};
2819
2820struct VkExternalFormatANDROID
2821{
2822	VkStructureType	sType;
2823	void*			pNext;
2824	deUint64		externalFormat;
2825};
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889