add original versions of glbook tests, gles2.0 and not webgl-friendly

7 files changed, 1579 insertions, 0 deletions

diff --git a/tests/glbook/Chapter_10/MultiTexture/MultiTexture_orig.c b/tests/glbook/Chapter_10/MultiTexture/MultiTexture_orig.c
new file mode 100644
index 00000000..5324ad92
--- /dev/null
+++ b/tests/glbook/Chapter_10/MultiTexture/MultiTexture_orig.c
@@ -0,0 +1,213 @@
+//

+// 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

+//

+

+// MultiTexture.c

+//

+//    This is an example that draws a quad with a basemap and

+//    lightmap to demonstrate multitexturing.

+//

+#include <stdlib.h>

+#include "esUtil.h"

+

+typedef struct

+{

+   // Handle to a program object

+   GLuint programObject;

+

+   // Attribute locations

+   GLint  positionLoc;

+   GLint  texCoordLoc;

+

+   // Sampler locations

+   GLint baseMapLoc;

+   GLint lightMapLoc;

+

+   // Texture handle

+   GLuint baseMapTexId;

+   GLuint lightMapTexId;

+

+} UserData;

+

+

+///

+// Load texture from disk

+//

+GLuint LoadTexture ( char *fileName )

+{

+   int width,

+       height;

+   char *buffer = esLoadTGA ( fileName, &width, &height );

+   GLuint texId;

+

+   if ( buffer == NULL )

+   {

+      esLogMessage ( "Error loading (%s) image.\n", fileName );

+      return 0;

+   }

+

+   glGenTextures ( 1, &texId );

+   glBindTexture ( GL_TEXTURE_2D, texId );

+

+   glTexImage2D ( GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, buffer );

+   glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );

+   glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );

+   glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );

+   glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );

+

+   free ( buffer );

+

+   return texId;

+}

+

+

+

+///

+// Initialize the shader and program object

+//

+int Init ( ESContext *esContext )

+{

+   UserData *userData = esContext->userData;

+   GLbyte vShaderStr[] =  

+      "attribute vec4 a_position;   \n"

+      "attribute vec2 a_texCoord;   \n"

+      "varying vec2 v_texCoord;     \n"

+      "void main()                  \n"

+      "{                            \n"

+      "   gl_Position = a_position; \n"

+      "   v_texCoord = a_texCoord;  \n"

+      "}                            \n";

+   

+   GLbyte fShaderStr[] =  

+      "precision mediump float;                            \n"

+      "varying vec2 v_texCoord;                            \n"

+      "uniform sampler2D s_baseMap;                        \n"

+      "uniform sampler2D s_lightMap;                       \n"

+      "void main()                                         \n"

+      "{                                                   \n"

+      "  vec4 baseColor;                                   \n"

+      "  vec4 lightColor;                                  \n"

+      "                                                    \n"

+      "  baseColor = texture2D( s_baseMap, v_texCoord );   \n"

+      "  lightColor = texture2D( s_lightMap, v_texCoord ); \n"

+      "  gl_FragColor = baseColor * (lightColor + 0.25);   \n"

+      "}                                                   \n";

+

+   // Load the shaders and get a linked program object

+   userData->programObject = esLoadProgram ( vShaderStr, fShaderStr );

+

+   // Get the attribute locations

+   userData->positionLoc = glGetAttribLocation ( userData->programObject, "a_position" );

+   userData->texCoordLoc = glGetAttribLocation ( userData->programObject, "a_texCoord" );

+   

+   // Get the sampler location

+   userData->baseMapLoc = glGetUniformLocation ( userData->programObject, "s_baseMap" );

+   userData->lightMapLoc = glGetUniformLocation ( userData->programObject, "s_lightMap" );

+

+   // Load the textures

+   userData->baseMapTexId = LoadTexture ( "basemap.tga" );

+   userData->lightMapTexId = LoadTexture ( "lightmap.tga" );

+

+   if ( userData->baseMapTexId == 0 || userData->lightMapTexId == 0 )

+      return FALSE;

+

+   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;

+   GLfloat vVertices[] = { -0.5f,  0.5f, 0.0f,  // Position 0

+                            0.0f,  0.0f,        // TexCoord 0 

+                           -0.5f, -0.5f, 0.0f,  // Position 1

+                            0.0f,  1.0f,        // TexCoord 1

+                            0.5f, -0.5f, 0.0f,  // Position 2

+                            1.0f,  1.0f,        // TexCoord 2

+                            0.5f,  0.5f, 0.0f,  // Position 3

+                            1.0f,  0.0f         // TexCoord 3

+                         };

+   GLushort indices[] = { 0, 1, 2, 0, 2, 3 };

+      

+   // Set the viewport

+   glViewport ( 0, 0, esContext->width, esContext->height );

+   

+   // Clear the color buffer

+   glClear ( GL_COLOR_BUFFER_BIT );

+

+   // Use the program object

+   glUseProgram ( userData->programObject );

+

+   // Load the vertex position

+   glVertexAttribPointer ( userData->positionLoc, 3, GL_FLOAT, 

+                           GL_FALSE, 5 * sizeof(GLfloat), vVertices );

+   // Load the texture coordinate

+   glVertexAttribPointer ( userData->texCoordLoc, 2, GL_FLOAT,

+                           GL_FALSE, 5 * sizeof(GLfloat), &vVertices[3] );

+

+   glEnableVertexAttribArray ( userData->positionLoc );

+   glEnableVertexAttribArray ( userData->texCoordLoc );

+

+   // Bind the base map

+   glActiveTexture ( GL_TEXTURE0 );

+   glBindTexture ( GL_TEXTURE_2D, userData->baseMapTexId );

+

+   // Set the base map sampler to texture unit to 0

+   glUniform1i ( userData->baseMapLoc, 0 );

+

+   // Bind the light map

+   glActiveTexture ( GL_TEXTURE1 );

+   glBindTexture ( GL_TEXTURE_2D, userData->lightMapTexId );

+   

+   // Set the light map sampler to texture unit 1

+   glUniform1i ( userData->lightMapLoc, 1 );

+

+   glDrawElements ( GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices );

+

+   eglSwapBuffers ( esContext->eglDisplay, esContext->eglSurface );

+}

+

+///

+// Cleanup

+//

+void ShutDown ( ESContext *esContext )

+{

+   UserData *userData = esContext->userData;

+

+   // Delete texture object

+   glDeleteTextures ( 1, &userData->baseMapTexId );

+   glDeleteTextures ( 1, &userData->lightMapTexId );

+

+   // Delete program object

+   glDeleteProgram ( userData->programObject );

+}

+

+

+int main ( int argc, char *argv[] )

+{

+   ESContext esContext;

+   UserData  userData;

+

+   esInitContext ( &esContext );

+   esContext.userData = &userData;

+

+   esCreateWindow ( &esContext, "MultiTexture", 320, 240, ES_WINDOW_RGB );

+   

+   if ( !Init ( &esContext ) )

+      return 0;

+

+   esRegisterDrawFunc ( &esContext, Draw );

+   

+   esMainLoop ( &esContext );

+

+   ShutDown ( &esContext );

+}

diff --git a/tests/glbook/Chapter_13/ParticleSystem/ParticleSystem_orig.c b/tests/glbook/Chapter_13/ParticleSystem/ParticleSystem_orig.c
new file mode 100644
index 00000000..378d05a7
--- /dev/null
+++ b/tests/glbook/Chapter_13/ParticleSystem/ParticleSystem_orig.c
@@ -0,0 +1,294 @@
+//

+// 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

+//

+

+// ParticleSystem.c

+//

+//    This is an example that demonstrates rendering a particle system

+//    using a vertex shader and point sprites.

+//

+#include <stdlib.h>

+#include <math.h>

+#include "esUtil.h"

+

+#define NUM_PARTICLES	1000

+#define PARTICLE_SIZE   7

+

+typedef struct

+{

+   // Handle to a program object

+   GLuint programObject;

+

+   // Attribute locations

+   GLint  lifetimeLoc;

+   GLint  startPositionLoc;

+   GLint  endPositionLoc;

+   

+   // Uniform location

+   GLint timeLoc;

+   GLint colorLoc;

+   GLint centerPositionLoc;

+   GLint samplerLoc;

+

+   // Texture handle

+   GLuint textureId;

+

+   // Particle vertex data

+   float particleData[ NUM_PARTICLES * PARTICLE_SIZE ];

+

+   // Current time

+   float time;

+

+} UserData;

+

+///

+// Load texture from disk

+//

+GLuint LoadTexture ( char *fileName )

+{

+   int width,

+       height;

+   char *buffer = esLoadTGA ( fileName, &width, &height );

+   GLuint texId;

+

+   if ( buffer == NULL )

+   {

+      esLogMessage ( "Error loading (%s) image.\n", fileName );

+      return 0;

+   }

+

+   glGenTextures ( 1, &texId );

+   glBindTexture ( GL_TEXTURE_2D, texId );

+

+   glTexImage2D ( GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, buffer );

+   glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );

+   glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );

+   glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );

+   glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );

+

+   free ( buffer );

+

+   return texId;

+}

+

+

+///

+// Initialize the shader and program object

+//

+int Init ( ESContext *esContext )

+{

+   UserData *userData = esContext->userData;

+   int i;

+   

+   GLbyte vShaderStr[] =

+      "uniform float u_time;		                           \n"

+      "uniform vec3 u_centerPosition;                       \n"

+      "attribute float a_lifetime;                          \n"

+      "attribute vec3 a_startPosition;                      \n"

+      "attribute vec3 a_endPosition;                        \n"

+      "varying float v_lifetime;                            \n"

+      "void main()                                          \n"

+      "{                                                    \n"

+      "  if ( u_time <= a_lifetime )                        \n"

+      "  {                                                  \n"

+      "    gl_Position.xyz = a_startPosition +              \n"

+      "                      (u_time * a_endPosition);      \n"

+      "    gl_Position.xyz += u_centerPosition;             \n"

+      "    gl_Position.w = 1.0;                             \n"

+      "  }                                                  \n"

+      "  else                                               \n"

+      "     gl_Position = vec4( -1000, -1000, 0, 0 );       \n"

+      "  v_lifetime = 1.0 - ( u_time / a_lifetime );        \n"

+      "  v_lifetime = clamp ( v_lifetime, 0.0, 1.0 );       \n"

+      "  gl_PointSize = ( v_lifetime * v_lifetime ) * 40.0; \n"

+      "}";

+      

+   GLbyte fShaderStr[] =  

+      "precision mediump float;                             \n"

+      "uniform vec4 u_color;		                           \n"

+      "varying float v_lifetime;                            \n"

+      "uniform sampler2D s_texture;                         \n"

+      "void main()                                          \n"

+      "{                                                    \n"

+      "  vec4 texColor;                                     \n"

+      "  texColor = texture2D( s_texture, gl_PointCoord );  \n"

+      "  gl_FragColor = vec4( u_color ) * texColor;         \n"

+      "  gl_FragColor.a *= v_lifetime;                      \n"

+      "}                                                    \n";

+

+   // Load the shaders and get a linked program object

+   userData->programObject = esLoadProgram ( vShaderStr, fShaderStr );

+

+   // Get the attribute locations

+   userData->lifetimeLoc = glGetAttribLocation ( userData->programObject, "a_lifetime" );

+   userData->startPositionLoc = glGetAttribLocation ( userData->programObject, "a_startPosition" );

+   userData->endPositionLoc = glGetAttribLocation ( userData->programObject, "a_endPosition" );

+   

+   // Get the uniform locations

+   userData->timeLoc = glGetUniformLocation ( userData->programObject, "u_time" );

+   userData->centerPositionLoc = glGetUniformLocation ( userData->programObject, "u_centerPosition" );

+   userData->colorLoc = glGetUniformLocation ( userData->programObject, "u_color" );

+   userData->samplerLoc = glGetUniformLocation ( userData->programObject, "s_texture" );

+

+   glClearColor ( 0.0f, 0.0f, 0.0f, 0.0f );

+

+   // Fill in particle data array

+   srand ( 0 );

+   for ( i = 0; i < NUM_PARTICLES; i++ )

+   {

+      float *particleData = &userData->particleData[i * PARTICLE_SIZE];

+   

+      // Lifetime of particle

+      (*particleData++) = ( (float)(rand() % 10000) / 10000.0f );

+

+      // End position of particle

+      (*particleData++) = ( (float)(rand() % 10000) / 5000.0f ) - 1.0f;

+      (*particleData++) = ( (float)(rand() % 10000) / 5000.0f ) - 1.0f;

+      (*particleData++) = ( (float)(rand() % 10000) / 5000.0f ) - 1.0f;

+

+      // Start position of particle

+      (*particleData++) = ( (float)(rand() % 10000) / 40000.0f ) - 0.125f;

+      (*particleData++) = ( (float)(rand() % 10000) / 40000.0f ) - 0.125f;

+      (*particleData++) = ( (float)(rand() % 10000) / 40000.0f ) - 0.125f;

+

+   }

+

+   // Initialize time to cause reset on first update

+   userData->time = 1.0f;

+

+   userData->textureId = LoadTexture ( "smoke.tga" );

+   if ( userData->textureId <= 0 )

+   {

+      return FALSE;

+   }

+   

+   return TRUE;

+}

+

+///

+//  Update time-based variables

+//

+void Update ( ESContext *esContext, float deltaTime )

+{

+   UserData *userData = esContext->userData;

+  

+   userData->time += deltaTime;

+

+   if ( userData->time >= 1.0f )

+   {

+      float centerPos[3];

+      float color[4];

+

+      userData->time = 0.0f;

+

+      // Pick a new start location and color

+      centerPos[0] = ( (float)(rand() % 10000) / 10000.0f ) - 0.5f;

+      centerPos[1] = ( (float)(rand() % 10000) / 10000.0f ) - 0.5f;

+      centerPos[2] = ( (float)(rand() % 10000) / 10000.0f ) - 0.5f;

+      

+      glUniform3fv ( userData->centerPositionLoc, 1, &centerPos[0] );

+

+      // Random color

+      color[0] = ( (float)(rand() % 10000) / 20000.0f ) + 0.5f;

+      color[1] = ( (float)(rand() % 10000) / 20000.0f ) + 0.5f;

+      color[2] = ( (float)(rand() % 10000) / 20000.0f ) + 0.5f;

+      color[3] = 0.5;

+

+      glUniform4fv ( userData->colorLoc, 1, &color[0] );

+   }

+

+   // Load uniform time variable

+   glUniform1f ( userData->timeLoc, userData->time );

+}

+

+///

+// 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 );

+

+   // Use the program object

+   glUseProgram ( userData->programObject );

+

+   // Load the vertex attributes

+   glVertexAttribPointer ( userData->lifetimeLoc, 1, GL_FLOAT, 

+                           GL_FALSE, PARTICLE_SIZE * sizeof(GLfloat), 

+                           userData->particleData );

+   

+   glVertexAttribPointer ( userData->endPositionLoc, 3, GL_FLOAT,

+                           GL_FALSE, PARTICLE_SIZE * sizeof(GLfloat),

+                           &userData->particleData[1] );

+

+   glVertexAttribPointer ( userData->startPositionLoc, 3, GL_FLOAT,

+                           GL_FALSE, PARTICLE_SIZE * sizeof(GLfloat),

+                           &userData->particleData[4] );

+

+   

+   glEnableVertexAttribArray ( userData->lifetimeLoc );

+   glEnableVertexAttribArray ( userData->endPositionLoc );

+   glEnableVertexAttribArray ( userData->startPositionLoc );

+   // Blend particles

+   glEnable ( GL_BLEND );

+   glBlendFunc ( GL_SRC_ALPHA, GL_ONE );

+

+   // Bind the texture

+   glActiveTexture ( GL_TEXTURE0 );

+   glBindTexture ( GL_TEXTURE_2D, userData->textureId );

+   glEnable ( GL_TEXTURE_2D );

+

+   // Set the sampler texture unit to 0

+   glUniform1i ( userData->samplerLoc, 0 );

+

+   glDrawArrays( GL_POINTS, 0, NUM_PARTICLES );

+   

+   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 );

+}

+

+

+int main ( int argc, char *argv[] )

+{

+   ESContext esContext;

+   UserData  userData;

+

+   esInitContext ( &esContext );

+   esContext.userData = &userData;

+

+   esCreateWindow ( &esContext, "ParticleSystem", 640, 480, ES_WINDOW_RGB );

+   

+   if ( !Init ( &esContext ) )

+      return 0;

+

+   esRegisterDrawFunc ( &esContext, Draw );

+   esRegisterUpdateFunc ( &esContext, Update );

+   

+   esMainLoop ( &esContext );

+

+   ShutDown ( &esContext );

+}

diff --git a/tests/glbook/Chapter_2/Hello_Triangle/Hello_Triangle_orig.c b/tests/glbook/Chapter_2/Hello_Triangle/Hello_Triangle_orig.c
new file mode 100644
index 00000000..fd4c506a
--- /dev/null
+++ b/tests/glbook/Chapter_2/Hello_Triangle/Hello_Triangle_orig.c
@@ -0,0 +1,193 @@
+//
+// 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
+//
+
+// Hello_Triangle.c
+//
+//    This is a simple example that draws a single triangle with
+//    a minimal vertex/fragment shader.  The purpose of this 
+//    example is to demonstrate the basic concepts of 
+//    OpenGL ES 2.0 rendering.
+#include <stdlib.h>
+#include "esUtil.h"
+
+typedef struct
+{
+   // Handle to a program object
+   GLuint programObject;
+
+} UserData;
+
+///
+// Create a shader object, load the shader source, and
+// compile the shader.
+//
+GLuint LoadShader ( GLenum type, const char *shaderSrc )
+{
+   GLuint shader;
+   GLint compiled;
+   
+   // Create the shader object
+   shader = glCreateShader ( type );
+
+   if ( shader == 0 )
+   	return 0;
+
+   // Load the shader source
+   glShaderSource ( shader, 1, &shaderSrc, NULL );
+   
+   // Compile the shader
+   glCompileShader ( shader );
+
+   // Check the compile status
+   glGetShaderiv ( shader, GL_COMPILE_STATUS, &compiled );
+
+   if ( !compiled ) 
+   {
+      GLint infoLen = 0;
+
+      glGetShaderiv ( shader, GL_INFO_LOG_LENGTH, &infoLen );
+      
+      if ( infoLen > 1 )
+      {
+         char* infoLog = malloc (sizeof(char) * infoLen );
+
+         glGetShaderInfoLog ( shader, infoLen, NULL, infoLog );
+         esLogMessage ( "Error compiling shader:\n%s\n", infoLog );            
+         
+         free ( infoLog );
+      }
+
+      glDeleteShader ( shader );
+      return 0;
+   }
+
+   return shader;
+
+}
+
+///
+// Initialize the shader and program object
+//
+int Init ( ESContext *esContext )
+{
+   esContext->userData = malloc(sizeof(UserData));
+
+   UserData *userData = esContext->userData;
+   GLbyte vShaderStr[] =  
+      "attribute vec4 vPosition;    \n"
+      "void main()                  \n"
+      "{                            \n"
+      "   gl_Position = vPosition;  \n"
+      "}                            \n";
+   
+   GLbyte fShaderStr[] =  
+      "precision mediump float;\n"\
+      "void main()                                  \n"
+      "{                                            \n"
+      "  gl_FragColor = vec4 ( 1.0, 0.0, 0.0, 1.0 );\n"
+      "}                                            \n";
+
+   GLuint vertexShader;
+   GLuint fragmentShader;
+   GLuint programObject;
+   GLint linked;
+
+   // Load the vertex/fragment shaders
+   vertexShader = LoadShader ( GL_VERTEX_SHADER, vShaderStr );
+   fragmentShader = LoadShader ( GL_FRAGMENT_SHADER, fShaderStr );
+
+   // Create the program object
+   programObject = glCreateProgram ( );
+   
+   if ( programObject == 0 )
+      return 0;
+
+   glAttachShader ( programObject, vertexShader );
+   glAttachShader ( programObject, fragmentShader );
+
+   // Bind vPosition to attribute 0   
+   glBindAttribLocation ( programObject, 0, "vPosition" );
+
+   // Link the program
+   glLinkProgram ( programObject );
+
+   // Check the link status
+   glGetProgramiv ( programObject, GL_LINK_STATUS, &linked );
+
+   if ( !linked ) 
+   {
+      GLint infoLen = 0;
+
+      glGetProgramiv ( programObject, GL_INFO_LOG_LENGTH, &infoLen );
+      
+      if ( infoLen > 1 )
+      {
+         char* infoLog = malloc (sizeof(char) * infoLen );
+
+         glGetProgramInfoLog ( programObject, infoLen, NULL, infoLog );
+         esLogMessage ( "Error linking program:\n%s\n", infoLog );            
+         
+         free ( infoLog );
+      }
+
+      glDeleteProgram ( programObject );
+      return GL_FALSE;
+   }
+
+   // Store the program object
+   userData->programObject = programObject;
+
+   glClearColor ( 0.0f, 0.0f, 0.0f, 0.0f );
+   return GL_TRUE;
+}
+
+///
+// Draw a triangle using the shader pair created in Init()
+//
+void Draw ( ESContext *esContext )
+{
+   UserData *userData = esContext->userData;
+   GLfloat vVertices[] = {  0.0f,  0.5f, 0.0f, 
+                           -0.5f, -0.5f, 0.0f,
+                            0.5f, -0.5f, 0.0f };
+      
+   // Set the viewport
+   glViewport ( 0, 0, esContext->width, esContext->height );
+   
+   // Clear the color buffer
+   glClear ( GL_COLOR_BUFFER_BIT );
+
+   // Use the program object
+   glUseProgram ( userData->programObject );
+
+   // Load the vertex data
+   glVertexAttribPointer ( 0, 3, GL_FLOAT, GL_FALSE, 0, vVertices );
+   glEnableVertexAttribArray ( 0 );
+
+   glDrawArrays ( GL_TRIANGLES, 0, 3 );
+}
+
+int main ( int argc, char *argv[] )
+{
+   ESContext esContext;
+   UserData  userData;
+
+   esInitContext ( &esContext );
+   esContext.userData = &userData;
+
+   esCreateWindow ( &esContext, "Hello Triangle", 320, 240, ES_WINDOW_RGB );
+
+   if ( !Init ( &esContext ) )
+      return 0;
+
+   esRegisterDrawFunc ( &esContext, Draw );
+
+   esMainLoop ( &esContext );
+}
diff --git a/tests/glbook/Chapter_8/Simple_VertexShader/Simple_VertexShader_orig.c b/tests/glbook/Chapter_8/Simple_VertexShader/Simple_VertexShader_orig.c
new file mode 100644
index 00000000..6036bf0c
--- /dev/null
+++ b/tests/glbook/Chapter_8/Simple_VertexShader/Simple_VertexShader_orig.c
@@ -0,0 +1,196 @@
+//
+// 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
+//
+
+// Simple_VertexShader.c
+//
+//    This is a simple example that draws a rotating cube in perspective
+//    using a vertex shader to transform the object
+//
+#include <stdlib.h>
+#include "esUtil.h"
+
+typedef struct
+{
+   // Handle to a program object
+   GLuint programObject;
+
+   // Attribute locations
+   GLint  positionLoc;
+
+   // Uniform locations
+   GLint  mvpLoc;
+   
+   // Vertex daata
+   GLfloat  *vertices;
+   GLuint *indices;
+   int       numIndices;
+
+   // Rotation angle
+   GLfloat   angle;
+
+   // MVP matrix
+   ESMatrix  mvpMatrix;
+} UserData;
+
+///
+// Initialize the shader and program object
+//
+int Init ( ESContext *esContext )
+{
+   esContext->userData = malloc(sizeof(UserData));
+	
+   UserData *userData = esContext->userData;
+   GLbyte vShaderStr[] =  
+      "uniform mat4 u_mvpMatrix;                   \n"
+      "attribute vec4 a_position;                  \n"
+      "void main()                                 \n"
+      "{                                           \n"
+      "   gl_Position = u_mvpMatrix * a_position;  \n"
+      "}                                           \n";
+   
+   GLbyte fShaderStr[] =  
+      "precision mediump float;                            \n"
+      "void main()                                         \n"
+      "{                                                   \n"
+      "  gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );        \n"
+      "}                                                   \n";
+
+   // Load the shaders and get a linked program object
+   userData->programObject = esLoadProgram ( vShaderStr, fShaderStr );
+
+   // Get the attribute locations
+   userData->positionLoc = glGetAttribLocation ( userData->programObject, "a_position" );
+
+   // Get the uniform locations
+   userData->mvpLoc = glGetUniformLocation( userData->programObject, "u_mvpMatrix" );
+   
+   // Generate the vertex data
+   userData->numIndices = esGenCube( 1.0, &userData->vertices,
+                                     NULL, NULL, &userData->indices );
+   
+   // Starting rotation angle for the cube
+   userData->angle = 45.0f;
+
+   glClearColor ( 0.0f, 0.0f, 0.0f, 0.0f );
+   return GL_TRUE;
+}
+
+
+///
+// Update MVP matrix based on time
+//
+void Update ( ESContext *esContext, float deltaTime )
+{
+   UserData *userData = (UserData*) esContext->userData;
+   ESMatrix perspective;
+   ESMatrix modelview;
+   float    aspect;
+   
+   // Compute a rotation angle based on time to rotate the cube
+   userData->angle += ( deltaTime * 40.0f );
+   if( userData->angle >= 360.0f )
+      userData->angle -= 360.0f;
+
+   // Compute the window aspect ratio
+   aspect = (GLfloat) esContext->width / (GLfloat) esContext->height;
+   
+   // Generate a perspective matrix with a 60 degree FOV
+   esMatrixLoadIdentity( &perspective );
+   esPerspective( &perspective, 60.0f, aspect, 1.0f, 20.0f );
+
+   // Generate a model view matrix to rotate/translate the cube
+   esMatrixLoadIdentity( &modelview );
+
+   // Translate away from the viewer
+   esTranslate( &modelview, 0.0, 0.0, -2.0 );
+
+   // Rotate the cube
+   esRotate( &modelview, userData->angle, 1.0, 0.0, 1.0 );
+   
+   // Compute the final MVP by multiplying the 
+   // modevleiw and perspective matrices together
+   esMatrixMultiply( &userData->mvpMatrix, &modelview, &perspective );
+}
+
+///
+// 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 );
+
+   // Use the program object
+   glUseProgram ( userData->programObject );
+
+   // Load the vertex position
+   glVertexAttribPointer ( userData->positionLoc, 3, GL_FLOAT, 
+                           GL_FALSE, 3 * sizeof(GLfloat), userData->vertices );
+   
+   glEnableVertexAttribArray ( userData->positionLoc );
+   
+   
+   // Load the MVP matrix
+   glUniformMatrix4fv( userData->mvpLoc, 1, GL_FALSE, (GLfloat*) &userData->mvpMatrix.m[0][0] );
+   
+   // Draw the cube
+   glDrawElements ( GL_TRIANGLES, userData->numIndices, GL_UNSIGNED_INT, userData->indices );
+}
+
+///
+// Cleanup
+//
+void ShutDown ( ESContext *esContext )
+{
+   UserData *userData = esContext->userData;
+
+   if ( userData->vertices != NULL )
+   {
+      free ( userData->vertices );
+   }
+
+   if ( userData->indices != NULL )
+   {
+      free ( userData->indices );
+   }
+
+   // Delete program object
+   glDeleteProgram ( userData->programObject );
+
+   free(userData);
+}
+
+int main ( int argc, char *argv[] )
+{
+   ESContext esContext;
+   UserData  userData;
+
+   esInitContext ( &esContext );
+   esContext.userData = &userData;
+
+   esCreateWindow ( &esContext, "Simple Texture 2D", 320, 240, ES_WINDOW_RGB );
+
+   if ( !Init ( &esContext ) )
+      return 0;
+
+   esRegisterDrawFunc ( &esContext, Draw );
+   esRegisterUpdateFunc ( &esContext, Update );
+
+   esMainLoop ( &esContext );
+
+   ShutDown ( &esContext );
+}
+
diff --git a/tests/glbook/Chapter_9/Simple_Texture2D/Simple_Texture2D_orig.c b/tests/glbook/Chapter_9/Simple_Texture2D/Simple_Texture2D_orig.c
new file mode 100644
index 00000000..cc465c9a
--- /dev/null
+++ b/tests/glbook/Chapter_9/Simple_Texture2D/Simple_Texture2D_orig.c
@@ -0,0 +1,199 @@
+//
+// 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
+//
+
+// Simple_Texture2D.c
+//
+//    This is a simple example that draws a quad with a 2D
+//    texture image. The purpose of this example is to demonstrate 
+//    the basics of 2D texturing
+//
+#include <stdlib.h>
+#include "esUtil.h"
+
+typedef struct
+{
+   // Handle to a program object
+   GLuint programObject;
+
+   // Attribute locations
+   GLint  positionLoc;
+   GLint  texCoordLoc;
+
+   // Sampler location
+   GLint samplerLoc;
+
+   // Texture handle
+   GLuint textureId;
+
+} UserData;
+
+///
+// Create a simple 2x2 texture image with four different colors
+//
+GLuint CreateSimpleTexture2D( )
+{
+   // Texture object handle
+   GLuint textureId;
+   
+   // 2x2 Image, 3 bytes per pixel (R, G, B)
+   GLubyte pixels[4 * 3] =
+   {  
+      255,   0,   0, // Red
+        0, 255,   0, // Green
+        0,   0, 255, // Blue
+      255, 255,   0  // Yellow
+   };
+
+   // Use tightly packed data
+   glPixelStorei ( GL_UNPACK_ALIGNMENT, 1 );
+
+   // Generate a texture object
+   glGenTextures ( 1, &textureId );
+
+   // Bind the texture object
+   glBindTexture ( GL_TEXTURE_2D, textureId );
+
+   // Load the texture
+   glTexImage2D ( GL_TEXTURE_2D, 0, GL_RGB, 2, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, pixels );
+
+   // Set the filtering mode
+   glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+   glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+
+   return textureId;
+
+}
+
+
+///
+// Initialize the shader and program object
+//
+int Init ( ESContext *esContext )
+{
+   esContext->userData = malloc(sizeof(UserData));	
+   UserData *userData = esContext->userData;
+   GLbyte vShaderStr[] =  
+      "attribute vec4 a_position;   \n"
+      "attribute vec2 a_texCoord;   \n"
+      "varying vec2 v_texCoord;     \n"
+      "void main()                  \n"
+      "{                            \n"
+      "   gl_Position = a_position; \n"
+      "   v_texCoord = a_texCoord;  \n"
+      "}                            \n";
+   
+   GLbyte fShaderStr[] =  
+      "precision mediump float;                            \n"
+      "varying vec2 v_texCoord;                            \n"
+      "uniform sampler2D s_texture;                        \n"
+      "void main()                                         \n"
+      "{                                                   \n"
+      "  gl_FragColor = texture2D( s_texture, v_texCoord );\n"
+      "}                                                   \n";
+
+   // Load the shaders and get a linked program object
+   userData->programObject = esLoadProgram ( vShaderStr, fShaderStr );
+
+   // Get the attribute locations
+   userData->positionLoc = glGetAttribLocation ( userData->programObject, "a_position" );
+   userData->texCoordLoc = glGetAttribLocation ( userData->programObject, "a_texCoord" );
+   
+   // Get the sampler location
+   userData->samplerLoc = glGetUniformLocation ( userData->programObject, "s_texture" );
+
+   // Load the texture
+   userData->textureId = CreateSimpleTexture2D ();
+
+   glClearColor ( 0.0f, 0.0f, 0.0f, 0.0f );
+   return GL_TRUE;
+}
+
+///
+// Draw a triangle using the shader pair created in Init()
+//
+void Draw ( ESContext *esContext )
+{
+   UserData *userData = esContext->userData;
+