Ch02ValidationLayers.diff

diff --git "a/G:\\Java-Dev\\Vulkan-Tutorial-Java\\src\\main\\java\\javavulkantutorial\\Ch01InstanceCreation.java" "b/G:\\Java-Dev\\Vulkan-Tutorial-Java\\src\\main\\java\\javavulkantutorial\\Ch02ValidationLayers.java"
index b20e928..4bf9c62 100644
--- "a/G:\\Java-Dev\\Vulkan-Tutorial-Java\\src\\main\\java\\javavulkantutorial\\Ch01InstanceCreation.java"
+++ "b/G:\\Java-Dev\\Vulkan-Tutorial-Java\\src\\main\\java\\javavulkantutorial\\Ch02ValidationLayers.java"
@@ -2,28 +2,75 @@ package javavulkantutorial;
 
 import org.lwjgl.PointerBuffer;
 import org.lwjgl.system.MemoryStack;
-import org.lwjgl.vulkan.VkApplicationInfo;
-import org.lwjgl.vulkan.VkInstance;
-import org.lwjgl.vulkan.VkInstanceCreateInfo;
+import org.lwjgl.vulkan.*;
 
+import java.nio.IntBuffer;
+import java.nio.LongBuffer;
+import java.util.HashSet;
+import java.util.Set;
+
+import static java.util.stream.Collectors.toSet;
 import static org.lwjgl.glfw.GLFW.*;
-import static org.lwjgl.glfw.GLFW.glfwTerminate;
 import static org.lwjgl.glfw.GLFWVulkan.glfwGetRequiredInstanceExtensions;
+import static org.lwjgl.system.Configuration.DEBUG;
+import static org.lwjgl.system.MemoryStack.stackGet;
 import static org.lwjgl.system.MemoryStack.stackPush;
 import static org.lwjgl.system.MemoryUtil.NULL;
+import static org.lwjgl.vulkan.EXTDebugUtils.*;
 import static org.lwjgl.vulkan.VK10.*;
 
-public class Ch01InstanceCreation {
+public class Ch02ValidationLayers {
 
     private static class HelloTriangleApplication {
 
         private static final int WIDTH = 800;
         private static final int HEIGHT = 600;
 
+        private static final boolean ENABLE_VALIDATION_LAYERS = DEBUG.get(true);
+
+        private static final Set<String> VALIDATION_LAYERS;
+        static {
+            if(ENABLE_VALIDATION_LAYERS) {
+                VALIDATION_LAYERS = new HashSet<>();
+                VALIDATION_LAYERS.add("VK_LAYER_KHRONOS_validation");
+            } else {
+                // We are not going to use it, so we don't create it
+                VALIDATION_LAYERS = null;
+            }
+        }
+
+        private static int debugCallback(int messageSeverity, int messageType, long pCallbackData, long pUserData) {
+
+            VkDebugUtilsMessengerCallbackDataEXT callbackData = VkDebugUtilsMessengerCallbackDataEXT.create(pCallbackData);
+
+            System.err.println("Validation layer: " + callbackData.pMessageString());
+
+            return VK_FALSE;
+        }
+
+        private static int createDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerCreateInfoEXT createInfo,
+                                                        VkAllocationCallbacks allocationCallbacks, LongBuffer pDebugMessenger) {
+
+            if(vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT") != NULL) {
+                return vkCreateDebugUtilsMessengerEXT(instance, createInfo, allocationCallbacks, pDebugMessenger);
+            }
+
+            return VK_ERROR_EXTENSION_NOT_PRESENT;
+        }
+
+        private static void destroyDebugUtilsMessengerEXT(VkInstance instance, long debugMessenger, VkAllocationCallbacks allocationCallbacks) {
+
+            if(vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT") != NULL) {
+                vkDestroyDebugUtilsMessengerEXT(instance, debugMessenger, allocationCallbacks);
+            }
+
+        }
+
         // ======= FIELDS ======= //
 
         private long window;
         private VkInstance instance;
+        private long debugMessenger;
 
         // ======= METHODS ======= //
 
@@ -54,6 +101,7 @@ public class Ch01InstanceCreation {
 
         private void initVulkan() {
             createInstance();
+            setupDebugMessenger();
         }
 
         private void mainLoop() {
@@ -66,6 +114,10 @@ public class Ch01InstanceCreation {
 
         private void cleanup() {
 
+            if(ENABLE_VALIDATION_LAYERS) {
+                destroyDebugUtilsMessengerEXT(instance, debugMessenger, null);
+            }
+
             vkDestroyInstance(instance, null);
 
             glfwDestroyWindow(window);
@@ -75,6 +127,10 @@ public class Ch01InstanceCreation {
 
         private void createInstance() {
 
+            if(ENABLE_VALIDATION_LAYERS && !checkValidationLayerSupport()) {
+                throw new RuntimeException("Validation requested but not supported");
+            }
+
             try(MemoryStack stack = stackPush()) {
 
                 // Use calloc to initialize the structs with 0s. Otherwise, the program can crash due to random values
@@ -93,9 +149,16 @@ public class Ch01InstanceCreation {
                 createInfo.sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO);
                 createInfo.pApplicationInfo(appInfo);
                 // enabledExtensionCount is implicitly set when you call ppEnabledExtensionNames
-                createInfo.ppEnabledExtensionNames(glfwGetRequiredInstanceExtensions());
-                // same with enabledLayerCount
-                createInfo.ppEnabledLayerNames(null);
+                createInfo.ppEnabledExtensionNames(getRequiredExtensions(stack));
+
+                if(ENABLE_VALIDATION_LAYERS) {
+
+                    createInfo.ppEnabledLayerNames(validationLayersAsPointerBuffer(stack));
+
+                    VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo = VkDebugUtilsMessengerCreateInfoEXT.calloc(stack);
+                    populateDebugMessengerCreateInfo(debugCreateInfo);
+                    createInfo.pNext(debugCreateInfo.address());
+                }
 
                 // We need to retrieve the pointer of the created instance
                 PointerBuffer instancePtr = stack.mallocPointer(1);
@@ -108,6 +171,84 @@ public class Ch01InstanceCreation {
             }
         }
 
+        private void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo) {
+            debugCreateInfo.sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT);
+            debugCreateInfo.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);
+            debugCreateInfo.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);
+            debugCreateInfo.pfnUserCallback(HelloTriangleApplication::debugCallback);
+        }
+
+        private void setupDebugMessenger() {
+
+            if(!ENABLE_VALIDATION_LAYERS) {
+                return;
+            }
+
+            try(MemoryStack stack = stackPush()) {
+
+                VkDebugUtilsMessengerCreateInfoEXT createInfo = VkDebugUtilsMessengerCreateInfoEXT.calloc(stack);
+
+                populateDebugMessengerCreateInfo(createInfo);
+
+                LongBuffer pDebugMessenger = stack.longs(VK_NULL_HANDLE);
+
+                if(createDebugUtilsMessengerEXT(instance, createInfo, null, pDebugMessenger) != VK_SUCCESS) {
+                    throw new RuntimeException("Failed to set up debug messenger");
+                }
+
+                debugMessenger = pDebugMessenger.get(0);
+            }
+        }
+
+        private PointerBuffer validationLayersAsPointerBuffer(MemoryStack stack) {
+
+            PointerBuffer buffer = stack.mallocPointer(VALIDATION_LAYERS.size());
+
+            VALIDATION_LAYERS.stream()
+                    .map(stack::UTF8)
+                    .forEach(buffer::put);
+
+            return buffer.rewind();
+        }
+
+        private PointerBuffer getRequiredExtensions(MemoryStack stack) {
+
+            PointerBuffer glfwExtensions = glfwGetRequiredInstanceExtensions();
+
+            if(ENABLE_VALIDATION_LAYERS) {
+
+                PointerBuffer extensions = stack.mallocPointer(glfwExtensions.capacity() + 1);
+
+                extensions.put(glfwExtensions);
+                extensions.put(stack.UTF8(VK_EXT_DEBUG_UTILS_EXTENSION_NAME));
+
+                // Rewind the buffer before returning it to reset its position back to 0
+                return extensions.rewind();
+            }
+
+            return glfwExtensions;
+        }
+
+        private boolean checkValidationLayerSupport() {
+
+            try(MemoryStack stack = stackPush()) {
+
+                IntBuffer layerCount = stack.ints(0);
+
+                vkEnumerateInstanceLayerProperties(layerCount, null);
+
+                VkLayerProperties.Buffer availableLayers = VkLayerProperties.malloc(layerCount.get(0), stack);
+
+                vkEnumerateInstanceLayerProperties(layerCount, availableLayers);
+
+                Set<String> availableLayerNames = availableLayers.stream()
+                        .map(VkLayerProperties::layerNameString)
+                        .collect(toSet());
+
+                return availableLayerNames.containsAll(VALIDATION_LAYERS);
+            }
+        }
+
     }
 
     public static void main(String[] args) {
@@ -116,4 +257,5 @@ public class Ch01InstanceCreation {
 
         app.run();
     }
+
 }