vkGetPhysicalDeviceSurfaceCapabilitiesKHR returns nothing

Question

I create a physical device and a surface. It works fine, but when I call:

vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface,
                                          &surface_capabilities)

although the function returns 0, surface_capabilities structure is still not initialised，every member is null.

The same problem happened to

vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface,
                                     &formats_count, nullptr)

function and

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

the formats_count and present_modes_count are null too when after call the functions.

Here's my 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

You are missing "VK_KHR_surface" extension in your extension list. Add that to your extensions list. Or better yet use glfwGetRequiredInstanceExtensions() to get the names of those exact extensions that are needed.

You also need to perform error checking. E.g. check the VkResult returned from glfwCreateWindowSurface() for errors. Always consistently check VkResults returned from Vulkan commands. For GLFW set up error callback with glfwSetErrorCallback(), and also check returned error codes. BTW I don't see glfwInit(); is it in Window.h?

Also you have duplicate surface creation. You have called glfwCreateWindowSurface() and then you also have called vkCreateWin32SurfaceKHR().