520 lines
18 KiB
C++
520 lines
18 KiB
C++
#define GLFW_INCLUDE_NONE
|
|
#define GLFW_INCLUDE_VULKAN
|
|
#include <GLFW/glfw3.h>
|
|
#include <algorithm>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <fmt/format.h>
|
|
#include <iostream>
|
|
#include <limits>
|
|
#include <optional>
|
|
#include <set>
|
|
#include <span>
|
|
#include <stdexcept>
|
|
#include <vulkan/vulkan_core.h>
|
|
|
|
#include "util/magic_enum.hpp"
|
|
#include "util/types.h"
|
|
|
|
const u32 WIDTH = 800;
|
|
const u32 HEIGHT = 600;
|
|
|
|
const std::array<const char*, 1> deviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
|
|
const std::array<const char*, 1> validationLayers = { "VK_LAYER_KHRONOS_validation" };
|
|
|
|
#ifdef NDEBUG
|
|
const bool enableValidationLayers = false;
|
|
#else
|
|
const bool enableValidationLayers = true;
|
|
#endif
|
|
|
|
fn CreateDebugUtilsMessengerEXT(
|
|
VkInstance instance,
|
|
const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDebugUtilsMessengerEXT* pDebugMessenger
|
|
) -> VkResult {
|
|
auto func = std::bit_cast<PFN_vkCreateDebugUtilsMessengerEXT>(
|
|
vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT")
|
|
);
|
|
|
|
if (func != nullptr)
|
|
return func(instance, pCreateInfo, pAllocator, pDebugMessenger);
|
|
|
|
return VK_ERROR_EXTENSION_NOT_PRESENT;
|
|
}
|
|
|
|
fn DestroyDebugUtilsMessengerEXT(
|
|
VkInstance instance,
|
|
VkDebugUtilsMessengerEXT debugMessenger,
|
|
const VkAllocationCallbacks* pAllocator
|
|
) -> void {
|
|
auto func = std::bit_cast<PFN_vkDestroyDebugUtilsMessengerEXT>(
|
|
vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT")
|
|
);
|
|
|
|
if (func != nullptr)
|
|
func(instance, debugMessenger, pAllocator);
|
|
}
|
|
|
|
struct QueueFamilyIndices {
|
|
std::optional<u32> graphics_family;
|
|
std::optional<u32> present_family;
|
|
|
|
fn isComplete() -> bool { return graphics_family.has_value() && present_family.has_value(); }
|
|
};
|
|
|
|
struct SwapChainSupportDetails {
|
|
VkSurfaceCapabilitiesKHR capabilities;
|
|
std::vector<VkSurfaceFormatKHR> formats;
|
|
std::vector<VkPresentModeKHR> present_modes;
|
|
};
|
|
|
|
class Application {
|
|
public:
|
|
fn run() -> void {
|
|
initWindow();
|
|
initVulkan();
|
|
mainLoop();
|
|
cleanup();
|
|
}
|
|
|
|
private:
|
|
GLFWwindow* mWindow;
|
|
|
|
VkInstance mInstance;
|
|
VkDebugUtilsMessengerEXT mDebugMessenger;
|
|
VkSurfaceKHR mSurface;
|
|
|
|
VkPhysicalDevice mPhysicalDevice = VK_NULL_HANDLE;
|
|
VkDevice mDevice;
|
|
|
|
VkQueue mGraphicsQueue;
|
|
VkQueue mPresentQueue;
|
|
|
|
VkSwapchainKHR mSwapChain;
|
|
std::vector<VkImage> mSwapChainImages;
|
|
VkFormat mSwapChainImageFormat;
|
|
VkExtent2D mSwapChainExtent;
|
|
|
|
fn initWindow() -> void {
|
|
if (glfwInit() == GLFW_FALSE)
|
|
throw std::runtime_error("Failed to initialize GLFW!");
|
|
|
|
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
|
|
glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
|
|
|
|
if (mWindow = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr); mWindow == nullptr)
|
|
throw std::runtime_error("Failed to create GLFW window!");
|
|
}
|
|
|
|
fn initVulkan() -> void {
|
|
createInstance();
|
|
setupDebugMessenger();
|
|
createSurface();
|
|
pickPhysicalDevice();
|
|
createLogicalDevice();
|
|
createSwapChain();
|
|
}
|
|
|
|
fn mainLoop() -> void {
|
|
while (!glfwWindowShouldClose(mWindow)) { glfwPollEvents(); }
|
|
}
|
|
|
|
fn cleanup() -> void {
|
|
vkDestroySwapchainKHR(mDevice, mSwapChain, nullptr);
|
|
vkDestroyDevice(mDevice, nullptr);
|
|
|
|
if (enableValidationLayers)
|
|
DestroyDebugUtilsMessengerEXT(mInstance, mDebugMessenger, nullptr);
|
|
|
|
vkDestroySurfaceKHR(mInstance, mSurface, nullptr);
|
|
vkDestroyInstance(mInstance, nullptr);
|
|
|
|
glfwDestroyWindow(mWindow);
|
|
|
|
glfwTerminate();
|
|
}
|
|
|
|
fn createInstance() -> void {
|
|
if (enableValidationLayers && !checkValidationLayerSupport())
|
|
throw std::runtime_error("validation layers requested, but not available!");
|
|
|
|
VkApplicationInfo appInfo {};
|
|
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
|
|
appInfo.pApplicationName = "Hello Triangle";
|
|
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
|
|
appInfo.pEngineName = "No Engine";
|
|
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
|
|
appInfo.apiVersion = VK_API_VERSION_1_0;
|
|
|
|
VkInstanceCreateInfo createInfo {};
|
|
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
|
createInfo.pApplicationInfo = &appInfo;
|
|
|
|
std::vector<const char*> extensions = getRequiredExtensions();
|
|
|
|
VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo {};
|
|
if (enableValidationLayers) {
|
|
createInfo.enabledLayerCount = static_cast<u32>(validationLayers.size());
|
|
createInfo.ppEnabledLayerNames = validationLayers.data();
|
|
|
|
populateDebugMessengerCreateInfo(debugCreateInfo);
|
|
createInfo.pNext = static_cast<VkDebugUtilsMessengerCreateInfoEXT*>(&debugCreateInfo);
|
|
} else {
|
|
createInfo.enabledLayerCount = 0;
|
|
|
|
createInfo.pNext = nullptr;
|
|
}
|
|
|
|
extensions.emplace_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
|
|
|
|
createInfo.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
|
|
|
|
createInfo.enabledExtensionCount = static_cast<u32>(extensions.size());
|
|
createInfo.ppEnabledExtensionNames = extensions.data();
|
|
|
|
for (const char* extension : extensions) std::cout << extension << std::endl;
|
|
|
|
if (vkCreateInstance(&createInfo, nullptr, &mInstance) != VK_SUCCESS)
|
|
throw std::runtime_error("failed to create instance!");
|
|
}
|
|
|
|
static fn populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo) -> void {
|
|
createInfo = {};
|
|
createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
|
|
createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT |
|
|
VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
|
|
VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
|
|
createInfo.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;
|
|
createInfo.pfnUserCallback = debugCallback;
|
|
}
|
|
|
|
fn setupDebugMessenger() -> void {
|
|
if (!enableValidationLayers)
|
|
return;
|
|
|
|
VkDebugUtilsMessengerCreateInfoEXT createInfo;
|
|
populateDebugMessengerCreateInfo(createInfo);
|
|
|
|
if (CreateDebugUtilsMessengerEXT(mInstance, &createInfo, nullptr, &mDebugMessenger) != VK_SUCCESS)
|
|
throw std::runtime_error("failed to set up debug messenger!");
|
|
}
|
|
|
|
fn createSurface() -> void {
|
|
if (VkResult result = glfwCreateWindowSurface(mInstance, mWindow, nullptr, &mSurface);
|
|
result != VK_SUCCESS)
|
|
throw std::runtime_error(
|
|
"Failed to create window surface! Error: " + string(magic_enum::enum_name(result))
|
|
);
|
|
}
|
|
|
|
fn pickPhysicalDevice() -> void {
|
|
u32 deviceCount = 0;
|
|
vkEnumeratePhysicalDevices(mInstance, &deviceCount, nullptr);
|
|
|
|
if (deviceCount == 0)
|
|
throw std::runtime_error("failed to find GPUs with Vulkan support!");
|
|
|
|
std::vector<VkPhysicalDevice> devices(deviceCount);
|
|
vkEnumeratePhysicalDevices(mInstance, &deviceCount, devices.data());
|
|
|
|
for (const auto& device : devices)
|
|
if (isDeviceSuitable(device)) {
|
|
mPhysicalDevice = device;
|
|
break;
|
|
}
|
|
|
|
if (mPhysicalDevice == VK_NULL_HANDLE)
|
|
throw std::runtime_error("failed to find a suitable GPU!");
|
|
}
|
|
|
|
fn createLogicalDevice() -> void {
|
|
QueueFamilyIndices indices = findQueueFamilies(mPhysicalDevice);
|
|
|
|
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
|
|
std::set<u32> uniqueQueueFamilies = { indices.graphics_family.value(), indices.present_family.value() };
|
|
|
|
f32 queuePriority = 1.0F;
|
|
for (u32 queueFamily : uniqueQueueFamilies) {
|
|
VkDeviceQueueCreateInfo queueCreateInfo {};
|
|
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
|
|
queueCreateInfo.queueFamilyIndex = queueFamily;
|
|
queueCreateInfo.queueCount = 1;
|
|
queueCreateInfo.pQueuePriorities = &queuePriority;
|
|
queueCreateInfos.push_back(queueCreateInfo);
|
|
}
|
|
|
|
VkPhysicalDeviceFeatures deviceFeatures {};
|
|
|
|
VkDeviceCreateInfo createInfo {};
|
|
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
|
|
|
|
createInfo.queueCreateInfoCount = static_cast<u32>(queueCreateInfos.size());
|
|
createInfo.pQueueCreateInfos = queueCreateInfos.data();
|
|
|
|
createInfo.pEnabledFeatures = &deviceFeatures;
|
|
|
|
createInfo.enabledExtensionCount = static_cast<u32>(deviceExtensions.size());
|
|
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
|
|
|
|
if (enableValidationLayers) {
|
|
createInfo.enabledLayerCount = static_cast<u32>(validationLayers.size());
|
|
createInfo.ppEnabledLayerNames = validationLayers.data();
|
|
} else {
|
|
createInfo.enabledLayerCount = 0;
|
|
}
|
|
|
|
if (vkCreateDevice(mPhysicalDevice, &createInfo, nullptr, &mDevice) != VK_SUCCESS) {
|
|
throw std::runtime_error("failed to create logical device!");
|
|
}
|
|
|
|
vkGetDeviceQueue(mDevice, indices.graphics_family.value(), 0, &mGraphicsQueue);
|
|
vkGetDeviceQueue(mDevice, indices.present_family.value(), 0, &mPresentQueue);
|
|
}
|
|
|
|
fn createSwapChain() -> void {
|
|
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(mPhysicalDevice);
|
|
|
|
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
|
|
VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.present_modes);
|
|
VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities);
|
|
|
|
u32 imageCount = swapChainSupport.capabilities.minImageCount + 1;
|
|
if (swapChainSupport.capabilities.maxImageCount > 0 &&
|
|
imageCount > swapChainSupport.capabilities.maxImageCount)
|
|
imageCount = swapChainSupport.capabilities.maxImageCount;
|
|
|
|
VkSwapchainCreateInfoKHR createInfo {};
|
|
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
|
|
createInfo.surface = mSurface;
|
|
createInfo.minImageCount = imageCount;
|
|
createInfo.imageFormat = surfaceFormat.format;
|
|
createInfo.imageColorSpace = surfaceFormat.colorSpace;
|
|
createInfo.imageExtent = extent;
|
|
createInfo.imageArrayLayers = 1;
|
|
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
|
|
QueueFamilyIndices indices = findQueueFamilies(mPhysicalDevice);
|
|
std::array<u32, 2> queueFamilyIndices = { indices.graphics_family.value(),
|
|
indices.present_family.value() };
|
|
|
|
if (indices.graphics_family != indices.present_family) {
|
|
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
|
|
createInfo.queueFamilyIndexCount = 2;
|
|
createInfo.pQueueFamilyIndices = queueFamilyIndices.data();
|
|
} else {
|
|
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
createInfo.queueFamilyIndexCount = 0; // Optional
|
|
createInfo.pQueueFamilyIndices = nullptr; // Optional
|
|
}
|
|
|
|
createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
|
|
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
|
|
createInfo.presentMode = presentMode;
|
|
createInfo.clipped = VK_TRUE;
|
|
createInfo.oldSwapchain = VK_NULL_HANDLE;
|
|
|
|
if (vkCreateSwapchainKHR(mDevice, &createInfo, nullptr, &mSwapChain) != VK_SUCCESS)
|
|
throw std::runtime_error("Failed to create swap chain!");
|
|
|
|
vkGetSwapchainImagesKHR(mDevice, mSwapChain, &imageCount, nullptr);
|
|
mSwapChainImages.resize(imageCount);
|
|
vkGetSwapchainImagesKHR(mDevice, mSwapChain, &imageCount, mSwapChainImages.data());
|
|
|
|
mSwapChainImageFormat = surfaceFormat.format;
|
|
mSwapChainExtent = extent;
|
|
}
|
|
|
|
static fn chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats
|
|
) -> VkSurfaceFormatKHR {
|
|
for (const auto& availableFormat : availableFormats) {
|
|
if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB &&
|
|
availableFormat.colorSpace == VK_COLORSPACE_SRGB_NONLINEAR_KHR)
|
|
return availableFormat;
|
|
}
|
|
|
|
return availableFormats[0];
|
|
}
|
|
|
|
static fn chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes
|
|
) -> VkPresentModeKHR {
|
|
for (const auto& availablePresentMode : availablePresentModes)
|
|
if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR)
|
|
return availablePresentMode;
|
|
|
|
return VK_PRESENT_MODE_FIFO_KHR;
|
|
}
|
|
|
|
fn chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities) -> VkExtent2D {
|
|
if (capabilities.currentExtent.width != std::numeric_limits<u32>::max()) {
|
|
return capabilities.currentExtent;
|
|
}
|
|
|
|
int width = 0, height = 0;
|
|
glfwGetFramebufferSize(mWindow, &width, &height);
|
|
|
|
VkExtent2D actualExtent = { static_cast<u32>(width), static_cast<u32>(height) };
|
|
|
|
actualExtent.width =
|
|
std::clamp(actualExtent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
|
|
actualExtent.height =
|
|
std::clamp(actualExtent.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);
|
|
|
|
return actualExtent;
|
|
}
|
|
|
|
fn querySwapChainSupport(VkPhysicalDevice device) -> SwapChainSupportDetails {
|
|
SwapChainSupportDetails details;
|
|
|
|
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, mSurface, &details.capabilities);
|
|
|
|
u32 formatCount = 0;
|
|
vkGetPhysicalDeviceSurfaceFormatsKHR(device, mSurface, &formatCount, nullptr);
|
|
|
|
if (formatCount != 0) {
|
|
details.formats.resize(formatCount);
|
|
vkGetPhysicalDeviceSurfaceFormatsKHR(device, mSurface, &formatCount, details.formats.data());
|
|
}
|
|
|
|
u32 presentModeCount = 0;
|
|
vkGetPhysicalDeviceSurfacePresentModesKHR(device, mSurface, &presentModeCount, nullptr);
|
|
|
|
if (presentModeCount != 0) {
|
|
details.present_modes.resize(presentModeCount);
|
|
vkGetPhysicalDeviceSurfacePresentModesKHR(
|
|
device, mSurface, &presentModeCount, details.present_modes.data()
|
|
);
|
|
}
|
|
|
|
return details;
|
|
}
|
|
|
|
fn isDeviceSuitable(VkPhysicalDevice device) -> bool {
|
|
QueueFamilyIndices indices = findQueueFamilies(device);
|
|
|
|
const bool extensionsSupported = checkDeviceExtensionSupport(device);
|
|
|
|
bool swapChainAdequate = false;
|
|
|
|
if (extensionsSupported) {
|
|
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);
|
|
swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.present_modes.empty();
|
|
}
|
|
|
|
return indices.isComplete() && extensionsSupported && swapChainAdequate;
|
|
}
|
|
|
|
static fn checkDeviceExtensionSupport(VkPhysicalDevice device) -> bool {
|
|
u32 extensionCount = 0;
|
|
vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);
|
|
|
|
std::vector<VkExtensionProperties> availableExtensions(extensionCount);
|
|
vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, availableExtensions.data());
|
|
|
|
std::set<string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
|
|
|
|
for (const VkExtensionProperties& extension : availableExtensions)
|
|
requiredExtensions.erase(static_cast<const char*>(extension.extensionName));
|
|
|
|
return requiredExtensions.empty();
|
|
}
|
|
|
|
fn findQueueFamilies(VkPhysicalDevice device) -> QueueFamilyIndices {
|
|
QueueFamilyIndices indices;
|
|
|
|
u32 queueFamilyCount = 0;
|
|
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
|
|
|
|
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
|
|
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
|
|
|
|
u32 idx = 0;
|
|
|
|
for (const auto& queueFamily : queueFamilies) {
|
|
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
|
|
indices.graphics_family = idx;
|
|
|
|
VkBool32 presentSupport = false;
|
|
vkGetPhysicalDeviceSurfaceSupportKHR(device, idx, mSurface, &presentSupport);
|
|
|
|
if (presentSupport)
|
|
indices.present_family = idx;
|
|
|
|
if (indices.isComplete())
|
|
break;
|
|
|
|
idx++;
|
|
}
|
|
|
|
return indices;
|
|
}
|
|
|
|
static fn getRequiredExtensions() -> std::vector<const char*> {
|
|
u32 glfwExtensionCount = 0;
|
|
const char** glfwExtensions = nullptr;
|
|
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
|
|
|
|
std::vector<const char*> extensions;
|
|
if (glfwExtensions) {
|
|
std::span<const char*> extSpan(glfwExtensions, glfwExtensionCount);
|
|
extensions.assign(extSpan.begin(), extSpan.end());
|
|
}
|
|
|
|
if (enableValidationLayers)
|
|
extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
|
|
|
|
return extensions;
|
|
}
|
|
|
|
static fn checkValidationLayerSupport() -> bool {
|
|
u32 layerCount = 0;
|
|
vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
|
|
|
|
std::vector<VkLayerProperties> availableLayers(layerCount);
|
|
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
|
|
|
|
for (const char* layerName : validationLayers) {
|
|
bool layerFound = false;
|
|
|
|
for (const auto& layerProperties : availableLayers) {
|
|
if (strcmp(layerName, static_cast<const char*>(layerProperties.layerName)) == 0) {
|
|
layerFound = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!layerFound)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static VKAPI_ATTR fn VKAPI_CALL debugCallback(
|
|
VkDebugUtilsMessageSeverityFlagBitsEXT /*messageSeverity*/,
|
|
VkDebugUtilsMessageTypeFlagsEXT /*messageType*/,
|
|
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
|
|
void* /*pUserData*/
|
|
) -> VkBool32 {
|
|
fmt::println("Validation Layer: {}", pCallbackData->pMessage);
|
|
|
|
return VK_FALSE;
|
|
}
|
|
};
|
|
|
|
fn main() -> i32 {
|
|
Application app;
|
|
|
|
try {
|
|
app.run();
|
|
} catch (const std::exception& e) {
|
|
std::cerr << e.what() << std::endl;
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|