Properly choose swapchain format

src/renderer.cpp

@@ -18,25 +18,25 @@ Renderer::Renderer() {
     createLogicalDevice();
     createCommandPool();
     createPresentationRenderPass();
-    
+
     worldPass_ = new WorldPass(*this);
 }
 
 Renderer::~Renderer() {
     vkDeviceWaitIdle(device_);
-    
+
     delete worldPass_;
-    
+
     vkDestroyRenderPass(device_, presentationRenderPass_, nullptr);
-    
+
     vkDestroyCommandPool(device_, commandPool_, nullptr);
 
 #ifdef DEBUG
     destroyMessenger_(instance_, messenger_, nullptr);
 #endif
-    
+
     vkDestroyDevice(device_, nullptr);
-    
+
     vkDestroyInstance(instance_, nullptr);
 }
 
@@ -46,7 +46,7 @@ void Renderer::render(RenderTarget* target) {
 
     vkWaitForFences(device_, 1, &target->fences[imageIndex], true, UINT64_MAX);
     vkResetFences(device_, 1, &target->fences[imageIndex]);
-    
+
     const VkCommandBuffer commandBuffer = target->commandBuffers[imageIndex];
 
     VkCommandBufferBeginInfo beginInfo = {};
@@ -58,14 +58,14 @@ void Renderer::render(RenderTarget* target) {
     viewport.width = target->extent.width;
     viewport.height = target->extent.height;
     viewport.maxDepth = 1.0f;
-    
+
     vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
-    
+
     VkRect2D scissor = {};
     scissor.extent = target->extent;
-    
+
     vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
-    
+
     VkClearValue clearColor = {};
     clearColor.color.float32[0] = sin((platform::getTime() / 500.0f) * 0.2f) * 0.5f + 0.5f;
     clearColor.color.float32[1] = sin((platform::getTime() / 500.0f) * 0.4f) * 0.5f + 0.5f;
@@ -80,15 +80,15 @@ void Renderer::render(RenderTarget* target) {
     renderPassBeginInfo.pClearValues = &clearColor;
 
     vkCmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
-    
+
     worldPass_->render(commandBuffer);
-    
+
     vkCmdEndRenderPass(commandBuffer);
-    
+
     vkEndCommandBuffer(commandBuffer);
 
     const VkPipelineStageFlags waitStage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-    
+
     VkSubmitInfo submitInfo = {};
     submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
     submitInfo.waitSemaphoreCount = 1;
@@ -100,7 +100,7 @@ void Renderer::render(RenderTarget* target) {
     submitInfo.pSignalSemaphores = &target->renderFinishedSemaphore;
 
     vkQueueSubmit(graphicsQueue_, 1, &submitInfo, target->fences[imageIndex]);
-    
+
     VkPresentInfoKHR presentInfo = {};
     presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
     presentInfo.waitSemaphoreCount = 1;
@@ -114,30 +114,30 @@ void Renderer::render(RenderTarget* target) {
 
 RenderTarget* Renderer::createSurfaceRenderTarget(VkSurfaceKHR surface, RenderTarget* oldTarget) {
     vkDeviceWaitIdle(device_);
-    
+
     RenderTarget* target = new RenderTarget();
     target->surface = surface;
-    
+
     VkSurfaceCapabilitiesKHR surfaceCapabilities = {};
     vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice_, surface, &surfaceCapabilities);
-    
+
     target->extent = surfaceCapabilities.currentExtent;
-    
+
     uint32_t surfaceFormatCount = 0;
     vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice_, surface, &surfaceFormatCount, nullptr);
-    
+
     VkSurfaceFormatKHR* surfaceFormats = new VkSurfaceFormatKHR[surfaceFormatCount];
     vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice_, surface, &surfaceFormatCount, surfaceFormats);
-    
+
     uint32_t chosenFormat = 0;
     for(uint32_t i = 0; i < surfaceFormatCount; i++) {
-        if(surfaceFormats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
+        if(surfaceFormats[i].format == VK_FORMAT_R8G8B8_SRGB)
             chosenFormat = i;
     }
-    
+
     VkBool32 supported = false;
     vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice_, queueIndices.presentation, surface, &supported);
-    
+
     VkSwapchainCreateInfoKHR swapchainCreateInfo = {};
     swapchainCreateInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
     swapchainCreateInfo.surface = surface;
@@ -156,22 +156,22 @@ RenderTarget* Renderer::createSurfaceRenderTarget(VkSurfaceKHR surface, RenderTa
 
     if(oldTarget)
         swapchainCreateInfo.oldSwapchain = oldTarget->swapchain;
-    
+
     vkCreateSwapchainKHR(device_, &swapchainCreateInfo, nullptr, &target->swapchain);
-        
+
     if(oldTarget)
         destroyRenderTarget(oldTarget);
-    
+
     delete[] surfaceFormats;
-    
+
     uint32_t swapchainImageCount = 0;
     vkGetSwapchainImagesKHR(device_, target->swapchain, &swapchainImageCount, nullptr);
-    
+
     target->numImages = swapchainImageCount;
-    
+
     target->images = new VkImage[swapchainImageCount];
     vkGetSwapchainImagesKHR(device_, target->swapchain, &swapchainImageCount, target->images);
-    
+
     target->imageViews = new VkImageView[swapchainImageCount];
     for(uint32_t i = 0; i < swapchainImageCount; i++) {
         VkImageViewCreateInfo createInfo = {};
@@ -205,23 +205,23 @@ RenderTarget* Renderer::createSurfaceRenderTarget(VkSurfaceKHR surface, RenderTa
     allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
     allocateInfo.commandPool = commandPool_;
     allocateInfo.commandBufferCount = swapchainImageCount;
-    
+
     target->commandBuffers = new VkCommandBuffer[swapchainImageCount];
-    
+
     vkAllocateCommandBuffers(device_, &allocateInfo, target->commandBuffers);
-    
+
     VkSemaphoreCreateInfo semaphoreCreateInfo = {};
     semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
-    
+
     vkCreateSemaphore(device_, &semaphoreCreateInfo, nullptr, &target->imageAvailableSemaphore);
     vkCreateSemaphore(device_, &semaphoreCreateInfo, nullptr, &target->renderFinishedSemaphore);
-    
+
     VkFenceCreateInfo fenceCreateInfo = {};
     fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
     fenceCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
 
     target->fences = new VkFence[swapchainImageCount];
-    
+
     for(uint32_t i = 0; i < swapchainImageCount; i++)
         vkCreateFence(device_, &fenceCreateInfo, nullptr, &target->fences[i]);
 
@@ -230,36 +230,36 @@ RenderTarget* Renderer::createSurfaceRenderTarget(VkSurfaceKHR surface, RenderTa
 
 void Renderer::destroyRenderTarget(RenderTarget* target) {
     vkDeviceWaitIdle(device_);
-    
+
     for(uint32_t i = 0; i < target->numImages; i++)
         vkDestroyFence(device_, target->fences[i], nullptr);
-    
+
     delete[] target->fences;
-    
+
     vkDestroySemaphore(device_, target->renderFinishedSemaphore, nullptr);
     vkDestroySemaphore(device_, target->imageAvailableSemaphore, nullptr);
 
     vkFreeCommandBuffers(device_, commandPool_, target->numImages, target->commandBuffers);
-    
+
     delete[] target->commandBuffers;
-    
+
     for(uint32_t i = 0; i < target->numImages; i++) {
         vkDestroyFramebuffer(device_, target->framebuffers[i], nullptr);
         vkDestroyImageView(device_, target->imageViews[i], nullptr);
     }
-    
+
     delete[] target->framebuffers;
     delete[] target->imageViews;
     delete[] target->images;
-    
+
     vkDestroySwapchainKHR(device_, target->swapchain, nullptr);
-    
+
     delete target;
 }
 
 VkShaderModule Renderer::createShader(const char* path) {
     std::ifstream file(path, std::ios::ate | std::ios::binary);
-    
+
     size_t fileSize = (size_t) file.tellg();
     std::vector<char> buffer(fileSize);
     file.seekg(0);
@@ -280,10 +280,10 @@ VkShaderModule Renderer::createShader(const char* path) {
 void Renderer::createInstance() {
     uint32_t layerCount = 0;
     vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
-    
+
     VkLayerProperties* availableLayers = new VkLayerProperties[layerCount];
     vkEnumerateInstanceLayerProperties(&layerCount, availableLayers);
-    
+
     std::vector<const char*> enabledLayers;
 #ifdef DEBUG
     for(uint32_t i = 0; i < layerCount; i++) {
@@ -293,10 +293,10 @@ void Renderer::createInstance() {
 #endif
 
     delete[] availableLayers;
-    
+
     uint32_t extensionCount = 0;
     vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
-    
+
     VkExtensionProperties* availableExtensions = new VkExtensionProperties[extensionCount];
     vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, availableExtensions);
 
@@ -311,7 +311,7 @@ void Renderer::createInstance() {
 #endif
 
     delete[] availableExtensions;
-    
+
     auto requiredExtensions = platform::getRequiredExtensions();
     enabledExtensions.insert(enabledExtensions.end(), requiredExtensions.begin(), requiredExtensions.end());
 
@@ -321,7 +321,7 @@ void Renderer::createInstance() {
     instanceCreateInfo.ppEnabledLayerNames = enabledLayers.data();
     instanceCreateInfo.enabledExtensionCount = enabledExtensions.size();
     instanceCreateInfo.ppEnabledExtensionNames = enabledExtensions.data();
-    
+
     vkCreateInstance(&instanceCreateInfo, nullptr, &instance_);
 }
 
@@ -336,10 +336,10 @@ void Renderer::createDebugMessenger() {
     messengerCreateInfo.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;
     messengerCreateInfo.pfnUserCallback = [](VkDebugUtilsMessageSeverityFlagBitsEXT, unsigned int, const VkDebugUtilsMessengerCallbackDataEXT* callback, void*) -> unsigned int {
         std::cout << callback->pMessage << std::endl;
-        
+
         return VK_SUCCESS;
     };
-    
+
     createMessenger_(instance_, &messengerCreateInfo, nullptr, &messenger_);
 }
 #endif
@@ -347,59 +347,59 @@ void Renderer::createDebugMessenger() {
 void Renderer::createLogicalDevice() {
     uint32_t physicalDeviceCount = 0;
     vkEnumeratePhysicalDevices(instance_, &physicalDeviceCount, nullptr);
-    
+
     VkPhysicalDevice* physicalDevices = new VkPhysicalDevice[physicalDeviceCount];
     vkEnumeratePhysicalDevices(instance_, &physicalDeviceCount, physicalDevices);
-        
+
     for(uint32_t i = 0; i < physicalDeviceCount; i++) {
         VkPhysicalDeviceProperties properties = {};
         vkGetPhysicalDeviceProperties(physicalDevices[i], &properties);
-    
+
         physicalDevice_ = physicalDevices[i];
     }
-    
+
     delete[] physicalDevices;
-    
+
     uint32_t queueFamilyPropertiesCount = 0;
     vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice_, &queueFamilyPropertiesCount, nullptr);
-    
+
     VkQueueFamilyProperties* queueFamilyProperties = new VkQueueFamilyProperties[queueFamilyPropertiesCount];
     vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice_, &queueFamilyPropertiesCount, queueFamilyProperties);
-        
+
     for(uint32_t i = 0; i < queueFamilyPropertiesCount; i++) {
         if(queueFamilyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)
             queueIndices.graphics = i;
     }
-    
+
     delete[] queueFamilyProperties;
-    
+
     queueIndices.presentation = queueIndices.graphics; //FIXME: this may not always be true!!
-    
+
     const std::set<uint32_t> queueFamilyIndices = {queueIndices.graphics};
     std::vector<VkDeviceQueueCreateInfo> deviceQueueCreateInfos;
     for(auto queueFamilyIndex : queueFamilyIndices) {
         const float priority = 1.0f;
-        
+
         VkDeviceQueueCreateInfo queueCreateInfo = {};
         queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
         queueCreateInfo.queueFamilyIndex = queueFamilyIndex;
         queueCreateInfo.queueCount = 1;
         queueCreateInfo.pQueuePriorities = &priority;
-        
+
         deviceQueueCreateInfos.push_back(queueCreateInfo);
     }
-    
+
     const std::vector<const char*> enabledExtensions = {"VK_KHR_swapchain"};
-    
+
     VkDeviceCreateInfo deviceCreateInfo = {};
     deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
     deviceCreateInfo.queueCreateInfoCount = deviceQueueCreateInfos.size();
     deviceCreateInfo.pQueueCreateInfos = deviceQueueCreateInfos.data();
     deviceCreateInfo.enabledExtensionCount = enabledExtensions.size();
     deviceCreateInfo.ppEnabledExtensionNames = enabledExtensions.data();
-    
+
     vkCreateDevice(physicalDevice_, &deviceCreateInfo, nullptr, &device_);
-    
+
     vkGetDeviceQueue(device_, queueIndices.graphics, 0, &graphicsQueue_);
 }
 
@@ -408,7 +408,7 @@ void Renderer::createCommandPool() {
     poolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
     poolCreateInfo.queueFamilyIndex = queueIndices.graphics;
     poolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
-    
+
     vkCreateCommandPool(device_, &poolCreateInfo, nullptr, &commandPool_);
 }