summaryrefslogtreecommitdiff
path: root/main.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'main.cpp')
-rw-r--r--main.cpp555
1 files changed, 555 insertions, 0 deletions
diff --git a/main.cpp b/main.cpp
new file mode 100644
index 0000000..07c54a2
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,555 @@
+// Coding along: https://docs.vulkan.org/tutorial/
+
+#define GLFW_INCLUDE_VULKAN
+#include <GLFW/glfw3.h>
+
+#include <iostream>
+#include <stdexcept>
+#include <cstdlib>
+#include <vector>
+#include <cstring>
+#include <optional>
+#include <set>
+#include <cstdint>
+#include <limits>
+#include <algorithm>
+
+const uint32_t WIDTH = 800;
+const uint32_t HEIGHT = 600;
+
+const std::vector<const char*> validationLayers = {
+ "VK_LAYER_KHRONOS_validation"
+};
+
+#ifdef NDEBUG
+ const bool enableValidationLayers = false;
+#else
+ const bool enableValidationLayers = true;
+#endif
+
+class HelloTriangleApplication {
+
+public:
+
+ void run() {
+ initWindow();
+ initVulkan();
+ mainLoop();
+ cleanup();
+ }
+
+private:
+
+ const std::vector<const char*> deviceExtensions = {
+ VK_KHR_SWAPCHAIN_EXTENSION_NAME
+ };
+
+ GLFWwindow* window;
+ VkInstance instance;
+ VkDebugUtilsMessengerEXT debugMessenger;
+ VkSurfaceKHR surface;
+
+ VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
+ VkDevice device;
+
+ VkQueue graphicsQueue;
+ VkQueue presentQueue;
+
+ VkSwapchainKHR swapChain;
+ std::vector<VkImage> swapChainImages;
+ VkFormat swapChainImageFormat;
+ VkExtent2D swapChainExtent;
+
+ std::vector<VkImageView> swapChainImageViews;
+
+ 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;
+ }
+
+ 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;
+ }
+
+ void initWindow() {
+ std::cout << enableValidationLayers << std::endl;
+ glfwInit();
+ glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+ glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
+ window = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr);
+ }
+ void initVulkan() {
+ createInstance(); // 01 Setup -> Instance
+ setupDebugMessenger(); // 02 Setup -> Validation Layers
+ createSurface(); // 05 Presentation -> Window surface
+ pickPhysicalDevice(); // 03 Setup -> Physical Device
+ createLogicalDevice(); // 04 Setup -> Logical Device
+ createSwapChain(); // 06 Presentation -> Swap Chain
+ createImageViews(); // 07 Presentation -> Image Views
+ createGraphicsPipeline(); // 08 Graphics Pipeline -> Introduction
+
+ }
+
+ void createGraphicsPipeline() {
+
+ }
+
+ void createImageViews() {
+ swapChainImageViews.resize(swapChainImages.size());
+ for (size_t i = 0; i < swapChainImages.size(); i++) {
+ std::cout << "Swap Chain Image: " << i << std::endl;
+ VkImageViewCreateInfo createInfo{};
+ createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+ createInfo.image = swapChainImages[i];
+ createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+ createInfo.format = swapChainImageFormat;
+ createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
+ createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
+ createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
+ createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
+ createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+ createInfo.subresourceRange.baseMipLevel = 0;
+ createInfo.subresourceRange.levelCount = 1;
+ createInfo.subresourceRange.baseArrayLayer = 0;
+ createInfo.subresourceRange.layerCount = 1;
+ if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS) {
+ throw std::runtime_error("failed to create image views!");
+ }
+ }
+ }
+
+ void createSwapChain() {
+ SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice);
+
+ VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
+ VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
+ VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities);
+
+ uint32_t 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 = surface;
+ 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(physicalDevice);
+ uint32_t queueFamilyIndices[] = {indices.graphicsFamily.value(), indices.presentFamily.value()};
+
+ if (indices.graphicsFamily != indices.presentFamily) {
+ createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
+ createInfo.queueFamilyIndexCount = 2;
+ createInfo.pQueueFamilyIndices = queueFamilyIndices;
+ } 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(device, &createInfo, nullptr, &swapChain) != VK_SUCCESS) {
+ throw std::runtime_error("failed to create swap chain!");
+ }
+
+ vkGetSwapchainImagesKHR(device, swapChain, &imageCount, nullptr);
+ swapChainImages.resize(imageCount);
+ vkGetSwapchainImagesKHR(device, swapChain, &imageCount, swapChainImages.data());
+ swapChainImageFormat = surfaceFormat.format;
+ swapChainExtent = extent;
+ }
+
+ void createSurface() {
+ if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS) {
+ throw std::runtime_error("failed to create window surface!");
+ }
+ }
+
+ void createLogicalDevice() {
+ QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
+
+ VkDeviceQueueCreateInfo queueCreateInfo{};
+ queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+ queueCreateInfo.queueFamilyIndex = indices.graphicsFamily.value();
+ queueCreateInfo.queueCount = 1;
+ float queuePriority = 1.0f;
+ queueCreateInfo.pQueuePriorities = &queuePriority;
+
+ VkPhysicalDeviceFeatures deviceFeatures{};
+ VkDeviceCreateInfo createInfo{};
+
+ createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+ createInfo.pQueueCreateInfos = &queueCreateInfo;
+ createInfo.queueCreateInfoCount = 1;
+ createInfo.pEnabledFeatures = &deviceFeatures;
+ createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
+ createInfo.ppEnabledExtensionNames = deviceExtensions.data();
+
+ // for backward compat.
+ if (enableValidationLayers) {
+ createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
+ createInfo.ppEnabledLayerNames = validationLayers.data();
+ } else {
+ createInfo.enabledLayerCount = 0;
+ }
+
+ std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
+ std::set<uint32_t> uniqueQueueFamilies = {indices.graphicsFamily.value(), indices.presentFamily.value()};
+
+ for (uint32_t 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);
+ }
+
+ createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
+ createInfo.pQueueCreateInfos = queueCreateInfos.data();
+
+ if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS) {
+ throw std::runtime_error("failed to create logical device!");
+ }
+ vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
+ vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
+ }
+
+ 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) {
+
+ VkPhysicalDeviceProperties deviceProperties;
+ VkPhysicalDeviceFeatures deviceFeatures;
+
+ vkGetPhysicalDeviceProperties(device, &deviceProperties);
+ vkGetPhysicalDeviceFeatures(device, &deviceFeatures);
+
+ // return deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU && deviceFeatures.geometryShader;
+
+ QueueFamilyIndices indices = findQueueFamilies(device);
+ bool extensionsSupported = checkDeviceExtensionSupport(device);
+
+ bool swapChainAdequate = false;
+ if (extensionsSupported) {
+ SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);
+ swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
+ }
+ return indices.isComplete() && extensionsSupported && swapChainAdequate;
+ }
+
+ bool checkDeviceExtensionSupport(VkPhysicalDevice device) {
+ uint32_t extensionCount;
+ vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);
+
+ std::vector<VkExtensionProperties> availableExtensions(extensionCount);
+ vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, availableExtensions.data());
+
+ std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
+
+ for (const auto& extension : availableExtensions) {
+ std::cout << "Available Device Extension: " << extension.extensionName << std::endl;
+ requiredExtensions.erase(extension.extensionName);
+ }
+
+ return requiredExtensions.empty();
+ }
+
+ 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 mainLoop() {
+ while (!glfwWindowShouldClose(window)) {
+ glfwPollEvents();
+ }
+ }
+
+ void cleanup() {
+ for (auto imageView : swapChainImageViews) {
+ vkDestroyImageView(device, imageView, nullptr);
+ }
+ vkDestroySwapchainKHR(device, swapChain, nullptr);
+ vkDestroyDevice(device, nullptr);
+ if (enableValidationLayers) {
+ DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);
+ }
+ vkDestroySurfaceKHR(instance, surface, 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();
+
+ if (enableValidationLayers) {
+ createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
+ createInfo.ppEnabledLayerNames = validationLayers.data();
+ } else {
+ createInfo.enabledLayerCount = 0;
+ }
+
+ 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!");
+ }
+
+ uint32_t extensionCount = 0;
+ vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
+ std::vector<VkExtensionProperties> extensionslist(extensionCount);
+ vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensionslist.data());
+ std::cout << "available extensions:\n";
+ for (const auto& extension : extensionslist) {
+ std::cout << '\t' << extension.extensionName << '\n';
+ }
+ }
+
+ 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;
+ std::cout << layerName << std::endl;
+ break;
+ }
+ }
+
+ if (!layerFound) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ 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;
+ }
+
+ VkResult CreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pDebugMessenger) {
+ auto func = (PFN_vkCreateDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
+ if (func != nullptr) {
+ return func(instance, pCreateInfo, pAllocator, pDebugMessenger);
+ } else {
+ return VK_ERROR_EXTENSION_NOT_PRESENT;
+ }
+ }
+
+ void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator) {
+ auto func = (PFN_vkDestroyDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
+ if (func != nullptr) {
+ func(instance, debugMessenger, pAllocator);
+ }
+ }
+
+ struct SwapChainSupportDetails {
+ VkSurfaceCapabilitiesKHR capabilities;
+ std::vector<VkSurfaceFormatKHR> formats;
+ std::vector<VkPresentModeKHR> presentModes;
+ };
+
+ SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device) {
+ SwapChainSupportDetails details;
+ vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
+
+ uint32_t formatCount;
+ vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
+
+ if (formatCount != 0) {
+ details.formats.resize(formatCount);
+ vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
+ }
+
+ uint32_t presentModeCount;
+ vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
+
+ if (presentModeCount != 0) {
+ details.presentModes.resize(presentModeCount);
+ vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
+ }
+
+ return details;
+ }
+
+ struct QueueFamilyIndices {
+ std::optional<uint32_t> graphicsFamily;
+ std::optional<uint32_t> presentFamily;
+ bool isComplete() {
+ return graphicsFamily.has_value() && presentFamily.has_value();
+ }
+ };
+
+ 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;
+ }
+
+ VkBool32 presentSupport = false;
+ vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
+
+ if (presentSupport) {
+ indices.presentFamily = i;
+ }
+
+ if (indices.isComplete()) {
+ break;
+ }
+ i++;
+ }
+
+ return indices;
+ }
+
+ VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats) {
+ for (const auto& availableFormat : availableFormats) {
+ if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
+ return availableFormat;
+ }
+ }
+ return availableFormats[0];
+ }
+
+ VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes) {
+ for (const auto& availablePresentMode : availablePresentModes) {
+ if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR) {
+ return availablePresentMode;
+ }
+ }
+
+ return VK_PRESENT_MODE_FIFO_KHR;
+ }
+
+ VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities) {
+ if (capabilities.currentExtent.width != std::numeric_limits<uint32_t>::max()) {
+ return capabilities.currentExtent;
+ } else {
+ int width, height;
+ glfwGetFramebufferSize(window, &width, &height);
+
+ VkExtent2D actualExtent = {
+ static_cast<uint32_t>(width),
+ static_cast<uint32_t>(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;
+ }
+ }
+
+};
+
+int main() {
+ HelloTriangleApplication app;
+ std::cout << "Miguel's Vulkan" << std::endl;
+ try {
+ app.run();
+ } catch (const std::exception& e) {
+ std::cerr << e.what() << std::endl;
+ return EXIT_FAILURE;
+ }
+ std::cout << "Finito" << std::endl;
+ return EXIT_SUCCESS;
+} \ No newline at end of file
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-08 16:45:43 +0000