405 lines
13 KiB
C
405 lines
13 KiB
C
#if OS_WINDOWS
|
|
|
|
#define VK_PLATFORM_SURFACE_EXTENSION VK_KHR_WIN32_SURFACE_EXTENSION_NAME
|
|
|
|
static void *Vk_LoadLibrary() {
|
|
void *result = LoadLibraryA("vulkan-1.dll");
|
|
|
|
if (result != 0) {
|
|
vk.GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr) GetProcAddress(result, "vkGetInstanceProcAddr");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static void Vk_CreateSurface(SDL_Window *window) {
|
|
SDL_PropertiesID prop_id = SDL_GetWindowProperties(window);
|
|
|
|
VkWin32SurfaceCreateInfoKHR create_info = { 0 };
|
|
create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
|
|
create_info.hinstance = SDL_GetPointerProperty(prop_id, SDL_PROP_WINDOW_WIN32_INSTANCE_POINTER, 0);
|
|
create_info.hwnd = SDL_GetPointerProperty(prop_id, SDL_PROP_WINDOW_WIN32_HWND_POINTER, 0);
|
|
|
|
vk.err = vk.CreateWin32SurfaceKHR(vk.instance, &create_info, 0, &vk.surface);
|
|
}
|
|
|
|
#elif OS_LINUX
|
|
|
|
#define VK_PLATFORM_SURFACE_EXTENSION \
|
|
VK_KHR_XLIB_SURFACE_EXTENSION_NAME, \
|
|
VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME
|
|
|
|
static void *Vk_LoadLibrary() {
|
|
void *result = dlopen("libvulkan.so", RTLD_LAZY);
|
|
|
|
if (result != 0) {
|
|
vk.GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr) dlsym(result, "vkGetInstanceProcAddr");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static void Vk_CreateSurface(SDL_Window *window) {
|
|
SDL_PropertiesID prop_id = SDL_GetWindowProperties(window);
|
|
|
|
struct wl_display *wl_display = SDL_GetPointerProperty(prop_id, SDL_PROP_WINDOW_WAYLAND_DISPLAY_POINTER, 0);
|
|
if (wl_display == 0) {
|
|
// Assume we are running via X11 if there isn't a vaild Wayland display
|
|
//
|
|
VkXlibSurfaceCreateInfoKHR create_info = { 0 };
|
|
create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
|
|
create_info.dpy = SDL_GetPointerProperty(prop_id, SDL_PROP_WINDOW_X11_DISPLAY_POINTER, 0);
|
|
create_info.window = SDL_GetNumberProperty(prop_id, SDL_PROP_WINDOW_X11_WINDOW_NUMBER, 0);
|
|
|
|
vk.err = vk.CreateXlibSurfaceKHR(vk.instance, &create_info, 0, &vk.surface);
|
|
}
|
|
else {
|
|
VkWaylandSurfaceCreateInfoKHR create_info = { 0 };
|
|
create_info.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
|
|
create_info.display = wl_display;
|
|
create_info.surface = SDL_GetPointerProperty(prop_id, SDL_PROP_WINDOW_WAYLAND_SURFACE_POINTER, 0);
|
|
|
|
vk.err = vk.CreateWaylandSurfaceKHR(vk.instance, &create_info, 0, &vk.surface);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
Vk_Context vk;
|
|
|
|
bool Vk_Setup(SDL_Window *window) {
|
|
bool result = false;
|
|
|
|
vk.lib = Vk_LoadLibrary();
|
|
|
|
// Create instance
|
|
//
|
|
if (vk.err == VK_SUCCESS) {
|
|
vk.CreateInstance = (PFN_vkCreateInstance) vk.GetInstanceProcAddr(0, "vkCreateInstance");
|
|
|
|
const char *extensions[] = {
|
|
VK_KHR_SURFACE_EXTENSION_NAME,
|
|
VK_PLATFORM_SURFACE_EXTENSION,
|
|
|
|
#if !LD_RELEASE
|
|
VK_EXT_DEBUG_UTILS_EXTENSION_NAME
|
|
#endif
|
|
};
|
|
|
|
const char *layers[] = {
|
|
"VK_LAYER_KHRONOS_validation"
|
|
};
|
|
|
|
U32 n_layers = LD_RELEASE ? 0 : ArraySize(layers);
|
|
|
|
VkApplicationInfo app = { 0 };
|
|
app.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
|
|
app.apiVersion = VK_API_VERSION_1_3; // I know 1.4 is out
|
|
|
|
VkInstanceCreateInfo create_info = { 0 };
|
|
create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
|
create_info.pApplicationInfo = &app;
|
|
create_info.ppEnabledExtensionNames = extensions;
|
|
create_info.enabledExtensionCount = ArraySize(extensions);
|
|
create_info.ppEnabledLayerNames = layers;
|
|
create_info.enabledLayerCount = n_layers;
|
|
|
|
vk.err = vk.CreateInstance(&create_info, 0, &vk.instance);
|
|
}
|
|
|
|
// Load instance level functions and create window surface
|
|
//
|
|
if (vk.err == VK_SUCCESS) {
|
|
#define VK_INSTANCE_FUNCTIONS
|
|
#define VK_FUNC(x) vk.x = (PFN_vk##x) vk.GetInstanceProcAddr(vk.instance, Stringify(Glue(vk, x)))
|
|
#include "functions.h"
|
|
#undef VK_FUNC
|
|
|
|
Vk_CreateSurface(window);
|
|
}
|
|
|
|
// Select GPU
|
|
//
|
|
if (vk.err == VK_SUCCESS) {
|
|
VkPhysicalDevice devices[8] = { 0 };
|
|
U32 n_devices;
|
|
|
|
vk.EnumeratePhysicalDevices(vk.instance, &n_devices, 0);
|
|
vk.EnumeratePhysicalDevices(vk.instance, &n_devices, devices);
|
|
|
|
vk.gpu = devices[0];
|
|
|
|
for (U32 it = 0; it < n_devices; ++it) {
|
|
VkPhysicalDeviceProperties props;
|
|
vk.GetPhysicalDeviceProperties(devices[it], &props);
|
|
|
|
if (props.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
|
|
vk.gpu = devices[it];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (vk.gpu != VK_NULL_HANDLE) {
|
|
VkQueueFamilyProperties qprops[32] = { 0 };
|
|
U32 n_qprops = 0;
|
|
|
|
vk.GetPhysicalDeviceQueueFamilyProperties(vk.gpu, &n_qprops, 0);
|
|
vk.GetPhysicalDeviceQueueFamilyProperties(vk.gpu, &n_qprops, qprops);
|
|
|
|
for (U32 it = 0; it < n_qprops; ++it) {
|
|
if (qprops[it].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
|
|
// Assumed combined graphics-present queue, this is the case on all desktop class
|
|
// gpus
|
|
vk.queue.family = it;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
printf("[Error] :: Failed to create instance\n");
|
|
}
|
|
|
|
// Create logical device
|
|
//
|
|
if (vk.gpu != VK_NULL_HANDLE) {
|
|
const char *extensions[] = {
|
|
VK_KHR_SWAPCHAIN_EXTENSION_NAME
|
|
};
|
|
|
|
VkPhysicalDeviceVulkan11Features features11 = { 0 };
|
|
features11.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
|
|
features11.storageBuffer16BitAccess = VK_TRUE;
|
|
features11.uniformAndStorageBuffer16BitAccess = VK_TRUE;
|
|
|
|
VkPhysicalDeviceVulkan12Features features12 = { 0 };
|
|
features12.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
|
|
features12.pNext = &features11;
|
|
features12.shaderFloat16 = VK_TRUE;
|
|
features12.shaderInt8 = VK_TRUE;
|
|
features12.storageBuffer8BitAccess = VK_TRUE;
|
|
features12.uniformAndStorageBuffer8BitAccess = VK_TRUE;
|
|
features12.descriptorIndexing = VK_TRUE;
|
|
|
|
// @Todo: we will probably need to enable some of the 'nonuniform' indexing features
|
|
|
|
VkPhysicalDeviceVulkan13Features features13 = { 0 };
|
|
features13.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
|
|
features13.pNext = &features12;
|
|
features13.synchronization2 = VK_TRUE;
|
|
features13.dynamicRendering = VK_TRUE;
|
|
|
|
F32 priority = 1.0f;
|
|
|
|
VkDeviceQueueCreateInfo queue_info = { 0 };
|
|
queue_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
|
|
queue_info.queueFamilyIndex = vk.queue.family;
|
|
queue_info.queueCount = 1;
|
|
queue_info.pQueuePriorities = &priority;
|
|
|
|
VkDeviceCreateInfo create_info = { 0 };
|
|
create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
|
|
create_info.pNext = &features13;
|
|
create_info.queueCreateInfoCount = 1;
|
|
create_info.pQueueCreateInfos = &queue_info;
|
|
create_info.enabledExtensionCount = ArraySize(extensions);
|
|
create_info.ppEnabledExtensionNames = extensions;
|
|
create_info.pEnabledFeatures = 0;
|
|
|
|
vk.err = vk.CreateDevice(vk.gpu, &create_info, 0, &vk.device);
|
|
}
|
|
else {
|
|
printf("[Error] :: Failed to find suitable GPU\n");
|
|
vk.err = VK_ERROR_DEVICE_LOST;
|
|
}
|
|
|
|
if (vk.err == VK_SUCCESS) {
|
|
// Load device level functions and acquire the device queue
|
|
#define VK_DEVICE_FUNCTIONS
|
|
#define VK_FUNC(x) vk.x = (PFN_vk##x) vk.GetDeviceProcAddr(vk.device, Stringify(Glue(vk, x)))
|
|
#include "functions.h"
|
|
#undef VK_FUNC
|
|
|
|
vk.GetDeviceQueue(vk.device, vk.queue.family, 0, &vk.queue.handle);
|
|
|
|
// Create swapchain
|
|
U32 n_images = 2;
|
|
{
|
|
VkSurfaceCapabilitiesKHR caps;
|
|
vk.GetPhysicalDeviceSurfaceCapabilitiesKHR(vk.gpu, vk.surface, &caps);
|
|
|
|
if (caps.currentExtent.width == -1) {
|
|
int w, h;
|
|
SDL_GetWindowSizeInPixels(window, &w, &h);
|
|
|
|
vk.swapchain.width = w;
|
|
vk.swapchain.height = h;
|
|
}
|
|
else {
|
|
vk.swapchain.width = caps.currentExtent.width;
|
|
vk.swapchain.height = caps.currentExtent.height;
|
|
}
|
|
|
|
n_images = Max(n_images, caps.minImageCount);
|
|
}
|
|
|
|
{
|
|
VkSurfaceFormatKHR formats[32];
|
|
U32 n_formats = 0;
|
|
|
|
vk.GetPhysicalDeviceSurfaceFormatsKHR(vk.gpu, vk.surface, &n_formats, 0);
|
|
vk.GetPhysicalDeviceSurfaceFormatsKHR(vk.gpu, vk.surface, &n_formats, formats);
|
|
|
|
vk.swapchain.format = formats[0];
|
|
|
|
for (U32 it = 0; it < n_formats; ++it) {
|
|
VkSurfaceFormatKHR *fmt = &formats[it];
|
|
|
|
if ((fmt->format == VK_FORMAT_B8G8R8A8_SRGB) ||
|
|
(fmt->format == VK_FORMAT_R8G8B8A8_SRGB))
|
|
{
|
|
if (fmt->colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
|
|
vk.swapchain.format = formats[it];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
VkSwapchainCreateInfoKHR create_info = { 0 };
|
|
create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
|
|
create_info.surface = vk.surface;
|
|
create_info.minImageCount = n_images;
|
|
create_info.imageFormat = vk.swapchain.format.format;
|
|
create_info.imageColorSpace = vk.swapchain.format.colorSpace;
|
|
create_info.imageExtent = (VkExtent2D) { vk.swapchain.width, vk.swapchain.height };
|
|
create_info.imageArrayLayers = 1;
|
|
create_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
create_info.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
|
|
create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
|
|
create_info.presentMode = VK_PRESENT_MODE_FIFO_KHR;
|
|
create_info.clipped = VK_TRUE;
|
|
|
|
vk.err = vk.CreateSwapchainKHR(vk.device, &create_info, 0, &vk.swapchain.handle);
|
|
|
|
vk.swapchain.n_images = n_images;
|
|
}
|
|
else {
|
|
printf("[Error] :: Failed to create device\n");
|
|
}
|
|
|
|
if (vk.err == VK_SUCCESS) {
|
|
// Get the swapchain images and create image views using them
|
|
U32 n_images = 0;
|
|
vk.GetSwapchainImagesKHR(vk.device, vk.swapchain.handle, &n_images, 0);
|
|
vk.GetSwapchainImagesKHR(vk.device, vk.swapchain.handle, &n_images, vk.swapchain.images);
|
|
|
|
if (n_images != vk.swapchain.n_images) {
|
|
printf("[Warn] :: Swapchain image count mismatch\n");
|
|
vk.swapchain.n_images = n_images;
|
|
}
|
|
|
|
VkImageViewCreateInfo create_info = { 0 };
|
|
create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
|
create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
create_info.format = vk.swapchain.format.format;
|
|
|
|
create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
create_info.subresourceRange.levelCount = 1;
|
|
create_info.subresourceRange.layerCount = 1;
|
|
|
|
for (U32 it = 0; it < n_images && vk.err == VK_SUCCESS; ++it) {
|
|
create_info.image = vk.swapchain.images[it];
|
|
vk.err = vk.CreateImageView(vk.device, &create_info, 0, &vk.swapchain.views[it]);
|
|
}
|
|
}
|
|
|
|
for (U32 it = 0; it < VK_FRAMES_IN_FLIGHT && vk.err == VK_SUCCESS; ++it) {
|
|
Vk_Frame *frame = &vk.frames[it];
|
|
|
|
VkCommandPoolCreateInfo pool = { 0 };
|
|
pool.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
|
pool.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
|
|
pool.queueFamilyIndex = vk.queue.family;
|
|
|
|
VkResult err = vk.CreateCommandPool(vk.device, &pool, 0, &frame->pool);
|
|
|
|
VkCommandBufferAllocateInfo alloc = { 0 };
|
|
alloc.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
|
alloc.commandBufferCount = 1;
|
|
alloc.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
|
alloc.commandPool = frame->pool;
|
|
|
|
vk.AllocateCommandBuffers(vk.device, &alloc, &frame->cmd);
|
|
|
|
VkSemaphoreCreateInfo semaphore = { 0 };
|
|
semaphore.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
|
|
|
|
err = Min(vk.CreateSemaphore(vk.device, &semaphore, 0, &frame->acquire), err);
|
|
err = Min(vk.CreateSemaphore(vk.device, &semaphore, 0, &frame->complete), err);
|
|
|
|
VkFenceCreateInfo fence = { 0 };
|
|
fence.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
|
|
fence.flags = VK_FENCE_CREATE_SIGNALED_BIT;
|
|
|
|
err = Min(vk.CreateFence(vk.device, &fence, 0, &frame->fence), err);
|
|
|
|
vk.err = err;
|
|
}
|
|
|
|
result = (vk.err == VK_SUCCESS);
|
|
return result;
|
|
}
|
|
|
|
Vk_Frame *Vk_FrameBegin(SDL_Window *window) {
|
|
(void) window; // might need this for the resize later
|
|
Vk_Frame *frame = &vk.frames[vk.n_frames & 1];
|
|
|
|
vk.WaitForFences(vk.device, 1, &frame->fence, VK_TRUE, UINT64_MAX);
|
|
|
|
vk.ResetFences(vk.device, 1, &frame->fence);
|
|
vk.ResetCommandPool(vk.device, frame->pool, 0);
|
|
|
|
VkResult res = vk.AcquireNextImageKHR(vk.device, vk.swapchain.handle, UINT64_MAX, frame->acquire, 0, &frame->image);
|
|
(void) res; // @Todo: check res to see if swapchain is out of date and rebuild
|
|
|
|
VkCommandBufferBeginInfo begin_info = { 0 };
|
|
begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
|
|
vk.BeginCommandBuffer(frame->cmd, &begin_info);
|
|
|
|
return frame;
|
|
}
|
|
|
|
void Vk_FrameEnd() {
|
|
Vk_Frame *frame = &vk.frames[vk.n_frames & 1];
|
|
|
|
vk.EndCommandBuffer(frame->cmd);
|
|
|
|
VkPipelineStageFlags stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
|
|
|
VkSubmitInfo submit = { 0 };
|
|
submit.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submit.waitSemaphoreCount = 1;
|
|
submit.pWaitSemaphores = &frame->acquire;
|
|
submit.pWaitDstStageMask = &stage;
|
|
submit.commandBufferCount = 1;
|
|
submit.pCommandBuffers = &frame->cmd;
|
|
submit.signalSemaphoreCount = 1;
|
|
submit.pSignalSemaphores = &frame->complete;
|
|
|
|
vk.QueueSubmit(vk.queue.handle, 1, &submit, frame->fence);
|
|
|
|
VkPresentInfoKHR present = { 0 };
|
|
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
|
|
present.waitSemaphoreCount = 1;
|
|
present.pWaitSemaphores = &frame->complete;
|
|
present.swapchainCount = 1;
|
|
present.pSwapchains = &vk.swapchain.handle;
|
|
present.pImageIndices = &frame->image;
|
|
|
|
vk.QueuePresentKHR(vk.queue.handle, &present);
|
|
|
|
vk.n_frames += 1;
|
|
}
|