[−][src]Trait bedrock::ResolverInterface

pub trait ResolverInterface {
    unsafe fn create_instance(
        &self, 
        create_info: *const VkInstanceCreateInfo, 
        allocator: *const VkAllocationCallbacks, 
        instance: *mut VkInstance
    ) -> VkResult;

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

    unsafe fn enumerate_physical_devices(
        &self, 
        instance: VkInstance, 
        physical_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, 
        ommandBuffer: 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;
}

Required methods

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

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

unsafe fn enumerate_physical_devices(
    &self,
    instance: VkInstance,
    physical_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,
    ommandBuffer: 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

Loading content...

Implementors

impl ResolverInterface for Resolver[src]

Loading content...