write()

bool MayaFlux::IO::AssimpModelWriter::write ( const std::string &  filepath, const std::vector< Kakshya::MeshData > &  meshes, const ModelWriteOptions &  options = {}  )

overridevirtual

Write one or more meshes to disk as a single scene.

Parameters

filepath	Destination path.
meshes	One or more meshes. Must each satisfy MeshData::is_valid().
options	Format-specific options.

Returns

true on success. On failure call get_last_error().

Implements MayaFlux::IO::ModelWriter.

Definition at line 111 of file AssimpModelWriter.cpp.

{
    m_last_error.clear();
 
    if (meshes.empty()) {
        set_error("No meshes to write");
        return false;
    }
 
    for (const auto& m : meshes) {
        if (!m.is_valid()) {
            set_error("MeshData failed is_valid()");
            return false;
        }
        if (m.layout.stride_bytes != sizeof(Kakshya::MeshVertex)) {
            set_error("MeshData vertex stride is not the canonical MeshVertex layout");
            return false;
        }
    }
 
    const auto ext = extension_of(filepath);
    std::string format_id = options.format_id;
    if (format_id.empty()) {
        format_id = default_format_id(ext);
    }
    if (format_id.empty()) {
        set_error("No format_id resolved for extension '" + ext
            + "', pass ModelWriteOptions::format_id explicitly");
        return false;
    }
 
    // NOLINTBEGIN(cppcoreguidelines-owning-memory)
    // aiScene is a C-style struct: every array is a raw owning pointer freed
    // by aiScene's own destructor (and aiMesh's/aiMaterial's for their own
    // sub-arrays). A smart pointer cannot be substituted at this boundary.
    aiScene scene;
    scene.mRootNode = new aiNode();
 
    scene.mNumMaterials = static_cast<unsigned int>(meshes.size());
    scene.mMaterials = new aiMaterial*[scene.mNumMaterials];
 
    scene.mNumMeshes = static_cast<unsigned int>(meshes.size());
    scene.mMeshes = new aiMesh*[scene.mNumMeshes];
 
    scene.mRootNode->mNumMeshes = scene.mNumMeshes;
    scene.mRootNode->mMeshes = new unsigned int[scene.mNumMeshes];
 
    for (unsigned int mi = 0; mi < scene.mNumMeshes; ++mi) {
        const auto& mesh_data = meshes[mi];
        const auto info = submesh_info_for(mesh_data);
 
        auto* mat = new aiMaterial();
        const std::string mat_name = !options.material_name_override.empty()
            ? options.material_name_override
            : (!info.material_name.empty() ? info.material_name : "material_" + std::to_string(mi));
        aiString ai_mat_name(mat_name);
        mat->AddProperty(&ai_mat_name, AI_MATKEY_NAME);
        if (!info.diffuse_path.empty()) {
            aiString tex_path(info.diffuse_path);
            mat->AddProperty(&tex_path, AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));
        }
        scene.mMaterials[mi] = mat;
 
        auto* mesh = new aiMesh();
        mesh->mMaterialIndex = mi;
        mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
        mesh->mName = aiString(!info.name.empty() ? info.name : "mesh_" + std::to_string(mi));
 
        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);
 
        const auto* verts = reinterpret_cast<const Kakshya::MeshVertex*>(vb->data());
        const size_t vertex_count = vb->size() / sizeof(Kakshya::MeshVertex);
 
        mesh->mNumVertices = static_cast<unsigned int>(vertex_count);
        mesh->mVertices = new aiVector3D[vertex_count];
        mesh->mNormals = new aiVector3D[vertex_count];
        mesh->mTangents = new aiVector3D[vertex_count];
        mesh->mTextureCoords[0] = new aiVector3D[vertex_count];
        mesh->mNumUVComponents[0] = 2;
        mesh->mColors[0] = new aiColor4D[vertex_count];
 
        for (size_t v = 0; v < vertex_count; ++v) {
            const auto& mv = verts[v];
            mesh->mVertices[v] = aiVector3D(mv.position.x, mv.position.y, mv.position.z);
            mesh->mNormals[v] = aiVector3D(mv.normal.x, mv.normal.y, mv.normal.z);
            mesh->mTangents[v] = aiVector3D(mv.tangent.x, mv.tangent.y, mv.tangent.z);
            mesh->mTextureCoords[0][v] = aiVector3D(mv.uv.x, mv.uv.y, 0.0F);
            mesh->mColors[0][v] = aiColor4D(mv.color.x, mv.color.y, mv.color.z, 1.0F);
        }
 
        const size_t face_count = ib->size() / 3;
        mesh->mNumFaces = static_cast<unsigned int>(face_count);
        mesh->mFaces = new aiFace[face_count];
        for (size_t f = 0; f < face_count; ++f) {
            auto& face = mesh->mFaces[f];
            face.mNumIndices = 3;
            face.mIndices = new unsigned int[3] {
                (*ib)[(f * 3) + 0],
                (*ib)[(f * 3) + 1],
                (*ib)[(f * 3) + 2],
            };
        }
 
        scene.mMeshes[mi] = mesh;
        scene.mRootNode->mMeshes[mi] = mi;
    }
    // NOLINTEND(cppcoreguidelines-owning-memory)
 
    const auto resolved = resolve_write_path(filepath);
 
    Assimp::Exporter exporter;
    const auto ret = exporter.Export(&scene, format_id, resolved);
 
    if (ret != AI_SUCCESS) {
        set_error(exporter.GetErrorString());
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "AssimpModelWriter: export failed for '{}' (format '{}'): {}",
            resolved, format_id, m_last_error);
        return false;
    }
 
    MF_INFO(Journal::Component::IO, Journal::Context::FileIO,
        "AssimpModelWriter: wrote '{}', {} mesh(es), format '{}'",
        resolved, meshes.size(), format_id);
    return true;
}

References MayaFlux::Journal::FileIO, MayaFlux::IO::ModelWriteOptions::format_id, MayaFlux::Journal::IO, m_last_error, MayaFlux::IO::ModelWriteOptions::material_name_override, MF_ERROR, MF_INFO, MayaFlux::IO::resolve_write_path(), and set_error().

Here is the call graph for this function: