Edge Collapse mit assimp

Question

Ich versuche, den Edge-Kollaps in meiner Game-Engine zu implementieren, es gibt ein Problem, das von Assimp verursacht wird. Die Indizes, die von face.mNumIndices analysiert werden, sind immer die Indexierung der Inkrementreihenfolge.

Wenn ich die Liste der Indizes überprüfe, sollte der Wert 0,1,2,3,4....,999... sein. Aber ich weiß, das ist eine Art von mechanism, die von Assimp verwendet wird, und das Objekt wird in Ordnung gerendert. Aber es gibt ein anderes Problem bei Mesh Simplication, ich konnte die Half-Edge-Struktur für diese Indizes nicht erzeugen. Ich blieb ein paar Tage dran und habe keine Antwort. Soll ich Assimp aufgeben? Jede Beratung wird geschätzt.

Bearbeiten: Meine Scheitelpunkte sind zwischen den Gesichtern geteilt, Der Code, den ich verwendet, um die Daten hier zu erhalten.

BasicRenderModel* AssimpLoader::ProcessMeshBasicVersion(aiMesh * mesh, const aiScene * scene) 
{ 
    //std::vector<Vertex> vertices; 
    float *vertices = new float[mesh->mNumVertices * 3]; 
    int vertexLength = mesh->mNumVertices * 3; 
    float *normals = new float[mesh->mNumVertices * 3]; 
    int normalLength = mesh->mNumVertices * 3; 
    float *texCoords = new float[mesh->mNumVertices * 2]; 
    int texCoordLength = mesh->mNumVertices * 2; 
    std::vector<int> indicesList; 
    int *indices; 
    int indexLength; 

    //std::vector<Texture> textures; 
    std::map<TextureType, std::vector<Texture>> textures; 
    for (GLuint i = 0; i < mesh->mNumVertices; i++) 
    { 
     // Process vertex positions, normals and texture coordinates 
     vertices[i * 3] = mesh->mVertices[i].x; 
     vertices[i * 3 + 1] = mesh->mVertices[i].y; 
     vertices[i * 3 + 2] = mesh->mVertices[i].z; 
     normals[i * 3] = mesh->mNormals[i].x; 
     normals[i * 3 + 1] = mesh->mNormals[i].y; 
     normals[i * 3 + 2] = mesh->mNormals[i].z; 
     if (mesh->mTextureCoords[0]) // Does the mesh contain texture coordinates? 
     { 
      texCoords[i * 2] = mesh->mTextureCoords[0][i].x; 
      texCoords[i * 2 + 1] = mesh->mTextureCoords[0][i].y; 
     } 
     else 
      texCoords[i * 2] = texCoords[i * 2 + 1] = 0.0f; 
     Debug::Log("vertex: " + std::to_string(vertices[i * 3]) + "," + std::to_string(vertices[i * 3 + 1]) + "," + std::to_string(vertices[i * 3 + 2])); 
    } 
    // Process indices 
    for (GLuint i = 0; i < mesh->mNumFaces; i++) 
    { 
     aiFace face = mesh->mFaces[i]; 
     for (GLuint j = 0; j < face.mNumIndices; j++) 
      indicesList.push_back(face.mIndices[j]); 
    } 
    indices = new int[indicesList.size()]; 
    indexLength = indicesList.size(); 
    for (int i = 0; i < (int)indicesList.size(); i++) 
     indices[i] = indicesList[i]; 

    return this->loader.LoadRenderModel(vertices, vertexLength, indices, indexLength, texCoords, texCoordLength, normals, normalLength); 
} 

und das Ergebnis Eckpunkten this object und Indizes, die durch den Code erzeugte here

Vergleichen Sie das Ergebnis und OBJ-Datei. Für das Tree-Objekt hat die Obj-Datei 624 Scheitelpunkte, aber Assimp hat 927 Scheitelpunkte und Indizes von Obj sind 310 (Linien) * 3 = 930, aber die von Assimp gelesenen Indizes sind 927-Indizes. Ich dachte, Assimp verarbeitet die Daten dahinter und generiert die angegebenen Indizes und Vertices.

Wenn ich Indizes neu berechnen muss, bedeutet das, dass ich alle Scheitelpunkte für jeden Scheitelpunkt überprüfen muss, um herauszufinden, welche die gleichen sind, und konstruiere die Indizes ..? Konnte nicht herausfinden, wie man dieses Problem slove.

Answer 1

Es gibt zwei wichtige Dinge, um den Algorithmus mit Assimp Importer arbeiten zu lassen.

1. Das Modell sollte ein gemeinsamer Scheitelpunkt mit Gesichtern sein. Wenn das Modell nicht vorhanden ist, sollte es mit einigen Optionen in der 3D-Modell-Software durchgeführt werden. Das Baumobjekt, das ich in der Frage Abschnitt zur Verfügung stellen, muss ich entfernen doppelte (entfernen doppelte Scheitelpunkte) in Blender und die normale sollte nur eine sein.

2. Die andere Sache muss beachtet werden, dass die Nachbearbeitung Option mit assimp. Überprüfen Sie die Assimp-Dokumentation, gibt es ein Flag namens aiProcess_JoinIdenticalVertices, wenn dies nicht aktiviert ist, würde Assimp die völlig eindeutigen Indizes für eindeutige Vertices generieren. Es gibt weitere Informationen unter here.