OpenGL (core profile) model's triangles wrong rendering

Question

Here is an issue of my project, please look at the screenshots:

1. problems
2. original(correct)

My object is build in a wrong way. The vertices are not connected properly. I suspect that it has something to do with the indices of the model. Anyway here is the code that constructs the mesh for me:

mesh model::processMesh(aiMesh * mesh_, const aiScene * scene)
{
    std::vector<vertex> vertices;
    std::vector<GLuint> indices;
    std::vector<texture> textures;

    //vertices
    for (GLuint i = 0; i < mesh_->mNumVertices; i++)
    {
        vertex vert;
        glm::vec3 vector;

        //positions
        vector.x = mesh_->mVertices[i].x;
        vector.y = mesh_->mVertices[i].y;
        vector.z = mesh_->mVertices[i].z;
        vert.position = vector;

        //normals
        vector.x = mesh_->mNormals[i].x;
        vector.y = mesh_->mNormals[i].y;
        vector.z = mesh_->mNormals[i].z;
        vert.normal = vector;

        //texture coords
        if (mesh_->mTextureCoords[0])
        {
            glm::vec2 vector_;
            vector_.x = mesh_->mTextureCoords[0][i].x;
            vector_.y = mesh_->mTextureCoords[0][i].y;
            vert.texCoords = vector_;
        }
        else vert.texCoords = glm::vec2(0.0f, 0.0f);

        vertices.push_back(vert);
    }

    //indices
    for (GLuint i = 0; i < mesh_->mNumFaces; i++)
    {
        aiFace face = mesh_->mFaces[i];
        for (GLuint j = 0; j < mesh_->mNumFaces; j++) indices.push_back(face.mIndices[j]);
    }

    //textures
    if (mesh_->mMaterialIndex >= 0)
    {
        aiMaterial* material = scene->mMaterials[mesh_->mMaterialIndex];

        //diffuse
        std::vector<texture> diffuseMaps = this->loadMaterialTextures(material, aiTextureType_DIFFUSE, TEX_DIFF_NAME);
        textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
        //specular
        std::vector<texture> specularMaps = this->loadMaterialTextures(material, aiTextureType_SPECULAR, TEX_SPEC_NAME);
        textures.insert(textures.end(), specularMaps.begin(), specularMaps.end());
    }

    return mesh(vertices, indices, textures);
}

In this function I set up all objects:

void mesh::setupMesh()
{
    //buffers
    glGenVertexArrays(1, &this->vao);
    glGenBuffers(1, &this->vbo);
    glGenBuffers(1, &this->ebo);

    glBindVertexArray(this->vao);

    glBindBuffer(GL_ARRAY_BUFFER, this->vbo);
    glBufferData(GL_ARRAY_BUFFER, this->vertices.size() * sizeof(vertex), &this->vertices[0], GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->ebo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, this->indices.size() * sizeof(GLuint), &this->indices[0], GL_STATIC_DRAW);

    //attributes
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(vertex), (GLvoid*)0);
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(vertex), (GLvoid*)offsetof(vertex, normal));
    glEnableVertexAttribArray(2);
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(vertex), (GLvoid*)offsetof(vertex, texCoords));

    //unbind
    glBindVertexArray(0);
}

And here is the render

void mesh::draw(shader* shader)
{
    GLuint tex_diffNumber = 1;
    GLuint tex_specNumber = 1;

    for (GLuint i = 0; i < this->textures.size() ; i++)
    {
        //load target texture
        glActiveTexture(GL_TEXTURE0 + i);

        std::stringstream sstream;
        std::string number;
        std::string name = this->textures[i].type;

        if (name == TEX_DIFF_NAME) 
            sstream << tex_diffNumber++;
        else if (name == TEX_SPEC_NAME) 
            sstream << tex_specNumber++;

        number = sstream.str();

        glBindTexture(GL_TEXTURE_2D, this->textures[i].id);
        glUniform1i(glGetUniformLocation(shader->shaderProgID, (name + number).c_str()), i);

    }

    //set shininess
    //glUniform1f(glGetUniformLocation(shader->shaderProgID, "material.shininess"), 16.0f);

    //draw
    glBindVertexArray(this->vao);
    glDrawElements(GL_TRIANGLES, this->indices.size(), GL_UNSIGNED_INT, 0);
    glBindVertexArray(0);

    //release
    for (GLuint i = 0; i < this->textures.size(); i++)
    {
        glActiveTexture(GL_TEXTURE0 + i);
        glBindTexture(GL_TEXTURE_2D, 0);
    }
}

The question is why does my model have wrong built triangles? Ask any additional info. Thank you for help in advance, guys!

Answer 1

for (GLuint i = 0; i < mesh_->mNumFaces; i++)
{
    aiFace face = mesh_->mFaces[i];
    for (GLuint j = 0; j < mesh_->mNumFaces; j++)
        indices.push_back(face.mIndices[j]);
}

This looks wrong to me. I don't think the inner loop should run over all faces again. Instead it should iterate over all indices in the face:

for (GLuint i = 0; i < mesh_->mNumFaces; i++)
{
    aiFace face = mesh_->mFaces[i];
    for (GLuint j = 0; j < face->mNumIndices; j++)
        indices.push_back(face.mIndices[j]);
}

Note, that the original version was reading outside of the available memory, since the loop was most probably going till j = 5 (six faces), but there are only faces with a maximum of four indices. If one would have attached a debugger and stepped through it, this should have been easily visible.