auto func = (PFN_vkCreateDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");

if (func != nullptr) {

return func(instance, pCreateInfo, pAllocator, pDebugMessenger);

} else {

return VK_ERROR_EXTENSION_NOT_PRESENT;

}

auto func = (PFN_vkDestroyDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");

if (func != nullptr) {

func(instance, debugMessenger, pAllocator);

}

std::optional<uint32_t> graphicsFamily;

bool isComplete() {

return graphicsFamily.has_value();

}

void run() {

initWindow();

initVulkan();

mainLoop();

cleanup();

}

GLFWwindow* window;

VkInstance instance;

VkDebugUtilsMessengerEXT debugMessenger;

VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;

void initWindow() {

glfwInit();

glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);

glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);

window = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr);

}

void initVulkan() {

createInstance();

setupDebugMessenger();

pickPhysicalDevice();

}

void mainLoop() {

while (!glfwWindowShouldClose(window)) {

glfwPollEvents();

}

}

void cleanup() {

if (enableValidationLayers) {

DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);

}

vkDestroyInstance(instance, nullptr);

glfwDestroyWindow(window);

glfwTerminate();

}

void createInstance() {

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;

auto extensions = getRequiredExtensions();

createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());

createInfo.ppEnabledExtensionNames = extensions.data();

VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo;

if (enableValidationLayers) {

createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());

createInfo.ppEnabledLayerNames = validationLayers.data();

populateDebugMessengerCreateInfo(debugCreateInfo);

createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT*) &debugCreateInfo;

} else {

createInfo.enabledLayerCount = 0;

createInfo.pNext = nullptr;

}

if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {

throw std::runtime_error("failed to create instance!");

}

}

void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo) {

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;

}

void setupDebugMessenger() {

if (!enableValidationLayers) return;

VkDebugUtilsMessengerCreateInfoEXT createInfo;

populateDebugMessengerCreateInfo(createInfo);

if (CreateDebugUtilsMessengerEXT(instance, &createInfo, nullptr, &debugMessenger) != VK_SUCCESS) {

throw std::runtime_error("failed to set up debug messenger!");

}

}

void pickPhysicalDevice() {

uint32_t deviceCount = 0;

vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);

if (deviceCount == 0) {

throw std::runtime_error("failed to find GPUs with Vulkan support!");

}

std::vector<VkPhysicalDevice> devices(deviceCount);

vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());

for (const auto& device : devices) {

if (isDeviceSuitable(device)) {

physicalDevice = device;

break;

}

}

if (physicalDevice == VK_NULL_HANDLE) {

throw std::runtime_error("failed to find a suitable GPU!");

}

}

bool isDeviceSuitable(VkPhysicalDevice device) {

QueueFamilyIndices indices = findQueueFamilies(device);

return indices.isComplete();

}

QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device) {

QueueFamilyIndices indices;

uint32_t queueFamilyCount = 0;

vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);

std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);

vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());

int i = 0;

for (const auto& queueFamily : queueFamilies) {

if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) {

indices.graphicsFamily = i;

}

if (indices.isComplete()) {

break;

}

i++;

}

return indices;

}

std::vector<const char*> getRequiredExtensions() {

uint32_t glfwExtensionCount = 0;

const char** glfwExtensions;

glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);

std::vector<const char*> extensions(glfwExtensions, glfwExtensions + glfwExtensionCount);

if (enableValidationLayers) {

extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);

}

return extensions;

}

bool checkValidationLayerSupport() {

uint32_t layerCount;

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, layerProperties.layerName) == 0) {

layerFound = true;

break;

}

}

if (!layerFound) {

return false;

}

}

return true;

}

static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData) {

std::cerr << "validation layer: " << pCallbackData->pMessage << std::endl;

return VK_FALSE;

}

HelloTriangleApplication app;

try {

app.run();

} catch (const std::exception& e) {

std::cerr << e.what() << std::endl;

return EXIT_FAILURE;

}

return EXIT_SUCCESS;