Modified texture cubemap example to use VBOs instead of client-side vertex ar...

third_party/gles2_book/Chapter_9/Simple_TextureCubemap/Simple_TextureCubemap.c

 //
 // Book:      OpenGL(R) ES 2.0 Programming Guide
 // Authors:   Aaftab Munshi, Dan Ginsburg, Dave Shreiner
 // ISBN-10:   0321502795
 // ISBN-13:   9780321502797
 // Publisher: Addison-Wesley Professional
 // URLs:      http://safari.informit.com/9780321563835
 //            http://www.opengles-book.com
 //
 
@@ skipping 13 matching lines @@
    GLint  positionLoc;
    GLint  normalLoc;
 
    // Sampler location
    GLint samplerLoc;
 
    // Texture handle
    GLuint textureId;
 
    // Vertex data
-   int      numIndices;
-   GLfloat *vertices;
-   GLfloat *normals;
-   GLuint  *indices;
-
+   int    numIndices;
+   GLuint vboIds[3];
 } UserData;
 
 ///
 // Create a simple cubemap with a 1x1 face with a different
 // color for each face
-GLuint CreateSimpleTextureCubemap( )
+static GLuint CreateSimpleTextureCubemap( )
 {
    GLuint textureId;
    // Six 1x1 RGB faces
    GLubyte cubePixels[6][3] =
    {
       // Face 0 - Red
       255, 0, 0,
       // Face 1 - Green,
       0, 255, 0, 
       // Face 3 - Blue
@@ skipping 44 matching lines @@
 
 }
 
 
 ///
 // Initialize the shader and program object
 //
 int Init ( ESContext *esContext )
 {
    UserData *userData = esContext->userData;
+   int numSlices = 20;
+   int numVertices = ( (numSlices / 2) + 1 ) * ( numSlices + 1 );
+   GLfloat *vertices = NULL;
+   GLfloat *normals = NULL;
+   GLushort *indices = NULL;
    GLbyte vShaderStr[] =  
       "attribute vec4 a_position;   \n"
       "attribute vec3 a_normal;     \n"
       "varying vec3 v_normal;       \n"
       "void main()                  \n"
       "{                            \n"
       "   gl_Position = a_position; \n"
       "   v_normal = a_normal;      \n"
       "}                            \n";
    
@@ skipping 13 matching lines @@
    userData->positionLoc = glGetAttribLocation ( userData->programObject, "a_position" );
    userData->normalLoc = glGetAttribLocation ( userData->programObject, "a_normal" );
    
    // Get the sampler locations
    userData->samplerLoc = glGetUniformLocation ( userData->programObject, "s_texture" );
 
    // Load the texture
    userData->textureId = CreateSimpleTextureCubemap ();
 
    // Generate the vertex data
-   userData->numIndices = esGenSphere ( 20, 0.75f, &userData->vertices, &userData->normals, 
-                                        NULL, &userData->indices );
-
+   userData->numIndices = esGenSphere ( numSlices, 0.75f, &vertices, &normals, 
+                                        NULL, &indices );
+   glGenBuffers( 3, userData->vboIds );
+   // Load vertex positions
+   glBindBuffer ( GL_ARRAY_BUFFER, userData->vboIds[0] );
+   glBufferData ( GL_ARRAY_BUFFER, 3 * numVertices * sizeof(GLfloat),
+                  vertices, GL_STATIC_DRAW );
+   // Load vertex normals
+   glBindBuffer ( GL_ARRAY_BUFFER, userData->vboIds[1] );
+   glBufferData ( GL_ARRAY_BUFFER, 3 * numVertices * sizeof(GLfloat),
+                  normals, GL_STATIC_DRAW );
+   // Load vertex indices
+   glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER, userData->vboIds[2] );
+   glBufferData ( GL_ELEMENT_ARRAY_BUFFER, userData->numIndices * sizeof(GLushort),
+                  indices, GL_STATIC_DRAW );
+   if ( vertices != NULL ) free ( vertices );
+   if ( normals != NULL ) free ( normals );
+   if ( indices != NULL ) free ( indices );
    
    glClearColor ( 0.0f, 0.0f, 0.0f, 0.0f );
    return TRUE;
 }
 
 ///
 // Draw a triangle using the shader pair created in Init()
 //
 void Draw ( ESContext *esContext )
 {
    UserData *userData = esContext->userData;
       
    // Set the viewport
    glViewport ( 0, 0, esContext->width, esContext->height );
    
    // Clear the color buffer
    glClear ( GL_COLOR_BUFFER_BIT );
 
    
    glCullFace ( GL_BACK );
    glEnable ( GL_CULL_FACE );
    
    // Use the program object
    glUseProgram ( userData->programObject );
 
    // Load the vertex position
    glVertexAttribPointer ( userData->positionLoc, 3, GL_FLOAT, 
-                           GL_FALSE, 0, userData->vertices );
+                           GL_FALSE, 0, 0 );
    // Load the normal
    glVertexAttribPointer ( userData->normalLoc, 3, GL_FLOAT,
-                           GL_FALSE, 0, userData->normals );
+                           GL_FALSE, 0, 0 );
 
    glEnableVertexAttribArray ( userData->positionLoc );
    glEnableVertexAttribArray ( userData->normalLoc );
 
    // Bind the texture
    glActiveTexture ( GL_TEXTURE0 );
    glBindTexture ( GL_TEXTURE_CUBE_MAP, userData->textureId );
 
    // Set the sampler texture unit to 0
    glUniform1i ( userData->samplerLoc, 0 );
 
    glDrawElements ( GL_TRIANGLES, userData->numIndices, 
-                    GL_UNSIGNED_INT, userData->indices );
+                    GL_UNSIGNED_SHORT, 0 );
 
    eglSwapBuffers ( esContext->eglDisplay, esContext->eglSurface );
 }
 
 ///
 // Cleanup
 //
 void ShutDown ( ESContext *esContext )
 {
    UserData *userData = esContext->userData;
 
    // Delete texture object
    glDeleteTextures ( 1, &userData->textureId );
 
    // Delete program object
    glDeleteProgram ( userData->programObject );
 
-   free ( userData->vertices );
-   free ( userData->normals );
+   
 }
 
 
 int main ( int argc, char *argv[] )
 {
    ESContext esContext;
    UserData  userData;
 
    esInitContext ( &esContext );
    esContext.userData = &userData;
 
    esCreateWindow ( &esContext, "Simple Texture Cubemap", 320, 240, ES_WINDOW_RGB );
    
    if ( !Init ( &esContext ) )
       return 0;
 
    esRegisterDrawFunc ( &esContext, Draw );
    
    esMainLoop ( &esContext );
 
    ShutDown ( &esContext );
 }