create_instance.cpp

    auto static default_validation_layers() -> std::vector<char const*> {
        return std::vector<char const*> {
            #if !defined(NDEBUG)
            "VK_LAYER_KHRONOS_validation"
            #endif
        };
    }

    auto static default_instance_extensions() -> std::vector<char const*> {
        return std::vector<char const*> {
                VK_KHR_SURFACE_EXTENSION_NAME,
                #if defined(VK_USE_PLATFORM_XCB_KHR)
                VK_KHR_XCB_SURFACE_EXTENSION_NAME,
                #endif
                #if defined(VK_USE_PLATFORM_WIN32_KHR)
                VK_KHR_WIN32_SURFACE_EXTENSION_NAME,
                #endif
                #if defined(VK_USE_PLATFORM_METAL_EXT)
                VK_EXT_METAL_SURFACE_EXTENSION_NAME,
                #endif
                #if !defined(NDEBUG)
                VK_EXT_DEBUG_UTILS_EXTENSION_NAME
                #endif
        };
    }

    auto static default_enabled_validation_features() -> std::vector<vk::ValidationFeatureEnableEXT> {
        return std::vector<vk::ValidationFeatureEnableEXT> {
            #if !defined(NDEBUG)
            vk::ValidationFeatureEnableEXT::eGpuAssisted,
            vk::ValidationFeatureEnableEXT::eBestPractices,
            vk::ValidationFeatureEnableEXT::eSynchronizationValidation
            #endif
        };
    }

    auto static default_debug_utils_messenger_callback(VkDebugUtilsMessageSeverityFlagBitsEXT   const  message_severity,
                                                       VkDebugUtilsMessageTypeFlagsEXT         const  message_types,
                                                       VkDebugUtilsMessengerCallbackDataEXT    const* callback_data,
                                                       void*) -> vk::Bool32 {
        auto callback {static_cast<vk::DebugUtilsMessengerCallbackDataEXT>(*callback_data)};

        std::cerr << vk::to_string(static_cast<vk::DebugUtilsMessageSeverityFlagBitsEXT>(message_severity))
                  << ": "
                  << vk::to_string(static_cast<vk::DebugUtilsMessageTypeFlagsEXT>(message_types))
                  << ":\n\t messageIDName   = <"
                  << callback.pMessageIdName
                  << ">\n\t messageIdNumber = "
                  << callback.messageIdNumber
                  << "\n\t message         = <"
                  << callback.pMessage
                  << ">\n";
        if (callback.queueLabelCount > 0) {
            for (auto i {std::uint32_t{}}; i < callback.queueLabelCount; ++i) {
                std::cerr << "\t\t labelName = <"
                          << callback.pQueueLabels[i].pLabelName
                          << ">\n";
            }
        }
        if (callback.cmdBufLabelCount > 0) {
            std::cerr << "\tCommandBuffer Labels:\n";
            for (auto i{std::uint32_t{}}; i < callback.cmdBufLabelCount; ++i) {
                std::cerr << "\t\tlabelName = <"
                          << callback.pCmdBufLabels[i].pLabelName
                          << ">\n";
            }
        }
        if (callback.objectCount > 0) {
            std::cerr << "\tObjects:\n";
            for (auto i{std::uint32_t{}}; i < callback.objectCount; ++i) {
                std::cerr << "\t\tObject "
                          << i
                          << "\n\t\t\tobjectType   = "
                          << vk::to_string(static_cast<vk::ObjectType>(callback.pObjects[i].objectType))
                          << "\n\t\t\tobjectHandle = "
                          << callback.pObjects[i].objectHandle
                          << "\n";
                if (callback.pObjects[i].pObjectName) {
                    std::cerr << "\t\t\tobjectName   = <"
                              << callback.pObjects[i].pObjectName
                              << ">\n";
                }
            }
        }
        return vk::Bool32{true};
    }

    auto static create_instance(std::vector<char const*>                    const& validation_layers = default_validation_layers(),
                                std::vector<char const*>                    const& instance_extensions = default_instance_extensions(),
                                std::vector<vk::ValidationFeatureEnableEXT> const& enabled_validation_features = default_enabled_validation_features(),
                                PFN_vkDebugUtilsMessengerCallbackEXT        const& debug_utils_messenger_callback = default_debug_utils_messenger_callback)
                                -> vk::Instance {
        return vk::createInstance(vk::StructureChain<vk::InstanceCreateInfo, vk::ValidationFeaturesEXT, vk::DebugUtilsMessengerCreateInfoEXT> {
                vk::InstanceCreateInfo {
                        vk::InstanceCreateFlags(),
                        nullptr,
                        [&validation_layers] {
                            auto available_layers {vk::enumerateInstanceLayerProperties()};
                            auto enabled_layers {std::vector<char const*> {}};
                            std::copy_if(validation_layers.begin(), validation_layers.end(), std::back_inserter(enabled_layers), [&available_layers](char const* requested_layer) {
                                return std::any_of(available_layers.begin(), available_layers.end(), [&requested_layer](vk::LayerProperties const& available_layer) {
                                    return strcmp(requested_layer, available_layer.layerName) == 0;
                                });
                            });
                            return enabled_layers;
                        }(),
                        [&instance_extensions] {
                            auto available_extensions {vk::enumerateInstanceExtensionProperties()};
                            auto enabled_extensions {std::vector<char const*> {}};
                            std::copy_if(instance_extensions.begin(), instance_extensions.end(), std::back_inserter(enabled_extensions), [&available_extensions](char const* requested_extension) {
                                return std::any_of(available_extensions.begin(), available_extensions.end(), [&requested_extension](vk::ExtensionProperties const& available_extension) {
                                    return strcmp(requested_extension, available_extension.extensionName) == 0;
                                });
                            });
                            return enabled_extensions;
                        }()
                },
                vk::ValidationFeaturesEXT{enabled_validation_features},
                vk::DebugUtilsMessengerCreateInfoEXT {
                        vk::DebugUtilsMessengerCreateFlagsEXT(),
                        vk::DebugUtilsMessageSeverityFlagsEXT {
                                vk::DebugUtilsMessageSeverityFlagBitsEXT::eError |
                                vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning
                        },
                        vk::DebugUtilsMessageTypeFlagsEXT {
                                vk::DebugUtilsMessageTypeFlagBitsEXT::eGeneral |
                                vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation |
                                vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance
                        },
                        debug_utils_messenger_callback
                }
        }.get<vk::InstanceCreateInfo>());
    }