1
2
3
4
5
6
7
8
9
10
11

struct vertice
{
float x, y, z;        //Vertice
float nx, ny, nz;     //Normal
float s0, t0;         //C. Textura 0
float s1, t1;         //C. Textura 1
float s2, t2;         //C. Textura 2
float relleno[4];     //ATI indica que es mejor que estas 
                      //estructuras sean multiplos de 32
                      //por tema de rendimiento del VBO. 
};

1
2
3
4
5
6
7
8

// Comentamos todas las referencias a glaux
// o las borramos. no usaremos esta libreria mas.
//#pragma comment( lib, "glaux.lib" )	  
 
...
 
// Otra referencia glaux fuera.
//#include <GL/glaux.h> 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// Elimino la parte de pintar la bola con glaux.
 
// y dibujo una esfera solida de 1 de radio
// usando la libreria glaux, que para eso la
// hemos cargado.
// Realizamos con la esfera lo mismo
// que con los cubos pero con otro
// identificador (el 5).
//if(Seleccion) 
//  glReadPixels(Raton.x,rect.bottom-Raton.y, 1,1,
//               GL_DEPTH_COMPONENT,GL_FLOAT,&z1);
//auxSolidSphere(1.0);
//if(Seleccion)
//  glReadPixels(Raton.x,rect.bottom-Raton.y, 1,1,
//               GL_DEPTH_COMPONENT,GL_FLOAT,&z2);
 
//if(ObjetoSel==5)
//{	glDisable(GL_LIGHTING);
//	glPolygonMode(GL_FRONT, GL_LINE);
//	auxSolidSphere(1);
//	glPolygonMode(GL_FRONT, GL_FILL);
//	glEnable(GL_LIGHTING);
//}
//if(z2<z1 && Seleccion) ObjetoSel=5;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// Como cualquier extension, chequeo si mi tarjeta la
// soporta. En el caso de VBOs si la version de OpenGL
// fuera 1.5 o mas estaria incluido en el nucleo de OpenGL
// y no haria falta la extension ni poner detras de las 
// funciones ARB o detras de las definiciones _ARB.
if (!GLEE_ARB_vertex_buffer_object)
{
  // Si no se soporta mandamos un mansaje...
  MessageBoxA(NULL, "ARB_vertex_buffer_object NO soportado", 
              "USW", MB_OK);
  // ... salimos del programa y no hacemos mas.
  PostMessage(IdVentana, WM_CLOSE, 0, 0); 
  return;
}

1
2
3
4
5

// Definimos tres variables para guardar el identificativo
// de los VBOs que vamos a usar.
GLuint vboVertices;
GLuint vboNormales;
GLuint vboTextura;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// Vamos a crear los 3 VBOs y los vamos a cargar con los datos
// que antes teniamos simplemente en un array.
// A partir de aqui los datos estaran en mamoria de la tarjeta de video 
// o memoria AGP, o donde el driver OpenGL de nuestra tarjeta crea que 
// va a rendir mejor
 
// Generamos 3 VBOs para los vertices, normales y coordenadas
// de textura
glGenBuffersARB(1, &vboVertices);
glGenBuffersARB(1, &vboNormales);
glGenBuffersARB(1, &vboTextura);
// Indico a OpenGL que voy a hacer algo con el VBO que usare
// para los vertices, hago bind del VBO.
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboVertices);
// Paso al VBO los datos de vertices, indico que los datos pasados son 
// coordenadas de vertices, normales o textura (no indices), el tamaño 
// del buffer, el puntero donde estan los datos a traspasar y por ultimo 
// la frecuencia con que se van a modificar los datos del VBO 
// (en nuestro caso nunca) 
glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(GLfloat)*9*NCaras, 
                Puntos, GL_STATIC_DRAW_ARB);
// Hago bind del VBO para normales.
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboNormales);
// Indico el tamaño y le paso los datos de las normales
glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(GLfloat)*9*NCaras, 
                Normales, GL_STATIC_DRAW_ARB);
// Hago bind del VBO para coordenadas de textura.
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboTextura);
// Le paso los datos de coordenadas de textura.
glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(GLfloat)*6*NCaras, 
                uvTex, GL_STATIC_DRAW_ARB);

1
2
3
4
5
6
7
8

// Hago bind del VBO para vertices, indico a 
// OpenGL que lo use a partir de ahora. 
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboVertices);
 
// Como uso un VBO, le paso 0 en vez de un puntero.
// Eso quiere decir que use el VBO, que ya tiene los
// datos de vertices.
glVertexPointer(3, GL_FLOAT, sizeof(GLfloat)*3, 0);

1
2
3
4
5
6
7

// Hago bind del VBO para normales
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboNormales);
 
// Le paso 0 en vez de un puntero para indicar que
// use los datos de normales del VBO que esta activo y
// donde ya estan los datos de las normales.
glNormalPointer(GL_FLOAT, sizeof(GLfloat)*3, 0);

1
2
3
4
5
6
7
8

// Hago bind del VBO que tiene las coordenadas 
// de textura
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboTextura);
 
// Le indico que las coordenadas de textura estan 
// en el VBO activo (el ultimo con el que hicimos bind)
// pasando 0 o NULL en vez de un puntero.
glTexCoordPointer(2, GL_FLOAT,sizeof(GLfloat)*2, 0);

1
2
3
4
5

// Al hacer bind de un VBO pasando 0 como 
// parametro en vez de el id de un VBO le
// estoy diciendo que deje de usar VBOs, 
// que use vertex array normales.
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);

1
2
3
4
5

// Como siempre, borro lo que creo para no dejar basura
// (memoria asignada sin usar)
glDeleteBuffersARB(1, &vboVertices);
glDeleteBuffersARB(1, &vboNormales);
glDeleteBuffersARB(1, &vboTextura);

1
2
3
4
5
6
7
8

// Hago bind del VBO con las coordenadas de textura
// para usar las mismas que el modelo pero en la
// TEXTURE1
 
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboTextura);
// E indico a OpenGL que los datos estan el un VBO pasando
// 0 en vez de un puntero.
glTexCoordPointer(2, GL_FLOAT, 0, 0);