Using meshoptimizer code | Import model, optimize model, export optimized model

[Sturmik]

Hello, I am currently trying to use meshoptimizer library, however I am having trouble understanding how I should apply it. I am new to rendering and some of its concepts, so this might be the reason why I don't understand the problem I am facing now.

What I am looking for is to load model, optimize it and export it as new optimized version. By optimization I mean optimizing its vertices and indices (Indexing - Vertex cache optimization - Overdraw optimization - Vertex fetch optimization). The problem is that after applying the optimization I get a model with the incorrect texture or with more vertices than the original number.

I suppose similar issue was discussed here: #334. However, I couldn’t understand, what to do to in my case.

I use assimp (https://github.com/assimp/assimp) to import a model, apply meshoptimizer methods to it and export the new optimized version. I applied mesh optimization to .obj and .fbx files, but both types of models had the same problem with incorrect texture.
By the way, the size of the model file also increases after exporting, but I assume this is due to the assimp export method.

Can you please tell me where I am applying the optimization incorrectly and how to avoid distorting the model view?

---

Code:

#include <assimp/Importer.hpp>     
#include <assimp/Exporter.hpp>
#include <assimp/scene.h>         
#include <assimp/postprocess.h>    

#include "MeshOptimizer/meshoptimizer.h"

#include <vector>

struct vec3
{
  float x;
  float y;
  float z;

  vec3(): vec3(0.0,0.0,0.0){}
  vec3(float x, float y, float z) : x(x), y(y), z(z) {}
};

int main()
{
  // Import file
  Assimp::Importer importer;

  // OBJ example
  const aiScene* scene = importer.ReadFile("Chair.obj", aiProcess_Triangulate);

  // FBX example
  //   const aiScene* scene = importer.ReadFile("Container.fbx", aiProcess_Triangulate);

  // Iterate through all meshes and optimize them
  for (unsigned int m = 0; m < scene->mNumMeshes; ++m)
  { 
    // Get mesh
    aiMesh* mesh = scene->mMeshes[0];

    // Get mesh original positions and indices
    std::vector<vec3> positions;
    std::vector<unsigned int> indices;

    for (unsigned int i = 0; i != mesh->mNumVertices; i++) 
    {
      const aiVector3D v = mesh->mVertices[i];
      positions.push_back(vec3(v.x, v.z, v.y));
    }
    for (unsigned int i = 0; i != mesh->mNumFaces; i++) 
    {
      for (unsigned int j = 0; j != 3; j++)
      { 
        indices.push_back(mesh->mFaces[i].mIndices[j]);
      }
    }

    // Remap indices and vertices
    std::vector<unsigned int> remap(indices.size());
    const size_t vertexCount = meshopt_generateVertexRemap(remap.data(), indices.data(), indices.size(),
  positions.data(), indices.size(), sizeof(vec3));
  
    std::vector<unsigned int> remappedIndices(indices.size());
    std::vector<vec3> remappedVertices(vertexCount);
    meshopt_remapIndexBuffer(remappedIndices.data(), indices.data(), indices.size(), remap.data());
    meshopt_remapVertexBuffer(remappedVertices.data(), positions.data(), positions.size(), sizeof(vec3), remap.data());

    // Optimize vertex cache
    meshopt_optimizeVertexCache(remappedIndices.data(), remappedIndices.data(), indices.size(), vertexCount);

    // Optimize overdraw
    meshopt_optimizeOverdraw(remappedIndices.data(), remappedIndices.data(), indices.size(),
  &remappedVertices[0].x, vertexCount, sizeof(vec3), 1.05f);

    // Optimize vertex fetch
    meshopt_optimizeVertexFetch(remappedVertices.data(), remappedIndices.data(), indices.size(), 
    remappedVertices.data(), vertexCount, sizeof(vec3));

    // Update mesh vertices and faces
    mesh->mNumVertices = remappedVertices.size();
    mesh->mVertices = new aiVector3D[mesh->mNumVertices];

    mesh->mNumFaces = remappedIndices.size() / 3;
    mesh->mFaces = new aiFace[mesh->mNumFaces];
    for (unsigned int i = 0; i != mesh->mNumVertices; i++)
    {
      mesh->mVertices[i].x = remappedVertices[i].x;    
      mesh->mVertices[i].y = remappedVertices[i].y;
      mesh->mVertices[i].z = remappedVertices[i].z;
    }
    for (unsigned int i = 0, f = 0; i != remappedIndices.size(); i+=3, ++f)
    {
      mesh->mFaces[f].mNumIndices = 3;
      mesh->mFaces[f].mIndices = new unsigned int[mesh->mFaces[f].mNumIndices];
      mesh->mFaces[f].mIndices[0] = remappedIndices[i];
      mesh->mFaces[f].mIndices[1] = remappedIndices[i + 1];
      mesh->mFaces[f].mIndices[2] = remappedIndices[i + 2];
    }
  }

  // Export resulting mesh
  Assimp::Exporter exporter;

  // OBJ example
  exporter.Export(scene, "obj", "test.obj");

  // FBX example
  // exporter.Export(scene, "fbx", "test.fbx");
}

I will attach some results from the current program.

---

Example models: https://drive.google.com/drive/folders/1dQMGRbREltF-UKADxeA9UZ1IBWXZ4QW9?usp=sharing

FBX Container model optimization example (model with word optimization in the name was optimized with meshoptimizer, same rule will apply to all further examples):

FBX Container file size:

Initial Container.fbx:

Optimized Container.fbx:

---

OBJ Chair model optimization example:

OBJ Chair file size:

Initial Chair.obj:

Optimized Chair.obj:

---

FBX Sword model optimization example:
Here the number of vertices has increased.

FBX Sword file size:

Initial Sword.fbx:

Optimized Sword.fbx:

---

[zeux]

This code doesn't recompute or reorder any attributes like normals, so it would make sense to me that you're getting the wrong rendered output - this code is effectively merging vertices with the same positions but different attributes like normals as it doesn't pass anything but positions into meshopt_generateVertexRemap, but the mesh in question still contains normal/UV data that is not reindexed correctly.

There's two options here:

1. You can use meshopt functions without rebuilding vertex data as it would be simpler - for example, you can run optimizeVertexCache and optimizeOverdraw without running the other steps. These would preserve vertex data as is without any modifications, but may not be as optimal.
2. You can fully reprocess the mesh while taking into account all streams - not just positions. The easiest option is likely to use support for deinterleaved geometry, https://github.com/zeux/meshoptimizer#deinterleaved-geometry