using System;

namespace Vulkan 
{
	public struct DispatchLoaderStatic 
	{
		public Result vkCreateInstance(InstanceCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,Instance* pInstance) => Vulkan.vkCreateInstance(pCreateInfo,pAllocator,pInstance);
		public void vkDestroyInstance(Instance instance,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyInstance(instance,pAllocator);
		public Result vkEnumeratePhysicalDevices(Instance instance,uint32* pPhysicalDeviceCount,PhysicalDevice* pPhysicalDevices) => Vulkan.vkEnumeratePhysicalDevices(instance,pPhysicalDeviceCount,pPhysicalDevices);
		public void vkGetPhysicalDeviceFeatures(PhysicalDevice physicalDevice,PhysicalDeviceFeatures* pFeatures) => Vulkan.vkGetPhysicalDeviceFeatures(physicalDevice,pFeatures);
		public void vkGetPhysicalDeviceFormatProperties(PhysicalDevice physicalDevice,Format format,FormatProperties* pFormatProperties) => Vulkan.vkGetPhysicalDeviceFormatProperties(physicalDevice,format,pFormatProperties);
		public Result vkGetPhysicalDeviceImageFormatProperties(PhysicalDevice physicalDevice,Format format,ImageType type,ImageTiling tiling,ImageUsageFlags usage,ImageCreateFlags flags,ImageFormatProperties* pImageFormatProperties) => Vulkan.vkGetPhysicalDeviceImageFormatProperties(physicalDevice,format,type,tiling,usage,flags,pImageFormatProperties);
		public void vkGetPhysicalDeviceProperties(PhysicalDevice physicalDevice,PhysicalDeviceProperties* pProperties) => Vulkan.vkGetPhysicalDeviceProperties(physicalDevice,pProperties);
		public void vkGetPhysicalDeviceQueueFamilyProperties(PhysicalDevice physicalDevice,uint32* pQueueFamilyPropertyCount,QueueFamilyProperties* pQueueFamilyProperties) => Vulkan.vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice,pQueueFamilyPropertyCount,pQueueFamilyProperties);
		public void vkGetPhysicalDeviceMemoryProperties(PhysicalDevice physicalDevice,PhysicalDeviceMemoryProperties* pMemoryProperties) => Vulkan.vkGetPhysicalDeviceMemoryProperties(physicalDevice,pMemoryProperties);
		public PFN_vkVoidFunction vkGetInstanceProcAddr(Instance instance,char8* pName) => Vulkan.vkGetInstanceProcAddr(instance,pName);
		public PFN_vkVoidFunction vkGetDeviceProcAddr(Device device,char8* pName) => Vulkan.vkGetDeviceProcAddr(device,pName);
		public Result vkCreateDevice(PhysicalDevice physicalDevice,DeviceCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,Device* pDevice) => Vulkan.vkCreateDevice(physicalDevice,pCreateInfo,pAllocator,pDevice);
		public void vkDestroyDevice(Device device,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyDevice(device,pAllocator);
		public Result vkEnumerateInstanceExtensionProperties(char8* pLayerName,uint32* pPropertyCount,ExtensionProperties* pProperties) => Vulkan.vkEnumerateInstanceExtensionProperties(pLayerName,pPropertyCount,pProperties);
		public Result vkEnumerateDeviceExtensionProperties(PhysicalDevice physicalDevice,char8* pLayerName,uint32* pPropertyCount,ExtensionProperties* pProperties) => Vulkan.vkEnumerateDeviceExtensionProperties(physicalDevice,pLayerName,pPropertyCount,pProperties);
		public Result vkEnumerateInstanceLayerProperties(uint32* pPropertyCount,LayerProperties* pProperties) => Vulkan.vkEnumerateInstanceLayerProperties(pPropertyCount,pProperties);
		public Result vkEnumerateDeviceLayerProperties(PhysicalDevice physicalDevice,uint32* pPropertyCount,LayerProperties* pProperties) => Vulkan.vkEnumerateDeviceLayerProperties(physicalDevice,pPropertyCount,pProperties);
		public void vkGetDeviceQueue(Device device,uint32 queueFamilyIndex,uint32 queueIndex,Queue* pQueue) => Vulkan.vkGetDeviceQueue(device,queueFamilyIndex,queueIndex,pQueue);
		public Result vkQueueSubmit(Queue queue,uint32 submitCount,SubmitInfo* pSubmits,Fence fence) => Vulkan.vkQueueSubmit(queue,submitCount,pSubmits,fence);
		public Result vkQueueWaitIdle(Queue queue) => Vulkan.vkQueueWaitIdle(queue);
		public Result vkDeviceWaitIdle(Device device) => Vulkan.vkDeviceWaitIdle(device);
		public Result vkAllocateMemory(Device device,MemoryAllocateInfo* pAllocateInfo,AllocationCallbacks* pAllocator,DeviceMemory* pMemory) => Vulkan.vkAllocateMemory(device,pAllocateInfo,pAllocator,pMemory);
		public void vkFreeMemory(Device device,DeviceMemory memory,AllocationCallbacks* pAllocator) => Vulkan.vkFreeMemory(device,memory,pAllocator);
		public Result vkMapMemory(Device device,DeviceMemory memory,DeviceSize offset,DeviceSize size,MemoryMapFlags flags,void** ppData) => Vulkan.vkMapMemory(device,memory,offset,size,flags,ppData);
		public void vkUnmapMemory(Device device,DeviceMemory memory) => Vulkan.vkUnmapMemory(device,memory);
		public Result vkFlushMappedMemoryRanges(Device device,uint32 memoryRangeCount,MappedMemoryRange* pMemoryRanges) => Vulkan.vkFlushMappedMemoryRanges(device,memoryRangeCount,pMemoryRanges);
		public Result vkInvalidateMappedMemoryRanges(Device device,uint32 memoryRangeCount,MappedMemoryRange* pMemoryRanges) => Vulkan.vkInvalidateMappedMemoryRanges(device,memoryRangeCount,pMemoryRanges);
		public void vkGetDeviceMemoryCommitment(Device device,DeviceMemory memory,DeviceSize* pCommittedMemoryInBytes) => Vulkan.vkGetDeviceMemoryCommitment(device,memory,pCommittedMemoryInBytes);
		public Result vkBindBufferMemory(Device device,Buffer buffer,DeviceMemory memory,DeviceSize memoryOffset) => Vulkan.vkBindBufferMemory(device,buffer,memory,memoryOffset);
		public Result vkBindImageMemory(Device device,Image image,DeviceMemory memory,DeviceSize memoryOffset) => Vulkan.vkBindImageMemory(device,image,memory,memoryOffset);
		public void vkGetBufferMemoryRequirements(Device device,Buffer buffer,MemoryRequirements* pMemoryRequirements) => Vulkan.vkGetBufferMemoryRequirements(device,buffer,pMemoryRequirements);
		public void vkGetImageMemoryRequirements(Device device,Image image,MemoryRequirements* pMemoryRequirements) => Vulkan.vkGetImageMemoryRequirements(device,image,pMemoryRequirements);
		public void vkGetImageSparseMemoryRequirements(Device device,Image image,uint32* pSparseMemoryRequirementCount,SparseImageMemoryRequirements* pSparseMemoryRequirements) => Vulkan.vkGetImageSparseMemoryRequirements(device,image,pSparseMemoryRequirementCount,pSparseMemoryRequirements);
		public void vkGetPhysicalDeviceSparseImageFormatProperties(PhysicalDevice physicalDevice,Format format,ImageType type,SampleCountFlags samples,ImageUsageFlags usage,ImageTiling tiling,uint32* pPropertyCount,SparseImageFormatProperties* pProperties) => Vulkan.vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice,format,type,samples,usage,tiling,pPropertyCount,pProperties);
		public Result vkQueueBindSparse(Queue queue,uint32 bindInfoCount,BindSparseInfo* pBindInfo,Fence fence) => Vulkan.vkQueueBindSparse(queue,bindInfoCount,pBindInfo,fence);
		public Result vkCreateFence(Device device,FenceCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,Fence* pFence) => Vulkan.vkCreateFence(device,pCreateInfo,pAllocator,pFence);
		public void vkDestroyFence(Device device,Fence fence,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyFence(device,fence,pAllocator);
		public Result vkResetFences(Device device,uint32 fenceCount,Fence* pFences) => Vulkan.vkResetFences(device,fenceCount,pFences);
		public Result vkGetFenceStatus(Device device,Fence fence) => Vulkan.vkGetFenceStatus(device,fence);
		public Result vkWaitForFences(Device device,uint32 fenceCount,Fence* pFences,Bool32 waitAll,uint64 timeout) => Vulkan.vkWaitForFences(device,fenceCount,pFences,waitAll,timeout);
		public Result vkCreateSemaphore(Device device,SemaphoreCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,Semaphore* pSemaphore) => Vulkan.vkCreateSemaphore(device,pCreateInfo,pAllocator,pSemaphore);
		public void vkDestroySemaphore(Device device,Semaphore semaphore,AllocationCallbacks* pAllocator) => Vulkan.vkDestroySemaphore(device,semaphore,pAllocator);
		public Result vkCreateEvent(Device device,EventCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,Event* pEvent) => Vulkan.vkCreateEvent(device,pCreateInfo,pAllocator,pEvent);
		public void vkDestroyEvent(Device device,Event event,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyEvent(device,event,pAllocator);
		public Result vkGetEventStatus(Device device,Event event) => Vulkan.vkGetEventStatus(device,event);
		public Result vkSetEvent(Device device,Event event) => Vulkan.vkSetEvent(device,event);
		public Result vkResetEvent(Device device,Event event) => Vulkan.vkResetEvent(device,event);
		public Result vkCreateQueryPool(Device device,QueryPoolCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,QueryPool* pQueryPool) => Vulkan.vkCreateQueryPool(device,pCreateInfo,pAllocator,pQueryPool);
		public void vkDestroyQueryPool(Device device,QueryPool queryPool,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyQueryPool(device,queryPool,pAllocator);
		public Result vkGetQueryPoolResults(Device device,QueryPool queryPool,uint32 firstQuery,uint32 queryCount,uint dataSize,void* pData,DeviceSize stride,QueryResultFlags flags) => Vulkan.vkGetQueryPoolResults(device,queryPool,firstQuery,queryCount,dataSize,pData,stride,flags);
		public Result vkCreateBuffer(Device device,BufferCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,Buffer* pBuffer) => Vulkan.vkCreateBuffer(device,pCreateInfo,pAllocator,pBuffer);
		public void vkDestroyBuffer(Device device,Buffer buffer,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyBuffer(device,buffer,pAllocator);
		public Result vkCreateBufferView(Device device,BufferViewCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,BufferView* pView) => Vulkan.vkCreateBufferView(device,pCreateInfo,pAllocator,pView);
		public void vkDestroyBufferView(Device device,BufferView bufferView,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyBufferView(device,bufferView,pAllocator);
		public Result vkCreateImage(Device device,ImageCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,Image* pImage) => Vulkan.vkCreateImage(device,pCreateInfo,pAllocator,pImage);
		public void vkDestroyImage(Device device,Image image,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyImage(device,image,pAllocator);
		public void vkGetImageSubresourceLayout(Device device,Image image,ImageSubresource* pSubresource,SubresourceLayout* pLayout) => Vulkan.vkGetImageSubresourceLayout(device,image,pSubresource,pLayout);
		public Result vkCreateImageView(Device device,ImageViewCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,ImageView* pView) => Vulkan.vkCreateImageView(device,pCreateInfo,pAllocator,pView);
		public void vkDestroyImageView(Device device,ImageView imageView,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyImageView(device,imageView,pAllocator);
		public Result vkCreateShaderModule(Device device,ShaderModuleCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,ShaderModule* pShaderModule) => Vulkan.vkCreateShaderModule(device,pCreateInfo,pAllocator,pShaderModule);
		public void vkDestroyShaderModule(Device device,ShaderModule shaderModule,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyShaderModule(device,shaderModule,pAllocator);
		public Result vkCreatePipelineCache(Device device,PipelineCacheCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,PipelineCache* pPipelineCache) => Vulkan.vkCreatePipelineCache(device,pCreateInfo,pAllocator,pPipelineCache);
		public void vkDestroyPipelineCache(Device device,PipelineCache pipelineCache,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyPipelineCache(device,pipelineCache,pAllocator);
		public Result vkGetPipelineCacheData(Device device,PipelineCache pipelineCache,uint* pDataSize,void* pData) => Vulkan.vkGetPipelineCacheData(device,pipelineCache,pDataSize,pData);
		public Result vkMergePipelineCaches(Device device,PipelineCache dstCache,uint32 srcCacheCount,PipelineCache* pSrcCaches) => Vulkan.vkMergePipelineCaches(device,dstCache,srcCacheCount,pSrcCaches);
		public Result vkCreateGraphicsPipelines(Device device,PipelineCache pipelineCache,uint32 createInfoCount,GraphicsPipelineCreateInfo* pCreateInfos,AllocationCallbacks* pAllocator,Pipeline* pPipelines) => Vulkan.vkCreateGraphicsPipelines(device,pipelineCache,createInfoCount,pCreateInfos,pAllocator,pPipelines);
		public Result vkCreateComputePipelines(Device device,PipelineCache pipelineCache,uint32 createInfoCount,ComputePipelineCreateInfo* pCreateInfos,AllocationCallbacks* pAllocator,Pipeline* pPipelines) => Vulkan.vkCreateComputePipelines(device,pipelineCache,createInfoCount,pCreateInfos,pAllocator,pPipelines);
		public void vkDestroyPipeline(Device device,Pipeline pipeline,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyPipeline(device,pipeline,pAllocator);
		public Result vkCreatePipelineLayout(Device device,PipelineLayoutCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,PipelineLayout* pPipelineLayout) => Vulkan.vkCreatePipelineLayout(device,pCreateInfo,pAllocator,pPipelineLayout);
		public void vkDestroyPipelineLayout(Device device,PipelineLayout pipelineLayout,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyPipelineLayout(device,pipelineLayout,pAllocator);
		public Result vkCreateSampler(Device device,SamplerCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,Sampler* pSampler) => Vulkan.vkCreateSampler(device,pCreateInfo,pAllocator,pSampler);
		public void vkDestroySampler(Device device,Sampler sampler,AllocationCallbacks* pAllocator) => Vulkan.vkDestroySampler(device,sampler,pAllocator);
		public Result vkCreateDescriptorSetLayout(Device device,DescriptorSetLayoutCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,DescriptorSetLayout* pSetLayout) => Vulkan.vkCreateDescriptorSetLayout(device,pCreateInfo,pAllocator,pSetLayout);
		public void vkDestroyDescriptorSetLayout(Device device,DescriptorSetLayout descriptorSetLayout,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyDescriptorSetLayout(device,descriptorSetLayout,pAllocator);
		public Result vkCreateDescriptorPool(Device device,DescriptorPoolCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,DescriptorPool* pDescriptorPool) => Vulkan.vkCreateDescriptorPool(device,pCreateInfo,pAllocator,pDescriptorPool);
		public void vkDestroyDescriptorPool(Device device,DescriptorPool descriptorPool,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyDescriptorPool(device,descriptorPool,pAllocator);
		public Result vkResetDescriptorPool(Device device,DescriptorPool descriptorPool,DescriptorPoolResetFlags flags) => Vulkan.vkResetDescriptorPool(device,descriptorPool,flags);
		public Result vkAllocateDescriptorSets(Device device,DescriptorSetAllocateInfo* pAllocateInfo,DescriptorSet* pDescriptorSets) => Vulkan.vkAllocateDescriptorSets(device,pAllocateInfo,pDescriptorSets);
		public Result vkFreeDescriptorSets(Device device,DescriptorPool descriptorPool,uint32 descriptorSetCount,DescriptorSet* pDescriptorSets) => Vulkan.vkFreeDescriptorSets(device,descriptorPool,descriptorSetCount,pDescriptorSets);
		public void vkUpdateDescriptorSets(Device device,uint32 descriptorWriteCount,WriteDescriptorSet* pDescriptorWrites,uint32 descriptorCopyCount,CopyDescriptorSet* pDescriptorCopies) => Vulkan.vkUpdateDescriptorSets(device,descriptorWriteCount,pDescriptorWrites,descriptorCopyCount,pDescriptorCopies);
		public Result vkCreateFramebuffer(Device device,FramebufferCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,Framebuffer* pFramebuffer) => Vulkan.vkCreateFramebuffer(device,pCreateInfo,pAllocator,pFramebuffer);
		public void vkDestroyFramebuffer(Device device,Framebuffer framebuffer,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyFramebuffer(device,framebuffer,pAllocator);
		public Result vkCreateRenderPass(Device device,RenderPassCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,RenderPass* pRenderPass) => Vulkan.vkCreateRenderPass(device,pCreateInfo,pAllocator,pRenderPass);
		public void vkDestroyRenderPass(Device device,RenderPass renderPass,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyRenderPass(device,renderPass,pAllocator);
		public void vkGetRenderAreaGranularity(Device device,RenderPass renderPass,Extent2D* pGranularity) => Vulkan.vkGetRenderAreaGranularity(device,renderPass,pGranularity);
		public Result vkCreateCommandPool(Device device,CommandPoolCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,CommandPool* pCommandPool) => Vulkan.vkCreateCommandPool(device,pCreateInfo,pAllocator,pCommandPool);
		public void vkDestroyCommandPool(Device device,CommandPool commandPool,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyCommandPool(device,commandPool,pAllocator);
		public Result vkResetCommandPool(Device device,CommandPool commandPool,CommandPoolResetFlags flags) => Vulkan.vkResetCommandPool(device,commandPool,flags);
		public Result vkAllocateCommandBuffers(Device device,CommandBufferAllocateInfo* pAllocateInfo,CommandBuffer* pCommandBuffers) => Vulkan.vkAllocateCommandBuffers(device,pAllocateInfo,pCommandBuffers);
		public void vkFreeCommandBuffers(Device device,CommandPool commandPool,uint32 commandBufferCount,CommandBuffer* pCommandBuffers) => Vulkan.vkFreeCommandBuffers(device,commandPool,commandBufferCount,pCommandBuffers);
		public Result vkBeginCommandBuffer(CommandBuffer commandBuffer,CommandBufferBeginInfo* pBeginInfo) => Vulkan.vkBeginCommandBuffer(commandBuffer,pBeginInfo);
		public Result vkEndCommandBuffer(CommandBuffer commandBuffer) => Vulkan.vkEndCommandBuffer(commandBuffer);
		public Result vkResetCommandBuffer(CommandBuffer commandBuffer,CommandBufferResetFlags flags) => Vulkan.vkResetCommandBuffer(commandBuffer,flags);
		public void vkCmdBindPipeline(CommandBuffer commandBuffer,PipelineBindPoint pipelineBindPoint,Pipeline pipeline) => Vulkan.vkCmdBindPipeline(commandBuffer,pipelineBindPoint,pipeline);
		public void vkCmdSetViewport(CommandBuffer commandBuffer,uint32 firstViewport,uint32 viewportCount,Viewport* pViewports) => Vulkan.vkCmdSetViewport(commandBuffer,firstViewport,viewportCount,pViewports);
		public void vkCmdSetScissor(CommandBuffer commandBuffer,uint32 firstScissor,uint32 scissorCount,Rect2D* pScissors) => Vulkan.vkCmdSetScissor(commandBuffer,firstScissor,scissorCount,pScissors);
		public void vkCmdSetLineWidth(CommandBuffer commandBuffer,float lineWidth) => Vulkan.vkCmdSetLineWidth(commandBuffer,lineWidth);
		public void vkCmdSetDepthBias(CommandBuffer commandBuffer,float depthBiasConstantFactor,float depthBiasClamp,float depthBiasSlopeFactor) => Vulkan.vkCmdSetDepthBias(commandBuffer,depthBiasConstantFactor,depthBiasClamp,depthBiasSlopeFactor);
		public void vkCmdSetBlendConstants(CommandBuffer commandBuffer,float blendConstants) => Vulkan.vkCmdSetBlendConstants(commandBuffer,blendConstants);
		public void vkCmdSetDepthBounds(CommandBuffer commandBuffer,float minDepthBounds,float maxDepthBounds) => Vulkan.vkCmdSetDepthBounds(commandBuffer,minDepthBounds,maxDepthBounds);
		public void vkCmdSetStencilCompareMask(CommandBuffer commandBuffer,StencilFaceFlags faceMask,uint32 compareMask) => Vulkan.vkCmdSetStencilCompareMask(commandBuffer,faceMask,compareMask);
		public void vkCmdSetStencilWriteMask(CommandBuffer commandBuffer,StencilFaceFlags faceMask,uint32 writeMask) => Vulkan.vkCmdSetStencilWriteMask(commandBuffer,faceMask,writeMask);
		public void vkCmdSetStencilReference(CommandBuffer commandBuffer,StencilFaceFlags faceMask,uint32 reference) => Vulkan.vkCmdSetStencilReference(commandBuffer,faceMask,reference);
		public void vkCmdBindDescriptorSets(CommandBuffer commandBuffer,PipelineBindPoint pipelineBindPoint,PipelineLayout layout,uint32 firstSet,uint32 descriptorSetCount,DescriptorSet* pDescriptorSets,uint32 dynamicOffsetCount,uint32* pDynamicOffsets) => Vulkan.vkCmdBindDescriptorSets(commandBuffer,pipelineBindPoint,layout,firstSet,descriptorSetCount,pDescriptorSets,dynamicOffsetCount,pDynamicOffsets);
		public void vkCmdBindIndexBuffer(CommandBuffer commandBuffer,Buffer buffer,DeviceSize offset,IndexType indexType) => Vulkan.vkCmdBindIndexBuffer(commandBuffer,buffer,offset,indexType);
		public void vkCmdBindVertexBuffers(CommandBuffer commandBuffer,uint32 firstBinding,uint32 bindingCount,Buffer* pBuffers,DeviceSize* pOffsets) => Vulkan.vkCmdBindVertexBuffers(commandBuffer,firstBinding,bindingCount,pBuffers,pOffsets);
		public void vkCmdDraw(CommandBuffer commandBuffer,uint32 vertexCount,uint32 instanceCount,uint32 firstVertex,uint32 firstInstance) => Vulkan.vkCmdDraw(commandBuffer,vertexCount,instanceCount,firstVertex,firstInstance);
		public void vkCmdDrawIndexed(CommandBuffer commandBuffer,uint32 indexCount,uint32 instanceCount,uint32 firstIndex,int32 vertexOffset,uint32 firstInstance) => Vulkan.vkCmdDrawIndexed(commandBuffer,indexCount,instanceCount,firstIndex,vertexOffset,firstInstance);
		public void vkCmdDrawIndirect(CommandBuffer commandBuffer,Buffer buffer,DeviceSize offset,uint32 drawCount,uint32 stride) => Vulkan.vkCmdDrawIndirect(commandBuffer,buffer,offset,drawCount,stride);
		public void vkCmdDrawIndexedIndirect(CommandBuffer commandBuffer,Buffer buffer,DeviceSize offset,uint32 drawCount,uint32 stride) => Vulkan.vkCmdDrawIndexedIndirect(commandBuffer,buffer,offset,drawCount,stride);
		public void vkCmdDispatch(CommandBuffer commandBuffer,uint32 groupCountX,uint32 groupCountY,uint32 groupCountZ) => Vulkan.vkCmdDispatch(commandBuffer,groupCountX,groupCountY,groupCountZ);
		public void vkCmdDispatchIndirect(CommandBuffer commandBuffer,Buffer buffer,DeviceSize offset) => Vulkan.vkCmdDispatchIndirect(commandBuffer,buffer,offset);
		public void vkCmdCopyBuffer(CommandBuffer commandBuffer,Buffer srcBuffer,Buffer dstBuffer,uint32 regionCount,BufferCopy* pRegions) => Vulkan.vkCmdCopyBuffer(commandBuffer,srcBuffer,dstBuffer,regionCount,pRegions);
		public void vkCmdCopyImage(CommandBuffer commandBuffer,Image srcImage,ImageLayout srcImageLayout,Image dstImage,ImageLayout dstImageLayout,uint32 regionCount,ImageCopy* pRegions) => Vulkan.vkCmdCopyImage(commandBuffer,srcImage,srcImageLayout,dstImage,dstImageLayout,regionCount,pRegions);
		public void vkCmdBlitImage(CommandBuffer commandBuffer,Image srcImage,ImageLayout srcImageLayout,Image dstImage,ImageLayout dstImageLayout,uint32 regionCount,ImageBlit* pRegions,Filter filter) => Vulkan.vkCmdBlitImage(commandBuffer,srcImage,srcImageLayout,dstImage,dstImageLayout,regionCount,pRegions,filter);
		public void vkCmdCopyBufferToImage(CommandBuffer commandBuffer,Buffer srcBuffer,Image dstImage,ImageLayout dstImageLayout,uint32 regionCount,BufferImageCopy* pRegions) => Vulkan.vkCmdCopyBufferToImage(commandBuffer,srcBuffer,dstImage,dstImageLayout,regionCount,pRegions);
		public void vkCmdCopyImageToBuffer(CommandBuffer commandBuffer,Image srcImage,ImageLayout srcImageLayout,Buffer dstBuffer,uint32 regionCount,BufferImageCopy* pRegions) => Vulkan.vkCmdCopyImageToBuffer(commandBuffer,srcImage,srcImageLayout,dstBuffer,regionCount,pRegions);
		public void vkCmdUpdateBuffer(CommandBuffer commandBuffer,Buffer dstBuffer,DeviceSize dstOffset,DeviceSize dataSize,void* pData) => Vulkan.vkCmdUpdateBuffer(commandBuffer,dstBuffer,dstOffset,dataSize,pData);
		public void vkCmdFillBuffer(CommandBuffer commandBuffer,Buffer dstBuffer,DeviceSize dstOffset,DeviceSize size,uint32 data) => Vulkan.vkCmdFillBuffer(commandBuffer,dstBuffer,dstOffset,size,data);
		public void vkCmdClearColorImage(CommandBuffer commandBuffer,Image image,ImageLayout imageLayout,ClearColorValue* pColor,uint32 rangeCount,ImageSubresourceRange* pRanges) => Vulkan.vkCmdClearColorImage(commandBuffer,image,imageLayout,pColor,rangeCount,pRanges);
		public void vkCmdClearDepthStencilImage(CommandBuffer commandBuffer,Image image,ImageLayout imageLayout,ClearDepthStencilValue* pDepthStencil,uint32 rangeCount,ImageSubresourceRange* pRanges) => Vulkan.vkCmdClearDepthStencilImage(commandBuffer,image,imageLayout,pDepthStencil,rangeCount,pRanges);
		public void vkCmdClearAttachments(CommandBuffer commandBuffer,uint32 attachmentCount,ClearAttachment* pAttachments,uint32 rectCount,ClearRect* pRects) => Vulkan.vkCmdClearAttachments(commandBuffer,attachmentCount,pAttachments,rectCount,pRects);
		public void vkCmdResolveImage(CommandBuffer commandBuffer,Image srcImage,ImageLayout srcImageLayout,Image dstImage,ImageLayout dstImageLayout,uint32 regionCount,ImageResolve* pRegions) => Vulkan.vkCmdResolveImage(commandBuffer,srcImage,srcImageLayout,dstImage,dstImageLayout,regionCount,pRegions);
		public void vkCmdSetEvent(CommandBuffer commandBuffer,Event event,PipelineStageFlags stageMask) => Vulkan.vkCmdSetEvent(commandBuffer,event,stageMask);
		public void vkCmdResetEvent(CommandBuffer commandBuffer,Event event,PipelineStageFlags stageMask) => Vulkan.vkCmdResetEvent(commandBuffer,event,stageMask);
		public void vkCmdWaitEvents(CommandBuffer commandBuffer,uint32 eventCount,Event* pEvents,PipelineStageFlags srcStageMask,PipelineStageFlags dstStageMask,uint32 memoryBarrierCount,MemoryBarrier* pMemoryBarriers,uint32 bufferMemoryBarrierCount,BufferMemoryBarrier* pBufferMemoryBarriers,uint32 imageMemoryBarrierCount,ImageMemoryBarrier* pImageMemoryBarriers) => Vulkan.vkCmdWaitEvents(commandBuffer,eventCount,pEvents,srcStageMask,dstStageMask,memoryBarrierCount,pMemoryBarriers,bufferMemoryBarrierCount,pBufferMemoryBarriers,imageMemoryBarrierCount,pImageMemoryBarriers);
		public void vkCmdPipelineBarrier(CommandBuffer commandBuffer,PipelineStageFlags srcStageMask,PipelineStageFlags dstStageMask,DependencyFlags dependencyFlags,uint32 memoryBarrierCount,MemoryBarrier* pMemoryBarriers,uint32 bufferMemoryBarrierCount,BufferMemoryBarrier* pBufferMemoryBarriers,uint32 imageMemoryBarrierCount,ImageMemoryBarrier* pImageMemoryBarriers) => Vulkan.vkCmdPipelineBarrier(commandBuffer,srcStageMask,dstStageMask,dependencyFlags,memoryBarrierCount,pMemoryBarriers,bufferMemoryBarrierCount,pBufferMemoryBarriers,imageMemoryBarrierCount,pImageMemoryBarriers);
		public void vkCmdBeginQuery(CommandBuffer commandBuffer,QueryPool queryPool,uint32 query,QueryControlFlags flags) => Vulkan.vkCmdBeginQuery(commandBuffer,queryPool,query,flags);
		public void vkCmdEndQuery(CommandBuffer commandBuffer,QueryPool queryPool,uint32 query) => Vulkan.vkCmdEndQuery(commandBuffer,queryPool,query);
		public void vkCmdResetQueryPool(CommandBuffer commandBuffer,QueryPool queryPool,uint32 firstQuery,uint32 queryCount) => Vulkan.vkCmdResetQueryPool(commandBuffer,queryPool,firstQuery,queryCount);
		public void vkCmdWriteTimestamp(CommandBuffer commandBuffer,PipelineStageFlags pipelineStage,QueryPool queryPool,uint32 query) => Vulkan.vkCmdWriteTimestamp(commandBuffer,pipelineStage,queryPool,query);
		public void vkCmdCopyQueryPoolResults(CommandBuffer commandBuffer,QueryPool queryPool,uint32 firstQuery,uint32 queryCount,Buffer dstBuffer,DeviceSize dstOffset,DeviceSize stride,QueryResultFlags flags) => Vulkan.vkCmdCopyQueryPoolResults(commandBuffer,queryPool,firstQuery,queryCount,dstBuffer,dstOffset,stride,flags);
		public void vkCmdPushConstants(CommandBuffer commandBuffer,PipelineLayout layout,ShaderStageFlags stageFlags,uint32 offset,uint32 size,void* pValues) => Vulkan.vkCmdPushConstants(commandBuffer,layout,stageFlags,offset,size,pValues);
		public void vkCmdBeginRenderPass(CommandBuffer commandBuffer,RenderPassBeginInfo* pRenderPassBegin,SubpassContents contents) => Vulkan.vkCmdBeginRenderPass(commandBuffer,pRenderPassBegin,contents);
		public void vkCmdNextSubpass(CommandBuffer commandBuffer,SubpassContents contents) => Vulkan.vkCmdNextSubpass(commandBuffer,contents);
		public void vkCmdEndRenderPass(CommandBuffer commandBuffer) => Vulkan.vkCmdEndRenderPass(commandBuffer);
		public void vkCmdExecuteCommands(CommandBuffer commandBuffer,uint32 commandBufferCount,CommandBuffer* pCommandBuffers) => Vulkan.vkCmdExecuteCommands(commandBuffer,commandBufferCount,pCommandBuffers);
		public Result vkEnumerateInstanceVersion(uint32* pApiVersion) => Vulkan.vkEnumerateInstanceVersion(pApiVersion);
		public Result vkBindBufferMemory2(Device device,uint32 bindInfoCount,BindBufferMemoryInfo* pBindInfos) => Vulkan.vkBindBufferMemory2(device,bindInfoCount,pBindInfos);
		public Result vkBindImageMemory2(Device device,uint32 bindInfoCount,BindImageMemoryInfo* pBindInfos) => Vulkan.vkBindImageMemory2(device,bindInfoCount,pBindInfos);
		public void vkGetDeviceGroupPeerMemoryFeatures(Device device,uint32 heapIndex,uint32 localDeviceIndex,uint32 remoteDeviceIndex,PeerMemoryFeatureFlags* pPeerMemoryFeatures) => Vulkan.vkGetDeviceGroupPeerMemoryFeatures(device,heapIndex,localDeviceIndex,remoteDeviceIndex,pPeerMemoryFeatures);
		public void vkCmdSetDeviceMask(CommandBuffer commandBuffer,uint32 deviceMask) => Vulkan.vkCmdSetDeviceMask(commandBuffer,deviceMask);
		public void vkCmdDispatchBase(CommandBuffer commandBuffer,uint32 baseGroupX,uint32 baseGroupY,uint32 baseGroupZ,uint32 groupCountX,uint32 groupCountY,uint32 groupCountZ) => Vulkan.vkCmdDispatchBase(commandBuffer,baseGroupX,baseGroupY,baseGroupZ,groupCountX,groupCountY,groupCountZ);
		public Result vkEnumeratePhysicalDeviceGroups(Instance instance,uint32* pPhysicalDeviceGroupCount,PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) => Vulkan.vkEnumeratePhysicalDeviceGroups(instance,pPhysicalDeviceGroupCount,pPhysicalDeviceGroupProperties);
		public void vkGetImageMemoryRequirements2(Device device,ImageMemoryRequirementsInfo2* pInfo,MemoryRequirements2* pMemoryRequirements) => Vulkan.vkGetImageMemoryRequirements2(device,pInfo,pMemoryRequirements);
		public void vkGetBufferMemoryRequirements2(Device device,BufferMemoryRequirementsInfo2* pInfo,MemoryRequirements2* pMemoryRequirements) => Vulkan.vkGetBufferMemoryRequirements2(device,pInfo,pMemoryRequirements);
		public void vkGetImageSparseMemoryRequirements2(Device device,ImageSparseMemoryRequirementsInfo2* pInfo,uint32* pSparseMemoryRequirementCount,SparseImageMemoryRequirements2* pSparseMemoryRequirements) => Vulkan.vkGetImageSparseMemoryRequirements2(device,pInfo,pSparseMemoryRequirementCount,pSparseMemoryRequirements);
		public void vkGetPhysicalDeviceFeatures2(PhysicalDevice physicalDevice,PhysicalDeviceFeatures2* pFeatures) => Vulkan.vkGetPhysicalDeviceFeatures2(physicalDevice,pFeatures);
		public void vkGetPhysicalDeviceProperties2(PhysicalDevice physicalDevice,PhysicalDeviceProperties2* pProperties) => Vulkan.vkGetPhysicalDeviceProperties2(physicalDevice,pProperties);
		public void vkGetPhysicalDeviceFormatProperties2(PhysicalDevice physicalDevice,Format format,FormatProperties2* pFormatProperties) => Vulkan.vkGetPhysicalDeviceFormatProperties2(physicalDevice,format,pFormatProperties);
		public Result vkGetPhysicalDeviceImageFormatProperties2(PhysicalDevice physicalDevice,PhysicalDeviceImageFormatInfo2* pImageFormatInfo,ImageFormatProperties2* pImageFormatProperties) => Vulkan.vkGetPhysicalDeviceImageFormatProperties2(physicalDevice,pImageFormatInfo,pImageFormatProperties);
		public void vkGetPhysicalDeviceQueueFamilyProperties2(PhysicalDevice physicalDevice,uint32* pQueueFamilyPropertyCount,QueueFamilyProperties2* pQueueFamilyProperties) => Vulkan.vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice,pQueueFamilyPropertyCount,pQueueFamilyProperties);
		public void vkGetPhysicalDeviceMemoryProperties2(PhysicalDevice physicalDevice,PhysicalDeviceMemoryProperties2* pMemoryProperties) => Vulkan.vkGetPhysicalDeviceMemoryProperties2(physicalDevice,pMemoryProperties);
		public void vkGetPhysicalDeviceSparseImageFormatProperties2(PhysicalDevice physicalDevice,PhysicalDeviceSparseImageFormatInfo2* pFormatInfo,uint32* pPropertyCount,SparseImageFormatProperties2* pProperties) => Vulkan.vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice,pFormatInfo,pPropertyCount,pProperties);
		public void vkTrimCommandPool(Device device,CommandPool commandPool,CommandPoolTrimFlags flags) => Vulkan.vkTrimCommandPool(device,commandPool,flags);
		public void vkGetDeviceQueue2(Device device,DeviceQueueInfo2* pQueueInfo,Queue* pQueue) => Vulkan.vkGetDeviceQueue2(device,pQueueInfo,pQueue);
		public Result vkCreateSamplerYcbcrConversion(Device device,SamplerYcbcrConversionCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,SamplerYcbcrConversion* pYcbcrConversion) => Vulkan.vkCreateSamplerYcbcrConversion(device,pCreateInfo,pAllocator,pYcbcrConversion);
		public void vkDestroySamplerYcbcrConversion(Device device,SamplerYcbcrConversion ycbcrConversion,AllocationCallbacks* pAllocator) => Vulkan.vkDestroySamplerYcbcrConversion(device,ycbcrConversion,pAllocator);
		public Result vkCreateDescriptorUpdateTemplate(Device device,DescriptorUpdateTemplateCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,DescriptorUpdateTemplate* pDescriptorUpdateTemplate) => Vulkan.vkCreateDescriptorUpdateTemplate(device,pCreateInfo,pAllocator,pDescriptorUpdateTemplate);
		public void vkDestroyDescriptorUpdateTemplate(Device device,DescriptorUpdateTemplate descriptorUpdateTemplate,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyDescriptorUpdateTemplate(device,descriptorUpdateTemplate,pAllocator);
		public void vkUpdateDescriptorSetWithTemplate(Device device,DescriptorSet descriptorSet,DescriptorUpdateTemplate descriptorUpdateTemplate,void* pData) => Vulkan.vkUpdateDescriptorSetWithTemplate(device,descriptorSet,descriptorUpdateTemplate,pData);
		public void vkGetPhysicalDeviceExternalBufferProperties(PhysicalDevice physicalDevice,PhysicalDeviceExternalBufferInfo* pExternalBufferInfo,ExternalBufferProperties* pExternalBufferProperties) => Vulkan.vkGetPhysicalDeviceExternalBufferProperties(physicalDevice,pExternalBufferInfo,pExternalBufferProperties);
		public void vkGetPhysicalDeviceExternalFenceProperties(PhysicalDevice physicalDevice,PhysicalDeviceExternalFenceInfo* pExternalFenceInfo,ExternalFenceProperties* pExternalFenceProperties) => Vulkan.vkGetPhysicalDeviceExternalFenceProperties(physicalDevice,pExternalFenceInfo,pExternalFenceProperties);
		public void vkGetPhysicalDeviceExternalSemaphoreProperties(PhysicalDevice physicalDevice,PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,ExternalSemaphoreProperties* pExternalSemaphoreProperties) => Vulkan.vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice,pExternalSemaphoreInfo,pExternalSemaphoreProperties);
		public void vkGetDescriptorSetLayoutSupport(Device device,DescriptorSetLayoutCreateInfo* pCreateInfo,DescriptorSetLayoutSupport* pSupport) => Vulkan.vkGetDescriptorSetLayoutSupport(device,pCreateInfo,pSupport);
		public void vkCmdDrawIndirectCount(CommandBuffer commandBuffer,Buffer buffer,DeviceSize offset,Buffer countBuffer,DeviceSize countBufferOffset,uint32 maxDrawCount,uint32 stride) => Vulkan.vkCmdDrawIndirectCount(commandBuffer,buffer,offset,countBuffer,countBufferOffset,maxDrawCount,stride);
		public void vkCmdDrawIndexedIndirectCount(CommandBuffer commandBuffer,Buffer buffer,DeviceSize offset,Buffer countBuffer,DeviceSize countBufferOffset,uint32 maxDrawCount,uint32 stride) => Vulkan.vkCmdDrawIndexedIndirectCount(commandBuffer,buffer,offset,countBuffer,countBufferOffset,maxDrawCount,stride);
		public Result vkCreateRenderPass2(Device device,RenderPassCreateInfo2* pCreateInfo,AllocationCallbacks* pAllocator,RenderPass* pRenderPass) => Vulkan.vkCreateRenderPass2(device,pCreateInfo,pAllocator,pRenderPass);
		public void vkCmdBeginRenderPass2(CommandBuffer commandBuffer,RenderPassBeginInfo* pRenderPassBegin,SubpassBeginInfo* pSubpassBeginInfo) => Vulkan.vkCmdBeginRenderPass2(commandBuffer,pRenderPassBegin,pSubpassBeginInfo);
		public void vkCmdNextSubpass2(CommandBuffer commandBuffer,SubpassBeginInfo* pSubpassBeginInfo,SubpassEndInfo* pSubpassEndInfo) => Vulkan.vkCmdNextSubpass2(commandBuffer,pSubpassBeginInfo,pSubpassEndInfo);
		public void vkCmdEndRenderPass2(CommandBuffer commandBuffer,SubpassEndInfo* pSubpassEndInfo) => Vulkan.vkCmdEndRenderPass2(commandBuffer,pSubpassEndInfo);
		public void vkResetQueryPool(Device device,QueryPool queryPool,uint32 firstQuery,uint32 queryCount) => Vulkan.vkResetQueryPool(device,queryPool,firstQuery,queryCount);
		public Result vkGetSemaphoreCounterValue(Device device,Semaphore semaphore,uint64* pValue) => Vulkan.vkGetSemaphoreCounterValue(device,semaphore,pValue);
		public Result vkWaitSemaphores(Device device,SemaphoreWaitInfo* pWaitInfo,uint64 timeout) => Vulkan.vkWaitSemaphores(device,pWaitInfo,timeout);
		public Result vkSignalSemaphore(Device device,SemaphoreSignalInfo* pSignalInfo) => Vulkan.vkSignalSemaphore(device,pSignalInfo);
		public DeviceAddress vkGetBufferDeviceAddress(Device device,BufferDeviceAddressInfo* pInfo) => Vulkan.vkGetBufferDeviceAddress(device,pInfo);
		public uint64 vkGetBufferOpaqueCaptureAddress(Device device,BufferDeviceAddressInfo* pInfo) => Vulkan.vkGetBufferOpaqueCaptureAddress(device,pInfo);
		public uint64 vkGetDeviceMemoryOpaqueCaptureAddress(Device device,DeviceMemoryOpaqueCaptureAddressInfo* pInfo) => Vulkan.vkGetDeviceMemoryOpaqueCaptureAddress(device,pInfo);
		public void vkDestroySurfaceKHR(Instance instance,SurfaceKHR surface,AllocationCallbacks* pAllocator) => Vulkan.vkDestroySurfaceKHR(instance,surface,pAllocator);
		public Result vkGetPhysicalDeviceSurfaceSupportKHR(PhysicalDevice physicalDevice,uint32 queueFamilyIndex,SurfaceKHR surface,Bool32* pSupported) => Vulkan.vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice,queueFamilyIndex,surface,pSupported);
		public Result vkGetPhysicalDeviceSurfaceCapabilitiesKHR(PhysicalDevice physicalDevice,SurfaceKHR surface,SurfaceCapabilitiesKHR* pSurfaceCapabilities) => Vulkan.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice,surface,pSurfaceCapabilities);
		public Result vkGetPhysicalDeviceSurfaceFormatsKHR(PhysicalDevice physicalDevice,SurfaceKHR surface,uint32* pSurfaceFormatCount,SurfaceFormatKHR* pSurfaceFormats) => Vulkan.vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice,surface,pSurfaceFormatCount,pSurfaceFormats);
		public Result vkGetPhysicalDeviceSurfacePresentModesKHR(PhysicalDevice physicalDevice,SurfaceKHR surface,uint32* pPresentModeCount,PresentModeKHR* pPresentModes) => Vulkan.vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice,surface,pPresentModeCount,pPresentModes);
		public Result vkCreateSwapchainKHR(Device device,SwapchainCreateInfoKHR* pCreateInfo,AllocationCallbacks* pAllocator,SwapchainKHR* pSwapchain) => Vulkan.vkCreateSwapchainKHR(device,pCreateInfo,pAllocator,pSwapchain);
		public void vkDestroySwapchainKHR(Device device,SwapchainKHR swapchain,AllocationCallbacks* pAllocator) => Vulkan.vkDestroySwapchainKHR(device,swapchain,pAllocator);
		public Result vkGetSwapchainImagesKHR(Device device,SwapchainKHR swapchain,uint32* pSwapchainImageCount,Image* pSwapchainImages) => Vulkan.vkGetSwapchainImagesKHR(device,swapchain,pSwapchainImageCount,pSwapchainImages);
		public Result vkAcquireNextImageKHR(Device device,SwapchainKHR swapchain,uint64 timeout,Semaphore semaphore,Fence fence,uint32* pImageIndex) => Vulkan.vkAcquireNextImageKHR(device,swapchain,timeout,semaphore,fence,pImageIndex);
		public Result vkQueuePresentKHR(Queue queue,PresentInfoKHR* pPresentInfo) => Vulkan.vkQueuePresentKHR(queue,pPresentInfo);
		public Result vkGetDeviceGroupPresentCapabilitiesKHR(Device device,DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) => Vulkan.vkGetDeviceGroupPresentCapabilitiesKHR(device,pDeviceGroupPresentCapabilities);
		public Result vkGetDeviceGroupSurfacePresentModesKHR(Device device,SurfaceKHR surface,DeviceGroupPresentModeFlagsKHR* pModes) => Vulkan.vkGetDeviceGroupSurfacePresentModesKHR(device,surface,pModes);
		public Result vkGetPhysicalDevicePresentRectanglesKHR(PhysicalDevice physicalDevice,SurfaceKHR surface,uint32* pRectCount,Rect2D* pRects) => Vulkan.vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice,surface,pRectCount,pRects);
		public Result vkAcquireNextImage2KHR(Device device,AcquireNextImageInfoKHR* pAcquireInfo,uint32* pImageIndex) => Vulkan.vkAcquireNextImage2KHR(device,pAcquireInfo,pImageIndex);
		public Result vkGetPhysicalDeviceDisplayPropertiesKHR(PhysicalDevice physicalDevice,uint32* pPropertyCount,DisplayPropertiesKHR* pProperties) => Vulkan.vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice,pPropertyCount,pProperties);
		public Result vkGetPhysicalDeviceDisplayPlanePropertiesKHR(PhysicalDevice physicalDevice,uint32* pPropertyCount,DisplayPlanePropertiesKHR* pProperties) => Vulkan.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice,pPropertyCount,pProperties);
		public Result vkGetDisplayPlaneSupportedDisplaysKHR(PhysicalDevice physicalDevice,uint32 planeIndex,uint32* pDisplayCount,DisplayKHR* pDisplays) => Vulkan.vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice,planeIndex,pDisplayCount,pDisplays);
		public Result vkGetDisplayModePropertiesKHR(PhysicalDevice physicalDevice,DisplayKHR display,uint32* pPropertyCount,DisplayModePropertiesKHR* pProperties) => Vulkan.vkGetDisplayModePropertiesKHR(physicalDevice,display,pPropertyCount,pProperties);
		public Result vkCreateDisplayModeKHR(PhysicalDevice physicalDevice,DisplayKHR display,DisplayModeCreateInfoKHR* pCreateInfo,AllocationCallbacks* pAllocator,DisplayModeKHR* pMode) => Vulkan.vkCreateDisplayModeKHR(physicalDevice,display,pCreateInfo,pAllocator,pMode);
		public Result vkGetDisplayPlaneCapabilitiesKHR(PhysicalDevice physicalDevice,DisplayModeKHR mode,uint32 planeIndex,DisplayPlaneCapabilitiesKHR* pCapabilities) => Vulkan.vkGetDisplayPlaneCapabilitiesKHR(physicalDevice,mode,planeIndex,pCapabilities);
		public Result vkCreateDisplayPlaneSurfaceKHR(Instance instance,DisplaySurfaceCreateInfoKHR* pCreateInfo,AllocationCallbacks* pAllocator,SurfaceKHR* pSurface) => Vulkan.vkCreateDisplayPlaneSurfaceKHR(instance,pCreateInfo,pAllocator,pSurface);
		public Result vkCreateSharedSwapchainsKHR(Device device,uint32 swapchainCount,SwapchainCreateInfoKHR* pCreateInfos,AllocationCallbacks* pAllocator,SwapchainKHR* pSwapchains) => Vulkan.vkCreateSharedSwapchainsKHR(device,swapchainCount,pCreateInfos,pAllocator,pSwapchains);
		public void vkGetPhysicalDeviceFeatures2KHR(PhysicalDevice physicalDevice,PhysicalDeviceFeatures2* pFeatures) => Vulkan.vkGetPhysicalDeviceFeatures2KHR(physicalDevice,pFeatures);
		public void vkGetPhysicalDeviceProperties2KHR(PhysicalDevice physicalDevice,PhysicalDeviceProperties2* pProperties) => Vulkan.vkGetPhysicalDeviceProperties2KHR(physicalDevice,pProperties);
		public void vkGetPhysicalDeviceFormatProperties2KHR(PhysicalDevice physicalDevice,Format format,FormatProperties2* pFormatProperties) => Vulkan.vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice,format,pFormatProperties);
		public Result vkGetPhysicalDeviceImageFormatProperties2KHR(PhysicalDevice physicalDevice,PhysicalDeviceImageFormatInfo2* pImageFormatInfo,ImageFormatProperties2* pImageFormatProperties) => Vulkan.vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice,pImageFormatInfo,pImageFormatProperties);
		public void vkGetPhysicalDeviceQueueFamilyProperties2KHR(PhysicalDevice physicalDevice,uint32* pQueueFamilyPropertyCount,QueueFamilyProperties2* pQueueFamilyProperties) => Vulkan.vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice,pQueueFamilyPropertyCount,pQueueFamilyProperties);
		public void vkGetPhysicalDeviceMemoryProperties2KHR(PhysicalDevice physicalDevice,PhysicalDeviceMemoryProperties2* pMemoryProperties) => Vulkan.vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice,pMemoryProperties);
		public void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(PhysicalDevice physicalDevice,PhysicalDeviceSparseImageFormatInfo2* pFormatInfo,uint32* pPropertyCount,SparseImageFormatProperties2* pProperties) => Vulkan.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice,pFormatInfo,pPropertyCount,pProperties);
		public void vkGetDeviceGroupPeerMemoryFeaturesKHR(Device device,uint32 heapIndex,uint32 localDeviceIndex,uint32 remoteDeviceIndex,PeerMemoryFeatureFlags* pPeerMemoryFeatures) => Vulkan.vkGetDeviceGroupPeerMemoryFeaturesKHR(device,heapIndex,localDeviceIndex,remoteDeviceIndex,pPeerMemoryFeatures);
		public void vkCmdSetDeviceMaskKHR(CommandBuffer commandBuffer,uint32 deviceMask) => Vulkan.vkCmdSetDeviceMaskKHR(commandBuffer,deviceMask);
		public void vkCmdDispatchBaseKHR(CommandBuffer commandBuffer,uint32 baseGroupX,uint32 baseGroupY,uint32 baseGroupZ,uint32 groupCountX,uint32 groupCountY,uint32 groupCountZ) => Vulkan.vkCmdDispatchBaseKHR(commandBuffer,baseGroupX,baseGroupY,baseGroupZ,groupCountX,groupCountY,groupCountZ);
		public void vkTrimCommandPoolKHR(Device device,CommandPool commandPool,CommandPoolTrimFlags flags) => Vulkan.vkTrimCommandPoolKHR(device,commandPool,flags);
		public Result vkEnumeratePhysicalDeviceGroupsKHR(Instance instance,uint32* pPhysicalDeviceGroupCount,PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) => Vulkan.vkEnumeratePhysicalDeviceGroupsKHR(instance,pPhysicalDeviceGroupCount,pPhysicalDeviceGroupProperties);
		public void vkGetPhysicalDeviceExternalBufferPropertiesKHR(PhysicalDevice physicalDevice,PhysicalDeviceExternalBufferInfo* pExternalBufferInfo,ExternalBufferProperties* pExternalBufferProperties) => Vulkan.vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice,pExternalBufferInfo,pExternalBufferProperties);
		public Result vkGetMemoryFdKHR(Device device,MemoryGetFdInfoKHR* pGetFdInfo,int* pFd) => Vulkan.vkGetMemoryFdKHR(device,pGetFdInfo,pFd);
		public Result vkGetMemoryFdPropertiesKHR(Device device,ExternalMemoryHandleTypeFlags handleType,int fd,MemoryFdPropertiesKHR* pMemoryFdProperties) => Vulkan.vkGetMemoryFdPropertiesKHR(device,handleType,fd,pMemoryFdProperties);
		public void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(PhysicalDevice physicalDevice,PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,ExternalSemaphoreProperties* pExternalSemaphoreProperties) => Vulkan.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice,pExternalSemaphoreInfo,pExternalSemaphoreProperties);
		public Result vkImportSemaphoreFdKHR(Device device,ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) => Vulkan.vkImportSemaphoreFdKHR(device,pImportSemaphoreFdInfo);
		public Result vkGetSemaphoreFdKHR(Device device,SemaphoreGetFdInfoKHR* pGetFdInfo,int* pFd) => Vulkan.vkGetSemaphoreFdKHR(device,pGetFdInfo,pFd);
		public void vkCmdPushDescriptorSetKHR(CommandBuffer commandBuffer,PipelineBindPoint pipelineBindPoint,PipelineLayout layout,uint32 set,uint32 descriptorWriteCount,WriteDescriptorSet* pDescriptorWrites) => Vulkan.vkCmdPushDescriptorSetKHR(commandBuffer,pipelineBindPoint,layout,set,descriptorWriteCount,pDescriptorWrites);
		public void vkCmdPushDescriptorSetWithTemplateKHR(CommandBuffer commandBuffer,DescriptorUpdateTemplate descriptorUpdateTemplate,PipelineLayout layout,uint32 set,void* pData) => Vulkan.vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer,descriptorUpdateTemplate,layout,set,pData);
		public Result vkCreateDescriptorUpdateTemplateKHR(Device device,DescriptorUpdateTemplateCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,DescriptorUpdateTemplate* pDescriptorUpdateTemplate) => Vulkan.vkCreateDescriptorUpdateTemplateKHR(device,pCreateInfo,pAllocator,pDescriptorUpdateTemplate);
		public void vkDestroyDescriptorUpdateTemplateKHR(Device device,DescriptorUpdateTemplate descriptorUpdateTemplate,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyDescriptorUpdateTemplateKHR(device,descriptorUpdateTemplate,pAllocator);
		public void vkUpdateDescriptorSetWithTemplateKHR(Device device,DescriptorSet descriptorSet,DescriptorUpdateTemplate descriptorUpdateTemplate,void* pData) => Vulkan.vkUpdateDescriptorSetWithTemplateKHR(device,descriptorSet,descriptorUpdateTemplate,pData);
		public Result vkCreateRenderPass2KHR(Device device,RenderPassCreateInfo2* pCreateInfo,AllocationCallbacks* pAllocator,RenderPass* pRenderPass) => Vulkan.vkCreateRenderPass2KHR(device,pCreateInfo,pAllocator,pRenderPass);
		public void vkCmdBeginRenderPass2KHR(CommandBuffer commandBuffer,RenderPassBeginInfo* pRenderPassBegin,SubpassBeginInfo* pSubpassBeginInfo) => Vulkan.vkCmdBeginRenderPass2KHR(commandBuffer,pRenderPassBegin,pSubpassBeginInfo);
		public void vkCmdNextSubpass2KHR(CommandBuffer commandBuffer,SubpassBeginInfo* pSubpassBeginInfo,SubpassEndInfo* pSubpassEndInfo) => Vulkan.vkCmdNextSubpass2KHR(commandBuffer,pSubpassBeginInfo,pSubpassEndInfo);
		public void vkCmdEndRenderPass2KHR(CommandBuffer commandBuffer,SubpassEndInfo* pSubpassEndInfo) => Vulkan.vkCmdEndRenderPass2KHR(commandBuffer,pSubpassEndInfo);
		public Result vkGetSwapchainStatusKHR(Device device,SwapchainKHR swapchain) => Vulkan.vkGetSwapchainStatusKHR(device,swapchain);
		public void vkGetPhysicalDeviceExternalFencePropertiesKHR(PhysicalDevice physicalDevice,PhysicalDeviceExternalFenceInfo* pExternalFenceInfo,ExternalFenceProperties* pExternalFenceProperties) => Vulkan.vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice,pExternalFenceInfo,pExternalFenceProperties);
		public Result vkImportFenceFdKHR(Device device,ImportFenceFdInfoKHR* pImportFenceFdInfo) => Vulkan.vkImportFenceFdKHR(device,pImportFenceFdInfo);
		public Result vkGetFenceFdKHR(Device device,FenceGetFdInfoKHR* pGetFdInfo,int* pFd) => Vulkan.vkGetFenceFdKHR(device,pGetFdInfo,pFd);
		public Result vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(PhysicalDevice physicalDevice,uint32 queueFamilyIndex,uint32* pCounterCount,PerformanceCounterKHR* pCounters,PerformanceCounterDescriptionKHR* pCounterDescriptions) => Vulkan.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice,queueFamilyIndex,pCounterCount,pCounters,pCounterDescriptions);
		public void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(PhysicalDevice physicalDevice,QueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo,uint32* pNumPasses) => Vulkan.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice,pPerformanceQueryCreateInfo,pNumPasses);
		public Result vkAcquireProfilingLockKHR(Device device,AcquireProfilingLockInfoKHR* pInfo) => Vulkan.vkAcquireProfilingLockKHR(device,pInfo);
		public void vkReleaseProfilingLockKHR(Device device) => Vulkan.vkReleaseProfilingLockKHR(device);
		public Result vkGetPhysicalDeviceSurfaceCapabilities2KHR(PhysicalDevice physicalDevice,PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,SurfaceCapabilities2KHR* pSurfaceCapabilities) => Vulkan.vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice,pSurfaceInfo,pSurfaceCapabilities);
		public Result vkGetPhysicalDeviceSurfaceFormats2KHR(PhysicalDevice physicalDevice,PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,uint32* pSurfaceFormatCount,SurfaceFormat2KHR* pSurfaceFormats) => Vulkan.vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice,pSurfaceInfo,pSurfaceFormatCount,pSurfaceFormats);
		public Result vkGetPhysicalDeviceDisplayProperties2KHR(PhysicalDevice physicalDevice,uint32* pPropertyCount,DisplayProperties2KHR* pProperties) => Vulkan.vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice,pPropertyCount,pProperties);
		public Result vkGetPhysicalDeviceDisplayPlaneProperties2KHR(PhysicalDevice physicalDevice,uint32* pPropertyCount,DisplayPlaneProperties2KHR* pProperties) => Vulkan.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice,pPropertyCount,pProperties);
		public Result vkGetDisplayModeProperties2KHR(PhysicalDevice physicalDevice,DisplayKHR display,uint32* pPropertyCount,DisplayModeProperties2KHR* pProperties) => Vulkan.vkGetDisplayModeProperties2KHR(physicalDevice,display,pPropertyCount,pProperties);
		public Result vkGetDisplayPlaneCapabilities2KHR(PhysicalDevice physicalDevice,DisplayPlaneInfo2KHR* pDisplayPlaneInfo,DisplayPlaneCapabilities2KHR* pCapabilities) => Vulkan.vkGetDisplayPlaneCapabilities2KHR(physicalDevice,pDisplayPlaneInfo,pCapabilities);
		public void vkGetImageMemoryRequirements2KHR(Device device,ImageMemoryRequirementsInfo2* pInfo,MemoryRequirements2* pMemoryRequirements) => Vulkan.vkGetImageMemoryRequirements2KHR(device,pInfo,pMemoryRequirements);
		public void vkGetBufferMemoryRequirements2KHR(Device device,BufferMemoryRequirementsInfo2* pInfo,MemoryRequirements2* pMemoryRequirements) => Vulkan.vkGetBufferMemoryRequirements2KHR(device,pInfo,pMemoryRequirements);
		public void vkGetImageSparseMemoryRequirements2KHR(Device device,ImageSparseMemoryRequirementsInfo2* pInfo,uint32* pSparseMemoryRequirementCount,SparseImageMemoryRequirements2* pSparseMemoryRequirements) => Vulkan.vkGetImageSparseMemoryRequirements2KHR(device,pInfo,pSparseMemoryRequirementCount,pSparseMemoryRequirements);
		public Result vkCreateSamplerYcbcrConversionKHR(Device device,SamplerYcbcrConversionCreateInfo* pCreateInfo,AllocationCallbacks* pAllocator,SamplerYcbcrConversion* pYcbcrConversion) => Vulkan.vkCreateSamplerYcbcrConversionKHR(device,pCreateInfo,pAllocator,pYcbcrConversion);
		public void vkDestroySamplerYcbcrConversionKHR(Device device,SamplerYcbcrConversion ycbcrConversion,AllocationCallbacks* pAllocator) => Vulkan.vkDestroySamplerYcbcrConversionKHR(device,ycbcrConversion,pAllocator);
		public Result vkBindBufferMemory2KHR(Device device,uint32 bindInfoCount,BindBufferMemoryInfo* pBindInfos) => Vulkan.vkBindBufferMemory2KHR(device,bindInfoCount,pBindInfos);
		public Result vkBindImageMemory2KHR(Device device,uint32 bindInfoCount,BindImageMemoryInfo* pBindInfos) => Vulkan.vkBindImageMemory2KHR(device,bindInfoCount,pBindInfos);
		public void vkGetDescriptorSetLayoutSupportKHR(Device device,DescriptorSetLayoutCreateInfo* pCreateInfo,DescriptorSetLayoutSupport* pSupport) => Vulkan.vkGetDescriptorSetLayoutSupportKHR(device,pCreateInfo,pSupport);
		public void vkCmdDrawIndirectCountKHR(CommandBuffer commandBuffer,Buffer buffer,DeviceSize offset,Buffer countBuffer,DeviceSize countBufferOffset,uint32 maxDrawCount,uint32 stride) => Vulkan.vkCmdDrawIndirectCountKHR(commandBuffer,buffer,offset,countBuffer,countBufferOffset,maxDrawCount,stride);
		public void vkCmdDrawIndexedIndirectCountKHR(CommandBuffer commandBuffer,Buffer buffer,DeviceSize offset,Buffer countBuffer,DeviceSize countBufferOffset,uint32 maxDrawCount,uint32 stride) => Vulkan.vkCmdDrawIndexedIndirectCountKHR(commandBuffer,buffer,offset,countBuffer,countBufferOffset,maxDrawCount,stride);
		public Result vkGetSemaphoreCounterValueKHR(Device device,Semaphore semaphore,uint64* pValue) => Vulkan.vkGetSemaphoreCounterValueKHR(device,semaphore,pValue);
		public Result vkWaitSemaphoresKHR(Device device,SemaphoreWaitInfo* pWaitInfo,uint64 timeout) => Vulkan.vkWaitSemaphoresKHR(device,pWaitInfo,timeout);
		public Result vkSignalSemaphoreKHR(Device device,SemaphoreSignalInfo* pSignalInfo) => Vulkan.vkSignalSemaphoreKHR(device,pSignalInfo);
		public DeviceAddress vkGetBufferDeviceAddressKHR(Device device,BufferDeviceAddressInfo* pInfo) => Vulkan.vkGetBufferDeviceAddressKHR(device,pInfo);
		public uint64 vkGetBufferOpaqueCaptureAddressKHR(Device device,BufferDeviceAddressInfo* pInfo) => Vulkan.vkGetBufferOpaqueCaptureAddressKHR(device,pInfo);
		public uint64 vkGetDeviceMemoryOpaqueCaptureAddressKHR(Device device,DeviceMemoryOpaqueCaptureAddressInfo* pInfo) => Vulkan.vkGetDeviceMemoryOpaqueCaptureAddressKHR(device,pInfo);
		public Result vkGetPipelineExecutablePropertiesKHR(Device device,PipelineInfoKHR* pPipelineInfo,uint32* pExecutableCount,PipelineExecutablePropertiesKHR* pProperties) => Vulkan.vkGetPipelineExecutablePropertiesKHR(device,pPipelineInfo,pExecutableCount,pProperties);
		public Result vkGetPipelineExecutableStatisticsKHR(Device device,PipelineExecutableInfoKHR* pExecutableInfo,uint32* pStatisticCount,PipelineExecutableStatisticKHR* pStatistics) => Vulkan.vkGetPipelineExecutableStatisticsKHR(device,pExecutableInfo,pStatisticCount,pStatistics);
		public Result vkGetPipelineExecutableInternalRepresentationsKHR(Device device,PipelineExecutableInfoKHR* pExecutableInfo,uint32* pInternalRepresentationCount,PipelineExecutableInternalRepresentationKHR* pInternalRepresentations) => Vulkan.vkGetPipelineExecutableInternalRepresentationsKHR(device,pExecutableInfo,pInternalRepresentationCount,pInternalRepresentations);
		public Result vkCreateDebugReportCallbackEXT(Instance instance,DebugReportCallbackCreateInfoEXT* pCreateInfo,AllocationCallbacks* pAllocator,DebugReportCallbackEXT* pCallback) => Vulkan.vkCreateDebugReportCallbackEXT(instance,pCreateInfo,pAllocator,pCallback);
		public void vkDestroyDebugReportCallbackEXT(Instance instance,DebugReportCallbackEXT callback,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyDebugReportCallbackEXT(instance,callback,pAllocator);
		public void vkDebugReportMessageEXT(Instance instance,DebugReportFlagsEXT flags,DebugReportObjectTypeEXT objectType,uint64 object,uint location,int32 messageCode,char8* pLayerPrefix,char8* pMessage) => Vulkan.vkDebugReportMessageEXT(instance,flags,objectType,object,location,messageCode,pLayerPrefix,pMessage);
		public Result vkDebugMarkerSetObjectTagEXT(Device device,DebugMarkerObjectTagInfoEXT* pTagInfo) => Vulkan.vkDebugMarkerSetObjectTagEXT(device,pTagInfo);
		public Result vkDebugMarkerSetObjectNameEXT(Device device,DebugMarkerObjectNameInfoEXT* pNameInfo) => Vulkan.vkDebugMarkerSetObjectNameEXT(device,pNameInfo);
		public void vkCmdDebugMarkerBeginEXT(CommandBuffer commandBuffer,DebugMarkerMarkerInfoEXT* pMarkerInfo) => Vulkan.vkCmdDebugMarkerBeginEXT(commandBuffer,pMarkerInfo);
		public void vkCmdDebugMarkerEndEXT(CommandBuffer commandBuffer) => Vulkan.vkCmdDebugMarkerEndEXT(commandBuffer);
		public void vkCmdDebugMarkerInsertEXT(CommandBuffer commandBuffer,DebugMarkerMarkerInfoEXT* pMarkerInfo) => Vulkan.vkCmdDebugMarkerInsertEXT(commandBuffer,pMarkerInfo);
		public void vkCmdBindTransformFeedbackBuffersEXT(CommandBuffer commandBuffer,uint32 firstBinding,uint32 bindingCount,Buffer* pBuffers,DeviceSize* pOffsets,DeviceSize* pSizes) => Vulkan.vkCmdBindTransformFeedbackBuffersEXT(commandBuffer,firstBinding,bindingCount,pBuffers,pOffsets,pSizes);
		public void vkCmdBeginTransformFeedbackEXT(CommandBuffer commandBuffer,uint32 firstCounterBuffer,uint32 counterBufferCount,Buffer* pCounterBuffers,DeviceSize* pCounterBufferOffsets) => Vulkan.vkCmdBeginTransformFeedbackEXT(commandBuffer,firstCounterBuffer,counterBufferCount,pCounterBuffers,pCounterBufferOffsets);
		public void vkCmdEndTransformFeedbackEXT(CommandBuffer commandBuffer,uint32 firstCounterBuffer,uint32 counterBufferCount,Buffer* pCounterBuffers,DeviceSize* pCounterBufferOffsets) => Vulkan.vkCmdEndTransformFeedbackEXT(commandBuffer,firstCounterBuffer,counterBufferCount,pCounterBuffers,pCounterBufferOffsets);
		public void vkCmdBeginQueryIndexedEXT(CommandBuffer commandBuffer,QueryPool queryPool,uint32 query,QueryControlFlags flags,uint32 index) => Vulkan.vkCmdBeginQueryIndexedEXT(commandBuffer,queryPool,query,flags,index);
		public void vkCmdEndQueryIndexedEXT(CommandBuffer commandBuffer,QueryPool queryPool,uint32 query,uint32 index) => Vulkan.vkCmdEndQueryIndexedEXT(commandBuffer,queryPool,query,index);
		public void vkCmdDrawIndirectByteCountEXT(CommandBuffer commandBuffer,uint32 instanceCount,uint32 firstInstance,Buffer counterBuffer,DeviceSize counterBufferOffset,uint32 counterOffset,uint32 vertexStride) => Vulkan.vkCmdDrawIndirectByteCountEXT(commandBuffer,instanceCount,firstInstance,counterBuffer,counterBufferOffset,counterOffset,vertexStride);
		public uint32 vkGetImageViewHandleNVX(Device device,ImageViewHandleInfoNVX* pInfo) => Vulkan.vkGetImageViewHandleNVX(device,pInfo);
		public void vkCmdDrawIndirectCountAMD(CommandBuffer commandBuffer,Buffer buffer,DeviceSize offset,Buffer countBuffer,DeviceSize countBufferOffset,uint32 maxDrawCount,uint32 stride) => Vulkan.vkCmdDrawIndirectCountAMD(commandBuffer,buffer,offset,countBuffer,countBufferOffset,maxDrawCount,stride);
		public void vkCmdDrawIndexedIndirectCountAMD(CommandBuffer commandBuffer,Buffer buffer,DeviceSize offset,Buffer countBuffer,DeviceSize countBufferOffset,uint32 maxDrawCount,uint32 stride) => Vulkan.vkCmdDrawIndexedIndirectCountAMD(commandBuffer,buffer,offset,countBuffer,countBufferOffset,maxDrawCount,stride);
		public Result vkGetShaderInfoAMD(Device device,Pipeline pipeline,ShaderStageFlags shaderStage,ShaderInfoTypeAMD infoType,uint* pInfoSize,void* pInfo) => Vulkan.vkGetShaderInfoAMD(device,pipeline,shaderStage,infoType,pInfoSize,pInfo);
		public Result vkGetPhysicalDeviceExternalImageFormatPropertiesNV(PhysicalDevice physicalDevice,Format format,ImageType type,ImageTiling tiling,ImageUsageFlags usage,ImageCreateFlags flags,ExternalMemoryHandleTypeFlagsNV externalHandleType,ExternalImageFormatPropertiesNV* pExternalImageFormatProperties) => Vulkan.vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice,format,type,tiling,usage,flags,externalHandleType,pExternalImageFormatProperties);
		public void vkCmdBeginConditionalRenderingEXT(CommandBuffer commandBuffer,ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) => Vulkan.vkCmdBeginConditionalRenderingEXT(commandBuffer,pConditionalRenderingBegin);
		public void vkCmdEndConditionalRenderingEXT(CommandBuffer commandBuffer) => Vulkan.vkCmdEndConditionalRenderingEXT(commandBuffer);
		public void vkCmdSetViewportWScalingNV(CommandBuffer commandBuffer,uint32 firstViewport,uint32 viewportCount,ViewportWScalingNV* pViewportWScalings) => Vulkan.vkCmdSetViewportWScalingNV(commandBuffer,firstViewport,viewportCount,pViewportWScalings);
		public Result vkReleaseDisplayEXT(PhysicalDevice physicalDevice,DisplayKHR display) => Vulkan.vkReleaseDisplayEXT(physicalDevice,display);
		public Result vkGetPhysicalDeviceSurfaceCapabilities2EXT(PhysicalDevice physicalDevice,SurfaceKHR surface,SurfaceCapabilities2EXT* pSurfaceCapabilities) => Vulkan.vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice,surface,pSurfaceCapabilities);
		public Result vkDisplayPowerControlEXT(Device device,DisplayKHR display,DisplayPowerInfoEXT* pDisplayPowerInfo) => Vulkan.vkDisplayPowerControlEXT(device,display,pDisplayPowerInfo);
		public Result vkRegisterDeviceEventEXT(Device device,DeviceEventInfoEXT* pDeviceEventInfo,AllocationCallbacks* pAllocator,Fence* pFence) => Vulkan.vkRegisterDeviceEventEXT(device,pDeviceEventInfo,pAllocator,pFence);
		public Result vkRegisterDisplayEventEXT(Device device,DisplayKHR display,DisplayEventInfoEXT* pDisplayEventInfo,AllocationCallbacks* pAllocator,Fence* pFence) => Vulkan.vkRegisterDisplayEventEXT(device,display,pDisplayEventInfo,pAllocator,pFence);
		public Result vkGetSwapchainCounterEXT(Device device,SwapchainKHR swapchain,SurfaceCounterFlagsEXT counter,uint64* pCounterValue) => Vulkan.vkGetSwapchainCounterEXT(device,swapchain,counter,pCounterValue);
		public Result vkGetRefreshCycleDurationGOOGLE(Device device,SwapchainKHR swapchain,RefreshCycleDurationGOOGLE* pDisplayTimingProperties) => Vulkan.vkGetRefreshCycleDurationGOOGLE(device,swapchain,pDisplayTimingProperties);
		public Result vkGetPastPresentationTimingGOOGLE(Device device,SwapchainKHR swapchain,uint32* pPresentationTimingCount,PastPresentationTimingGOOGLE* pPresentationTimings) => Vulkan.vkGetPastPresentationTimingGOOGLE(device,swapchain,pPresentationTimingCount,pPresentationTimings);
		public void vkCmdSetDiscardRectangleEXT(CommandBuffer commandBuffer,uint32 firstDiscardRectangle,uint32 discardRectangleCount,Rect2D* pDiscardRectangles) => Vulkan.vkCmdSetDiscardRectangleEXT(commandBuffer,firstDiscardRectangle,discardRectangleCount,pDiscardRectangles);
		public void vkSetHdrMetadataEXT(Device device,uint32 swapchainCount,SwapchainKHR* pSwapchains,HdrMetadataEXT* pMetadata) => Vulkan.vkSetHdrMetadataEXT(device,swapchainCount,pSwapchains,pMetadata);
		public Result vkSetDebugUtilsObjectNameEXT(Device device,DebugUtilsObjectNameInfoEXT* pNameInfo) => Vulkan.vkSetDebugUtilsObjectNameEXT(device,pNameInfo);
		public Result vkSetDebugUtilsObjectTagEXT(Device device,DebugUtilsObjectTagInfoEXT* pTagInfo) => Vulkan.vkSetDebugUtilsObjectTagEXT(device,pTagInfo);
		public void vkQueueBeginDebugUtilsLabelEXT(Queue queue,DebugUtilsLabelEXT* pLabelInfo) => Vulkan.vkQueueBeginDebugUtilsLabelEXT(queue,pLabelInfo);
		public void vkQueueEndDebugUtilsLabelEXT(Queue queue) => Vulkan.vkQueueEndDebugUtilsLabelEXT(queue);
		public void vkQueueInsertDebugUtilsLabelEXT(Queue queue,DebugUtilsLabelEXT* pLabelInfo) => Vulkan.vkQueueInsertDebugUtilsLabelEXT(queue,pLabelInfo);
		public void vkCmdBeginDebugUtilsLabelEXT(CommandBuffer commandBuffer,DebugUtilsLabelEXT* pLabelInfo) => Vulkan.vkCmdBeginDebugUtilsLabelEXT(commandBuffer,pLabelInfo);
		public void vkCmdEndDebugUtilsLabelEXT(CommandBuffer commandBuffer) => Vulkan.vkCmdEndDebugUtilsLabelEXT(commandBuffer);
		public void vkCmdInsertDebugUtilsLabelEXT(CommandBuffer commandBuffer,DebugUtilsLabelEXT* pLabelInfo) => Vulkan.vkCmdInsertDebugUtilsLabelEXT(commandBuffer,pLabelInfo);
		public Result vkCreateDebugUtilsMessengerEXT(Instance instance,DebugUtilsMessengerCreateInfoEXT* pCreateInfo,AllocationCallbacks* pAllocator,DebugUtilsMessengerEXT* pMessenger) => Vulkan.vkCreateDebugUtilsMessengerEXT(instance,pCreateInfo,pAllocator,pMessenger);
		public void vkDestroyDebugUtilsMessengerEXT(Instance instance,DebugUtilsMessengerEXT messenger,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyDebugUtilsMessengerEXT(instance,messenger,pAllocator);
		public void vkSubmitDebugUtilsMessageEXT(Instance instance,DebugUtilsMessageSeverityFlagsEXT messageSeverity,DebugUtilsMessageTypeFlagsEXT messageTypes,DebugUtilsMessengerCallbackDataEXT* pCallbackData) => Vulkan.vkSubmitDebugUtilsMessageEXT(instance,messageSeverity,messageTypes,pCallbackData);
		public void vkCmdSetSampleLocationsEXT(CommandBuffer commandBuffer,SampleLocationsInfoEXT* pSampleLocationsInfo) => Vulkan.vkCmdSetSampleLocationsEXT(commandBuffer,pSampleLocationsInfo);
		public void vkGetPhysicalDeviceMultisamplePropertiesEXT(PhysicalDevice physicalDevice,SampleCountFlags samples,MultisamplePropertiesEXT* pMultisampleProperties) => Vulkan.vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice,samples,pMultisampleProperties);
		public Result vkGetImageDrmFormatModifierPropertiesEXT(Device device,Image image,ImageDrmFormatModifierPropertiesEXT* pProperties) => Vulkan.vkGetImageDrmFormatModifierPropertiesEXT(device,image,pProperties);
		public Result vkCreateValidationCacheEXT(Device device,ValidationCacheCreateInfoEXT* pCreateInfo,AllocationCallbacks* pAllocator,ValidationCacheEXT* pValidationCache) => Vulkan.vkCreateValidationCacheEXT(device,pCreateInfo,pAllocator,pValidationCache);
		public void vkDestroyValidationCacheEXT(Device device,ValidationCacheEXT validationCache,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyValidationCacheEXT(device,validationCache,pAllocator);
		public Result vkMergeValidationCachesEXT(Device device,ValidationCacheEXT dstCache,uint32 srcCacheCount,ValidationCacheEXT* pSrcCaches) => Vulkan.vkMergeValidationCachesEXT(device,dstCache,srcCacheCount,pSrcCaches);
		public Result vkGetValidationCacheDataEXT(Device device,ValidationCacheEXT validationCache,uint* pDataSize,void* pData) => Vulkan.vkGetValidationCacheDataEXT(device,validationCache,pDataSize,pData);
		public void vkCmdBindShadingRateImageNV(CommandBuffer commandBuffer,ImageView imageView,ImageLayout imageLayout) => Vulkan.vkCmdBindShadingRateImageNV(commandBuffer,imageView,imageLayout);
		public void vkCmdSetViewportShadingRatePaletteNV(CommandBuffer commandBuffer,uint32 firstViewport,uint32 viewportCount,ShadingRatePaletteNV* pShadingRatePalettes) => Vulkan.vkCmdSetViewportShadingRatePaletteNV(commandBuffer,firstViewport,viewportCount,pShadingRatePalettes);
		public void vkCmdSetCoarseSampleOrderNV(CommandBuffer commandBuffer,CoarseSampleOrderTypeNV sampleOrderType,uint32 customSampleOrderCount,CoarseSampleOrderCustomNV* pCustomSampleOrders) => Vulkan.vkCmdSetCoarseSampleOrderNV(commandBuffer,sampleOrderType,customSampleOrderCount,pCustomSampleOrders);
		public Result vkCreateAccelerationStructureNV(Device device,AccelerationStructureCreateInfoNV* pCreateInfo,AllocationCallbacks* pAllocator,AccelerationStructureNV* pAccelerationStructure) => Vulkan.vkCreateAccelerationStructureNV(device,pCreateInfo,pAllocator,pAccelerationStructure);
		public void vkDestroyAccelerationStructureKHR(Device device,AccelerationStructureKHR accelerationStructure,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyAccelerationStructureKHR(device,accelerationStructure,pAllocator);
		public void vkDestroyAccelerationStructureNV(Device device,AccelerationStructureKHR accelerationStructure,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyAccelerationStructureNV(device,accelerationStructure,pAllocator);
		public void vkGetAccelerationStructureMemoryRequirementsNV(Device device,AccelerationStructureMemoryRequirementsInfoNV* pInfo,MemoryRequirements2KHR* pMemoryRequirements) => Vulkan.vkGetAccelerationStructureMemoryRequirementsNV(device,pInfo,pMemoryRequirements);
		public Result vkBindAccelerationStructureMemoryKHR(Device device,uint32 bindInfoCount,BindAccelerationStructureMemoryInfoKHR* pBindInfos) => Vulkan.vkBindAccelerationStructureMemoryKHR(device,bindInfoCount,pBindInfos);
		public Result vkBindAccelerationStructureMemoryNV(Device device,uint32 bindInfoCount,BindAccelerationStructureMemoryInfoKHR* pBindInfos) => Vulkan.vkBindAccelerationStructureMemoryNV(device,bindInfoCount,pBindInfos);
		public void vkCmdBuildAccelerationStructureNV(CommandBuffer commandBuffer,AccelerationStructureInfoNV* pInfo,Buffer instanceData,DeviceSize instanceOffset,Bool32 update,AccelerationStructureKHR dst,AccelerationStructureKHR src,Buffer scratch,DeviceSize scratchOffset) => Vulkan.vkCmdBuildAccelerationStructureNV(commandBuffer,pInfo,instanceData,instanceOffset,update,dst,src,scratch,scratchOffset);
		public void vkCmdCopyAccelerationStructureNV(CommandBuffer commandBuffer,AccelerationStructureKHR dst,AccelerationStructureKHR src,CopyAccelerationStructureModeKHR mode) => Vulkan.vkCmdCopyAccelerationStructureNV(commandBuffer,dst,src,mode);
		public void vkCmdTraceRaysNV(CommandBuffer commandBuffer,Buffer raygenShaderBindingTableBuffer,DeviceSize raygenShaderBindingOffset,Buffer missShaderBindingTableBuffer,DeviceSize missShaderBindingOffset,DeviceSize missShaderBindingStride,Buffer hitShaderBindingTableBuffer,DeviceSize hitShaderBindingOffset,DeviceSize hitShaderBindingStride,Buffer callableShaderBindingTableBuffer,DeviceSize callableShaderBindingOffset,DeviceSize callableShaderBindingStride,uint32 width,uint32 height,uint32 depth) => Vulkan.vkCmdTraceRaysNV(commandBuffer,raygenShaderBindingTableBuffer,raygenShaderBindingOffset,missShaderBindingTableBuffer,missShaderBindingOffset,missShaderBindingStride,hitShaderBindingTableBuffer,hitShaderBindingOffset,hitShaderBindingStride,callableShaderBindingTableBuffer,callableShaderBindingOffset,callableShaderBindingStride,width,height,depth);
		public Result vkCreateRayTracingPipelinesNV(Device device,PipelineCache pipelineCache,uint32 createInfoCount,RayTracingPipelineCreateInfoNV* pCreateInfos,AllocationCallbacks* pAllocator,Pipeline* pPipelines) => Vulkan.vkCreateRayTracingPipelinesNV(device,pipelineCache,createInfoCount,pCreateInfos,pAllocator,pPipelines);
		public Result vkGetRayTracingShaderGroupHandlesKHR(Device device,Pipeline pipeline,uint32 firstGroup,uint32 groupCount,uint dataSize,void* pData) => Vulkan.vkGetRayTracingShaderGroupHandlesKHR(device,pipeline,firstGroup,groupCount,dataSize,pData);
		public Result vkGetRayTracingShaderGroupHandlesNV(Device device,Pipeline pipeline,uint32 firstGroup,uint32 groupCount,uint dataSize,void* pData) => Vulkan.vkGetRayTracingShaderGroupHandlesNV(device,pipeline,firstGroup,groupCount,dataSize,pData);
		public Result vkGetAccelerationStructureHandleNV(Device device,AccelerationStructureKHR accelerationStructure,uint dataSize,void* pData) => Vulkan.vkGetAccelerationStructureHandleNV(device,accelerationStructure,dataSize,pData);
		public void vkCmdWriteAccelerationStructuresPropertiesKHR(CommandBuffer commandBuffer,uint32 accelerationStructureCount,AccelerationStructureKHR* pAccelerationStructures,QueryType queryType,QueryPool queryPool,uint32 firstQuery) => Vulkan.vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer,accelerationStructureCount,pAccelerationStructures,queryType,queryPool,firstQuery);
		public void vkCmdWriteAccelerationStructuresPropertiesNV(CommandBuffer commandBuffer,uint32 accelerationStructureCount,AccelerationStructureKHR* pAccelerationStructures,QueryType queryType,QueryPool queryPool,uint32 firstQuery) => Vulkan.vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer,accelerationStructureCount,pAccelerationStructures,queryType,queryPool,firstQuery);
		public Result vkCompileDeferredNV(Device device,Pipeline pipeline,uint32 shader) => Vulkan.vkCompileDeferredNV(device,pipeline,shader);
		public Result vkGetMemoryHostPointerPropertiesEXT(Device device,ExternalMemoryHandleTypeFlags handleType,void* pHostPointer,MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) => Vulkan.vkGetMemoryHostPointerPropertiesEXT(device,handleType,pHostPointer,pMemoryHostPointerProperties);
		public void vkCmdWriteBufferMarkerAMD(CommandBuffer commandBuffer,PipelineStageFlags pipelineStage,Buffer dstBuffer,DeviceSize dstOffset,uint32 marker) => Vulkan.vkCmdWriteBufferMarkerAMD(commandBuffer,pipelineStage,dstBuffer,dstOffset,marker);
		public Result vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(PhysicalDevice physicalDevice,uint32* pTimeDomainCount,TimeDomainEXT* pTimeDomains) => Vulkan.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice,pTimeDomainCount,pTimeDomains);
		public Result vkGetCalibratedTimestampsEXT(Device device,uint32 timestampCount,CalibratedTimestampInfoEXT* pTimestampInfos,uint64* pTimestamps,uint64* pMaxDeviation) => Vulkan.vkGetCalibratedTimestampsEXT(device,timestampCount,pTimestampInfos,pTimestamps,pMaxDeviation);
		public void vkCmdDrawMeshTasksNV(CommandBuffer commandBuffer,uint32 taskCount,uint32 firstTask) => Vulkan.vkCmdDrawMeshTasksNV(commandBuffer,taskCount,firstTask);
		public void vkCmdDrawMeshTasksIndirectNV(CommandBuffer commandBuffer,Buffer buffer,DeviceSize offset,uint32 drawCount,uint32 stride) => Vulkan.vkCmdDrawMeshTasksIndirectNV(commandBuffer,buffer,offset,drawCount,stride);
		public void vkCmdDrawMeshTasksIndirectCountNV(CommandBuffer commandBuffer,Buffer buffer,DeviceSize offset,Buffer countBuffer,DeviceSize countBufferOffset,uint32 maxDrawCount,uint32 stride) => Vulkan.vkCmdDrawMeshTasksIndirectCountNV(commandBuffer,buffer,offset,countBuffer,countBufferOffset,maxDrawCount,stride);
		public void vkCmdSetExclusiveScissorNV(CommandBuffer commandBuffer,uint32 firstExclusiveScissor,uint32 exclusiveScissorCount,Rect2D* pExclusiveScissors) => Vulkan.vkCmdSetExclusiveScissorNV(commandBuffer,firstExclusiveScissor,exclusiveScissorCount,pExclusiveScissors);
		public void vkCmdSetCheckpointNV(CommandBuffer commandBuffer,void* pCheckpointMarker) => Vulkan.vkCmdSetCheckpointNV(commandBuffer,pCheckpointMarker);
		public void vkGetQueueCheckpointDataNV(Queue queue,uint32* pCheckpointDataCount,CheckpointDataNV* pCheckpointData) => Vulkan.vkGetQueueCheckpointDataNV(queue,pCheckpointDataCount,pCheckpointData);
		public Result vkInitializePerformanceApiINTEL(Device device,InitializePerformanceApiInfoINTEL* pInitializeInfo) => Vulkan.vkInitializePerformanceApiINTEL(device,pInitializeInfo);
		public void vkUninitializePerformanceApiINTEL(Device device) => Vulkan.vkUninitializePerformanceApiINTEL(device);
		public Result vkCmdSetPerformanceMarkerINTEL(CommandBuffer commandBuffer,PerformanceMarkerInfoINTEL* pMarkerInfo) => Vulkan.vkCmdSetPerformanceMarkerINTEL(commandBuffer,pMarkerInfo);
		public Result vkCmdSetPerformanceStreamMarkerINTEL(CommandBuffer commandBuffer,PerformanceStreamMarkerInfoINTEL* pMarkerInfo) => Vulkan.vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer,pMarkerInfo);
		public Result vkCmdSetPerformanceOverrideINTEL(CommandBuffer commandBuffer,PerformanceOverrideInfoINTEL* pOverrideInfo) => Vulkan.vkCmdSetPerformanceOverrideINTEL(commandBuffer,pOverrideInfo);
		public Result vkAcquirePerformanceConfigurationINTEL(Device device,PerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,PerformanceConfigurationINTEL* pConfiguration) => Vulkan.vkAcquirePerformanceConfigurationINTEL(device,pAcquireInfo,pConfiguration);
		public Result vkReleasePerformanceConfigurationINTEL(Device device,PerformanceConfigurationINTEL configuration) => Vulkan.vkReleasePerformanceConfigurationINTEL(device,configuration);
		public Result vkQueueSetPerformanceConfigurationINTEL(Queue queue,PerformanceConfigurationINTEL configuration) => Vulkan.vkQueueSetPerformanceConfigurationINTEL(queue,configuration);
		public Result vkGetPerformanceParameterINTEL(Device device,PerformanceParameterTypeINTEL parameter,PerformanceValueINTEL* pValue) => Vulkan.vkGetPerformanceParameterINTEL(device,parameter,pValue);
		public void vkSetLocalDimmingAMD(Device device,SwapchainKHR swapChain,Bool32 localDimmingEnable) => Vulkan.vkSetLocalDimmingAMD(device,swapChain,localDimmingEnable);
		public DeviceAddress vkGetBufferDeviceAddressEXT(Device device,BufferDeviceAddressInfo* pInfo) => Vulkan.vkGetBufferDeviceAddressEXT(device,pInfo);
		public Result vkGetPhysicalDeviceToolPropertiesEXT(PhysicalDevice physicalDevice,uint32* pToolCount,PhysicalDeviceToolPropertiesEXT* pToolProperties) => Vulkan.vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice,pToolCount,pToolProperties);
		public Result vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(PhysicalDevice physicalDevice,uint32* pPropertyCount,CooperativeMatrixPropertiesNV* pProperties) => Vulkan.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice,pPropertyCount,pProperties);
		public Result vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(PhysicalDevice physicalDevice,uint32* pCombinationCount,FramebufferMixedSamplesCombinationNV* pCombinations) => Vulkan.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice,pCombinationCount,pCombinations);
		public Result vkCreateHeadlessSurfaceEXT(Instance instance,HeadlessSurfaceCreateInfoEXT* pCreateInfo,AllocationCallbacks* pAllocator,SurfaceKHR* pSurface) => Vulkan.vkCreateHeadlessSurfaceEXT(instance,pCreateInfo,pAllocator,pSurface);
		public void vkCmdSetLineStippleEXT(CommandBuffer commandBuffer,uint32 lineStippleFactor,uint16 lineStipplePattern) => Vulkan.vkCmdSetLineStippleEXT(commandBuffer,lineStippleFactor,lineStipplePattern);
		public void vkResetQueryPoolEXT(Device device,QueryPool queryPool,uint32 firstQuery,uint32 queryCount) => Vulkan.vkResetQueryPoolEXT(device,queryPool,firstQuery,queryCount);
		public void vkGetGeneratedCommandsMemoryRequirementsNV(Device device,GeneratedCommandsMemoryRequirementsInfoNV* pInfo,MemoryRequirements2* pMemoryRequirements) => Vulkan.vkGetGeneratedCommandsMemoryRequirementsNV(device,pInfo,pMemoryRequirements);
		public void vkCmdPreprocessGeneratedCommandsNV(CommandBuffer commandBuffer,GeneratedCommandsInfoNV* pGeneratedCommandsInfo) => Vulkan.vkCmdPreprocessGeneratedCommandsNV(commandBuffer,pGeneratedCommandsInfo);
		public void vkCmdExecuteGeneratedCommandsNV(CommandBuffer commandBuffer,Bool32 isPreprocessed,GeneratedCommandsInfoNV* pGeneratedCommandsInfo) => Vulkan.vkCmdExecuteGeneratedCommandsNV(commandBuffer,isPreprocessed,pGeneratedCommandsInfo);
		public void vkCmdBindPipelineShaderGroupNV(CommandBuffer commandBuffer,PipelineBindPoint pipelineBindPoint,Pipeline pipeline,uint32 groupIndex) => Vulkan.vkCmdBindPipelineShaderGroupNV(commandBuffer,pipelineBindPoint,pipeline,groupIndex);
		public Result vkCreateIndirectCommandsLayoutNV(Device device,IndirectCommandsLayoutCreateInfoNV* pCreateInfo,AllocationCallbacks* pAllocator,IndirectCommandsLayoutNV* pIndirectCommandsLayout) => Vulkan.vkCreateIndirectCommandsLayoutNV(device,pCreateInfo,pAllocator,pIndirectCommandsLayout);
		public void vkDestroyIndirectCommandsLayoutNV(Device device,IndirectCommandsLayoutNV indirectCommandsLayout,AllocationCallbacks* pAllocator) => Vulkan.vkDestroyIndirectCommandsLayoutNV(device,indirectCommandsLayout,pAllocator);

	}
	public struct DispatchLoaderDynamic 
	{
		public PFN_vkCreateInstance vkCreateInstance = null;
		public PFN_vkDestroyInstance vkDestroyInstance = null;
		public PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = null;
		public PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = null;
		public PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = null;
		public PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = null;
		public PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = null;
		public PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = null;
		public PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = null;
		public PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = null;
		public PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = null;
		public PFN_vkCreateDevice vkCreateDevice = null;
		public PFN_vkDestroyDevice vkDestroyDevice = null;
		public PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = null;
		public PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = null;
		public PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = null;
		public PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = null;
		public PFN_vkGetDeviceQueue vkGetDeviceQueue = null;
		public PFN_vkQueueSubmit vkQueueSubmit = null;
		public PFN_vkQueueWaitIdle vkQueueWaitIdle = null;
		public PFN_vkDeviceWaitIdle vkDeviceWaitIdle = null;
		public PFN_vkAllocateMemory vkAllocateMemory = null;
		public PFN_vkFreeMemory vkFreeMemory = null;
		public PFN_vkMapMemory vkMapMemory = null;
		public PFN_vkUnmapMemory vkUnmapMemory = null;
		public PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = null;
		public PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = null;
		public PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = null;
		public PFN_vkBindBufferMemory vkBindBufferMemory = null;
		public PFN_vkBindImageMemory vkBindImageMemory = null;
		public PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = null;
		public PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = null;
		public PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = null;
		public PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = null;
		public PFN_vkQueueBindSparse vkQueueBindSparse = null;
		public PFN_vkCreateFence vkCreateFence = null;
		public PFN_vkDestroyFence vkDestroyFence = null;
		public PFN_vkResetFences vkResetFences = null;
		public PFN_vkGetFenceStatus vkGetFenceStatus = null;
		public PFN_vkWaitForFences vkWaitForFences = null;
		public PFN_vkCreateSemaphore vkCreateSemaphore = null;
		public PFN_vkDestroySemaphore vkDestroySemaphore = null;
		public PFN_vkCreateEvent vkCreateEvent = null;
		public PFN_vkDestroyEvent vkDestroyEvent = null;
		public PFN_vkGetEventStatus vkGetEventStatus = null;
		public PFN_vkSetEvent vkSetEvent = null;
		public PFN_vkResetEvent vkResetEvent = null;
		public PFN_vkCreateQueryPool vkCreateQueryPool = null;
		public PFN_vkDestroyQueryPool vkDestroyQueryPool = null;
		public PFN_vkGetQueryPoolResults vkGetQueryPoolResults = null;
		public PFN_vkCreateBuffer vkCreateBuffer = null;
		public PFN_vkDestroyBuffer vkDestroyBuffer = null;
		public PFN_vkCreateBufferView vkCreateBufferView = null;
		public PFN_vkDestroyBufferView vkDestroyBufferView = null;
		public PFN_vkCreateImage vkCreateImage = null;
		public PFN_vkDestroyImage vkDestroyImage = null;
		public PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = null;
		public PFN_vkCreateImageView vkCreateImageView = null;
		public PFN_vkDestroyImageView vkDestroyImageView = null;
		public PFN_vkCreateShaderModule vkCreateShaderModule = null;
		public PFN_vkDestroyShaderModule vkDestroyShaderModule = null;
		public PFN_vkCreatePipelineCache vkCreatePipelineCache = null;
		public PFN_vkDestroyPipelineCache vkDestroyPipelineCache = null;
		public PFN_vkGetPipelineCacheData vkGetPipelineCacheData = null;
		public PFN_vkMergePipelineCaches vkMergePipelineCaches = null;
		public PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = null;
		public PFN_vkCreateComputePipelines vkCreateComputePipelines = null;
		public PFN_vkDestroyPipeline vkDestroyPipeline = null;
		public PFN_vkCreatePipelineLayout vkCreatePipelineLayout = null;
		public PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = null;
		public PFN_vkCreateSampler vkCreateSampler = null;
		public PFN_vkDestroySampler vkDestroySampler = null;
		public PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = null;
		public PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = null;
		public PFN_vkCreateDescriptorPool vkCreateDescriptorPool = null;
		public PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = null;
		public PFN_vkResetDescriptorPool vkResetDescriptorPool = null;
		public PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = null;
		public PFN_vkFreeDescriptorSets vkFreeDescriptorSets = null;
		public PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = null;
		public PFN_vkCreateFramebuffer vkCreateFramebuffer = null;
		public PFN_vkDestroyFramebuffer vkDestroyFramebuffer = null;
		public PFN_vkCreateRenderPass vkCreateRenderPass = null;
		public PFN_vkDestroyRenderPass vkDestroyRenderPass = null;
		public PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = null;
		public PFN_vkCreateCommandPool vkCreateCommandPool = null;
		public PFN_vkDestroyCommandPool vkDestroyCommandPool = null;
		public PFN_vkResetCommandPool vkResetCommandPool = null;
		public PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = null;
		public PFN_vkFreeCommandBuffers vkFreeCommandBuffers = null;
		public PFN_vkBeginCommandBuffer vkBeginCommandBuffer = null;
		public PFN_vkEndCommandBuffer vkEndCommandBuffer = null;
		public PFN_vkResetCommandBuffer vkResetCommandBuffer = null;
		public PFN_vkCmdBindPipeline vkCmdBindPipeline = null;
		public PFN_vkCmdSetViewport vkCmdSetViewport = null;
		public PFN_vkCmdSetScissor vkCmdSetScissor = null;
		public PFN_vkCmdSetLineWidth vkCmdSetLineWidth = null;
		public PFN_vkCmdSetDepthBias vkCmdSetDepthBias = null;
		public PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = null;
		public PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = null;
		public PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = null;
		public PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = null;
		public PFN_vkCmdSetStencilReference vkCmdSetStencilReference = null;
		public PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = null;
		public PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = null;
		public PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = null;
		public PFN_vkCmdDraw vkCmdDraw = null;
		public PFN_vkCmdDrawIndexed vkCmdDrawIndexed = null;
		public PFN_vkCmdDrawIndirect vkCmdDrawIndirect = null;
		public PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = null;
		public PFN_vkCmdDispatch vkCmdDispatch = null;
		public PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = null;
		public PFN_vkCmdCopyBuffer vkCmdCopyBuffer = null;
		public PFN_vkCmdCopyImage vkCmdCopyImage = null;
		public PFN_vkCmdBlitImage vkCmdBlitImage = null;
		public PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = null;
		public PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = null;
		public PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = null;
		public PFN_vkCmdFillBuffer vkCmdFillBuffer = null;
		public PFN_vkCmdClearColorImage vkCmdClearColorImage = null;
		public PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = null;
		public PFN_vkCmdClearAttachments vkCmdClearAttachments = null;
		public PFN_vkCmdResolveImage vkCmdResolveImage = null;
		public PFN_vkCmdSetEvent vkCmdSetEvent = null;
		public PFN_vkCmdResetEvent vkCmdResetEvent = null;
		public PFN_vkCmdWaitEvents vkCmdWaitEvents = null;
		public PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = null;
		public PFN_vkCmdBeginQuery vkCmdBeginQuery = null;
		public PFN_vkCmdEndQuery vkCmdEndQuery = null;
		public PFN_vkCmdResetQueryPool vkCmdResetQueryPool = null;
		public PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = null;
		public PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = null;
		public PFN_vkCmdPushConstants vkCmdPushConstants = null;
		public PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = null;
		public PFN_vkCmdNextSubpass vkCmdNextSubpass = null;
		public PFN_vkCmdEndRenderPass vkCmdEndRenderPass = null;
		public PFN_vkCmdExecuteCommands vkCmdExecuteCommands = null;
		public PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = null;
		public PFN_vkBindBufferMemory2 vkBindBufferMemory2 = null;
		public PFN_vkBindImageMemory2 vkBindImageMemory2 = null;
		public PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = null;
		public PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = null;
		public PFN_vkCmdDispatchBase vkCmdDispatchBase = null;
		public PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = null;
		public PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = null;
		public PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = null;
		public PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = null;
		public PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = null;
		public PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = null;
		public PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = null;
		public PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = null;
		public PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = null;
		public PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = null;
		public PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = null;
		public PFN_vkTrimCommandPool vkTrimCommandPool = null;
		public PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = null;
		public PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = null;
		public PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = null;
		public PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = null;
		public PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = null;
		public PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = null;
		public PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = null;
		public PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = null;
		public PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = null;
		public PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = null;
		public PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = null;
		public PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = null;
		public PFN_vkCreateRenderPass2 vkCreateRenderPass2 = null;
		public PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = null;
		public PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = null;
		public PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = null;
		public PFN_vkResetQueryPool vkResetQueryPool = null;
		public PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = null;
		public PFN_vkWaitSemaphores vkWaitSemaphores = null;
		public PFN_vkSignalSemaphore vkSignalSemaphore = null;
		public PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = null;
		public PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = null;
		public PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = null;
		public PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = null;
		public PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = null;
		public PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = null;
		public PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = null;
		public PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = null;
		public PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = null;
		public PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = null;
		public PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = null;
		public PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = null;
		public PFN_vkQueuePresentKHR vkQueuePresentKHR = null;
		public PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = null;
		public PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = null;
		public PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = null;
		public PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = null;
		public PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = null;
		public PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = null;
		public PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = null;
		public PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = null;
		public PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = null;
		public PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = null;
		public PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = null;
		public PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = null;
		public PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = null;
		public PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = null;
		public PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = null;
		public PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = null;
		public PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = null;
		public PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = null;
		public PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = null;
		public PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = null;
		public PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = null;
		public PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = null;
		public PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = null;
		public PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = null;
		public PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = null;
		public PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = null;
		public PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = null;
		public PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = null;
		public PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = null;
		public PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = null;
		public PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = null;
		public PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = null;
		public PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = null;
		public PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = null;
		public PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = null;
		public PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = null;
		public PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = null;
		public PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = null;
		public PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = null;
		public PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = null;
		public PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = null;
		public PFN_vkImportFenceFdKHR vkImportFenceFdKHR = null;
		public PFN_vkGetFenceFdKHR vkGetFenceFdKHR = null;
		public PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = null;
		public PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = null;
		public PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = null;
		public PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = null;
		public PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = null;
		public PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = null;
		public PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = null;
		public PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = null;
		public PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = null;
		public PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = null;
		public PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = null;
		public PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = null;
		public PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = null;
		public PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = null;
		public PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = null;
		public PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = null;
		public PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = null;
		public PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = null;
		public PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = null;
		public PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = null;
		public PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = null;
		public PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = null;
		public PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = null;
		public PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = null;
		public PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = null;
		public PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = null;
		public PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = null;
		public PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = null;
		public PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = null;
		public PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = null;
		public PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = null;
		public PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = null;
		public PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = null;
		public PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = null;
		public PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = null;
		public PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = null;
		public PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = null;
		public PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = null;
		public PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = null;
		public PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = null;
		public PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = null;
		public PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = null;
		public PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = null;
		public PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = null;
		public PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = null;
		public PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = null;
		public PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = null;
		public PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = null;
		public PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = null;
		public PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = null;
		public PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = null;
		public PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = null;
		public PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = null;
		public PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = null;
		public PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = null;
		public PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = null;
		public PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = null;
		public PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = null;
		public PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = null;
		public PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = null;
		public PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = null;
		public PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = null;
		public PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = null;
		public PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = null;
		public PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = null;
		public PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = null;
		public PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = null;
		public PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = null;
		public PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = null;
		public PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = null;
		public PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = null;
		public PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = null;
		public PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = null;
		public PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = null;
		public PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = null;
		public PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = null;
		public PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = null;
		public PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = null;
		public PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = null;
		public PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = null;
		public PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = null;
		public PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = null;
		public PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = null;
		public PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = null;
		public PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = null;
		public PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = null;
		public PFN_vkBindAccelerationStructureMemoryKHR vkBindAccelerationStructureMemoryKHR = null;
		public PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = null;
		public PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = null;
		public PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = null;
		public PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = null;
		public PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = null;
		public PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = null;
		public PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = null;
		public PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = null;
		public PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = null;
		public PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = null;
		public PFN_vkCompileDeferredNV vkCompileDeferredNV = null;
		public PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = null;
		public PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = null;
		public PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = null;
		public PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = null;
		public PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = null;
		public PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = null;
		public PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = null;
		public PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = null;
		public PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = null;
		public PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = null;
		public PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = null;
		public PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = null;
		public PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = null;
		public PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = null;
		public PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = null;
		public PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = null;
		public PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = null;
		public PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = null;
		public PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = null;
		public PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = null;
		public PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = null;
		public PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = null;
		public PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = null;
		public PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = null;
		public PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = null;
		public PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = null;
		public PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = null;
		public PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = null;
		public PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = null;
		public PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = null;
		public PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV = null;
		public PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = null;
		public PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV = null;

	}
}