pick_physical_device()

bool MayaFlux::Core::VKDevice::pick_physical_device ( vk::Instance  instance, vk::SurfaceKHR  temp_surface  )

private

Pick a suitable physical device (GPU)

Parameters

instance	Vulkan instance
temp_surface	Temporary surface for presentation support checks

Returns

true if a suitable device was found

Definition at line 72 of file VKDevice.cpp.

{
    vk::Instance vk_instance(instance);
    auto devices = vk_instance.enumeratePhysicalDevices();
 
    if (devices.empty()) {
        error<std::runtime_error>(Journal::Component::Core, Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "Failed to find GPUs with Vulkan support!");
    }
 
    for (const auto& device : devices) {
        QueueFamilyIndices indices = find_queue_families(device, nullptr);
 
        if (indices.graphics_family.has_value()) {
            auto available_extensions = device.enumerateDeviceExtensionProperties();
            bool supports_swapchain = false;
            bool supports_mesh_shader = false;
 
            for (const auto& ext : available_extensions) {
                if (strcmp(ext.extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
                    supports_swapchain = true;
                }
                if (strcmp(ext.extensionName, VK_EXT_MESH_SHADER_EXTENSION_NAME) == 0) {
                    supports_mesh_shader = true;
                }
            }
 
            if (!supports_swapchain) {
                MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
                    "Physical device {} does not support VK_KHR_swapchain - skipping",
                    device.getProperties().deviceName.data());
                continue;
            }
 
            if (!supports_mesh_shader) {
                MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
                    "Physical device {} does not support VK_EXT_mesh_shader - "
                    "mesh shading features will be unavailable",
                    device.getProperties().deviceName.data());
            } else {
                vk::PhysicalDeviceMeshShaderFeaturesEXT mesh_features;
                vk::PhysicalDeviceFeatures2 temp_features;
                temp_features.pNext = &mesh_features;
                device.getFeatures2(&temp_features);
 
                if (mesh_features.meshShader == VK_FALSE || mesh_features.taskShader == VK_FALSE) {
                    MF_INFO(Journal::Component::Core, Journal::Context::GraphicsBackend,
                        "Physical device {} supports VK_EXT_mesh_shader extension but features disabled",
                        device.getProperties().deviceName.data());
                    supports_mesh_shader = false;
                }
            }
 
            m_physical_device = device;
            m_queue_families = indices;
            m_supports_mesh_shaders = supports_mesh_shader;
 
            vk::PhysicalDeviceProperties props = device.getProperties();
            MF_PRINT(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "Selected GPU: {}", props.deviceName.data());
            return true;
        }
    }
 
    error<std::runtime_error>(Journal::Component::Core, Journal::Context::GraphicsBackend,
        std::source_location::current(),
        "Failed to find a suitable GPU!");
    return false;
}

References MayaFlux::Journal::Core, find_queue_families(), MayaFlux::Core::QueueFamilyIndices::graphics_family, MayaFlux::Journal::GraphicsBackend, m_physical_device, m_queue_families, m_supports_mesh_shaders, MF_INFO, MF_PRINT, and MF_WARN.

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function: