• 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 * This file was generated by /scripts/gen_framework.py
4 */
5
6struct VkBaseOutStructure
7{
8	VkStructureType				sType;
9	struct VkBaseOutStructure*	pNext;
10};
11
12struct VkBaseInStructure
13{
14	VkStructureType					sType;
15	const struct VkBaseInStructure*	pNext;
16};
17
18struct VkOffset2D
19{
20	int32_t	x;
21	int32_t	y;
22};
23
24struct VkOffset3D
25{
26	int32_t	x;
27	int32_t	y;
28	int32_t	z;
29};
30
31struct VkExtent2D
32{
33	uint32_t	width;
34	uint32_t	height;
35};
36
37struct VkExtent3D
38{
39	uint32_t	width;
40	uint32_t	height;
41	uint32_t	depth;
42};
43
44struct VkViewport
45{
46	float	x;
47	float	y;
48	float	width;
49	float	height;
50	float	minDepth;
51	float	maxDepth;
52};
53
54struct VkRect2D
55{
56	VkOffset2D	offset;
57	VkExtent2D	extent;
58};
59
60struct VkClearRect
61{
62	VkRect2D	rect;
63	uint32_t	baseArrayLayer;
64	uint32_t	layerCount;
65};
66
67struct VkComponentMapping
68{
69	VkComponentSwizzle	r;
70	VkComponentSwizzle	g;
71	VkComponentSwizzle	b;
72	VkComponentSwizzle	a;
73};
74
75struct VkExtensionProperties
76{
77	char		extensionName[VK_MAX_EXTENSION_NAME_SIZE];
78	uint32_t	specVersion;
79};
80
81struct VkLayerProperties
82{
83	char		layerName[VK_MAX_EXTENSION_NAME_SIZE];
84	uint32_t	specVersion;
85	uint32_t	implementationVersion;
86	char		description[VK_MAX_DESCRIPTION_SIZE];
87};
88
89struct VkApplicationInfo
90{
91	VkStructureType	sType;
92	const void*		pNext;
93	const char*		pApplicationName;
94	uint32_t		applicationVersion;
95	const char*		pEngineName;
96	uint32_t		engineVersion;
97	uint32_t		apiVersion;
98};
99
100struct VkAllocationCallbacks
101{
102	void*									pUserData;
103	PFN_vkAllocationFunction				pfnAllocation;
104	PFN_vkReallocationFunction				pfnReallocation;
105	PFN_vkFreeFunction						pfnFree;
106	PFN_vkInternalAllocationNotification	pfnInternalAllocation;
107	PFN_vkInternalFreeNotification			pfnInternalFree;
108};
109
110struct VkDeviceQueueCreateInfo
111{
112	VkStructureType				sType;
113	const void*					pNext;
114	VkDeviceQueueCreateFlags	flags;
115	uint32_t					queueFamilyIndex;
116	uint32_t					queueCount;
117	const float*				pQueuePriorities;
118};
119
120struct VkInstanceCreateInfo
121{
122	VkStructureType				sType;
123	const void*					pNext;
124	VkInstanceCreateFlags		flags;
125	const VkApplicationInfo*	pApplicationInfo;
126	uint32_t					enabledLayerCount;
127	const char* const*			ppEnabledLayerNames;
128	uint32_t					enabledExtensionCount;
129	const char* const*			ppEnabledExtensionNames;
130};
131
132struct VkQueueFamilyProperties
133{
134	VkQueueFlags	queueFlags;
135	uint32_t		queueCount;
136	uint32_t		timestampValidBits;
137	VkExtent3D		minImageTransferGranularity;
138};
139
140struct VkMemoryAllocateInfo
141{
142	VkStructureType	sType;
143	const void*		pNext;
144	VkDeviceSize	allocationSize;
145	uint32_t		memoryTypeIndex;
146};
147
148struct VkMemoryRequirements
149{
150	VkDeviceSize	size;
151	VkDeviceSize	alignment;
152	uint32_t		memoryTypeBits;
153};
154
155struct VkSparseImageFormatProperties
156{
157	VkImageAspectFlags			aspectMask;
158	VkExtent3D					imageGranularity;
159	VkSparseImageFormatFlags	flags;
160};
161
162struct VkSparseImageMemoryRequirements
163{
164	VkSparseImageFormatProperties	formatProperties;
165	uint32_t						imageMipTailFirstLod;
166	VkDeviceSize					imageMipTailSize;
167	VkDeviceSize					imageMipTailOffset;
168	VkDeviceSize					imageMipTailStride;
169};
170
171struct VkMemoryType
172{
173	VkMemoryPropertyFlags	propertyFlags;
174	uint32_t				heapIndex;
175};
176
177struct VkMemoryHeap
178{
179	VkDeviceSize		size;
180	VkMemoryHeapFlags	flags;
181};
182
183struct VkPhysicalDeviceMemoryProperties
184{
185	uint32_t		memoryTypeCount;
186	VkMemoryType	memoryTypes[VK_MAX_MEMORY_TYPES];
187	uint32_t		memoryHeapCount;
188	VkMemoryHeap	memoryHeaps[VK_MAX_MEMORY_HEAPS];
189};
190
191struct VkMappedMemoryRange
192{
193	VkStructureType	sType;
194	const void*		pNext;
195	VkDeviceMemory	memory;
196	VkDeviceSize	offset;
197	VkDeviceSize	size;
198};
199
200struct VkFormatProperties
201{
202	VkFormatFeatureFlags	linearTilingFeatures;
203	VkFormatFeatureFlags	optimalTilingFeatures;
204	VkFormatFeatureFlags	bufferFeatures;
205};
206
207struct VkImageFormatProperties
208{
209	VkExtent3D			maxExtent;
210	uint32_t			maxMipLevels;
211	uint32_t			maxArrayLayers;
212	VkSampleCountFlags	sampleCounts;
213	VkDeviceSize		maxResourceSize;
214};
215
216struct VkDescriptorBufferInfo
217{
218	VkBuffer		buffer;
219	VkDeviceSize	offset;
220	VkDeviceSize	range;
221};
222
223struct VkDescriptorImageInfo
224{
225	VkSampler		sampler;
226	VkImageView		imageView;
227	VkImageLayout	imageLayout;
228};
229
230struct VkWriteDescriptorSet
231{
232	VkStructureType					sType;
233	const void*						pNext;
234	VkDescriptorSet					dstSet;
235	uint32_t						dstBinding;
236	uint32_t						dstArrayElement;
237	uint32_t						descriptorCount;
238	VkDescriptorType				descriptorType;
239	const VkDescriptorImageInfo*	pImageInfo;
240	const VkDescriptorBufferInfo*	pBufferInfo;
241	const VkBufferView*				pTexelBufferView;
242};
243
244struct VkCopyDescriptorSet
245{
246	VkStructureType	sType;
247	const void*		pNext;
248	VkDescriptorSet	srcSet;
249	uint32_t		srcBinding;
250	uint32_t		srcArrayElement;
251	VkDescriptorSet	dstSet;
252	uint32_t		dstBinding;
253	uint32_t		dstArrayElement;
254	uint32_t		descriptorCount;
255};
256
257struct VkBufferCreateInfo
258{
259	VkStructureType		sType;
260	const void*			pNext;
261	VkBufferCreateFlags	flags;
262	VkDeviceSize		size;
263	VkBufferUsageFlags	usage;
264	VkSharingMode		sharingMode;
265	uint32_t			queueFamilyIndexCount;
266	const uint32_t*		pQueueFamilyIndices;
267};
268
269struct VkBufferViewCreateInfo
270{
271	VkStructureType			sType;
272	const void*				pNext;
273	VkBufferViewCreateFlags	flags;
274	VkBuffer				buffer;
275	VkFormat				format;
276	VkDeviceSize			offset;
277	VkDeviceSize			range;
278};
279
280struct VkImageSubresource
281{
282	VkImageAspectFlags	aspectMask;
283	uint32_t			mipLevel;
284	uint32_t			arrayLayer;
285};
286
287struct VkImageSubresourceLayers
288{
289	VkImageAspectFlags	aspectMask;
290	uint32_t			mipLevel;
291	uint32_t			baseArrayLayer;
292	uint32_t			layerCount;
293};
294
295struct VkImageSubresourceRange
296{
297	VkImageAspectFlags	aspectMask;
298	uint32_t			baseMipLevel;
299	uint32_t			levelCount;
300	uint32_t			baseArrayLayer;
301	uint32_t			layerCount;
302};
303
304struct VkMemoryBarrier
305{
306	VkStructureType	sType;
307	const void*		pNext;
308	VkAccessFlags	srcAccessMask;
309	VkAccessFlags	dstAccessMask;
310};
311
312struct VkBufferMemoryBarrier
313{
314	VkStructureType	sType;
315	const void*		pNext;
316	VkAccessFlags	srcAccessMask;
317	VkAccessFlags	dstAccessMask;
318	uint32_t		srcQueueFamilyIndex;
319	uint32_t		dstQueueFamilyIndex;
320	VkBuffer		buffer;
321	VkDeviceSize	offset;
322	VkDeviceSize	size;
323};
324
325struct VkImageMemoryBarrier
326{
327	VkStructureType			sType;
328	const void*				pNext;
329	VkAccessFlags			srcAccessMask;
330	VkAccessFlags			dstAccessMask;
331	VkImageLayout			oldLayout;
332	VkImageLayout			newLayout;
333	uint32_t				srcQueueFamilyIndex;
334	uint32_t				dstQueueFamilyIndex;
335	VkImage					image;
336	VkImageSubresourceRange	subresourceRange;
337};
338
339struct VkImageCreateInfo
340{
341	VkStructureType			sType;
342	const void*				pNext;
343	VkImageCreateFlags		flags;
344	VkImageType				imageType;
345	VkFormat				format;
346	VkExtent3D				extent;
347	uint32_t				mipLevels;
348	uint32_t				arrayLayers;
349	VkSampleCountFlagBits	samples;
350	VkImageTiling			tiling;
351	VkImageUsageFlags		usage;
352	VkSharingMode			sharingMode;
353	uint32_t				queueFamilyIndexCount;
354	const uint32_t*			pQueueFamilyIndices;
355	VkImageLayout			initialLayout;
356};
357
358struct VkSubresourceLayout
359{
360	VkDeviceSize	offset;
361	VkDeviceSize	size;
362	VkDeviceSize	rowPitch;
363	VkDeviceSize	arrayPitch;
364	VkDeviceSize	depthPitch;
365};
366
367struct VkImageViewCreateInfo
368{
369	VkStructureType			sType;
370	const void*				pNext;
371	VkImageViewCreateFlags	flags;
372	VkImage					image;
373	VkImageViewType			viewType;
374	VkFormat				format;
375	VkComponentMapping		components;
376	VkImageSubresourceRange	subresourceRange;
377};
378
379struct VkBufferCopy
380{
381	VkDeviceSize	srcOffset;
382	VkDeviceSize	dstOffset;
383	VkDeviceSize	size;
384};
385
386struct VkSparseMemoryBind
387{
388	VkDeviceSize			resourceOffset;
389	VkDeviceSize			size;
390	VkDeviceMemory			memory;
391	VkDeviceSize			memoryOffset;
392	VkSparseMemoryBindFlags	flags;
393};
394
395struct VkSparseImageMemoryBind
396{
397	VkImageSubresource		subresource;
398	VkOffset3D				offset;
399	VkExtent3D				extent;
400	VkDeviceMemory			memory;
401	VkDeviceSize			memoryOffset;
402	VkSparseMemoryBindFlags	flags;
403};
404
405struct VkSparseBufferMemoryBindInfo
406{
407	VkBuffer					buffer;
408	uint32_t					bindCount;
409	const VkSparseMemoryBind*	pBinds;
410};
411
412struct VkSparseImageOpaqueMemoryBindInfo
413{
414	VkImage						image;
415	uint32_t					bindCount;
416	const VkSparseMemoryBind*	pBinds;
417};
418
419struct VkSparseImageMemoryBindInfo
420{
421	VkImage							image;
422	uint32_t						bindCount;
423	const VkSparseImageMemoryBind*	pBinds;
424};
425
426struct VkBindSparseInfo
427{
428	VkStructureType								sType;
429	const void*									pNext;
430	uint32_t									waitSemaphoreCount;
431	const VkSemaphore*							pWaitSemaphores;
432	uint32_t									bufferBindCount;
433	const VkSparseBufferMemoryBindInfo*			pBufferBinds;
434	uint32_t									imageOpaqueBindCount;
435	const VkSparseImageOpaqueMemoryBindInfo*	pImageOpaqueBinds;
436	uint32_t									imageBindCount;
437	const VkSparseImageMemoryBindInfo*			pImageBinds;
438	uint32_t									signalSemaphoreCount;
439	const VkSemaphore*							pSignalSemaphores;
440};
441
442struct VkImageCopy
443{
444	VkImageSubresourceLayers	srcSubresource;
445	VkOffset3D					srcOffset;
446	VkImageSubresourceLayers	dstSubresource;
447	VkOffset3D					dstOffset;
448	VkExtent3D					extent;
449};
450
451struct VkImageBlit
452{
453	VkImageSubresourceLayers	srcSubresource;
454	VkOffset3D					srcOffsets[2];
455	VkImageSubresourceLayers	dstSubresource;
456	VkOffset3D					dstOffsets[2];
457};
458
459struct VkBufferImageCopy
460{
461	VkDeviceSize				bufferOffset;
462	uint32_t					bufferRowLength;
463	uint32_t					bufferImageHeight;
464	VkImageSubresourceLayers	imageSubresource;
465	VkOffset3D					imageOffset;
466	VkExtent3D					imageExtent;
467};
468
469struct VkImageResolve
470{
471	VkImageSubresourceLayers	srcSubresource;
472	VkOffset3D					srcOffset;
473	VkImageSubresourceLayers	dstSubresource;
474	VkOffset3D					dstOffset;
475	VkExtent3D					extent;
476};
477
478struct VkShaderModuleCreateInfo
479{
480	VkStructureType				sType;
481	const void*					pNext;
482	VkShaderModuleCreateFlags	flags;
483	size_t						codeSize;
484	const uint32_t*				pCode;
485};
486
487struct VkDescriptorSetLayoutBinding
488{
489	uint32_t			binding;
490	VkDescriptorType	descriptorType;
491	uint32_t			descriptorCount;
492	VkShaderStageFlags	stageFlags;
493	const VkSampler*	pImmutableSamplers;
494};
495
496struct VkDescriptorSetLayoutCreateInfo
497{
498	VkStructureType						sType;
499	const void*							pNext;
500	VkDescriptorSetLayoutCreateFlags	flags;
501	uint32_t							bindingCount;
502	const VkDescriptorSetLayoutBinding*	pBindings;
503};
504
505struct VkDescriptorPoolSize
506{
507	VkDescriptorType	type;
508	uint32_t			descriptorCount;
509};
510
511struct VkDescriptorPoolCreateInfo
512{
513	VkStructureType				sType;
514	const void*					pNext;
515	VkDescriptorPoolCreateFlags	flags;
516	uint32_t					maxSets;
517	uint32_t					poolSizeCount;
518	const VkDescriptorPoolSize*	pPoolSizes;
519};
520
521struct VkDescriptorSetAllocateInfo
522{
523	VkStructureType					sType;
524	const void*						pNext;
525	VkDescriptorPool				descriptorPool;
526	uint32_t						descriptorSetCount;
527	const VkDescriptorSetLayout*	pSetLayouts;
528};
529
530struct VkSpecializationMapEntry
531{
532	uint32_t	constantID;
533	uint32_t	offset;
534	size_t		size;
535};
536
537struct VkSpecializationInfo
538{
539	uint32_t						mapEntryCount;
540	const VkSpecializationMapEntry*	pMapEntries;
541	size_t							dataSize;
542	const void*						pData;
543};
544
545struct VkPipelineShaderStageCreateInfo
546{
547	VkStructureType						sType;
548	const void*							pNext;
549	VkPipelineShaderStageCreateFlags	flags;
550	VkShaderStageFlagBits				stage;
551	VkShaderModule						module;
552	const char*							pName;
553	const VkSpecializationInfo*			pSpecializationInfo;
554};
555
556struct VkComputePipelineCreateInfo
557{
558	VkStructureType					sType;
559	const void*						pNext;
560	VkPipelineCreateFlags			flags;
561	VkPipelineShaderStageCreateInfo	stage;
562	VkPipelineLayout				layout;
563	VkPipeline						basePipelineHandle;
564	int32_t							basePipelineIndex;
565};
566
567struct VkVertexInputBindingDescription
568{
569	uint32_t			binding;
570	uint32_t			stride;
571	VkVertexInputRate	inputRate;
572};
573
574struct VkVertexInputAttributeDescription
575{
576	uint32_t	location;
577	uint32_t	binding;
578	VkFormat	format;
579	uint32_t	offset;
580};
581
582struct VkPipelineVertexInputStateCreateInfo
583{
584	VkStructureType								sType;
585	const void*									pNext;
586	VkPipelineVertexInputStateCreateFlags		flags;
587	uint32_t									vertexBindingDescriptionCount;
588	const VkVertexInputBindingDescription*		pVertexBindingDescriptions;
589	uint32_t									vertexAttributeDescriptionCount;
590	const VkVertexInputAttributeDescription*	pVertexAttributeDescriptions;
591};
592
593struct VkPipelineInputAssemblyStateCreateInfo
594{
595	VkStructureType							sType;
596	const void*								pNext;
597	VkPipelineInputAssemblyStateCreateFlags	flags;
598	VkPrimitiveTopology						topology;
599	VkBool32								primitiveRestartEnable;
600};
601
602struct VkPipelineTessellationStateCreateInfo
603{
604	VkStructureType							sType;
605	const void*								pNext;
606	VkPipelineTessellationStateCreateFlags	flags;
607	uint32_t								patchControlPoints;
608};
609
610struct VkPipelineViewportStateCreateInfo
611{
612	VkStructureType						sType;
613	const void*							pNext;
614	VkPipelineViewportStateCreateFlags	flags;
615	uint32_t							viewportCount;
616	const VkViewport*					pViewports;
617	uint32_t							scissorCount;
618	const VkRect2D*						pScissors;
619};
620
621struct VkPipelineRasterizationStateCreateInfo
622{
623	VkStructureType							sType;
624	const void*								pNext;
625	VkPipelineRasterizationStateCreateFlags	flags;
626	VkBool32								depthClampEnable;
627	VkBool32								rasterizerDiscardEnable;
628	VkPolygonMode							polygonMode;
629	VkCullModeFlags							cullMode;
630	VkFrontFace								frontFace;
631	VkBool32								depthBiasEnable;
632	float									depthBiasConstantFactor;
633	float									depthBiasClamp;
634	float									depthBiasSlopeFactor;
635	float									lineWidth;
636};
637
638struct VkPipelineMultisampleStateCreateInfo
639{
640	VkStructureType							sType;
641	const void*								pNext;
642	VkPipelineMultisampleStateCreateFlags	flags;
643	VkSampleCountFlagBits					rasterizationSamples;
644	VkBool32								sampleShadingEnable;
645	float									minSampleShading;
646	const VkSampleMask*						pSampleMask;
647	VkBool32								alphaToCoverageEnable;
648	VkBool32								alphaToOneEnable;
649};
650
651struct VkPipelineColorBlendAttachmentState
652{
653	VkBool32				blendEnable;
654	VkBlendFactor			srcColorBlendFactor;
655	VkBlendFactor			dstColorBlendFactor;
656	VkBlendOp				colorBlendOp;
657	VkBlendFactor			srcAlphaBlendFactor;
658	VkBlendFactor			dstAlphaBlendFactor;
659	VkBlendOp				alphaBlendOp;
660	VkColorComponentFlags	colorWriteMask;
661};
662
663struct VkPipelineColorBlendStateCreateInfo
664{
665	VkStructureType								sType;
666	const void*									pNext;
667	VkPipelineColorBlendStateCreateFlags		flags;
668	VkBool32									logicOpEnable;
669	VkLogicOp									logicOp;
670	uint32_t									attachmentCount;
671	const VkPipelineColorBlendAttachmentState*	pAttachments;
672	float										blendConstants[4];
673};
674
675struct VkPipelineDynamicStateCreateInfo
676{
677	VkStructureType						sType;
678	const void*							pNext;
679	VkPipelineDynamicStateCreateFlags	flags;
680	uint32_t							dynamicStateCount;
681	const VkDynamicState*				pDynamicStates;
682};
683
684struct VkStencilOpState
685{
686	VkStencilOp	failOp;
687	VkStencilOp	passOp;
688	VkStencilOp	depthFailOp;
689	VkCompareOp	compareOp;
690	uint32_t	compareMask;
691	uint32_t	writeMask;
692	uint32_t	reference;
693};
694
695struct VkPipelineDepthStencilStateCreateInfo
696{
697	VkStructureType							sType;
698	const void*								pNext;
699	VkPipelineDepthStencilStateCreateFlags	flags;
700	VkBool32								depthTestEnable;
701	VkBool32								depthWriteEnable;
702	VkCompareOp								depthCompareOp;
703	VkBool32								depthBoundsTestEnable;
704	VkBool32								stencilTestEnable;
705	VkStencilOpState						front;
706	VkStencilOpState						back;
707	float									minDepthBounds;
708	float									maxDepthBounds;
709};
710
711struct VkGraphicsPipelineCreateInfo
712{
713	VkStructureType									sType;
714	const void*										pNext;
715	VkPipelineCreateFlags							flags;
716	uint32_t										stageCount;
717	const VkPipelineShaderStageCreateInfo*			pStages;
718	const VkPipelineVertexInputStateCreateInfo*		pVertexInputState;
719	const VkPipelineInputAssemblyStateCreateInfo*	pInputAssemblyState;
720	const VkPipelineTessellationStateCreateInfo*	pTessellationState;
721	const VkPipelineViewportStateCreateInfo*		pViewportState;
722	const VkPipelineRasterizationStateCreateInfo*	pRasterizationState;
723	const VkPipelineMultisampleStateCreateInfo*		pMultisampleState;
724	const VkPipelineDepthStencilStateCreateInfo*	pDepthStencilState;
725	const VkPipelineColorBlendStateCreateInfo*		pColorBlendState;
726	const VkPipelineDynamicStateCreateInfo*			pDynamicState;
727	VkPipelineLayout								layout;
728	VkRenderPass									renderPass;
729	uint32_t										subpass;
730	VkPipeline										basePipelineHandle;
731	int32_t											basePipelineIndex;
732};
733
734struct VkPipelineCacheCreateInfo
735{
736	VkStructureType				sType;
737	const void*					pNext;
738	VkPipelineCacheCreateFlags	flags;
739	size_t						initialDataSize;
740	const void*					pInitialData;
741};
742
743struct VkPipelineCacheHeaderVersionOne
744{
745	uint32_t						headerSize;
746	VkPipelineCacheHeaderVersion	headerVersion;
747	uint32_t						vendorID;
748	uint32_t						deviceID;
749	uint8_t							pipelineCacheUUID[VK_UUID_SIZE];
750};
751
752struct VkPipelineCacheStageValidationIndexEntry
753{
754	uint64_t	codeSize;
755	uint64_t	codeOffset;
756};
757
758struct VkPipelineCacheSafetyCriticalIndexEntry
759{
760	uint8_t		pipelineIdentifier[VK_UUID_SIZE];
761	uint64_t	pipelineMemorySize;
762	uint64_t	jsonSize;
763	uint64_t	jsonOffset;
764	uint32_t	stageIndexCount;
765	uint32_t	stageIndexStride;
766	uint64_t	stageIndexOffset;
767};
768
769struct VkPipelineCacheHeaderVersionSafetyCriticalOne
770{
771	VkPipelineCacheHeaderVersionOne		headerVersionOne;
772	VkPipelineCacheValidationVersion	validationVersion;
773	uint32_t							implementationData;
774	uint32_t							pipelineIndexCount;
775	uint32_t							pipelineIndexStride;
776	uint64_t							pipelineIndexOffset;
777};
778
779struct VkPushConstantRange
780{
781	VkShaderStageFlags	stageFlags;
782	uint32_t			offset;
783	uint32_t			size;
784};
785
786struct VkPipelineLayoutCreateInfo
787{
788	VkStructureType					sType;
789	const void*						pNext;
790	VkPipelineLayoutCreateFlags		flags;
791	uint32_t						setLayoutCount;
792	const VkDescriptorSetLayout*	pSetLayouts;
793	uint32_t						pushConstantRangeCount;
794	const VkPushConstantRange*		pPushConstantRanges;
795};
796
797struct VkSamplerCreateInfo
798{
799	VkStructureType			sType;
800	const void*				pNext;
801	VkSamplerCreateFlags	flags;
802	VkFilter				magFilter;
803	VkFilter				minFilter;
804	VkSamplerMipmapMode		mipmapMode;
805	VkSamplerAddressMode	addressModeU;
806	VkSamplerAddressMode	addressModeV;
807	VkSamplerAddressMode	addressModeW;
808	float					mipLodBias;
809	VkBool32				anisotropyEnable;
810	float					maxAnisotropy;
811	VkBool32				compareEnable;
812	VkCompareOp				compareOp;
813	float					minLod;
814	float					maxLod;
815	VkBorderColor			borderColor;
816	VkBool32				unnormalizedCoordinates;
817};
818
819struct VkCommandPoolCreateInfo
820{
821	VkStructureType				sType;
822	const void*					pNext;
823	VkCommandPoolCreateFlags	flags;
824	uint32_t					queueFamilyIndex;
825};
826
827struct VkCommandBufferAllocateInfo
828{
829	VkStructureType			sType;
830	const void*				pNext;
831	VkCommandPool			commandPool;
832	VkCommandBufferLevel	level;
833	uint32_t				commandBufferCount;
834};
835
836struct VkCommandBufferInheritanceInfo
837{
838	VkStructureType					sType;
839	const void*						pNext;
840	VkRenderPass					renderPass;
841	uint32_t						subpass;
842	VkFramebuffer					framebuffer;
843	VkBool32						occlusionQueryEnable;
844	VkQueryControlFlags				queryFlags;
845	VkQueryPipelineStatisticFlags	pipelineStatistics;
846};
847
848struct VkCommandBufferBeginInfo
849{
850	VkStructureType							sType;
851	const void*								pNext;
852	VkCommandBufferUsageFlags				flags;
853	const VkCommandBufferInheritanceInfo*	pInheritanceInfo;
854};
855
856union VkClearColorValue
857{
858	float		float32[4];
859	int32_t		int32[4];
860	uint32_t	uint32[4];
861};
862
863struct VkClearDepthStencilValue
864{
865	float		depth;
866	uint32_t	stencil;
867};
868
869union VkClearValue
870{
871	VkClearColorValue			color;
872	VkClearDepthStencilValue	depthStencil;
873};
874
875struct VkRenderPassBeginInfo
876{
877	VkStructureType		sType;
878	const void*			pNext;
879	VkRenderPass		renderPass;
880	VkFramebuffer		framebuffer;
881	VkRect2D			renderArea;
882	uint32_t			clearValueCount;
883	const VkClearValue*	pClearValues;
884};
885
886struct VkClearAttachment
887{
888	VkImageAspectFlags	aspectMask;
889	uint32_t			colorAttachment;
890	VkClearValue		clearValue;
891};
892
893struct VkAttachmentDescription
894{
895	VkAttachmentDescriptionFlags	flags;
896	VkFormat						format;
897	VkSampleCountFlagBits			samples;
898	VkAttachmentLoadOp				loadOp;
899	VkAttachmentStoreOp				storeOp;
900	VkAttachmentLoadOp				stencilLoadOp;
901	VkAttachmentStoreOp				stencilStoreOp;
902	VkImageLayout					initialLayout;
903	VkImageLayout					finalLayout;
904};
905
906struct VkAttachmentReference
907{
908	uint32_t		attachment;
909	VkImageLayout	layout;
910};
911
912struct VkSubpassDescription
913{
914	VkSubpassDescriptionFlags		flags;
915	VkPipelineBindPoint				pipelineBindPoint;
916	uint32_t						inputAttachmentCount;
917	const VkAttachmentReference*	pInputAttachments;
918	uint32_t						colorAttachmentCount;
919	const VkAttachmentReference*	pColorAttachments;
920	const VkAttachmentReference*	pResolveAttachments;
921	const VkAttachmentReference*	pDepthStencilAttachment;
922	uint32_t						preserveAttachmentCount;
923	const uint32_t*					pPreserveAttachments;
924};
925
926struct VkSubpassDependency
927{
928	uint32_t				srcSubpass;
929	uint32_t				dstSubpass;
930	VkPipelineStageFlags	srcStageMask;
931	VkPipelineStageFlags	dstStageMask;
932	VkAccessFlags			srcAccessMask;
933	VkAccessFlags			dstAccessMask;
934	VkDependencyFlags		dependencyFlags;
935};
936
937struct VkRenderPassCreateInfo
938{
939	VkStructureType					sType;
940	const void*						pNext;
941	VkRenderPassCreateFlags			flags;
942	uint32_t						attachmentCount;
943	const VkAttachmentDescription*	pAttachments;
944	uint32_t						subpassCount;
945	const VkSubpassDescription*		pSubpasses;
946	uint32_t						dependencyCount;
947	const VkSubpassDependency*		pDependencies;
948};
949
950struct VkEventCreateInfo
951{
952	VkStructureType		sType;
953	const void*			pNext;
954	VkEventCreateFlags	flags;
955};
956
957struct VkFenceCreateInfo
958{
959	VkStructureType		sType;
960	const void*			pNext;
961	VkFenceCreateFlags	flags;
962};
963
964struct VkPhysicalDeviceFeatures
965{
966	VkBool32	robustBufferAccess;
967	VkBool32	fullDrawIndexUint32;
968	VkBool32	imageCubeArray;
969	VkBool32	independentBlend;
970	VkBool32	geometryShader;
971	VkBool32	tessellationShader;
972	VkBool32	sampleRateShading;
973	VkBool32	dualSrcBlend;
974	VkBool32	logicOp;
975	VkBool32	multiDrawIndirect;
976	VkBool32	drawIndirectFirstInstance;
977	VkBool32	depthClamp;
978	VkBool32	depthBiasClamp;
979	VkBool32	fillModeNonSolid;
980	VkBool32	depthBounds;
981	VkBool32	wideLines;
982	VkBool32	largePoints;
983	VkBool32	alphaToOne;
984	VkBool32	multiViewport;
985	VkBool32	samplerAnisotropy;
986	VkBool32	textureCompressionETC2;
987	VkBool32	textureCompressionASTC_LDR;
988	VkBool32	textureCompressionBC;
989	VkBool32	occlusionQueryPrecise;
990	VkBool32	pipelineStatisticsQuery;
991	VkBool32	vertexPipelineStoresAndAtomics;
992	VkBool32	fragmentStoresAndAtomics;
993	VkBool32	shaderTessellationAndGeometryPointSize;
994	VkBool32	shaderImageGatherExtended;
995	VkBool32	shaderStorageImageExtendedFormats;
996	VkBool32	shaderStorageImageMultisample;
997	VkBool32	shaderStorageImageReadWithoutFormat;
998	VkBool32	shaderStorageImageWriteWithoutFormat;
999	VkBool32	shaderUniformBufferArrayDynamicIndexing;
1000	VkBool32	shaderSampledImageArrayDynamicIndexing;
1001	VkBool32	shaderStorageBufferArrayDynamicIndexing;
1002	VkBool32	shaderStorageImageArrayDynamicIndexing;
1003	VkBool32	shaderClipDistance;
1004	VkBool32	shaderCullDistance;
1005	VkBool32	shaderFloat64;
1006	VkBool32	shaderInt64;
1007	VkBool32	shaderInt16;
1008	VkBool32	shaderResourceResidency;
1009	VkBool32	shaderResourceMinLod;
1010	VkBool32	sparseBinding;
1011	VkBool32	sparseResidencyBuffer;
1012	VkBool32	sparseResidencyImage2D;
1013	VkBool32	sparseResidencyImage3D;
1014	VkBool32	sparseResidency2Samples;
1015	VkBool32	sparseResidency4Samples;
1016	VkBool32	sparseResidency8Samples;
1017	VkBool32	sparseResidency16Samples;
1018	VkBool32	sparseResidencyAliased;
1019	VkBool32	variableMultisampleRate;
1020	VkBool32	inheritedQueries;
1021};
1022
1023struct VkDeviceCreateInfo
1024{
1025	VkStructureType					sType;
1026	const void*						pNext;
1027	VkDeviceCreateFlags				flags;
1028	uint32_t						queueCreateInfoCount;
1029	const VkDeviceQueueCreateInfo*	pQueueCreateInfos;
1030	uint32_t						enabledLayerCount;
1031	const char* const*				ppEnabledLayerNames;
1032	uint32_t						enabledExtensionCount;
1033	const char* const*				ppEnabledExtensionNames;
1034	const VkPhysicalDeviceFeatures*	pEnabledFeatures;
1035};
1036
1037struct VkPhysicalDeviceSparseProperties
1038{
1039	VkBool32	residencyStandard2DBlockShape;
1040	VkBool32	residencyStandard2DMultisampleBlockShape;
1041	VkBool32	residencyStandard3DBlockShape;
1042	VkBool32	residencyAlignedMipSize;
1043	VkBool32	residencyNonResidentStrict;
1044};
1045
1046struct VkPhysicalDeviceLimits
1047{
1048	uint32_t			maxImageDimension1D;
1049	uint32_t			maxImageDimension2D;
1050	uint32_t			maxImageDimension3D;
1051	uint32_t			maxImageDimensionCube;
1052	uint32_t			maxImageArrayLayers;
1053	uint32_t			maxTexelBufferElements;
1054	uint32_t			maxUniformBufferRange;
1055	uint32_t			maxStorageBufferRange;
1056	uint32_t			maxPushConstantsSize;
1057	uint32_t			maxMemoryAllocationCount;
1058	uint32_t			maxSamplerAllocationCount;
1059	VkDeviceSize		bufferImageGranularity;
1060	VkDeviceSize		sparseAddressSpaceSize;
1061	uint32_t			maxBoundDescriptorSets;
1062	uint32_t			maxPerStageDescriptorSamplers;
1063	uint32_t			maxPerStageDescriptorUniformBuffers;
1064	uint32_t			maxPerStageDescriptorStorageBuffers;
1065	uint32_t			maxPerStageDescriptorSampledImages;
1066	uint32_t			maxPerStageDescriptorStorageImages;
1067	uint32_t			maxPerStageDescriptorInputAttachments;
1068	uint32_t			maxPerStageResources;
1069	uint32_t			maxDescriptorSetSamplers;
1070	uint32_t			maxDescriptorSetUniformBuffers;
1071	uint32_t			maxDescriptorSetUniformBuffersDynamic;
1072	uint32_t			maxDescriptorSetStorageBuffers;
1073	uint32_t			maxDescriptorSetStorageBuffersDynamic;
1074	uint32_t			maxDescriptorSetSampledImages;
1075	uint32_t			maxDescriptorSetStorageImages;
1076	uint32_t			maxDescriptorSetInputAttachments;
1077	uint32_t			maxVertexInputAttributes;
1078	uint32_t			maxVertexInputBindings;
1079	uint32_t			maxVertexInputAttributeOffset;
1080	uint32_t			maxVertexInputBindingStride;
1081	uint32_t			maxVertexOutputComponents;
1082	uint32_t			maxTessellationGenerationLevel;
1083	uint32_t			maxTessellationPatchSize;
1084	uint32_t			maxTessellationControlPerVertexInputComponents;
1085	uint32_t			maxTessellationControlPerVertexOutputComponents;
1086	uint32_t			maxTessellationControlPerPatchOutputComponents;
1087	uint32_t			maxTessellationControlTotalOutputComponents;
1088	uint32_t			maxTessellationEvaluationInputComponents;
1089	uint32_t			maxTessellationEvaluationOutputComponents;
1090	uint32_t			maxGeometryShaderInvocations;
1091	uint32_t			maxGeometryInputComponents;
1092	uint32_t			maxGeometryOutputComponents;
1093	uint32_t			maxGeometryOutputVertices;
1094	uint32_t			maxGeometryTotalOutputComponents;
1095	uint32_t			maxFragmentInputComponents;
1096	uint32_t			maxFragmentOutputAttachments;
1097	uint32_t			maxFragmentDualSrcAttachments;
1098	uint32_t			maxFragmentCombinedOutputResources;
1099	uint32_t			maxComputeSharedMemorySize;
1100	uint32_t			maxComputeWorkGroupCount[3];
1101	uint32_t			maxComputeWorkGroupInvocations;
1102	uint32_t			maxComputeWorkGroupSize[3];
1103	uint32_t			subPixelPrecisionBits;
1104	uint32_t			subTexelPrecisionBits;
1105	uint32_t			mipmapPrecisionBits;
1106	uint32_t			maxDrawIndexedIndexValue;
1107	uint32_t			maxDrawIndirectCount;
1108	float				maxSamplerLodBias;
1109	float				maxSamplerAnisotropy;
1110	uint32_t			maxViewports;
1111	uint32_t			maxViewportDimensions[2];
1112	float				viewportBoundsRange[2];
1113	uint32_t			viewportSubPixelBits;
1114	size_t				minMemoryMapAlignment;
1115	VkDeviceSize		minTexelBufferOffsetAlignment;
1116	VkDeviceSize		minUniformBufferOffsetAlignment;
1117	VkDeviceSize		minStorageBufferOffsetAlignment;
1118	int32_t				minTexelOffset;
1119	uint32_t			maxTexelOffset;
1120	int32_t				minTexelGatherOffset;
1121	uint32_t			maxTexelGatherOffset;
1122	float				minInterpolationOffset;
1123	float				maxInterpolationOffset;
1124	uint32_t			subPixelInterpolationOffsetBits;
1125	uint32_t			maxFramebufferWidth;
1126	uint32_t			maxFramebufferHeight;
1127	uint32_t			maxFramebufferLayers;
1128	VkSampleCountFlags	framebufferColorSampleCounts;
1129	VkSampleCountFlags	framebufferDepthSampleCounts;
1130	VkSampleCountFlags	framebufferStencilSampleCounts;
1131	VkSampleCountFlags	framebufferNoAttachmentsSampleCounts;
1132	uint32_t			maxColorAttachments;
1133	VkSampleCountFlags	sampledImageColorSampleCounts;
1134	VkSampleCountFlags	sampledImageIntegerSampleCounts;
1135	VkSampleCountFlags	sampledImageDepthSampleCounts;
1136	VkSampleCountFlags	sampledImageStencilSampleCounts;
1137	VkSampleCountFlags	storageImageSampleCounts;
1138	uint32_t			maxSampleMaskWords;
1139	VkBool32			timestampComputeAndGraphics;
1140	float				timestampPeriod;
1141	uint32_t			maxClipDistances;
1142	uint32_t			maxCullDistances;
1143	uint32_t			maxCombinedClipAndCullDistances;
1144	uint32_t			discreteQueuePriorities;
1145	float				pointSizeRange[2];
1146	float				lineWidthRange[2];
1147	float				pointSizeGranularity;
1148	float				lineWidthGranularity;
1149	VkBool32			strictLines;
1150	VkBool32			standardSampleLocations;
1151	VkDeviceSize		optimalBufferCopyOffsetAlignment;
1152	VkDeviceSize		optimalBufferCopyRowPitchAlignment;
1153	VkDeviceSize		nonCoherentAtomSize;
1154};
1155
1156struct VkPhysicalDeviceProperties
1157{
1158	uint32_t							apiVersion;
1159	uint32_t							driverVersion;
1160	uint32_t							vendorID;
1161	uint32_t							deviceID;
1162	VkPhysicalDeviceType				deviceType;
1163	char								deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
1164	uint8_t								pipelineCacheUUID[VK_UUID_SIZE];
1165	VkPhysicalDeviceLimits				limits;
1166	VkPhysicalDeviceSparseProperties	sparseProperties;
1167};
1168
1169struct VkSemaphoreCreateInfo
1170{
1171	VkStructureType			sType;
1172	const void*				pNext;
1173	VkSemaphoreCreateFlags	flags;
1174};
1175
1176struct VkQueryPoolCreateInfo
1177{
1178	VkStructureType					sType;
1179	const void*						pNext;
1180	VkQueryPoolCreateFlags			flags;
1181	VkQueryType						queryType;
1182	uint32_t						queryCount;
1183	VkQueryPipelineStatisticFlags	pipelineStatistics;
1184};
1185
1186struct VkFramebufferCreateInfo
1187{
1188	VkStructureType				sType;
1189	const void*					pNext;
1190	VkFramebufferCreateFlags	flags;
1191	VkRenderPass				renderPass;
1192	uint32_t					attachmentCount;
1193	const VkImageView*			pAttachments;
1194	uint32_t					width;
1195	uint32_t					height;
1196	uint32_t					layers;
1197};
1198
1199struct VkDrawIndirectCommand
1200{
1201	uint32_t	vertexCount;
1202	uint32_t	instanceCount;
1203	uint32_t	firstVertex;
1204	uint32_t	firstInstance;
1205};
1206
1207struct VkDrawIndexedIndirectCommand
1208{
1209	uint32_t	indexCount;
1210	uint32_t	instanceCount;
1211	uint32_t	firstIndex;
1212	int32_t		vertexOffset;
1213	uint32_t	firstInstance;
1214};
1215
1216struct VkDispatchIndirectCommand
1217{
1218	uint32_t	x;
1219	uint32_t	y;
1220	uint32_t	z;
1221};
1222
1223struct VkSubmitInfo
1224{
1225	VkStructureType				sType;
1226	const void*					pNext;
1227	uint32_t					waitSemaphoreCount;
1228	const VkSemaphore*			pWaitSemaphores;
1229	const VkPipelineStageFlags*	pWaitDstStageMask;
1230	uint32_t					commandBufferCount;
1231	const VkCommandBuffer*		pCommandBuffers;
1232	uint32_t					signalSemaphoreCount;
1233	const VkSemaphore*			pSignalSemaphores;
1234};
1235
1236struct VkDisplayPropertiesKHR
1237{
1238	VkDisplayKHR				display;
1239	const char*					displayName;
1240	VkExtent2D					physicalDimensions;
1241	VkExtent2D					physicalResolution;
1242	VkSurfaceTransformFlagsKHR	supportedTransforms;
1243	VkBool32					planeReorderPossible;
1244	VkBool32					persistentContent;
1245};
1246
1247struct VkDisplayPlanePropertiesKHR
1248{
1249	VkDisplayKHR	currentDisplay;
1250	uint32_t		currentStackIndex;
1251};
1252
1253struct VkDisplayModeParametersKHR
1254{
1255	VkExtent2D	visibleRegion;
1256	uint32_t	refreshRate;
1257};
1258
1259struct VkDisplayModePropertiesKHR
1260{
1261	VkDisplayModeKHR			displayMode;
1262	VkDisplayModeParametersKHR	parameters;
1263};
1264
1265struct VkDisplayModeCreateInfoKHR
1266{
1267	VkStructureType				sType;
1268	const void*					pNext;
1269	VkDisplayModeCreateFlagsKHR	flags;
1270	VkDisplayModeParametersKHR	parameters;
1271};
1272
1273struct VkDisplayPlaneCapabilitiesKHR
1274{
1275	VkDisplayPlaneAlphaFlagsKHR	supportedAlpha;
1276	VkOffset2D					minSrcPosition;
1277	VkOffset2D					maxSrcPosition;
1278	VkExtent2D					minSrcExtent;
1279	VkExtent2D					maxSrcExtent;
1280	VkOffset2D					minDstPosition;
1281	VkOffset2D					maxDstPosition;
1282	VkExtent2D					minDstExtent;
1283	VkExtent2D					maxDstExtent;
1284};
1285
1286struct VkDisplaySurfaceCreateInfoKHR
1287{
1288	VkStructureType					sType;
1289	const void*						pNext;
1290	VkDisplaySurfaceCreateFlagsKHR	flags;
1291	VkDisplayModeKHR				displayMode;
1292	uint32_t						planeIndex;
1293	uint32_t						planeStackIndex;
1294	VkSurfaceTransformFlagBitsKHR	transform;
1295	float							globalAlpha;
1296	VkDisplayPlaneAlphaFlagBitsKHR	alphaMode;
1297	VkExtent2D						imageExtent;
1298};
1299
1300struct VkDisplayPresentInfoKHR
1301{
1302	VkStructureType	sType;
1303	const void*		pNext;
1304	VkRect2D		srcRect;
1305	VkRect2D		dstRect;
1306	VkBool32		persistent;
1307};
1308
1309struct VkSurfaceCapabilitiesKHR
1310{
1311	uint32_t						minImageCount;
1312	uint32_t						maxImageCount;
1313	VkExtent2D						currentExtent;
1314	VkExtent2D						minImageExtent;
1315	VkExtent2D						maxImageExtent;
1316	uint32_t						maxImageArrayLayers;
1317	VkSurfaceTransformFlagsKHR		supportedTransforms;
1318	VkSurfaceTransformFlagBitsKHR	currentTransform;
1319	VkCompositeAlphaFlagsKHR		supportedCompositeAlpha;
1320	VkImageUsageFlags				supportedUsageFlags;
1321};
1322
1323struct VkSurfaceFormatKHR
1324{
1325	VkFormat		format;
1326	VkColorSpaceKHR	colorSpace;
1327};
1328
1329struct VkSwapchainCreateInfoKHR
1330{
1331	VkStructureType					sType;
1332	const void*						pNext;
1333	VkSwapchainCreateFlagsKHR		flags;
1334	VkSurfaceKHR					surface;
1335	uint32_t						minImageCount;
1336	VkFormat						imageFormat;
1337	VkColorSpaceKHR					imageColorSpace;
1338	VkExtent2D						imageExtent;
1339	uint32_t						imageArrayLayers;
1340	VkImageUsageFlags				imageUsage;
1341	VkSharingMode					imageSharingMode;
1342	uint32_t						queueFamilyIndexCount;
1343	const uint32_t*					pQueueFamilyIndices;
1344	VkSurfaceTransformFlagBitsKHR	preTransform;
1345	VkCompositeAlphaFlagBitsKHR		compositeAlpha;
1346	VkPresentModeKHR				presentMode;
1347	VkBool32						clipped;
1348	VkSwapchainKHR					oldSwapchain;
1349};
1350
1351struct VkPresentInfoKHR
1352{
1353	VkStructureType			sType;
1354	const void*				pNext;
1355	uint32_t				waitSemaphoreCount;
1356	const VkSemaphore*		pWaitSemaphores;
1357	uint32_t				swapchainCount;
1358	const VkSwapchainKHR*	pSwapchains;
1359	const uint32_t*			pImageIndices;
1360	VkResult*				pResults;
1361};
1362
1363struct VkValidationFeaturesEXT
1364{
1365	VkStructureType							sType;
1366	const void*								pNext;
1367	uint32_t								enabledValidationFeatureCount;
1368	const VkValidationFeatureEnableEXT*		pEnabledValidationFeatures;
1369	uint32_t								disabledValidationFeatureCount;
1370	const VkValidationFeatureDisableEXT*	pDisabledValidationFeatures;
1371};
1372
1373struct VkApplicationParametersEXT
1374{
1375	VkStructureType	sType;
1376	const void*		pNext;
1377	uint32_t		vendorID;
1378	uint32_t		deviceID;
1379	uint32_t		key;
1380	uint64_t		value;
1381};
1382
1383struct VkExportMemorySciBufInfoNV
1384{
1385	VkStructureType			sType;
1386	const void*				pNext;
1387	pt::NvSciBufAttrList	pAttributes;
1388};
1389
1390struct VkImportMemorySciBufInfoNV
1391{
1392	VkStructureType						sType;
1393	const void*							pNext;
1394	VkExternalMemoryHandleTypeFlagBits	handleType;
1395	pt::NvSciBufObj						handle;
1396};
1397
1398struct VkMemoryGetSciBufInfoNV
1399{
1400	VkStructureType						sType;
1401	const void*							pNext;
1402	VkDeviceMemory						memory;
1403	VkExternalMemoryHandleTypeFlagBits	handleType;
1404};
1405
1406struct VkMemorySciBufPropertiesNV
1407{
1408	VkStructureType	sType;
1409	const void*		pNext;
1410	uint32_t		memoryTypeBits;
1411};
1412
1413struct VkPhysicalDeviceExternalMemorySciBufFeaturesNV
1414{
1415	VkStructureType	sType;
1416	void*			pNext;
1417	VkBool32		sciBufImport;
1418	VkBool32		sciBufExport;
1419};
1420
1421struct VkPhysicalDeviceFeatures2
1422{
1423	VkStructureType				sType;
1424	void*						pNext;
1425	VkPhysicalDeviceFeatures	features;
1426};
1427
1428struct VkPhysicalDeviceProperties2
1429{
1430	VkStructureType				sType;
1431	void*						pNext;
1432	VkPhysicalDeviceProperties	properties;
1433};
1434
1435struct VkFormatProperties2
1436{
1437	VkStructureType		sType;
1438	void*				pNext;
1439	VkFormatProperties	formatProperties;
1440};
1441
1442struct VkImageFormatProperties2
1443{
1444	VkStructureType			sType;
1445	void*					pNext;
1446	VkImageFormatProperties	imageFormatProperties;
1447};
1448
1449struct VkPhysicalDeviceImageFormatInfo2
1450{
1451	VkStructureType		sType;
1452	const void*			pNext;
1453	VkFormat			format;
1454	VkImageType			type;
1455	VkImageTiling		tiling;
1456	VkImageUsageFlags	usage;
1457	VkImageCreateFlags	flags;
1458};
1459
1460struct VkQueueFamilyProperties2
1461{
1462	VkStructureType			sType;
1463	void*					pNext;
1464	VkQueueFamilyProperties	queueFamilyProperties;
1465};
1466
1467struct VkPhysicalDeviceMemoryProperties2
1468{
1469	VkStructureType						sType;
1470	void*								pNext;
1471	VkPhysicalDeviceMemoryProperties	memoryProperties;
1472};
1473
1474struct VkSparseImageFormatProperties2
1475{
1476	VkStructureType					sType;
1477	void*							pNext;
1478	VkSparseImageFormatProperties	properties;
1479};
1480
1481struct VkPhysicalDeviceSparseImageFormatInfo2
1482{
1483	VkStructureType			sType;
1484	const void*				pNext;
1485	VkFormat				format;
1486	VkImageType				type;
1487	VkSampleCountFlagBits	samples;
1488	VkImageUsageFlags		usage;
1489	VkImageTiling			tiling;
1490};
1491
1492struct VkConformanceVersion
1493{
1494	uint8_t	major;
1495	uint8_t	minor;
1496	uint8_t	subminor;
1497	uint8_t	patch;
1498};
1499
1500struct VkPhysicalDeviceDriverProperties
1501{
1502	VkStructureType			sType;
1503	void*					pNext;
1504	VkDriverId				driverID;
1505	char					driverName[VK_MAX_DRIVER_NAME_SIZE];
1506	char					driverInfo[VK_MAX_DRIVER_INFO_SIZE];
1507	VkConformanceVersion	conformanceVersion;
1508};
1509
1510struct VkRectLayerKHR
1511{
1512	VkOffset2D	offset;
1513	VkExtent2D	extent;
1514	uint32_t	layer;
1515};
1516
1517struct VkPresentRegionKHR
1518{
1519	uint32_t				rectangleCount;
1520	const VkRectLayerKHR*	pRectangles;
1521};
1522
1523struct VkPhysicalDeviceVariablePointersFeatures
1524{
1525	VkStructureType	sType;
1526	void*			pNext;
1527	VkBool32		variablePointersStorageBuffer;
1528	VkBool32		variablePointers;
1529};
1530
1531struct VkPresentRegionsKHR
1532{
1533	VkStructureType				sType;
1534	const void*					pNext;
1535	uint32_t					swapchainCount;
1536	const VkPresentRegionKHR*	pRegions;
1537};
1538
1539struct VkExternalMemoryProperties
1540{
1541	VkExternalMemoryFeatureFlags	externalMemoryFeatures;
1542	VkExternalMemoryHandleTypeFlags	exportFromImportedHandleTypes;
1543	VkExternalMemoryHandleTypeFlags	compatibleHandleTypes;
1544};
1545
1546struct VkPhysicalDeviceExternalImageFormatInfo
1547{
1548	VkStructureType						sType;
1549	const void*							pNext;
1550	VkExternalMemoryHandleTypeFlagBits	handleType;
1551};
1552
1553struct VkExternalImageFormatProperties
1554{
1555	VkStructureType				sType;
1556	void*						pNext;
1557	VkExternalMemoryProperties	externalMemoryProperties;
1558};
1559
1560struct VkPhysicalDeviceExternalBufferInfo
1561{
1562	VkStructureType						sType;
1563	const void*							pNext;
1564	VkBufferCreateFlags					flags;
1565	VkBufferUsageFlags					usage;
1566	VkExternalMemoryHandleTypeFlagBits	handleType;
1567};
1568
1569struct VkExternalBufferProperties
1570{
1571	VkStructureType				sType;
1572	void*						pNext;
1573	VkExternalMemoryProperties	externalMemoryProperties;
1574};
1575
1576struct VkPhysicalDeviceIDProperties
1577{
1578	VkStructureType	sType;
1579	void*			pNext;
1580	uint8_t			deviceUUID[VK_UUID_SIZE];
1581	uint8_t			driverUUID[VK_UUID_SIZE];
1582	uint8_t			deviceLUID[VK_LUID_SIZE];
1583	uint32_t		deviceNodeMask;
1584	VkBool32		deviceLUIDValid;
1585};
1586
1587struct VkExternalMemoryImageCreateInfo
1588{
1589	VkStructureType					sType;
1590	const void*						pNext;
1591	VkExternalMemoryHandleTypeFlags	handleTypes;
1592};
1593
1594struct VkExternalMemoryBufferCreateInfo
1595{
1596	VkStructureType					sType;
1597	const void*						pNext;
1598	VkExternalMemoryHandleTypeFlags	handleTypes;
1599};
1600
1601struct VkExportMemoryAllocateInfo
1602{
1603	VkStructureType					sType;
1604	const void*						pNext;
1605	VkExternalMemoryHandleTypeFlags	handleTypes;
1606};
1607
1608struct VkImportMemoryFdInfoKHR
1609{
1610	VkStructureType						sType;
1611	const void*							pNext;
1612	VkExternalMemoryHandleTypeFlagBits	handleType;
1613	int									fd;
1614};
1615
1616struct VkMemoryFdPropertiesKHR
1617{
1618	VkStructureType	sType;
1619	void*			pNext;
1620	uint32_t		memoryTypeBits;
1621};
1622
1623struct VkMemoryGetFdInfoKHR
1624{
1625	VkStructureType						sType;
1626	const void*							pNext;
1627	VkDeviceMemory						memory;
1628	VkExternalMemoryHandleTypeFlagBits	handleType;
1629};
1630
1631struct VkPhysicalDeviceExternalSemaphoreInfo
1632{
1633	VkStructureType							sType;
1634	const void*								pNext;
1635	VkExternalSemaphoreHandleTypeFlagBits	handleType;
1636};
1637
1638struct VkExternalSemaphoreProperties
1639{
1640	VkStructureType						sType;
1641	void*								pNext;
1642	VkExternalSemaphoreHandleTypeFlags	exportFromImportedHandleTypes;
1643	VkExternalSemaphoreHandleTypeFlags	compatibleHandleTypes;
1644	VkExternalSemaphoreFeatureFlags		externalSemaphoreFeatures;
1645};
1646
1647struct VkExportSemaphoreCreateInfo
1648{
1649	VkStructureType						sType;
1650	const void*							pNext;
1651	VkExternalSemaphoreHandleTypeFlags	handleTypes;
1652};
1653
1654struct VkImportSemaphoreFdInfoKHR
1655{
1656	VkStructureType							sType;
1657	const void*								pNext;
1658	VkSemaphore								semaphore;
1659	VkSemaphoreImportFlags					flags;
1660	VkExternalSemaphoreHandleTypeFlagBits	handleType;
1661	int										fd;
1662};
1663
1664struct VkSemaphoreGetFdInfoKHR
1665{
1666	VkStructureType							sType;
1667	const void*								pNext;
1668	VkSemaphore								semaphore;
1669	VkExternalSemaphoreHandleTypeFlagBits	handleType;
1670};
1671
1672struct VkPhysicalDeviceExternalFenceInfo
1673{
1674	VkStructureType						sType;
1675	const void*							pNext;
1676	VkExternalFenceHandleTypeFlagBits	handleType;
1677};
1678
1679struct VkExternalFenceProperties
1680{
1681	VkStructureType					sType;
1682	void*							pNext;
1683	VkExternalFenceHandleTypeFlags	exportFromImportedHandleTypes;
1684	VkExternalFenceHandleTypeFlags	compatibleHandleTypes;
1685	VkExternalFenceFeatureFlags		externalFenceFeatures;
1686};
1687
1688struct VkExportFenceCreateInfo
1689{
1690	VkStructureType					sType;
1691	const void*						pNext;
1692	VkExternalFenceHandleTypeFlags	handleTypes;
1693};
1694
1695struct VkImportFenceFdInfoKHR
1696{
1697	VkStructureType						sType;
1698	const void*							pNext;
1699	VkFence								fence;
1700	VkFenceImportFlags					flags;
1701	VkExternalFenceHandleTypeFlagBits	handleType;
1702	int									fd;
1703};
1704
1705struct VkFenceGetFdInfoKHR
1706{
1707	VkStructureType						sType;
1708	const void*							pNext;
1709	VkFence								fence;
1710	VkExternalFenceHandleTypeFlagBits	handleType;
1711};
1712
1713struct VkExportFenceSciSyncInfoNV
1714{
1715	VkStructureType			sType;
1716	const void*				pNext;
1717	pt::NvSciSyncAttrList	pAttributes;
1718};
1719
1720struct VkImportFenceSciSyncInfoNV
1721{
1722	VkStructureType						sType;
1723	const void*							pNext;
1724	VkFence								fence;
1725	VkExternalFenceHandleTypeFlagBits	handleType;
1726	void*								handle;
1727};
1728
1729struct VkFenceGetSciSyncInfoNV
1730{
1731	VkStructureType						sType;
1732	const void*							pNext;
1733	VkFence								fence;
1734	VkExternalFenceHandleTypeFlagBits	handleType;
1735};
1736
1737struct VkExportSemaphoreSciSyncInfoNV
1738{
1739	VkStructureType			sType;
1740	const void*				pNext;
1741	pt::NvSciSyncAttrList	pAttributes;
1742};
1743
1744struct VkImportSemaphoreSciSyncInfoNV
1745{
1746	VkStructureType							sType;
1747	const void*								pNext;
1748	VkSemaphore								semaphore;
1749	VkExternalSemaphoreHandleTypeFlagBits	handleType;
1750	void*									handle;
1751};
1752
1753struct VkSemaphoreGetSciSyncInfoNV
1754{
1755	VkStructureType							sType;
1756	const void*								pNext;
1757	VkSemaphore								semaphore;
1758	VkExternalSemaphoreHandleTypeFlagBits	handleType;
1759};
1760
1761struct VkSciSyncAttributesInfoNV
1762{
1763	VkStructureType				sType;
1764	const void*					pNext;
1765	VkSciSyncClientTypeNV		clientType;
1766	VkSciSyncPrimitiveTypeNV	primitiveType;
1767};
1768
1769struct VkPhysicalDeviceExternalSciSyncFeaturesNV
1770{
1771	VkStructureType	sType;
1772	void*			pNext;
1773	VkBool32		sciSyncFence;
1774	VkBool32		sciSyncSemaphore;
1775	VkBool32		sciSyncImport;
1776	VkBool32		sciSyncExport;
1777};
1778
1779struct VkPhysicalDeviceExternalSciSync2FeaturesNV
1780{
1781	VkStructureType	sType;
1782	void*			pNext;
1783	VkBool32		sciSyncFence;
1784	VkBool32		sciSyncSemaphore2;
1785	VkBool32		sciSyncImport;
1786	VkBool32		sciSyncExport;
1787};
1788
1789struct VkSemaphoreSciSyncPoolCreateInfoNV
1790{
1791	VkStructureType		sType;
1792	const void*			pNext;
1793	pt::NvSciSyncObj	handle;
1794};
1795
1796struct VkSemaphoreSciSyncCreateInfoNV
1797{
1798	VkStructureType				sType;
1799	const void*					pNext;
1800	VkSemaphoreSciSyncPoolNV	semaphorePool;
1801	const pt::NvSciSyncFence*	pFence;
1802};
1803
1804struct VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV
1805{
1806	VkStructureType	sType;
1807	const void*		pNext;
1808	uint32_t		semaphoreSciSyncPoolRequestCount;
1809};
1810
1811struct VkPhysicalDeviceMultiviewFeatures
1812{
1813	VkStructureType	sType;
1814	void*			pNext;
1815	VkBool32		multiview;
1816	VkBool32		multiviewGeometryShader;
1817	VkBool32		multiviewTessellationShader;
1818};
1819
1820struct VkPhysicalDeviceMultiviewProperties
1821{
1822	VkStructureType	sType;
1823	void*			pNext;
1824	uint32_t		maxMultiviewViewCount;
1825	uint32_t		maxMultiviewInstanceIndex;
1826};
1827
1828struct VkRenderPassMultiviewCreateInfo
1829{
1830	VkStructureType	sType;
1831	const void*		pNext;
1832	uint32_t		subpassCount;
1833	const uint32_t*	pViewMasks;
1834	uint32_t		dependencyCount;
1835	const int32_t*	pViewOffsets;
1836	uint32_t		correlationMaskCount;
1837	const uint32_t*	pCorrelationMasks;
1838};
1839
1840struct VkSurfaceCapabilities2EXT
1841{
1842	VkStructureType					sType;
1843	void*							pNext;
1844	uint32_t						minImageCount;
1845	uint32_t						maxImageCount;
1846	VkExtent2D						currentExtent;
1847	VkExtent2D						minImageExtent;
1848	VkExtent2D						maxImageExtent;
1849	uint32_t						maxImageArrayLayers;
1850	VkSurfaceTransformFlagsKHR		supportedTransforms;
1851	VkSurfaceTransformFlagBitsKHR	currentTransform;
1852	VkCompositeAlphaFlagsKHR		supportedCompositeAlpha;
1853	VkImageUsageFlags				supportedUsageFlags;
1854	VkSurfaceCounterFlagsEXT		supportedSurfaceCounters;
1855};
1856
1857struct VkDisplayPowerInfoEXT
1858{
1859	VkStructureType			sType;
1860	const void*				pNext;
1861	VkDisplayPowerStateEXT	powerState;
1862};
1863
1864struct VkDeviceEventInfoEXT
1865{
1866	VkStructureType			sType;
1867	const void*				pNext;
1868	VkDeviceEventTypeEXT	deviceEvent;
1869};
1870
1871struct VkDisplayEventInfoEXT
1872{
1873	VkStructureType			sType;
1874	const void*				pNext;
1875	VkDisplayEventTypeEXT	displayEvent;
1876};
1877
1878struct VkSwapchainCounterCreateInfoEXT
1879{
1880	VkStructureType				sType;
1881	const void*					pNext;
1882	VkSurfaceCounterFlagsEXT	surfaceCounters;
1883};
1884
1885struct VkPhysicalDeviceGroupProperties
1886{
1887	VkStructureType		sType;
1888	void*				pNext;
1889	uint32_t			physicalDeviceCount;
1890	VkPhysicalDevice	physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
1891	VkBool32			subsetAllocation;
1892};
1893
1894struct VkMemoryAllocateFlagsInfo
1895{
1896	VkStructureType			sType;
1897	const void*				pNext;
1898	VkMemoryAllocateFlags	flags;
1899	uint32_t				deviceMask;
1900};
1901
1902struct VkBindBufferMemoryInfo
1903{
1904	VkStructureType	sType;
1905	const void*		pNext;
1906	VkBuffer		buffer;
1907	VkDeviceMemory	memory;
1908	VkDeviceSize	memoryOffset;
1909};
1910
1911struct VkBindBufferMemoryDeviceGroupInfo
1912{
1913	VkStructureType	sType;
1914	const void*		pNext;
1915	uint32_t		deviceIndexCount;
1916	const uint32_t*	pDeviceIndices;
1917};
1918
1919struct VkBindImageMemoryInfo
1920{
1921	VkStructureType	sType;
1922	const void*		pNext;
1923	VkImage			image;
1924	VkDeviceMemory	memory;
1925	VkDeviceSize	memoryOffset;
1926};
1927
1928struct VkBindImageMemoryDeviceGroupInfo
1929{
1930	VkStructureType	sType;
1931	const void*		pNext;
1932	uint32_t		deviceIndexCount;
1933	const uint32_t*	pDeviceIndices;
1934	uint32_t		splitInstanceBindRegionCount;
1935	const VkRect2D*	pSplitInstanceBindRegions;
1936};
1937
1938struct VkDeviceGroupRenderPassBeginInfo
1939{
1940	VkStructureType	sType;
1941	const void*		pNext;
1942	uint32_t		deviceMask;
1943	uint32_t		deviceRenderAreaCount;
1944	const VkRect2D*	pDeviceRenderAreas;
1945};
1946
1947struct VkDeviceGroupCommandBufferBeginInfo
1948{
1949	VkStructureType	sType;
1950	const void*		pNext;
1951	uint32_t		deviceMask;
1952};
1953
1954struct VkDeviceGroupSubmitInfo
1955{
1956	VkStructureType	sType;
1957	const void*		pNext;
1958	uint32_t		waitSemaphoreCount;
1959	const uint32_t*	pWaitSemaphoreDeviceIndices;
1960	uint32_t		commandBufferCount;
1961	const uint32_t*	pCommandBufferDeviceMasks;
1962	uint32_t		signalSemaphoreCount;
1963	const uint32_t*	pSignalSemaphoreDeviceIndices;
1964};
1965
1966struct VkDeviceGroupBindSparseInfo
1967{
1968	VkStructureType	sType;
1969	const void*		pNext;
1970	uint32_t		resourceDeviceIndex;
1971	uint32_t		memoryDeviceIndex;
1972};
1973
1974struct VkDeviceGroupPresentCapabilitiesKHR
1975{
1976	VkStructureType						sType;
1977	void*								pNext;
1978	uint32_t							presentMask[VK_MAX_DEVICE_GROUP_SIZE];
1979	VkDeviceGroupPresentModeFlagsKHR	modes;
1980};
1981
1982struct VkImageSwapchainCreateInfoKHR
1983{
1984	VkStructureType	sType;
1985	const void*		pNext;
1986	VkSwapchainKHR	swapchain;
1987};
1988
1989struct VkBindImageMemorySwapchainInfoKHR
1990{
1991	VkStructureType	sType;
1992	const void*		pNext;
1993	VkSwapchainKHR	swapchain;
1994	uint32_t		imageIndex;
1995};
1996
1997struct VkAcquireNextImageInfoKHR
1998{
1999	VkStructureType	sType;
2000	const void*		pNext;
2001	VkSwapchainKHR	swapchain;
2002	uint64_t		timeout;
2003	VkSemaphore		semaphore;
2004	VkFence			fence;
2005	uint32_t		deviceMask;
2006};
2007
2008struct VkDeviceGroupPresentInfoKHR
2009{
2010	VkStructureType						sType;
2011	const void*							pNext;
2012	uint32_t							swapchainCount;
2013	const uint32_t*						pDeviceMasks;
2014	VkDeviceGroupPresentModeFlagBitsKHR	mode;
2015};
2016
2017struct VkDeviceGroupDeviceCreateInfo
2018{
2019	VkStructureType			sType;
2020	const void*				pNext;
2021	uint32_t				physicalDeviceCount;
2022	const VkPhysicalDevice*	pPhysicalDevices;
2023};
2024
2025struct VkDeviceGroupSwapchainCreateInfoKHR
2026{
2027	VkStructureType						sType;
2028	const void*							pNext;
2029	VkDeviceGroupPresentModeFlagsKHR	modes;
2030};
2031
2032struct VkDescriptorUpdateTemplateEntry
2033{
2034	uint32_t			dstBinding;
2035	uint32_t			dstArrayElement;
2036	uint32_t			descriptorCount;
2037	VkDescriptorType	descriptorType;
2038	size_t				offset;
2039	size_t				stride;
2040};
2041
2042struct VkDescriptorUpdateTemplateCreateInfo
2043{
2044	VkStructureType							sType;
2045	const void*								pNext;
2046	VkDescriptorUpdateTemplateCreateFlags	flags;
2047	uint32_t								descriptorUpdateEntryCount;
2048	const VkDescriptorUpdateTemplateEntry*	pDescriptorUpdateEntries;
2049	VkDescriptorUpdateTemplateType			templateType;
2050	VkDescriptorSetLayout					descriptorSetLayout;
2051	VkPipelineBindPoint						pipelineBindPoint;
2052	VkPipelineLayout						pipelineLayout;
2053	uint32_t								set;
2054};
2055
2056struct VkXYColorEXT
2057{
2058	float	x;
2059	float	y;
2060};
2061
2062struct VkHdrMetadataEXT
2063{
2064	VkStructureType	sType;
2065	const void*		pNext;
2066	VkXYColorEXT	displayPrimaryRed;
2067	VkXYColorEXT	displayPrimaryGreen;
2068	VkXYColorEXT	displayPrimaryBlue;
2069	VkXYColorEXT	whitePoint;
2070	float			maxLuminance;
2071	float			minLuminance;
2072	float			maxContentLightLevel;
2073	float			maxFrameAverageLightLevel;
2074};
2075
2076struct VkPhysicalDeviceDiscardRectanglePropertiesEXT
2077{
2078	VkStructureType	sType;
2079	void*			pNext;
2080	uint32_t		maxDiscardRectangles;
2081};
2082
2083struct VkPipelineDiscardRectangleStateCreateInfoEXT
2084{
2085	VkStructureType									sType;
2086	const void*										pNext;
2087	VkPipelineDiscardRectangleStateCreateFlagsEXT	flags;
2088	VkDiscardRectangleModeEXT						discardRectangleMode;
2089	uint32_t										discardRectangleCount;
2090	const VkRect2D*									pDiscardRectangles;
2091};
2092
2093struct VkInputAttachmentAspectReference
2094{
2095	uint32_t			subpass;
2096	uint32_t			inputAttachmentIndex;
2097	VkImageAspectFlags	aspectMask;
2098};
2099
2100struct VkRenderPassInputAttachmentAspectCreateInfo
2101{
2102	VkStructureType							sType;
2103	const void*								pNext;
2104	uint32_t								aspectReferenceCount;
2105	const VkInputAttachmentAspectReference*	pAspectReferences;
2106};
2107
2108struct VkPhysicalDeviceSurfaceInfo2KHR
2109{
2110	VkStructureType	sType;
2111	const void*		pNext;
2112	VkSurfaceKHR	surface;
2113};
2114
2115struct VkSurfaceCapabilities2KHR
2116{
2117	VkStructureType				sType;
2118	void*						pNext;
2119	VkSurfaceCapabilitiesKHR	surfaceCapabilities;
2120};
2121
2122struct VkSurfaceFormat2KHR
2123{
2124	VkStructureType		sType;
2125	void*				pNext;
2126	VkSurfaceFormatKHR	surfaceFormat;
2127};
2128
2129struct VkDisplayProperties2KHR
2130{
2131	VkStructureType			sType;
2132	void*					pNext;
2133	VkDisplayPropertiesKHR	displayProperties;
2134};
2135
2136struct VkDisplayPlaneProperties2KHR
2137{
2138	VkStructureType				sType;
2139	void*						pNext;
2140	VkDisplayPlanePropertiesKHR	displayPlaneProperties;
2141};
2142
2143struct VkDisplayModeProperties2KHR
2144{
2145	VkStructureType				sType;
2146	void*						pNext;
2147	VkDisplayModePropertiesKHR	displayModeProperties;
2148};
2149
2150struct VkDisplayPlaneInfo2KHR
2151{
2152	VkStructureType		sType;
2153	const void*			pNext;
2154	VkDisplayModeKHR	mode;
2155	uint32_t			planeIndex;
2156};
2157
2158struct VkDisplayPlaneCapabilities2KHR
2159{
2160	VkStructureType					sType;
2161	void*							pNext;
2162	VkDisplayPlaneCapabilitiesKHR	capabilities;
2163};
2164
2165struct VkSharedPresentSurfaceCapabilitiesKHR
2166{
2167	VkStructureType		sType;
2168	void*				pNext;
2169	VkImageUsageFlags	sharedPresentSupportedUsageFlags;
2170};
2171
2172struct VkPhysicalDevice16BitStorageFeatures
2173{
2174	VkStructureType	sType;
2175	void*			pNext;
2176	VkBool32		storageBuffer16BitAccess;
2177	VkBool32		uniformAndStorageBuffer16BitAccess;
2178	VkBool32		storagePushConstant16;
2179	VkBool32		storageInputOutput16;
2180};
2181
2182struct VkPhysicalDeviceSubgroupProperties
2183{
2184	VkStructureType			sType;
2185	void*					pNext;
2186	uint32_t				subgroupSize;
2187	VkShaderStageFlags		supportedStages;
2188	VkSubgroupFeatureFlags	supportedOperations;
2189	VkBool32				quadOperationsInAllStages;
2190};
2191
2192struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures
2193{
2194	VkStructureType	sType;
2195	void*			pNext;
2196	VkBool32		shaderSubgroupExtendedTypes;
2197};
2198
2199struct VkBufferMemoryRequirementsInfo2
2200{
2201	VkStructureType	sType;
2202	const void*		pNext;
2203	VkBuffer		buffer;
2204};
2205
2206struct VkImageMemoryRequirementsInfo2
2207{
2208	VkStructureType	sType;
2209	const void*		pNext;
2210	VkImage			image;
2211};
2212
2213struct VkImageSparseMemoryRequirementsInfo2
2214{
2215	VkStructureType	sType;
2216	const void*		pNext;
2217	VkImage			image;
2218};
2219
2220struct VkMemoryRequirements2
2221{
2222	VkStructureType			sType;
2223	void*					pNext;
2224	VkMemoryRequirements	memoryRequirements;
2225};
2226
2227struct VkSparseImageMemoryRequirements2
2228{
2229	VkStructureType					sType;
2230	void*							pNext;
2231	VkSparseImageMemoryRequirements	memoryRequirements;
2232};
2233
2234struct VkPhysicalDevicePointClippingProperties
2235{
2236	VkStructureType			sType;
2237	void*					pNext;
2238	VkPointClippingBehavior	pointClippingBehavior;
2239};
2240
2241struct VkMemoryDedicatedRequirements
2242{
2243	VkStructureType	sType;
2244	void*			pNext;
2245	VkBool32		prefersDedicatedAllocation;
2246	VkBool32		requiresDedicatedAllocation;
2247};
2248
2249struct VkMemoryDedicatedAllocateInfo
2250{
2251	VkStructureType	sType;
2252	const void*		pNext;
2253	VkImage			image;
2254	VkBuffer		buffer;
2255};
2256
2257struct VkImageViewUsageCreateInfo
2258{
2259	VkStructureType		sType;
2260	const void*			pNext;
2261	VkImageUsageFlags	usage;
2262};
2263
2264struct VkPipelineTessellationDomainOriginStateCreateInfo
2265{
2266	VkStructureType				sType;
2267	const void*					pNext;
2268	VkTessellationDomainOrigin	domainOrigin;
2269};
2270
2271struct VkSamplerYcbcrConversionInfo
2272{
2273	VkStructureType				sType;
2274	const void*					pNext;
2275	VkSamplerYcbcrConversion	conversion;
2276};
2277
2278struct VkSamplerYcbcrConversionCreateInfo
2279{
2280	VkStructureType					sType;
2281	const void*						pNext;
2282	VkFormat						format;
2283	VkSamplerYcbcrModelConversion	ycbcrModel;
2284	VkSamplerYcbcrRange				ycbcrRange;
2285	VkComponentMapping				components;
2286	VkChromaLocation				xChromaOffset;
2287	VkChromaLocation				yChromaOffset;
2288	VkFilter						chromaFilter;
2289	VkBool32						forceExplicitReconstruction;
2290};
2291
2292struct VkBindImagePlaneMemoryInfo
2293{
2294	VkStructureType			sType;
2295	const void*				pNext;
2296	VkImageAspectFlagBits	planeAspect;
2297};
2298
2299struct VkImagePlaneMemoryRequirementsInfo
2300{
2301	VkStructureType			sType;
2302	const void*				pNext;
2303	VkImageAspectFlagBits	planeAspect;
2304};
2305
2306struct VkPhysicalDeviceSamplerYcbcrConversionFeatures
2307{
2308	VkStructureType	sType;
2309	void*			pNext;
2310	VkBool32		samplerYcbcrConversion;
2311};
2312
2313struct VkSamplerYcbcrConversionImageFormatProperties
2314{
2315	VkStructureType	sType;
2316	void*			pNext;
2317	uint32_t		combinedImageSamplerDescriptorCount;
2318};
2319
2320struct VkProtectedSubmitInfo
2321{
2322	VkStructureType	sType;
2323	const void*		pNext;
2324	VkBool32		protectedSubmit;
2325};
2326
2327struct VkPhysicalDeviceProtectedMemoryFeatures
2328{
2329	VkStructureType	sType;
2330	void*			pNext;
2331	VkBool32		protectedMemory;
2332};
2333
2334struct VkPhysicalDeviceProtectedMemoryProperties
2335{
2336	VkStructureType	sType;
2337	void*			pNext;
2338	VkBool32		protectedNoFault;
2339};
2340
2341struct VkDeviceQueueInfo2
2342{
2343	VkStructureType				sType;
2344	const void*					pNext;
2345	VkDeviceQueueCreateFlags	flags;
2346	uint32_t					queueFamilyIndex;
2347	uint32_t					queueIndex;
2348};
2349
2350struct VkPhysicalDeviceSamplerFilterMinmaxProperties
2351{
2352	VkStructureType	sType;
2353	void*			pNext;
2354	VkBool32		filterMinmaxSingleComponentFormats;
2355	VkBool32		filterMinmaxImageComponentMapping;
2356};
2357
2358struct VkSampleLocationEXT
2359{
2360	float	x;
2361	float	y;
2362};
2363
2364struct VkSampleLocationsInfoEXT
2365{
2366	VkStructureType				sType;
2367	const void*					pNext;
2368	VkSampleCountFlagBits		sampleLocationsPerPixel;
2369	VkExtent2D					sampleLocationGridSize;
2370	uint32_t					sampleLocationsCount;
2371	const VkSampleLocationEXT*	pSampleLocations;
2372};
2373
2374struct VkAttachmentSampleLocationsEXT
2375{
2376	uint32_t					attachmentIndex;
2377	VkSampleLocationsInfoEXT	sampleLocationsInfo;
2378};
2379
2380struct VkSubpassSampleLocationsEXT
2381{
2382	uint32_t					subpassIndex;
2383	VkSampleLocationsInfoEXT	sampleLocationsInfo;
2384};
2385
2386struct VkRenderPassSampleLocationsBeginInfoEXT
2387{
2388	VkStructureType							sType;
2389	const void*								pNext;
2390	uint32_t								attachmentInitialSampleLocationsCount;
2391	const VkAttachmentSampleLocationsEXT*	pAttachmentInitialSampleLocations;
2392	uint32_t								postSubpassSampleLocationsCount;
2393	const VkSubpassSampleLocationsEXT*		pPostSubpassSampleLocations;
2394};
2395
2396struct VkPipelineSampleLocationsStateCreateInfoEXT
2397{
2398	VkStructureType				sType;
2399	const void*					pNext;
2400	VkBool32					sampleLocationsEnable;
2401	VkSampleLocationsInfoEXT	sampleLocationsInfo;
2402};
2403
2404struct VkPhysicalDeviceSampleLocationsPropertiesEXT
2405{
2406	VkStructureType		sType;
2407	void*				pNext;
2408	VkSampleCountFlags	sampleLocationSampleCounts;
2409	VkExtent2D			maxSampleLocationGridSize;
2410	float				sampleLocationCoordinateRange[2];
2411	uint32_t			sampleLocationSubPixelBits;
2412	VkBool32			variableSampleLocations;
2413};
2414
2415struct VkMultisamplePropertiesEXT
2416{
2417	VkStructureType	sType;
2418	void*			pNext;
2419	VkExtent2D		maxSampleLocationGridSize;
2420};
2421
2422struct VkSamplerReductionModeCreateInfo
2423{
2424	VkStructureType			sType;
2425	const void*				pNext;
2426	VkSamplerReductionMode	reductionMode;
2427};
2428
2429struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT
2430{
2431	VkStructureType	sType;
2432	void*			pNext;
2433	VkBool32		advancedBlendCoherentOperations;
2434};
2435
2436struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT
2437{
2438	VkStructureType	sType;
2439	void*			pNext;
2440	uint32_t		advancedBlendMaxColorAttachments;
2441	VkBool32		advancedBlendIndependentBlend;
2442	VkBool32		advancedBlendNonPremultipliedSrcColor;
2443	VkBool32		advancedBlendNonPremultipliedDstColor;
2444	VkBool32		advancedBlendCorrelatedOverlap;
2445	VkBool32		advancedBlendAllOperations;
2446};
2447
2448struct VkPipelineColorBlendAdvancedStateCreateInfoEXT
2449{
2450	VkStructureType		sType;
2451	const void*			pNext;
2452	VkBool32			srcPremultiplied;
2453	VkBool32			dstPremultiplied;
2454	VkBlendOverlapEXT	blendOverlap;
2455};
2456
2457struct VkImageFormatListCreateInfo
2458{
2459	VkStructureType	sType;
2460	const void*		pNext;
2461	uint32_t		viewFormatCount;
2462	const VkFormat*	pViewFormats;
2463};
2464
2465struct VkPhysicalDeviceMaintenance3Properties
2466{
2467	VkStructureType	sType;
2468	void*			pNext;
2469	uint32_t		maxPerSetDescriptors;
2470	VkDeviceSize	maxMemoryAllocationSize;
2471};
2472
2473struct VkDescriptorSetLayoutSupport
2474{
2475	VkStructureType	sType;
2476	void*			pNext;
2477	VkBool32		supported;
2478};
2479
2480struct VkPhysicalDeviceShaderDrawParametersFeatures
2481{
2482	VkStructureType	sType;
2483	void*			pNext;
2484	VkBool32		shaderDrawParameters;
2485};
2486
2487struct VkPhysicalDeviceShaderFloat16Int8Features
2488{
2489	VkStructureType	sType;
2490	void*			pNext;
2491	VkBool32		shaderFloat16;
2492	VkBool32		shaderInt8;
2493};
2494
2495struct VkPhysicalDeviceFloatControlsProperties
2496{
2497	VkStructureType						sType;
2498	void*								pNext;
2499	VkShaderFloatControlsIndependence	denormBehaviorIndependence;
2500	VkShaderFloatControlsIndependence	roundingModeIndependence;
2501	VkBool32							shaderSignedZeroInfNanPreserveFloat16;
2502	VkBool32							shaderSignedZeroInfNanPreserveFloat32;
2503	VkBool32							shaderSignedZeroInfNanPreserveFloat64;
2504	VkBool32							shaderDenormPreserveFloat16;
2505	VkBool32							shaderDenormPreserveFloat32;
2506	VkBool32							shaderDenormPreserveFloat64;
2507	VkBool32							shaderDenormFlushToZeroFloat16;
2508	VkBool32							shaderDenormFlushToZeroFloat32;
2509	VkBool32							shaderDenormFlushToZeroFloat64;
2510	VkBool32							shaderRoundingModeRTEFloat16;
2511	VkBool32							shaderRoundingModeRTEFloat32;
2512	VkBool32							shaderRoundingModeRTEFloat64;
2513	VkBool32							shaderRoundingModeRTZFloat16;
2514	VkBool32							shaderRoundingModeRTZFloat32;
2515	VkBool32							shaderRoundingModeRTZFloat64;
2516};
2517
2518struct VkPhysicalDeviceHostQueryResetFeatures
2519{
2520	VkStructureType	sType;
2521	void*			pNext;
2522	VkBool32		hostQueryReset;
2523};
2524
2525struct VkDeviceQueueGlobalPriorityCreateInfoKHR
2526{
2527	VkStructureType				sType;
2528	const void*					pNext;
2529	VkQueueGlobalPriorityKHR	globalPriority;
2530};
2531
2532struct VkDebugUtilsObjectNameInfoEXT
2533{
2534	VkStructureType	sType;
2535	const void*		pNext;
2536	VkObjectType	objectType;
2537	uint64_t		objectHandle;
2538	const char*		pObjectName;
2539};
2540
2541struct VkDebugUtilsObjectTagInfoEXT
2542{
2543	VkStructureType	sType;
2544	const void*		pNext;
2545	VkObjectType	objectType;
2546	uint64_t		objectHandle;
2547	uint64_t		tagName;
2548	size_t			tagSize;
2549	const void*		pTag;
2550};
2551
2552struct VkDebugUtilsLabelEXT
2553{
2554	VkStructureType	sType;
2555	const void*		pNext;
2556	const char*		pLabelName;
2557	float			color[4];
2558};
2559
2560struct VkDebugUtilsMessengerCreateInfoEXT
2561{
2562	VkStructureType							sType;
2563	const void*								pNext;
2564	VkDebugUtilsMessengerCreateFlagsEXT		flags;
2565	VkDebugUtilsMessageSeverityFlagsEXT		messageSeverity;
2566	VkDebugUtilsMessageTypeFlagsEXT			messageType;
2567	PFN_vkDebugUtilsMessengerCallbackEXT	pfnUserCallback;
2568	void*									pUserData;
2569};
2570
2571struct VkDebugUtilsMessengerCallbackDataEXT
2572{
2573	VkStructureType								sType;
2574	const void*									pNext;
2575	VkDebugUtilsMessengerCallbackDataFlagsEXT	flags;
2576	const char*									pMessageIdName;
2577	int32_t										messageIdNumber;
2578	const char*									pMessage;
2579	uint32_t									queueLabelCount;
2580	const VkDebugUtilsLabelEXT*					pQueueLabels;
2581	uint32_t									cmdBufLabelCount;
2582	const VkDebugUtilsLabelEXT*					pCmdBufLabels;
2583	uint32_t									objectCount;
2584	const VkDebugUtilsObjectNameInfoEXT*		pObjects;
2585};
2586
2587struct VkImportMemoryHostPointerInfoEXT
2588{
2589	VkStructureType						sType;
2590	const void*							pNext;
2591	VkExternalMemoryHandleTypeFlagBits	handleType;
2592	void*								pHostPointer;
2593};
2594
2595struct VkMemoryHostPointerPropertiesEXT
2596{
2597	VkStructureType	sType;
2598	void*			pNext;
2599	uint32_t		memoryTypeBits;
2600};
2601
2602struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT
2603{
2604	VkStructureType	sType;
2605	void*			pNext;
2606	VkDeviceSize	minImportedHostPointerAlignment;
2607};
2608
2609struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT
2610{
2611	VkStructureType	sType;
2612	void*			pNext;
2613	float			primitiveOverestimationSize;
2614	float			maxExtraPrimitiveOverestimationSize;
2615	float			extraPrimitiveOverestimationSizeGranularity;
2616	VkBool32		primitiveUnderestimation;
2617	VkBool32		conservativePointAndLineRasterization;
2618	VkBool32		degenerateTrianglesRasterized;
2619	VkBool32		degenerateLinesRasterized;
2620	VkBool32		fullyCoveredFragmentShaderInputVariable;
2621	VkBool32		conservativeRasterizationPostDepthCoverage;
2622};
2623
2624struct VkCalibratedTimestampInfoEXT
2625{
2626	VkStructureType	sType;
2627	const void*		pNext;
2628	VkTimeDomainEXT	timeDomain;
2629};
2630
2631struct VkPipelineRasterizationConservativeStateCreateInfoEXT
2632{
2633	VkStructureType											sType;
2634	const void*												pNext;
2635	VkPipelineRasterizationConservativeStateCreateFlagsEXT	flags;
2636	VkConservativeRasterizationModeEXT						conservativeRasterizationMode;
2637	float													extraPrimitiveOverestimationSize;
2638};
2639
2640struct VkPhysicalDeviceDescriptorIndexingFeatures
2641{
2642	VkStructureType	sType;
2643	void*			pNext;
2644	VkBool32		shaderInputAttachmentArrayDynamicIndexing;
2645	VkBool32		shaderUniformTexelBufferArrayDynamicIndexing;
2646	VkBool32		shaderStorageTexelBufferArrayDynamicIndexing;
2647	VkBool32		shaderUniformBufferArrayNonUniformIndexing;
2648	VkBool32		shaderSampledImageArrayNonUniformIndexing;
2649	VkBool32		shaderStorageBufferArrayNonUniformIndexing;
2650	VkBool32		shaderStorageImageArrayNonUniformIndexing;
2651	VkBool32		shaderInputAttachmentArrayNonUniformIndexing;
2652	VkBool32		shaderUniformTexelBufferArrayNonUniformIndexing;
2653	VkBool32		shaderStorageTexelBufferArrayNonUniformIndexing;
2654	VkBool32		descriptorBindingUniformBufferUpdateAfterBind;
2655	VkBool32		descriptorBindingSampledImageUpdateAfterBind;
2656	VkBool32		descriptorBindingStorageImageUpdateAfterBind;
2657	VkBool32		descriptorBindingStorageBufferUpdateAfterBind;
2658	VkBool32		descriptorBindingUniformTexelBufferUpdateAfterBind;
2659	VkBool32		descriptorBindingStorageTexelBufferUpdateAfterBind;
2660	VkBool32		descriptorBindingUpdateUnusedWhilePending;
2661	VkBool32		descriptorBindingPartiallyBound;
2662	VkBool32		descriptorBindingVariableDescriptorCount;
2663	VkBool32		runtimeDescriptorArray;
2664};
2665
2666struct VkPhysicalDeviceDescriptorIndexingProperties
2667{
2668	VkStructureType	sType;
2669	void*			pNext;
2670	uint32_t		maxUpdateAfterBindDescriptorsInAllPools;
2671	VkBool32		shaderUniformBufferArrayNonUniformIndexingNative;
2672	VkBool32		shaderSampledImageArrayNonUniformIndexingNative;
2673	VkBool32		shaderStorageBufferArrayNonUniformIndexingNative;
2674	VkBool32		shaderStorageImageArrayNonUniformIndexingNative;
2675	VkBool32		shaderInputAttachmentArrayNonUniformIndexingNative;
2676	VkBool32		robustBufferAccessUpdateAfterBind;
2677	VkBool32		quadDivergentImplicitLod;
2678	uint32_t		maxPerStageDescriptorUpdateAfterBindSamplers;
2679	uint32_t		maxPerStageDescriptorUpdateAfterBindUniformBuffers;
2680	uint32_t		maxPerStageDescriptorUpdateAfterBindStorageBuffers;
2681	uint32_t		maxPerStageDescriptorUpdateAfterBindSampledImages;
2682	uint32_t		maxPerStageDescriptorUpdateAfterBindStorageImages;
2683	uint32_t		maxPerStageDescriptorUpdateAfterBindInputAttachments;
2684	uint32_t		maxPerStageUpdateAfterBindResources;
2685	uint32_t		maxDescriptorSetUpdateAfterBindSamplers;
2686	uint32_t		maxDescriptorSetUpdateAfterBindUniformBuffers;
2687	uint32_t		maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
2688	uint32_t		maxDescriptorSetUpdateAfterBindStorageBuffers;
2689	uint32_t		maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
2690	uint32_t		maxDescriptorSetUpdateAfterBindSampledImages;
2691	uint32_t		maxDescriptorSetUpdateAfterBindStorageImages;
2692	uint32_t		maxDescriptorSetUpdateAfterBindInputAttachments;
2693};
2694
2695struct VkDescriptorSetLayoutBindingFlagsCreateInfo
2696{
2697	VkStructureType					sType;
2698	const void*						pNext;
2699	uint32_t						bindingCount;
2700	const VkDescriptorBindingFlags*	pBindingFlags;
2701};
2702
2703struct VkDescriptorSetVariableDescriptorCountAllocateInfo
2704{
2705	VkStructureType	sType;
2706	const void*		pNext;
2707	uint32_t		descriptorSetCount;
2708	const uint32_t*	pDescriptorCounts;
2709};
2710
2711struct VkDescriptorSetVariableDescriptorCountLayoutSupport
2712{
2713	VkStructureType	sType;
2714	void*			pNext;
2715	uint32_t		maxVariableDescriptorCount;
2716};
2717
2718struct VkAttachmentDescription2
2719{
2720	VkStructureType					sType;
2721	const void*						pNext;
2722	VkAttachmentDescriptionFlags	flags;
2723	VkFormat						format;
2724	VkSampleCountFlagBits			samples;
2725	VkAttachmentLoadOp				loadOp;
2726	VkAttachmentStoreOp				storeOp;
2727	VkAttachmentLoadOp				stencilLoadOp;
2728	VkAttachmentStoreOp				stencilStoreOp;
2729	VkImageLayout					initialLayout;
2730	VkImageLayout					finalLayout;
2731};
2732
2733struct VkAttachmentReference2
2734{
2735	VkStructureType		sType;
2736	const void*			pNext;
2737	uint32_t			attachment;
2738	VkImageLayout		layout;
2739	VkImageAspectFlags	aspectMask;
2740};
2741
2742struct VkSubpassDescription2
2743{
2744	VkStructureType					sType;
2745	const void*						pNext;
2746	VkSubpassDescriptionFlags		flags;
2747	VkPipelineBindPoint				pipelineBindPoint;
2748	uint32_t						viewMask;
2749	uint32_t						inputAttachmentCount;
2750	const VkAttachmentReference2*	pInputAttachments;
2751	uint32_t						colorAttachmentCount;
2752	const VkAttachmentReference2*	pColorAttachments;
2753	const VkAttachmentReference2*	pResolveAttachments;
2754	const VkAttachmentReference2*	pDepthStencilAttachment;
2755	uint32_t						preserveAttachmentCount;
2756	const uint32_t*					pPreserveAttachments;
2757};
2758
2759struct VkSubpassDependency2
2760{
2761	VkStructureType			sType;
2762	const void*				pNext;
2763	uint32_t				srcSubpass;
2764	uint32_t				dstSubpass;
2765	VkPipelineStageFlags	srcStageMask;
2766	VkPipelineStageFlags	dstStageMask;
2767	VkAccessFlags			srcAccessMask;
2768	VkAccessFlags			dstAccessMask;
2769	VkDependencyFlags		dependencyFlags;
2770	int32_t					viewOffset;
2771};
2772
2773struct VkRenderPassCreateInfo2
2774{
2775	VkStructureType					sType;
2776	const void*						pNext;
2777	VkRenderPassCreateFlags			flags;
2778	uint32_t						attachmentCount;
2779	const VkAttachmentDescription2*	pAttachments;
2780	uint32_t						subpassCount;
2781	const VkSubpassDescription2*	pSubpasses;
2782	uint32_t						dependencyCount;
2783	const VkSubpassDependency2*		pDependencies;
2784	uint32_t						correlatedViewMaskCount;
2785	const uint32_t*					pCorrelatedViewMasks;
2786};
2787
2788struct VkSubpassBeginInfo
2789{
2790	VkStructureType		sType;
2791	const void*			pNext;
2792	VkSubpassContents	contents;
2793};
2794
2795struct VkSubpassEndInfo
2796{
2797	VkStructureType	sType;
2798	const void*		pNext;
2799};
2800
2801struct VkPhysicalDeviceTimelineSemaphoreFeatures
2802{
2803	VkStructureType	sType;
2804	void*			pNext;
2805	VkBool32		timelineSemaphore;
2806};
2807
2808struct VkPhysicalDeviceTimelineSemaphoreProperties
2809{
2810	VkStructureType	sType;
2811	void*			pNext;
2812	uint64_t		maxTimelineSemaphoreValueDifference;
2813};
2814
2815struct VkSemaphoreTypeCreateInfo
2816{
2817	VkStructureType	sType;
2818	const void*		pNext;
2819	VkSemaphoreType	semaphoreType;
2820	uint64_t		initialValue;
2821};
2822
2823struct VkTimelineSemaphoreSubmitInfo
2824{
2825	VkStructureType	sType;
2826	const void*		pNext;
2827	uint32_t		waitSemaphoreValueCount;
2828	const uint64_t*	pWaitSemaphoreValues;
2829	uint32_t		signalSemaphoreValueCount;
2830	const uint64_t*	pSignalSemaphoreValues;
2831};
2832
2833struct VkSemaphoreWaitInfo
2834{
2835	VkStructureType			sType;
2836	const void*				pNext;
2837	VkSemaphoreWaitFlags	flags;
2838	uint32_t				semaphoreCount;
2839	const VkSemaphore*		pSemaphores;
2840	const uint64_t*			pValues;
2841};
2842
2843struct VkSemaphoreSignalInfo
2844{
2845	VkStructureType	sType;
2846	const void*		pNext;
2847	VkSemaphore		semaphore;
2848	uint64_t		value;
2849};
2850
2851struct VkVertexInputBindingDivisorDescriptionEXT
2852{
2853	uint32_t	binding;
2854	uint32_t	divisor;
2855};
2856
2857struct VkPipelineVertexInputDivisorStateCreateInfoEXT
2858{
2859	VkStructureType										sType;
2860	const void*											pNext;
2861	uint32_t											vertexBindingDivisorCount;
2862	const VkVertexInputBindingDivisorDescriptionEXT*	pVertexBindingDivisors;
2863};
2864
2865struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT
2866{
2867	VkStructureType	sType;
2868	void*			pNext;
2869	uint32_t		maxVertexAttribDivisor;
2870};
2871
2872struct VkPhysicalDevicePCIBusInfoPropertiesEXT
2873{
2874	VkStructureType	sType;
2875	void*			pNext;
2876	uint32_t		pciDomain;
2877	uint32_t		pciBus;
2878	uint32_t		pciDevice;
2879	uint32_t		pciFunction;
2880};
2881
2882struct VkPhysicalDevice8BitStorageFeatures
2883{
2884	VkStructureType	sType;
2885	void*			pNext;
2886	VkBool32		storageBuffer8BitAccess;
2887	VkBool32		uniformAndStorageBuffer8BitAccess;
2888	VkBool32		storagePushConstant8;
2889};
2890
2891struct VkPhysicalDeviceVulkanMemoryModelFeatures
2892{
2893	VkStructureType	sType;
2894	void*			pNext;
2895	VkBool32		vulkanMemoryModel;
2896	VkBool32		vulkanMemoryModelDeviceScope;
2897	VkBool32		vulkanMemoryModelAvailabilityVisibilityChains;
2898};
2899
2900struct VkPhysicalDeviceShaderAtomicInt64Features
2901{
2902	VkStructureType	sType;
2903	void*			pNext;
2904	VkBool32		shaderBufferInt64Atomics;
2905	VkBool32		shaderSharedInt64Atomics;
2906};
2907
2908struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT
2909{
2910	VkStructureType	sType;
2911	void*			pNext;
2912	VkBool32		shaderBufferFloat32Atomics;
2913	VkBool32		shaderBufferFloat32AtomicAdd;
2914	VkBool32		shaderBufferFloat64Atomics;
2915	VkBool32		shaderBufferFloat64AtomicAdd;
2916	VkBool32		shaderSharedFloat32Atomics;
2917	VkBool32		shaderSharedFloat32AtomicAdd;
2918	VkBool32		shaderSharedFloat64Atomics;
2919	VkBool32		shaderSharedFloat64AtomicAdd;
2920	VkBool32		shaderImageFloat32Atomics;
2921	VkBool32		shaderImageFloat32AtomicAdd;
2922	VkBool32		sparseImageFloat32Atomics;
2923	VkBool32		sparseImageFloat32AtomicAdd;
2924};
2925
2926struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT
2927{
2928	VkStructureType	sType;
2929	void*			pNext;
2930	VkBool32		vertexAttributeInstanceRateDivisor;
2931	VkBool32		vertexAttributeInstanceRateZeroDivisor;
2932};
2933
2934struct VkQueueFamilyCheckpointPropertiesNV
2935{
2936	VkStructureType			sType;
2937	void*					pNext;
2938	VkPipelineStageFlags	checkpointExecutionStageMask;
2939};
2940
2941struct VkCheckpointDataNV
2942{
2943	VkStructureType			sType;
2944	void*					pNext;
2945	VkPipelineStageFlagBits	stage;
2946	void*					pCheckpointMarker;
2947};
2948
2949struct VkPhysicalDeviceDepthStencilResolveProperties
2950{
2951	VkStructureType		sType;
2952	void*				pNext;
2953	VkResolveModeFlags	supportedDepthResolveModes;
2954	VkResolveModeFlags	supportedStencilResolveModes;
2955	VkBool32			independentResolveNone;
2956	VkBool32			independentResolve;
2957};
2958
2959struct VkSubpassDescriptionDepthStencilResolve
2960{
2961	VkStructureType					sType;
2962	const void*						pNext;
2963	VkResolveModeFlagBits			depthResolveMode;
2964	VkResolveModeFlagBits			stencilResolveMode;
2965	const VkAttachmentReference2*	pDepthStencilResolveAttachment;
2966};
2967
2968struct VkImageViewASTCDecodeModeEXT
2969{
2970	VkStructureType	sType;
2971	const void*		pNext;
2972	VkFormat		decodeMode;
2973};
2974
2975struct VkPhysicalDeviceASTCDecodeFeaturesEXT
2976{
2977	VkStructureType	sType;
2978	void*			pNext;
2979	VkBool32		decodeModeSharedExponent;
2980};
2981
2982struct VkDrmFormatModifierPropertiesEXT
2983{
2984	uint64_t				drmFormatModifier;
2985	uint32_t				drmFormatModifierPlaneCount;
2986	VkFormatFeatureFlags	drmFormatModifierTilingFeatures;
2987};
2988
2989struct VkDrmFormatModifierPropertiesListEXT
2990{
2991	VkStructureType						sType;
2992	void*								pNext;
2993	uint32_t							drmFormatModifierCount;
2994	VkDrmFormatModifierPropertiesEXT*	pDrmFormatModifierProperties;
2995};
2996
2997struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT
2998{
2999	VkStructureType	sType;
3000	const void*		pNext;
3001	uint64_t		drmFormatModifier;
3002	VkSharingMode	sharingMode;
3003	uint32_t		queueFamilyIndexCount;
3004	const uint32_t*	pQueueFamilyIndices;
3005};
3006
3007struct VkImageDrmFormatModifierListCreateInfoEXT
3008{
3009	VkStructureType	sType;
3010	const void*		pNext;
3011	uint32_t		drmFormatModifierCount;
3012	const uint64_t*	pDrmFormatModifiers;
3013};
3014
3015struct VkImageDrmFormatModifierExplicitCreateInfoEXT
3016{
3017	VkStructureType				sType;
3018	const void*					pNext;
3019	uint64_t					drmFormatModifier;
3020	uint32_t					drmFormatModifierPlaneCount;
3021	const VkSubresourceLayout*	pPlaneLayouts;
3022};
3023
3024struct VkImageDrmFormatModifierPropertiesEXT
3025{
3026	VkStructureType	sType;
3027	void*			pNext;
3028	uint64_t		drmFormatModifier;
3029};
3030
3031struct VkImageStencilUsageCreateInfo
3032{
3033	VkStructureType		sType;
3034	const void*			pNext;
3035	VkImageUsageFlags	stencilUsage;
3036};
3037
3038struct VkPhysicalDeviceScalarBlockLayoutFeatures
3039{
3040	VkStructureType	sType;
3041	void*			pNext;
3042	VkBool32		scalarBlockLayout;
3043};
3044
3045struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures
3046{
3047	VkStructureType	sType;
3048	void*			pNext;
3049	VkBool32		uniformBufferStandardLayout;
3050};
3051
3052struct VkPhysicalDeviceDepthClipEnableFeaturesEXT
3053{
3054	VkStructureType	sType;
3055	void*			pNext;
3056	VkBool32		depthClipEnable;
3057};
3058
3059struct VkPipelineRasterizationDepthClipStateCreateInfoEXT
3060{
3061	VkStructureType										sType;
3062	const void*											pNext;
3063	VkPipelineRasterizationDepthClipStateCreateFlagsEXT	flags;
3064	VkBool32											depthClipEnable;
3065};
3066
3067struct VkPhysicalDeviceMemoryBudgetPropertiesEXT
3068{
3069	VkStructureType	sType;
3070	void*			pNext;
3071	VkDeviceSize	heapBudget[VK_MAX_MEMORY_HEAPS];
3072	VkDeviceSize	heapUsage[VK_MAX_MEMORY_HEAPS];
3073};
3074
3075struct VkPhysicalDeviceBufferDeviceAddressFeatures
3076{
3077	VkStructureType	sType;
3078	void*			pNext;
3079	VkBool32		bufferDeviceAddress;
3080	VkBool32		bufferDeviceAddressCaptureReplay;
3081	VkBool32		bufferDeviceAddressMultiDevice;
3082};
3083
3084struct VkBufferDeviceAddressInfo
3085{
3086	VkStructureType	sType;
3087	const void*		pNext;
3088	VkBuffer		buffer;
3089};
3090
3091struct VkBufferOpaqueCaptureAddressCreateInfo
3092{
3093	VkStructureType	sType;
3094	const void*		pNext;
3095	uint64_t		opaqueCaptureAddress;
3096};
3097
3098struct VkPhysicalDeviceImageViewImageFormatInfoEXT
3099{
3100	VkStructureType	sType;
3101	void*			pNext;
3102	VkImageViewType	imageViewType;
3103};
3104
3105struct VkFilterCubicImageViewImageFormatPropertiesEXT
3106{
3107	VkStructureType	sType;
3108	void*			pNext;
3109	VkBool32		filterCubic;
3110	VkBool32		filterCubicMinmax;
3111};
3112
3113struct VkPhysicalDeviceImagelessFramebufferFeatures
3114{
3115	VkStructureType	sType;
3116	void*			pNext;
3117	VkBool32		imagelessFramebuffer;
3118};
3119
3120struct VkFramebufferAttachmentImageInfo
3121{
3122	VkStructureType		sType;
3123	const void*			pNext;
3124	VkImageCreateFlags	flags;
3125	VkImageUsageFlags	usage;
3126	uint32_t			width;
3127	uint32_t			height;
3128	uint32_t			layerCount;
3129	uint32_t			viewFormatCount;
3130	const VkFormat*		pViewFormats;
3131};
3132
3133struct VkFramebufferAttachmentsCreateInfo
3134{
3135	VkStructureType							sType;
3136	const void*								pNext;
3137	uint32_t								attachmentImageInfoCount;
3138	const VkFramebufferAttachmentImageInfo*	pAttachmentImageInfos;
3139};
3140
3141struct VkRenderPassAttachmentBeginInfo
3142{
3143	VkStructureType		sType;
3144	const void*			pNext;
3145	uint32_t			attachmentCount;
3146	const VkImageView*	pAttachments;
3147};
3148
3149struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
3150{
3151	VkStructureType	sType;
3152	void*			pNext;
3153	VkBool32		textureCompressionASTC_HDR;
3154};
3155
3156struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT
3157{
3158	VkStructureType	sType;
3159	void*			pNext;
3160	VkBool32		ycbcrImageArrays;
3161};
3162
3163struct VkPhysicalDevicePerformanceQueryFeaturesKHR
3164{
3165	VkStructureType	sType;
3166	void*			pNext;
3167	VkBool32		performanceCounterQueryPools;
3168	VkBool32		performanceCounterMultipleQueryPools;
3169};
3170
3171struct VkPhysicalDevicePerformanceQueryPropertiesKHR
3172{
3173	VkStructureType	sType;
3174	void*			pNext;
3175	VkBool32		allowCommandBufferQueryCopies;
3176};
3177
3178struct VkPerformanceCounterKHR
3179{
3180	VkStructureType					sType;
3181	void*							pNext;
3182	VkPerformanceCounterUnitKHR		unit;
3183	VkPerformanceCounterScopeKHR	scope;
3184	VkPerformanceCounterStorageKHR	storage;
3185	uint8_t							uuid[VK_UUID_SIZE];
3186};
3187
3188struct VkPerformanceCounterDescriptionKHR
3189{
3190	VkStructureType							sType;
3191	void*									pNext;
3192	VkPerformanceCounterDescriptionFlagsKHR	flags;
3193	char									name[VK_MAX_DESCRIPTION_SIZE];
3194	char									category[VK_MAX_DESCRIPTION_SIZE];
3195	char									description[VK_MAX_DESCRIPTION_SIZE];
3196};
3197
3198struct VkQueryPoolPerformanceCreateInfoKHR
3199{
3200	VkStructureType	sType;
3201	const void*		pNext;
3202	uint32_t		queueFamilyIndex;
3203	uint32_t		counterIndexCount;
3204	const uint32_t*	pCounterIndices;
3205};
3206
3207union VkPerformanceCounterResultKHR
3208{
3209	int32_t		int32;
3210	int64_t		int64;
3211	uint32_t	uint32;
3212	uint64_t	uint64;
3213	float		float32;
3214	double		float64;
3215};
3216
3217struct VkAcquireProfilingLockInfoKHR
3218{
3219	VkStructureType					sType;
3220	const void*						pNext;
3221	VkAcquireProfilingLockFlagsKHR	flags;
3222	uint64_t						timeout;
3223};
3224
3225struct VkPerformanceQuerySubmitInfoKHR
3226{
3227	VkStructureType	sType;
3228	const void*		pNext;
3229	uint32_t		counterPassIndex;
3230};
3231
3232struct VkPerformanceQueryReservationInfoKHR
3233{
3234	VkStructureType	sType;
3235	const void*		pNext;
3236	uint32_t		maxPerformanceQueriesPerPool;
3237};
3238
3239struct VkHeadlessSurfaceCreateInfoEXT
3240{
3241	VkStructureType					sType;
3242	const void*						pNext;
3243	VkHeadlessSurfaceCreateFlagsEXT	flags;
3244};
3245
3246struct VkPhysicalDeviceShaderClockFeaturesKHR
3247{
3248	VkStructureType	sType;
3249	void*			pNext;
3250	VkBool32		shaderSubgroupClock;
3251	VkBool32		shaderDeviceClock;
3252};
3253
3254struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT
3255{
3256	VkStructureType	sType;
3257	void*			pNext;
3258	VkBool32		indexTypeUint8;
3259};
3260
3261struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT
3262{
3263	VkStructureType	sType;
3264	void*			pNext;
3265	VkBool32		fragmentShaderSampleInterlock;
3266	VkBool32		fragmentShaderPixelInterlock;
3267	VkBool32		fragmentShaderShadingRateInterlock;
3268};
3269
3270struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures
3271{
3272	VkStructureType	sType;
3273	void*			pNext;
3274	VkBool32		separateDepthStencilLayouts;
3275};
3276
3277struct VkAttachmentReferenceStencilLayout
3278{
3279	VkStructureType	sType;
3280	void*			pNext;
3281	VkImageLayout	stencilLayout;
3282};
3283
3284struct VkAttachmentDescriptionStencilLayout
3285{
3286	VkStructureType	sType;
3287	void*			pNext;
3288	VkImageLayout	stencilInitialLayout;
3289	VkImageLayout	stencilFinalLayout;
3290};
3291
3292struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
3293{
3294	VkStructureType	sType;
3295	void*			pNext;
3296	VkBool32		shaderDemoteToHelperInvocation;
3297};
3298
3299struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT
3300{
3301	VkStructureType	sType;
3302	void*			pNext;
3303	VkBool32		texelBufferAlignment;
3304};
3305
3306struct VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT
3307{
3308	VkStructureType	sType;
3309	void*			pNext;
3310	VkDeviceSize	storageTexelBufferOffsetAlignmentBytes;
3311	VkBool32		storageTexelBufferOffsetSingleTexelAlignment;
3312	VkDeviceSize	uniformTexelBufferOffsetAlignmentBytes;
3313	VkBool32		uniformTexelBufferOffsetSingleTexelAlignment;
3314};
3315
3316struct VkPhysicalDeviceSubgroupSizeControlFeaturesEXT
3317{
3318	VkStructureType	sType;
3319	void*			pNext;
3320	VkBool32		subgroupSizeControl;
3321	VkBool32		computeFullSubgroups;
3322};
3323
3324struct VkPhysicalDeviceSubgroupSizeControlPropertiesEXT
3325{
3326	VkStructureType		sType;
3327	void*				pNext;
3328	uint32_t			minSubgroupSize;
3329	uint32_t			maxSubgroupSize;
3330	uint32_t			maxComputeWorkgroupSubgroups;
3331	VkShaderStageFlags	requiredSubgroupSizeStages;
3332};
3333
3334struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
3335{
3336	VkStructureType	sType;
3337	void*			pNext;
3338	uint32_t		requiredSubgroupSize;
3339};
3340
3341struct VkMemoryOpaqueCaptureAddressAllocateInfo
3342{
3343	VkStructureType	sType;
3344	const void*		pNext;
3345	uint64_t		opaqueCaptureAddress;
3346};
3347
3348struct VkDeviceMemoryOpaqueCaptureAddressInfo
3349{
3350	VkStructureType	sType;
3351	const void*		pNext;
3352	VkDeviceMemory	memory;
3353};
3354
3355struct VkPhysicalDeviceLineRasterizationFeaturesEXT
3356{
3357	VkStructureType	sType;
3358	void*			pNext;
3359	VkBool32		rectangularLines;
3360	VkBool32		bresenhamLines;
3361	VkBool32		smoothLines;
3362	VkBool32		stippledRectangularLines;
3363	VkBool32		stippledBresenhamLines;
3364	VkBool32		stippledSmoothLines;
3365};
3366
3367struct VkPhysicalDeviceLineRasterizationPropertiesEXT
3368{
3369	VkStructureType	sType;
3370	void*			pNext;
3371	uint32_t		lineSubPixelPrecisionBits;
3372};
3373
3374struct VkPipelineRasterizationLineStateCreateInfoEXT
3375{
3376	VkStructureType				sType;
3377	const void*					pNext;
3378	VkLineRasterizationModeEXT	lineRasterizationMode;
3379	VkBool32					stippledLineEnable;
3380	uint32_t					lineStippleFactor;
3381	uint16_t					lineStipplePattern;
3382};
3383
3384struct VkPhysicalDeviceVulkan11Features
3385{
3386	VkStructureType	sType;
3387	void*			pNext;
3388	VkBool32		storageBuffer16BitAccess;
3389	VkBool32		uniformAndStorageBuffer16BitAccess;
3390	VkBool32		storagePushConstant16;
3391	VkBool32		storageInputOutput16;
3392	VkBool32		multiview;
3393	VkBool32		multiviewGeometryShader;
3394	VkBool32		multiviewTessellationShader;
3395	VkBool32		variablePointersStorageBuffer;
3396	VkBool32		variablePointers;
3397	VkBool32		protectedMemory;
3398	VkBool32		samplerYcbcrConversion;
3399	VkBool32		shaderDrawParameters;
3400};
3401
3402struct VkPhysicalDeviceVulkan11Properties
3403{
3404	VkStructureType			sType;
3405	void*					pNext;
3406	uint8_t					deviceUUID[VK_UUID_SIZE];
3407	uint8_t					driverUUID[VK_UUID_SIZE];
3408	uint8_t					deviceLUID[VK_LUID_SIZE];
3409	uint32_t				deviceNodeMask;
3410	VkBool32				deviceLUIDValid;
3411	uint32_t				subgroupSize;
3412	VkShaderStageFlags		subgroupSupportedStages;
3413	VkSubgroupFeatureFlags	subgroupSupportedOperations;
3414	VkBool32				subgroupQuadOperationsInAllStages;
3415	VkPointClippingBehavior	pointClippingBehavior;
3416	uint32_t				maxMultiviewViewCount;
3417	uint32_t				maxMultiviewInstanceIndex;
3418	VkBool32				protectedNoFault;
3419	uint32_t				maxPerSetDescriptors;
3420	VkDeviceSize			maxMemoryAllocationSize;
3421};
3422
3423struct VkPhysicalDeviceVulkan12Features
3424{
3425	VkStructureType	sType;
3426	void*			pNext;
3427	VkBool32		samplerMirrorClampToEdge;
3428	VkBool32		drawIndirectCount;
3429	VkBool32		storageBuffer8BitAccess;
3430	VkBool32		uniformAndStorageBuffer8BitAccess;
3431	VkBool32		storagePushConstant8;
3432	VkBool32		shaderBufferInt64Atomics;
3433	VkBool32		shaderSharedInt64Atomics;
3434	VkBool32		shaderFloat16;
3435	VkBool32		shaderInt8;
3436	VkBool32		descriptorIndexing;
3437	VkBool32		shaderInputAttachmentArrayDynamicIndexing;
3438	VkBool32		shaderUniformTexelBufferArrayDynamicIndexing;
3439	VkBool32		shaderStorageTexelBufferArrayDynamicIndexing;
3440	VkBool32		shaderUniformBufferArrayNonUniformIndexing;
3441	VkBool32		shaderSampledImageArrayNonUniformIndexing;
3442	VkBool32		shaderStorageBufferArrayNonUniformIndexing;
3443	VkBool32		shaderStorageImageArrayNonUniformIndexing;
3444	VkBool32		shaderInputAttachmentArrayNonUniformIndexing;
3445	VkBool32		shaderUniformTexelBufferArrayNonUniformIndexing;
3446	VkBool32		shaderStorageTexelBufferArrayNonUniformIndexing;
3447	VkBool32		descriptorBindingUniformBufferUpdateAfterBind;
3448	VkBool32		descriptorBindingSampledImageUpdateAfterBind;
3449	VkBool32		descriptorBindingStorageImageUpdateAfterBind;
3450	VkBool32		descriptorBindingStorageBufferUpdateAfterBind;
3451	VkBool32		descriptorBindingUniformTexelBufferUpdateAfterBind;
3452	VkBool32		descriptorBindingStorageTexelBufferUpdateAfterBind;
3453	VkBool32		descriptorBindingUpdateUnusedWhilePending;
3454	VkBool32		descriptorBindingPartiallyBound;
3455	VkBool32		descriptorBindingVariableDescriptorCount;
3456	VkBool32		runtimeDescriptorArray;
3457	VkBool32		samplerFilterMinmax;
3458	VkBool32		scalarBlockLayout;
3459	VkBool32		imagelessFramebuffer;
3460	VkBool32		uniformBufferStandardLayout;
3461	VkBool32		shaderSubgroupExtendedTypes;
3462	VkBool32		separateDepthStencilLayouts;
3463	VkBool32		hostQueryReset;
3464	VkBool32		timelineSemaphore;
3465	VkBool32		bufferDeviceAddress;
3466	VkBool32		bufferDeviceAddressCaptureReplay;
3467	VkBool32		bufferDeviceAddressMultiDevice;
3468	VkBool32		vulkanMemoryModel;
3469	VkBool32		vulkanMemoryModelDeviceScope;
3470	VkBool32		vulkanMemoryModelAvailabilityVisibilityChains;
3471	VkBool32		shaderOutputViewportIndex;
3472	VkBool32		shaderOutputLayer;
3473	VkBool32		subgroupBroadcastDynamicId;
3474};
3475
3476struct VkPhysicalDeviceVulkan12Properties
3477{
3478	VkStructureType						sType;
3479	void*								pNext;
3480	VkDriverId							driverID;
3481	char								driverName[VK_MAX_DRIVER_NAME_SIZE];
3482	char								driverInfo[VK_MAX_DRIVER_INFO_SIZE];
3483	VkConformanceVersion				conformanceVersion;
3484	VkShaderFloatControlsIndependence	denormBehaviorIndependence;
3485	VkShaderFloatControlsIndependence	roundingModeIndependence;
3486	VkBool32							shaderSignedZeroInfNanPreserveFloat16;
3487	VkBool32							shaderSignedZeroInfNanPreserveFloat32;
3488	VkBool32							shaderSignedZeroInfNanPreserveFloat64;
3489	VkBool32							shaderDenormPreserveFloat16;
3490	VkBool32							shaderDenormPreserveFloat32;
3491	VkBool32							shaderDenormPreserveFloat64;
3492	VkBool32							shaderDenormFlushToZeroFloat16;
3493	VkBool32							shaderDenormFlushToZeroFloat32;
3494	VkBool32							shaderDenormFlushToZeroFloat64;
3495	VkBool32							shaderRoundingModeRTEFloat16;
3496	VkBool32							shaderRoundingModeRTEFloat32;
3497	VkBool32							shaderRoundingModeRTEFloat64;
3498	VkBool32							shaderRoundingModeRTZFloat16;
3499	VkBool32							shaderRoundingModeRTZFloat32;
3500	VkBool32							shaderRoundingModeRTZFloat64;
3501	uint32_t							maxUpdateAfterBindDescriptorsInAllPools;
3502	VkBool32							shaderUniformBufferArrayNonUniformIndexingNative;
3503	VkBool32							shaderSampledImageArrayNonUniformIndexingNative;
3504	VkBool32							shaderStorageBufferArrayNonUniformIndexingNative;
3505	VkBool32							shaderStorageImageArrayNonUniformIndexingNative;
3506	VkBool32							shaderInputAttachmentArrayNonUniformIndexingNative;
3507	VkBool32							robustBufferAccessUpdateAfterBind;
3508	VkBool32							quadDivergentImplicitLod;
3509	uint32_t							maxPerStageDescriptorUpdateAfterBindSamplers;
3510	uint32_t							maxPerStageDescriptorUpdateAfterBindUniformBuffers;
3511	uint32_t							maxPerStageDescriptorUpdateAfterBindStorageBuffers;
3512	uint32_t							maxPerStageDescriptorUpdateAfterBindSampledImages;
3513	uint32_t							maxPerStageDescriptorUpdateAfterBindStorageImages;
3514	uint32_t							maxPerStageDescriptorUpdateAfterBindInputAttachments;
3515	uint32_t							maxPerStageUpdateAfterBindResources;
3516	uint32_t							maxDescriptorSetUpdateAfterBindSamplers;
3517	uint32_t							maxDescriptorSetUpdateAfterBindUniformBuffers;
3518	uint32_t							maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
3519	uint32_t							maxDescriptorSetUpdateAfterBindStorageBuffers;
3520	uint32_t							maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
3521	uint32_t							maxDescriptorSetUpdateAfterBindSampledImages;
3522	uint32_t							maxDescriptorSetUpdateAfterBindStorageImages;
3523	uint32_t							maxDescriptorSetUpdateAfterBindInputAttachments;
3524	VkResolveModeFlags					supportedDepthResolveModes;
3525	VkResolveModeFlags					supportedStencilResolveModes;
3526	VkBool32							independentResolveNone;
3527	VkBool32							independentResolve;
3528	VkBool32							filterMinmaxSingleComponentFormats;
3529	VkBool32							filterMinmaxImageComponentMapping;
3530	uint64_t							maxTimelineSemaphoreValueDifference;
3531	VkSampleCountFlags					framebufferIntegerColorSampleCounts;
3532};
3533
3534struct VkPhysicalDeviceVulkan13Features
3535{
3536	VkStructureType	sType;
3537	void*			pNext;
3538	VkBool32		robustImageAccess;
3539	VkBool32		inlineUniformBlock;
3540	VkBool32		descriptorBindingInlineUniformBlockUpdateAfterBind;
3541	VkBool32		pipelineCreationCacheControl;
3542	VkBool32		privateData;
3543	VkBool32		shaderDemoteToHelperInvocation;
3544	VkBool32		shaderTerminateInvocation;
3545	VkBool32		subgroupSizeControl;
3546	VkBool32		computeFullSubgroups;
3547	VkBool32		synchronization2;
3548	VkBool32		textureCompressionASTC_HDR;
3549	VkBool32		shaderZeroInitializeWorkgroupMemory;
3550	VkBool32		dynamicRendering;
3551	VkBool32		shaderIntegerDotProduct;
3552	VkBool32		maintenance4;
3553};
3554
3555struct VkPhysicalDeviceVulkan13Properties
3556{
3557	VkStructureType		sType;
3558	void*				pNext;
3559	uint32_t			minSubgroupSize;
3560	uint32_t			maxSubgroupSize;
3561	uint32_t			maxComputeWorkgroupSubgroups;
3562	VkShaderStageFlags	requiredSubgroupSizeStages;
3563	uint32_t			maxInlineUniformBlockSize;
3564	uint32_t			maxPerStageDescriptorInlineUniformBlocks;
3565	uint32_t			maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
3566	uint32_t			maxDescriptorSetInlineUniformBlocks;
3567	uint32_t			maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
3568	uint32_t			maxInlineUniformTotalSize;
3569	VkBool32			integerDotProduct8BitUnsignedAccelerated;
3570	VkBool32			integerDotProduct8BitSignedAccelerated;
3571	VkBool32			integerDotProduct8BitMixedSignednessAccelerated;
3572	VkBool32			integerDotProduct4x8BitPackedUnsignedAccelerated;
3573	VkBool32			integerDotProduct4x8BitPackedSignedAccelerated;
3574	VkBool32			integerDotProduct4x8BitPackedMixedSignednessAccelerated;
3575	VkBool32			integerDotProduct16BitUnsignedAccelerated;
3576	VkBool32			integerDotProduct16BitSignedAccelerated;
3577	VkBool32			integerDotProduct16BitMixedSignednessAccelerated;
3578	VkBool32			integerDotProduct32BitUnsignedAccelerated;
3579	VkBool32			integerDotProduct32BitSignedAccelerated;
3580	VkBool32			integerDotProduct32BitMixedSignednessAccelerated;
3581	VkBool32			integerDotProduct64BitUnsignedAccelerated;
3582	VkBool32			integerDotProduct64BitSignedAccelerated;
3583	VkBool32			integerDotProduct64BitMixedSignednessAccelerated;
3584	VkBool32			integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
3585	VkBool32			integerDotProductAccumulatingSaturating8BitSignedAccelerated;
3586	VkBool32			integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
3587	VkBool32			integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
3588	VkBool32			integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
3589	VkBool32			integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
3590	VkBool32			integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
3591	VkBool32			integerDotProductAccumulatingSaturating16BitSignedAccelerated;
3592	VkBool32			integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
3593	VkBool32			integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
3594	VkBool32			integerDotProductAccumulatingSaturating32BitSignedAccelerated;
3595	VkBool32			integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
3596	VkBool32			integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
3597	VkBool32			integerDotProductAccumulatingSaturating64BitSignedAccelerated;
3598	VkBool32			integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
3599	VkDeviceSize		storageTexelBufferOffsetAlignmentBytes;
3600	VkBool32			storageTexelBufferOffsetSingleTexelAlignment;
3601	VkDeviceSize		uniformTexelBufferOffsetAlignmentBytes;
3602	VkBool32			uniformTexelBufferOffsetSingleTexelAlignment;
3603	VkDeviceSize		maxBufferSize;
3604};
3605
3606struct VkFaultData
3607{
3608	VkStructureType	sType;
3609	void*			pNext;
3610	VkFaultLevel	faultLevel;
3611	VkFaultType		faultType;
3612};
3613
3614struct VkFaultCallbackInfo
3615{
3616	VkStructureType				sType;
3617	const void*					pNext;
3618	uint32_t					faultCount;
3619	VkFaultData*				pFaults;
3620	PFN_vkFaultCallbackFunction	pfnFaultCallback;
3621};
3622
3623struct VkSamplerCustomBorderColorCreateInfoEXT
3624{
3625	VkStructureType		sType;
3626	const void*			pNext;
3627	VkClearColorValue	customBorderColor;
3628	VkFormat			format;
3629};
3630
3631struct VkPhysicalDeviceCustomBorderColorPropertiesEXT
3632{
3633	VkStructureType	sType;
3634	void*			pNext;
3635	uint32_t		maxCustomBorderColorSamplers;
3636};
3637
3638struct VkPhysicalDeviceCustomBorderColorFeaturesEXT
3639{
3640	VkStructureType	sType;
3641	void*			pNext;
3642	VkBool32		customBorderColors;
3643	VkBool32		customBorderColorWithoutFormat;
3644};
3645
3646struct VkRefreshObjectKHR
3647{
3648	VkObjectType			objectType;
3649	uint64_t				objectHandle;
3650	VkRefreshObjectFlagsKHR	flags;
3651};
3652
3653struct VkRefreshObjectListKHR
3654{
3655	VkStructureType				sType;
3656	const void*					pNext;
3657	uint32_t					objectCount;
3658	const VkRefreshObjectKHR*	pObjects;
3659};
3660
3661struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT
3662{
3663	VkStructureType	sType;
3664	void*			pNext;
3665	VkBool32		extendedDynamicState;
3666};
3667
3668struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT
3669{
3670	VkStructureType	sType;
3671	void*			pNext;
3672	VkBool32		extendedDynamicState2;
3673	VkBool32		extendedDynamicState2LogicOp;
3674	VkBool32		extendedDynamicState2PatchControlPoints;
3675};
3676
3677struct VkPipelineOfflineCreateInfo
3678{
3679	VkStructureType			sType;
3680	const void*				pNext;
3681	uint8_t					pipelineIdentifier[VK_UUID_SIZE];
3682	VkPipelineMatchControl	matchControl;
3683	VkDeviceSize			poolEntrySize;
3684};
3685
3686struct VkPhysicalDeviceRobustness2FeaturesEXT
3687{
3688	VkStructureType	sType;
3689	void*			pNext;
3690	VkBool32		robustBufferAccess2;
3691	VkBool32		robustImageAccess2;
3692	VkBool32		nullDescriptor;
3693};
3694
3695struct VkPhysicalDeviceRobustness2PropertiesEXT
3696{
3697	VkStructureType	sType;
3698	void*			pNext;
3699	VkDeviceSize	robustStorageBufferAccessSizeAlignment;
3700	VkDeviceSize	robustUniformBufferAccessSizeAlignment;
3701};
3702
3703struct VkPhysicalDeviceImageRobustnessFeaturesEXT
3704{
3705	VkStructureType	sType;
3706	void*			pNext;
3707	VkBool32		robustImageAccess;
3708};
3709
3710struct VkPhysicalDevice4444FormatsFeaturesEXT
3711{
3712	VkStructureType	sType;
3713	void*			pNext;
3714	VkBool32		formatA4R4G4B4;
3715	VkBool32		formatA4B4G4R4;
3716};
3717
3718struct VkBufferCopy2KHR
3719{
3720	VkStructureType	sType;
3721	const void*		pNext;
3722	VkDeviceSize	srcOffset;
3723	VkDeviceSize	dstOffset;
3724	VkDeviceSize	size;
3725};
3726
3727struct VkImageCopy2KHR
3728{
3729	VkStructureType				sType;
3730	const void*					pNext;
3731	VkImageSubresourceLayers	srcSubresource;
3732	VkOffset3D					srcOffset;
3733	VkImageSubresourceLayers	dstSubresource;
3734	VkOffset3D					dstOffset;
3735	VkExtent3D					extent;
3736};
3737
3738struct VkImageBlit2KHR
3739{
3740	VkStructureType				sType;
3741	const void*					pNext;
3742	VkImageSubresourceLayers	srcSubresource;
3743	VkOffset3D					srcOffsets[2];
3744	VkImageSubresourceLayers	dstSubresource;
3745	VkOffset3D					dstOffsets[2];
3746};
3747
3748struct VkBufferImageCopy2KHR
3749{
3750	VkStructureType				sType;
3751	const void*					pNext;
3752	VkDeviceSize				bufferOffset;
3753	uint32_t					bufferRowLength;
3754	uint32_t					bufferImageHeight;
3755	VkImageSubresourceLayers	imageSubresource;
3756	VkOffset3D					imageOffset;
3757	VkExtent3D					imageExtent;
3758};
3759
3760struct VkImageResolve2KHR
3761{
3762	VkStructureType				sType;
3763	const void*					pNext;
3764	VkImageSubresourceLayers	srcSubresource;
3765	VkOffset3D					srcOffset;
3766	VkImageSubresourceLayers	dstSubresource;
3767	VkOffset3D					dstOffset;
3768	VkExtent3D					extent;
3769};
3770
3771struct VkCopyBufferInfo2KHR
3772{
3773	VkStructureType			sType;
3774	const void*				pNext;
3775	VkBuffer				srcBuffer;
3776	VkBuffer				dstBuffer;
3777	uint32_t				regionCount;
3778	const VkBufferCopy2KHR*	pRegions;
3779};
3780
3781struct VkCopyImageInfo2KHR
3782{
3783	VkStructureType			sType;
3784	const void*				pNext;
3785	VkImage					srcImage;
3786	VkImageLayout			srcImageLayout;
3787	VkImage					dstImage;
3788	VkImageLayout			dstImageLayout;
3789	uint32_t				regionCount;
3790	const VkImageCopy2KHR*	pRegions;
3791};
3792
3793struct VkBlitImageInfo2KHR
3794{
3795	VkStructureType			sType;
3796	const void*				pNext;
3797	VkImage					srcImage;
3798	VkImageLayout			srcImageLayout;
3799	VkImage					dstImage;
3800	VkImageLayout			dstImageLayout;
3801	uint32_t				regionCount;
3802	const VkImageBlit2KHR*	pRegions;
3803	VkFilter				filter;
3804};
3805
3806struct VkCopyBufferToImageInfo2KHR
3807{
3808	VkStructureType					sType;
3809	const void*						pNext;
3810	VkBuffer						srcBuffer;
3811	VkImage							dstImage;
3812	VkImageLayout					dstImageLayout;
3813	uint32_t						regionCount;
3814	const VkBufferImageCopy2KHR*	pRegions;
3815};
3816
3817struct VkCopyImageToBufferInfo2KHR
3818{
3819	VkStructureType					sType;
3820	const void*						pNext;
3821	VkImage							srcImage;
3822	VkImageLayout					srcImageLayout;
3823	VkBuffer						dstBuffer;
3824	uint32_t						regionCount;
3825	const VkBufferImageCopy2KHR*	pRegions;
3826};
3827
3828struct VkResolveImageInfo2KHR
3829{
3830	VkStructureType				sType;
3831	const void*					pNext;
3832	VkImage						srcImage;
3833	VkImageLayout				srcImageLayout;
3834	VkImage						dstImage;
3835	VkImageLayout				dstImageLayout;
3836	uint32_t					regionCount;
3837	const VkImageResolve2KHR*	pRegions;
3838};
3839
3840struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT
3841{
3842	VkStructureType	sType;
3843	void*			pNext;
3844	VkBool32		shaderImageInt64Atomics;
3845	VkBool32		sparseImageInt64Atomics;
3846};
3847
3848struct VkFragmentShadingRateAttachmentInfoKHR
3849{
3850	VkStructureType					sType;
3851	const void*						pNext;
3852	const VkAttachmentReference2*	pFragmentShadingRateAttachment;
3853	VkExtent2D						shadingRateAttachmentTexelSize;
3854};
3855
3856struct VkPipelineFragmentShadingRateStateCreateInfoKHR
3857{
3858	VkStructureType						sType;
3859	const void*							pNext;
3860	VkExtent2D							fragmentSize;
3861	VkFragmentShadingRateCombinerOpKHR	combinerOps[2];
3862};
3863
3864struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR
3865{
3866	VkStructureType	sType;
3867	void*			pNext;
3868	VkBool32		pipelineFragmentShadingRate;
3869	VkBool32		primitiveFragmentShadingRate;
3870	VkBool32		attachmentFragmentShadingRate;
3871};
3872
3873struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR
3874{
3875	VkStructureType			sType;
3876	void*					pNext;
3877	VkExtent2D				minFragmentShadingRateAttachmentTexelSize;
3878	VkExtent2D				maxFragmentShadingRateAttachmentTexelSize;
3879	uint32_t				maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
3880	VkBool32				primitiveFragmentShadingRateWithMultipleViewports;
3881	VkBool32				layeredShadingRateAttachments;
3882	VkBool32				fragmentShadingRateNonTrivialCombinerOps;
3883	VkExtent2D				maxFragmentSize;
3884	uint32_t				maxFragmentSizeAspectRatio;
3885	uint32_t				maxFragmentShadingRateCoverageSamples;
3886	VkSampleCountFlagBits	maxFragmentShadingRateRasterizationSamples;
3887	VkBool32				fragmentShadingRateWithShaderDepthStencilWrites;
3888	VkBool32				fragmentShadingRateWithSampleMask;
3889	VkBool32				fragmentShadingRateWithShaderSampleMask;
3890	VkBool32				fragmentShadingRateWithConservativeRasterization;
3891	VkBool32				fragmentShadingRateWithFragmentShaderInterlock;
3892	VkBool32				fragmentShadingRateWithCustomSampleLocations;
3893	VkBool32				fragmentShadingRateStrictMultiplyCombiner;
3894};
3895
3896struct VkPhysicalDeviceFragmentShadingRateKHR
3897{
3898	VkStructureType		sType;
3899	void*				pNext;
3900	VkSampleCountFlags	sampleCounts;
3901	VkExtent2D			fragmentSize;
3902};
3903
3904struct VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR
3905{
3906	VkStructureType	sType;
3907	void*			pNext;
3908	VkBool32		shaderTerminateInvocation;
3909};
3910
3911struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT
3912{
3913	VkStructureType	sType;
3914	void*			pNext;
3915	VkBool32		vertexInputDynamicState;
3916};
3917
3918struct VkVertexInputBindingDescription2EXT
3919{
3920	VkStructureType		sType;
3921	void*				pNext;
3922	uint32_t			binding;
3923	uint32_t			stride;
3924	VkVertexInputRate	inputRate;
3925	uint32_t			divisor;
3926};
3927
3928struct VkVertexInputAttributeDescription2EXT
3929{
3930	VkStructureType	sType;
3931	void*			pNext;
3932	uint32_t		location;
3933	uint32_t		binding;
3934	VkFormat		format;
3935	uint32_t		offset;
3936};
3937
3938struct VkPhysicalDeviceColorWriteEnableFeaturesEXT
3939{
3940	VkStructureType	sType;
3941	void*			pNext;
3942	VkBool32		colorWriteEnable;
3943};
3944
3945struct VkPipelineColorWriteCreateInfoEXT
3946{
3947	VkStructureType	sType;
3948	const void*		pNext;
3949	uint32_t		attachmentCount;
3950	const VkBool32*	pColorWriteEnables;
3951};
3952
3953struct VkMemoryBarrier2KHR
3954{
3955	VkStructureType			sType;
3956	const void*				pNext;
3957	VkPipelineStageFlags2	srcStageMask;
3958	VkAccessFlags2			srcAccessMask;
3959	VkPipelineStageFlags2	dstStageMask;
3960	VkAccessFlags2			dstAccessMask;
3961};
3962
3963struct VkImageMemoryBarrier2KHR
3964{
3965	VkStructureType			sType;
3966	const void*				pNext;
3967	VkPipelineStageFlags2	srcStageMask;
3968	VkAccessFlags2			srcAccessMask;
3969	VkPipelineStageFlags2	dstStageMask;
3970	VkAccessFlags2			dstAccessMask;
3971	VkImageLayout			oldLayout;
3972	VkImageLayout			newLayout;
3973	uint32_t				srcQueueFamilyIndex;
3974	uint32_t				dstQueueFamilyIndex;
3975	VkImage					image;
3976	VkImageSubresourceRange	subresourceRange;
3977};
3978
3979struct VkBufferMemoryBarrier2KHR
3980{
3981	VkStructureType			sType;
3982	const void*				pNext;
3983	VkPipelineStageFlags2	srcStageMask;
3984	VkAccessFlags2			srcAccessMask;
3985	VkPipelineStageFlags2	dstStageMask;
3986	VkAccessFlags2			dstAccessMask;
3987	uint32_t				srcQueueFamilyIndex;
3988	uint32_t				dstQueueFamilyIndex;
3989	VkBuffer				buffer;
3990	VkDeviceSize			offset;
3991	VkDeviceSize			size;
3992};
3993
3994struct VkDependencyInfoKHR
3995{
3996	VkStructureType						sType;
3997	const void*							pNext;
3998	VkDependencyFlags					dependencyFlags;
3999	uint32_t							memoryBarrierCount;
4000	const VkMemoryBarrier2KHR*			pMemoryBarriers;
4001	uint32_t							bufferMemoryBarrierCount;
4002	const VkBufferMemoryBarrier2KHR*	pBufferMemoryBarriers;
4003	uint32_t							imageMemoryBarrierCount;
4004	const VkImageMemoryBarrier2KHR*		pImageMemoryBarriers;
4005};
4006
4007struct VkSemaphoreSubmitInfoKHR
4008{
4009	VkStructureType			sType;
4010	const void*				pNext;
4011	VkSemaphore				semaphore;
4012	uint64_t				value;
4013	VkPipelineStageFlags2	stageMask;
4014	uint32_t				deviceIndex;
4015};
4016
4017struct VkCommandBufferSubmitInfoKHR
4018{
4019	VkStructureType	sType;
4020	const void*		pNext;
4021	VkCommandBuffer	commandBuffer;
4022	uint32_t		deviceMask;
4023};
4024
4025struct VkSubmitInfo2KHR
4026{
4027	VkStructureType						sType;
4028	const void*							pNext;
4029	VkSubmitFlags						flags;
4030	uint32_t							waitSemaphoreInfoCount;
4031	const VkSemaphoreSubmitInfoKHR*		pWaitSemaphoreInfos;
4032	uint32_t							commandBufferInfoCount;
4033	const VkCommandBufferSubmitInfoKHR*	pCommandBufferInfos;
4034	uint32_t							signalSemaphoreInfoCount;
4035	const VkSemaphoreSubmitInfoKHR*		pSignalSemaphoreInfos;
4036};
4037
4038struct VkQueueFamilyCheckpointProperties2NV
4039{
4040	VkStructureType			sType;
4041	void*					pNext;
4042	VkPipelineStageFlags2	checkpointExecutionStageMask;
4043};
4044
4045struct VkCheckpointData2NV
4046{
4047	VkStructureType			sType;
4048	void*					pNext;
4049	VkPipelineStageFlags2	stage;
4050	void*					pCheckpointMarker;
4051};
4052
4053struct VkPhysicalDeviceSynchronization2FeaturesKHR
4054{
4055	VkStructureType	sType;
4056	void*			pNext;
4057	VkBool32		synchronization2;
4058};
4059
4060struct VkPhysicalDeviceVulkanSC10Properties
4061{
4062	VkStructureType	sType;
4063	void*			pNext;
4064	VkBool32		deviceNoDynamicHostAllocations;
4065	VkBool32		deviceDestroyFreesMemory;
4066	VkBool32		commandPoolMultipleCommandBuffersRecording;
4067	VkBool32		commandPoolResetCommandBuffer;
4068	VkBool32		commandBufferSimultaneousUse;
4069	VkBool32		secondaryCommandBufferNullOrImagelessFramebuffer;
4070	VkBool32		recycleDescriptorSetMemory;
4071	VkBool32		recyclePipelineMemory;
4072	uint32_t		maxRenderPassSubpasses;
4073	uint32_t		maxRenderPassDependencies;
4074	uint32_t		maxSubpassInputAttachments;
4075	uint32_t		maxSubpassPreserveAttachments;
4076	uint32_t		maxFramebufferAttachments;
4077	uint32_t		maxDescriptorSetLayoutBindings;
4078	uint32_t		maxQueryFaultCount;
4079	uint32_t		maxCallbackFaultCount;
4080	uint32_t		maxCommandPoolCommandBuffers;
4081	VkDeviceSize	maxCommandBufferSize;
4082};
4083
4084struct VkPipelinePoolSize
4085{
4086	VkStructureType	sType;
4087	const void*		pNext;
4088	VkDeviceSize	poolEntrySize;
4089	uint32_t		poolEntryCount;
4090};
4091
4092struct VkDeviceObjectReservationCreateInfo
4093{
4094	VkStructureType						sType;
4095	const void*							pNext;
4096	uint32_t							pipelineCacheCreateInfoCount;
4097	const VkPipelineCacheCreateInfo*	pPipelineCacheCreateInfos;
4098	uint32_t							pipelinePoolSizeCount;
4099	const VkPipelinePoolSize*			pPipelinePoolSizes;
4100	uint32_t							semaphoreRequestCount;
4101	uint32_t							commandBufferRequestCount;
4102	uint32_t							fenceRequestCount;
4103	uint32_t							deviceMemoryRequestCount;
4104	uint32_t							bufferRequestCount;
4105	uint32_t							imageRequestCount;
4106	uint32_t							eventRequestCount;
4107	uint32_t							queryPoolRequestCount;
4108	uint32_t							bufferViewRequestCount;
4109	uint32_t							imageViewRequestCount;
4110	uint32_t							layeredImageViewRequestCount;
4111	uint32_t							pipelineCacheRequestCount;
4112	uint32_t							pipelineLayoutRequestCount;
4113	uint32_t							renderPassRequestCount;
4114	uint32_t							graphicsPipelineRequestCount;
4115	uint32_t							computePipelineRequestCount;
4116	uint32_t							descriptorSetLayoutRequestCount;
4117	uint32_t							samplerRequestCount;
4118	uint32_t							descriptorPoolRequestCount;
4119	uint32_t							descriptorSetRequestCount;
4120	uint32_t							framebufferRequestCount;
4121	uint32_t							commandPoolRequestCount;
4122	uint32_t							samplerYcbcrConversionRequestCount;
4123	uint32_t							surfaceRequestCount;
4124	uint32_t							swapchainRequestCount;
4125	uint32_t							displayModeRequestCount;
4126	uint32_t							subpassDescriptionRequestCount;
4127	uint32_t							attachmentDescriptionRequestCount;
4128	uint32_t							descriptorSetLayoutBindingRequestCount;
4129	uint32_t							descriptorSetLayoutBindingLimit;
4130	uint32_t							maxImageViewMipLevels;
4131	uint32_t							maxImageViewArrayLayers;
4132	uint32_t							maxLayeredImageViewMipLevels;
4133	uint32_t							maxOcclusionQueriesPerPool;
4134	uint32_t							maxPipelineStatisticsQueriesPerPool;
4135	uint32_t							maxTimestampQueriesPerPool;
4136	uint32_t							maxImmutableSamplersPerDescriptorSetLayout;
4137};
4138
4139struct VkCommandPoolMemoryReservationCreateInfo
4140{
4141	VkStructureType	sType;
4142	const void*		pNext;
4143	VkDeviceSize	commandPoolReservedSize;
4144	uint32_t		commandPoolMaxCommandBuffers;
4145};
4146
4147struct VkCommandPoolMemoryConsumption
4148{
4149	VkStructureType	sType;
4150	void*			pNext;
4151	VkDeviceSize	commandPoolAllocated;
4152	VkDeviceSize	commandPoolReservedSize;
4153	VkDeviceSize	commandBufferAllocated;
4154};
4155
4156struct VkPhysicalDeviceVulkanSC10Features
4157{
4158	VkStructureType	sType;
4159	void*			pNext;
4160	VkBool32		shaderAtomicInstructions;
4161};
4162
4163struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT
4164{
4165	VkStructureType	sType;
4166	void*			pNext;
4167	VkBool32		ycbcr2plane444Formats;
4168};
4169
4170struct VkFormatProperties3KHR
4171{
4172	VkStructureType			sType;
4173	void*					pNext;
4174	VkFormatFeatureFlags2	linearTilingFeatures;
4175	VkFormatFeatureFlags2	optimalTilingFeatures;
4176	VkFormatFeatureFlags2	bufferFeatures;
4177};
4178
4179struct VkDrmFormatModifierProperties2EXT
4180{
4181	uint64_t				drmFormatModifier;
4182	uint32_t				drmFormatModifierPlaneCount;
4183	VkFormatFeatureFlags2	drmFormatModifierTilingFeatures;
4184};
4185
4186struct VkDrmFormatModifierPropertiesList2EXT
4187{
4188	VkStructureType						sType;
4189	void*								pNext;
4190	uint32_t							drmFormatModifierCount;
4191	VkDrmFormatModifierProperties2EXT*	pDrmFormatModifierProperties;
4192};
4193
4194struct VkImportScreenBufferInfoQNX
4195{
4196	VkStructureType			sType;
4197	const void*				pNext;
4198	struct _screen_buffer*	buffer;
4199};
4200
4201struct VkScreenBufferPropertiesQNX
4202{
4203	VkStructureType	sType;
4204	void*			pNext;
4205	VkDeviceSize	allocationSize;
4206	uint32_t		memoryTypeBits;
4207};
4208
4209struct VkScreenBufferFormatPropertiesQNX
4210{
4211	VkStructureType					sType;
4212	void*							pNext;
4213	VkFormat						format;
4214	uint64_t						externalFormat;
4215	uint64_t						screenUsage;
4216	VkFormatFeatureFlags			formatFeatures;
4217	VkComponentMapping				samplerYcbcrConversionComponents;
4218	VkSamplerYcbcrModelConversion	suggestedYcbcrModel;
4219	VkSamplerYcbcrRange				suggestedYcbcrRange;
4220	VkChromaLocation				suggestedXChromaOffset;
4221	VkChromaLocation				suggestedYChromaOffset;
4222};
4223
4224struct VkExternalFormatQNX
4225{
4226	VkStructureType	sType;
4227	void*			pNext;
4228	uint64_t		externalFormat;
4229};
4230
4231struct VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX
4232{
4233	VkStructureType	sType;
4234	void*			pNext;
4235	VkBool32		screenBufferImport;
4236};
4237
4238typedef VkPhysicalDeviceExternalMemorySciBufFeaturesNV VkPhysicalDeviceExternalSciBufFeaturesNV;
4239
4240typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;
4241
4242typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR;
4243
4244typedef VkFormatProperties2 VkFormatProperties2KHR;
4245
4246typedef VkImageFormatProperties2 VkImageFormatProperties2KHR;
4247
4248typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR;
4249
4250typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR;
4251
4252typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR;
4253
4254typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR;
4255
4256typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR;
4257
4258typedef VkConformanceVersion VkConformanceVersionKHR;
4259
4260typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR;
4261
4262typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR;
4263
4264typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR;
4265
4266typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures;
4267
4268typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR;
4269
4270typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR;
4271
4272typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR;
4273
4274typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR;
4275
4276typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR;
4277
4278typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR;
4279
4280typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR;
4281
4282typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR;
4283
4284typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR;
4285
4286typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR;
4287
4288typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR;
4289
4290typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR;
4291
4292typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR;
4293
4294typedef VkExternalFenceProperties VkExternalFencePropertiesKHR;
4295
4296typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR;
4297
4298typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR;
4299
4300typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR;
4301
4302typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR;
4303
4304typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;
4305
4306typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR;
4307
4308typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;
4309
4310typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR;
4311
4312typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR;
4313
4314typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR;
4315
4316typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR;
4317
4318typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR;
4319
4320typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR;
4321
4322typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR;
4323
4324typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR;
4325
4326typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR;
4327
4328typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR;
4329
4330typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR;
4331
4332typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR;
4333
4334typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR;
4335
4336typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
4337
4338typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR;
4339
4340typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR;
4341
4342typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR;
4343
4344typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;
4345
4346typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR;
4347
4348typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR;
4349
4350typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR;
4351
4352typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;
4353
4354typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR;
4355
4356typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR;
4357
4358typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR;
4359
4360typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR;
4361
4362typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;
4363
4364typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR;
4365
4366typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
4367
4368typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR;
4369
4370typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
4371
4372typedef VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfoEXT;
4373
4374typedef VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR;
4375
4376typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR;
4377
4378typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR;
4379
4380typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures;
4381
4382typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR;
4383
4384typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR;
4385
4386typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR;
4387
4388typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT;
4389
4390typedef VkDeviceQueueGlobalPriorityCreateInfoKHR VkDeviceQueueGlobalPriorityCreateInfoEXT;
4391
4392typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT;
4393
4394typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT;
4395
4396typedef VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfoEXT;
4397
4398typedef VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfoEXT;
4399
4400typedef VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupportEXT;
4401
4402typedef VkAttachmentDescription2 VkAttachmentDescription2KHR;
4403
4404typedef VkAttachmentReference2 VkAttachmentReference2KHR;
4405
4406typedef VkSubpassDescription2 VkSubpassDescription2KHR;
4407
4408typedef VkSubpassDependency2 VkSubpassDependency2KHR;
4409
4410typedef VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR;
4411
4412typedef VkSubpassBeginInfo VkSubpassBeginInfoKHR;
4413
4414typedef VkSubpassEndInfo VkSubpassEndInfoKHR;
4415
4416typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR;
4417
4418typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR;
4419
4420typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR;
4421
4422typedef VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR;
4423
4424typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR;
4425
4426typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR;
4427
4428typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR;
4429
4430typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR;
4431
4432typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR;
4433
4434typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR;
4435
4436typedef VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolveKHR;
4437
4438typedef VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT;
4439
4440typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT;
4441
4442typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
4443
4444typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR;
4445
4446typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR;
4447
4448typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoEXT;
4449
4450typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR;
4451
4452typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR;
4453
4454typedef VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfoKHR;
4455
4456typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR;
4457
4458typedef VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR;
4459
4460typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;
4461
4462typedef VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayoutKHR;
4463
4464typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR;
4465
4466typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT VkShaderRequiredSubgroupSizeCreateInfoEXT;
4467
4468typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR;
4469
4470typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR;
4471
4472