dymokomi/luce-gpu
Source of release 0.5.6
0.5.6 / src / gpu / vulkan / entry.lucb
#==============================================================================================
#
# entry - Vulkan's entry points, found at run time
#
# DESCRIPTION:
# The system's Vulkan loader (libvulkan.so.1 on Linux, vulkan-1.dll on Windows) is
# opened when the first device is, and every function below calls through the table it
# fills. Nothing links against Vulkan, so building needs no Vulkan SDK or development
# package, and a machine without Vulkan gets an error instead of a missing library.
# Each function keeps the name and signature of the C one it stands for.
#
#==============================================================================================
extern func dlopen(file: c.str, mode: i32) -> void*?
extern func dlsym(handle: void*, name: c.str) -> void*?
extern func LoadLibraryW(name: u16*) -> void*?
extern func GetProcAddress(module: void*, name: c.str) -> void*?
struct VulkanFunctions:
var vkGetPhysicalDeviceProperties: (func(u64, void*) -> unit)?
var vkCreateInstance: (func(VkInstanceCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyInstance: (func(u64, void*?) -> unit)?
var vkEnumeratePhysicalDevices: (func(u64, u32*?, u64*?) -> i32)?
var vkGetPhysicalDeviceQueueFamilyProperties: (func(u64, u32*?, VkQueueFamilyProperties*?) -> unit)?
var vkGetPhysicalDeviceMemoryProperties: (func(u64, VkPhysicalDeviceMemoryProperties*?) -> unit)?
var vkGetPhysicalDeviceFormatProperties: (func(u64, u32, VkFormatProperties*?) -> unit)?
var vkCreateDevice: (func(u64, VkDeviceCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyDevice: (func(u64, void*?) -> unit)?
var vkGetDeviceQueue: (func(u64, u32, u32, u64*?) -> unit)?
var vkCreateWin32SurfaceKHR: (func(u64, VkWin32SurfaceCreateInfoKHR*?, void*?, u64*?) -> i32)?
var vkGetPhysicalDeviceWin32PresentationSupportKHR: (func(u64, u32) -> u32)?
var vkDestroySurfaceKHR: (func(u64, u64, void*?) -> unit)?
var vkGetPhysicalDeviceSurfaceSupportKHR: (func(u64, u32, u64, u32*?) -> i32)?
var vkGetPhysicalDeviceSurfaceCapabilitiesKHR: (func(u64, u64, VkSurfaceCapabilitiesKHR*?) -> i32)?
var vkGetPhysicalDeviceSurfaceFormatsKHR: (func(u64, u64, u32*?, VkSurfaceFormatKHR*?) -> i32)?
var vkCreateSwapchainKHR: (func(u64, VkSwapchainCreateInfoKHR*?, void*?, u64*?) -> i32)?
var vkDestroySwapchainKHR: (func(u64, u64, void*?) -> unit)?
var vkGetSwapchainImagesKHR: (func(u64, u64, u32*?, u64*?) -> i32)?
var vkAcquireNextImageKHR: (func(u64, u64, u64, u64, u64, u32*?) -> i32)?
var vkQueuePresentKHR: (func(u64, VkPresentInfoKHR*?) -> i32)?
var vkQueueSubmit: (func(u64, u32, VkSubmitInfo*?, u64) -> i32)?
var vkQueueWaitIdle: (func(u64) -> i32)?
var vkDeviceWaitIdle: (func(u64) -> i32)?
var vkCreateImageView: (func(u64, VkImageViewCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyImageView: (func(u64, u64, void*?) -> unit)?
var vkCreateImage: (func(u64, VkImageCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyImage: (func(u64, u64, void*?) -> unit)?
var vkGetImageMemoryRequirements: (func(u64, u64, VkMemoryRequirements*?) -> unit)?
var vkAllocateMemory: (func(u64, VkMemoryAllocateInfo*?, void*?, u64*?) -> i32)?
var vkFreeMemory: (func(u64, u64, void*?) -> unit)?
var vkBindImageMemory: (func(u64, u64, u64, u64) -> i32)?
var vkCreateBuffer: (func(u64, VkBufferCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyBuffer: (func(u64, u64, void*?) -> unit)?
var vkGetBufferMemoryRequirements: (func(u64, u64, VkMemoryRequirements*?) -> unit)?
var vkBindBufferMemory: (func(u64, u64, u64, u64) -> i32)?
var vkMapMemory: (func(u64, u64, u64, u64, u32, void*?*?) -> i32)?
var vkUnmapMemory: (func(u64, u64) -> unit)?
var vkCreateRenderPass: (func(u64, VkRenderPassCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyRenderPass: (func(u64, u64, void*?) -> unit)?
var vkCreateFramebuffer: (func(u64, VkFramebufferCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyFramebuffer: (func(u64, u64, void*?) -> unit)?
var vkCreateShaderModule: (func(u64, VkShaderModuleCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyShaderModule: (func(u64, u64, void*?) -> unit)?
var vkCreatePipelineLayout: (func(u64, VkPipelineLayoutCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyPipelineLayout: (func(u64, u64, void*?) -> unit)?
var vkCreateGraphicsPipelines: (func(u64, u64, u32, VkGraphicsPipelineCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyPipeline: (func(u64, u64, void*?) -> unit)?
var vkCreateCommandPool: (func(u64, VkCommandPoolCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyCommandPool: (func(u64, u64, void*?) -> unit)?
var vkAllocateCommandBuffers: (func(u64, VkCommandBufferAllocateInfo*?, u64*?) -> i32)?
var vkResetCommandPool: (func(u64, u64, u32) -> i32)?
var vkBeginCommandBuffer: (func(u64, VkCommandBufferBeginInfo*?) -> i32)?
var vkEndCommandBuffer: (func(u64) -> i32)?
var vkCmdBeginRenderPass: (func(u64, VkRenderPassBeginInfo*?, u32) -> unit)?
var vkCmdEndRenderPass: (func(u64) -> unit)?
var vkCmdBindPipeline: (func(u64, u32, u64) -> unit)?
var vkCmdSetViewport: (func(u64, u32, u32, VkViewport*?) -> unit)?
var vkCmdSetDepthBias: (func(u64, f32, f32, f32) -> unit)?
var vkCmdSetScissor: (func(u64, u32, u32, VkRect2D*?) -> unit)?
var vkCmdBindVertexBuffers: (func(u64, u32, u32, u64*?, u64*?) -> unit)?
var vkCmdDraw: (func(u64, u32, u32, u32, u32) -> unit)?
var vkCmdDrawIndirect: (func(u64, u64, u64, u32, u32) -> unit)?
var vkCreateSemaphore: (func(u64, VkSemaphoreCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroySemaphore: (func(u64, u64, void*?) -> unit)?
var vkCreateFence: (func(u64, VkFenceCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyFence: (func(u64, u64, void*?) -> unit)?
var vkWaitForFences: (func(u64, u32, u64*?, u32, u64) -> i32)?
var vkResetFences: (func(u64, u32, u64*?) -> i32)?
var vkCreateDescriptorSetLayout: (func(u64, VkDescriptorSetLayoutCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyDescriptorSetLayout: (func(u64, u64, void*?) -> unit)?
var vkCreateDescriptorPool: (func(u64, VkDescriptorPoolCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyDescriptorPool: (func(u64, u64, void*?) -> unit)?
var vkAllocateDescriptorSets: (func(u64, VkDescriptorSetAllocateInfo*?, u64*?) -> i32)?
var vkUpdateDescriptorSets: (func(u64, u32, VkWriteDescriptorSet*?, u32, VkCopyDescriptorSet*?) -> unit)?
var vkCmdBindDescriptorSets: (func(u64, u32, u64, u32, u32, u64*?, u32, u32*?) -> unit)?
var vkCmdPushConstants: (func(u64, u64, u32, u32, u32, void*?) -> unit)?
var vkCreateSampler: (func(u64, VkSamplerCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroySampler: (func(u64, u64, void*?) -> unit)?
var vkCmdPipelineBarrier: (func(u64, u32, u32, u32, u32, void*?, u32, void*?, u32, VkImageMemoryBarrier*?) -> unit)?
var vkCmdCopyBufferToImage: (func(u64, u64, u64, u32, u32, VkBufferImageCopy*?) -> unit)?
var vkCmdCopyImageToBuffer: (func(u64, u64, u32, u64, u32, VkBufferImageCopy*?) -> unit)?
var vkCmdCopyImage: (func(u64, u64, u32, u64, u32, u32, VkImageCopy*?) -> unit)?
var vkCmdBlitImage: (func(u64, u64, u32, u64, u32, u32, VkImageBlit*?, u32) -> unit)?
var vkCmdCopyBuffer: (func(u64, u64, u64, u32, VkBufferCopy*?) -> unit)?
var vkCreateXlibSurfaceKHR: (func(u64, VkXlibSurfaceCreateInfoKHR*?, void*?, u64*?) -> i32)?
var vkEnumerateInstanceVersion: (func(u32*?) -> i32)?
var vkGetPhysicalDeviceProperties2: (func(u64, VkPhysicalDeviceProperties2*?) -> unit)?
var vkGetPhysicalDeviceFeatures2: (func(u64, VkPhysicalDeviceFeatures2*?) -> unit)?
var vkEnumerateDeviceExtensionProperties: (func(u64, void*?, u32*?, VkExtensionProperties*?) -> i32)?
var vkCreateComputePipelines: (func(u64, u64, u32, VkComputePipelineCreateInfo*?, void*?, u64*?) -> i32)?
var vkCmdDispatch: (func(u64, u32, u32, u32) -> unit)?
var vkCmdDispatchIndirect: (func(u64, u64, u64) -> unit)?
var vkCmdFillBuffer: (func(u64, u64, u64, u64, u32) -> unit)?
var vkCreateQueryPool: (func(u64, VkQueryPoolCreateInfo*?, void*?, u64*?) -> i32)?
var vkDestroyQueryPool: (func(u64, u64, void*?) -> unit)?
var vkCmdResetQueryPool: (func(u64, u64, u32, u32) -> unit)?
var vkCmdWriteTimestamp: (func(u64, u32, u64, u32) -> unit)?
var vkGetQueryPoolResults: (func(u64, u64, u32, u32, usize, void*?, u64, u32) -> i32)?
var vkGetBufferDeviceAddress: (func(u64, VkBufferDeviceAddressInfo*?) -> u64)?
var vkGetDeviceProcAddr: (func(u64, c.str) -> void*?)?
var vulkan_functions: VulkanFunctions*? = none
## Open the system's Vulkan loader and find its functions, once. A function a
## platform's loader lacks (another platform's surface) stays unset and traps
## only if called.
func vulkan_load() -> !:
if vulkan_functions != none:
return
let library = try vulkan_library()
let table = try new VulkanFunctions() in memory.heap
if let found = vulkan_symbol(library, "vkCreateInstance"):
table.vkCreateInstance = (func(VkInstanceCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyInstance"):
table.vkDestroyInstance = (func(u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkEnumeratePhysicalDevices"):
table.vkEnumeratePhysicalDevices = (func(u64, u32*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkGetPhysicalDeviceQueueFamilyProperties"):
table.vkGetPhysicalDeviceQueueFamilyProperties = (func(u64, u32*?, VkQueueFamilyProperties*?) -> unit)found
if let found = vulkan_symbol(library, "vkGetPhysicalDeviceMemoryProperties"):
table.vkGetPhysicalDeviceMemoryProperties = (func(u64, VkPhysicalDeviceMemoryProperties*?) -> unit)found
if let found = vulkan_symbol(library, "vkGetPhysicalDeviceFormatProperties"):
table.vkGetPhysicalDeviceFormatProperties = (func(u64, u32, VkFormatProperties*?) -> unit)found
if let found = vulkan_symbol(library, "vkCreateDevice"):
table.vkCreateDevice = (func(u64, VkDeviceCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyDevice"):
table.vkDestroyDevice = (func(u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkGetDeviceQueue"):
table.vkGetDeviceQueue = (func(u64, u32, u32, u64*?) -> unit)found
if let found = vulkan_symbol(library, "vkCreateWin32SurfaceKHR"):
table.vkCreateWin32SurfaceKHR = (func(u64, VkWin32SurfaceCreateInfoKHR*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkGetPhysicalDeviceWin32PresentationSupportKHR"):
table.vkGetPhysicalDeviceWin32PresentationSupportKHR = (func(u64, u32) -> u32)found
if let found = vulkan_symbol(library, "vkDestroySurfaceKHR"):
table.vkDestroySurfaceKHR = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkGetPhysicalDeviceSurfaceSupportKHR"):
table.vkGetPhysicalDeviceSurfaceSupportKHR = (func(u64, u32, u64, u32*?) -> i32)found
if let found = vulkan_symbol(library, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"):
table.vkGetPhysicalDeviceSurfaceCapabilitiesKHR = (func(u64, u64, VkSurfaceCapabilitiesKHR*?) -> i32)found
if let found = vulkan_symbol(library, "vkGetPhysicalDeviceSurfaceFormatsKHR"):
table.vkGetPhysicalDeviceSurfaceFormatsKHR = (func(u64, u64, u32*?, VkSurfaceFormatKHR*?) -> i32)found
if let found = vulkan_symbol(library, "vkCreateSwapchainKHR"):
table.vkCreateSwapchainKHR = (func(u64, VkSwapchainCreateInfoKHR*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroySwapchainKHR"):
table.vkDestroySwapchainKHR = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkGetSwapchainImagesKHR"):
table.vkGetSwapchainImagesKHR = (func(u64, u64, u32*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkAcquireNextImageKHR"):
table.vkAcquireNextImageKHR = (func(u64, u64, u64, u64, u64, u32*?) -> i32)found
if let found = vulkan_symbol(library, "vkQueuePresentKHR"):
table.vkQueuePresentKHR = (func(u64, VkPresentInfoKHR*?) -> i32)found
if let found = vulkan_symbol(library, "vkQueueSubmit"):
table.vkQueueSubmit = (func(u64, u32, VkSubmitInfo*?, u64) -> i32)found
if let found = vulkan_symbol(library, "vkQueueWaitIdle"):
table.vkQueueWaitIdle = (func(u64) -> i32)found
if let found = vulkan_symbol(library, "vkDeviceWaitIdle"):
table.vkDeviceWaitIdle = (func(u64) -> i32)found
if let found = vulkan_symbol(library, "vkCreateImageView"):
table.vkCreateImageView = (func(u64, VkImageViewCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyImageView"):
table.vkDestroyImageView = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkCreateImage"):
table.vkCreateImage = (func(u64, VkImageCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyImage"):
table.vkDestroyImage = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkGetImageMemoryRequirements"):
table.vkGetImageMemoryRequirements = (func(u64, u64, VkMemoryRequirements*?) -> unit)found
if let found = vulkan_symbol(library, "vkAllocateMemory"):
table.vkAllocateMemory = (func(u64, VkMemoryAllocateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkFreeMemory"):
table.vkFreeMemory = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkBindImageMemory"):
table.vkBindImageMemory = (func(u64, u64, u64, u64) -> i32)found
if let found = vulkan_symbol(library, "vkCreateBuffer"):
table.vkCreateBuffer = (func(u64, VkBufferCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyBuffer"):
table.vkDestroyBuffer = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkGetBufferMemoryRequirements"):
table.vkGetBufferMemoryRequirements = (func(u64, u64, VkMemoryRequirements*?) -> unit)found
if let found = vulkan_symbol(library, "vkBindBufferMemory"):
table.vkBindBufferMemory = (func(u64, u64, u64, u64) -> i32)found
if let found = vulkan_symbol(library, "vkMapMemory"):
table.vkMapMemory = (func(u64, u64, u64, u64, u32, void*?*?) -> i32)found
if let found = vulkan_symbol(library, "vkUnmapMemory"):
table.vkUnmapMemory = (func(u64, u64) -> unit)found
if let found = vulkan_symbol(library, "vkCreateRenderPass"):
table.vkCreateRenderPass = (func(u64, VkRenderPassCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyRenderPass"):
table.vkDestroyRenderPass = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkCreateFramebuffer"):
table.vkCreateFramebuffer = (func(u64, VkFramebufferCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyFramebuffer"):
table.vkDestroyFramebuffer = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkCreateShaderModule"):
table.vkCreateShaderModule = (func(u64, VkShaderModuleCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyShaderModule"):
table.vkDestroyShaderModule = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkCreatePipelineLayout"):
table.vkCreatePipelineLayout = (func(u64, VkPipelineLayoutCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyPipelineLayout"):
table.vkDestroyPipelineLayout = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkCreateGraphicsPipelines"):
table.vkCreateGraphicsPipelines = (func(u64, u64, u32, VkGraphicsPipelineCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyPipeline"):
table.vkDestroyPipeline = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkCreateCommandPool"):
table.vkCreateCommandPool = (func(u64, VkCommandPoolCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyCommandPool"):
table.vkDestroyCommandPool = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkAllocateCommandBuffers"):
table.vkAllocateCommandBuffers = (func(u64, VkCommandBufferAllocateInfo*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkResetCommandPool"):
table.vkResetCommandPool = (func(u64, u64, u32) -> i32)found
if let found = vulkan_symbol(library, "vkBeginCommandBuffer"):
table.vkBeginCommandBuffer = (func(u64, VkCommandBufferBeginInfo*?) -> i32)found
if let found = vulkan_symbol(library, "vkEndCommandBuffer"):
table.vkEndCommandBuffer = (func(u64) -> i32)found
if let found = vulkan_symbol(library, "vkCmdBeginRenderPass"):
table.vkCmdBeginRenderPass = (func(u64, VkRenderPassBeginInfo*?, u32) -> unit)found
if let found = vulkan_symbol(library, "vkCmdEndRenderPass"):
table.vkCmdEndRenderPass = (func(u64) -> unit)found
if let found = vulkan_symbol(library, "vkCmdBindPipeline"):
table.vkCmdBindPipeline = (func(u64, u32, u64) -> unit)found
if let found = vulkan_symbol(library, "vkCmdSetViewport"):
table.vkCmdSetViewport = (func(u64, u32, u32, VkViewport*?) -> unit)found
if let found = vulkan_symbol(library, "vkCmdSetDepthBias"):
table.vkCmdSetDepthBias = (func(u64, f32, f32, f32) -> unit)found
if let found = vulkan_symbol(library, "vkCmdSetScissor"):
table.vkCmdSetScissor = (func(u64, u32, u32, VkRect2D*?) -> unit)found
if let found = vulkan_symbol(library, "vkCmdBindVertexBuffers"):
table.vkCmdBindVertexBuffers = (func(u64, u32, u32, u64*?, u64*?) -> unit)found
if let found = vulkan_symbol(library, "vkCmdDraw"):
table.vkCmdDraw = (func(u64, u32, u32, u32, u32) -> unit)found
if let found = vulkan_symbol(library, "vkCmdDrawIndirect"):
table.vkCmdDrawIndirect = (func(u64, u64, u64, u32, u32) -> unit)found
if let found = vulkan_symbol(library, "vkCreateSemaphore"):
table.vkCreateSemaphore = (func(u64, VkSemaphoreCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroySemaphore"):
table.vkDestroySemaphore = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkCreateFence"):
table.vkCreateFence = (func(u64, VkFenceCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyFence"):
table.vkDestroyFence = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkWaitForFences"):
table.vkWaitForFences = (func(u64, u32, u64*?, u32, u64) -> i32)found
if let found = vulkan_symbol(library, "vkResetFences"):
table.vkResetFences = (func(u64, u32, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkCreateDescriptorSetLayout"):
table.vkCreateDescriptorSetLayout = (func(u64, VkDescriptorSetLayoutCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyDescriptorSetLayout"):
table.vkDestroyDescriptorSetLayout = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkCreateDescriptorPool"):
table.vkCreateDescriptorPool = (func(u64, VkDescriptorPoolCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyDescriptorPool"):
table.vkDestroyDescriptorPool = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkAllocateDescriptorSets"):
table.vkAllocateDescriptorSets = (func(u64, VkDescriptorSetAllocateInfo*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkUpdateDescriptorSets"):
table.vkUpdateDescriptorSets = (func(u64, u32, VkWriteDescriptorSet*?, u32, VkCopyDescriptorSet*?) -> unit)found
if let found = vulkan_symbol(library, "vkCmdBindDescriptorSets"):
table.vkCmdBindDescriptorSets = (func(u64, u32, u64, u32, u32, u64*?, u32, u32*?) -> unit)found
if let found = vulkan_symbol(library, "vkCmdPushConstants"):
table.vkCmdPushConstants = (func(u64, u64, u32, u32, u32, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkCreateSampler"):
table.vkCreateSampler = (func(u64, VkSamplerCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroySampler"):
table.vkDestroySampler = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkCmdPipelineBarrier"):
table.vkCmdPipelineBarrier = (func(u64, u32, u32, u32, u32, void*?, u32, void*?, u32, VkImageMemoryBarrier*?) -> unit)found
if let found = vulkan_symbol(library, "vkCmdCopyBufferToImage"):
table.vkCmdCopyBufferToImage = (func(u64, u64, u64, u32, u32, VkBufferImageCopy*?) -> unit)found
if let found = vulkan_symbol(library, "vkCmdCopyImageToBuffer"):
table.vkCmdCopyImageToBuffer = (func(u64, u64, u32, u64, u32, VkBufferImageCopy*?) -> unit)found
if let found = vulkan_symbol(library, "vkCmdCopyImage"):
table.vkCmdCopyImage = (func(u64, u64, u32, u64, u32, u32, VkImageCopy*?) -> unit)found
if let found = vulkan_symbol(library, "vkCmdBlitImage"):
table.vkCmdBlitImage = (func(u64, u64, u32, u64, u32, u32, VkImageBlit*?, u32) -> unit)found
if let found = vulkan_symbol(library, "vkCmdCopyBuffer"):
table.vkCmdCopyBuffer = (func(u64, u64, u64, u32, VkBufferCopy*?) -> unit)found
if let found = vulkan_symbol(library, "vkCreateXlibSurfaceKHR"):
table.vkCreateXlibSurfaceKHR = (func(u64, VkXlibSurfaceCreateInfoKHR*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkGetPhysicalDeviceProperties"):
table.vkGetPhysicalDeviceProperties = (func(u64, void*) -> unit)found
if let found = vulkan_symbol(library, "vkEnumerateInstanceVersion"):
table.vkEnumerateInstanceVersion = (func(u32*?) -> i32)found
if let found = vulkan_symbol(library, "vkGetPhysicalDeviceProperties2"):
table.vkGetPhysicalDeviceProperties2 = (func(u64, VkPhysicalDeviceProperties2*?) -> unit)found
if let found = vulkan_symbol(library, "vkGetPhysicalDeviceFeatures2"):
table.vkGetPhysicalDeviceFeatures2 = (func(u64, VkPhysicalDeviceFeatures2*?) -> unit)found
if let found = vulkan_symbol(library, "vkEnumerateDeviceExtensionProperties"):
table.vkEnumerateDeviceExtensionProperties = (func(u64, void*?, u32*?, VkExtensionProperties*?) -> i32)found
if let found = vulkan_symbol(library, "vkCreateComputePipelines"):
table.vkCreateComputePipelines = (func(u64, u64, u32, VkComputePipelineCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkCmdDispatch"):
table.vkCmdDispatch = (func(u64, u32, u32, u32) -> unit)found
if let found = vulkan_symbol(library, "vkCmdDispatchIndirect"):
table.vkCmdDispatchIndirect = (func(u64, u64, u64) -> unit)found
if let found = vulkan_symbol(library, "vkCmdFillBuffer"):
table.vkCmdFillBuffer = (func(u64, u64, u64, u64, u32) -> unit)found
if let found = vulkan_symbol(library, "vkCreateQueryPool"):
table.vkCreateQueryPool = (func(u64, VkQueryPoolCreateInfo*?, void*?, u64*?) -> i32)found
if let found = vulkan_symbol(library, "vkDestroyQueryPool"):
table.vkDestroyQueryPool = (func(u64, u64, void*?) -> unit)found
if let found = vulkan_symbol(library, "vkCmdResetQueryPool"):
table.vkCmdResetQueryPool = (func(u64, u64, u32, u32) -> unit)found
if let found = vulkan_symbol(library, "vkCmdWriteTimestamp"):
table.vkCmdWriteTimestamp = (func(u64, u32, u64, u32) -> unit)found
if let found = vulkan_symbol(library, "vkGetQueryPoolResults"):
table.vkGetQueryPoolResults = (func(u64, u64, u32, u32, usize, void*?, u64, u32) -> i32)found
if let found = vulkan_symbol(library, "vkGetBufferDeviceAddress"):
table.vkGetBufferDeviceAddress = (func(u64, VkBufferDeviceAddressInfo*?) -> u64)found
if let found = vulkan_symbol(library, "vkGetDeviceProcAddr"):
table.vkGetDeviceProcAddr = (func(u64, c.str) -> void*?)found
if table.vkCreateInstance == none:
free(table) in memory.heap
error(unavailable, "the Vulkan loader has no vkCreateInstance")
vulkan_functions = table
func vulkan_library() -> void*!:
if platform.windows:
var name: u16[13] = [118, 117, 108, 107, 97, 110, 45, 49, 46, 100, 108, 108, 0]
return LoadLibraryW(&name[0]) else error(unavailable, "Vulkan is not installed (vulkan-1.dll)")
# RTLD_NOW: every symbol is resolved at open.
return dlopen("libvulkan.so.1", 2) else error(unavailable, "Vulkan is not installed (libvulkan.so.1)")
func vulkan_symbol(library: void*, name: c.str) -> void*?:
if platform.windows:
return GetProcAddress(library, name)
return dlsym(library, name)
func vulkan_entry() -> VulkanFunctions*:
return vulkan_functions else trap("Vulkan is used before it was loaded")
# mark: The functions ==========================================================================
func vkCreateInstance(pCreateInfo: VkInstanceCreateInfo*?, pAllocator: void*?, pInstance: u64*?) -> i32:
let call = vulkan_entry().vkCreateInstance else trap("the Vulkan loader lacks vkCreateInstance")
return call(pCreateInfo, pAllocator, pInstance)
func vkDestroyInstance(instance: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyInstance else trap("the Vulkan loader lacks vkDestroyInstance")
call(instance, pAllocator)
func vkEnumeratePhysicalDevices(instance: u64, pPhysicalDeviceCount: u32*?, pPhysicalDevices: u64*?) -> i32:
let call = vulkan_entry().vkEnumeratePhysicalDevices else trap("the Vulkan loader lacks vkEnumeratePhysicalDevices")
return call(instance, pPhysicalDeviceCount, pPhysicalDevices)
func vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice: u64, pQueueFamilyPropertyCount: u32*?, pQueueFamilyProperties: VkQueueFamilyProperties*?):
let call = vulkan_entry().vkGetPhysicalDeviceQueueFamilyProperties else trap("the Vulkan loader lacks vkGetPhysicalDeviceQueueFamilyProperties")
call(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties)
func vkGetPhysicalDeviceMemoryProperties(physicalDevice: u64, pMemoryProperties: VkPhysicalDeviceMemoryProperties*?):
let call = vulkan_entry().vkGetPhysicalDeviceMemoryProperties else trap("the Vulkan loader lacks vkGetPhysicalDeviceMemoryProperties")
call(physicalDevice, pMemoryProperties)
func vkGetPhysicalDeviceFormatProperties(physicalDevice: u64, format_value: u32, pFormatProperties: VkFormatProperties*?):
let call = vulkan_entry().vkGetPhysicalDeviceFormatProperties else trap("the Vulkan loader lacks vkGetPhysicalDeviceFormatProperties")
call(physicalDevice, format_value, pFormatProperties)
func vkCreateDevice(physicalDevice: u64, pCreateInfo: VkDeviceCreateInfo*?, pAllocator: void*?, pDevice: u64*?) -> i32:
let call = vulkan_entry().vkCreateDevice else trap("the Vulkan loader lacks vkCreateDevice")
return call(physicalDevice, pCreateInfo, pAllocator, pDevice)
func vkDestroyDevice(device: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyDevice else trap("the Vulkan loader lacks vkDestroyDevice")
call(device, pAllocator)
func vkGetDeviceQueue(device: u64, queueFamilyIndex: u32, queueIndex: u32, pQueue: u64*?):
let call = vulkan_entry().vkGetDeviceQueue else trap("the Vulkan loader lacks vkGetDeviceQueue")
call(device, queueFamilyIndex, queueIndex, pQueue)
func vkCreateWin32SurfaceKHR(instance: u64, pCreateInfo: VkWin32SurfaceCreateInfoKHR*?, pAllocator: void*?, pSurface: u64*?) -> i32:
let call = vulkan_entry().vkCreateWin32SurfaceKHR else trap("the Vulkan loader lacks vkCreateWin32SurfaceKHR")
return call(instance, pCreateInfo, pAllocator, pSurface)
func vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice: u64, queueFamilyIndex: u32) -> u32:
let call = vulkan_entry().vkGetPhysicalDeviceWin32PresentationSupportKHR else trap("the Vulkan loader lacks vkGetPhysicalDeviceWin32PresentationSupportKHR")
return call(physicalDevice, queueFamilyIndex)
func vkDestroySurfaceKHR(instance: u64, surface: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroySurfaceKHR else trap("the Vulkan loader lacks vkDestroySurfaceKHR")
call(instance, surface, pAllocator)
func vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice: u64, queueFamilyIndex: u32, surface: u64, pSupported: u32*?) -> i32:
let call = vulkan_entry().vkGetPhysicalDeviceSurfaceSupportKHR else trap("the Vulkan loader lacks vkGetPhysicalDeviceSurfaceSupportKHR")
return call(physicalDevice, queueFamilyIndex, surface, pSupported)
func vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice: u64, surface: u64, pSurfaceCapabilities: VkSurfaceCapabilitiesKHR*?) -> i32:
let call = vulkan_entry().vkGetPhysicalDeviceSurfaceCapabilitiesKHR else trap("the Vulkan loader lacks vkGetPhysicalDeviceSurfaceCapabilitiesKHR")
return call(physicalDevice, surface, pSurfaceCapabilities)
func vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice: u64, surface: u64, pSurfaceFormatCount: u32*?, pSurfaceFormats: VkSurfaceFormatKHR*?) -> i32:
let call = vulkan_entry().vkGetPhysicalDeviceSurfaceFormatsKHR else trap("the Vulkan loader lacks vkGetPhysicalDeviceSurfaceFormatsKHR")
return call(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats)
func vkCreateSwapchainKHR(device: u64, pCreateInfo: VkSwapchainCreateInfoKHR*?, pAllocator: void*?, pSwapchain: u64*?) -> i32:
let call = vulkan_entry().vkCreateSwapchainKHR else trap("the Vulkan loader lacks vkCreateSwapchainKHR")
return call(device, pCreateInfo, pAllocator, pSwapchain)
func vkDestroySwapchainKHR(device: u64, swapchain: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroySwapchainKHR else trap("the Vulkan loader lacks vkDestroySwapchainKHR")
call(device, swapchain, pAllocator)
func vkGetSwapchainImagesKHR(device: u64, swapchain: u64, pSwapchainImageCount: u32*?, pSwapchainImages: u64*?) -> i32:
let call = vulkan_entry().vkGetSwapchainImagesKHR else trap("the Vulkan loader lacks vkGetSwapchainImagesKHR")
return call(device, swapchain, pSwapchainImageCount, pSwapchainImages)
func vkAcquireNextImageKHR(device: u64, swapchain: u64, timeout: u64, semaphore: u64, fence: u64, pImageIndex: u32*?) -> i32:
let call = vulkan_entry().vkAcquireNextImageKHR else trap("the Vulkan loader lacks vkAcquireNextImageKHR")
return call(device, swapchain, timeout, semaphore, fence, pImageIndex)
func vkQueuePresentKHR(queue: u64, pPresentInfo: VkPresentInfoKHR*?) -> i32:
let call = vulkan_entry().vkQueuePresentKHR else trap("the Vulkan loader lacks vkQueuePresentKHR")
return call(queue, pPresentInfo)
func vkQueueSubmit(queue: u64, submitCount: u32, pSubmits: VkSubmitInfo*?, fence: u64) -> i32:
let call = vulkan_entry().vkQueueSubmit else trap("the Vulkan loader lacks vkQueueSubmit")
return call(queue, submitCount, pSubmits, fence)
func vkQueueWaitIdle(queue: u64) -> i32:
let call = vulkan_entry().vkQueueWaitIdle else trap("the Vulkan loader lacks vkQueueWaitIdle")
return call(queue)
func vkDeviceWaitIdle(device: u64) -> i32:
let call = vulkan_entry().vkDeviceWaitIdle else trap("the Vulkan loader lacks vkDeviceWaitIdle")
return call(device)
func vkCreateImageView(device: u64, pCreateInfo: VkImageViewCreateInfo*?, pAllocator: void*?, pView: u64*?) -> i32:
let call = vulkan_entry().vkCreateImageView else trap("the Vulkan loader lacks vkCreateImageView")
return call(device, pCreateInfo, pAllocator, pView)
func vkDestroyImageView(device: u64, imageView: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyImageView else trap("the Vulkan loader lacks vkDestroyImageView")
call(device, imageView, pAllocator)
func vkCreateImage(device: u64, pCreateInfo: VkImageCreateInfo*?, pAllocator: void*?, pImage: u64*?) -> i32:
let call = vulkan_entry().vkCreateImage else trap("the Vulkan loader lacks vkCreateImage")
return call(device, pCreateInfo, pAllocator, pImage)
func vkDestroyImage(device: u64, image: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyImage else trap("the Vulkan loader lacks vkDestroyImage")
call(device, image, pAllocator)
func vkGetImageMemoryRequirements(device: u64, image: u64, pMemoryRequirements: VkMemoryRequirements*?):
let call = vulkan_entry().vkGetImageMemoryRequirements else trap("the Vulkan loader lacks vkGetImageMemoryRequirements")
call(device, image, pMemoryRequirements)
func vkAllocateMemory(device: u64, pAllocateInfo: VkMemoryAllocateInfo*?, pAllocator: void*?, pMemory: u64*?) -> i32:
let call = vulkan_entry().vkAllocateMemory else trap("the Vulkan loader lacks vkAllocateMemory")
return call(device, pAllocateInfo, pAllocator, pMemory)
func vkFreeMemory(device: u64, memory_value: u64, pAllocator: void*?):
let call = vulkan_entry().vkFreeMemory else trap("the Vulkan loader lacks vkFreeMemory")
call(device, memory_value, pAllocator)
func vkBindImageMemory(device: u64, image: u64, memory_value: u64, memoryOffset: u64) -> i32:
let call = vulkan_entry().vkBindImageMemory else trap("the Vulkan loader lacks vkBindImageMemory")
return call(device, image, memory_value, memoryOffset)
func vkCreateBuffer(device: u64, pCreateInfo: VkBufferCreateInfo*?, pAllocator: void*?, pBuffer: u64*?) -> i32:
let call = vulkan_entry().vkCreateBuffer else trap("the Vulkan loader lacks vkCreateBuffer")
return call(device, pCreateInfo, pAllocator, pBuffer)
func vkDestroyBuffer(device: u64, buffer: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyBuffer else trap("the Vulkan loader lacks vkDestroyBuffer")
call(device, buffer, pAllocator)
func vkGetBufferMemoryRequirements(device: u64, buffer: u64, pMemoryRequirements: VkMemoryRequirements*?):
let call = vulkan_entry().vkGetBufferMemoryRequirements else trap("the Vulkan loader lacks vkGetBufferMemoryRequirements")
call(device, buffer, pMemoryRequirements)
func vkBindBufferMemory(device: u64, buffer: u64, memory_value: u64, memoryOffset: u64) -> i32:
let call = vulkan_entry().vkBindBufferMemory else trap("the Vulkan loader lacks vkBindBufferMemory")
return call(device, buffer, memory_value, memoryOffset)
func vkMapMemory(device: u64, memory_value: u64, offset: u64, size: u64, flags: u32, ppData: void*?*?) -> i32:
let call = vulkan_entry().vkMapMemory else trap("the Vulkan loader lacks vkMapMemory")
return call(device, memory_value, offset, size, flags, ppData)
func vkUnmapMemory(device: u64, memory_value: u64):
let call = vulkan_entry().vkUnmapMemory else trap("the Vulkan loader lacks vkUnmapMemory")
call(device, memory_value)
func vkCreateRenderPass(device: u64, pCreateInfo: VkRenderPassCreateInfo*?, pAllocator: void*?, pRenderPass: u64*?) -> i32:
let call = vulkan_entry().vkCreateRenderPass else trap("the Vulkan loader lacks vkCreateRenderPass")
return call(device, pCreateInfo, pAllocator, pRenderPass)
func vkDestroyRenderPass(device: u64, renderPass: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyRenderPass else trap("the Vulkan loader lacks vkDestroyRenderPass")
call(device, renderPass, pAllocator)
func vkCreateFramebuffer(device: u64, pCreateInfo: VkFramebufferCreateInfo*?, pAllocator: void*?, pFramebuffer: u64*?) -> i32:
let call = vulkan_entry().vkCreateFramebuffer else trap("the Vulkan loader lacks vkCreateFramebuffer")
return call(device, pCreateInfo, pAllocator, pFramebuffer)
func vkDestroyFramebuffer(device: u64, framebuffer: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyFramebuffer else trap("the Vulkan loader lacks vkDestroyFramebuffer")
call(device, framebuffer, pAllocator)
func vkCreateShaderModule(device: u64, pCreateInfo: VkShaderModuleCreateInfo*?, pAllocator: void*?, pShaderModule: u64*?) -> i32:
let call = vulkan_entry().vkCreateShaderModule else trap("the Vulkan loader lacks vkCreateShaderModule")
return call(device, pCreateInfo, pAllocator, pShaderModule)
func vkDestroyShaderModule(device: u64, shaderModule: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyShaderModule else trap("the Vulkan loader lacks vkDestroyShaderModule")
call(device, shaderModule, pAllocator)
func vkCreatePipelineLayout(device: u64, pCreateInfo: VkPipelineLayoutCreateInfo*?, pAllocator: void*?, pPipelineLayout: u64*?) -> i32:
let call = vulkan_entry().vkCreatePipelineLayout else trap("the Vulkan loader lacks vkCreatePipelineLayout")
return call(device, pCreateInfo, pAllocator, pPipelineLayout)
func vkDestroyPipelineLayout(device: u64, pipelineLayout: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyPipelineLayout else trap("the Vulkan loader lacks vkDestroyPipelineLayout")
call(device, pipelineLayout, pAllocator)
func vkCreateGraphicsPipelines(device: u64, pipelineCache: u64, createInfoCount: u32, pCreateInfos: VkGraphicsPipelineCreateInfo*?, pAllocator: void*?, pPipelines: u64*?) -> i32:
let call = vulkan_entry().vkCreateGraphicsPipelines else trap("the Vulkan loader lacks vkCreateGraphicsPipelines")
return call(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines)
func vkDestroyPipeline(device: u64, pipeline: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyPipeline else trap("the Vulkan loader lacks vkDestroyPipeline")
call(device, pipeline, pAllocator)
func vkCreateCommandPool(device: u64, pCreateInfo: VkCommandPoolCreateInfo*?, pAllocator: void*?, pCommandPool: u64*?) -> i32:
let call = vulkan_entry().vkCreateCommandPool else trap("the Vulkan loader lacks vkCreateCommandPool")
return call(device, pCreateInfo, pAllocator, pCommandPool)
func vkDestroyCommandPool(device: u64, commandPool: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyCommandPool else trap("the Vulkan loader lacks vkDestroyCommandPool")
call(device, commandPool, pAllocator)
func vkAllocateCommandBuffers(device: u64, pAllocateInfo: VkCommandBufferAllocateInfo*?, pCommandBuffers: u64*?) -> i32:
let call = vulkan_entry().vkAllocateCommandBuffers else trap("the Vulkan loader lacks vkAllocateCommandBuffers")
return call(device, pAllocateInfo, pCommandBuffers)
func vkResetCommandPool(device: u64, commandPool: u64, flags: u32) -> i32:
let call = vulkan_entry().vkResetCommandPool else trap("the Vulkan loader lacks vkResetCommandPool")
return call(device, commandPool, flags)
func vkBeginCommandBuffer(commandBuffer: u64, pBeginInfo: VkCommandBufferBeginInfo*?) -> i32:
let call = vulkan_entry().vkBeginCommandBuffer else trap("the Vulkan loader lacks vkBeginCommandBuffer")
return call(commandBuffer, pBeginInfo)
func vkEndCommandBuffer(commandBuffer: u64) -> i32:
let call = vulkan_entry().vkEndCommandBuffer else trap("the Vulkan loader lacks vkEndCommandBuffer")
return call(commandBuffer)
func vkCmdBeginRenderPass(commandBuffer: u64, pRenderPassBegin: VkRenderPassBeginInfo*?, contents: u32):
let call = vulkan_entry().vkCmdBeginRenderPass else trap("the Vulkan loader lacks vkCmdBeginRenderPass")
call(commandBuffer, pRenderPassBegin, contents)
func vkCmdEndRenderPass(commandBuffer: u64):
let call = vulkan_entry().vkCmdEndRenderPass else trap("the Vulkan loader lacks vkCmdEndRenderPass")
call(commandBuffer)
func vkCmdBindPipeline(commandBuffer: u64, pipelineBindPoint: u32, pipeline: u64):
let call = vulkan_entry().vkCmdBindPipeline else trap("the Vulkan loader lacks vkCmdBindPipeline")
call(commandBuffer, pipelineBindPoint, pipeline)
func vkCmdSetDepthBias(commandBuffer: u64, constant: f32, clamp: f32, slope: f32):
let call = vulkan_entry().vkCmdSetDepthBias else trap("the Vulkan loader lacks vkCmdSetDepthBias")
call(commandBuffer,constant,clamp,slope)
func vkCmdSetViewport(commandBuffer: u64, firstViewport: u32, viewportCount: u32, pViewports: VkViewport*?):
let call = vulkan_entry().vkCmdSetViewport else trap("the Vulkan loader lacks vkCmdSetViewport")
call(commandBuffer, firstViewport, viewportCount, pViewports)
func vkCmdSetScissor(commandBuffer: u64, firstScissor: u32, scissorCount: u32, pScissors: VkRect2D*?):
let call = vulkan_entry().vkCmdSetScissor else trap("the Vulkan loader lacks vkCmdSetScissor")
call(commandBuffer, firstScissor, scissorCount, pScissors)
func vkCmdBindVertexBuffers(commandBuffer: u64, firstBinding: u32, bindingCount: u32, pBuffers: u64*?, pOffsets: u64*?):
let call = vulkan_entry().vkCmdBindVertexBuffers else trap("the Vulkan loader lacks vkCmdBindVertexBuffers")
call(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets)
func vkCmdDraw(commandBuffer: u64, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32):
let call = vulkan_entry().vkCmdDraw else trap("the Vulkan loader lacks vkCmdDraw")
call(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance)
func vkCmdDrawIndirect(commandBuffer: u64, buffer: u64, offset: u64, drawCount: u32, stride: u32):
let call = vulkan_entry().vkCmdDrawIndirect else trap("the Vulkan loader lacks vkCmdDrawIndirect")
call(commandBuffer, buffer, offset, drawCount, stride)
func vkCreateSemaphore(device: u64, pCreateInfo: VkSemaphoreCreateInfo*?, pAllocator: void*?, pSemaphore: u64*?) -> i32:
let call = vulkan_entry().vkCreateSemaphore else trap("the Vulkan loader lacks vkCreateSemaphore")
return call(device, pCreateInfo, pAllocator, pSemaphore)
func vkDestroySemaphore(device: u64, semaphore: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroySemaphore else trap("the Vulkan loader lacks vkDestroySemaphore")
call(device, semaphore, pAllocator)
func vkCreateFence(device: u64, pCreateInfo: VkFenceCreateInfo*?, pAllocator: void*?, pFence: u64*?) -> i32:
let call = vulkan_entry().vkCreateFence else trap("the Vulkan loader lacks vkCreateFence")
return call(device, pCreateInfo, pAllocator, pFence)
func vkDestroyFence(device: u64, fence: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyFence else trap("the Vulkan loader lacks vkDestroyFence")
call(device, fence, pAllocator)
func vkWaitForFences(device: u64, fenceCount: u32, pFences: u64*?, waitAll: u32, timeout: u64) -> i32:
let call = vulkan_entry().vkWaitForFences else trap("the Vulkan loader lacks vkWaitForFences")
return call(device, fenceCount, pFences, waitAll, timeout)
func vkResetFences(device: u64, fenceCount: u32, pFences: u64*?) -> i32:
let call = vulkan_entry().vkResetFences else trap("the Vulkan loader lacks vkResetFences")
return call(device, fenceCount, pFences)
func vkCreateDescriptorSetLayout(device: u64, pCreateInfo: VkDescriptorSetLayoutCreateInfo*?, pAllocator: void*?, pSetLayout: u64*?) -> i32:
let call = vulkan_entry().vkCreateDescriptorSetLayout else trap("the Vulkan loader lacks vkCreateDescriptorSetLayout")
return call(device, pCreateInfo, pAllocator, pSetLayout)
func vkDestroyDescriptorSetLayout(device: u64, descriptorSetLayout: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyDescriptorSetLayout else trap("the Vulkan loader lacks vkDestroyDescriptorSetLayout")
call(device, descriptorSetLayout, pAllocator)
func vkCreateDescriptorPool(device: u64, pCreateInfo: VkDescriptorPoolCreateInfo*?, pAllocator: void*?, pDescriptorPool: u64*?) -> i32:
let call = vulkan_entry().vkCreateDescriptorPool else trap("the Vulkan loader lacks vkCreateDescriptorPool")
return call(device, pCreateInfo, pAllocator, pDescriptorPool)
func vkDestroyDescriptorPool(device: u64, descriptorPool: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyDescriptorPool else trap("the Vulkan loader lacks vkDestroyDescriptorPool")
call(device, descriptorPool, pAllocator)
func vkAllocateDescriptorSets(device: u64, pAllocateInfo: VkDescriptorSetAllocateInfo*?, pDescriptorSets: u64*?) -> i32:
let call = vulkan_entry().vkAllocateDescriptorSets else trap("the Vulkan loader lacks vkAllocateDescriptorSets")
return call(device, pAllocateInfo, pDescriptorSets)
func vkUpdateDescriptorSets(device: u64, descriptorWriteCount: u32, pDescriptorWrites: VkWriteDescriptorSet*?, descriptorCopyCount: u32, pDescriptorCopies: VkCopyDescriptorSet*?):
let call = vulkan_entry().vkUpdateDescriptorSets else trap("the Vulkan loader lacks vkUpdateDescriptorSets")
call(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies)
func vkCmdBindDescriptorSets(commandBuffer: u64, pipelineBindPoint: u32, layout: u64, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: u64*?, dynamicOffsetCount: u32, pDynamicOffsets: u32*?):
let call = vulkan_entry().vkCmdBindDescriptorSets else trap("the Vulkan loader lacks vkCmdBindDescriptorSets")
call(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets)
func vkCmdPushConstants(commandBuffer: u64, layout: u64, stageFlags: u32, offset: u32, size: u32, pValues: void*?):
let call = vulkan_entry().vkCmdPushConstants else trap("the Vulkan loader lacks vkCmdPushConstants")
call(commandBuffer, layout, stageFlags, offset, size, pValues)
func vkCreateSampler(device: u64, pCreateInfo: VkSamplerCreateInfo*?, pAllocator: void*?, pSampler: u64*?) -> i32:
let call = vulkan_entry().vkCreateSampler else trap("the Vulkan loader lacks vkCreateSampler")
return call(device, pCreateInfo, pAllocator, pSampler)
func vkDestroySampler(device: u64, sampler: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroySampler else trap("the Vulkan loader lacks vkDestroySampler")
call(device, sampler, pAllocator)
func vkCmdPipelineBarrier(commandBuffer: u64, srcStageMask: u32, dstStageMask: u32, dependencyFlags: u32, memoryBarrierCount: u32, pMemoryBarriers: void*?, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: void*?, imageMemoryBarrierCount: u32, pImageMemoryBarriers: VkImageMemoryBarrier*?):
let call = vulkan_entry().vkCmdPipelineBarrier else trap("the Vulkan loader lacks vkCmdPipelineBarrier")
call(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers)
func vkCmdCopyBufferToImage(commandBuffer: u64, srcBuffer: u64, dstImage: u64, dstImageLayout: u32, regionCount: u32, pRegions: VkBufferImageCopy*?):
let call = vulkan_entry().vkCmdCopyBufferToImage else trap("the Vulkan loader lacks vkCmdCopyBufferToImage")
call(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions)
func vkCmdCopyImageToBuffer(commandBuffer: u64, srcImage: u64, srcImageLayout: u32, dstBuffer: u64, regionCount: u32, pRegions: VkBufferImageCopy*?):
let call = vulkan_entry().vkCmdCopyImageToBuffer else trap("the Vulkan loader lacks vkCmdCopyImageToBuffer")
call(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions)
func vkCmdCopyImage(commandBuffer: u64, srcImage: u64, srcImageLayout: u32, dstImage: u64, dstImageLayout: u32, regionCount: u32, pRegions: VkImageCopy*?):
let call = vulkan_entry().vkCmdCopyImage else trap("the Vulkan loader lacks vkCmdCopyImage")
call(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions)
func vkCmdBlitImage(commandBuffer: u64, srcImage: u64, srcImageLayout: u32, dstImage: u64, dstImageLayout: u32, regionCount: u32, pRegions: VkImageBlit*?, filter: u32):
let call = vulkan_entry().vkCmdBlitImage else trap("the Vulkan loader lacks vkCmdBlitImage")
call(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter)
func vkCmdCopyBuffer(commandBuffer: u64, srcBuffer: u64, dstBuffer: u64, regionCount: u32, pRegions: VkBufferCopy*?):
let call = vulkan_entry().vkCmdCopyBuffer else trap("the Vulkan loader lacks vkCmdCopyBuffer")
call(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions)
func vkCreateXlibSurfaceKHR(instance: u64, pCreateInfo: VkXlibSurfaceCreateInfoKHR*?, pAllocator: void*?, pSurface: u64*?) -> i32:
let call = vulkan_entry().vkCreateXlibSurfaceKHR else trap("the Vulkan loader lacks vkCreateXlibSurfaceKHR")
return call(instance, pCreateInfo, pAllocator, pSurface)
## Read into a VkPhysicalDeviceProperties-sized buffer (the bindings leave the struct out).
func vkGetPhysicalDeviceProperties(physicalDevice: u64, pProperties: void*):
let call = vulkan_entry().vkGetPhysicalDeviceProperties else trap("the Vulkan loader lacks vkGetPhysicalDeviceProperties")
call(physicalDevice, pProperties)
func vkEnumerateInstanceVersion(pApiVersion: u32*?) -> i32:
let call = vulkan_entry().vkEnumerateInstanceVersion else trap("the Vulkan loader lacks vkEnumerateInstanceVersion")
return call(pApiVersion)
func vkGetPhysicalDeviceProperties2(physicalDevice: u64, pProperties: VkPhysicalDeviceProperties2*?):
let call = vulkan_entry().vkGetPhysicalDeviceProperties2 else trap("the Vulkan loader lacks vkGetPhysicalDeviceProperties2")
call(physicalDevice, pProperties)
func vkGetPhysicalDeviceFeatures2(physicalDevice: u64, pFeatures: VkPhysicalDeviceFeatures2*?):
let call = vulkan_entry().vkGetPhysicalDeviceFeatures2 else trap("the Vulkan loader lacks vkGetPhysicalDeviceFeatures2")
call(physicalDevice, pFeatures)
func vkEnumerateDeviceExtensionProperties(physicalDevice: u64, pLayerName: void*?, pPropertyCount: u32*?, pProperties: VkExtensionProperties*?) -> i32:
let call = vulkan_entry().vkEnumerateDeviceExtensionProperties else trap("the Vulkan loader lacks vkEnumerateDeviceExtensionProperties")
return call(physicalDevice, pLayerName, pPropertyCount, pProperties)
func vkCreateComputePipelines(device: u64, pipelineCache: u64, createInfoCount: u32, pCreateInfos: VkComputePipelineCreateInfo*?, pAllocator: void*?, pPipelines: u64*?) -> i32:
let call = vulkan_entry().vkCreateComputePipelines else trap("the Vulkan loader lacks vkCreateComputePipelines")
return call(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines)
func vkCmdDispatch(commandBuffer: u64, groupCountX: u32, groupCountY: u32, groupCountZ: u32):
let call = vulkan_entry().vkCmdDispatch else trap("the Vulkan loader lacks vkCmdDispatch")
call(commandBuffer, groupCountX, groupCountY, groupCountZ)
func vkCmdDispatchIndirect(commandBuffer: u64, buffer: u64, offset: u64):
let call = vulkan_entry().vkCmdDispatchIndirect else trap("the Vulkan loader lacks vkCmdDispatchIndirect")
call(commandBuffer, buffer, offset)
func vkCmdFillBuffer(commandBuffer: u64, dstBuffer: u64, dstOffset: u64, size: u64, data: u32):
let call = vulkan_entry().vkCmdFillBuffer else trap("the Vulkan loader lacks vkCmdFillBuffer")
call(commandBuffer, dstBuffer, dstOffset, size, data)
func vkCreateQueryPool(device: u64, pCreateInfo: VkQueryPoolCreateInfo*?, pAllocator: void*?, pQueryPool: u64*?) -> i32:
let call = vulkan_entry().vkCreateQueryPool else trap("the Vulkan loader lacks vkCreateQueryPool")
return call(device, pCreateInfo, pAllocator, pQueryPool)
func vkDestroyQueryPool(device: u64, queryPool: u64, pAllocator: void*?):
let call = vulkan_entry().vkDestroyQueryPool else trap("the Vulkan loader lacks vkDestroyQueryPool")
call(device, queryPool, pAllocator)
func vkCmdResetQueryPool(commandBuffer: u64, queryPool: u64, firstQuery: u32, queryCount: u32):
let call = vulkan_entry().vkCmdResetQueryPool else trap("the Vulkan loader lacks vkCmdResetQueryPool")
call(commandBuffer, queryPool, firstQuery, queryCount)
func vkCmdWriteTimestamp(commandBuffer: u64, pipelineStage: u32, queryPool: u64, query: u32):
let call = vulkan_entry().vkCmdWriteTimestamp else trap("the Vulkan loader lacks vkCmdWriteTimestamp")
call(commandBuffer, pipelineStage, queryPool, query)
func vkGetQueryPoolResults(device: u64, queryPool: u64, firstQuery: u32, queryCount: u32, dataSize: usize, pData: void*?, stride: u64, flags: u32) -> i32:
let call = vulkan_entry().vkGetQueryPoolResults else trap("the Vulkan loader lacks vkGetQueryPoolResults")
return call(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags)
func vkGetBufferDeviceAddress(device: u64, pInfo: VkBufferDeviceAddressInfo*?) -> u64:
let call = vulkan_entry().vkGetBufferDeviceAddress else trap("the Vulkan loader lacks vkGetBufferDeviceAddress")
return call(device, pInfo)
func vkGetDeviceProcAddr(device: u64, pName: c.str) -> void*?:
let call = vulkan_entry().vkGetDeviceProcAddr else trap("the Vulkan loader lacks vkGetDeviceProcAddr")
return call(device, pName)
## The loader's Vulkan version: 1.0 when it predates vkEnumerateInstanceVersion.
func vulkan_instance_version() -> u32:
if vulkan_entry().vkEnumerateInstanceVersion == none:
return vulkan_api_version_1_0
var version: u32 = vulkan_api_version_1_0
if vkEnumerateInstanceVersion(&version) != VK_SUCCESS:
return vulkan_api_version_1_0
return version