from_image_array() [2/2]

void MayaFlux::Kakshya::TextureContainer::from_image_array	(	const std::shared_ptr< Core::VKImage > &	image,
		const std::shared_ptr< Buffers::VKBuffer > &	staging
	)

Download all array layers from a VKImage, reusing a caller-supplied persistent staging buffer.

Identical to from_image_array() but passes staging through to TextureLoom::download_data. The staging buffer must be at least byte_size() * get_layer_count() bytes. Use Buffers::create_image_staging_buffer(byte_size() * get_layer_count()) to allocate it once before the render loop.

Parameters

image	Source VKImage with array_layers >= get_layer_count().
staging	Host-visible staging VKBuffer sized to at least byte_size() * get_layer_count().

Definition at line 313 of file TextureContainer.cpp.

{
    if (!image || !image->is_initialized()) {
        MF_ERROR(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "TextureContainer::from_image_array(staging) called with uninitialised image");
        return;
    }
 
    const auto n = static_cast<uint32_t>(m_data.size());
    if (image->get_array_layers() < n) {
        MF_ERROR(Journal::Component::Kakshya, Journal::Context::ContainerProcessing,
            "TextureContainer::from_image_array(staging) image has {} layers, container expects {}",
            image->get_array_layers(), n);
        return;
    }
 
    const size_t layer_bytes = byte_size();
    std::vector<uint8_t> combined(layer_bytes * n);
    TextureLoom::instance().download_data(image, combined.data(), combined.size(), staging);
 
    const size_t element_count = static_cast<size_t>(m_width) * m_height * m_channels;
    for (uint32_t i = 0; i < n; ++i) {
        Memory::SeqlockWriteGuard g(m_slot_locks[i]);
        m_data[i] = make_empty_storage(m_format, element_count);
        auto [ptr, bytes] = variant_bytes_mutable(m_data[i]);
        if (ptr && bytes == layer_bytes)
            std::memcpy(ptr, combined.data() + i * layer_bytes, layer_bytes);
        m_cpu_stale[i].store(false, std::memory_order_release);
 
        m_normalised_dirty[i].store(true, std::memory_order_release);
    }
 
    update_processing_state(ProcessingState::READY);
}

References byte_size(), MayaFlux::Journal::ContainerProcessing, MayaFlux::Portal::Graphics::TextureLoom::download_data(), image, MayaFlux::Portal::Graphics::TextureLoom::instance(), MayaFlux::Journal::Kakshya, m_channels, m_cpu_stale, m_data, m_format, m_height, m_normalised_dirty, m_slot_locks, m_width, MayaFlux::Kakshya::make_empty_storage(), MF_ERROR, ptr, MayaFlux::Kakshya::READY, update_processing_state(), and MayaFlux::Kakshya::variant_bytes_mutable().

Here is the call graph for this function: