◆ create()

bool MayaFlux::Core::VKSwapchain::create	(	VKContext &	context,
		vk::SurfaceKHR	surface,
		const WindowCreateInfo &	window_config
	)
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
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;
 
    const auto& queue_families = m_context->get_queue_families();
 
    std::vector<uint32_t> queue_family_indices;
    uint32_t graphics_family = queue_families.graphics_family.value();
    uint32_t present_family = queue_families.present_family.value();
 
    if (graphics_family != present_family) {
        queue_family_indices = { graphics_family, present_family };
        create_info.imageSharingMode = vk::SharingMode::eConcurrent;
        create_info.queueFamilyIndexCount = static_cast<uint32_t>(queue_family_indices.size());
        create_info.pQueueFamilyIndices = queue_family_indices.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;
}
Referenced by recreate().
Here is the call graph for this function:
Here is the caller graph for this function: