extract_single_mesh()

Kakshya::MeshData MayaFlux::IO::ModelReader::extract_single_mesh ( const void *  ai_mesh, const void *  ai_scene, std::string_view  mesh_name, std::string_view  material_name  ) const

private

Definition at line 374 of file ModelReader.cpp.

{
    const auto* mesh = static_cast<const aiMesh*>(ai_mesh_ptr);
 
    using V = Nodes::MeshVertex;
 
    std::vector<V> verts;
    verts.reserve(mesh->mNumVertices);
 
    for (unsigned int v = 0; v < mesh->mNumVertices; ++v) {
        V vert {};
 
        vert.position = {
            mesh->mVertices[v].x,
            mesh->mVertices[v].y,
            mesh->mVertices[v].z
        };
 
        if (mesh->HasNormals()) {
            vert.normal = {
                mesh->mNormals[v].x,
                mesh->mNormals[v].y,
                mesh->mNormals[v].z
            };
        } else {
            vert.normal = { 0.0F, 1.0F, 0.0F };
        }
 
        if (mesh->HasTangentsAndBitangents()) {
            vert.tangent = {
                mesh->mTangents[v].x,
                mesh->mTangents[v].y,
                mesh->mTangents[v].z
            };
        } else {
            vert.tangent = { 1.0F, 0.0F, 0.0F };
        }
 
        if (mesh->HasTextureCoords(0)) {
            vert.uv = {
                mesh->mTextureCoords[0][v].x,
                mesh->mTextureCoords[0][v].y
            };
        } else {
            vert.uv = { 0.0F, 0.0F };
        }
 
        if (mesh->HasVertexColors(0)) {
            vert.color = {
                mesh->mColors[0][v].r,
                mesh->mColors[0][v].g,
                mesh->mColors[0][v].b
            };
        } else {
            vert.color = { 0.8F, 0.8F, 0.8F };
        }
 
        vert.weight = 0.0F;
        verts.push_back(vert);
    }
 
    std::vector<uint32_t> indices;
    indices.reserve(static_cast<size_t>(mesh->mNumFaces) * 3);
 
    for (unsigned int f = 0; f < mesh->mNumFaces; ++f) {
        const aiFace& face = mesh->mFaces[f];
        if (face.mNumIndices != 3) {
            continue;
        }
        indices.push_back(face.mIndices[0]);
        indices.push_back(face.mIndices[1]);
        indices.push_back(face.mIndices[2]);
    }
 
    if (verts.empty() || indices.empty()) {
        set_error("Mesh has no usable geometry after extraction");
        return {};
    }
 
    auto data = Kakshya::MeshData::empty();
    Kakshya::MeshInsertion ins(data.vertex_variant, data.index_variant);
    ins.insert_flat(
        std::span<const uint8_t>(
            reinterpret_cast<const uint8_t*>(verts.data()),
            verts.size() * sizeof(V)),
        std::span<const uint32_t>(indices),
        Kakshya::VertexLayout::for_meshes(sizeof(V)));
 
    auto access = ins.build();
    if (!access) {
        set_error("MeshInsertion::build() failed");
        return {};
    }
    data.layout = access->layout;
 
    Kakshya::MeshSubrange sub;
    sub.index_start = 0;
    sub.index_count = static_cast<uint32_t>(indices.size());
    sub.vertex_offset = 0;
    sub.name = std::string(mesh_name);
    sub.material_name = std::string(material_name);
 
    const auto* s = static_cast<const aiScene*>(ai_scene);
 
    if (s->mNumMaterials > 0 && mesh->mMaterialIndex < s->mNumMaterials) {
        aiString tex_path;
        const aiMaterial* mat = s->mMaterials[mesh->mMaterialIndex];
        if (mat->GetTexture(aiTextureType_DIFFUSE, 0, &tex_path) == AI_SUCCESS) {
            sub.diffuse_path = std::filesystem::path(tex_path.C_Str()).generic_string();
            sub.diffuse_embedded = (!sub.diffuse_path.empty()
                && sub.diffuse_path[0] == '*');
 
            MF_DEBUG(Journal::Component::IO, Journal::Context::FileIO,
                "ModelReader: mesh '{}' diffuse={} embedded={}",
                std::string(mesh_name),
                sub.diffuse_path,
                sub.diffuse_embedded);
        }
    }
 
    Kakshya::RegionGroup rg("submeshes");
    rg.add_region(sub.to_region());
    data.submeshes = std::move(rg);
 
    MF_DEBUG(Journal::Component::IO, Journal::Context::FileIO,
        "ModelReader: extracted mesh '{}' mat='{}' — {} verts, {} indices",
        mesh_name.empty() ? "<unnamed>" : mesh_name,
        material_name.empty() ? "<none>" : material_name,
        verts.size(), indices.size());
 
    return data;
}

References MayaFlux::Kakshya::RegionGroup::add_region(), MayaFlux::Kakshya::MeshInsertion::build(), MayaFlux::Kakshya::MeshSubrange::diffuse_embedded, MayaFlux::Kakshya::MeshSubrange::diffuse_path, MayaFlux::Kakshya::MeshData::empty(), MayaFlux::Journal::FileIO, MayaFlux::Kakshya::VertexLayout::for_meshes(), MayaFlux::Kakshya::MeshSubrange::index_count, MayaFlux::Kakshya::MeshSubrange::index_start, MayaFlux::Kakshya::MeshInsertion::insert_flat(), MayaFlux::Journal::IO, MayaFlux::Kakshya::MeshSubrange::material_name, MF_DEBUG, MayaFlux::Kakshya::MeshSubrange::name, MayaFlux::Nodes::MeshVertex::position, set_error(), MayaFlux::Kakshya::MeshSubrange::to_region(), MayaFlux::IO::V, and MayaFlux::Kakshya::MeshSubrange::vertex_offset.

Referenced by create_mesh_network(), and extract_meshes().

Here is the call graph for this function:

Here is the caller graph for this function: