Revamp Swapchain

Arcane/src/Arcane/Platform/Vulkan/VulkanContext.cpp

@@ -3,13 +3,44 @@
 #include "Arcane/Core/Application.h"
 #include "VulkanDevice.h"
 #include "VulkanSwapChain.h"
+#include <iostream>
 
 #define VK_USE_PLATFORM_WIN32_KHR
 #include <GLFW/glfw3.h>
 #define GLFW_EXPOSE_NATIVE_WIN32
 #include <GLFW/glfw3native.h>
 
+#ifdef NDEBUG
+	const bool enableValidationLayers = false;
+#else
+	const bool enableValidationLayers = false;
+#endif
+
 namespace Arcane {
+	static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+		VkDebugUtilsMessageTypeFlagsEXT messageType,
+		const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
+		void* pUserData) {
+
+		std::cout << "validation layer: " << pCallbackData->pMessage << std::endl;
+
+		return VK_FALSE;
+	}
+
+	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;
+		}
+	}
+
+	const std::vector<const char*> validationLayers = {
+		"VK_LAYER_KHRONOS_validation"
+	};
+
 
 	VulkanContext::VulkanContext()
 	{
@@ -27,38 +58,105 @@ namespace Arcane {
 		createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
 		createInfo.pApplicationInfo = &appInfo;
 
-		// -- GLFW extensions
-		uint32_t glfwExtensionCount = 0;
-		const char** glfwExtensions;
+		if (enableValidationLayers && !CheckValidationLayerSupport()) {
+			printf("Cant enable validation layers\n");
+		}
 
-		glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
-		createInfo.enabledExtensionCount = glfwExtensionCount;
-		createInfo.ppEnabledExtensionNames = glfwExtensions;
-		createInfo.enabledLayerCount = 0;
+		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;
+		}
+
 		if (vkCreateInstance(&createInfo, nullptr, &m_Instance) != VK_SUCCESS) {
 			printf("Instance Not Created\n");
 		}
 		else {
 			printf("Vulkan Instance Created\n");
 		}
 
+		SetUpDebugMessenger();
+
 		Application& app = Application::Get();
 		GLFWwindow* window = static_cast<GLFWwindow*>(app.GetWindow().GetNativeWindow());
 
-		// Create Window Surface
 		if (glfwCreateWindowSurface(m_Instance, window, nullptr, &m_Surface) != VK_SUCCESS) {
-			printf("Window Surface Not Created\n");
+			printf("Surface Not Created\n");
 		}
 		else {
-			printf("Window Surface Created\n");
+			printf("Surface Created\n");
 		}
 
+		// Create the vulkan devices
 		m_PhysicalDevice = new VulkanPhysicalDevice(m_Surface);
 		m_Device = new VulkanDevice(*m_PhysicalDevice);
+
+		// Setup Swapchain
 		m_SwapChain = new VulkanSwapChain(*m_Device, m_Surface);
 	}
 
+	bool VulkanContext::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;
+					break;
+				}
+			}
+
+			if (!layerFound) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	void VulkanContext::SetUpDebugMessenger()
+	{
+		VkDebugUtilsMessengerCreateInfoEXT 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;
+		createInfo.pUserData = nullptr; // Optional
+
+		if (CreateDebugUtilsMessengerEXT(m_Instance, &createInfo, nullptr, &m_DebugMessenger) != VK_SUCCESS) {
+			printf("failed to set up debug messenger!\n");
+		}
+
+	}
+
+	std::vector<const char*> VulkanContext::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;
+	}
+
 	void VulkanContext::SwapBuffers()
 	{
 		// printf("Swapchain Image index: %d\n", m_SwapChain->GetImageIndex());

Arcane/src/Arcane/Platform/Vulkan/VulkanContext.h

@@ -21,11 +21,16 @@ namespace Arcane {
 		VulkanPhysicalDevice& GetPhysicalDevice() { return *m_PhysicalDevice; }
 		VulkanSwapChain& GetSwapChain() { return *m_SwapChain; }
 		VkSurfaceKHR GetSurface() { return m_Surface; }
+	private:
+		bool CheckValidationLayerSupport();
+		std::vector<const char*> GetRequiredExtensions();
+		void SetUpDebugMessenger();
 	private:
 		inline static VkInstance m_Instance;
 		VkSurfaceKHR m_Surface;
 		VulkanPhysicalDevice* m_PhysicalDevice;
 		VulkanDevice* m_Device;
 		VulkanSwapChain* m_SwapChain;
+		VkDebugUtilsMessengerEXT m_DebugMessenger;
 	};
 }

Arcane/src/Arcane/Platform/Vulkan/VulkanPipeline.cpp

@@ -20,7 +20,6 @@ namespace Arcane {
 		VkVertexInputBindingDescription bindingDescription = static_cast<VulkanVertexDescriptor*>(spec.descriptor)->GetBindingDescription();
 
 		auto attributeDescriptions = static_cast<VulkanVertexDescriptor*>(spec.descriptor)->GetAttributeDescriptions();
-		auto vulkanUniformBufferLayout = static_cast<VulkanUniformBuffer*>(spec.uniformBuffer)->GetLayout();
 
 		// Creating Vertex Shader
 		VkPipelineShaderStageCreateInfo vertShaderStageInfo{};
@@ -109,8 +108,13 @@ namespace Arcane {
 
 		VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
 		pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
-		pipelineLayoutInfo.setLayoutCount = 1;
-		pipelineLayoutInfo.pSetLayouts = &vulkanUniformBufferLayout;
+
+		if (spec.uniformBuffer != nullptr) {
+			auto vulkanUniformBufferLayout = static_cast<VulkanUniformBuffer*>(spec.uniformBuffer)->GetLayout();
+			pipelineLayoutInfo.setLayoutCount = 1;
+			pipelineLayoutInfo.pSetLayouts = &vulkanUniformBufferLayout;
+		}
+
 
 		if (vkCreatePipelineLayout(logicalDevice, &pipelineLayoutInfo, nullptr, &m_PipelineLayout) != VK_SUCCESS) {
 			printf("Pipeline Layout Not Created");

Arcane/src/Arcane/Renderer/Pipeline.h

@@ -8,10 +8,10 @@
 namespace Arcane {
 	struct PipelineSpecification
 	{
-		Shader* shader;
-		RenderPass* renderPass;
-		VertexDescriptor* descriptor;
-		UniformBuffer* uniformBuffer;
+		Shader* shader = nullptr;
+		RenderPass* renderPass = nullptr;
+		VertexDescriptor* descriptor = nullptr;
+		UniformBuffer* uniformBuffer = nullptr;
 	};
 
 	class Pipeline

Arcane/src/Arcane/Renderer/RendererAPI.h

@@ -3,6 +3,7 @@
 #include "Buffer.h"
 #include "Pipeline.h"
 #include "RenderPass.h"
+#include "UniformBuffer.h"
 
 namespace Arcane {
 
@@ -22,6 +23,8 @@ namespace Arcane {
 
 		// Render Functions
 		virtual void RenderTriangle(VertexBuffer* buffer, Pipeline* pipeline) = 0;
+
+		// -- Without Uniform Buffer
 		virtual void RenderQuad(VertexBuffer* buffer, Pipeline* pipeline) = 0;
 
 		// Static Renderer Functions

EnchantingTable/src/EditorLayer.cpp

@@ -70,10 +70,6 @@ void EditorLayer::OnDetach()
 
 void EditorLayer::OnUpdate(float deltaTime)
 {
-	// Test Quad Color
-	glm::vec3 quadColor = {1.0f, 1.0f, 1.0f};
-	m_UniformBuffer->WriteData(glm::value_ptr(quadColor), sizeof(quadColor));
-
 	// Begin a Render pass
 	Arcane::Renderer::BeginRenderPass(m_RenderPass);