Struct bedrock::Resolver

pub struct Resolver();

Methods

impl Resolver

pub fn get<'a>() -> &'a Self

Trait Implementations

impl ResolverInterface for Resolver

unsafe fn create_instance(
    &self,
    create_info: *const VkInstanceCreateInfo,
    alloator: *const VkAllocationCallbacks,
    instance: *mut VkInstance
) -> VkResult

unsafe fn destroy_instance(
    &self,
    instance: VkInstance,
    allocator: *const VkAllocationCallbacks
)

unsafe fn enumerate_physical_devices(
    &self,
    instance: VkInstance,
    phyical_device_count: *mut u32,
    physical_devices: *mut VkPhysicalDevice
) -> VkResult

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

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

unsafe fn get_physical_device_image_format_properties(
    &self,
    physicalDevice: VkPhysicalDevice,
    format: VkFormat,
    itype: VkImageType,
    tiling: VkImageTiling,
    usage: VkImageUsageFlags,
    flags: VkImageCreateFlags,
    pImageFormatProperties: *mut VkImageFormatProperties
) -> VkResult

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

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

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

unsafe fn get_instance_proc_addr(
    &self,
    instance: VkInstance,
    pName: *const c_char
) -> Option<PFN_vkVoidFunction>

unsafe fn get_device_proc_addr(
    &self,
    device: VkDevice,
    pName: *const c_char
) -> Option<PFN_vkVoidFunction>

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

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

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

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

unsafe fn enumerate_instance_layer_properties(
    &self,
    pPropertyCount: *mut u32,
    pProperties: *mut VkLayerProperties
) -> VkResult

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unsafe fn get_buffer_memory_requirements(
    &self,
    device: VkDevice,
    buffer: VkBuffer,
    pMemoryRequirements: *mut VkMemoryRequirements
)

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

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

unsafe fn get_physical_device_sparse_image_format_properties(
    &self,
    physicalDevice: VkPhysicalDevice,
    format: VkFormat,
    _type: VkImageType,
    samples: VkSampleCountFlags,
    usage: VkImageUsageFlags,
    tiling: VkImageTiling,
    pPropertyCount: *mut u32,
    pProperties: *mut VkSparseImageFormatProperties
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unsafe fn cmd_set_line_width(
    &self,
    commandBuffer: VkCommandBuffer,
    lineWidth: c_float
)

unsafe fn cmd_set_depth_bias(
    &self,
    commandBuffer: VkCommandBuffer,
    depthBiasConstantFactor: c_float,
    depthBiasClamp: c_float,
    depthBiasSlopeFactor: c_float
)

unsafe fn cmd_set_blend_constants(
    &self,
    commandBuffer: VkCommandBuffer,
    blendConstants: [c_float; 4]
)

unsafe fn cmd_set_depth_bounds(
    &self,
    commandBuffer: VkCommandBuffer,
    minDepthBounds: c_float,
    maxDepthBounds: c_float
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unsafe fn cmd_write_timestamp(
    &self,
    commandBuffer: VkCommandBuffer,
    pipelineStage: VkPipelineStageFlags,
    queryPool: VkQueryPool,
    query: u32
)

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

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

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

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

unsafe fn cmd_end_render_pass(&self, commandBuffer: VkCommandBuffer)

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

unsafe fn enumerate_instance_version(&self, pApiVersion: *mut u32) -> VkResult

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unsafe fn destroy_surface_khr(
    &self,
    instance: VkInstance,
    surface: VkSurfaceKHR,
    pAllocator: *const VkAllocationCallbacks
)

unsafe fn get_physical_device_surface_support_khr(
    &self,
    physicalDevice: VkPhysicalDevice,
    queueFamilyIndex: u32,
    surface: VkSurfaceKHR,
    pSupported: *mut VkBool32
) -> VkResult

unsafe fn get_physical_device_surface_capabilities_khr(
    &self,
    physicalDevice: VkPhysicalDevice,
    surface: VkSurfaceKHR,
    pSurfaceCapabilities: *mut VkSurfaceCapabilitiesKHR
) -> VkResult

unsafe fn get_physical_device_surface_formats_khr(
    &self,
    physicalDevice: VkPhysicalDevice,
    surface: VkSurfaceKHR,
    pSurfaceFormatCount: *mut u32,
    pSurfaceFormats: *mut VkSurfaceFormatKHR
) -> VkResult

unsafe fn get_physical_device_surface_present_modes_khr(
    &self,
    physicalDevice: VkPhysicalDevice,
    surface: VkSurfaceKHR,
    pPresentModeCount: *mut u32,
    pPresentModes: *mut VkPresentModeKHR
) -> VkResult

unsafe fn create_swapchain_khr(
    &self,
    device: VkDevice,
    pCreateInfo: *const VkSwapchainCreateInfoKHR,
    pAllocator: *const VkAllocationCallbacks,
    pSwapchain: *mut VkSwapchainKHR
) -> VkResult

unsafe fn destroy_swapchain_khr(
    &self,
    device: VkDevice,
    swapchain: VkSwapchainKHR,
    pAllocator: *const VkAllocationCallbacks
)

unsafe fn get_swapchain_images_khr(
    &self,
    device: VkDevice,
    swapchain: VkSwapchainKHR,
    pSwapchainImageCount: *mut u32,
    pSwapchainImages: *mut VkImage
) -> VkResult

unsafe fn acquire_next_image_khr(
    &self,
    device: VkDevice,
    swapchain: VkSwapchainKHR,
    timeout: u64,
    semaphore: VkSemaphore,
    fence: VkFence,
    pImageIndex: *mut u32
) -> VkResult

unsafe fn queue_present_khr(
    &self,
    queue: VkQueue,
    pPresentInfo: *const VkPresentInfoKHR
) -> VkResult

unsafe fn get_physical_device_display_properties_khr(
    &self,
    physicalDevice: VkPhysicalDevice,
    pPropertyCount: *mut u32,
    pProperties: *mut VkDisplayPropertiesKHR
) -> VkResult

unsafe fn get_physical_device_display_plane_properties_khr(
    &self,
    physicalDevice: VkPhysicalDevice,
    pPropertyCount: *mut u32,
    pProperties: *mut VkDisplayPlanePropertiesKHR
) -> VkResult

unsafe fn get_display_plane_supported_displays_khr(
    &self,
    physicalDevice: VkPhysicalDevice,
    planeIndex: u32,
    pDisplayCount: *mut u32,
    pDisplays: *mut VkDisplayKHR
) -> VkResult

unsafe fn get_display_mode_properties_khr(
    &self,
    physicalDevice: VkPhysicalDevice,
    display: VkDisplayKHR,
    pPropertyCount: *mut u32,
    pProperties: *mut VkDisplayModePropertiesKHR
) -> VkResult

unsafe fn create_display_mode_khr(
    &self,
    physicalDevice: VkPhysicalDevice,
    display: VkDisplayKHR,
    pCreateInfo: *const VkDisplayModeCreateInfoKHR,
    pAllocator: *const VkAllocationCallbacks,
    pMode: *mut VkDisplayModeKHR
) -> VkResult

unsafe fn get_display_plane_capabilities_khr(
    &self,
    physicalDevice: VkPhysicalDevice,
    mode: VkDisplayModeKHR,
    planeIndex: u32,
    pCapabilities: *mut VkDisplayPlaneCapabilitiesKHR
) -> VkResult

unsafe fn create_display_plane_surface_khr(
    &self,
    instance: VkInstance,
    pCreateInfo: *const VkDisplaySurfaceCreateInfoKHR,
    pAllocator: *const VkAllocationCallbacks,
    pSurface: *mut VkSurfaceKHR
) -> VkResult