resize()

void MayaFlux::Buffers::VKBuffer::resize	(	size_t	new_size,
		bool	preserve_data = false
	)

Resize buffer and recreate GPU resources if needed.

Parameters

new_size	New size in bytes
preserve_data	If true, copy existing data to new buffer

If buffer is already initialized (has GPU resources), this will:

1. Create new GPU buffer with new size
2. Optionally copy old data
3. Destroy old GPU buffer
4. Update buffer resources

If buffer is not initialized, just updates logical size.

Definition at line 142 of file VKBuffer.cpp.

{
    if (new_size == m_size_bytes)
        return;
 
    if (!is_initialized()) {
        m_size_bytes = new_size;
        infer_dimensions_from_data(new_size);
 
        MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferManagement,
            "Cannot resize uninitialized VKBuffer");
        return;
    }
 
    auto buffer_service = Registry::BackendRegistry::instance()
                              .get_service<Registry::Service::BufferService>();
 
    if (!buffer_service) {
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::BufferManagement,
            std::source_location::current(),
            "Cannot resize buffer: BufferService not available");
    }
 
    std::vector<uint8_t> old_data;
    if (preserve_data && is_host_visible() && m_resources.mapped_ptr) {
        size_t copy_size = std::min(m_size_bytes, new_size);
        old_data.resize(copy_size);
        std::memcpy(old_data.data(), m_resources.mapped_ptr, copy_size);
 
        MF_DEBUG(Journal::Component::Buffers, Journal::Context::BufferManagement,
            "Preserved {} bytes of old buffer data", copy_size);
    }
 
    auto display_service = Registry::BackendRegistry::instance()
                               .get_service<Registry::Service::DisplayService>();
 
    if (!display_service) {
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::BufferManagement,
            std::source_location::current(),
            "Cannot resize buffer: BufferService not available");
    }
 
    display_service->wait_idle();
    buffer_service->destroy_buffer(shared_from_this());
 
    m_resources.buffer = vk::Buffer {};
    m_resources.memory = vk::DeviceMemory {};
    m_resources.mapped_ptr = nullptr;
 
    m_size_bytes = new_size;
    infer_dimensions_from_data(new_size);
 
    buffer_service->initialize_buffer(shared_from_this());
 
    if (!is_initialized()) {
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::BufferManagement,
            std::source_location::current(),
            "Failed to recreate buffer after resize");
    }
 
    if (preserve_data && !old_data.empty() && is_host_visible() && m_resources.mapped_ptr) {
        std::memcpy(m_resources.mapped_ptr, old_data.data(), old_data.size());
        mark_dirty_range(0, old_data.size());
 
        MF_DEBUG(Journal::Component::Buffers, Journal::Context::BufferManagement,
            "Restored {} bytes to resized buffer", old_data.size());
    }
 
    // clear_pipeline_commands();
 
    MF_INFO(Journal::Component::Buffers, Journal::Context::BufferManagement,
        "VKBuffer resize complete: {} bytes", m_size_bytes);
}

References MayaFlux::Buffers::VKBufferResources::buffer, MayaFlux::Journal::BufferManagement, MayaFlux::Journal::Buffers, MayaFlux::Registry::BackendRegistry::get_service(), infer_dimensions_from_data(), MayaFlux::Registry::BackendRegistry::instance(), is_host_visible(), is_initialized(), m_resources, m_size_bytes, MayaFlux::Buffers::VKBufferResources::mapped_ptr, mark_dirty_range(), MayaFlux::Buffers::VKBufferResources::memory, MF_DEBUG, MF_INFO, and MF_RT_ERROR.

Here is the call graph for this function: