void ModelVBO::Load(ModelOBJ obj)
{
if (obj.hasPositions())
{
glGenBuffers(1, &vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glBufferData(GL_ARRAY_BUFFER, obj.getNumberOfVertices() * obj.getVertexSize(), obj.getVertexBuffer(), GL_STATIC_DRAW);
}
if (obj.hasTextureCoords())
{
glGenBuffers(1, &uvbuffer);
glBindBuffer(GL_ARRAY_BUFFER, uvbuffer);
glBufferData(GL_ARRAY_BUFFER, obj.getNumberOfVertices() * obj.getVertexSize(), obj.getVertexBuffer(), GL_STATIC_DRAW);
}
if (obj.hasNormals())
{
glGenBuffers(1, &normalbuffer);
glBindBuffer(GL_ARRAY_BUFFER, normalbuffer);
glBufferData(GL_ARRAY_BUFFER, obj.getNumberOfVertices() * obj.getVertexSize(), obj.getVertexBuffer(), GL_STATIC_DRAW);
}
if (obj.hasTangents())
{
glGenBuffers(1, &tangentbuffer);
glBindBuffer(GL_ARRAY_BUFFER, tangentbuffer);
glBufferData(GL_ARRAY_BUFFER, obj.getNumberOfVertices() * obj.getVertexSize(), obj.getVertexBuffer(), GL_STATIC_DRAW);
}
glGenBuffers(1, &elementbuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementbuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, obj.getNumberOfIndices() * obj.getIndexSize(), obj.getIndexBuffer(),
GL_STATIC_DRAW);
}
void init_VBO()
{
// 1 vertex, 1 normal, + N element sets
num_buffer_objects = 2 + model.getNumberOfMeshes();
bufferObjects = (GLuint*) malloc( sizeof(GLuint) * num_buffer_objects );
glGenBuffers( num_buffer_objects, bufferObjects );
//
// Copy data to video memory
//
// Vertices array stores Vertex data & Normal Data
glBindBuffer( GL_ARRAY_BUFFER, bufferObjects[VERTEX_DATA] );
glBufferData( GL_ARRAY_BUFFER, model.getVertexSize() * model.getNumberOfVertices(),
model.getVertexBuffer(), GL_STATIC_DRAW );
/* Normal data
if ( model.hasNormals())
{
glBindBuffer( GL_ARRAY_BUFFER, bufferObjects[NORMAL_DATA] );
glBufferData( GL_ARRAY_BUFFER, sizeof(float)* model.getNumberOfVertices() * 3,
model.getVertexBuffer()->normal, GL_STATIC_DRAW );
} */
for ( int i = 0; i < model.getNumberOfMeshes(); ++i )
{
const ModelOBJ::Mesh *pMesh = &model.getMesh(i);
// Indexes
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, bufferObjects[INDEX_DATA+i] );
glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned int) * pMesh->triangleCount * 3, model.getIndexBuffer() + pMesh->startIndex, GL_STATIC_DRAW );
}
}
//MODEL - vertex array version
void draw_test_model_Vertex_Arrays()
{
const ModelOBJ::Mesh *pMesh = 0;
const ModelOBJ::Material *pMaterial = 0;
for (int i = 0; i < model.getNumberOfMeshes(); ++i)
{
pMesh = &model.getMesh(i);
pMaterial = pMesh->pMaterial;
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, pMaterial->ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, pMaterial->diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, pMaterial->specular);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, pMaterial->shininess * 128.0f);
if (model.hasPositions())
{
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, model.getVertexSize(),
model.getVertexBuffer()->position);
}
if ( model.hasNormals())
{
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, model.getVertexSize(),
model.getVertexBuffer()->normal);
}
glDrawElements(GL_TRIANGLES, pMesh->triangleCount * 3, GL_UNSIGNED_INT,
model.getIndexBuffer() + pMesh->startIndex);
if (model.hasNormals())
glDisableClientState(GL_NORMAL_ARRAY);
if (model.hasPositions())
glDisableClientState(GL_VERTEX_ARRAY);
}
}
void draw_test_model_VBO()
{
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_INDEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
// Here’s where the data is now
// Vertex data
glBindBuffer( GL_ARRAY_BUFFER, bufferObjects[VERTEX_DATA] );
glVertexPointer( 3, GL_FLOAT, model.getVertexSize(), 0 );
// Normal data
if ( model.hasNormals())
{
//glBindBuffer( GL_ARRAY_BUFFER, bufferObjects[NORMAL_DATA] );
glBindBuffer( GL_ARRAY_BUFFER, bufferObjects[VERTEX_DATA] );
glNormalPointer( GL_FLOAT, model.getVertexSize(), model.getVertexBuffer()->normal /* pointer? */ );
}
for ( int i = 0; i < model.getNumberOfMeshes(); ++i )
{
const ModelOBJ::Mesh * pMesh = &model.getMesh(i);
// Indexes
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, bufferObjects[INDEX_DATA+i] );
glDrawElements( GL_TRIANGLES, pMesh->triangleCount * 3, GL_UNSIGNED_INT, 0 );
}
// free the VBO context for regular Vertex Array calls
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_INDEX_ARRAY);
}
void ModelVBO::BindBuffers(ModelOBJ obj)
{
if (obj.hasPositions())
{
// 1rst attribute buffer : vertices
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glVertexAttribPointer(
0, // attribute
3, // size
GL_FLOAT, // type
GL_FALSE, // normalized?
obj.getVertexSize(), // stride
(void *)0 // array buffer offset
);
}
if (obj.hasTextureCoords())
{
// 2nd attribute buffer : UVs
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, uvbuffer);
glVertexAttribPointer(
1, // attribute
2, // size
GL_FLOAT, // type
GL_FALSE, // normalized?
obj.getVertexSize(), // stride
(void *)(3 * sizeof(float)) // array buffer offset
);
}
if (obj.hasNormals())
{
// 3rd attribute buffer : normals
glEnableVertexAttribArray(2);
glBindBuffer(GL_ARRAY_BUFFER, normalbuffer);
glVertexAttribPointer(
2, // attribute
3, // size
GL_FLOAT, // type
GL_FALSE, // normalized?
obj.getVertexSize(), // stride
(void *)(5 * sizeof(float)) // array buffer offset
);
}
if (obj.hasTangents())
{
// 4th attribute buffer : tangents
glEnableVertexAttribArray(3);
glBindBuffer(GL_ARRAY_BUFFER, tangentbuffer);
glVertexAttribPointer(
3, // attribute
4, // size
GL_FLOAT, // type
GL_FALSE, // normalized?
obj.getVertexSize(), // stride
(void *)(8 * sizeof(float)) // array buffer offset
);
}
}
void DrawFrame()
{
glViewport(0, 0, g_windowWidth, g_windowHeight);
glClearColor(0.3f, 0.5f, 0.9f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(CAMERA_FOVY,
static_cast<float>(g_windowWidth) / static_cast<float>(g_windowHeight),
CAMERA_ZNEAR, CAMERA_ZFAR);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(g_cameraPos[0], g_cameraPos[1], g_cameraPos[2],
g_targetPos[0], g_targetPos[1], g_targetPos[2],
0.0f, 1.0f, 0.0f);
glRotatef(g_pitch, 1.0f, 0.0f, 0.0f);
glRotatef(g_heading, 0.0f, 1.0f, 0.0f);
const ModelOBJ::Mesh *pMesh = 0;
const ModelOBJ::Material *pMaterial = 0;
const ModelOBJ::Vertex *pVertices = 0;
ModelTextures::const_iterator iter;
for (int i = 0; i < g_model.getNumberOfMeshes(); ++i)
{
pMesh = &g_model.getMesh(i);
pMaterial = pMesh->pMaterial;
pVertices = g_model.getVertexBuffer();
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, pMaterial->ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, pMaterial->diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, pMaterial->specular);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, pMaterial->shininess * 128.0f);
if (g_enableTextures)
{
iter = g_modelTextures.find(pMaterial->colorMapFilename);
if (iter == g_modelTextures.end())
{
glDisable(GL_TEXTURE_2D);
}
else
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, iter->second);
}
}
else
{
glDisable(GL_TEXTURE_2D);
}
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, g_model.getVertexSize(), g_model.getVertexBuffer()->position);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, g_model.getVertexSize(), g_model.getVertexBuffer()->texCoord);
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, g_model.getVertexSize(), g_model.getVertexBuffer()->normal);
glDrawElements(GL_TRIANGLES, pMesh->triangleCount * 3, GL_UNSIGNED_INT, g_model.getIndexBuffer() + pMesh->startIndex);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
}
