Big changes

engine/src/device.cpp

@@ -21,6 +21,10 @@ debugCallback(vk::DebugUtilsMessageSeverityFlagBitsEXT m_severity,
     return VK_SUCCESS;
   } else if (m_severity == vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning) {
     log::warning(pCallback_data->pMessage);
+  } else if (m_severity == vk::DebugUtilsMessageSeverityFlagBitsEXT::eInfo) {
+    log::info(pCallback_data->pMessage);
+  } else if (m_severity == vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose) {
+    log::verbose(pCallback_data->pMessage);
   } else {
     log::info(pCallback_data->pMessage);
   }
@@ -51,10 +55,16 @@ void destroyDebugUtilsMessengerEXT(VkInstance instance,
   }
 }
 
-Device::Device(Window& window) : window{window} {
+Device::Device(Window* window)
+    : headless{window == nullptr},
+      enabledExtensions{headless ? std::vector<const char*>{}
+                                 : std::vector<const char*>{
+                                       VK_KHR_SWAPCHAIN_EXTENSION_NAME}} {
   createVulkanInstance();
   setupDebugMessenger();
-  this->window.createSurface(*instance, surface);
+  if (!this->headless) {
+    window->createSurface(*instance, surface);
+  }
   pickPhysicalDevice();
   createLogicalDevice();
   createCommandPool();
@@ -70,8 +80,42 @@ Device::~Device() {
   this->device->destroyCommandPool(commandPool);
   log::trace("destroyed vk::CommandPool");
 
-  this->instance->destroySurfaceKHR(surface);
-  log::trace("destroyed vk::SurfaceKHR");
+  if (!this->headless) {
+    this->instance->destroySurfaceKHR(surface);
+    log::trace("destroyed vk::SurfaceKHR");
+  }
+}
+
+Device::Builder& Device::Builder::withWindow(Window& window) {
+  this->window = &window;
+  this->headlessRequested = false;
+  this->modeSet = true;
+  return *this;
+}
+
+Device::Builder& Device::Builder::headless() {
+  this->window = nullptr;
+  this->headlessRequested = true;
+  this->modeSet = true;
+  return *this;
+}
+
+std::unique_ptr<Device> Device::Builder::build() const {
+  if (!this->modeSet) {
+    log::fatal(
+        "failed to build device: neither withWindow() nor headless() was "
+        "called");
+    throw std::runtime_error(
+        "failed to build device: no window/headless mode specified");
+  }
+
+  if (this->headlessRequested) {
+    log::verbose("building headless Device");
+    return std::unique_ptr<Device>(new Device(nullptr));
+  } else {
+    log::verbose("building windowed Device");
+    return std::unique_ptr<Device>(new Device(this->window));
+  }
 }
 
 u32 Device::findMemoryType(u32 typeFilter, vk::MemoryPropertyFlags properties) {
@@ -299,12 +343,14 @@ bool Device::checkValidationLayerSupport() {
 }
 
 std::vector<const char*> Device::getRequiredExtensions() {
-  u32 glfw_extension_count = 0;
-  const char** glfw_extensions;
-  glfw_extensions = glfwGetRequiredInstanceExtensions(&glfw_extension_count);
+  std::vector<const char*> extensions;
 
-  std::vector<const char*> extensions(glfw_extensions,
-                                      glfw_extensions + glfw_extension_count);
+  if (!this->headless) {
+    u32 glfw_extension_count = 0;
+    const char** glfw_extensions =
+        glfwGetRequiredInstanceExtensions(&glfw_extension_count);
+    extensions.assign(glfw_extensions, glfw_extensions + glfw_extension_count);
+  }
 
   if (enableValidationLayers) {
     extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
@@ -381,7 +427,8 @@ QueueFamilyIndices Device::findQueueFamilies(vk::PhysicalDevice device) {
       indices.graphicsFamily = i;
     }
 
-    if (queueFamily.queueCount > 0 && device.getSurfaceSupportKHR(i, surface)) {
+    if (!this->headless && queueFamily.queueCount > 0 &&
+        device.getSurfaceSupportKHR(i, surface)) {
       indices.presentFamily = i;
     }
 
@@ -410,6 +457,10 @@ bool Device::isPhysicalDeviceSuitable(const vk::PhysicalDevice& device) {
 
   bool extensionsSupported = checkDeviceExtensionSupport(device);
 
+  if (this->headless) {
+    return indices.graphicsFamily.has_value() && extensionsSupported;
+  }
+
   bool swapchainAdequate = false;
   if (extensionsSupported) {
     SwapchainSupportDetails swapchainSupport = querySwapchainSupport(device);
@@ -450,10 +501,12 @@ void Device::pickPhysicalDevice() {
 void Device::createLogicalDevice() {
   QueueFamilyIndices indices = findQueueFamilies(this->physicalDevice);
 
-  std::vector<vk::DeviceQueueCreateInfo> queueCreateInfos;
-  std::set<uint32_t> uniqueQueueFamilies = {indices.graphicsFamily.value(),
-                                            indices.presentFamily.value()};
+  std::set<uint32_t> uniqueQueueFamilies = {indices.graphicsFamily.value()};
+  if (!this->headless) {
+    uniqueQueueFamilies.insert(indices.presentFamily.value());
+  }
 
+  std::vector<vk::DeviceQueueCreateInfo> queueCreateInfos;
   float queuePriority = 1.0f;
 
   for (uint32_t queueFamily : uniqueQueueFamilies) {
@@ -461,11 +514,15 @@ void Device::createLogicalDevice() {
         {vk::DeviceQueueCreateFlags(), queueFamily, 1, &queuePriority});
   }
 
+  vk::PhysicalDeviceVulkan13Features vulkan13Features{};
+  vulkan13Features.dynamicRendering = vk::True;
+
   auto deviceFeatures = vk::PhysicalDeviceFeatures();
   auto createInfo = vk::DeviceCreateInfo(
       vk::DeviceCreateFlags(), static_cast<uint32_t>(queueCreateInfos.size()),
       queueCreateInfos.data());
   createInfo.pEnabledFeatures = &deviceFeatures;
+  createInfo.pNext = &vulkan13Features;
 
   createInfo.enabledExtensionCount =
       static_cast<uint32_t>(this->enabledExtensions.size());
@@ -480,7 +537,9 @@ void Device::createLogicalDevice() {
   }
 
   this->graphicsQueue = device->getQueue(indices.graphicsFamily.value(), 0);
-  this->presentQueue = device->getQueue(indices.presentFamily.value(), 0);
+  if (!this->headless) {
+    this->presentQueue = device->getQueue(indices.presentFamily.value(), 0);
+  }
 }
 
 SwapchainSupportDetails Device::querySwapchainSupport(