create_mesh_network()

std::shared_ptr< Nodes::Network::MeshNetwork > MayaFlux::IO::ModelReader::create_mesh_network

(

const TextureResolver &

resolver = nullptr

)

const

Construct a MeshNetwork from all meshes in the currently loaded scene.

One MeshSlot per aiMesh, named from aiMesh::mName (or "mesh_N" if unnamed). Each slot's MeshWriterNode holds the extracted vertex and index data.

If resolver is provided, it is called with the raw diffuse path from each mesh's material. The returned VKImage is assigned to slot.diffuse_texture. Null resolver skips texture binding entirely.

Requires open(). Does not call close().

Parameters

resolver

Optional texture resolver.

Returns

Populated MeshNetwork, or nullptr if no scene is loaded.

Definition at line 155 of file ModelReader.cpp.

{
    if (!m_impl->scene) {
        set_error("No scene loaded");
        return nullptr;
    }
 
    auto net = std::make_shared<Nodes::Network::MeshNetwork>();
    const aiScene* s = m_impl->scene;
 
    for (unsigned int i = 0; i < s->mNumMeshes; ++i) {
        const aiMesh* ai_mesh = s->mMeshes[i];
 
        std::string mesh_name(ai_mesh->mName.C_Str());
        if (mesh_name.empty())
            mesh_name = "mesh_" + std::to_string(i);
 
        std::string mat_name;
        if (s->mNumMaterials > 0 && ai_mesh->mMaterialIndex < s->mNumMaterials) {
            aiString ai_mat;
            s->mMaterials[ai_mesh->mMaterialIndex]->Get(AI_MATKEY_NAME, ai_mat);
            mat_name = ai_mat.C_Str();
        }
 
        auto mesh_data = extract_single_mesh(ai_mesh, s, mesh_name, mat_name);
        if (!mesh_data.is_valid()) {
            MF_WARN(Journal::Component::IO, Journal::Context::FileIO,
                "ModelReader::create_mesh_network: skipping invalid mesh '{}'", mesh_name);
            continue;
        }
 
        const auto* vb = std::get_if<std::vector<uint8_t>>(&mesh_data.vertex_variant);
        const auto* ib = std::get_if<std::vector<uint32_t>>(&mesh_data.index_variant);
 
        if (!vb || !ib)
            continue;
 
        const size_t vertex_count = vb->size() / sizeof(Nodes::MeshVertex);
        auto node = std::make_shared<Nodes::GpuSync::MeshWriterNode>(vertex_count);
        node->set_mesh(
            std::span<const Nodes::MeshVertex>(
                reinterpret_cast<const Nodes::MeshVertex*>(vb->data()),
                vertex_count),
            std::span<const uint32_t>(ib->data(), ib->size()));
 
        auto slot_idx = net->add_slot(mesh_name, node);
 
        if (resolver) {
            const auto raw = get_diffuse_path(mesh_data);
            if (!raw.empty()) {
                auto image = resolver(raw);
                if (image) {
                    net->get_slot(slot_idx).diffuse_texture = std::move(image);
                } else {
                    MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
                        "ModelReader::create_mesh_network: resolver returned null for '{}' (slot '{}')",
                        raw, mesh_name);
                }
            }
        }
    }
 
    MF_INFO(Journal::Component::IO, Journal::Context::FileIO,
        "ModelReader::create_mesh_network: {} slots", net->slot_count());
 
    return net;
}

References extract_single_mesh(), MayaFlux::Journal::FileIO, image, MayaFlux::Journal::IO, m_impl, MF_ERROR, MF_INFO, MF_WARN, and set_error().

Here is the call graph for this function: