Struct vulkan_raw::Functions

pub struct Functions { /* fields omitted */ }

Methods

impl Functions

pub fn load_from_instance(
    instance: VkInstance
) -> Result<Functions, LoadingError>

pub fn load_from_device(
    core_functions: &Functions,
    device: VkDevice
) -> Result<Functions, LoadingError>

pub unsafe fn vkDestroyInstance(
    &self,
    instance: VkInstance,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkEnumeratePhysicalDevices(
    &self,
    instance: VkInstance,
    pPhysicalDeviceCount: *mut u32,
    pPhysicalDevices: *mut VkPhysicalDevice
) -> VkResult

pub unsafe fn vkGetDeviceProcAddr(
    &self,
    device: VkDevice,
    pName: *const c_char
) -> PFN_vkVoidFunction

pub unsafe fn vkGetPhysicalDeviceProperties(
    &self,
    physicalDevice: VkPhysicalDevice,
    pProperties: *mut VkPhysicalDeviceProperties
)

pub unsafe fn vkGetPhysicalDeviceQueueFamilyProperties(
    &self,
    physicalDevice: VkPhysicalDevice,
    pQueueFamilyPropertyCount: *mut u32,
    pQueueFamilyProperties: *mut VkQueueFamilyProperties
)

pub unsafe fn vkGetPhysicalDeviceMemoryProperties(
    &self,
    physicalDevice: VkPhysicalDevice,
    pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties
)

pub unsafe fn vkGetPhysicalDeviceFeatures(
    &self,
    physicalDevice: VkPhysicalDevice,
    pFeatures: *mut VkPhysicalDeviceFeatures
)

pub unsafe fn vkGetPhysicalDeviceFormatProperties(
    &self,
    physicalDevice: VkPhysicalDevice,
    format: VkFormat,
    pFormatProperties: *mut VkFormatProperties
)

pub unsafe fn vkGetPhysicalDeviceImageFormatProperties(
    &self,
    physicalDevice: VkPhysicalDevice,
    format: VkFormat,
    r#type: VkImageType,
    tiling: VkImageTiling,
    usage: VkImageUsageFlags,
    flags: VkImageCreateFlags,
    pImageFormatProperties: *mut VkImageFormatProperties
) -> VkResult

pub unsafe fn vkCreateDevice(
    &self,
    physicalDevice: VkPhysicalDevice,
    pCreateInfo: *const VkDeviceCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pDevice: *mut VkDevice
) -> VkResult

pub unsafe fn vkDestroyDevice(
    &self,
    device: VkDevice,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkEnumerateDeviceLayerProperties(
    &self,
    physicalDevice: VkPhysicalDevice,
    pPropertyCount: *mut u32,
    pProperties: *mut VkLayerProperties
) -> VkResult

pub unsafe fn vkEnumerateDeviceExtensionProperties(
    &self,
    physicalDevice: VkPhysicalDevice,
    pLayerName: *const c_char,
    pPropertyCount: *mut u32,
    pProperties: *mut VkExtensionProperties
) -> VkResult

pub unsafe fn vkGetDeviceQueue(
    &self,
    device: VkDevice,
    queueFamilyIndex: u32,
    queueIndex: u32,
    pQueue: *mut VkQueue
)

pub unsafe fn vkQueueSubmit(
    &self,
    queue: VkQueue,
    submitCount: u32,
    pSubmits: *const VkSubmitInfo,
    fence: VkFence
) -> VkResult

pub unsafe fn vkQueueWaitIdle(&self, queue: VkQueue) -> VkResult

pub unsafe fn vkDeviceWaitIdle(&self, device: VkDevice) -> VkResult

pub unsafe fn vkAllocateMemory(
    &self,
    device: VkDevice,
    pAllocateInfo: *const VkMemoryAllocateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pMemory: *mut VkDeviceMemory
) -> VkResult

pub unsafe fn vkFreeMemory(
    &self,
    device: VkDevice,
    memory: VkDeviceMemory,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkMapMemory(
    &self,
    device: VkDevice,
    memory: VkDeviceMemory,
    offset: VkDeviceSize,
    size: VkDeviceSize,
    flags: VkMemoryMapFlags,
    ppData: *mut *mut c_void
) -> VkResult

pub unsafe fn vkUnmapMemory(&self, device: VkDevice, memory: VkDeviceMemory)

pub unsafe fn vkFlushMappedMemoryRanges(
    &self,
    device: VkDevice,
    memoryRangeCount: u32,
    pMemoryRanges: *const VkMappedMemoryRange
) -> VkResult

pub unsafe fn vkInvalidateMappedMemoryRanges(
    &self,
    device: VkDevice,
    memoryRangeCount: u32,
    pMemoryRanges: *const VkMappedMemoryRange
) -> VkResult

pub unsafe fn vkGetDeviceMemoryCommitment(
    &self,
    device: VkDevice,
    memory: VkDeviceMemory,
    pCommittedMemoryInBytes: *mut VkDeviceSize
)

pub unsafe fn vkGetBufferMemoryRequirements(
    &self,
    device: VkDevice,
    buffer: VkBuffer,
    pMemoryRequirements: *const VkMemoryRequirements
)

pub unsafe fn vkBindBufferMemory(
    &self,
    device: VkDevice,
    buffer: VkBuffer,
    memory: VkDeviceMemory,
    memoryOffset: VkDeviceSize
) -> VkResult

pub unsafe fn vkGetImageMemoryRequirements(
    &self,
    device: VkDevice,
    image: VkImage,
    pMemoryRequirements: *mut VkMemoryRequirements
)

pub unsafe fn vkBindImageMemory(
    &self,
    device: VkDevice,
    image: VkImage,
    memory: VkDeviceMemory,
    memoryOffset: VkDeviceSize
) -> VkResult

pub unsafe fn vkGetImageSparseMemoryRequirements(
    &self,
    device: VkDevice,
    image: VkImage,
    pSparseMemoryRequirementCount: *mut u32,
    pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements
)

pub unsafe fn vkGetPhysicalDeviceSparseImageFormatProperties(
    &self,
    physicalDevice: VkPhysicalDevice,
    format: VkFormat,
    r#type: VkImageType,
    samples: VkSampleCountFlagBits,
    usage: VkImageUsageFlags,
    tiling: VkImageTiling,
    pPropertyCount: *mut u32,
    pProperties: *mut VkSparseImageFormatProperties
)

pub unsafe fn vkQueueBindSparse(
    &self,
    queue: VkQueue,
    bindInfoCount: u32,
    pBindInfo: *const VkBindSparseInfo,
    fence: VkFence
) -> VkResult

pub unsafe fn vkCreateFence(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkFenceCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pFence: *mut VkFence
) -> VkResult

pub unsafe fn vkDestroyFence(
    &self,
    device: VkDevice,
    fence: VkFence,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkResetFences(
    &self,
    device: VkDevice,
    fenceCount: u32,
    pFences: *const VkFence
) -> VkResult

pub unsafe fn vkGetFenceStatus(
    &self,
    device: VkDevice,
    fence: VkFence
) -> VkResult

pub unsafe fn vkWaitForFences(
    &self,
    device: VkDevice,
    fenceCount: u32,
    pFences: *const VkFence,
    waitAll: VkBool32,
    timeout: u64
) -> VkResult

pub unsafe fn vkCreateSemaphore(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkSemaphoreCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pSemaphore: *mut VkSemaphore
) -> VkResult

pub unsafe fn vkDestroySemaphore(
    &self,
    device: VkDevice,
    semaphore: VkSemaphore,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkCreateEvent(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkEventCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pEvent: *mut VkEvent
) -> VkResult

pub unsafe fn vkDestroyEvent(
    &self,
    device: VkDevice,
    event: VkEvent,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkGetEventStatus(
    &self,
    device: VkDevice,
    event: VkEvent
) -> VkResult

pub unsafe fn vkSetEvent(&self, device: VkDevice, event: VkEvent) -> VkResult

pub unsafe fn vkResetEvent(&self, device: VkDevice, event: VkEvent) -> VkResult

pub unsafe fn vkCreateQueryPool(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkQueryPoolCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pQueryPool: *mut VkQueryPool
) -> VkResult

pub unsafe fn vkDestroyQueryPool(
    &self,
    device: VkDevice,
    queryPool: VkQueryPool,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkGetQueryPoolResults(
    &self,
    device: VkDevice,
    queryPool: VkQueryPool,
    firstQuery: u32,
    queryCount: u32,
    dataSize: isize,
    pData: *mut c_void,
    stride: VkDeviceSize,
    flags: VkQueryResultFlags
) -> VkResult

pub unsafe fn vkCreateBuffer(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkBufferCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pBuffer: *mut VkBuffer
) -> VkResult

pub unsafe fn vkDestroyBuffer(
    &self,
    device: VkDevice,
    buffer: VkBuffer,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkCreateBufferView(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkBufferViewCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pView: *mut VkBufferView
) -> VkResult

pub unsafe fn vkDestroyBufferView(
    &self,
    device: VkDevice,
    bufferView: VkBufferView,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkCreateImage(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkImageCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pImage: *mut VkImage
) -> VkResult

pub unsafe fn vkDestroyImage(
    &self,
    device: VkDevice,
    image: VkImage,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkGetImageSubresourceLayout(
    &self,
    device: VkDevice,
    image: VkImage,
    pSubresource: *const VkImageSubresource,
    pLayout: *mut VkSubresourceLayout
)

pub unsafe fn vkCreateImageView(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkImageViewCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pView: *mut VkImageView
) -> VkResult

pub unsafe fn vkDestroyImageView(
    &self,
    device: VkDevice,
    imageView: VkImageView,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkCreateShaderModule(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkShaderModuleCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pShaderModule: *mut VkShaderModule
) -> VkResult

pub unsafe fn vkDestroyShaderModule(
    &self,
    device: VkDevice,
    shaderModule: VkShaderModule,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkCreatePipelineCache(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkPipelineCacheCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pPipelineCache: *mut VkPipelineCache
) -> VkResult

pub unsafe fn vkDestroyPipelineCache(
    &self,
    device: VkDevice,
    pipelineCache: VkPipelineCache,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkGetPipelineCacheData(
    &self,
    device: VkDevice,
    pipelineCache: VkPipelineCache,
    pDataSize: *mut isize,
    pData: *mut c_void
) -> VkResult

pub unsafe fn vkMergePipelineCaches(
    &self,
    device: VkDevice,
    dstCache: VkPipelineCache,
    srcCacheCount: u32,
    pSrcCaches: *const VkPipelineCache
) -> VkResult

pub unsafe fn vkCreateGraphicsPipelines(
    &self,
    device: VkDevice,
    pipelineCache: VkPipelineCache,
    createInfoCount: u32,
    pCreateInfos: *const VkGraphicsPipelineCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pPipelines: *mut VkPipeline
) -> VkResult

pub unsafe fn vkCreateComputePipelines(
    &self,
    device: VkDevice,
    pipelineCache: VkPipelineCache,
    createInfoCount: u32,
    pCreateInfos: *const VkComputePipelineCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pPipelines: *mut VkPipeline
) -> VkResult

pub unsafe fn vkDestroyPipeline(
    &self,
    device: VkDevice,
    pipeline: VkPipeline,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkCreatePipelineLayout(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkPipelineLayoutCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pPipelineLayout: *mut VkPipelineLayout
) -> VkResult

pub unsafe fn vkDestroyPipelineLayout(
    &self,
    device: VkDevice,
    pipelineLayout: VkPipelineLayout,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkCreateSampler(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkSamplerCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pSampler: *mut VkSampler
) -> VkResult

pub unsafe fn vkDestroySampler(
    &self,
    device: VkDevice,
    sampler: VkSampler,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkCreateDescriptorSetLayout(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkDescriptorSetLayoutCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pSetLayout: *mut VkDescriptorSetLayout
) -> VkResult

pub unsafe fn vkDestroyDescriptorSetLayout(
    &self,
    device: VkDevice,
    descriptorSetLayout: VkDescriptorSetLayout,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkCreateDescriptorPool(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkDescriptorPoolCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pDescriptorPool: *mut VkDescriptorPool
) -> VkResult

pub unsafe fn vkDestroyDescriptorPool(
    &self,
    device: VkDevice,
    descriptorPool: VkDescriptorPool,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkResetDescriptorPool(
    &self,
    device: VkDevice,
    descriptorPool: VkDescriptorPool,
    flags: VkDescriptorPoolResetFlags
) -> VkResult

pub unsafe fn vkAllocateDescriptorSets(
    &self,
    device: VkDevice,
    pAllocateInfo: *const VkDescriptorSetAllocateInfo,
    pDescriptorSets: *mut VkDescriptorSet
) -> VkResult

pub unsafe fn vkFreeDescriptorSets(
    &self,
    device: VkDevice,
    descriptorPool: VkDescriptorPool,
    descriptorSetCount: u32,
    pDescriptorSets: *const VkDescriptorSet
) -> VkResult

pub unsafe fn vkUpdateDescriptorSets(
    &self,
    device: VkDevice,
    descriptorWriteCount: u32,
    pDescriptorWrites: *const VkWriteDescriptorSet,
    descriptorCopyCount: u32,
    pDescriptorCopies: *const VkCopyDescriptorSet
)

pub unsafe fn vkCreateFramebuffer(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkFramebufferCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pFramebuffer: *mut VkFramebuffer
) -> VkResult

pub unsafe fn vkDestroyFramebuffer(
    &self,
    device: VkDevice,
    framebuffer: VkFramebuffer,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkCreateRenderPass(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkRenderPassCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pRenderPass: *mut VkRenderPass
) -> VkResult

pub unsafe fn vkDestroyRenderPass(
    &self,
    device: VkDevice,
    renderPass: VkRenderPass,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkGetRenderAreaGranularity(
    &self,
    device: VkDevice,
    renderPass: VkRenderPass,
    pGranularity: *mut VkExtent2D
)

pub unsafe fn vkCreateCommandPool(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkCommandPoolCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pCommandPool: *mut VkCommandPool
) -> VkResult

pub unsafe fn vkDestroyCommandPool(
    &self,
    device: VkDevice,
    commandPool: VkCommandPool,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkResetCommandPool(
    &self,
    device: VkDevice,
    commandPool: VkCommandPool,
    flags: VkCommandPoolResetFlags
) -> VkResult

pub unsafe fn vkAllocateCommandBuffers(
    &self,
    device: VkDevice,
    pAllocateInfo: *const VkCommandBufferAllocateInfo,
    pCommandBuffers: *mut VkCommandBuffer
) -> VkResult

pub unsafe fn vkFreeCommandBuffers(
    &self,
    device: VkDevice,
    commandPool: VkCommandPool,
    commandBufferCount: u32,
    pCommandBuffers: *const VkCommandBuffer
)

pub unsafe fn vkBeginCommandBuffer(
    &self,
    commandBuffer: VkCommandBuffer,
    pBeginInfo: *const VkCommandBufferBeginInfo
) -> VkResult

pub unsafe fn vkEndCommandBuffer(
    &self,
    commandBuffer: VkCommandBuffer
) -> VkResult

pub unsafe fn vkResetCommandBuffer(
    &self,
    commandBuffer: VkCommandBuffer,
    flags: VkCommandBufferResetFlags
) -> VkResult

pub unsafe fn vkCmdBindPipeline(
    &self,
    commandBuffer: VkCommandBuffer,
    pipelineBindPoint: VkPipelineBindPoint,
    pipeline: VkPipeline
)

pub unsafe fn vkCmdSetViewport(
    &self,
    commandBuffer: VkCommandBuffer,
    firstViewport: u32,
    viewportCount: u32,
    pViewports: *const VkViewport
)

pub unsafe fn vkCmdSetScissor(
    &self,
    commandBuffer: VkCommandBuffer,
    firstScissor: u32,
    scissorCount: u32,
    pScissors: *const VkRect2D
)

pub unsafe fn vkCmdSetLineWidth(
    &self,
    commandBuffer: VkCommandBuffer,
    lineWidth: f32
)

pub unsafe fn vkCmdSetDepthBias(
    &self,
    commandBuffer: VkCommandBuffer,
    depthBiasConstantFactor: f32,
    depthBiasClamp: f32,
    depthBiasSlopeFactor: f32
)

pub unsafe fn vkCmdSetBlendConstants(
    &self,
    commandBuffer: VkCommandBuffer,
    blendConstants: *const [f32; 4]
)

pub unsafe fn vkCmdSetDepthBounds(
    &self,
    commandBuffer: VkCommandBuffer,
    minDepthBounds: f32,
    maxDepthBounds: f32
)

pub unsafe fn vkCmdSetStencilCompareMask(
    &self,
    commandBuffer: VkCommandBuffer,
    faceMask: VkStencilFaceFlags,
    compareMask: u32
)

pub unsafe fn vkCmdSetStencilWriteMask(
    &self,
    commandBuffer: VkCommandBuffer,
    faceMask: VkStencilFaceFlags,
    writeMask: u32
)

pub unsafe fn vkCmdSetStencilReference(
    &self,
    commandBuffer: VkCommandBuffer,
    faceMask: VkStencilFaceFlags,
    reference: u32
)

pub unsafe fn vkCmdBindDescriptorSets(
    &self,
    commandBuffer: VkCommandBuffer,
    pipelineBindPoint: VkPipelineBindPoint,
    layout: VkPipelineLayout,
    firstSet: u32,
    descriptorSetCount: u32,
    pDescriptorSets: *const VkDescriptorSet,
    dynamicOffsetCount: u32,
    pDynamicOffsets: *const u32
)

pub unsafe fn vkCmdBindIndexBuffer(
    &self,
    commandBuffer: VkCommandBuffer,
    buffer: VkBuffer,
    offset: VkDeviceSize,
    indexType: VkIndexType
)

pub unsafe fn vkCmdBindVertexBuffers(
    &self,
    commandBuffer: VkCommandBuffer,
    firstBinding: u32,
    bindingCount: u32,
    pBuffers: *const VkBuffer,
    pOffsets: *const VkDeviceSize
)

pub unsafe fn vkCmdDraw(
    &self,
    commandBuffer: VkCommandBuffer,
    vertexCount: u32,
    instanceCount: u32,
    firstVertex: u32,
    firstInstance: u32
)

pub unsafe fn vkCmdDrawIndexed(
    &self,
    commandBuffer: VkCommandBuffer,
    indexCount: u32,
    instanceCount: u32,
    firstIndex: u32,
    vertexOffset: i32,
    firstInstance: u32
)

pub unsafe fn vkCmdDrawIndirect(
    &self,
    commandBuffer: VkCommandBuffer,
    buffer: VkBuffer,
    offset: VkDeviceSize,
    drawCount: u32,
    stride: u32
)

pub unsafe fn vkCmdDrawIndexedIndirect(
    &self,
    commandBuffer: VkCommandBuffer,
    buffer: VkBuffer,
    offset: VkDeviceSize,
    drawCount: u32,
    stride: u32
)

pub unsafe fn vkCmdDispatch(
    &self,
    commandBuffer: VkCommandBuffer,
    groupCountX: u32,
    groupCountY: u32,
    groupCountZ: u32
)

pub unsafe fn vkCmdDispatchIndirect(
    &self,
    commandBuffer: VkCommandBuffer,
    buffer: VkBuffer,
    offset: VkDeviceSize
)

pub unsafe fn vkCmdCopyBuffer(
    &self,
    commandBuffer: VkCommandBuffer,
    srcBuffer: VkBuffer,
    dstBuffer: VkBuffer,
    regionCount: u32,
    pRegions: *const VkBufferCopy
)

pub unsafe fn vkCmdCopyImage(
    &self,
    commandBuffer: VkCommandBuffer,
    srcImage: VkImage,
    srcImageLayout: VkImageLayout,
    dstImage: VkImage,
    dstImageLayout: VkImageLayout,
    regionCount: u32,
    pRegions: *const VkImageCopy
)

pub unsafe fn vkCmdBlitImage(
    &self,
    commandBuffer: VkCommandBuffer,
    srcImage: VkImage,
    srcImageLayout: VkImageLayout,
    dstImage: VkImage,
    dstImageLayout: VkImageLayout,
    regionCount: u32,
    pRegions: *const VkImageBlit,
    filter: VkFilter
)

pub unsafe fn vkCmdCopyBufferToImage(
    &self,
    commandBuffer: VkCommandBuffer,
    srcBuffer: VkBuffer,
    dstImage: VkImage,
    dstImageLayout: VkImageLayout,
    regionCount: u32,
    pRegions: *const VkBufferImageCopy
)

pub unsafe fn vkCmdCopyImageToBuffer(
    &self,
    commandBuffer: VkCommandBuffer,
    srcImage: VkImage,
    srcImageLayout: VkImageLayout,
    dstBuffer: VkBuffer,
    regionCount: u32,
    pRegions: *const VkBufferImageCopy
)

pub unsafe fn vkCmdUpdateBuffer(
    &self,
    commandBuffer: VkCommandBuffer,
    dstBuffer: VkBuffer,
    dstOffset: VkDeviceSize,
    dataSize: VkDeviceSize,
    pData: *const c_void
)

pub unsafe fn vkCmdFillBuffer(
    &self,
    commandBuffer: VkCommandBuffer,
    dstBuffer: VkBuffer,
    dstOffset: VkDeviceSize,
    size: VkDeviceSize,
    data: u32
)

pub unsafe fn vkCmdClearColorImage(
    &self,
    commandBuffer: VkCommandBuffer,
    image: VkImage,
    imageLayout: VkImageLayout,
    pColor: *const VkClearColorValue,
    rangeCount: u32,
    pRanges: *const VkImageSubresourceRange
)

pub unsafe fn vkCmdClearDepthStencilImage(
    &self,
    commandBuffer: VkCommandBuffer,
    image: VkImage,
    imageLayout: VkImageLayout,
    pDepthStencil: *const VkClearDepthStencilValue,
    rangeCount: u32,
    pRanges: *const VkImageSubresourceRange
)

pub unsafe fn vkCmdClearAttachments(
    &self,
    commandBuffer: VkCommandBuffer,
    attachmentCount: u32,
    pAttachments: *const VkClearAttachment,
    rectCount: u32,
    pRects: *const VkClearRect
)

pub unsafe fn vkCmdResolveImage(
    &self,
    commandBuffer: VkCommandBuffer,
    srcImage: VkImage,
    srcImageLayout: VkImageLayout,
    dstImage: VkImage,
    dstImageLayout: VkImageLayout,
    regionCount: u32,
    pRegions: *const VkImageResolve
)

pub unsafe fn vkCmdSetEvent(
    &self,
    commandBuffer: VkCommandBuffer,
    event: VkEvent,
    stageMask: VkPipelineStageFlags
)

pub unsafe fn vkCmdResetEvent(
    &self,
    commandBuffer: VkCommandBuffer,
    event: VkEvent,
    stageMask: VkPipelineStageFlags
)

pub unsafe fn vkCmdWaitEvents(
    &self,
    commandBuffer: VkCommandBuffer,
    eventCount: u32,
    pEvents: *const VkEvent,
    srcStageMask: VkPipelineStageFlags,
    dstStageMask: VkPipelineStageFlags,
    memoryBarrierCount: u32,
    pMemoryBarriers: *const VkMemoryBarrier,
    bufferMemoryBarrierCount: u32,
    pBufferMemoryBarriers: *const VkBufferMemoryBarrier,
    imageMemoryBarrierCount: u32,
    pImageMemoryBarriers: *const VkImageMemoryBarrier
)

pub unsafe fn vkCmdPipelineBarrier(
    &self,
    commandBuffer: VkCommandBuffer,
    srcStageMask: VkPipelineStageFlags,
    dstStageMask: VkPipelineStageFlags,
    dependencyFlags: VkDependencyFlags,
    memoryBarrierCount: u32,
    pMemoryBarriers: *const VkMemoryBarrier,
    bufferMemoryBarrierCount: u32,
    pBufferMemoryBarriers: *const VkBufferMemoryBarrier,
    imageMemoryBarrierCount: u32,
    pImageMemoryBarriers: *const VkImageMemoryBarrier
)

pub unsafe fn vkCmdBeginQuery(
    &self,
    commandBuffer: VkCommandBuffer,
    queryPool: VkQueryPool,
    query: u32,
    flags: VkQueryControlFlags
)

pub unsafe fn vkCmdEndQuery(
    &self,
    commandBuffer: VkCommandBuffer,
    queryPool: VkQueryPool,
    query: u32
)

pub unsafe fn vkCmdResetQueryPool(
    &self,
    commandBuffer: VkCommandBuffer,
    queryPool: VkQueryPool,
    firstQuery: u32,
    queryCount: u32
)

pub unsafe fn vkCmdWriteTimestamp(
    &self,
    commandBuffer: VkCommandBuffer,
    pipelineStage: VkPipelineStageFlagBits,
    queryPool: VkQueryPool,
    query: u32
)

pub unsafe fn vkCmdCopyQueryPoolResults(
    &self,
    commandBuffer: VkCommandBuffer,
    queryPool: VkQueryPool,
    firstQuery: u32,
    queryCount: u32,
    dstBuffer: VkBuffer,
    dstOffset: VkDeviceSize,
    stride: VkDeviceSize,
    flags: VkQueryResultFlags
)

pub unsafe fn vkCmdPushConstants(
    &self,
    commandBuffer: VkCommandBuffer,
    layout: VkPipelineLayout,
    stageFlags: VkShaderStageFlags,
    offset: u32,
    size: u32,
    pValues: *const c_void
)

pub unsafe fn vkCmdBeginRenderPass(
    &self,
    commandBuffer: VkCommandBuffer,
    pRenderPassBegin: *const VkRenderPassBeginInfo,
    contents: VkSubpassContents
)

pub unsafe fn vkCmdNextSubpass(
    &self,
    commandBuffer: VkCommandBuffer,
    contents: VkSubpassContents
)

pub unsafe fn vkCmdEndRenderPass(&self, commandBuffer: VkCommandBuffer)

pub unsafe fn vkCmdExecuteCommands(
    &self,
    commandBuffer: VkCommandBuffer,
    commandBufferCount: u32,
    pCommandBuffers: *const VkCommandBuffer
)

pub unsafe fn vkBindBufferMemory2(
    &self,
    device: VkDevice,
    bindInfoCount: u32,
    pBindInfos: *const VkBindBufferMemoryInfo
) -> VkResult

pub unsafe fn vkBindImageMemory2(
    &self,
    device: VkDevice,
    bindInfoCount: u32,
    pBindInfos: *const VkBindImageMemoryInfo
) -> VkResult

pub unsafe fn vkCmdDispatchBase(
    &self,
    commandBuffer: VkCommandBuffer,
    baseGroupX: u32,
    baseGroupY: u32,
    baseGroupZ: u32,
    groupCountX: u32,
    groupCountY: u32,
    groupCountZ: u32
)

pub unsafe fn vkCmdSetDeviceMask(
    &self,
    commandBuffer: VkCommandBuffer,
    deviceMask: u32
)

pub unsafe fn vkCreateDescriptorUpdateTemplate(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate
) -> VkResult

pub unsafe fn vkCreateSamplerYcbcrConversion(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo,
    pAllocator: *const VkAllocationCallbacks,
    pYcbcrConversion: *mut VkSamplerYcbcrConversion
) -> VkResult

pub unsafe fn vkDestroyDescriptorUpdateTemplate(
    &self,
    device: VkDevice,
    descriptorUpdateTemplate: VkDescriptorUpdateTemplate,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkDestroySamplerYcbcrConversion(
    &self,
    device: VkDevice,
    ycbcrConversion: VkSamplerYcbcrConversion,
    pAllocator: *const VkAllocationCallbacks
)

pub unsafe fn vkEnumeratePhysicalDeviceGroups(
    &self,
    instance: VkInstance,
    pPhysicalDeviceGroupCount: *mut u32,
    pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties
) -> VkResult

pub unsafe fn vkGetBufferMemoryRequirements2(
    &self,
    device: VkDevice,
    pInfo: *const VkBufferMemoryRequirementsInfo2,
    pMemoryRequirements: *mut VkMemoryRequirements2
)

pub unsafe fn vkGetDescriptorSetLayoutSupport(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkDescriptorSetLayoutCreateInfo,
    pSupport: *mut VkDescriptorSetLayoutSupport
)

pub unsafe fn vkGetDeviceGroupPeerMemoryFeatures(
    &self,
    device: VkDevice,
    heapIndex: u32,
    localDeviceIndex: u32,
    remoteDeviceIndex: u32,
    pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags
)

pub unsafe fn vkGetDeviceQueue2(
    &self,
    device: VkDevice,
    pQueueInfo: *const VkDeviceQueueInfo2,
    pQueue: *mut VkQueue
)

pub unsafe fn vkGetImageMemoryRequirements2(
    &self,
    device: VkDevice,
    pInfo: *const VkImageMemoryRequirementsInfo2,
    pMemoryRequirements: *mut VkMemoryRequirements2
)

pub unsafe fn vkGetImageSparseMemoryRequirements2(
    &self,
    device: VkDevice,
    pInfo: *const VkImageSparseMemoryRequirementsInfo2,
    pSparseMemoryRequirementCount: *mut u32,
    pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2
)

pub unsafe fn vkGetPhysicalDeviceExternalBufferProperties(
    &self,
    physicalDevice: VkPhysicalDevice,
    pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo,
    pExternalBufferProperties: *mut VkExternalBufferProperties
)

pub unsafe fn vkGetPhysicalDeviceExternalFenceProperties(
    &self,
    physicalDevice: VkPhysicalDevice,
    pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo,
    pExternalFenceProperties: *mut VkExternalFenceProperties
)

pub unsafe fn vkGetPhysicalDeviceExternalSemaphoreProperties(
    &self,
    physicalDevice: VkPhysicalDevice,
    pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo,
    pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties
)

pub unsafe fn vkGetPhysicalDeviceFeatures2(
    &self,
    physicalDevice: VkPhysicalDevice,
    pFeatures: *mut VkPhysicalDeviceFeatures2
)

pub unsafe fn vkGetPhysicalDeviceFormatProperties2(
    &self,
    physicalDevice: VkPhysicalDevice,
    format: VkFormat,
    pFormatProperties: *mut VkFormatProperties2
)

pub unsafe fn vkGetPhysicalDeviceImageFormatProperties2(
    &self,
    physicalDevice: VkPhysicalDevice,
    pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2,
    pImageFormatProperties: *mut VkImageFormatProperties2
) -> VkResult

pub unsafe fn vkGetPhysicalDeviceMemoryProperties2(
    &self,
    physicalDevice: VkPhysicalDevice,
    pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2
)

pub unsafe fn vkGetPhysicalDeviceProperties2(
    &self,
    physicalDevice: VkPhysicalDevice,
    pProperties: *mut VkPhysicalDeviceProperties2
)

pub unsafe fn vkGetPhysicalDeviceQueueFamilyProperties2(
    &self,
    physicalDevice: VkPhysicalDevice,
    pQueueFamilyPropertyCount: *mut u32,
    pQueueFamilyProperties: *mut VkQueueFamilyProperties2
)

pub unsafe fn vkGetPhysicalDeviceSparseImageFormatProperties2(
    &self,
    physicalDevice: VkPhysicalDevice,
    pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2,
    pPropertyCount: *mut u32,
    pProperties: *mut VkSparseImageFormatProperties2
)

pub unsafe fn vkTrimCommandPool(
    &self,
    device: VkDevice,
    commandPool: VkCommandPool,
    flags: VkCommandPoolTrimFlags
)

pub unsafe fn vkUpdateDescriptorSetWithTemplate(
    &self,
    device: VkDevice,
    descriptorSet: VkDescriptorSet,
    descriptorUpdateTemplate: VkDescriptorUpdateTemplate,
    pData: *const c_void
)

pub unsafe fn vkGetBufferDeviceAddress(
    &self,
    device: VkDevice,
    pInfo: *const VkBufferDeviceAddressInfo
) -> VkDeviceAddress

pub unsafe fn vkGetBufferOpaqueCaptureAddress(
    &self,
    device: VkDevice,
    pInfo: *const VkBufferDeviceAddressInfo
) -> u64

pub unsafe fn vkGetDeviceMemoryOpaqueCaptureAddress(
    &self,
    device: VkDevice,
    pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo
) -> u64

pub unsafe fn vkCreateRenderPass2(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkRenderPassCreateInfo2,
    pAllocator: *const VkAllocationCallbacks,
    pRenderPass: *mut VkRenderPass
) -> VkResult

pub unsafe fn vkCmdBeginRenderPass2(
    &self,
    commandBuffer: VkCommandBuffer,
    pRenderPassBegin: *const VkRenderPassBeginInfo,
    pSubpassBeginInfo: *const VkSubpassBeginInfo
)

pub unsafe fn vkCmdNextSubpass2(
    &self,
    commandBuffer: VkCommandBuffer,
    pSubpassBeginInfo: *const VkSubpassBeginInfo,
    pSubpassEndInfo: *const VkSubpassEndInfo
)

pub unsafe fn vkCmdEndRenderPass2(
    &self,
    commandBuffer: VkCommandBuffer,
    pSubpassEndInfo: *const VkSubpassEndInfo
)

pub unsafe fn vkCmdDrawIndirectCount(
    &self,
    commandBuffer: VkCommandBuffer,
    buffer: VkBuffer,
    offset: VkDeviceSize,
    countBuffer: VkBuffer,
    countBufferOffset: VkDeviceSize,
    maxDrawCount: u32,
    stride: u32
)

pub unsafe fn vkCmdDrawIndexedIndirectCount(
    &self,
    commandBuffer: VkCommandBuffer,
    buffer: VkBuffer,
    offset: VkDeviceSize,
    countBuffer: VkBuffer,
    countBufferOffset: VkDeviceSize,
    maxDrawCount: u32,
    stride: u32
)

pub unsafe fn vkGetSemaphoreCounterValue(
    &self,
    device: VkDevice,
    semaphore: VkSemaphore,
    pValue: *mut u64
) -> VkResult

pub unsafe fn vkWaitSemaphores(
    &self,
    device: VkDevice,
    pWaitInfo: *const VkSemaphoreWaitInfo,
    timeout: u64
) -> VkResult

pub unsafe fn vkSignalSemaphore(
    &self,
    device: VkDevice,
    pSignalInfo: *const VkSemaphoreSignalInfo
) -> VkResult

pub unsafe fn vkResetQueryPool(
    &self,
    device: VkDevice,
    queryPool: VkQueryPool,
    firstQuery: u32,
    queryCount: u32
)