三角形演示适用于ubuntu13.04，不适用于ubuntu 12.04

Question

我从互联网上获得了一个三角形演示。它适用于我的ubuntu13.04虚拟机，但它不能在我的ubuntu12.04虚拟机上运行。我的两台虚拟机都安装了libgles2-mesa-dev（apt-get）。唯一的diffrenet是：ubuntu12。 04 glesv2基于mesa-8.0而ubuntu13.04 glesv2基于mesa-9。 我的代码：

#include <GLES2/gl2.h>
#include <EGL/egl.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include <unistd.h>
#include <X11/Xlib.h>

#define VERTEX_ARRAY 0


EGLDisplay eglDisplay = 0;
EGLConfig eglConfig = 0;
EGLSurface eglSurface = 0;
EGLContext eglContext = 0;
EGLNativeWindowType eglWindow = 0;

bool TestEGLError()
{

    EGLint iErr = eglGetError();
    if (iErr != EGL_SUCCESS)
    {
        return false;
    }

    return true;
}

bool CreateEGLContext()
{
    eglDisplay = eglGetDisplay((EGLNativeDisplayType) EGL_DEFAULT_DISPLAY);

    EGLint iMajorVersion, iMinorVersion;
    if (!eglInitialize(eglDisplay, &iMajorVersion, &iMinorVersion))
    {
        return false;
    }

    const EGLint pi32ConfigAttribs[] =
    {
        EGL_LEVEL, 0,
        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
        EGL_NATIVE_RENDERABLE, EGL_FALSE,
        EGL_DEPTH_SIZE, EGL_DONT_CARE,
        EGL_NONE
    };
  EGLint config16bpp[] = {
        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
        EGL_RED_SIZE, 8,
        EGL_GREEN_SIZE, 8,
        EGL_BLUE_SIZE, 8,
        EGL_ALPHA_SIZE, 8,
        EGL_DEPTH_SIZE, 16,
        EGL_STENCIL_SIZE, 0,
        EGL_NONE
    };

    int iConfigs;
    if (!eglChooseConfig(eglDisplay,config16bpp, &eglConfig, 1, &iConfigs) || (iConfigs != 1))
    {

        return false;
    }


    eglSurface = eglCreateWindowSurface(eglDisplay, eglConfig, eglWindow, NULL);

    if(eglSurface == EGL_NO_SURFACE)
    {
        eglGetError(); // Clear error
        eglSurface = eglCreateWindowSurface(eglDisplay, eglConfig, NULL, NULL);
    }

    if (!TestEGLError())
    {
        return false;
    }


    eglBindAPI(EGL_OPENGL_ES_API);
    EGLint ai32ContextAttribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
    eglContext = eglCreateContext(eglDisplay, eglConfig, NULL, ai32ContextAttribs);

    if (!TestEGLError())
    {
        return false;
    }

    eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext);
    if (!TestEGLError())
    {
        return false;
    }

    return true;
}

bool Render()
{
    bool bRet = false;

    float pfIdentity[] =
    {
        1.0f,0.0f,0.0f,0.0f,
        0.0f,1.0f,0.0f,0.0f,
        0.0f,0.0f,1.0f,0.0f,
        0.0f,0.0f,0.0f,1.0f
    };

    char szFragShaderSrc[] = {"\
                              void main (void)\
                              {\
                              gl_FragColor = vec4(1.0, 1.0, 0.66 ,1.0);\
                              }"};
    char szVertShaderSrc[] = {"\
                              attribute highp vec4 myVertex;\
                              uniform mediump mat4 myPMVMatrix;\
                              void main(void)\
                              {\
                              gl_Position = myPMVMatrix * myVertex;\
                              }"};

    char * pszFragShader = (char *)szFragShaderSrc;
    char * pszVertShader = (char *)szVertShaderSrc;

    GLuint uiFragShader = 0;
    GLuint uiVertShader = 0; 
    GLuint uiProgramObject = 0;  

    GLint bShaderCompiled;
    GLint bLinked;

    GLuint ui32Vbo = 0; 

    GLfloat afVertices[] = { -0.4f,-0.4f,0.0f, // Position
        0.4f ,-0.4f,0.0f,
        0.0f ,0.4f ,0.0f};

    int i32InfoLogLength, i32CharsWritten;
    char* pszInfoLog = NULL;
    int i32Location = 0;
    unsigned int uiSize = 0;

    uiFragShader = glCreateShader(GL_FRAGMENT_SHADER);


    glShaderSource(uiFragShader, 1, (const char**)&pszFragShader, NULL);


    glCompileShader(uiFragShader);


    glGetShaderiv(uiFragShader, GL_COMPILE_STATUS, &bShaderCompiled);

    if (!bShaderCompiled)
    {  
        glGetShaderiv(uiFragShader, GL_INFO_LOG_LENGTH, &i32InfoLogLength);
        pszInfoLog = new char[i32InfoLogLength];
        glGetShaderInfoLog(uiFragShader, i32InfoLogLength, &i32CharsWritten, pszInfoLog);
        delete[] pszInfoLog;
        goto cleanup;
    }

    uiVertShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(uiVertShader, 1, (const char**)&pszVertShader, NULL);
    glCompileShader(uiVertShader);
    glGetShaderiv(uiVertShader, GL_COMPILE_STATUS, &bShaderCompiled);
    if (!bShaderCompiled)
    {
        glGetShaderiv(uiVertShader, GL_INFO_LOG_LENGTH, &i32InfoLogLength);
        pszInfoLog = new char[i32InfoLogLength];
        glGetShaderInfoLog(uiVertShader, i32InfoLogLength, &i32CharsWritten, pszInfoLog);
        delete[] pszInfoLog;
        goto cleanup;
    }

    uiProgramObject = glCreateProgram();

    glAttachShader(uiProgramObject, uiFragShader);
    glAttachShader(uiProgramObject, uiVertShader);

    glBindAttribLocation(uiProgramObject, VERTEX_ARRAY, "myVertex");

    glLinkProgram(uiProgramObject);

    glGetProgramiv(uiProgramObject, GL_LINK_STATUS, &bLinked);
    if (!bLinked)
    {
        glGetProgramiv(uiProgramObject, GL_INFO_LOG_LENGTH, &i32InfoLogLength);
        pszInfoLog = new char[i32InfoLogLength];
        glGetProgramInfoLog(uiProgramObject, i32InfoLogLength, &i32CharsWritten, pszInfoLog);
        delete[] pszInfoLog;
        goto cleanup;
    }

    glUseProgram(uiProgramObject);

    glClearColor(0.6f, 0.8f, 1.0f, 1.0f);

    glGenBuffers(1, &ui32Vbo);

    glBindBuffer(GL_ARRAY_BUFFER, ui32Vbo);

    uiSize = 3 * (sizeof(GLfloat) * 3); // Calc afVertices size (3 vertices * stride (3 GLfloats per vertex))
    glBufferData(GL_ARRAY_BUFFER, uiSize, afVertices, GL_STATIC_DRAW);

    {

        glClear(GL_COLOR_BUFFER_BIT);


        i32Location = glGetUniformLocation(uiProgramObject, "myPMVMatrix");

        glUniformMatrix4fv( i32Location, 1, GL_FALSE, pfIdentity);

        glEnableVertexAttribArray(VERTEX_ARRAY);

        glVertexAttribPointer(VERTEX_ARRAY, 3, GL_FLOAT, GL_FALSE, 0, 0);

        glDrawArrays(GL_TRIANGLES, 0, 3);

        eglSwapBuffers(eglDisplay, eglSurface);

    }
    bRet = true;

cleanup:
    if (uiProgramObject)
        glDeleteProgram(uiProgramObject);
    if (uiFragShader)
        glDeleteShader(uiFragShader);
    if (uiVertShader)
        glDeleteShader(uiVertShader);

    // Delete the VBO as it is no longer needed
    if (ui32Vbo)
        glDeleteBuffers(1, &ui32Vbo);

    return bRet;
}



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

     unsigned int uiHeight = 800;
        unsigned int uiWidth = 480;
        int screen;
        Display    *x_display;
        Window          root_window;

        x_display = XOpenDisplay ( NULL );   // open the standard display (the primary screen)
        if ( x_display == NULL ) {
            printf ("cannot connect to X server");
            return false;
         }

    screen = DefaultScreen(x_display);
    root_window = RootWindow(x_display,screen);

    static int Hnd = XCreateSimpleWindow(x_display, root_window,0,0,800,480,0,0,0);
    eglWindow = (EGLNativeWindowType)Hnd;


if (!eglWindow)
    {
        printf("Failed to create X window.\n");
        return false;
    }

    XUndefineCursor(x_display, eglWindow);
            XMapRaised(x_display, eglWindow);
    XFlush(x_display);

CreateEGLContext();
while(1)
{
Render();
usleep(100000);
}

return 0;
}