insert_submesh()

void MayaFlux::Kakshya::MeshInsertion::insert_submesh	(	std::span< const uint8_t >	vertex_bytes,
		std::span< const uint32_t >	index_data,
		std::string_view	name = {},
		std::string_view	material_name = {},
		const VertexLayout &	layout = VertexLayout::for_meshes(60)
	)

Append one submesh batch, accumulating into the shared buffers.

Vertex bytes are appended to the existing vector<uint8_t>; indices are offset by the current vertex count and appended to vector<uint32_t>. A Region is added to the internal submesh RegionGroup recording the index sub-range and names.

layout is taken from the first call; subsequent calls must have the same stride_bytes and attribute count. Mismatches log an error and skip the batch.

Parameters

vertex_bytes	Raw interleaved vertex data for this submesh.
index_data	Triangle indices local to this submesh (0-based).
name	Submesh name (may be empty).
material_name	Material name (may be empty).
layout	Vertex layout; ignored after first call.

Definition at line 101 of file MeshInsertion.cpp.

{
    if (layout.stride_bytes == 0) {
        MF_ERROR(Journal::Component::Kakshya, Journal::Context::Runtime,
            "MeshInsertion::insert_submesh: layout stride_bytes is zero");
        return;
    }
    if (vertex_bytes.size() % layout.stride_bytes != 0) {
        MF_ERROR(Journal::Component::Kakshya, Journal::Context::Runtime,
            "MeshInsertion::insert_submesh: vertex_bytes {} not a multiple of stride {}",
            vertex_bytes.size(), layout.stride_bytes);
        return;
    }
    if (index_data.size() % 3 != 0) {
        MF_ERROR(Journal::Component::Kakshya, Journal::Context::Runtime,
            "MeshInsertion::insert_submesh: index count {} is not a multiple of 3",
            index_data.size());
        return;
    }
 
    if (!m_layout_set) {
        m_layout = layout;
        m_layout_set = true;
    } else if (!validate_layout(layout)) {
        return;
    }
 
    ensure_vertex_storage();
    ensure_index_storage();
 
    auto& vbuf = std::get<std::vector<uint8_t>>(m_vertex_variant);
    auto& ibuf = std::get<std::vector<uint32_t>>(m_index_variant);
 
    const auto submesh_vcount = static_cast<uint32_t>(vertex_bytes.size() / layout.stride_bytes);
    const uint32_t index_start = m_index_count;
 
    vbuf.insert(vbuf.end(), vertex_bytes.begin(), vertex_bytes.end());
 
    ibuf.reserve(ibuf.size() + index_data.size());
    for (const uint32_t idx : index_data) {
        ibuf.push_back(idx + m_vertex_count);
    }
 
    MeshSubrange sub;
    sub.index_start = index_start;
    sub.index_count = static_cast<uint32_t>(index_data.size());
    sub.vertex_offset = m_vertex_count;
    sub.name = std::string(name);
    sub.material_name = std::string(material_name);
 
    if (!m_submeshes.has_value()) {
        m_submeshes = RegionGroup("submeshes");
    }
    m_submeshes->add_region(sub.to_region());
 
    m_vertex_count += submesh_vcount;
    m_index_count += static_cast<uint32_t>(index_data.size());
    m_layout.vertex_count = m_vertex_count;
 
    MF_DEBUG(Journal::Component::Kakshya, Journal::Context::Runtime,
        "MeshInsertion::insert_submesh: '{}' +{} vertices, +{} indices, "
        "running totals: {} vertices / {} indices",
        name.empty() ? "<unnamed>" : name,
        submesh_vcount, index_data.size(),
        m_vertex_count, m_index_count);
}

References ensure_index_storage(), ensure_vertex_storage(), MayaFlux::Kakshya::MeshSubrange::index_count, MayaFlux::Kakshya::MeshSubrange::index_start, MayaFlux::Journal::Kakshya, m_index_count, m_index_variant, m_layout, m_layout_set, m_submeshes, m_vertex_count, m_vertex_variant, MayaFlux::Kakshya::MeshSubrange::material_name, MF_DEBUG, MF_ERROR, MayaFlux::Kakshya::MeshSubrange::name, MayaFlux::Journal::Runtime, MayaFlux::Kakshya::VertexLayout::stride_bytes, MayaFlux::Kakshya::MeshSubrange::to_region(), validate_layout(), MayaFlux::Kakshya::VertexLayout::vertex_count, and MayaFlux::Kakshya::MeshSubrange::vertex_offset.

Here is the call graph for this function: