add validation layers + debug callback

src/Engine.cpp

@@ -45,9 +45,7 @@ bool Engine::createInstance() {
         .apiVersion = VK_API_VERSION_1_4 // this one is most important
     };
 
-    // get extensions that our windowing library requires
-    uint32_t instanceExtensionsCount = 0;
-    char const* const* instanceExtensions{ SDL_Vulkan_GetInstanceExtensions(&instanceExtensionsCount) };
+    std::vector<const char*> requiredInstanceExtensions = getRequiredInstanceExtensions();
 
     // get all available extensions
     auto extensionProperties = context_.enumerateInstanceExtensionProperties();
@@ -56,23 +54,23 @@ bool Engine::createInstance() {
     std::cout << "Available Vulkan Extensions: " << std::endl;
     for(const auto& extensionProperty : extensionProperties) {
         std::cout << "\t" << extensionProperty.extensionName << std::endl;
-    }
+    } // this would be a logger.debug(...)
 
     // check that all required extensions are available
-    for(uint32_t i = 0; i < instanceExtensionsCount; i++) { // for each extension that we require
+    for(uint32_t i = 0; i < requiredInstanceExtensions.size(); i++) { // for each extension that we require
         bool found = false;
         for(const auto& extensionProperty : extensionProperties) { // see if it matches any extensions that are provided
-            if(strcmp(extensionProperty.extensionName, instanceExtensions[i]) == 0) {
+            if(strcmp(extensionProperty.extensionName, requiredInstanceExtensions[i]) == 0) {
                 found = true;
                 break;
             }
         }
 	    if(!found) {
-            std::cout << "[" << __FUNCTION__ << ": " << __LINE__ << "] Required SDL3 extension not supported: " << instanceExtensions[i] << std::endl;
+            std::cout << "[" << __FUNCTION__ << ": " << __LINE__ << "] Required SDL3 extension not supported: " << requiredInstanceExtensions[i] << std::endl;
             errorCount++;
         } else {
 	        // in case you're curious
-            //std::cout << "[" << __FUNCTION__ << ": " << __LINE__ << "] SDL3 extension located: " << instanceExtensions[i] << std::endl;
+            //std::cout << "[" << __FUNCTION__ << ": " << __LINE__ << "] SDL3 extension located: " << requiredInstanceExtensions[i] << std::endl;
         }
     }
 
@@ -107,15 +105,78 @@ bool Engine::createInstance() {
     }
     
     // if any we had errors then we must exit
-    if(errorCount != 0) return false;
+    if(errorCount != 0) {
+        std::cout << "[" << __FUNCTION__ << ": " << __LINE__ << "] Unable to create Vulkan instance. Error count: " << errorCount << std::endl;
+        return false;
+    }
 
     vk::InstanceCreateInfo instanceCreateInfo {
         .pApplicationInfo = &appInfo,
-        .enabledExtensionCount = instanceExtensionsCount,
-        .ppEnabledExtensionNames = instanceExtensions,
+        .enabledLayerCount = static_cast<uint32_t>(requiredValidationLayers.size()),
+        .ppEnabledLayerNames = requiredValidationLayers.data(),
+        .enabledExtensionCount = static_cast<uint32_t>(requiredInstanceExtensions.size()),
+        .ppEnabledExtensionNames = requiredInstanceExtensions.data()
     };
 
     instance_ = vk::raii::Instance(context_, instanceCreateInfo);
     return (instance_ != nullptr);
 }
 
+std::vector<const char*> Engine::getRequiredInstanceExtensions() {
+
+    // get extensions that our windowing library requires
+    uint32_t sdlExtensionsCount = 0;
+    const char* const* sdlExtensions{ SDL_Vulkan_GetInstanceExtensions(&sdlExtensionsCount) };
+    // what in the world is this kind of pointer btw
+
+    std::vector<const char*> requiredExtensions(sdlExtensions, sdlExtensions + static_cast<size_t>(sdlExtensionsCount));
+
+    // manually add an extension for handling validation layers
+    if(enableValidationLayers) {
+        requiredExtensions.push_back(vk::EXTDebugUtilsExtensionName);
+    }
+
+    return requiredExtensions;
+}
+
+bool Engine::initDebugMessenger() {
+
+    if(!enableValidationLayers) return false;
+
+    // masks for which debug messages we want to see
+    vk::DebugUtilsMessageSeverityFlagsEXT severityFlags(vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning | vk::DebugUtilsMessageSeverityFlagBitsEXT::eError);
+    vk::DebugUtilsMessageTypeFlagsEXT messageTypeFlags( vk::DebugUtilsMessageTypeFlagBitsEXT::eGeneral | vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance | vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation);
+    vk::DebugUtilsMessengerCreateInfoEXT debugUtilsMessengerCreateInfoEXT{.messageSeverity = severityFlags,
+                                                                          .messageType     = messageTypeFlags,
+                                                                          .pfnUserCallback = &debugCallback};
+    debugMessenger_ = instance_.createDebugUtilsMessengerEXT( debugUtilsMessengerCreateInfoEXT );
+    // we could get rid of this and just pass all the control to the logger
+    // like: "treat all messages of severity vk::eVerbose as our own DebugVerbosity::Info"
+
+    return (debugMessenger_ != nullptr);
+}
+
+VKAPI_ATTR vk::Bool32 VKAPI_CALL Engine::debugCallback(vk::DebugUtilsMessageSeverityFlagBitsEXT severity,
+                                                              vk::DebugUtilsMessageTypeFlagsEXT type,
+                                                              const vk::DebugUtilsMessengerCallbackDataEXT* pCallbackData,
+                                                              void* pUserData) {
+
+    // this will eventually go through our logger
+    std::cout << "[ Validation Layer ] [Type: " << to_string(type) << "] " <<  pCallbackData->pMessage << std::endl;
+    /*
+    vk severity types:
+    vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose
+    vk::DebugUtilsMessageSeverityFlagBitsEXT::eInfo
+    vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning
+    vk::DebugUtilsMessageSeverityFlagBitsEXT::eError
+
+    vk message types:
+    vk::DebugUtilsMessageTypeFlagBitsEXT::eGeneral
+    vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation
+    vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance
+    */
+
+    // returns whether or not we should abort, we'll always say no
+    return vk::False;
+}
+