create()

bool MayaFlux::Core::VKSwapchain::create	(	VKContext &	context,
		vk::SurfaceKHR	surface,
		const WindowCreateInfo &	window_config,
		const std::vector< uint32_t > &	sharing_families = {}
	)

Create swapchain for the given surface using VKContext.

Parameters

context	Vulkan context (provides device and configuration)
surface	Window surface
window_config	per-window configuration overrides
sharing_families	Queue families that will access the swapchain images. Empty or single-entry yields eExclusive; two or more distinct families yields eConcurrent. Supply both graphics and present families when driving presentation on a separate queue.

Returns

True if creation succeeded

Definition at line 13 of file VKSwapchain.cpp.

{
    m_context = &context;
    m_surface = surface;
 
    const GraphicsSurfaceInfo& surface_info = m_context->get_surface_info();
 
    GraphicsSurfaceInfo::SurfaceFormat desired_format = window_config.surface_format.has_value()
        ? window_config.surface_format.value()
        : surface_info.format;
 
    GraphicsSurfaceInfo::ColorSpace desired_color_space = surface_info.color_space;
 
    GraphicsSurfaceInfo::PresentMode desired_present_mode = window_config.present_mode.has_value()
        ? window_config.present_mode.value()
        : surface_info.present_mode;
 
    uint32_t desired_image_count = surface_info.image_count;
 
    vk::PhysicalDevice physical_device = m_context->get_physical_device();
    vk::Device device = m_context->get_device();
 
    SwapchainSupportDetails support = query_support(physical_device, surface);
 
    if (!support.is_adequate()) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Swapchain support inadequate (formats: {}, modes: {})",
            support.formats.size(), support.present_modes.size());
        return false;
    }
 
    vk::SurfaceFormatKHR surface_format;
 
    if (surface_info.enable_hdr) {
        auto hdr_format = find_hdr_format(support.formats);
 
        if (hdr_format.has_value()) {
            surface_format = hdr_format.value();
        } else {
            MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "HDR requested but no HDR-capable format/colorspace supported by device/surface. Falling back to default.");
 
            surface_format = choose_surface_format(support.formats, desired_format, desired_color_space);
        }
 
    } else {
        surface_format = choose_surface_format(support.formats, desired_format, desired_color_space);
    }
 
    MF_INFO(Journal::Component::Core, Journal::Context::GraphicsBackend,
        "Chosen swapchain format: {}, color space: {}",
        vk::to_string(surface_format.format),
        vk::to_string(surface_format.colorSpace));
 
    vk::PresentModeKHR present_mode = choose_present_mode(
        support.present_modes, desired_present_mode);
    vk::Extent2D extent = choose_extent(support.capabilities, window_config.width, window_config.height);
 
    uint32_t image_count = std::max(desired_image_count, support.capabilities.minImageCount);
    if (support.capabilities.maxImageCount > 0) {
        image_count = std::min(image_count, support.capabilities.maxImageCount);
    }
 
    vk::SwapchainCreateInfoKHR create_info {};
    create_info.surface = surface;
    create_info.minImageCount = image_count;
    create_info.imageFormat = surface_format.format;
    create_info.imageColorSpace = surface_format.colorSpace;
    create_info.imageExtent = extent;
    create_info.imageArrayLayers = 1;
    create_info.imageUsage = vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eTransferDst;
 
    if (support.capabilities.supportedUsageFlags & vk::ImageUsageFlagBits::eTransferSrc) {
        create_info.imageUsage |= vk::ImageUsageFlagBits::eTransferSrc;
    } else {
        MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Surface does not support eTransferSrc; frame capture will be unavailable");
    }
 
    m_sharing_families = sharing_families;
 
    std::vector<uint32_t> unique_families;
    for (uint32_t f : sharing_families) {
        if (std::ranges::find(unique_families, f) == unique_families.end())
            unique_families.push_back(f);
    }
 
    if (unique_families.size() > 1) {
        create_info.imageSharingMode = vk::SharingMode::eConcurrent;
        create_info.queueFamilyIndexCount = static_cast<uint32_t>(unique_families.size());
        create_info.pQueueFamilyIndices = unique_families.data();
    } else {
        create_info.imageSharingMode = vk::SharingMode::eExclusive;
        create_info.queueFamilyIndexCount = 0;
        create_info.pQueueFamilyIndices = nullptr;
    }
 
    create_info.preTransform = support.capabilities.currentTransform;
    create_info.compositeAlpha = vk::CompositeAlphaFlagBitsKHR::eOpaque;
    create_info.presentMode = present_mode;
    create_info.clipped = VK_TRUE;
    create_info.oldSwapchain = nullptr;
 
    try {
        m_swapchain = device.createSwapchainKHR(create_info);
    } catch (const vk::SystemError& e) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Failed to create swapchain: {}", e.what());
        return false;
    }
 
    m_images = device.getSwapchainImagesKHR(m_swapchain);
 
    m_image_format = surface_format.format;
    m_extent = extent;
 
    m_window_config = &window_config;
 
    if (!create_image_views()) {
        cleanup_swapchain();
        return false;
    }
 
    MF_INFO(Journal::Component::Core, Journal::Context::GraphicsBackend,
        "Swapchain created: {}x{}, {} images, format {}",
        extent.width, extent.height, m_images.size(),
        vk::to_string(surface_format.format));
 
    return true;
}

References MayaFlux::Core::SwapchainSupportDetails::capabilities, choose_extent(), choose_present_mode(), choose_surface_format(), cleanup_swapchain(), MayaFlux::Core::GraphicsSurfaceInfo::color_space, MayaFlux::Journal::Core, create_image_views(), device, MayaFlux::Core::GraphicsSurfaceInfo::enable_hdr, find_hdr_format(), MayaFlux::Core::GraphicsSurfaceInfo::format, MayaFlux::Core::SwapchainSupportDetails::formats, MayaFlux::Core::VKContext::get_device(), MayaFlux::Core::VKContext::get_physical_device(), MayaFlux::Core::VKContext::get_surface_info(), MayaFlux::Journal::GraphicsBackend, MayaFlux::Core::WindowCreateInfo::height, MayaFlux::Core::GraphicsSurfaceInfo::image_count, MayaFlux::Core::SwapchainSupportDetails::is_adequate(), m_context, m_extent, m_image_format, m_images, m_sharing_families, m_surface, m_swapchain, m_window_config, MF_ERROR, MF_INFO, MF_WARN, MayaFlux::Core::GraphicsSurfaceInfo::present_mode, MayaFlux::Core::WindowCreateInfo::present_mode, MayaFlux::Core::SwapchainSupportDetails::present_modes, query_support(), MayaFlux::Core::WindowCreateInfo::surface_format, and MayaFlux::Core::WindowCreateInfo::width.

Referenced by recreate().

Here is the call graph for this function:

Here is the caller graph for this function: