Initial commit for vulkan tutorial

Following along the first 9 chapters of the Vulkan HelloTriangle
tutorial.

02_validation_layers.cpp

@@ -0,0 +1,125 @@
+#if defined(__INTELLISENSE__) || !defined(USE_CPP20_MODULES)
+#include <vulkan/vulkan_raii.hpp>
+#include <vulkan/vulkan_core.h>
+#else
+import vulkan_hpp;
+#endif
+
+#define GLFW_INCLUDE_VULKAN
+#include <GLFW/glfw3.h>
+#include <iostream>
+#include <vector>
+#include <stdexcept>
+#include <cstdlib>
+#include <cstdint>
+
+constexpr uint32_t WIDTH = 800;
+constexpr uint32_t HEIGHT = 600;
+
+const std::vector<char const *> validationLayers = {
+  "VK_LAYER_KHRONOS_validation"
+};
+
+#ifdef NDEBUG
+constexpr bool enableValidationLayers = false;
+#else
+constexpr bool enableValidationLayers = true;
+#endif
+
+class HelloTriangleApplication {
+  public:
+    void run() {
+      initWindow();
+      initVulkan();
+      mainLoop();
+      cleanup();
+    }
+  private:
+    void initWindow() {
+      glfwInit();
+      // Don't create an OpenGL context
+      glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+      glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
+      window = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr);
+    }
+    void initVulkan() {
+      createInstance();
+    }
+    void mainLoop() {
+      while (!glfwWindowShouldClose(window)) {
+        glfwPollEvents();
+      }
+    }
+    void cleanup() {
+      glfwDestroyWindow(window);
+      glfwTerminate();
+    }
+    void createInstance() {
+      constexpr vk::ApplicationInfo appInfo {
+        .pApplicationName   = "Hello Triangle",
+        .applicationVersion = VK_MAKE_VERSION(1, 0, 0),
+        .pEngineName        = "No Engine",
+        .engineVersion      = VK_MAKE_VERSION(1, 0, 0),
+        .apiVersion         = vk::ApiVersion14,
+      };
+
+      // Get the required layers
+      std::vector<char const*> requiredLayers;
+      if (enableValidationLayers) {
+        requiredLayers.assign(validationLayers.begin(), validationLayers.end());
+      }
+
+      // Check if the required layers are supported by the Vulkan implementation.
+      auto layerProperties = context.enumerateInstanceLayerProperties();
+      if (std::ranges::any_of(requiredLayers, [&layerProperties](auto const& requiredLayer) {
+        return std::ranges::none_of(layerProperties,
+                                   [requiredLayer](auto const& layerProperty)
+                                   { return strcmp(layerProperty.layerName, requiredLayer) == 0; });
+      }))
+      {
+        throw std::runtime_error("One or more required layers are not supported!");
+      }
+
+      // Get the required instance extensions from GLFW.
+      uint32_t glfwExtensionCount = 0;
+      auto glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
+
+      // Check if the required GLFW extensions are supported by the Vulkan implementation.
+      auto extensionProperties = context.enumerateInstanceExtensionProperties();
+      for (uint32_t i = 0; i < glfwExtensionCount; ++i)
+      {
+        if (std::ranges::none_of(extensionProperties,
+                                 [glfwExtension = glfwExtensions[i]](auto const& extensionProperty)
+                                 { return strcmp(extensionProperty.extensionName, glfwExtension) == 0; }))
+        {
+          throw std::runtime_error("Required GLFW extension not supported: " + std::string(glfwExtensions[i]));
+        }
+      }
+      vk::InstanceCreateInfo createInfo {
+        .pApplicationInfo        = &appInfo,
+        .enabledLayerCount       = static_cast<uint32_t>(requiredLayers.size()),
+        .ppEnabledLayerNames     = requiredLayers.data(),
+        .enabledExtensionCount   = glfwExtensionCount,
+        .ppEnabledExtensionNames = glfwExtensions,
+      };
+
+      instance = vk::raii::Instance(context, createInfo);
+    }
+
+    GLFWwindow *window;
+    vk::raii::Context  context;
+    vk::raii::Instance instance = nullptr;
+};
+
+int main() {
+  HelloTriangleApplication app;
+
+  try {
+    app.run();
+  } catch (const std::exception &e) {
+    std::cout << e.what() << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_SUCCESS;
+}