◆ create_logical_device()

bool MayaFlux::Core::VKDevice::create_logical_device	(	vk::Instance	instance,
		const GraphicsBackendInfo &	backend_info
	)
private
Create the logical device and retrieve queue handles.
Parameters
instance	Vulkan instance
backend_info	Graphics backend configuration
Returns: true if logical device creation succeeded
Definition at line 625 of file VKDevice.cpp.
{
    if (!m_queue_families.graphics_family.has_value()) {
        error<std::runtime_error>(Journal::Component::Core, Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "No graphics queue family found!");
    }
 
    std::set<uint32_t> unique_queue_families;
    unique_queue_families.insert(m_queue_families.graphics_family.value());
 
    if (m_queue_families.compute_family.has_value()) {
        unique_queue_families.insert(m_queue_families.compute_family.value());
    }
 
    if (m_queue_families.transfer_family.has_value() && m_queue_families.transfer_family != m_queue_families.graphics_family) {
        unique_queue_families.insert(m_queue_families.transfer_family.value());
    }
 
    for (uint32_t f = 0; f < QueueFamilyIndices::MAX_TRACKED_FAMILIES; ++f) {
        if (m_queue_families.can_present(f))
            unique_queue_families.insert(f);
    }
 
    std::vector<vk::DeviceQueueCreateInfo> queue_create_infos;
    float queue_priority = 1.0F;
 
    for (uint32_t queue_family : unique_queue_families) {
        vk::DeviceQueueCreateInfo queue_create_info {};
        queue_create_info.queueFamilyIndex = queue_family;
        queue_create_info.queueCount = 1;
        queue_create_info.pQueuePriorities = &queue_priority;
        queue_create_infos.push_back(queue_create_info);
    }
 
    vk::PhysicalDeviceFeatures device_features {};
    device_features.samplerAnisotropy = backend_info.required_features.sampler_anisotropy;
    device_features.geometryShader = backend_info.required_features.geometry_shaders;
    device_features.tessellationShader = backend_info.required_features.tessellation_shaders;
    device_features.multiViewport = backend_info.required_features.multi_viewport;
    device_features.fillModeNonSolid = backend_info.required_features.fill_mode_non_solid;
 
    std::vector<const char*> device_extensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
 
    auto supported_extensions = m_physical_device.enumerateDeviceExtensionProperties();
 
    auto is_supported = [&supported_extensions](std::string_view name) {
        return std::ranges::any_of(supported_extensions, [name](const auto& ext) {
            return name == ext.extensionName.data();
        });
    };
 
#ifdef MAYAFLUX_PLATFORM_MACOS
    if (is_supported("VK_KHR_portability_subset")) {
        device_extensions.push_back("VK_KHR_portability_subset");
    }
 
    auto feature_chain = vk::StructureChain {
        vk::PhysicalDeviceFeatures2 {},
        vk::PhysicalDeviceVulkan13Features {},
        vk::PhysicalDeviceVulkan12Features {}
    };
 
#else
    if (m_supports_mesh_shaders) {
        device_extensions.push_back(VK_EXT_MESH_SHADER_EXTENSION_NAME);
    }
 
    auto feature_chain = vk::StructureChain {
        vk::PhysicalDeviceFeatures2 {},
        vk::PhysicalDeviceVulkan13Features {},
        vk::PhysicalDeviceVulkan12Features {},
        vk::PhysicalDeviceMeshShaderFeaturesEXT {}
    };
 
    if (!m_supports_mesh_shaders) {
        feature_chain.unlink<vk::PhysicalDeviceMeshShaderFeaturesEXT>();
    } else {
        feature_chain.get<vk::PhysicalDeviceMeshShaderFeaturesEXT>().taskShader = VK_TRUE;
        feature_chain.get<vk::PhysicalDeviceMeshShaderFeaturesEXT>().meshShader = VK_TRUE;
    }
#endif
 
    feature_chain.get<vk::PhysicalDeviceFeatures2>().features = device_features;
    feature_chain.get<vk::PhysicalDeviceVulkan13Features>().dynamicRendering = VK_TRUE;
    feature_chain.get<vk::PhysicalDeviceVulkan13Features>().synchronization2 = VK_TRUE;
    feature_chain.get<vk::PhysicalDeviceVulkan12Features>().bufferDeviceAddress = VK_TRUE;
 
    std::vector<std::string> missing_required;
 
    for (const auto& ext : backend_info.required_extensions) {
        if (is_supported(ext)) {
            device_extensions.push_back(ext.c_str());
        } else {
            missing_required.push_back(ext);
        }
    }
 
    if (!missing_required.empty()) {
        std::string names;
        for (const auto& ext : missing_required) {
            if (!names.empty())
                names += ", ";
            names += ext;
        }
 
        error<std::runtime_error>(Journal::Component::Core, Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "Device '{}' does not support required extension(s): {}",
            m_device_name, names);
    }
 
    for (const auto& ext : backend_info.optional_extensions) {
        if (is_supported(ext)) {
            device_extensions.push_back(ext.c_str());
        } else {
            MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "Device '{}' does not support optional extension '{}'; skipping",
                m_device_name, ext);
        }
    }
 
    vk::DeviceCreateInfo create_info {};
    create_info.queueCreateInfoCount = static_cast<uint32_t>(queue_create_infos.size());
    create_info.pQueueCreateInfos = queue_create_infos.data();
    create_info.pNext = &feature_chain.get<vk::PhysicalDeviceFeatures2>();
    create_info.enabledExtensionCount = static_cast<uint32_t>(device_extensions.size());
    create_info.ppEnabledExtensionNames = device_extensions.data();
 
    try {
        m_logical_device = m_physical_device.createDevice(create_info);
        VULKAN_HPP_DEFAULT_DISPATCHER.init(m_logical_device);
 
    } catch (const std::exception& e) {
        error_rethrow(Journal::Component::Core, Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "Failed to create logical device: {}", e.what());
    }
 
    m_graphics_queue = m_logical_device.getQueue(m_queue_families.graphics_family.value(), 0);
 
    if (backend_info.enable_compute_queue && m_queue_families.compute_family.has_value()) {
        m_compute_queue = m_logical_device.getQueue(m_queue_families.compute_family.value(), 0);
    } else {
        m_compute_queue = m_graphics_queue;
    }
 
    if (backend_info.enable_transfer_queue && m_queue_families.transfer_family.has_value()) {
        m_transfer_queue = m_logical_device.getQueue(m_queue_families.transfer_family.value(), 0);
    } else {
        m_transfer_queue = m_graphics_queue;
    }
 
    for (uint32_t f = 0; f < QueueFamilyIndices::MAX_TRACKED_FAMILIES; ++f) {
        if (m_queue_families.can_present(f))
            m_present_queues[f] = m_logical_device.getQueue(f, 0);
    }
 
    return true;
}
Referenced by initialize().
Here is the call graph for this function:
Here is the caller graph for this function: