有没有办法修复验证错误 VUID-VkDeviceCreateInfo-pProperties-04451？

如何解决有没有办法修复验证错误 VUID-VkDeviceCreateInfo-pProperties-04451？

我一直在编写名为“NewDawn”的游戏引擎作为副项目。但是，在最后几个测试版本中，Vulkan 不断发出信息，表明我需要遵守名为 VUID-VkDeviceCreateInfo-pProperties-04451 的规范。我尝试了很多方法来尝试让它工作，是的，我确实确保我构建了我的“固定”代码。请往下看代码。

render.cpp：

#include "render.h"

#include <iostream>
#include <assert.h>
#include <vector>

const std::vector<const char*> validationLayers = {"VK_LAYER_KHRONOS_validation"};
/** Attempted fix **/ const char* portLayers = "VK_KHR_portability_subset";

Renderer::Renderer(){
}

void Renderer::init_all(){
    InitInst();
    InitDevice();
}

void Renderer::init_specifics(std::string system){
    if(system == "instance"){
        InitInst();
    } if(system == "device"){
        InitDevice();
    } else {
        logger.consoleerror("[NewDawn] Whoops! Invalid initialization! Please check argument,remember valid arguments are instance and device");
    }
}

void Renderer::InitInst(){
    logger.consolecustom(ENGINE_NAME,"Initialized!");

    logger.consolecustom(ENGINE_NAME,"Initializing error catching mechanisms!");
    {
        uint32_t layer_count;
        vkEnumerateInstanceLayerProperties(&layer_count,nullptr);
        std::vector<VkLayerProperties> layer_property_list(layer_count);
        vkEnumerateInstanceLayerProperties(&layer_count,layer_property_list.data());

        std::cout << "[NewDawn] Detected validation layers: \n";
        for(auto &i: layer_property_list){
            std::cout << " " << i.layerName << "\t\t | " << i.description << std::endl; // Update LoggerClass to support these kind of things
        }
        std::cout << std::endl;

        for(const char* layerName : validationLayers){
            for(const auto& layerProperties : layer_property_list) {
                if(strcmp(layerName,layerProperties.layerName) == 0) {
                    layerFound = true;
                    break;
                }
            }
        }

        if (!layerFound){
            logger.consoleerror("[NewDawn] Whoops! Validation layers for Vulkan is not found!",true,2);
        }
    }
    logger.consolecustom(ENGINE_NAME,"Completed initialization of error catching mechanisms!");

    /** Create application info **/

    logger.consolecustom(ENGINE_NAME,"Setting up frameworks [1/2]");
    VkApplicationInfo applicationInfo {};
    applicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
    applicationInfo.apiVersion = device_properties.apiVersion;
    applicationInfo.applicationVersion = VK_MAKE_VERSION(major,minor,patch);
    applicationInfo.pApplicationName = name;
    logger.consolecustom(ENGINE_NAME,"Completed setting up! [1/2]");

    /** Create info **/

    logger.consolecustom(ENGINE_NAME,"Setting up frameworks [2/2]");
    VkInstanceCreateInfo createInfo {};
    createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
    createInfo.pApplicationInfo = &applicationInfo;
    if (layerFound){
        createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
        createInfo.ppEnabledLayerNames = validationLayers.data();
    } else {
        createInfo.enabledLayerCount = 0;
    }
    logger.consolecustom(ENGINE_NAME,"Completed setting up! [2/2]");

    /** Create instance **/

    logger.consolecustom(ENGINE_NAME,"Completed setting up frameworks! Finalizing Frameworks!");
    auto err = vkCreateInstance(&createInfo,nullptr,&instance);
    if(VK_SUCCESS != err) {
        logger.consoleerror("[NewDawn] Whoops! vkCreateInstance has failed to complete! Terminating!",2);
    }
    logger.consolecustom(ENGINE_NAME,"Completed setting up frameworks!");
}

void Renderer::DeInitInst(){
    vkDestroyInstance(instance,nullptr);
    instance = nullptr;
}

void Renderer::InitDevice(){
    logger.consolecustom(ENGINE_NAME,"Initializing GPU(s)");

    /** GET GPU **/
    {
        uint32_t gpu_count = 0;
        vkEnumeratePhysicalDevices(instance,&gpu_count,nullptr);
        std::vector<VkPhysicalDevice> gpu_list(gpu_count);
        vkEnumeratePhysicalDevices(instance,gpu_list.data());
        gpu = gpu_list[0];
        /** GET GPU PROPERTIES **/
        vkGetPhysicalDeviceProperties(gpu,&device_properties);
    }
    logger.consolecustom(ENGINE_NAME,"Completed initializing GPU(s)!");

    logger.consolecustom(ENGINE_NAME,"Getting graphics info from selected GPU!");
    /** GET QUEUE INFO **/
    {
        uint32_t family_count = 0;
        vkGetPhysicalDeviceQueueFamilyProperties(gpu,&family_count,nullptr);
        std::vector<VkQueueFamilyProperties> family_property_list(family_count);
        vkGetPhysicalDeviceQueueFamilyProperties(gpu,family_property_list.data());

        bool found = false;
        for(uint32_t i=0; i < family_count; ++i) {
            if(family_property_list[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
                found = true;
                graphics_index = i;
            }
        } if(!found) {
            logger.consoleerror("[NewDawn] Whoops! Vulkan has failed to find a Queue Family! Terminating!",2);
        }
    }
    std::cout << "[NewDawn] Completed fetching graphics info!" << std::endl;

    std::cout << "[NewDawn] Initializing queue priorities!" << std::endl;
    /** GET QUEUE PRIORITIES **/
    float queue_priorities[] { 1.0f };
    VkDeviceQueueCreateInfo queueInfo {};
    queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
    queueInfo.queueFamilyIndex = graphics_index;
    queueInfo.queueCount = 1;
    queueInfo.pQueuePriorities = queue_priorities;
    std::cout << "[NewDawn] Completed initializing queue priorities!" << std::endl;

    std::cout << "[NewDawn] Initializing devices for use!" << std::endl;
    VkDeviceCreateInfo deviceInfo {};
  deviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
    deviceInfo.queueCreateInfoCount = 1;
    deviceInfo.pQueueCreateInfos = &queueInfo;
    /** Attempted fix **/ deviceInfo.ppEnabledExtensionNames = &portLayers;

    auto err = vkCreateDevice(gpu,&deviceInfo,&device);
    if(VK_SUCCESS != err){
        assert(1 && "[NewDawn] Whoops! Vulkan has failed to create a device successfully! Terminating!");
        std::exit(2);
    }
    std::cout << "[NewDawn] Completed initializing devices for use!" << std::endl;
}

void Renderer::DeInitDevice(){
    vkDestroyDevice(device,nullptr);
    device = nullptr;
}