vkGetPhysicalDeviceSurfaceCapabilitiesKHR ne renvoie rien

Question

Je crée un physical device et un surface. Il fonctionne très bien, mais quand je l'appelle:

vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, 
              &surface_capabilities) 

bien que la fonction retourne 0, la structure est surface_capabilities toujours pas initialisés, chaque membre est null.

Le même problème est arrivé à

vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, 
            &formats_count, nullptr) 

fonction

et

vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, 
              &present_modes_count, 
              &present_modes[0]) 

le formats_count et present_modes_count sont null trop quand appeler après les fonctions.

Voici mon code:

#define GLFW_INCLUDE_VULKAN 
    #define VK_USE_PLATFORM_WIN32_KHR 
    #include <iostream> 
    #include <stdexcept> 
    #include <vector> 
    #include <cstring> 
    #include "Window.h" 
    #include <vulkan\vulkan.h> 

    using namespace std; 

    int main() 
    { 

     Window* myWindow = new Window(); 

     uint32_t instance_extensions_count = 0; 
     vkEnumerateInstanceExtensionProperties(nullptr, &instance_extensions_count, nullptr); 
     vector<VkExtensionProperties> availible_instance_extensions(instance_extensions_count); 
     vkEnumerateInstanceExtensionProperties(nullptr, &instance_extensions_count, availible_instance_extensions.data()); 

     std::vector<const char*> extensions= { 
      "VK_KHR_win32_surface", 
     }; 
     /*------------------------------------------------------------------*/ 
     VkApplicationInfo application_info = { 
      VK_STRUCTURE_TYPE_APPLICATION_INFO, 
      nullptr, 
      "Test", 
      VK_MAKE_VERSION(1, 0, 0), 
      "Test", 
      VK_MAKE_VERSION(1, 0, 0), 
      VK_MAKE_VERSION(1, 0, 0), 

     }; 

     VkInstanceCreateInfo instance_create_info = 
     { 
      VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, 
      nullptr, 
       0, 
       &application_info, 
       0, 
       nullptr, 
       static_cast<uint32_t>(extensions.size()), 
       extensions.data(), 
     }; 

     VkInstance pInstance; 
     vkCreateInstance(&instance_create_info, nullptr, &pInstance); 

     /*------------------------------------------------------------------*/ 

     VkSurfaceKHR surface; 
     glfwCreateWindowSurface(pInstance, myWindow->window, nullptr, &surface); 
     VkWin32SurfaceCreateInfoKHR surface_create_info; 
     surface_create_info.flags = 0; 
     surface_create_info.hinstance = myWindow->instance; 
     surface_create_info.hwnd = myWindow->handle; 
     surface_create_info.pNext = nullptr; 
     surface_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; 

     vkCreateWin32SurfaceKHR(pInstance, &surface_create_info, nullptr, &surface); 
     /*------------------------------------------------------------------*/ 

     uint32_t num_devices = 0; 
     vkEnumeratePhysicalDevices(pInstance, &num_devices, nullptr); 
     vector<VkPhysicalDevice> physicalDevices(num_devices); 
     vkEnumeratePhysicalDevices(pInstance, &num_devices, physicalDevices.data()); 

     uint32_t device_extensions_count = 0; 
     vector<const char*> device_extensions = { 
      VK_KHR_SWAPCHAIN_EXTENSION_NAME 
     }; 
     VkPhysicalDevice physicalDevice = nullptr; 

     for (auto device : physicalDevices) 
     { 
      vkEnumerateDeviceExtensionProperties(device, nullptr, &device_extensions_count, nullptr); 
      vector<VkExtensionProperties> available_extensions(device_extensions_count); 
      vkEnumerateDeviceExtensionProperties(device, nullptr, &device_extensions_count, available_extensions.data()); 
      //CheckExtensionAvailability(device_extensions[i], available_extensions)  
      physicalDevice = device; 
     } 


     VkPhysicalDeviceProperties device_properties; 
     vkGetPhysicalDeviceProperties(physicalDevice, &device_properties); 
     VkPhysicalDeviceFeatures device_features; 
     vkGetPhysicalDeviceFeatures(physicalDevice, &device_features); 

     /*------------------------------------------------------------------*/ 

     uint32_t queue_families_count = 0; 
     vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queue_families_count, nullptr); 
     vector<VkQueueFamilyProperties> queue_family_properties(queue_families_count); 
     vector<VkBool32>    queue_present_support(queue_families_count); 
     vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queue_families_count, queue_family_properties.data()); 
     uint32_t graphics_queue_family_index = UINT32_MAX; 
     uint32_t present_queue_family_index = UINT32_MAX; 
     for (uint32_t i = 0; i < queue_families_count; ++i) 
     { 
     vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface, queue_present_support.data()); 
      if ((queue_family_properties[i].queueCount > 0) && (queue_family_properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)) 
       graphics_queue_family_index = i; 
     } 

     for (uint32_t i = 0; i < queue_families_count; ++i) { 
      if (queue_present_support[i]) { 
       present_queue_family_index = i; 
       break; 
      } 
     } 

     vector<float> queue_priorities = { 1.0f }; 
     vector<VkDeviceQueueCreateInfo> queue_create_infos; 
     queue_create_infos.push_back({ 
      VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, 
      nullptr, 
      0, 
      graphics_queue_family_index, 
      static_cast<uint32_t>(queue_priorities.size()), 
      queue_priorities.data() 
     }); 

     if (graphics_queue_family_index != present_queue_family_index) 
     { 
      queue_create_infos.push_back({ 
       VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, 
       nullptr, 
       0, 
       present_queue_family_index, 
       static_cast<uint32_t>(queue_priorities.size()), 
       queue_priorities.data() 
      }); 
     }; 
     /*------------------------------------------------------------------*/ 
     VkDeviceCreateInfo device_create_info = { 
      VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, 
      nullptr, 
      0, 
      static_cast<uint32_t>(queue_create_infos.size()), 
      &queue_create_infos[0], 
      0, 
      nullptr, 
      static_cast<uint32_t>(device_extensions.size()), 
      &device_extensions[0], 
      nullptr 
     }; 

     VkDevice device; 
     vkCreateDevice(physicalDevice, &device_create_info, nullptr, &device); 
     /*------------------------------------------------------------------*/ 
     VkSemaphore     imageAvailableSemaphore; 
     VkSemaphore     renderingFinishedSemaphore; 

     VkSemaphoreCreateInfo semaphore_create_info = { 
      VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, 
      nullptr, 
      0 
     }; 

     vkCreateSemaphore(device, &semaphore_create_info, nullptr, &imageAvailableSemaphore); 
     vkCreateSemaphore(device, &semaphore_create_info, nullptr, &renderingFinishedSemaphore); 

     /*---------------------------wrong code--------------------------------*/ 
     VkSurfaceCapabilitiesKHR surface_capabilities; 
     vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, &surface_capabilities); 
     surface_capabilities.maxImageCount;//the value is 3435973836 


     uint32_t formats_count; 
     vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, &formats_count, nullptr); 
     vector<VkSurfaceFormatKHR> surface_formats(formats_count); 
//formats_count is 3435973836 
     vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, &formats_count, surface_formats.data()); 

     uint32_t present_modes_count; 
     vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, &present_modes_count, nullptr); 
//present_modes_count is 3435973836 
     std::vector<VkPresentModeKHR> present_modes(present_modes_count); 
     vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, &present_modes_count, &present_modes[0]); 







     myWindow->GameLoop(); 

     return 0; 
    } 

Answer 1

Il vous manque l'extension "VK_KHR_surface" dans votre liste d'extension. Ajoutez cela à votre liste extensions. Ou mieux encore utiliser glfwGetRequiredInstanceExtensions() pour obtenir les noms des extensions exactes qui sont nécessaires.

Vous devez également vérifier les erreurs. Par exemple. vérifiez le VkResult retourné de glfwCreateWindowSurface() pour les erreurs. Vérifiez toujours de manière cohérente les VkResult retournés depuis les commandes Vulkan. Pour GLFW, configurez le rappel d'erreur avec glfwSetErrorCallback() et vérifiez également les codes d'erreur renvoyés. BTW je ne vois pas glfwInit(); est-ce au Window.h?

Vous avez également créé une surface en double. Vous avez appelé glfwCreateWindowSurface() et vous avez également appelé vkCreateWin32SurfaceKHR().