PDA

View Full Version : VAO and OBJ loader help



CrougVousen
04-25-2014, 11:27 AM
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.


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

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.

reto.koradi
04-25-2014, 01:19 PM
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.

CrougVousen
04-25-2014, 07:05 PM
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