306 lines
9.2 KiB
C++
306 lines
9.2 KiB
C++
#define GLFW_INCLUDE_NONE
|
|
#define GLFW_INCLUDE_VULKAN
|
|
#include <GLFW/glfw3.h>
|
|
#include <cstdlib>
|
|
#include <fmt/format.h>
|
|
#include <iostream>
|
|
#include <set>
|
|
#include <stdexcept>
|
|
|
|
#define VULKAN_HPP_NO_CONSTRUCTORS
|
|
#include <vulkan/vulkan.hpp>
|
|
|
|
#include "util/magic_enum.hpp"
|
|
#include "util/types.h"
|
|
|
|
namespace vk {
|
|
using DebugUtilsMessengerUnique = vk::UniqueHandle<vk::DebugUtilsMessengerEXT, vk::DispatchLoaderDynamic>;
|
|
}
|
|
|
|
constexpr int WIDTH = 800;
|
|
constexpr int HEIGHT = 600;
|
|
|
|
constexpr std::array<const char*, 1> validationLayers = { "VK_LAYER_KHRONOS_validation" };
|
|
|
|
#ifdef NDEBUG
|
|
constexpr bool enableValidationLayers = false;
|
|
#else
|
|
constexpr bool enableValidationLayers = true;
|
|
#endif
|
|
|
|
class VulkanApp {
|
|
public:
|
|
fn run() -> void {
|
|
initWindow();
|
|
initVulkan();
|
|
mainLoop();
|
|
cleanup();
|
|
}
|
|
|
|
private:
|
|
GLFWwindow* mWindow;
|
|
|
|
vk::UniqueInstance mInstance;
|
|
|
|
vk::DebugUtilsMessengerUnique mDebugMessenger;
|
|
vk::DispatchLoaderDynamic mLoader;
|
|
|
|
vk::PhysicalDevice mPhysicalDevice;
|
|
vk::UniqueDevice mDevice;
|
|
|
|
vk::Queue mGraphicsQueue;
|
|
vk::Queue mPresentQueue;
|
|
|
|
vk::UniqueSurfaceKHR mSurface;
|
|
|
|
struct QueueFamilyIndices {
|
|
std::optional<u32> graphics_family;
|
|
std::optional<u32> present_family;
|
|
|
|
fn isComplete() -> bool { return graphics_family.has_value() && present_family.has_value(); }
|
|
};
|
|
|
|
fn initWindow() -> void {
|
|
glfwInit();
|
|
|
|
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
|
|
glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
|
|
|
|
mWindow = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr);
|
|
}
|
|
|
|
fn initVulkan() -> void {
|
|
createInstance();
|
|
setupDebugMessenger();
|
|
createSurface();
|
|
pickPhysicalDevice();
|
|
createLogicalDevice();
|
|
}
|
|
|
|
fn mainLoop() -> void {
|
|
while (!glfwWindowShouldClose(mWindow)) { glfwPollEvents(); }
|
|
}
|
|
|
|
fn cleanup() -> void {
|
|
glfwDestroyWindow(mWindow);
|
|
glfwTerminate();
|
|
}
|
|
|
|
fn createInstance() -> void {
|
|
if (enableValidationLayers && !checkValidationLayerSupport())
|
|
throw std::runtime_error("validation layers requested, but not available!");
|
|
|
|
vk::ApplicationInfo appInfo { .pApplicationName = "Hello Triangle",
|
|
.applicationVersion = 1,
|
|
.pEngineName = "No Engine",
|
|
.engineVersion = 1,
|
|
.apiVersion = VK_API_VERSION_1_0 };
|
|
|
|
// Retrieve extensions using custom function
|
|
std::vector<const char*> extensions = getRequiredExtensions();
|
|
|
|
// Enable the portability extension and set flags
|
|
extensions.push_back("VK_KHR_portability_enumeration");
|
|
extensions.push_back("VK_KHR_get_physical_device_properties2");
|
|
|
|
vk::InstanceCreateInfo createInfo {
|
|
.flags = vk::InstanceCreateFlagBits::eEnumeratePortabilityKHR,
|
|
.pApplicationInfo = &appInfo,
|
|
.enabledLayerCount = enableValidationLayers ? static_cast<uint32_t>(validationLayers.size()) : 0,
|
|
.ppEnabledLayerNames = enableValidationLayers ? validationLayers.data() : nullptr,
|
|
.enabledExtensionCount = static_cast<uint32_t>(extensions.size()),
|
|
.ppEnabledExtensionNames = extensions.data()
|
|
};
|
|
|
|
#ifndef NDEBUG
|
|
fmt::println("Available extensions:");
|
|
|
|
for (const char* extension : extensions) fmt::println("\t{}", extension);
|
|
#endif
|
|
|
|
try {
|
|
mInstance = vk::createInstanceUnique(createInfo);
|
|
mLoader = vk::DispatchLoaderDynamic(mInstance.get(), vkGetInstanceProcAddr);
|
|
} catch (const vk::SystemError& err) {
|
|
throw std::runtime_error("Failed to create instance: " + std::string(err.what()));
|
|
}
|
|
}
|
|
|
|
fn setupDebugMessenger() -> void {
|
|
if (!enableValidationLayers)
|
|
return;
|
|
|
|
vk::DebugUtilsMessengerCreateInfoEXT messengerCreateInfo {
|
|
.messageSeverity = vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose |
|
|
vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning |
|
|
vk::DebugUtilsMessageSeverityFlagBitsEXT::eError,
|
|
.messageType = vk::DebugUtilsMessageTypeFlagBitsEXT::eGeneral |
|
|
vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation |
|
|
vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance,
|
|
.pfnUserCallback = debugCallback,
|
|
};
|
|
|
|
mDebugMessenger = mInstance->createDebugUtilsMessengerEXTUnique(messengerCreateInfo, nullptr, mLoader);
|
|
}
|
|
|
|
fn createSurface() -> void {
|
|
VkSurfaceKHR surface = nullptr;
|
|
|
|
VkResult result = glfwCreateWindowSurface(mInstance.get(), mWindow, nullptr, &surface);
|
|
|
|
if (result != VK_SUCCESS)
|
|
throw std::runtime_error(
|
|
"Failed to create window surface! Error code: " + string(magic_enum::enum_name(result))
|
|
);
|
|
|
|
mSurface = vk::UniqueSurfaceKHR(surface, mInstance.get());
|
|
}
|
|
|
|
fn pickPhysicalDevice() -> void {
|
|
std::vector<vk::PhysicalDevice> devices = mInstance->enumeratePhysicalDevices();
|
|
|
|
if (devices.empty())
|
|
throw std::runtime_error("Failed to find GPUs with Vulkan support!");
|
|
|
|
#ifndef NDEBUG
|
|
fmt::println("Available devices:");
|
|
#endif
|
|
|
|
for (const auto& device : devices) {
|
|
#ifndef NDEBUG
|
|
vk::PhysicalDeviceProperties properties = device.getProperties();
|
|
fmt::println("Device: {}", properties.deviceName.data());
|
|
#endif
|
|
|
|
if (isDeviceSuitable(device)) {
|
|
mPhysicalDevice = device;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!mPhysicalDevice)
|
|
throw std::runtime_error("Failed to find a suitable GPU!");
|
|
}
|
|
|
|
fn createLogicalDevice() -> void {
|
|
QueueFamilyIndices indices = findQueueFamilies(mPhysicalDevice);
|
|
|
|
std::vector<vk::DeviceQueueCreateInfo> queueCreateInfos;
|
|
std::set<u32> uniqueQueueFamilies = { indices.graphics_family.value(), indices.present_family.value() };
|
|
|
|
f32 queuePriority = 1.0F;
|
|
|
|
for (u32 queueFamily : uniqueQueueFamilies) {
|
|
vk::DeviceQueueCreateInfo queueCreateInfo { .queueFamilyIndex = queueFamily,
|
|
.queueCount = 1,
|
|
.pQueuePriorities = &queuePriority };
|
|
|
|
queueCreateInfos.push_back(queueCreateInfo);
|
|
}
|
|
|
|
vk::PhysicalDeviceFeatures deviceFeatures;
|
|
|
|
// Add the portability subset extension
|
|
std::vector<const char*> deviceExtensions = { "VK_KHR_portability_subset" };
|
|
|
|
vk::DeviceCreateInfo createInfo { .queueCreateInfoCount = static_cast<u32>(queueCreateInfos.size()),
|
|
.pQueueCreateInfos = queueCreateInfos.data(),
|
|
.enabledExtensionCount = static_cast<u32>(deviceExtensions.size()),
|
|
.ppEnabledExtensionNames = deviceExtensions.data(),
|
|
.pEnabledFeatures = &deviceFeatures };
|
|
|
|
mDevice = mPhysicalDevice.createDeviceUnique(createInfo);
|
|
|
|
mGraphicsQueue = mDevice->getQueue(indices.graphics_family.value(), 0);
|
|
mPresentQueue = mDevice->getQueue(indices.present_family.value(), 0);
|
|
}
|
|
|
|
fn isDeviceSuitable(vk::PhysicalDevice device) -> bool {
|
|
QueueFamilyIndices indices = findQueueFamilies(device);
|
|
|
|
return indices.isComplete();
|
|
}
|
|
|
|
fn findQueueFamilies(vk::PhysicalDevice device) -> QueueFamilyIndices {
|
|
QueueFamilyIndices indices;
|
|
|
|
std::vector<vk::QueueFamilyProperties> queueFamilies = device.getQueueFamilyProperties();
|
|
|
|
for (u32 i = 0; i < queueFamilies.size(); i++) {
|
|
if (queueFamilies[i].queueFlags & vk::QueueFlagBits::eGraphics)
|
|
indices.graphics_family = i;
|
|
|
|
vk::Bool32 presentSupport = device.getSurfaceSupportKHR(i, mSurface.get());
|
|
|
|
if (presentSupport)
|
|
indices.present_family = i;
|
|
|
|
if (indices.isComplete())
|
|
break;
|
|
}
|
|
|
|
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");
|
|
|
|
return extensions;
|
|
}
|
|
|
|
static fn checkValidationLayerSupport() -> bool {
|
|
std::vector<vk::LayerProperties> availableLayers = vk::enumerateInstanceLayerProperties();
|
|
|
|
for (const char* layerName : validationLayers) {
|
|
bool layerFound = false;
|
|
|
|
for (const auto& layerProperties : availableLayers)
|
|
if (strcmp(layerName, 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*/
|
|
) -> vk::Bool32 {
|
|
fmt::println("Validation layer: {}", pCallbackData->pMessage);
|
|
|
|
return VK_FALSE;
|
|
}
|
|
};
|
|
|
|
fn main() -> i32 {
|
|
VulkanApp app;
|
|
|
|
try {
|
|
app.run();
|
|
} catch (const std::exception& e) {
|
|
std::cerr << e.what() << std::endl;
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|