vkGetPhysicalDeviceSurfaceCapabilitiesKHR不返回任何內容

Question

我創建一個physical device和一個surface 。 它工作正常，但是當我打電話時：

vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface,
                                          &surface_capabilities)

盡管該函數返回0 ，但surface_capabilities結構仍未初始化，每個成員都為null 。

發生了同樣的問題

vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface,
                                     &formats_count, nullptr)

功能和

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

在formats_count和present_modes_count是null過當后調用的函數。

這是我的代碼：

   #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

您的擴展名列表中缺少"VK_KHR_surface"擴展名。 將其添加到您的extensions列表。 最好還是使用glfwGetRequiredInstanceExtensions（）來獲取所需的那些確切擴展名。

您還需要執行錯誤檢查。 如檢查VkResult從返回glfwCreateWindowSurface()的錯誤。 始終一致地檢查Vulkan命令返回的VkResult 。 對於GLFW，請使用glfwSetErrorCallback()設置錯誤回調，並檢查返回的錯誤代碼。 順便說一句，我沒有看到glfwInit() ; 在Window.h嗎？

此外，您還會重復創建曲面。 您調用了glfwCreateWindowSurface() ，然后調用了vkCreateWin32SurfaceKHR() 。