405 lines
15 KiB
C++
405 lines
15 KiB
C++
// vim:fileencoding=utf-8:foldmethod=marker
|
|
|
|
#include "wapp/wapp.h"
|
|
#include "vulkan_profiles/vulkan_profiles.h"
|
|
#include <glm/ext/vector_int2.hpp>
|
|
#include <SDL3/SDL.h>
|
|
#include <SDL3/SDL_events.h>
|
|
#include <SDL3/SDL_init.h>
|
|
#include <SDL3/SDL_keycode.h>
|
|
#include <SDL3/SDL_video.h>
|
|
#include <SDL3/SDL_vulkan.h>
|
|
#define VMA_IMPLEMENTATION
|
|
#include <vma/vk_mem_alloc.h>
|
|
#include <volk/volk.h>
|
|
#include <vulkan/vulkan.h>
|
|
#include <vulkan/vk_enum_string_helper.h>
|
|
#include <iostream>
|
|
|
|
enum ExitCode {
|
|
EXIT_CODE_SUCCESS,
|
|
EXIT_CODE_SDL_INIT_FAILED,
|
|
EXIT_CODE_VULKAN_LIB_LOAD_FAILED,
|
|
EXIT_CODE_WINDOW_CREATION_FAILED,
|
|
EXIT_CODE_SURFACE_CREATION_FAILED,
|
|
EXIT_CODE_GET_WINDOW_SIZE_FAILED,
|
|
EXIT_CODE_NO_INSTANCE_SUPPORT,
|
|
EXIT_CODE_NO_PHYSICAL_DEVICES,
|
|
EXIT_CODE_ALLOCATION_FAILURE,
|
|
EXIT_CODE_NO_SUITABLE_PHYSICAL_DEVICE,
|
|
EXIT_CODE_NO_PRESENTATION_SUPPORT,
|
|
EXIT_CODE_NO_PHYSICAL_DEVICE_SUPPORT,
|
|
EXIT_CODE_NO_QUEUE_FAMILIES,
|
|
EXIT_CODE_NO_SUITABLE_QUEUE_FAMILY,
|
|
};
|
|
|
|
typedef VkPhysicalDevice *VkPhysicalDeviceArray;
|
|
typedef VkQueueFamilyProperties2 *VkQueueFamilyProperties2Array;
|
|
typedef VkImage *VkImageArray;
|
|
typedef VkImageView *VkImageViewArray;
|
|
|
|
wapp_intern inline void check(VkResult result);
|
|
wapp_intern inline void check_swapchain(VkResult result);
|
|
wapp_intern inline void check(bool result, i32 code);
|
|
|
|
wapp_intern bool running = true;
|
|
wapp_intern bool update_swapchain = false;
|
|
wapp_intern f32 display_scale = 1.0f;
|
|
wapp_intern SDL_Window *window = nullptr;
|
|
wapp_intern VkInstance instance = VK_NULL_HANDLE;
|
|
wapp_intern VkPhysicalDevice physical_device = VK_NULL_HANDLE;
|
|
wapp_intern VkSurfaceKHR surface = VK_NULL_HANDLE;
|
|
wapp_intern u32 queue_family_index = 0;
|
|
wapp_intern VkDevice device = VK_NULL_HANDLE;
|
|
wapp_intern VkQueue queue = VK_NULL_HANDLE;
|
|
wapp_intern VmaAllocator allocator = VK_NULL_HANDLE;
|
|
wapp_intern glm::ivec2 window_size = {};
|
|
wapp_intern VkFormat image_format = VK_FORMAT_B8G8R8A8_SRGB;
|
|
wapp_intern VkSwapchainKHR swapchain = VK_NULL_HANDLE;
|
|
wapp_intern u32 swapchain_image_count = 0;
|
|
wapp_intern VkImageArray swapchain_images = nullptr;
|
|
wapp_intern VkImageViewArray swapchain_views = nullptr;
|
|
|
|
int main() {
|
|
// {{{ Initialisation
|
|
Allocator arena = wapp_mem_arena_allocator_init(MiB(64));
|
|
|
|
check(SDL_Init(SDL_INIT_VIDEO), EXIT_CODE_SDL_INIT_FAILED);
|
|
check(SDL_Vulkan_LoadLibrary(nullptr), EXIT_CODE_VULKAN_LIB_LOAD_FAILED);
|
|
check(volkInitialize());
|
|
|
|
display_scale = SDL_GetDisplayContentScale(SDL_GetPrimaryDisplay());
|
|
window = SDL_CreateWindow("How To Vulkan", (i32)(display_scale * 1920),
|
|
(i32)(display_scale * 1080), SDL_WINDOW_VULKAN);
|
|
check(window != nullptr, EXIT_CODE_WINDOW_CREATION_FAILED);
|
|
// }}}
|
|
|
|
// {{{ Get Vulkan Profile
|
|
VkBool32 supported = VK_FALSE;
|
|
|
|
VpProfileProperties profile = {
|
|
.profileName = VP_LEARN_HOW_TO_VULKAN_2026_NAME,
|
|
.specVersion = VP_LEARN_HOW_TO_VULKAN_2026_SPEC_VERSION,
|
|
};
|
|
// }}}
|
|
|
|
// {{{ Instance Creation
|
|
// {{{ Get Platform Extensions
|
|
u32 instance_extension_count = 0;
|
|
const char *const *instance_extensions = SDL_Vulkan_GetInstanceExtensions(&instance_extension_count);
|
|
// }}}
|
|
|
|
// {{{ Check Instance Profile Support
|
|
check(vpGetInstanceProfileSupport(NULL, &profile, &supported));
|
|
check(supported, EXIT_CODE_NO_INSTANCE_SUPPORT);
|
|
// }}}
|
|
|
|
VkApplicationInfo app_info = {};
|
|
app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
|
|
app_info.apiVersion = VP_LEARN_HOW_TO_VULKAN_2026_MIN_API_VERSION;
|
|
|
|
// {{{ Create Instance
|
|
VkInstanceCreateInfo instance_info = {};
|
|
instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
|
instance_info.pApplicationInfo = &app_info;
|
|
instance_info.enabledExtensionCount = instance_extension_count;
|
|
instance_info.ppEnabledExtensionNames = instance_extensions;
|
|
|
|
VpInstanceCreateInfo vp_instance_info = {};
|
|
vp_instance_info.pCreateInfo = &instance_info;
|
|
vp_instance_info.enabledFullProfileCount = 1;
|
|
vp_instance_info.pEnabledFullProfiles = &profile;
|
|
|
|
check(vpCreateInstance(&vp_instance_info, NULL, &instance));
|
|
// }}}
|
|
|
|
volkLoadInstance(instance);
|
|
// }}}
|
|
|
|
wapp_mem_arena_allocator_temp_begin(&arena);
|
|
|
|
// {{{ Physical Device Retrieval
|
|
// {{{ Get Physical Device Count
|
|
u32 physical_device_count = 0;
|
|
check(vkEnumeratePhysicalDevices(instance, &physical_device_count, nullptr));
|
|
check(physical_device_count > 0, EXIT_CODE_NO_PHYSICAL_DEVICES);
|
|
// }}}
|
|
|
|
// {{{ Get All Physical Devices
|
|
VkPhysicalDeviceArray physical_devices =
|
|
wapp_array_alloc_capacity(VkPhysicalDevice, &arena, physical_device_count, ARRAY_INIT_FILLED);
|
|
check(physical_devices != nullptr, EXIT_CODE_ALLOCATION_FAILURE);
|
|
|
|
check(vkEnumeratePhysicalDevices(instance, &physical_device_count, physical_devices));
|
|
|
|
// Set the count in case it changes after the second call to vkEnumeratePhysicalDevices
|
|
wapp_array_set_count(physical_devices, physical_device_count);
|
|
// }}}
|
|
|
|
// {{{ Choose Appropriate Physical Device
|
|
i32 index = -1;
|
|
for (u32 i = 0; i < wapp_array_count(physical_devices); ++i) {
|
|
VkPhysicalDeviceProperties2 base_properties = { .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 };
|
|
vkGetPhysicalDeviceProperties2(physical_devices[i], &base_properties);
|
|
switch (base_properties.properties.deviceType) {
|
|
case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: {
|
|
if (base_properties.properties.apiVersion >= VP_LEARN_HOW_TO_VULKAN_2026_MIN_API_VERSION) {
|
|
index = i;
|
|
}
|
|
} break;
|
|
case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: {
|
|
if (base_properties.properties.apiVersion >= VP_LEARN_HOW_TO_VULKAN_2026_MIN_API_VERSION) {
|
|
index = i;
|
|
}
|
|
} break;
|
|
default: continue;
|
|
}
|
|
}
|
|
check(index != -1, EXIT_CODE_NO_SUITABLE_PHYSICAL_DEVICE);
|
|
|
|
physical_device = physical_devices[index];
|
|
|
|
// {{{ Print Physical Device Information
|
|
VkPhysicalDeviceDriverProperties p_device_driver_props = {};
|
|
p_device_driver_props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
|
|
VkPhysicalDeviceProperties2 p_device_props = {};
|
|
p_device_props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
|
|
p_device_props.pNext = &p_device_driver_props;
|
|
vkGetPhysicalDeviceProperties2(physical_device, &p_device_props);
|
|
|
|
u32 api_major = VK_API_VERSION_MAJOR(p_device_props.properties.apiVersion);
|
|
u32 api_minor = VK_API_VERSION_MINOR(p_device_props.properties.apiVersion);
|
|
u32 api_patch = VK_API_VERSION_PATCH(p_device_props.properties.apiVersion);
|
|
u32 api_variant = VK_API_VERSION_VARIANT(p_device_props.properties.apiVersion);
|
|
std::cout << "Selected GPU: " << p_device_props.properties.deviceName << '\n'
|
|
<< "Driver version: " << p_device_driver_props.driverInfo << '\n'
|
|
<< "API version: " << api_major << '.' << api_minor << '.' << api_patch << '.'
|
|
<< api_variant << '\n';
|
|
// }}}
|
|
// }}}
|
|
|
|
// {{{ Check Physical Device Profile Support
|
|
check(vpGetPhysicalDeviceProfileSupport(instance, physical_device, &profile, &supported));
|
|
check(supported, EXIT_CODE_NO_PHYSICAL_DEVICE_SUPPORT);
|
|
// }}}
|
|
// }}}
|
|
|
|
// {{{ Surface Creation
|
|
check(SDL_Vulkan_CreateSurface(window, instance, nullptr, &surface), EXIT_CODE_SURFACE_CREATION_FAILED);
|
|
check(SDL_GetWindowSize(window, &window_size.x, &window_size.y), EXIT_CODE_GET_WINDOW_SIZE_FAILED);
|
|
VkSurfaceCapabilitiesKHR surface_caps{};
|
|
check(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, surface, &surface_caps));
|
|
// }}}
|
|
|
|
// {{{ Queue Family Retrieval
|
|
// {{{ Get Queue Family Count
|
|
u32 queue_family_count = 0;
|
|
vkGetPhysicalDeviceQueueFamilyProperties2(physical_device, &queue_family_count, nullptr);
|
|
check(queue_family_count > 0, EXIT_CODE_NO_QUEUE_FAMILIES);
|
|
// }}}
|
|
|
|
// {{{ Get All Queue Families
|
|
VkQueueFamilyProperties2Array queue_family_properties =
|
|
wapp_array_alloc_capacity(VkQueueFamilyProperties2, &arena, queue_family_count, ARRAY_INIT_FILLED);
|
|
check(queue_family_properties != nullptr, EXIT_CODE_ALLOCATION_FAILURE);
|
|
|
|
for (u32 i = 0; i < wapp_array_count(queue_family_properties); ++i) {
|
|
queue_family_properties[i].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
|
|
}
|
|
|
|
vkGetPhysicalDeviceQueueFamilyProperties2(physical_device, &queue_family_count, queue_family_properties);
|
|
|
|
// Set the count in case it changes after the second call to vkGetPhysicalDeviceQueueFamilyProperties2
|
|
wapp_array_set_count(queue_family_properties, queue_family_count);
|
|
// }}}
|
|
|
|
// {{{ Choose Appropriate Queue Family
|
|
i32 family_index = -1;
|
|
for (u32 i = 0; i < queue_family_count; ++i) {
|
|
if ((queue_family_properties[i].queueFamilyProperties.queueFlags &
|
|
(VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT)) != 0) {
|
|
family_index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
check(family_index != -1, EXIT_CODE_NO_SUITABLE_QUEUE_FAMILY);
|
|
|
|
queue_family_index = (u32)family_index;
|
|
// }}}
|
|
|
|
// {{{ Check Presentation Support
|
|
check(SDL_Vulkan_GetPresentationSupport(instance, physical_device, queue_family_index),
|
|
EXIT_CODE_NO_PRESENTATION_SUPPORT);
|
|
// }}}
|
|
// }}}
|
|
|
|
wapp_mem_arena_allocator_temp_end(&arena);
|
|
|
|
// {{{ Device And Queue Creation
|
|
// {{{ Create Device
|
|
f32 queue_priority = 1.0f;
|
|
VkDeviceQueueCreateInfo device_queue_create_info = {};
|
|
device_queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
|
|
device_queue_create_info.queueCount = 1;
|
|
device_queue_create_info.queueFamilyIndex = queue_family_index;
|
|
device_queue_create_info.pQueuePriorities = &queue_priority;
|
|
|
|
VkDeviceCreateInfo device_create_info = {};
|
|
device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
|
|
device_create_info.queueCreateInfoCount = 1;
|
|
device_create_info.pQueueCreateInfos = &device_queue_create_info;
|
|
|
|
VpDeviceCreateInfo vp_device_create_info = {};
|
|
vp_device_create_info.pCreateInfo = &device_create_info;
|
|
vp_device_create_info.enabledFullProfileCount = 1;
|
|
vp_device_create_info.pEnabledFullProfiles = &profile;
|
|
|
|
check(vpCreateDevice(physical_device, &vp_device_create_info, nullptr, &device));
|
|
// }}}
|
|
|
|
// {{{ Get Queue
|
|
vkGetDeviceQueue(device, queue_family_index, 0, &queue);
|
|
// }}}
|
|
|
|
volkLoadDevice(device);
|
|
// }}}
|
|
|
|
// {{{ Vulkan Memory Allocator (VMA) Setup
|
|
VmaVulkanFunctions vk_functions = {};
|
|
vk_functions.vkGetInstanceProcAddr = vkGetInstanceProcAddr;
|
|
vk_functions.vkGetDeviceProcAddr = vkGetDeviceProcAddr;
|
|
vk_functions.vkCreateImage = vkCreateImage;
|
|
|
|
VmaAllocatorCreateInfo allocator_create_info = {};
|
|
allocator_create_info.flags = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT;
|
|
allocator_create_info.instance = instance;
|
|
allocator_create_info.physicalDevice = physical_device;
|
|
allocator_create_info.device = device;
|
|
allocator_create_info.pVulkanFunctions = &vk_functions;
|
|
|
|
check(vmaCreateAllocator(&allocator_create_info, &allocator));
|
|
// }}}
|
|
|
|
// {{{ Swapchain Creation
|
|
// {{{ Calculate Extent
|
|
VkExtent2D swapchain_extent = surface_caps.currentExtent;
|
|
// Handle Wayland's special value (0xffffffff), which indicate that the surface size will
|
|
// basically be determined by the size of the surface
|
|
if (swapchain_extent.width == 0xffffffff) {
|
|
swapchain_extent.width = (u32)window_size.x;
|
|
swapchain_extent.height = (u32)window_size.y;
|
|
}
|
|
// }}}
|
|
|
|
// {{{ Create Swapchain
|
|
VkSwapchainCreateInfoKHR swapchain_create_info = {};
|
|
swapchain_create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
|
|
swapchain_create_info.surface = surface;
|
|
swapchain_create_info.minImageCount = surface_caps.minImageCount;
|
|
swapchain_create_info.imageFormat = image_format;
|
|
swapchain_create_info.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
|
|
swapchain_create_info.imageExtent = swapchain_extent;
|
|
swapchain_create_info.imageArrayLayers = 1;
|
|
swapchain_create_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
swapchain_create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
swapchain_create_info.queueFamilyIndexCount = 1;
|
|
swapchain_create_info.pQueueFamilyIndices = &queue_family_index;
|
|
swapchain_create_info.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
|
|
swapchain_create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
|
|
swapchain_create_info.presentMode = VK_PRESENT_MODE_FIFO_KHR;
|
|
|
|
check(vkCreateSwapchainKHR(device, &swapchain_create_info, nullptr, &swapchain));
|
|
// }}}
|
|
|
|
// {{{ Get Swapchain Images
|
|
check(vkGetSwapchainImagesKHR(device, swapchain, &swapchain_image_count, nullptr));
|
|
swapchain_images = wapp_array_alloc_capacity(VkImage, &arena, swapchain_image_count, ARRAY_INIT_FILLED);
|
|
check(swapchain_images != nullptr, EXIT_CODE_ALLOCATION_FAILURE);
|
|
check(vkGetSwapchainImagesKHR(device, swapchain, &swapchain_image_count, swapchain_images));
|
|
|
|
// Set the count in case it changes after the second call to vkGetSwapchainImagesKHR
|
|
wapp_array_set_count(swapchain_images, swapchain_image_count);
|
|
// }}}
|
|
|
|
// {{{ Create Swapchain Image Views
|
|
swapchain_views = wapp_array_alloc_capacity(VkImageView, &arena, swapchain_image_count, ARRAY_INIT_FILLED);
|
|
check(swapchain_views != nullptr, EXIT_CODE_ALLOCATION_FAILURE);
|
|
|
|
for (u32 i = 0; i < swapchain_image_count; ++i) {
|
|
VkImageViewCreateInfo view_create_info = {};
|
|
view_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
|
view_create_info.image = swapchain_images[i];
|
|
view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
view_create_info.format = image_format;
|
|
view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
view_create_info.subresourceRange.levelCount = 1;
|
|
view_create_info.subresourceRange.layerCount = 1;
|
|
|
|
check(vkCreateImageView(device, &view_create_info, nullptr, &swapchain_views[i]));
|
|
}
|
|
// }}}
|
|
// }}}
|
|
|
|
// {{{ Render Loop
|
|
SDL_Event event = {};
|
|
while (running) {
|
|
while (SDL_PollEvent(&event)) {
|
|
switch (event.type) {
|
|
case SDL_EVENT_QUIT:
|
|
running = false;
|
|
break;
|
|
case SDL_EVENT_KEY_DOWN:
|
|
if (event.key.key == SDLK_ESCAPE) {
|
|
running = false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// }}}
|
|
|
|
// {{{ Cleanup
|
|
for (u32 i = 0; i < swapchain_image_count; ++i) {
|
|
vkDestroyImageView(device, swapchain_views[i], nullptr);
|
|
}
|
|
vkDestroySwapchainKHR(device, swapchain, nullptr);
|
|
vmaDestroyAllocator(allocator);
|
|
vkDestroyDevice(device, nullptr);
|
|
vkDestroySurfaceKHR(instance, surface, nullptr);
|
|
vkDestroyInstance(instance, nullptr);
|
|
SDL_DestroyWindow(window);
|
|
SDL_Vulkan_UnloadLibrary();
|
|
SDL_Quit();
|
|
|
|
wapp_mem_arena_allocator_destroy(&arena);
|
|
// }}}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// {{{ Helper Functions
|
|
wapp_intern inline void check(VkResult result) {
|
|
if (result != VK_SUCCESS) {
|
|
std::cerr << "Vulkan call returned an error (" << string_VkResult(result) << ")\n";
|
|
exit(result);
|
|
}
|
|
}
|
|
wapp_intern inline void check_swapchain(VkResult result) {
|
|
if (result < VK_SUCCESS) {
|
|
if (result == VK_ERROR_OUT_OF_DATE_KHR) {
|
|
update_swapchain = true;
|
|
return;
|
|
}
|
|
std::cerr << "Vulkan call returned an error (" << result << ")\n";
|
|
exit(result);
|
|
}
|
|
}
|
|
wapp_intern inline void check(bool result, i32 code) {
|
|
if (!result) {
|
|
std::cerr << "Call returned an error\n";
|
|
exit(code);
|
|
}
|
|
}
|
|
// }}}
|