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 240 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());
    }
 
    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;
 
    vk::PhysicalDeviceFeatures2 features2 {};
    features2.features = device_features;
 
    vk::PhysicalDeviceVulkan13Features vulkan_13_features {};
    vulkan_13_features.dynamicRendering = VK_TRUE;
    vulkan_13_features.synchronization2 = VK_TRUE;
 
    std::vector<const char*> device_extensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
 
#ifdef MAYAFLUX_PLATFORM_MACOS
    auto available_exts = m_physical_device.enumerateDeviceExtensionProperties();
    bool has_portability = std::ranges::any_of(available_exts,
        [](const auto& ext) {
            return strcmp(ext.extensionName, "VK_KHR_portability_subset") == 0;
        });
 
    if (has_portability) {
        device_extensions.push_back("VK_KHR_portability_subset");
    }
#else
    vk::PhysicalDeviceMeshShaderFeaturesEXT mesh_shader_features {};
    if (m_supports_mesh_shaders) {
        device_extensions.push_back(VK_EXT_MESH_SHADER_EXTENSION_NAME);
 
        mesh_shader_features.taskShader = VK_TRUE;
        mesh_shader_features.meshShader = VK_TRUE;
 
        vulkan_13_features.pNext = &mesh_shader_features;
    }
#endif
 
    features2.pNext = &vulkan_13_features;
 
    for (const auto& ext : backend_info.required_extensions) {
        device_extensions.push_back(ext.c_str());
    }
 
    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 = &features2;
    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;
    }
 
    return true;
}

References MayaFlux::Core::QueueFamilyIndices::compute_family, MayaFlux::Journal::Core, MayaFlux::Core::GraphicsBackendInfo::enable_compute_queue, MayaFlux::Core::GraphicsBackendInfo::enable_transfer_queue, MayaFlux::Core::GraphicsBackendInfo::fill_mode_non_solid, MayaFlux::Core::GraphicsBackendInfo::geometry_shaders, MayaFlux::Core::QueueFamilyIndices::graphics_family, MayaFlux::Journal::GraphicsBackend, m_compute_queue, m_graphics_queue, m_logical_device, m_physical_device, m_queue_families, m_supports_mesh_shaders, m_transfer_queue, MayaFlux::Core::GraphicsBackendInfo::multi_viewport, MayaFlux::Core::GraphicsBackendInfo::required_extensions, MayaFlux::Core::GraphicsBackendInfo::required_features, MayaFlux::Core::GraphicsBackendInfo::sampler_anisotropy, MayaFlux::Core::GraphicsBackendInfo::tessellation_shaders, and MayaFlux::Core::QueueFamilyIndices::transfer_family.

Referenced by initialize().

Here is the caller graph for this function: