TextureLoom.cpp

Go to the documentation of this file.

#include "TextureLoom.hpp"
 
#include "MayaFlux/Core/Backends/Graphics/Vulkan/BackendResoureManager.hpp"
#include "MayaFlux/Core/Backends/Graphics/Vulkan/VKImage.hpp"
#include "MayaFlux/Core/Backends/Graphics/Vulkan/VulkanBackend.hpp"
 
#include "MayaFlux/Kakshya/NDData/TextureAccess.hpp"
 
#include "MayaFlux/Buffers/VKBuffer.hpp"
 
#include "MayaFlux/Journal/Archivist.hpp"
 
namespace MayaFlux::Portal::Graphics {
 
size_t ImageKeyHash::operator()(const ImageKey& key) const noexcept
{
    uint64_t hash = 14695981039346656037ULL;
    const auto mix = [&hash](uint64_t value) {
        hash = (hash ^ value) * 1099511628211ULL;
    };
 
    mix(key.width);
    mix(key.height);
    mix(key.layers);
    mix(key.mip_levels);
    mix(static_cast<uint64_t>(key.format));
    mix(static_cast<uint64_t>(key.kind));
 
    return static_cast<size_t>(hash);
}
 
bool TextureLoom::s_initialized = false;
 
bool TextureLoom::initialize(const std::shared_ptr<Core::VulkanBackend>& backend)
{
    if (s_initialized) {
        MF_WARN(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "TextureLoom already initialized (static flag)");
        return true;
    }
 
    if (!backend) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Cannot initialize TextureLoom with null backend");
        return false;
    }
 
    if (m_backend) {
        MF_WARN(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "TextureLoom already initialized");
        return true;
    }
 
    m_backend = backend;
    m_resource_manager = &m_backend->get_resource_manager();
    s_initialized = true;
 
    MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
        "TextureLoom initialized");
    return true;
}
 
void TextureLoom::shutdown()
{
    if (!s_initialized) {
        return;
    }
 
    if (!m_backend) {
        return;
    }
 
    MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
        "Shutting down TextureLoom...");
 
    for (auto& texture : m_textures) {
        if (texture && texture->is_initialized()) {
            m_resource_manager->cleanup_image(texture);
        }
    }
    m_textures.clear();
    m_sampler_cache.clear();
    m_resource_manager = nullptr;
    m_backend = nullptr;
 
    s_initialized = false;
 
    MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
        "TextureLoom shutdown complete");
}
 
//==============================================================================
// Texture Creation
//==============================================================================
 
std::shared_ptr<Core::VKImage> TextureLoom::create_2d(
    uint32_t width, uint32_t height,
    ImageFormat format, const void* data, uint32_t mip_levels)
{
    if (!is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "TextureLoom not initialized");
        return nullptr;
    }
 
    auto vk_format = to_vulkan_format(format);
    auto image = std::make_shared<Core::VKImage>(
        width, height, 1, vk_format,
        Core::VKImage::Usage::TEXTURE_2D,
        Core::VKImage::Type::TYPE_2D,
        mip_levels, 1,
        Kakshya::DataModality::IMAGE_COLOR);
 
    m_resource_manager->initialize_image(image);
 
    if (!image->is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Failed to initialize VKImage");
        return nullptr;
    }
 
    if (data) {
        size_t data_size = calculate_image_size(width, height, 1, format);
        upload_data(image, data, data_size);
    } else {
        m_resource_manager->transition_image_layout(
            image->get_image(),
            vk::ImageLayout::eUndefined,
            vk::ImageLayout::eShaderReadOnlyOptimal,
            mip_levels, 1, vk::ImageAspectFlagBits::eColor);
        image->set_current_layout(vk::ImageLayout::eShaderReadOnlyOptimal);
    }
 
    m_textures.push_back(image);
    MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
        "Created 2D texture: {}x{}, format: {}, mips: {}",
        width, height, vk::to_string(vk_format), mip_levels);
    return image;
}
 
std::shared_ptr<Core::VKImage> TextureLoom::create_2d_uninitialized(
    uint32_t width, uint32_t height,
    ImageFormat format, uint32_t mip_levels)
{
    if (!is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "TextureLoom not initialized");
        return nullptr;
    }
 
    auto vk_format = to_vulkan_format(format);
    auto image = std::make_shared<Core::VKImage>(
        width, height, 1, vk_format,
        Core::VKImage::Usage::TEXTURE_2D,
        Core::VKImage::Type::TYPE_2D,
        mip_levels, 1,
        Kakshya::DataModality::IMAGE_COLOR);
 
    m_resource_manager->initialize_image(image);
 
    if (!image->is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Failed to initialize VKImage");
        return nullptr;
    }
 
    m_textures.push_back(image);
    MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
        "Created 2D texture (uninitialized): {}x{}, format: {}, mips: {}",
        width, height, vk::to_string(vk_format), mip_levels);
    return image;
}
 
std::shared_ptr<Core::VKImage> TextureLoom::create_3d(
    uint32_t width, uint32_t height, uint32_t depth,
    ImageFormat format, const void* data)
{
    if (!is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "TextureLoom not initialized");
        return nullptr;
    }
 
    auto vk_format = to_vulkan_format(format);
    auto image = std::make_shared<Core::VKImage>(
        width, height, depth, vk_format,
        Core::VKImage::Usage::TEXTURE_2D,
        Core::VKImage::Type::TYPE_3D,
        1, 1, Kakshya::DataModality::VOLUMETRIC_3D);
 
    m_resource_manager->initialize_image(image);
 
    if (!image->is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Failed to initialize 3D VKImage");
        return nullptr;
    }
 
    if (data) {
        size_t data_size = calculate_image_size(width, height, depth, format);
        upload_data(image, data, data_size);
    } else {
        m_resource_manager->transition_image_layout(
            image->get_image(),
            vk::ImageLayout::eUndefined,
            vk::ImageLayout::eShaderReadOnlyOptimal,
            1, 1, vk::ImageAspectFlagBits::eColor);
        image->set_current_layout(vk::ImageLayout::eShaderReadOnlyOptimal);
    }
 
    m_textures.push_back(image);
    MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
        "Created 3D texture: {}x{}x{}, format: {}",
        width, height, depth, vk::to_string(vk_format));
    return image;
}
 
std::shared_ptr<Core::VKImage> TextureLoom::create_cubemap(
    uint32_t size, ImageFormat format, const void* data)
{
    if (!is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "TextureLoom not initialized");
        return nullptr;
    }
 
    auto vk_format = to_vulkan_format(format);
    auto image = std::make_shared<Core::VKImage>(
        size, size, 1, vk_format,
        Core::VKImage::Usage::TEXTURE_2D,
        Core::VKImage::Type::TYPE_CUBE,
        1, 6, Kakshya::DataModality::IMAGE_COLOR);
 
    m_resource_manager->initialize_image(image);
 
    if (!image->is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Failed to initialize cubemap VKImage");
        return nullptr;
    }
 
    if (data) {
        size_t face_size = calculate_image_size(size, size, 1, format);
        size_t total_size = face_size * 6;
        upload_data(image, data, total_size);
    } else {
        m_resource_manager->transition_image_layout(
            image->get_image(),
            vk::ImageLayout::eUndefined,
            vk::ImageLayout::eShaderReadOnlyOptimal,
            1, 6, vk::ImageAspectFlagBits::eColor);
        image->set_current_layout(vk::ImageLayout::eShaderReadOnlyOptimal);
    }
 
    m_textures.push_back(image);
    MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
        "Created cubemap: {}x{}, format: {}", size, size, vk::to_string(vk_format));
    return image;
}
 
std::shared_ptr<Core::VKImage> TextureLoom::create_2d_array(
    uint32_t width, uint32_t height, uint32_t layers,
    ImageFormat format, const void* data)
{
    if (!is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "TextureLoom not initialized");
        return nullptr;
    }
 
    if (layers == 0) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "create_2d_array: layers must be > 0");
        return nullptr;
    }
 
    auto vk_format = to_vulkan_format(format);
    auto image = std::make_shared<Core::VKImage>(
        width, height, 1, vk_format,
        Core::VKImage::Usage::TEXTURE_2D,
        Core::VKImage::Type::TYPE_2D,
        1, layers,
        Kakshya::DataModality::IMAGE_COLOR);
 
    m_resource_manager->initialize_image(image);
 
    if (!image->is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "create_2d_array: failed to initialize VKImage ({}x{} layers={})",
            width, height, layers);
        return nullptr;
    }
 
    if (data) {
        const size_t total = calculate_image_size(width, height, 1, format) * layers;
        upload_data(image, data, total);
    } else {
        m_resource_manager->transition_image_layout(
            image->get_image(),
            vk::ImageLayout::eUndefined,
            vk::ImageLayout::eShaderReadOnlyOptimal,
            1, layers, vk::ImageAspectFlagBits::eColor);
        image->set_current_layout(vk::ImageLayout::eShaderReadOnlyOptimal);
    }
 
    m_textures.push_back(image);
    MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
        "Created 2D array texture: {}x{} layers={} format={}",
        width, height, layers, vk::to_string(vk_format));
    return image;
}
 
std::shared_ptr<Core::VKImage> TextureLoom::create_render_target(
    uint32_t width, uint32_t height, ImageFormat format)
{
    if (!is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "TextureLoom not initialized");
        return nullptr;
    }
 
    auto vk_format = to_vulkan_format(format);
    auto image = std::make_shared<Core::VKImage>(
        width, height, 1, vk_format,
        Core::VKImage::Usage::RENDER_TARGET,
        Core::VKImage::Type::TYPE_2D,
        1, 1, Kakshya::DataModality::IMAGE_COLOR);
 
    m_resource_manager->initialize_image(image);
 
    if (!image->is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Failed to initialize render target VKImage");
        return nullptr;
    }
 
    m_resource_manager->transition_image_layout(
        image->get_image(),
        vk::ImageLayout::eUndefined,
        vk::ImageLayout::eColorAttachmentOptimal,
        1, 1, vk::ImageAspectFlagBits::eColor);
    image->set_current_layout(vk::ImageLayout::eColorAttachmentOptimal);
 
    m_textures.push_back(image);
    MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
        "Created render target: {}x{}, format: {}",
        width, height, vk::to_string(vk_format));
    return image;
}
 
std::shared_ptr<Core::VKImage> TextureLoom::create_depth_buffer(
    uint32_t width, uint32_t height, bool with_stencil)
{
    if (!is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "TextureLoom not initialized");
        return nullptr;
    }
 
    vk::Format vk_format = with_stencil
        ? vk::Format::eD24UnormS8Uint
        : vk::Format::eD32Sfloat;
 
    auto image = std::make_shared<Core::VKImage>(
        width, height, 1, vk_format,
        Core::VKImage::Usage::DEPTH_STENCIL,
        Core::VKImage::Type::TYPE_2D,
        1, 1, Kakshya::DataModality::IMAGE_2D);
 
    m_resource_manager->initialize_image(image);
 
    if (!image->is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Failed to initialize depth buffer VKImage");
        return nullptr;
    }
 
    vk::ImageAspectFlags aspect = with_stencil
        ? (vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil)
        : vk::ImageAspectFlagBits::eDepth;
 
    m_resource_manager->transition_image_layout(
        image->get_image(),
        vk::ImageLayout::eUndefined,
        vk::ImageLayout::eDepthStencilAttachmentOptimal,
        1, 1, aspect);
    image->set_current_layout(vk::ImageLayout::eDepthStencilAttachmentOptimal);
 
    m_textures.push_back(image);
    MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
        "Created depth buffer: {}x{}, format: {}, stencil: {}",
        width, height, vk::to_string(vk_format), with_stencil);
    return image;
}
 
std::shared_ptr<Core::VKImage> TextureLoom::create_storage_image(
    uint32_t width, uint32_t height, ImageFormat format)
{
    if (!is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "TextureLoom not initialized");
        return nullptr;
    }
 
    auto vk_format = to_vulkan_format(format);
    auto image = std::make_shared<Core::VKImage>(
        width, height, 1, vk_format,
        Core::VKImage::Usage::STORAGE,
        Core::VKImage::Type::TYPE_2D,
        1, 1, Kakshya::DataModality::IMAGE_COLOR);
 
    m_resource_manager->initialize_image(image);
 
    if (!image->is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Failed to initialize storage image VKImage");
        return nullptr;
    }
 
    m_resource_manager->transition_image_layout(
        image->get_image(),
        vk::ImageLayout::eUndefined,
        vk::ImageLayout::eGeneral,
        1, 1, vk::ImageAspectFlagBits::eColor);
    image->set_current_layout(vk::ImageLayout::eGeneral);
 
    m_textures.push_back(image);
    MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
        "Created storage image: {}x{}, format: {}",
        width, height, vk::to_string(vk_format));
    return image;
}
 
std::shared_ptr<Core::VKImage> TextureLoom::acquire_cached_image(
    ImageCacheEntry& entry, const ImageKey& key)
{
    if (key.width == 0 || key.height == 0 || key.layers == 0
        || key.mip_levels == 0)
        return nullptr;
 
    const auto usage = key.kind == ImageKey::Kind::STORAGE_2D
        ? Core::VKImage::Usage::STORAGE
        : Core::VKImage::Usage::TEXTURE_2D;
    if (entry.image && entry.key == key && entry.image->is_initialized()
        && entry.image->get_width() == key.width
        && entry.image->get_height() == key.height
        && entry.image->get_array_layers() == key.layers
        && entry.image->get_mip_levels() == key.mip_levels
        && entry.image->get_format() == to_vulkan_format(key.format)
        && entry.image->get_usage() == usage) {
        return entry.image;
    }
 
    std::shared_ptr<Core::VKImage> image;
    switch (key.kind) {
    case ImageKey::Kind::SAMPLED_2D:
        if (key.layers != 1)
            return nullptr;
        image = create_2d(key.width, key.height, key.format, nullptr, key.mip_levels);
        break;
    case ImageKey::Kind::SAMPLED_ARRAY:
        if (key.mip_levels != 1)
            return nullptr;
        image = create_2d_array(key.width, key.height, key.layers, key.format, nullptr);
        break;
    case ImageKey::Kind::STORAGE_2D:
        if (key.layers != 1 || key.mip_levels != 1)
            return nullptr;
        image = create_storage_image(key.width, key.height, key.format);
        break;
    }
 
    if (image) {
        entry.key = key;
        entry.image = image;
    }
    return image;
}
 
std::shared_ptr<Core::VKImage> TextureLoom::refresh_cached_image(
    ImageCacheEntry& entry,
    const ImageKey& key,
    std::span<const uint8_t> pixels,
    const std::shared_ptr<Buffers::VKBuffer>& staging)
{
    if (key.kind == ImageKey::Kind::STORAGE_2D || key.width == 0
        || key.height == 0 || key.layers == 0)
        return nullptr;
 
    const size_t required = calculate_image_size(key.width, key.height, 1, key.format)
        * key.layers;
    if (pixels.size() != required) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Cached image upload has {} bytes, expected {}", pixels.size(), required);
        return nullptr;
    }
 
    if (staging && (staging->get_size() < required || !staging->get_mapped_ptr())) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Cached image staging buffer is unavailable or too small");
        return nullptr;
    }
 
    auto image = acquire_cached_image(entry, key);
    if (!image)
        return nullptr;
 
    if (staging) {
        upload_data(image, pixels.data(), pixels.size(), staging);
    } else {
        upload_data(image, pixels.data(), pixels.size());
    }
 
    return image;
}
 
std::shared_ptr<Core::VKImage> ImageCacheSet::acquire(
    TextureLoom& loom, const ImageKey& key)
{
    if (m_last_entry && m_last_key == key)
        return m_last_entry->cache.image;
 
    auto found = m_entries.find(key);
    if (found != m_entries.end()) {
        m_last_key = key;
        m_last_entry = &found->second;
        return found->second.cache.image;
    }
 
    ImageCacheEntry cache;
    auto image = loom.acquire_cached_image(cache, key);
    if (!image)
        return nullptr;
 
    m_last_key.reset();
    m_last_entry = nullptr;
 
    auto [added, inserted] = m_entries.emplace(key, Entry { .cache = std::move(cache) });
    if (!inserted)
        return added->second.cache.image;
 
    m_cached_bytes += image->get_size_bytes();
    if (!m_budget_warned && m_cached_bytes > m_byte_budget) {
        m_budget_warned = true;
        MF_WARN(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Image cache holds {} bytes, exceeding its {}-byte warning threshold",
            m_cached_bytes, m_byte_budget);
    }
 
    m_last_key = key;
    m_last_entry = &added->second;
    return image;
}
 
std::shared_ptr<Core::VKImage> TextureLoom::create_2d(
    const Kakshya::DataVariant& variant,
    uint32_t width,
    uint32_t height,
    ImageFormat format)
{
    if (!is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "TextureLoom not initialized");
        return nullptr;
    }
 
    const auto access = Kakshya::as_texture_access(variant);
    if (!access) {
        return nullptr;
    }
 
    const size_t expected = calculate_image_size(width, height, 1, format);
    if (access->byte_count != expected) {
        error<std::invalid_argument>(
            Journal::Component::Portal,
            Journal::Context::ImageProcessing,
            std::source_location::current(),
            "create_2d: byte count mismatch — {} bytes supplied, "
            "{}x{} format {} requires {}",
            access->byte_count, width, height, static_cast<int>(format), expected);
    }
 
    return create_2d(width, height, format, access->data_ptr, 1);
}
 
//==============================================================================
// Data Upload/Download
//==============================================================================
 
void TextureLoom::upload_data(
    const std::shared_ptr<Core::VKImage>& image, const void* data, size_t size)
{
    if (!is_initialized() || !image || !data) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Invalid parameters for upload_data");
        return;
    }
 
    m_resource_manager->upload_image_data(image, data, size);
}
 
void TextureLoom::upload_data(
    const std::shared_ptr<Core::VKImage>& image,
    const void* data,
    size_t size,
    const std::shared_ptr<Buffers::VKBuffer>& staging,
    bool deferred)
{
    if (!is_initialized() || !image || !data || !staging) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Invalid parameters for upload_data_streaming");
        return;
    }
 
    m_resource_manager->upload_image_data(image, data, size, staging, deferred);
}
 
void TextureLoom::download_data(
    const std::shared_ptr<Core::VKImage>& image,
    void* data,
    size_t size,
    const std::shared_ptr<Buffers::VKBuffer>& staging,
    bool deferred,
    vk::ImageLayout restore_layout,
    vk::PipelineStageFlags restore_stage)
{
    if (!is_initialized() || !image || !data) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "download_data(staging): invalid parameters");
        return;
    }
 
    m_resource_manager->download_image_data(
        image, data, size, staging, deferred, restore_layout, restore_stage);
}
 
std::optional<Kakshya::ImageData> TextureLoom::download_image(
    const std::shared_ptr<Core::VKImage>& image,
    const std::shared_ptr<Buffers::VKBuffer>& staging,
    vk::ImageLayout restore_layout,
    vk::PipelineStageFlags restore_stage)
{
    if (!is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "download_image: TextureLoom is not initialised");
        return std::nullopt;
    }
 
    const auto format = readable_format(image);
    if (!format) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "download_image: image is not readable as a single-layer 2D base level");
        return std::nullopt;
    }
 
    const size_t byte_count = calculate_image_size(image->get_width(), image->get_height(), 1, *format);
 
    auto result = Kakshya::ImageData::allocate(
        image->get_width(), image->get_height(), get_channel_count(*format), *format);
    if (!result || result->byte_size() != byte_count) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "download_image: format {} has no typed pixel storage matching its size", static_cast<int>(*format));
        return std::nullopt;
    }
 
    download_data(image, result->data(), byte_count, staging, false, restore_layout, restore_stage);
 
    if (!result->is_consistent()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "download_image: downloaded pixels do not match format {}", static_cast<int>(*format));
        return std::nullopt;
    }
 
    return result;
}
 
void TextureLoom::transition_layout(
    const std::shared_ptr<Core::VKImage>& image,
    vk::ImageLayout old_layout,
    vk::ImageLayout new_layout,
    uint32_t mip_levels,
    uint32_t array_layers,
    vk::ImageAspectFlags aspect_mask)
{
    if (!is_initialized() || !image) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Invalid parameters for transition_vk_image_layout");
        return;
    }
 
    m_resource_manager->transition_image_layout(
        image->get_image(),
        old_layout,
        new_layout,
        mip_levels, array_layers, aspect_mask);
 
    image->set_current_layout(new_layout);
}
 
namespace {
 
    vk::Filter to_blit_filter(FilterMode mode)
    {
        return mode == FilterMode::NEAREST ? vk::Filter::eNearest : vk::Filter::eLinear;
    }
 
    std::optional<std::pair<vk::Offset3D, vk::Offset3D>> region_offsets(
        const vk::Rect2D& region, const Core::VKImage& image)
    {
        const int32_t left = region.offset.x;
        const int32_t top = region.offset.y;
 
        if (left < 0 || top < 0
            || static_cast<uint32_t>(left) >= image.get_width()
            || static_cast<uint32_t>(top) >= image.get_height()) {
            return std::nullopt;
        }
 
        const auto x = static_cast<uint32_t>(left);
        const auto y = static_cast<uint32_t>(top);
        const uint32_t width = region.extent.width != 0 ? region.extent.width : image.get_width() - x;
        const uint32_t height = region.extent.height != 0 ? region.extent.height : image.get_height() - y;
 
        if (x + width > image.get_width() || y + height > image.get_height()) {
            return std::nullopt;
        }
 
        return std::pair {
            vk::Offset3D { left, top, 0 },
            vk::Offset3D { static_cast<int32_t>(x + width), static_cast<int32_t>(y + height), 1 }
        };
    }
 
}
 
bool TextureLoom::upload_layer(
    const std::shared_ptr<Core::VKImage>& image,
    uint32_t layer,
    const void* data,
    size_t size,
    const std::shared_ptr<Buffers::VKBuffer>& staging,
    bool deferred)
{
    if (!is_initialized() || !image || !data) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Invalid parameters for upload_layer");
        return false;
    }
 
    return m_resource_manager->upload_image_layer(image, layer, data, size, staging, deferred);
}
 
bool TextureLoom::can_blit(
    const std::shared_ptr<Core::VKImage>& src,
    const std::shared_ptr<Core::VKImage>& dst,
    FilterMode filter) const
{
    if (!is_initialized() || !src || !dst) {
        return false;
    }
 
    return m_resource_manager->supports_blit(
        src->get_format(), dst->get_format(), to_blit_filter(filter));
}
 
bool TextureLoom::blit_layer(
    const std::shared_ptr<Core::VKImage>& src,
    const std::shared_ptr<Core::VKImage>& dst,
    const LayerBlit& blit,
    bool deferred)
{
    if (!is_initialized() || !src || !dst) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "Invalid parameters for blit_layer");
        return false;
    }
 
    if (blit.src_layer >= src->get_array_layers() || blit.dst_layer >= dst->get_array_layers()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "blit_layer: layer {} of {} or layer {} of {} does not exist",
            blit.src_layer, src->get_array_layers(), blit.dst_layer, dst->get_array_layers());
        return false;
    }
 
    constexpr auto color = vk::ImageAspectFlagBits::eColor;
    if (src->get_aspect_flags() != color || dst->get_aspect_flags() != color) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "blit_layer: only color images can be blitted");
        return false;
    }
 
    const auto src_offsets = region_offsets(blit.src, *src);
    auto dst_offsets = region_offsets(blit.dst, *dst);
    if (!src_offsets || !dst_offsets) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "blit_layer: a rectangle lies outside its image");
        return false;
    }
 
    if (blit.filter == FilterMode::CUBIC) {
        MF_WARN(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "blit_layer: cubic filtering is not available, using linear");
    }
 
    if (blit.flip_x) {
        std::swap(dst_offsets->first.x, dst_offsets->second.x);
    }
    if (blit.flip_y) {
        std::swap(dst_offsets->first.y, dst_offsets->second.y);
    }
 
    const vk::ImageBlit region {
        vk::ImageSubresourceLayers { color, 0, blit.src_layer, 1 },
        { src_offsets->first, src_offsets->second },
        vk::ImageSubresourceLayers { color, 0, blit.dst_layer, 1 },
        { dst_offsets->first, dst_offsets->second }
    };
 
    return m_resource_manager->blit_image(src, dst, region, to_blit_filter(blit.filter), deferred);
}
 
//==============================================================================
// Sampler Management
//==============================================================================
 
vk::Sampler TextureLoom::get_or_create_sampler(const SamplerConfig& config)
{
    if (!is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
            "TextureLoom not initialized");
        return nullptr;
    }
 
    size_t hash = hash_sampler_config(config);
    auto it = m_sampler_cache.find(hash);
    if (it != m_sampler_cache.end()) {
        return it->second;
    }
 
    vk::Sampler sampler = create_sampler(config);
    m_sampler_cache[hash] = sampler;
    return sampler;
}
 
vk::Sampler TextureLoom::get_default_sampler()
{
    SamplerConfig config;
    return get_or_create_sampler(config);
}
 
vk::Sampler TextureLoom::get_nearest_sampler()
{
    SamplerConfig config;
    config.mag_filter = FilterMode::NEAREST;
    config.min_filter = FilterMode::NEAREST;
    config.address_mode_u = AddressMode::CLAMP_TO_EDGE;
    config.address_mode_v = AddressMode::CLAMP_TO_EDGE;
    return get_or_create_sampler(config);
}
 
vk::Sampler TextureLoom::create_sampler(const SamplerConfig& config)
{
    return m_resource_manager->create_sampler(
        static_cast<vk::Filter>(config.mag_filter),
        static_cast<vk::SamplerAddressMode>(config.address_mode_u),
        config.max_anisotropy);
}
 
size_t TextureLoom::hash_sampler_config(const SamplerConfig& config)
{
    size_t hash = 0;
    hash ^= std::hash<int> {}(static_cast<int>(config.mag_filter)) << 0;
    hash ^= std::hash<int> {}(static_cast<int>(config.min_filter)) << 4;
    hash ^= std::hash<int> {}(static_cast<int>(config.address_mode_u)) << 8;
    hash ^= std::hash<int> {}(static_cast<int>(config.address_mode_v)) << 12;
    hash ^= std::hash<int> {}(static_cast<int>(config.address_mode_w)) << 16;
    hash ^= std::hash<float> {}(config.max_anisotropy) << 20;
    hash ^= std::hash<bool> {}(config.enable_mipmaps) << 24;
    return hash;
}
 
//==============================================================================
// Utilities
//==============================================================================
 
vk::Format TextureLoom::to_vulkan_format(ImageFormat format)
{
    switch (format) {
    case ImageFormat::R8:
        return vk::Format::eR8Unorm;
    case ImageFormat::RG8:
        return vk::Format::eR8G8Unorm;
    case ImageFormat::RGB8:
        return vk::Format::eR8G8B8Unorm;
    case ImageFormat::RGBA8:
        return vk::Format::eR8G8B8A8Unorm;
    case ImageFormat::RGBA8_SRGB:
        return vk::Format::eR8G8B8A8Srgb;
    case ImageFormat::BGRA8:
        return vk::Format::eB8G8R8A8Unorm;
    case ImageFormat::BGRA8_SRGB:
        return vk::Format::eB8G8R8A8Srgb;
    case ImageFormat::R16:
        return vk::Format::eR16Unorm;
    case ImageFormat::RG16:
        return vk::Format::eR16G16Unorm;
    case ImageFormat::RGBA16:
        return vk::Format::eR16G16B16A16Unorm;
    case ImageFormat::R16F:
        return vk::Format::eR16Sfloat;
    case ImageFormat::RG16F:
        return vk::Format::eR16G16Sfloat;
    case ImageFormat::RGBA16F:
        return vk::Format::eR16G16B16A16Sfloat;
    case ImageFormat::R32F:
        return vk::Format::eR32Sfloat;
    case ImageFormat::RG32F:
        return vk::Format::eR32G32Sfloat;
    case ImageFormat::RGBA32F:
        return vk::Format::eR32G32B32A32Sfloat;
    case ImageFormat::DEPTH16:
        return vk::Format::eD16Unorm;
    case ImageFormat::DEPTH24:
        return vk::Format::eX8D24UnormPack32;
    case ImageFormat::DEPTH32F:
        return vk::Format::eD32Sfloat;
    case ImageFormat::DEPTH24_STENCIL8:
        return vk::Format::eD24UnormS8Uint;
    default:
        return vk::Format::eR8G8B8A8Unorm;
    }
}
 
size_t TextureLoom::get_bytes_per_pixel(ImageFormat format)
{
    switch (format) {
    case ImageFormat::R8:
        return 1;
    case ImageFormat::RG8:
        return 2;
    case ImageFormat::RGB8:
        return 3;
    case ImageFormat::RGBA8:
    case ImageFormat::RGBA8_SRGB:
    case ImageFormat::BGRA8:
    case ImageFormat::BGRA8_SRGB:
        return 4;
    case ImageFormat::R16:
        return 2;
    case ImageFormat::RG16:
        return 4;
    case ImageFormat::RGBA16:
        return 8;
    case ImageFormat::R16F:
        return 2;
    case ImageFormat::RG16F:
        return 4;
    case ImageFormat::RGBA16F:
        return 8;
    case ImageFormat::R32F:
        return 4;
    case ImageFormat::RG32F:
        return 8;
    case ImageFormat::RGBA32F:
        return 16;
    case ImageFormat::DEPTH16:
        return 2;
    case ImageFormat::DEPTH24:
    case ImageFormat::DEPTH32F:
    case ImageFormat::DEPTH24_STENCIL8:
    default:
        return 4;
    }
}
 
std::optional<ImageFormat> TextureLoom::from_vulkan_format(vk::Format vk_format)
{
    switch (vk_format) {
    case vk::Format::eR8Unorm:
        return ImageFormat::R8;
    case vk::Format::eR8G8Unorm:
        return ImageFormat::RG8;
    case vk::Format::eR8G8B8Unorm:
        return ImageFormat::RGB8;
    case vk::Format::eR8G8B8A8Unorm:
        return ImageFormat::RGBA8;
    case vk::Format::eR8G8B8A8Srgb:
        return ImageFormat::RGBA8_SRGB;
    case vk::Format::eB8G8R8A8Unorm:
        return ImageFormat::BGRA8;
    case vk::Format::eB8G8R8A8Srgb:
        return ImageFormat::BGRA8_SRGB;
 
    case vk::Format::eR16Unorm:
        return ImageFormat::R16;
    case vk::Format::eR16G16Unorm:
        return ImageFormat::RG16;
    case vk::Format::eR16G16B16A16Unorm:
        return ImageFormat::RGBA16;
 
    case vk::Format::eR16Sfloat:
        return ImageFormat::R16F;
    case vk::Format::eR16G16Sfloat:
        return ImageFormat::RG16F;
    case vk::Format::eR16G16B16A16Sfloat:
        return ImageFormat::RGBA16F;
 
    case vk::Format::eR32Sfloat:
        return ImageFormat::R32F;
    case vk::Format::eR32G32Sfloat:
        return ImageFormat::RG32F;
    case vk::Format::eR32G32B32A32Sfloat:
        return ImageFormat::RGBA32F;
 
    case vk::Format::eD16Unorm:
        return ImageFormat::DEPTH16;
    case vk::Format::eX8D24UnormPack32:
        return ImageFormat::DEPTH24;
    case vk::Format::eD32Sfloat:
        return ImageFormat::DEPTH32F;
    case vk::Format::eD24UnormS8Uint:
        return ImageFormat::DEPTH24_STENCIL8;
 
    default:
        return std::nullopt;
    }
}
 
std::optional<ImageFormat> TextureLoom::transfer_format(
    const std::shared_ptr<Core::VKImage>& image,
    vk::ImageUsageFlagBits required_usage)
{
    if (!image || !image->is_initialized()) {
        return std::nullopt;
    }
 
    if (image->get_type() != Core::VKImage::Type::TYPE_2D
        || image->get_depth() != 1 || image->get_array_layers() != 1) {
        return std::nullopt;
    }
 
    if (!static_cast<bool>(image->get_usage_flags() & required_usage)) {
        return std::nullopt;
    }
 
    const auto aspects = image->get_aspect_flags();
    if (static_cast<bool>(aspects & vk::ImageAspectFlagBits::eDepth)
        && static_cast<bool>(aspects & vk::ImageAspectFlagBits::eStencil)) {
        return std::nullopt;
    }
 
    const auto format = from_vulkan_format(image->get_format());
    if (!format) {
        return std::nullopt;
    }
 
    const size_t byte_count = calculate_image_size(image->get_width(), image->get_height(), 1, *format);
    if (byte_count == 0 || byte_count > image->get_size_bytes()) {
        return std::nullopt;
    }
 
    return format;
}
 
std::optional<ImageFormat> TextureLoom::readable_format(
    const std::shared_ptr<Core::VKImage>& image)
{
    return transfer_format(image, vk::ImageUsageFlagBits::eTransferSrc);
}
 
std::optional<ImageFormat> TextureLoom::writable_format(
    const std::shared_ptr<Core::VKImage>& image)
{
    return transfer_format(image, vk::ImageUsageFlagBits::eTransferDst);
}
 
size_t TextureLoom::calculate_image_size(
    uint32_t width, uint32_t height, uint32_t depth, ImageFormat format)
{
    return static_cast<size_t>(width) * height * depth * get_bytes_per_pixel(format);
}
 
uint32_t TextureLoom::get_channel_count(ImageFormat format)
{
    switch (format) {
    case ImageFormat::R8:
    case ImageFormat::R16:
    case ImageFormat::R16F:
    case ImageFormat::R32F:
        return 1;
 
    case ImageFormat::RG8:
    case ImageFormat::RG16:
    case ImageFormat::RG16F:
    case ImageFormat::RG32F:
        return 2;
 
    case ImageFormat::RGB8:
        return 3;
 
    case ImageFormat::RGBA8:
    case ImageFormat::RGBA8_SRGB:
    case ImageFormat::BGRA8:
    case ImageFormat::BGRA8_SRGB:
    case ImageFormat::RGBA16:
    case ImageFormat::RGBA16F:
    case ImageFormat::RGBA32F:
        return 4;
 
    case ImageFormat::DEPTH16:
    case ImageFormat::DEPTH24:
    case ImageFormat::DEPTH32F:
        return 1;
 
    case ImageFormat::DEPTH24_STENCIL8:
        return 2;
 
    default:
        return 0;
    }
}
 
} // namespace MayaFlux::Portal::Graphics