Part of the Khronos Group
OpenGL.org

The Industry's Foundation for High Performance Graphics

from games to virtual reality, mobile phones to supercomputers

Results 1 to 3 of 3

Thread: VAO and OBJ loader help

  1. #1
    Newbie Newbie
    Join Date
    Apr 2014
    Posts
    2

    VAO and OBJ loader help

    So I have been reading about VAO's and indexed rendering lately, I tried it myself and am running into some problems. The code below should store an object into 4 VBOs and save the state with a VAO, and then draw it.

    Code :
    LiteEngine::Mesh::Mesh(std::vector<int>vecIndices, std::vector<int> texIndices, std::vector<int>norIndices, std::vector<vec3>vertices, std::vector<vec2>texCoords, std::vector<vec3>normals){
        std::vector<vec3> Vec;
        std::vector<vec2> Tex;
        std::vector<vec3> Nor;
        std::vector<unsigned int> indices;
        for(int i = 0;i < vecIndices.size();i++){
            int inVec = vecIndices[i];
            int inTex = texIndices[i];
            int inNor = norIndices[i];
            vec3 vec = vertices[inVec-1];
            vec2 tex;
            if(inTex!= -1)
                tex = texCoords[inTex-1];
            else
                tex = (vec2)vec;
            vec3 nor;
            if(inNor!=-1)
                nor = normals[inNor-1];
            else
                nor = vec;
     
            long index = findMatch(vec, tex, nor, Vec, Tex, Nor);
     
            if(index = -1){
                Vec.push_back(vec);
                Tex.push_back(tex);
                Nor.push_back(nor);
                indices.push_back((unsigned int)Vec.size()-1);
            }else{
                indices.push_back((unsigned int)index);
            }
            faces++;
        }
        std::vector<int>().swap(vecIndices);
        std::vector<int>().swap(texIndices);
        std::vector<int>().swap(norIndices);
        std::vector<vec3>().swap(vertices);
        std::vector<vec2>().swap(texCoords);
        std::vector<vec3>().swap(normals);
     
        glGenVertexArrays(1, &meshID);
        std::cout << "woohoo\r\n";
        glBindVertexArray(meshID);
        std::cout << "made it here\r\n";
     
        unsigned int ids[4];
        glGenBuffers(1, ids);
     
        vecID = ids[0];
        texID = ids[1];
        norID = ids[2];
        indicesID = ids[3];
     
        glBindBuffer(GL_ARRAY_BUFFER, vecID);
        glBufferData(GL_ARRAY_BUFFER, Vec.size() * sizeof(vec3), &Vec, GL_STATIC_DRAW);
        glEnableVertexAttribArray(0);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(vec3), 0);
     
        glBindBuffer(GL_ARRAY_BUFFER, texID);
        glBufferData(GL_ARRAY_BUFFER, Tex.size() * sizeof(vec2), &Tex, GL_STATIC_DRAW);
        glEnableVertexAttribArray(1);
        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(vec2), 0);
     
        glBindBuffer(GL_ARRAY_BUFFER, norID);
        glBufferData(GL_ARRAY_BUFFER, Nor.size() * sizeof(vec3), &Nor, GL_STATIC_DRAW);
        glEnableVertexAttribArray(2);
        glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(vec3), 0);
     
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indicesID);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices, GL_STATIC_DRAW);
     
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
        glBindVertexArray(0);
    }

    Drawing code
    Code :
    void LiteEngine::Engine::drawFrame(){
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();
        glMatrixMode(GL_PROJECTION);
     
        //204
        glBindVertexArray(mesh->meshID);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh->indicesID);
     
        glDrawArrays(GL_TRIANGLES, 0, mesh->faces);
        glDrawElements(GL_TRIANGLES, mesh->faces, GL_UNSIGNED_INT, (void*)0);
     
        glBindVertexArray(0);
        glutSwapBuffers();
    }

    I'm just looking to see if I am using VAOs correctly, if everything there is correct, I will know it's a problem with my object loading.

  2. #2
    Intern Contributor
    Join Date
    Mar 2014
    Location
    San Jose, CA
    Posts
    58
    Your VAO usage mostly seems fine. The biggest problem I see in the code is in the calls to glBufferData(). For example for the positions, you're passing &Vec as the data pointer. Vec is an object of type std::vector<vec3>. Which means that you're passing a pointer to an object, instead of a pointer to the position data. Try &Vec[0] instead. Same thing for the other vectors.

  3. #3
    Newbie Newbie
    Join Date
    Apr 2014
    Posts
    2
    Quote Originally Posted by reto.koradi View Post
    Your VAO usage mostly seems fine. The biggest problem I see in the code is in the calls to glBufferData(). For example for the positions, you're passing &Vec as the data pointer. Vec is an object of type std::vector<vec3>. Which means that you're passing a pointer to an object, instead of a pointer to the position data. Try &Vec[0] instead. Same thing for the other vectors.
    Thanks, that makes sense now, I saw them doing it in other tutorials but then never really explained why, I always assumed that they had a vector full of meshes and only needed that instance, but the way you explained it makes sense

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •