mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-19 14:45:29 +00:00
638 lines
23 KiB
C
638 lines
23 KiB
C
/*
|
|
* driver.c
|
|
* Copyright (C) 2026 Kovid Goyal <kovid at kovidgoyal.net>
|
|
*
|
|
* Distributed under terms of the GPL3 license.
|
|
*/
|
|
|
|
// The Vulkan implementation of the kitty GPU driver API, see ../api.h and
|
|
// internal.h for an overview.
|
|
|
|
#include "internal.h"
|
|
#include "version.h"
|
|
#include <dlfcn.h>
|
|
|
|
#define VK_DEFINE_FUNCTION(name) PFN_##name name = NULL;
|
|
VK_GLOBAL_FUNCTIONS(VK_DEFINE_FUNCTION)
|
|
VK_INSTANCE_FUNCTIONS(VK_DEFINE_FUNCTION)
|
|
VK_XLIB_FUNCTIONS(VK_DEFINE_FUNCTION)
|
|
VK_WAYLAND_FUNCTIONS(VK_DEFINE_FUNCTION)
|
|
VK_DEBUG_FUNCTIONS(VK_DEFINE_FUNCTION)
|
|
VK_DEVICE_FUNCTIONS(VK_DEFINE_FUNCTION)
|
|
#undef VK_DEFINE_FUNCTION
|
|
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = NULL;
|
|
|
|
// There is only ever one driver per process
|
|
static Driver *the_driver = NULL;
|
|
|
|
// Errors {{{
|
|
void
|
|
set_error(Driver *d, const char *fmt, ...) {
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
vsnprintf(d->last_error, sizeof(d->last_error), fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
void
|
|
log_error(Driver *d, const char *fmt, ...) {
|
|
char buf[4096];
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
vsnprintf(buf, sizeof(buf), fmt, ap);
|
|
va_end(ap);
|
|
d->params.log_error(buf);
|
|
}
|
|
|
|
void
|
|
debug_print(Driver *d, const char *fmt, ...) {
|
|
if (!d->params.debug_rendering) return;
|
|
char buf[4096];
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
vsnprintf(buf, sizeof(buf), fmt, ap);
|
|
va_end(ap);
|
|
d->params.debug_print(buf);
|
|
}
|
|
|
|
void
|
|
fatal(Driver *d, const char *fmt, ...) {
|
|
char buf[4096];
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
vsnprintf(buf, sizeof(buf), fmt, ap);
|
|
va_end(ap);
|
|
d->params.fatal(buf);
|
|
abort();
|
|
}
|
|
|
|
const char *
|
|
vk_result_string(VkResult r) {
|
|
switch (r) {
|
|
#define C(x) \
|
|
case x: return #x;
|
|
C(VK_SUCCESS)
|
|
C(VK_NOT_READY)
|
|
C(VK_TIMEOUT)
|
|
C(VK_INCOMPLETE)
|
|
C(VK_SUBOPTIMAL_KHR)
|
|
C(VK_ERROR_OUT_OF_HOST_MEMORY)
|
|
C(VK_ERROR_OUT_OF_DEVICE_MEMORY)
|
|
C(VK_ERROR_INITIALIZATION_FAILED)
|
|
C(VK_ERROR_DEVICE_LOST)
|
|
C(VK_ERROR_MEMORY_MAP_FAILED)
|
|
C(VK_ERROR_LAYER_NOT_PRESENT)
|
|
C(VK_ERROR_EXTENSION_NOT_PRESENT)
|
|
C(VK_ERROR_FEATURE_NOT_PRESENT)
|
|
C(VK_ERROR_INCOMPATIBLE_DRIVER)
|
|
C(VK_ERROR_TOO_MANY_OBJECTS)
|
|
C(VK_ERROR_FORMAT_NOT_SUPPORTED)
|
|
C(VK_ERROR_SURFACE_LOST_KHR)
|
|
C(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR)
|
|
C(VK_ERROR_OUT_OF_DATE_KHR)
|
|
C(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR)
|
|
C(VK_ERROR_INVALID_SHADER_NV)
|
|
C(VK_ERROR_OUT_OF_POOL_MEMORY)
|
|
C(VK_ERROR_UNKNOWN)
|
|
#undef C
|
|
default: return "unknown Vulkan error";
|
|
}
|
|
}
|
|
|
|
void
|
|
check_vk(Driver *d, VkResult r, const char *what) {
|
|
if (r != VK_SUCCESS) fatal(d, "Vulkan: %s failed with error: %s", what, vk_result_string(r));
|
|
}
|
|
|
|
static VKAPI_ATTR VkBool32 VKAPI_CALL
|
|
debug_messenger(
|
|
VkDebugUtilsMessageSeverityFlagBitsEXT severity,
|
|
VkDebugUtilsMessageTypeFlagsEXT type UNUSED,
|
|
const VkDebugUtilsMessengerCallbackDataEXT *data,
|
|
void *user_data) {
|
|
Driver *d = user_data;
|
|
if (severity >= VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) log_error(d, "Vulkan: %s", data->pMessage);
|
|
else debug_print(d, "Vulkan: %s", data->pMessage);
|
|
return VK_FALSE;
|
|
}
|
|
// }}}
|
|
|
|
// Loading {{{
|
|
static bool
|
|
load_libvulkan(Driver *d) {
|
|
static const char *names[] = {"libvulkan.so.1", "libvulkan.so"};
|
|
for (size_t i = 0; i < arraysz(names) && !d->libvulkan; i++) d->libvulkan = dlopen(names[i], RTLD_LAZY | RTLD_LOCAL);
|
|
if (!d->libvulkan) {
|
|
set_error(d, "Could not load the Vulkan library: %s", dlerror());
|
|
return false;
|
|
}
|
|
*(void **)&vkGetInstanceProcAddr = dlsym(d->libvulkan, "vkGetInstanceProcAddr");
|
|
if (!vkGetInstanceProcAddr) {
|
|
set_error(d, "The Vulkan library does not export vkGetInstanceProcAddr");
|
|
return false;
|
|
}
|
|
#define LOAD(name) \
|
|
if (!(name = (PFN_##name)vkGetInstanceProcAddr(NULL, #name))) { \
|
|
set_error(d, "Could not load the Vulkan function: %s", #name); \
|
|
return false; \
|
|
}
|
|
VK_GLOBAL_FUNCTIONS(LOAD)
|
|
#undef LOAD
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
load_instance_functions(Driver *d) {
|
|
#define LOAD(name) \
|
|
if (!(name = (PFN_##name)vkGetInstanceProcAddr(d->instance, #name))) { \
|
|
set_error(d, "Could not load the Vulkan function: %s", #name); \
|
|
return false; \
|
|
}
|
|
VK_INSTANCE_FUNCTIONS(LOAD)
|
|
if (d->platform == GPU_PLATFORM_WAYLAND) {
|
|
VK_WAYLAND_FUNCTIONS(LOAD)
|
|
} else {
|
|
VK_XLIB_FUNCTIONS(LOAD)
|
|
}
|
|
#undef LOAD
|
|
if (d->has_debug_utils) {
|
|
#define LOAD(name) name = (PFN_##name)vkGetInstanceProcAddr(d->instance, #name);
|
|
VK_DEBUG_FUNCTIONS(LOAD)
|
|
#undef LOAD
|
|
if (!vkCreateDebugUtilsMessengerEXT || !vkDestroyDebugUtilsMessengerEXT) d->has_debug_utils = false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
load_device_functions(Driver *d) {
|
|
#define LOAD(name) \
|
|
if (!(name = (PFN_##name)vkGetDeviceProcAddr(d->device, #name))) { \
|
|
set_error(d, "Could not load the Vulkan device function: %s", #name); \
|
|
return false; \
|
|
}
|
|
VK_DEVICE_FUNCTIONS(LOAD)
|
|
#undef LOAD
|
|
return true;
|
|
}
|
|
// }}}
|
|
|
|
// Instance and device {{{
|
|
static bool
|
|
has_extension(const VkExtensionProperties *exts, uint32_t count, const char *name) {
|
|
for (uint32_t i = 0; i < count; i++) {
|
|
if (strcmp(exts[i].extensionName, name) == 0) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool
|
|
create_instance(Driver *d, GPUPlatform platform) {
|
|
uint32_t version = 0;
|
|
if (vkEnumerateInstanceVersion(&version) != VK_SUCCESS ||
|
|
version < VK_MAKE_API_VERSION(0, VULKAN_REQUIRED_VERSION_MAJOR, VULKAN_REQUIRED_VERSION_MINOR, 0)) {
|
|
set_error(
|
|
d,
|
|
"The Vulkan loader supports version %u.%u, at least %d.%d is needed",
|
|
VK_API_VERSION_MAJOR(version),
|
|
VK_API_VERSION_MINOR(version),
|
|
VULKAN_REQUIRED_VERSION_MAJOR,
|
|
VULKAN_REQUIRED_VERSION_MINOR);
|
|
return false;
|
|
}
|
|
uint32_t num_exts = 0;
|
|
vkEnumerateInstanceExtensionProperties(NULL, &num_exts, NULL);
|
|
VkExtensionProperties *exts = calloc(MAX(1u, num_exts), sizeof(VkExtensionProperties));
|
|
if (!exts) {
|
|
set_error(d, "Out of memory");
|
|
return false;
|
|
}
|
|
vkEnumerateInstanceExtensionProperties(NULL, &num_exts, exts);
|
|
const char *platform_ext = platform == GPU_PLATFORM_WAYLAND ? VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME : VK_KHR_XLIB_SURFACE_EXTENSION_NAME;
|
|
const char *enabled[4];
|
|
uint32_t num_enabled = 0;
|
|
const char *required[] = {VK_KHR_SURFACE_EXTENSION_NAME, platform_ext};
|
|
for (size_t i = 0; i < arraysz(required); i++) {
|
|
if (!has_extension(exts, num_exts, required[i])) {
|
|
set_error(d, "The Vulkan instance does not support the required extension: %s", required[i]);
|
|
free(exts);
|
|
return false;
|
|
}
|
|
enabled[num_enabled++] = required[i];
|
|
}
|
|
if (d->params.debug_rendering && has_extension(exts, num_exts, VK_EXT_DEBUG_UTILS_EXTENSION_NAME)) {
|
|
enabled[num_enabled++] = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
|
|
d->has_debug_utils = true;
|
|
}
|
|
free(exts);
|
|
// Enable the validation layer when debugging rendering, if it is installed
|
|
const char *layers[1];
|
|
uint32_t num_layers = 0;
|
|
if (d->params.debug_rendering) {
|
|
uint32_t n = 0;
|
|
vkEnumerateInstanceLayerProperties(&n, NULL);
|
|
VkLayerProperties *props = calloc(MAX(1u, n), sizeof(VkLayerProperties));
|
|
if (props) {
|
|
vkEnumerateInstanceLayerProperties(&n, props);
|
|
for (uint32_t i = 0; i < n; i++) {
|
|
if (strcmp(props[i].layerName, "VK_LAYER_KHRONOS_validation") == 0) layers[num_layers++] = "VK_LAYER_KHRONOS_validation";
|
|
}
|
|
free(props);
|
|
}
|
|
debug_print(d, "Vulkan validation layer is %s", num_layers ? "enabled" : "not installed");
|
|
}
|
|
const VkApplicationInfo app = {
|
|
.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
|
|
.pApplicationName = "kitty",
|
|
.pEngineName = "kitty",
|
|
.apiVersion = VK_MAKE_API_VERSION(0, VULKAN_REQUIRED_VERSION_MAJOR, VULKAN_REQUIRED_VERSION_MINOR, 0),
|
|
};
|
|
const VkDebugUtilsMessengerCreateInfoEXT messenger_info = {
|
|
.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
|
|
.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT,
|
|
.messageType =
|
|
VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT,
|
|
.pfnUserCallback = debug_messenger,
|
|
.pUserData = d,
|
|
};
|
|
const VkInstanceCreateInfo info = {
|
|
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
|
|
.pNext = d->has_debug_utils ? &messenger_info : NULL,
|
|
.pApplicationInfo = &app,
|
|
.enabledExtensionCount = num_enabled,
|
|
.ppEnabledExtensionNames = enabled,
|
|
.enabledLayerCount = num_layers,
|
|
.ppEnabledLayerNames = layers,
|
|
};
|
|
VkResult r = vkCreateInstance(&info, NULL, &d->instance);
|
|
if (r != VK_SUCCESS) {
|
|
set_error(d, "Failed to create the Vulkan instance with error: %s", vk_result_string(r));
|
|
return false;
|
|
}
|
|
if (!load_instance_functions(d)) return false;
|
|
if (d->has_debug_utils) {
|
|
if (vkCreateDebugUtilsMessengerEXT(d->instance, &messenger_info, NULL, &d->messenger) != VK_SUCCESS) d->messenger = VK_NULL_HANDLE;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static const char *required_device_extensions[] = {
|
|
VK_KHR_SWAPCHAIN_EXTENSION_NAME,
|
|
VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME,
|
|
};
|
|
|
|
// Why the physical device cannot be used, NULL if it can. Sets queue_family
|
|
// to a queue family that supports graphics and presentation.
|
|
static const char *
|
|
unsuitable_device(Driver *d, VkPhysicalDevice dev, uint32_t *queue_family, bool *has_mutable_format) {
|
|
static char reason[512];
|
|
VkPhysicalDeviceProperties props;
|
|
vkGetPhysicalDeviceProperties(dev, &props);
|
|
if (props.apiVersion < VK_MAKE_API_VERSION(0, VULKAN_REQUIRED_VERSION_MAJOR, VULKAN_REQUIRED_VERSION_MINOR, 0)) {
|
|
snprintf(reason, sizeof(reason), "it supports only Vulkan %u.%u", VK_API_VERSION_MAJOR(props.apiVersion), VK_API_VERSION_MINOR(props.apiVersion));
|
|
return reason;
|
|
}
|
|
uint32_t num_exts = 0;
|
|
vkEnumerateDeviceExtensionProperties(dev, NULL, &num_exts, NULL);
|
|
VkExtensionProperties *exts = calloc(MAX(1u, num_exts), sizeof(VkExtensionProperties));
|
|
if (!exts) return "out of memory";
|
|
vkEnumerateDeviceExtensionProperties(dev, NULL, &num_exts, exts);
|
|
for (size_t i = 0; i < arraysz(required_device_extensions); i++) {
|
|
if (!has_extension(exts, num_exts, required_device_extensions[i])) {
|
|
snprintf(reason, sizeof(reason), "it does not support the extension: %s", required_device_extensions[i]);
|
|
free(exts);
|
|
return reason;
|
|
}
|
|
}
|
|
*has_mutable_format = has_extension(exts, num_exts, VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME);
|
|
free(exts);
|
|
VkPhysicalDeviceVulkan13Features f13 = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES};
|
|
VkPhysicalDeviceVulkan11Features f11 = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, .pNext = &f13};
|
|
VkPhysicalDeviceFeatures2 features = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, .pNext = &f11};
|
|
vkGetPhysicalDeviceFeatures2(dev, &features);
|
|
if (!f13.dynamicRendering) return "it does not support dynamic rendering";
|
|
if (!f13.synchronization2) return "it does not support synchronization2";
|
|
if (!f11.shaderDrawParameters) return "it does not support shader draw parameters";
|
|
uint32_t n = 0;
|
|
vkGetPhysicalDeviceQueueFamilyProperties(dev, &n, NULL);
|
|
VkQueueFamilyProperties *families = calloc(MAX(1u, n), sizeof(VkQueueFamilyProperties));
|
|
if (!families) return "out of memory";
|
|
vkGetPhysicalDeviceQueueFamilyProperties(dev, &n, families);
|
|
bool found = false;
|
|
for (uint32_t i = 0; i < n && !found; i++) {
|
|
if ((families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) && presentation_supported(d, dev, i)) {
|
|
*queue_family = i;
|
|
found = true;
|
|
}
|
|
}
|
|
free(families);
|
|
if (!found) return "it has no queue that can render and present to windows on this display";
|
|
return NULL;
|
|
}
|
|
|
|
static bool
|
|
create_device(Driver *d) {
|
|
uint32_t n = 0;
|
|
VkResult r = vkEnumeratePhysicalDevices(d->instance, &n, NULL);
|
|
if (r != VK_SUCCESS || !n) {
|
|
set_error(d, "No Vulkan devices found");
|
|
return false;
|
|
}
|
|
VkPhysicalDevice *devices = calloc(n, sizeof(VkPhysicalDevice));
|
|
if (!devices) {
|
|
set_error(d, "Out of memory");
|
|
return false;
|
|
}
|
|
vkEnumeratePhysicalDevices(d->instance, &n, devices);
|
|
// Use the first suitable device, in the order of the Vulkan loader, which
|
|
// puts the device driving the display first, honoring user preferences
|
|
// such as DRI_PRIME and MESA_VK_DEVICE_SELECT.
|
|
char reasons[2048] = {0};
|
|
size_t pos = 0;
|
|
for (uint32_t i = 0; i < n && !d->physical_device; i++) {
|
|
uint32_t qf = 0;
|
|
bool mutable_format = false;
|
|
const char *reason = unsuitable_device(d, devices[i], &qf, &mutable_format);
|
|
VkPhysicalDeviceProperties props;
|
|
vkGetPhysicalDeviceProperties(devices[i], &props);
|
|
if (reason) {
|
|
debug_print(d, "Vulkan: Not using the device %s as %s", props.deviceName, reason);
|
|
if (pos < sizeof(reasons)) pos += snprintf(reasons + pos, sizeof(reasons) - pos, "%s%s: %s", pos ? "; " : "", props.deviceName, reason);
|
|
continue;
|
|
}
|
|
d->physical_device = devices[i];
|
|
d->queue_family = qf;
|
|
d->has_swapchain_mutable_format = mutable_format;
|
|
d->properties = props;
|
|
}
|
|
free(devices);
|
|
if (!d->physical_device) {
|
|
set_error(d, "No suitable Vulkan device found: %s", reasons);
|
|
return false;
|
|
}
|
|
vkGetPhysicalDeviceMemoryProperties(d->physical_device, &d->memory_properties);
|
|
const float priority = 1.f;
|
|
const VkDeviceQueueCreateInfo queue_info = {
|
|
.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
|
|
.queueFamilyIndex = d->queue_family,
|
|
.queueCount = 1,
|
|
.pQueuePriorities = &priority,
|
|
};
|
|
VkPhysicalDeviceVulkan13Features f13 = {
|
|
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
|
|
.dynamicRendering = VK_TRUE,
|
|
.synchronization2 = VK_TRUE,
|
|
};
|
|
VkPhysicalDeviceVulkan11Features f11 = {
|
|
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,
|
|
.pNext = &f13,
|
|
.shaderDrawParameters = VK_TRUE,
|
|
};
|
|
const VkPhysicalDeviceFeatures2 features = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, .pNext = &f11};
|
|
const char *exts[arraysz(required_device_extensions) + 1];
|
|
uint32_t num_exts = 0;
|
|
for (size_t i = 0; i < arraysz(required_device_extensions); i++) exts[num_exts++] = required_device_extensions[i];
|
|
if (d->has_swapchain_mutable_format) exts[num_exts++] = VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME;
|
|
const VkDeviceCreateInfo info = {
|
|
.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
|
|
.pNext = &features,
|
|
.queueCreateInfoCount = 1,
|
|
.pQueueCreateInfos = &queue_info,
|
|
.enabledExtensionCount = num_exts,
|
|
.ppEnabledExtensionNames = exts,
|
|
};
|
|
r = vkCreateDevice(d->physical_device, &info, NULL, &d->device);
|
|
if (r != VK_SUCCESS) {
|
|
set_error(d, "Failed to create the Vulkan device for %s with error: %s", d->properties.deviceName, vk_result_string(r));
|
|
return false;
|
|
}
|
|
if (!load_device_functions(d)) return false;
|
|
vkGetDeviceQueue(d->device, d->queue_family, 0, &d->queue);
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
create_shared_objects(Driver *d) {
|
|
// The indices of the two triangles covering a quad, see draw_quad() in ../api.h
|
|
static const uint16_t indices[6] = {0, 1, 2, 0, 2, 3};
|
|
if (!create_buffer_with_memory(d, sizeof(indices), VK_BUFFER_USAGE_INDEX_BUFFER_BIT, MEMORY_UPLOAD, &d->quad_indices, &d->quad_indices_alloc)) return false;
|
|
memcpy(d->quad_indices_alloc.mapped, indices, sizeof(indices));
|
|
for (size_t i = 0; i < NUM_CONTEXTS; i++) {
|
|
Context *c = d->contexts + i;
|
|
const VkCommandPoolCreateInfo pool_info = {
|
|
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
|
|
.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
|
|
.queueFamilyIndex = d->queue_family,
|
|
};
|
|
if (vkCreateCommandPool(d->device, &pool_info, NULL, &c->pool) != VK_SUCCESS) {
|
|
set_error(d, "Failed to create a Vulkan command pool");
|
|
return false;
|
|
}
|
|
const VkCommandBufferAllocateInfo alloc_info = {
|
|
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
|
|
.commandPool = c->pool,
|
|
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
|
|
.commandBufferCount = 1,
|
|
};
|
|
if (vkAllocateCommandBuffers(d->device, &alloc_info, &c->cmd) != VK_SUCCESS) {
|
|
set_error(d, "Failed to allocate a Vulkan command buffer");
|
|
return false;
|
|
}
|
|
const VkFenceCreateInfo fence_info = {.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO};
|
|
if (vkCreateFence(d->device, &fence_info, NULL, &c->fence) != VK_SUCCESS) {
|
|
set_error(d, "Failed to create a Vulkan fence");
|
|
return false;
|
|
}
|
|
}
|
|
d->next_serial = 1;
|
|
return create_samplers(d);
|
|
}
|
|
// }}}
|
|
|
|
// Lifecycle {{{
|
|
static const char *
|
|
shader_target(void *driver UNUSED) {
|
|
#define S(x) #x
|
|
#define TARGET(v) "spirv-" S(v)
|
|
return TARGET(SPIRV_VERSION);
|
|
#undef TARGET
|
|
#undef S
|
|
}
|
|
|
|
static bool
|
|
connect_to_display(void *driver, const GPUNativeWindow *display) {
|
|
Driver *d = driver;
|
|
if (display->platform != GPU_PLATFORM_X11 && display->platform != GPU_PLATFORM_WAYLAND) {
|
|
set_error(d, "The Vulkan driver supports only X11 and Wayland");
|
|
return false;
|
|
}
|
|
d->platform = display->platform;
|
|
d->native_display = display->display;
|
|
if (!load_libvulkan(d) || !create_instance(d, display->platform) || !create_device(d) || !create_shared_objects(d)) return false;
|
|
snprintf(
|
|
d->version_string,
|
|
sizeof(d->version_string),
|
|
"Vulkan %u.%u.%u on %s",
|
|
VK_API_VERSION_MAJOR(d->properties.apiVersion),
|
|
VK_API_VERSION_MINOR(d->properties.apiVersion),
|
|
VK_API_VERSION_PATCH(d->properties.apiVersion),
|
|
d->properties.deviceName);
|
|
debug_print(d, "Using %s", d->version_string);
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
initialize(void *driver) {
|
|
Driver *d = driver;
|
|
if (!d->device) {
|
|
set_error(d, "The Vulkan driver was not connected to a display");
|
|
return false;
|
|
}
|
|
d->initialized = true;
|
|
return true;
|
|
}
|
|
|
|
static void
|
|
destroy(void *driver) {
|
|
Driver *d = driver;
|
|
if (d->device) {
|
|
vkDeviceWaitIdle(d->device);
|
|
release_native_resources(d);
|
|
destroy_contexts(d);
|
|
destroy_all_pipelines(d);
|
|
destroy_all_textures(d);
|
|
destroy_all_buffers(d);
|
|
while (d->vertex_layouts) vertex_layout_destroy(d, AS_HANDLE(d->vertex_layouts));
|
|
destroy_samplers(d);
|
|
if (d->quad_indices) {
|
|
vkDestroyBuffer(d->device, d->quad_indices, NULL);
|
|
free_memory(d, &d->quad_indices_alloc);
|
|
}
|
|
for (size_t i = 0; i < d->num_free_semaphores; i++) vkDestroySemaphore(d->device, d->free_semaphores[i], NULL);
|
|
free_all_memory(d);
|
|
vkDestroyDevice(d->device, NULL);
|
|
}
|
|
if (d->instance) {
|
|
if (d->messenger) vkDestroyDebugUtilsMessengerEXT(d->instance, d->messenger, NULL);
|
|
vkDestroyInstance(d->instance, NULL);
|
|
}
|
|
// The library is not unloaded, as with the drivers themselves, see unload_gpu_driver()
|
|
if (the_driver == d) the_driver = NULL;
|
|
free(d);
|
|
}
|
|
|
|
static const char *
|
|
last_error(void *driver) {
|
|
return ((Driver *)driver)->last_error;
|
|
}
|
|
|
|
static const char *
|
|
version_string(void *driver) {
|
|
return ((Driver *)driver)->version_string;
|
|
}
|
|
|
|
static void
|
|
get_capabilities(void *driver, GPUCapabilities *ans) {
|
|
Driver *d = driver;
|
|
ans->max_texture_size = d->properties.limits.maxImageDimension2D;
|
|
ans->max_array_texture_layers = d->properties.limits.maxImageArrayLayers;
|
|
// Encoding to sRGB needs both UNORM and SRGB views of swapchain images
|
|
ans->supports_srgb_output = d->has_swapchain_mutable_format;
|
|
// Vulkan places no alignment requirements on vertex input offsets and strides
|
|
ans->vertex_input_alignment = 1;
|
|
}
|
|
// }}}
|
|
|
|
__attribute__((visibility("default"))) bool
|
|
kitty_gpu_driver_load(uint32_t api_version, const GPUDriverInitParams *params, GPUDriverAPI *api, void **driver, char *errbuf, size_t errbuf_size) {
|
|
if (api_version != KITTY_GPU_API_VERSION) {
|
|
snprintf(errbuf, errbuf_size, "The Vulkan driver supports GPU API version %u but version %u was requested", KITTY_GPU_API_VERSION, api_version);
|
|
return false;
|
|
}
|
|
if (!params->log_error || !params->fatal || !params->debug_print) {
|
|
snprintf(errbuf, errbuf_size, "The Vulkan driver was not passed all required callbacks");
|
|
return false;
|
|
}
|
|
if (the_driver) {
|
|
snprintf(errbuf, errbuf_size, "The Vulkan driver has already been loaded");
|
|
return false;
|
|
}
|
|
Driver *d = calloc(1, sizeof(Driver));
|
|
if (!d) {
|
|
snprintf(errbuf, errbuf_size, "Out of memory allocating the Vulkan driver");
|
|
return false;
|
|
}
|
|
d->params = *params;
|
|
the_driver = d;
|
|
*api = (GPUDriverAPI){
|
|
.api_version = KITTY_GPU_API_VERSION,
|
|
.name = "Vulkan",
|
|
#define F(name) .name = name
|
|
F(shader_target),
|
|
.connect = connect_to_display,
|
|
F(initialize),
|
|
F(destroy),
|
|
F(last_error),
|
|
F(version_string),
|
|
F(get_capabilities),
|
|
|
|
F(texture_create),
|
|
F(texture_reset),
|
|
F(texture_destroy),
|
|
F(texture_upload),
|
|
F(texture_copy),
|
|
F(texture_read),
|
|
F(texture_get_desc),
|
|
F(bind_texture),
|
|
|
|
F(buffer_create),
|
|
F(buffer_destroy),
|
|
F(buffer_allocate),
|
|
F(buffer_map),
|
|
F(buffer_unmap),
|
|
F(buffer_copy),
|
|
F(bind_uniform_buffer),
|
|
|
|
F(pipeline_create),
|
|
F(pipeline_destroy),
|
|
F(use_pipeline),
|
|
F(pipeline_uniform_block),
|
|
F(pipeline_attribute_location),
|
|
F(set_params),
|
|
|
|
F(vertex_layout_create),
|
|
F(vertex_layout_destroy),
|
|
F(bind_vertex_layout),
|
|
F(vertex_layout_set_attribute),
|
|
|
|
F(choose_native_visual),
|
|
F(surface_create),
|
|
F(surface_destroy),
|
|
F(make_surface_current),
|
|
F(get_current_surface),
|
|
F(surface_resize),
|
|
F(surface_present),
|
|
F(surface_set_swap_interval),
|
|
F(surface_native_changed),
|
|
F(surface_recreate),
|
|
F(release_native_resources),
|
|
|
|
F(render_target_create),
|
|
F(render_target_destroy),
|
|
F(set_render_target),
|
|
F(get_render_target),
|
|
F(render_target_status),
|
|
F(clear),
|
|
F(set_viewport),
|
|
F(get_viewport),
|
|
F(set_scissor),
|
|
F(set_srgb_output),
|
|
F(read_pixels),
|
|
F(copy_to_texture),
|
|
|
|
F(draw_quad),
|
|
#undef F
|
|
};
|
|
*driver = d;
|
|
return true;
|
|
}
|