initialize_image()

void MayaFlux::Core::BackendResourceManager::initialize_image

(

const std::shared_ptr< VKImage > &

image

)

Initialize a VKImage (allocate VkImage, memory, and create image view)

Parameters

image

VKImage to initialize

Follows the same pattern as initialize_buffer:

1. Create VkImage
2. Allocate VkDeviceMemory
3. Bind memory to image
4. Create VkImageView
5. Store handles in VKImage

Definition at line 392 of file BackendResoureManager.cpp.

{
    if (!image) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Attempted to initialize null VKImage");
        return;
    }
 
    if (image->is_initialized()) {
        MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "VKImage already initialized, skipping");
        return;
    }
 
    // ========================================================================
    // Step 1: Create VkImage
    // ========================================================================
 
    vk::ImageCreateInfo image_info {};
 
    switch (image->get_type()) {
    case VKImage::Type::TYPE_1D:
        image_info.imageType = vk::ImageType::e1D;
        break;
    case VKImage::Type::TYPE_2D:
    case VKImage::Type::TYPE_CUBE:
        image_info.imageType = vk::ImageType::e2D;
        break;
    case VKImage::Type::TYPE_3D:
        image_info.imageType = vk::ImageType::e3D;
        break;
    }
 
    image_info.extent.width = image->get_width();
    image_info.extent.height = image->get_height();
    image_info.extent.depth = image->get_depth();
    image_info.mipLevels = image->get_mip_levels();
    image_info.arrayLayers = image->get_array_layers();
    image_info.format = image->get_format();
    image_info.tiling = vk::ImageTiling::eOptimal;
    image_info.initialLayout = vk::ImageLayout::eUndefined;
    image_info.usage = image->get_usage_flags();
    image_info.sharingMode = vk::SharingMode::eExclusive;
    image_info.samples = vk::SampleCountFlagBits::e1; // No MSAA for now
    image_info.flags = (image->get_type() == VKImage::Type::TYPE_CUBE)
        ? vk::ImageCreateFlagBits::eCubeCompatible
        : vk::ImageCreateFlags {};
 
    vk::Image vk_image;
    try {
        vk_image = m_context.get_device().createImage(image_info);
    } catch (const vk::SystemError& e) {
        error_rethrow(
            Journal::Component::Core,
            Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "Failed to create VkImage: " + std::string(e.what()));
    }
 
    // ========================================================================
    // Step 2: Allocate memory
    // ========================================================================
 
    vk::MemoryRequirements mem_requirements;
    mem_requirements = m_context.get_device().getImageMemoryRequirements(vk_image);
 
    vk::MemoryAllocateInfo alloc_info {};
    alloc_info.allocationSize = mem_requirements.size;
    alloc_info.memoryTypeIndex = find_memory_type(
        mem_requirements.memoryTypeBits,
        image->get_memory_properties());
 
    vk::DeviceMemory memory;
    try {
        memory = m_context.get_device().allocateMemory(alloc_info);
    } catch (const vk::SystemError& e) {
        m_context.get_device().destroyImage(vk_image);
        error_rethrow(
            Journal::Component::Core,
            Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "Failed to allocate VkDeviceMemory for image: " + std::string(e.what()));
    }
 
    // ========================================================================
    // Step 3: Bind memory to image
    // ========================================================================
 
    try {
        m_context.get_device().bindImageMemory(vk_image, memory, 0);
    } catch (const vk::SystemError& e) {
        m_context.get_device().freeMemory(memory);
        m_context.get_device().destroyImage(vk_image);
        error_rethrow(
            Journal::Component::Core,
            Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "Failed to bind memory to VkImage: " + std::string(e.what()));
    }
 
    // ========================================================================
    // Step 4: Create image view
    // ========================================================================
 
    vk::ImageViewCreateInfo view_info {};
 
    switch (image->get_type()) {
    case VKImage::Type::TYPE_1D:
        view_info.viewType = (image->get_array_layers() > 1)
            ? vk::ImageViewType::e1DArray
            : vk::ImageViewType::e1D;
        break;
    case VKImage::Type::TYPE_2D:
        view_info.viewType = (image->get_array_layers() > 1)
            ? vk::ImageViewType::e2DArray
            : vk::ImageViewType::e2D;
        break;
    case VKImage::Type::TYPE_3D:
        view_info.viewType = vk::ImageViewType::e3D;
        break;
    case VKImage::Type::TYPE_CUBE:
        view_info.viewType = vk::ImageViewType::eCube;
        break;
    }
 
    view_info.image = vk_image;
    view_info.format = image->get_format();
    view_info.subresourceRange.aspectMask = image->get_aspect_flags();
    view_info.subresourceRange.baseMipLevel = 0;
    view_info.subresourceRange.levelCount = image->get_mip_levels();
    view_info.subresourceRange.baseArrayLayer = 0;
    view_info.subresourceRange.layerCount = image->get_array_layers();
 
    view_info.components.r = vk::ComponentSwizzle::eIdentity;
    view_info.components.g = vk::ComponentSwizzle::eIdentity;
    view_info.components.b = vk::ComponentSwizzle::eIdentity;
    view_info.components.a = vk::ComponentSwizzle::eIdentity;
 
    vk::ImageView image_view;
    try {
        image_view = m_context.get_device().createImageView(view_info);
    } catch (const vk::SystemError& e) {
        m_context.get_device().freeMemory(memory);
        m_context.get_device().destroyImage(vk_image);
        error_rethrow(
            Journal::Component::Core,
            Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "Failed to create VkImageView: " + std::string(e.what()));
    }
 
    // ========================================================================
    // Step 5: Store handles in VKImage
    // ========================================================================
 
    VKImageResources resources {};
    resources.image = vk_image;
    resources.image_view = image_view;
    resources.memory = memory;
    resources.sampler = nullptr;
 
    image->set_image_resources(resources);
    image->set_current_layout(vk::ImageLayout::eUndefined);
 
    MF_INFO(Journal::Component::Core, Journal::Context::GraphicsBackend,
        "VKImage initialized: {}x{}x{}, format: {}, {} mips, {} layers",
        image->get_width(), image->get_height(), image->get_depth(),
        vk::to_string(image->get_format()),
        image->get_mip_levels(), image->get_array_layers());
}

References MayaFlux::Journal::Core, find_memory_type(), MayaFlux::Core::VKContext::get_device(), MayaFlux::Journal::GraphicsBackend, MayaFlux::Core::VKImageResources::image, image, m_context, MF_ERROR, MF_INFO, MF_WARN, MayaFlux::Core::VKImage::TYPE_1D, MayaFlux::Core::VKImage::TYPE_2D, MayaFlux::Core::VKImage::TYPE_3D, and MayaFlux::Core::VKImage::TYPE_CUBE.

Referenced by MayaFlux::Portal::Graphics::TextureLoom::create_2d(), MayaFlux::Portal::Graphics::TextureLoom::create_2d_array(), MayaFlux::Portal::Graphics::TextureLoom::create_3d(), MayaFlux::Portal::Graphics::TextureLoom::create_cubemap(), MayaFlux::Portal::Graphics::TextureLoom::create_depth_buffer(), MayaFlux::Portal::Graphics::TextureLoom::create_render_target(), and MayaFlux::Portal::Graphics::TextureLoom::create_storage_image().

Here is the call graph for this function:

Here is the caller graph for this function: