Attachment 85735 Details for Bug 69285 – SDL 1.2-based test case

SDL 1.2-based test case

main.cpp (text/plain), 8.33 KB, created by Charles Huber on 2013-09-12 18:26:29 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Charles Huber

Created: 2013-09-12 18:26:29 UTC

Size: 8.33 KB

patch

obsolete

>#include <iostream>
>#include <stdexcept>
>#include <vector>
>#include <map>
>#include <string>
>
>#include <glm/glm.hpp>
>#include <glm/gtc/matrix_transform.hpp>
>#include <glm/gtc/type_ptr.hpp>
>
>#include <SDL/SDL.h>
>#include <SDL/SDL_syswm.h>
>
>#include <EGL/egl.h>
>#include <GLES2/gl2.h>
>
>using namespace std;
>using namespace glm;
>
>
>class GlesContext
>{
>public:
>    GlesContext( NativeDisplayType aNatDisplay, NativeWindowType aNatWindow, EGLint aVersion = 1 )
>    {
>        if( ( mDisplay = eglGetDisplay( aNatDisplay ) ) == EGL_NO_DISPLAY )
>            throw runtime_error( "eglGetDisplay(): no display" );
>
>        EGLint maj = 0, min = 0;
>        if( eglInitialize( mDisplay, &maj, &min ) != EGL_TRUE )
>            throw runtime_error( "eglInitialize():" + eglGetErrorString() );
>
>        EGLint rtype = 0;
>        #ifdef EGL_OPENGL_ES_BIT
>        if( 1 == aVersion ) rtype = EGL_OPENGL_ES_BIT;
>        #endif
>        #ifdef EGL_OPENGL_ES2_BIT
>        if( 2 == aVersion ) rtype = EGL_OPENGL_ES2_BIT;
>        #endif
>        const EGLint cfgAttrs[] =
>        {
>            EGL_RED_SIZE,      	    5,
>            EGL_GREEN_SIZE,    	    5,
>            EGL_BLUE_SIZE,     	    5,
>            EGL_DEPTH_SIZE,	        16,
>            EGL_RENDERABLE_TYPE,    rtype,
>            EGL_NONE
>        };
>        EGLint numConfigs = 0;
>        if( eglChooseConfig( mDisplay, cfgAttrs, &mConfig, 1, &numConfigs ) != EGL_TRUE )
>            throw runtime_error( "eglChooseConfig(): " + eglGetErrorString() );
>        if( numConfigs == 0 )
>            throw runtime_error( "eglChooseConfig(): no matching config" );
>
>        if( ( mSurface = eglCreateWindowSurface( mDisplay, mConfig, aNatWindow, NULL ) ) == EGL_NO_SURFACE )
>            throw runtime_error( "eglCreateWindowSurface(): " + eglGetErrorString() );
>
>        if( eglBindAPI( EGL_OPENGL_ES_API ) != EGL_TRUE )
>            throw runtime_error( "eglBindAPI(): " + eglGetErrorString() );
>
>        EGLint ctxAttrs[] =
>        {
>            EGL_CONTEXT_CLIENT_VERSION, aVersion,
>            EGL_NONE
>        };
>        if( ( mContext = eglCreateContext( mDisplay, mConfig, EGL_NO_CONTEXT, ctxAttrs ) ) == EGL_NO_CONTEXT )
>            throw runtime_error( "eglCreateContext(): " + eglGetErrorString() );
>
>        if( !MakeCurrent() )
>            throw runtime_error( "eglMakeCurrent(): " + eglGetErrorString() );
>    }
>
>    ~GlesContext()
>    {
>        MakeCurrent( true );
>        eglDestroySurface( mDisplay, mSurface );
>        eglDestroyContext( mDisplay, mContext );
>        eglTerminate( mDisplay );
>    }
>
>    bool MakeCurrent( const bool aRelease = false )
>    {
>        EGLBoolean err = eglMakeCurrent
>            (
>            mDisplay,
>            ( aRelease ? EGL_NO_SURFACE : mSurface ),
>            ( aRelease ? EGL_NO_SURFACE : mSurface ),
>            ( aRelease ? EGL_NO_CONTEXT : mContext )
>            );
>        return ( EGL_TRUE == err );
>    }
>
>    bool SwapBuffers()
>    {
>        EGLBoolean err = eglSwapBuffers( mDisplay, mSurface );
>        return ( EGL_TRUE == err );
>    }
>
>private:
>    static std::string eglGetErrorString()
>    {
>        EGLint err = eglGetError();
>        if( err == EGL_NOT_INITIALIZED      )   return "EGL_NOT_INITIALIZED";
>        if( err == EGL_BAD_ACCESS           )   return "EGL_BAD_ACCESS";
>        if( err == EGL_BAD_ALLOC            )   return "EGL_BAD_ALLOC";
>        if( err == EGL_BAD_ATTRIBUTE        )   return "EGL_BAD_ATTRIBUTE";
>        if( err == EGL_BAD_CONTEXT          )   return "EGL_BAD_CONTEXT";
>        if( err == EGL_BAD_CONFIG           )   return "EGL_BAD_CONFIG";
>        if( err == EGL_BAD_CURRENT_SURFACE  )   return "EGL_BAD_CURRENT_SURFACE";
>        if( err == EGL_BAD_DISPLAY          )   return "EGL_BAD_DISPLAY";
>        if( err == EGL_BAD_SURFACE          )   return "EGL_BAD_SURFACE";
>        if( err == EGL_BAD_MATCH            )   return "EGL_BAD_MATCH";
>        if( err == EGL_BAD_PARAMETER        )   return "EGL_BAD_PARAMETER";
>        if( err == EGL_BAD_NATIVE_PIXMAP    )   return "EGL_BAD_NATIVE_PIXMAP";
>        if( err == EGL_BAD_NATIVE_WINDOW    )   return "EGL_BAD_NATIVE_WINDOW";
>        if( err == EGL_CONTEXT_LOST         )   return "EGL_CONTEXT_LOST";
>        return "";
>    }
>
>public:
>    EGLDisplay mDisplay;
>    EGLConfig mConfig;
>    EGLSurface mSurface;
>    EGLContext mContext;
>};
>
>
>void CheckStatus( GLuint obj )
>{
>    GLint status = GL_FALSE;
>    if( glIsShader(obj) )   glGetShaderiv( obj, GL_COMPILE_STATUS, &status );
>    if( glIsProgram(obj) )  glGetProgramiv( obj, GL_LINK_STATUS, &status );
>    if( status == GL_TRUE ) return;
>    char log[32768] = { 0 };
>    if( glIsShader(obj) )   glGetShaderInfoLog( obj, sizeof(log), NULL, log );
>    if( glIsProgram(obj) )  glGetProgramInfoLog( obj, sizeof(log), NULL, log );
>    std::cerr << log << std::endl;
>    exit( -1 );
>}
>
>void AttachShader( GLuint program, GLenum type, const char* src )
>{
>    GLuint shader = glCreateShader( type );
>    glShaderSource( shader, 1, &src, NULL );
>    glCompileShader( shader );
>    CheckStatus( shader );
>    glAttachShader( program, shader );
>    glDeleteShader( shader );
>}
>
>GLuint LoadShader( const char* vert, const char* frag )
>{
>    GLuint prog = glCreateProgram();
>    if( vert ) AttachShader( prog, GL_VERTEX_SHADER, vert );
>    if( frag ) AttachShader( prog, GL_FRAGMENT_SHADER, frag );
>    glLinkProgram( prog );
>    CheckStatus( prog );
>    return prog;
>}
>
>#define GLSL( version, shader )   "#version " #version "\n" #shader
>
>const GLchar* vertProg = GLSL
>(
>    100,
>    uniform mat4 uProj;
>    uniform mat4 uView;
>    attribute vec4 aPosn;
>    void main()
>    {
>        gl_Position = uProj * uView * aPosn;
>    }
>);
>
>const GLchar* fragProg = GLSL
>(
>    100,
>    precision highp float;
>    const float size = 3.0;
>    void main()
>    {
>        float xpos = floor( gl_FragCoord.x / size );
>        float ypos = floor( gl_FragCoord.y / size );
>        float col = mod( xpos + mod( ypos, 2.0 ), 2.0 );
>        gl_FragColor = vec4( col );
>    }
>);
>
>int main( int argc, char* argv[] )
>{
>    SDL_Init( SDL_INIT_EVERYTHING );
>    SDL_Surface* display = SDL_SetVideoMode( 640, 480, 32, SDL_SWSURFACE );
>
>    // Get the SDL window handle
>    SDL_SysWMinfo sysInfo;
>    SDL_VERSION( &sysInfo.version );
>    if( SDL_GetWMInfo( &sysInfo ) <= 0 )
>        return -1;
>
>    cout << "Creating context..." << endl;
>    GlesContext* ctx = NULL;
>    try
>    {
>        // X11
>        sysInfo.info.x11.lock_func();
>        ctx = new GlesContext( sysInfo.info.x11.display, sysInfo.info.x11.window, 2 );
>        sysInfo.info.x11.unlock_func();
>    }
>    catch( std::exception& e )
>    {
>        cerr << "Exception: " << e.what() << endl;
>        return -1;
>    }
>    cout << "Context created!" << endl;
>
>    cout << "Loading shader..." << endl;
>    GLuint prog = LoadShader( vertProg, fragProg );
>    cout << "Shader loaded!" << endl;
>
>    glEnable( GL_DEPTH_TEST );
>
>    // create geometry
>    vector< vec2 > verts;
>    verts.push_back( vec2( -4, -4 ) );
>    verts.push_back( vec2(  4, -4 ) );
>    verts.push_back( vec2(  4,  4 ) );
>    verts.push_back( vec2(  4,  4 ) );
>    verts.push_back( vec2( -4,  4 ) );
>    verts.push_back( vec2( -4, -4 ) );
>
>    bool running = true;
>    while( running )
>    {
>        // handle all pending events
>        SDL_Event event;
>        while( SDL_PollEvent(&event) )
>        {
>            switch (event.type)
>            {
>            case SDL_QUIT:
>                running = false;
>                break;
>            default:
>                break;
>            }
>        }
>
>        glClearColor( 0, 0, 0, 0 );
>        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
>
>        glUseProgram( prog );
>
>        glm::mat4 proj = glm::ortho( -2.0f, 2.0f, -2.0f, 2.0f, -1.0f, 1.0f );
>        GLint u_proj = glGetUniformLocation( prog, "uProj" );
>        glUniformMatrix4fv( u_proj, 1, GL_FALSE, glm::value_ptr( proj ) );
>
>        glm::mat4 view = glm::mat4( 1.0f );
>        view = glm::rotate( view, (float)SDL_GetTicks() / 10.0f, glm::vec3( 0.0f, 0.0f, 1.0f ) );
>        GLint uView = glGetUniformLocation( prog, "uView" );
>        glUniformMatrix4fv( uView, 1, GL_FALSE, glm::value_ptr( view ) );
>
>        GLint aPosn = glGetAttribLocation( prog, "aPosn" );
>        glVertexAttribPointer( aPosn, 2, GL_FLOAT, GL_FALSE, sizeof( vec2 ), &verts[0] );
>        glEnableVertexAttribArray( aPosn );
>
>        glDrawArrays( GL_TRIANGLES, 0, verts.size() );
>
>        glDisableVertexAttribArray( aPosn );
>
>        ctx->SwapBuffers();
>    }
>
>    delete ctx;
>
>    SDL_Quit();
>    return 0;
>}

Actions: View

Attachments on bug 69285: 85735 | 85736 | 85737

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.