upload_combined()

void MayaFlux::Buffers::MeshNetworkProcessor::upload_combined ( const std::shared_ptr< VKBuffer > &  vertex_buf )

private

Definition at line 121 of file MeshNetworkProcessor.cpp.

{
    const auto& slots = m_network->slots();
    const auto& order = m_network->sorted_indices();
 
    m_vertex_aggregate.clear();
    m_index_aggregate.clear();
    m_model_aggregate.clear();
    m_slot_index_aggregate.clear();
 
    uint32_t running_vertex_count = 0;
 
    for (uint32_t idx : order) {
        const auto& slot = slots[idx];
        if (!slot.node)
            continue;
 
        const auto& verts = slot.node->get_mesh_vertices();
        const auto& indices = slot.node->get_mesh_indices();
 
        const size_t v_bytes = verts.size() * sizeof(Nodes::MeshVertex);
        const auto* v_src = reinterpret_cast<const uint8_t*>(verts.data());
        m_vertex_aggregate.insert(m_vertex_aggregate.end(), v_src, v_src + v_bytes);
 
        for (uint32_t i : indices)
            m_index_aggregate.push_back(i + running_vertex_count);
 
        m_model_aggregate.push_back(slot.world_transform);
 
        const auto sorted_slot_pos = static_cast<uint32_t>(m_model_aggregate.size() - 1);
        m_slot_index_aggregate.insert(
            m_slot_index_aggregate.end(), verts.size(), sorted_slot_pos);
 
        running_vertex_count += static_cast<uint32_t>(verts.size());
    }
 
    if (m_vertex_aggregate.empty())
        return;
 
    const size_t v_required = m_vertex_aggregate.size();
    if (v_required > vertex_buf->get_size_bytes()) {
        const auto new_size = static_cast<size_t>(
            static_cast<float>(v_required) * 1.5F);
        vertex_buf->resize(new_size, false);
        if (m_vertex_staging)
            m_vertex_staging->resize(new_size, false);
    }
 
    upload_to_gpu(
        m_vertex_aggregate.data(),
        v_required,
        vertex_buf,
        vertex_buf->is_host_visible() ? nullptr : m_vertex_staging);
 
    const size_t i_required = m_index_aggregate.size() * sizeof(uint32_t);
    if (m_gpu_index_buffer && i_required > m_gpu_index_buffer->get_size_bytes()) {
        const auto new_size = static_cast<size_t>(
            static_cast<float>(i_required) * 1.5F);
        m_gpu_index_buffer->resize(new_size, false);
        if (m_index_staging)
            m_index_staging->resize(new_size, false);
    }
 
    if (m_gpu_index_buffer && !m_index_aggregate.empty()) {
        upload_to_gpu(
            m_index_aggregate.data(),
            i_required,
            m_gpu_index_buffer,
            m_index_staging);
    }
 
    for (uint32_t idx : order) {
        const auto& slot = slots[idx];
        if (slot.node && slot.node->get_mesh_vertex_count() > 0) {
            if (auto layout = slot.node->get_vertex_layout()) {
                layout->vertex_count = running_vertex_count;
                vertex_buf->set_vertex_layout(*layout);
            }
            break;
        }
    }
}

References m_gpu_index_buffer, m_index_aggregate, m_index_staging, m_model_aggregate, m_network, m_slot_index_aggregate, m_vertex_aggregate, m_vertex_staging, and MayaFlux::Buffers::upload_to_gpu().

Referenced by on_attach(), and processing_function().

Here is the call graph for this function:

Here is the caller graph for this function: