Changeset 90a424f in opengl-game

Timestamp:

Sep 16, 2019, 7:04:53 PM (5 years ago)

Author:

Dmitry Portnoy <dmitry.portnoy@…>

Branches:

feature/imgui-sdl, master, points-test

Children:

fe5c3ba

Parents:

c6fec84

Message:

In vulkangame, add code to create a Vulkan surface and pick a physical device

Files:

• vulkan-game.cpp (modified) (2 diffs)
• vulkan-game.hpp (modified) (2 diffs)
• vulkan-ref.cpp (modified) (10 diffs)
• vulkan-utils.cpp (modified) (2 diffs)
• vulkan-utils.hpp (modified) (3 diffs)

vulkan-game.cpp

@@ -93 +93 @@
    createVulkanInstance(validationLayers);
    setupDebugMessenger();
+   createVulkanSurface();
+   pickPhysicalDevice();
 }
 
@@ -230 +232 @@
    return VK_FALSE;
 }
+
+void VulkanGame::createVulkanSurface() {
+   if (gui->createVulkanSurface(instance, &surface) == RTWO_ERROR) {
+      throw runtime_error("failed to create window surface!");
+   }
+}
+
+void VulkanGame::pickPhysicalDevice() {
+   uint32_t deviceCount = 0;
+   vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
+
+   if (deviceCount == 0) {
+      throw runtime_error("failed to find GPUs with Vulkan support!");
+   }
+
+   vector<VkPhysicalDevice> devices(deviceCount);
+   vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());
+
+   cout << endl << "Graphics cards:" << endl;
+   for (const VkPhysicalDevice& device : devices) {
+      if (isDeviceSuitable(device)) {
+         physicalDevice = device;
+         break;
+      }
+   }
+   cout << endl;
+
+   if (physicalDevice == VK_NULL_HANDLE) {
+      throw runtime_error("failed to find a suitable GPU!");
+   }
+}
+
+bool VulkanGame::isDeviceSuitable(VkPhysicalDevice device) {
+   const vector<const char*> deviceExtensions = {
+      VK_KHR_SWAPCHAIN_EXTENSION_NAME
+   };
+
+   VkPhysicalDeviceProperties deviceProperties;
+   vkGetPhysicalDeviceProperties(device, &deviceProperties);
+
+   cout << "Device: " << deviceProperties.deviceName << endl;
+
+   QueueFamilyIndices indices = VulkanUtils::findQueueFamilies(device, surface);
+   bool extensionsSupported = VulkanUtils::checkDeviceExtensionSupport(device, deviceExtensions);
+   bool swapChainAdequate = false;
+
+   if (extensionsSupported) {
+      SwapChainSupportDetails swapChainSupport = VulkanUtils::querySwapChainSupport(device, surface);
+      swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
+   }
+
+   VkPhysicalDeviceFeatures supportedFeatures;
+   vkGetPhysicalDeviceFeatures(device, &supportedFeatures);
+
+   return indices.isComplete() && extensionsSupported && swapChainAdequate && supportedFeatures.samplerAnisotropy;
+}

vulkan-game.hpp

@@ -26 +26 @@
       VkInstance instance;
       VkDebugUtilsMessengerEXT debugMessenger;
+      VkSurfaceKHR surface;
+      VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
 
       bool initWindow(int width, int height, unsigned char guiFlags);
@@ -35 +37 @@
       void setupDebugMessenger();
       void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo);
+      void createVulkanSurface();
+      void pickPhysicalDevice();
+      bool isDeviceSuitable(VkPhysicalDevice device);
 
       static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(

vulkan-ref.cpp

@@ -32 +32 @@
 const int MAX_FRAMES_IN_FLIGHT = 2;
 
+/*** START OF REFACTORED CODE ***/
 #ifdef NDEBUG
    const bool enableValidationLayers = false;
@@ -60 +61 @@
     vector<VkPresentModeKHR> presentModes;
 };
+/*** END OF REFACTORED CODE ***/
 
 struct Vertex {
@@ -159 +161 @@
       VkInstance instance;
       VkDebugUtilsMessengerEXT debugMessenger;
+      VkSurfaceKHR surface;
+
+      VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
 /*** END OF REFACTORED CODE ***/
-      VkSurfaceKHR surface;
-
-      VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
       VkDevice device;
 
@@ -312 +314 @@
          createInstance();
          setupDebugMessenger();
-/*** END OF REFACTORED CODE ***/
          createSurface();
          pickPhysicalDevice();
+/*** END OF REFACTORED CODE ***/
          createLogicalDevice();
          createSwapChain();
@@ -491 +493 @@
          createInfo.pfnUserCallback = debugCallback;
       }
-      /*** END OF REFACTORED CODE ***/
 
       void createSurface() {
@@ -560 +561 @@
          return requiredExtensions.empty();
       }
+/*** END OF REFACTORED CODE ***/
 
       void createLogicalDevice() {
@@ -661 +663 @@
       }
 
+/*** START OF REFACTORED CODE ***/
       SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device) {
          SwapChainSupportDetails details;
@@ -684 +687 @@
          return details;
       }
+/*** END OF REFACTORED CODE ***/
 
       VkSurfaceFormatKHR chooseSwapSurfaceFormat(const vector<VkSurfaceFormatKHR>& availableFormats) {
@@ -1034 +1038 @@
       }
 
+/*** START OF REFACTORED CODE ***/
       QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device) {
          QueueFamilyIndices indices;
@@ -1065 +1070 @@
          return indices;
       }
+/*** END OF REFACTORED CODE ***/
 
       void createDepthResources() {

vulkan-utils.cpp

@@ -1 +1 @@
 #include "vulkan-utils.hpp"
+
+#include <set>
+#include <string>
 
 bool VulkanUtils::checkValidationLayerSupport(const vector<const char*> &validationLayers) {
@@ -48 +51 @@
    }
 }
+
+QueueFamilyIndices VulkanUtils::findQueueFamilies(VkPhysicalDevice device, VkSurfaceKHR surface) {
+   QueueFamilyIndices indices;
+
+   uint32_t queueFamilyCount = 0;
+   vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
+
+   vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
+   vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
+
+   int i = 0;
+   for (const auto& queueFamily : queueFamilies) {
+      if (queueFamily.queueCount > 0 && queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+         indices.graphicsFamily = i;
+      }
+
+      VkBool32 presentSupport = false;
+      vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
+
+      if (queueFamily.queueCount > 0 && presentSupport) {
+         indices.presentFamily = i;
+      }
+
+      if (indices.isComplete()) {
+         break;
+      }
+
+      i++;
+   }
+
+   return indices;
+}
+
+bool VulkanUtils::checkDeviceExtensionSupport(VkPhysicalDevice device, const vector<const char*>& deviceExtensions) {
+   uint32_t extensionCount;
+   vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);
+
+   vector<VkExtensionProperties> availableExtensions(extensionCount);
+   vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, availableExtensions.data());
+
+   set<string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
+
+   for (const auto& extension : availableExtensions) {
+      requiredExtensions.erase(extension.extensionName);
+   }
+
+   return requiredExtensions.empty();
+}
+
+SwapChainSupportDetails VulkanUtils::querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface) {
+   SwapChainSupportDetails details;
+
+   vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
+
+   uint32_t formatCount;
+   vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
+
+   if (formatCount != 0) {
+      details.formats.resize(formatCount);
+      vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
+   }
+
+   uint32_t presentModeCount;
+   vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
+
+   if (presentModeCount != 0) {
+      details.presentModes.resize(presentModeCount);
+      vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
+   }
+
+   return details;
+}

vulkan-utils.hpp

@@ -2 +2 @@
 #define _VULKAN_UTILS_H
 
+#include <optional>
 #include <vector>
 
@@ -7 +8 @@
 
 using namespace std;
+
+struct QueueFamilyIndices {
+   optional<uint32_t> graphicsFamily;
+   optional<uint32_t> presentFamily;
+
+   bool isComplete() {
+      return graphicsFamily.has_value() && presentFamily.has_value();
+   }
+};
+
+struct SwapChainSupportDetails {
+   VkSurfaceCapabilitiesKHR capabilities;
+   vector<VkSurfaceFormatKHR> formats;
+   vector<VkPresentModeKHR> presentModes;
+};
 
 class VulkanUtils {
@@ -20 +36 @@
             VkDebugUtilsMessengerEXT debugMessenger,
             const VkAllocationCallbacks* pAllocator);
+
+      static QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device, VkSurfaceKHR surface);
+      static bool checkDeviceExtensionSupport(VkPhysicalDevice device, const vector<const char*>& deviceExtensions);
+      static SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface);
 };