typedef struct _escontext
 {
    void*       userData;                    // Put your user data here...
    GLint       width;                          // Window width
    GLint       height;                         // Window height
    EGLNativeWindowType  hWnd;  // Window handle
    EGLDisplay  eglDisplay;             // EGL display
    EGLContext  eglContext;            // EGL context
    EGLSurface  eglSurface;            // EGL surface

    // Callbacks
    void (ESCALLBACK *drawFunc) ( struct _escontext * );
    void (ESCALLBACK *keyFunc) ( struct _escontext *, unsigned char, int, int );
    void (ESCALLBACK *updateFunc) ( struct _escontext *, float deltaTime );
 }ESContext;

 typedef struct
 {
    // Handle to a program object
    GLuint programObject;

    // Atrribute Location
    GLint positionLoc;
    GLint textureLoc;

    // Uniform location
    GLint matrixModeLoc;
    GLint matrixViewLoc;
    GLint matrixPerspectiveLoc;

    // Sampler location
    GLint samplerLoc;

    // texture
    GLuint texture;
 } UserData;

 /* type specifies the Shader type: GL_VERTEX_SHADER or GL_FRAGMENT_SHADER */
 GLuint LoadShader ( GLenum type, const char *shaderSrc )
 {
    GLuint shader;
    GLint compiled;

    // Create an empty shader object, which maintain the source code strings that define a shader
    shader = glCreateShader ( type );

     )
        ;

    // Replaces the source code in a shader object
    glShaderSource ( shader, , &shaderSrc, NULL );

    // Compile the shader object
    glCompileShader ( shader );

    // Check the shader object compile status
    glGetShaderiv ( shader, GL_COMPILE_STATUS, &compiled );

    if ( !compiled )
    {
       GLint infoLen = ;

       glGetShaderiv ( shader, GL_INFO_LOG_LENGTH, &infoLen );

        )
       {
          char* infoLog = malloc (sizeof(char) * infoLen );

          glGetShaderInfoLog ( shader, infoLen, NULL, infoLog );
          esLogMessage ( "Error compiling shader:\n%s\n", infoLog );            

          free ( infoLog );
       }

       glDeleteShader ( shader );
       ;
    }

    return shader;
 }

 GLuint LoadProgram ( const char *vShaderStr, const char *fShaderStr )
 {
    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 ( );
     )
       ;

    // Attaches a shader object to a program object
    glAttachShader ( programObject, vertexShader );
    glAttachShader ( programObject, fragmentShader );
    // Bind vPosition to attribute 0  
    glBindAttribLocation ( programObject, , "vPosition" );
    // Link the program object
    glLinkProgram ( programObject );

    // Check the link status
    glGetProgramiv ( programObject, GL_LINK_STATUS, &linked );

    if ( !linked )
    {
       GLint infoLen = ;

       glGetProgramiv ( programObject, GL_INFO_LOG_LENGTH, &infoLen );

        )
       {
          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;
    }

    // Free no longer needed shader resources
    glDeleteShader ( vertexShader );
    glDeleteShader ( fragmentShader );

    return programObject;
 }

 int CreateProgram(ESContext * esContext)
 {
      GLuint programObject;

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

     // Create user data
     esContext->userData = malloc(sizeof(UserData));
     UserData *userData = esContext->userData;

     // Load the shaders and get a linked program object
     programObject = LoadProgram ( (const char*)vShaderStr, (const char*)fShaderStr );
     )
     {
     return GL_FALSE;
     }

     // Store the program object
     userData->programObject = programObject;

     // Get the attribute locations
     userData->positionLoc = glGetAttribLocation ( g_programObject, "v_position" );
     glClearColor ( 0.0f, 0.0f, 0.0f, 1.0f );
     ;
 }

 void Render ( 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 ( , , 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 ( , , GL_FLOAT, GL_FALSE, , vVertices );
    glEnableVertexAttribArray (  );
    glDrawArrays ( GL_TRIANGLES, ,  );
    eglSwapBuffers(esContext->eglDisplay, esContext->eglSurface);

    void glVertexAttribPointer(
          GLuint   index,           // 指示将被修改的通用顶点属性的索引
           GLint   size,             // 指点每个顶点元素个数(1~4)
          GLenum   type,            // 数组中每个元素的数据类型
           GLboolean   normalized,   //指示定点数据值是否被归一化(归一化<[-1,1]或[0,1]>：GL_TRUE,直接使用:GL_FALSE)
          GLsizei   stride,         // 连续顶点属性间的偏移量，如果为0，相邻顶点属性间紧紧相邻
           const GLvoid *   pointer);//顶点数组
 //注:其index应该小于#define GL_MAX_VERTEX_ATTRIBS&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 0x8869