Changeset 10703

Show
Ignore:
Timestamp:
10/30/09 16:17:38 (5 years ago)
Author:
robert
Message:

Added EGL support into build system for GLES1 + GLES2.

Added EGL support into GraphicsWindowX11.

Location:
OpenSceneGraph/trunk
Files:
13 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/CMakeLists.txt

    r10691 r10703  
    287287OPTION(OSG_GLES1_AVAILABLE "Set to OFF to disable use of OpenGL ES 1.x functions library." OFF) 
    288288OPTION(OSG_GLES2_AVAILABLE "Set to OFF to disable use of OpenGL ES 2.x functions library." OFF) 
     289 
     290SET(OPENGL_egl_LIBRARY CACHE STRING "Set the OpenGL egl library.") 
    289291 
    290292# SET(OSG_GL_DISPLAYLISTS_AVAILABLE ${OSG_GL1_AVAILABLE}) 
  • OpenSceneGraph/trunk/CMakeModules/OsgMacroUtils.cmake

    r9808 r10703  
    5252 
    5353MACRO(LINK_CORELIB_DEFAULT CORELIB_NAME) 
    54     LINK_EXTERNAL(${CORELIB_NAME} ${OPENGL_LIBRARIES})  
     54    SET(ALL_GL_LIBRARIES ${OPENGL_LIBRARIES}) 
     55    IF (OSG_GLES1_AVAILABLE OR OSG_GLES2_AVAILABLE) 
     56        SET(ALL_GL_LIBRARIES ${ALL_GL_LIBRARIES} ${OPENGL_egl_LIBRARY}) 
     57    ENDIF() 
     58 
     59    LINK_EXTERNAL(${CORELIB_NAME} ${ALL_GL_LIBRARIES})  
    5560    LINK_WITH_VARIABLES(${CORELIB_NAME} OPENTHREADS_LIBRARY) 
    5661    IF(OPENSCENEGRAPH_SONAMES) 
     
    95100      ENDIF(TO_INSERT) 
    96101    ENDFOREACH(LINKLIB) 
     102 
     103    SET(ALL_GL_LIBRARIES ${OPENGL_LIBRARIES}) 
     104    IF (OSG_GLES1_AVAILABLE OR OSG_GLES2_AVAILABLE) 
     105        SET(ALL_GL_LIBRARIES ${ALL_GL_LIBRARIES} ${OPENGL_egl_LIBRARY}) 
     106    ENDIF() 
    97107 
    98108#    FOREACH(LINKLIB ${TARGET_LIBRARIES}) 
     
    108118    IF(MSVC  AND OSG_MSVC_VERSIONED_DLL) 
    109119        #when using full path name to specify linkage, it seems that already linked libs must be specified 
    110             LINK_EXTERNAL(${TARGET_TARGETNAME} ${OPENGL_LIBRARIES})  
     120            LINK_EXTERNAL(${TARGET_TARGETNAME} ${ALL_GL_LIBRARIES})  
    111121    ENDIF(MSVC AND OSG_MSVC_VERSIONED_DLL) 
    112122 
  • OpenSceneGraph/trunk/include/osg/ClipPlane

    r10691 r10703  
    2121#ifndef GL_CLIP_PLANE0 
    2222    #define GL_CLIP_PLANE0 0x3000 
     23    #define GL_CLIP_PLANE1 0x3001 
     24    #define GL_CLIP_PLANE2 0x3002 
     25    #define GL_CLIP_PLANE3 0x3003 
     26    #define GL_CLIP_PLANE4 0x3004 
     27    #define GL_CLIP_PLANE5 0x3005 
    2328#endif 
    2429 
  • OpenSceneGraph/trunk/include/osg/GL2Extensions

    r10691 r10703  
    3737#endif 
    3838 
     39#if !defined(GL_VERSION_2_0) 
     40    #define GL_VERTEX_PROGRAM_POINT_SIZE      0x8642 
     41    #define GL_VERTEX_PROGRAM_TWO_SIDE        0x8643 
     42#endif 
     43 
    3944#if !defined(GL_VERSION_2_0) && !defined(GL_ES_VERSION_2_0) 
    4045#define GL_VERSION_2_0 1 
     
    4550#define GL_VERTEX_ATTRIB_ARRAY_TYPE       0x8625 
    4651#define GL_CURRENT_VERTEX_ATTRIB          0x8626 
    47 #define GL_VERTEX_PROGRAM_POINT_SIZE      0x8642 
    48 #define GL_VERTEX_PROGRAM_TWO_SIDE        0x8643 
    4952#define GL_VERTEX_ATTRIB_ARRAY_POINTER    0x8645 
    5053#define GL_STENCIL_BACK_FUNC              0x8800 
  • OpenSceneGraph/trunk/include/osg/Light

    r10691 r10703  
    2121#ifndef GL_LIGHT0 
    2222    #define GL_LIGHT0 0x4000 
     23    #define GL_LIGHT1 0x4001 
     24    #define GL_LIGHT2 0x4002 
     25    #define GL_LIGHT3 0x4003 
     26    #define GL_LIGHT4 0x4004 
     27    #define GL_LIGHT5 0x4005 
     28    #define GL_LIGHT6 0x4006 
     29    #define GL_LIGHT7 0x4007 
    2330#endif 
    2431 
  • OpenSceneGraph/trunk/include/osg/Transform

    r7648 r10703  
    1919 
    2020#ifndef GL_RESCALE_NORMAL 
    21 #define GL_RESCALE_NORMAL                 0x803A 
     21#define GL_RESCALE_NORMAL       0x803A 
     22#endif 
     23 
     24#ifndef GL_NORMALIZE 
     25#define GL_NORMALIZE            0x0BA1 
    2226#endif 
    2327 
  • OpenSceneGraph/trunk/include/osgViewer/api/X11/GraphicsWindowX11

    r8763 r10703  
    2525 
    2626#include <X11/X.h> 
    27 #include <GL/glx.h> 
     27#include <X11/Xlib.h> 
     28#include <X11/Xutil.h> 
     29 
     30#if defined(OSG_GLES1_AVAILABLE) || defined(OSG_GLES2_AVAILABLE)  
     31    #define OSG_USE_EGL 
     32    #include <EGL/egl.h> 
     33#else 
     34    #include <GL/glx.h> 
     35#endif 
     36 
     37 
    2838#include <string.h> 
    2939 
     
    4252            _window(0), 
    4353            _visualInfo(0), 
    44             _glxContext(0), 
     54            _context(0), 
     55            #ifdef OSG_USE_EGL 
     56            _surface(0), 
     57            #endif 
    4558            _currentCursor(0), 
    4659            _initialized(false), 
     
    145158        Window& getParent() { return _parent; } 
    146159        Window& getWindow() { return _window; } 
    147         GLXContext& getGLXContext() { return _glxContext; } 
     160 
     161 
     162        #ifdef OSG_USE_EGL 
     163        typedef EGLContext Context; 
     164        #else 
     165        typedef GLXContext Context; 
     166        #endif 
     167 
     168        Context& getContext() { return _context; } 
    148169 
    149170        Cursor getCurrentCursor() { return _currentCursor; } 
     
    181202        Window          _window; 
    182203        XVisualInfo*    _visualInfo; 
    183         GLXContext      _glxContext; 
     204        Context         _context; 
     205 
     206        #ifdef OSG_USE_EGL 
     207        EGLSurface      _surface; 
     208        #endif 
    184209 
    185210        Cursor          _currentCursor; 
  • OpenSceneGraph/trunk/include/osgViewer/api/X11/PixelBufferX11

    r7873 r10703  
    2020#define OSGVIEWER_PIXELBUFFERX11 1 
    2121 
    22 #include <osg/GraphicsContext> 
    23 #include <osgViewer/Export> 
     22#include <osgViewer/api/X11/GraphicsWindowX11> 
    2423 
    25 #define GLX_GLXEXT_PROTOTYPES  1 
    26  
    27 #include <X11/X.h> 
    28 #include <GL/glx.h> 
    29  
    30 #ifndef GLX_VERSION_1_3 
    31     typedef XID GLXPbuffer; 
     24#ifndef OSG_USE_EGL 
     25    #ifndef GLX_VERSION_1_3 
     26        typedef XID GLXPbuffer; 
     27    #endif 
    3228#endif 
    33  
    3429 
    3530namespace osgViewer 
     
    7873        Display* getDisplay() const { return _display; } 
    7974         
    80         GLXPbuffer& getPbuffer() { return _pbuffer; } 
    81         GLXContext& getGLXContext() { return _glxContext; } 
     75        #ifdef OSG_USE_EGL 
     76            typedef EGLContext Context; 
     77            typedef EGLSurface Pbuffer; 
     78        #else 
     79            typedef GLXContext Context; 
     80            typedef GLXPbuffer Pbuffer; 
     81        #endif 
     82 
     83        Pbuffer& getPbuffer() { return _pbuffer; } 
     84        Context& getContext() { return _context; } 
    8285 
    8386    protected: 
     
    9194        bool            _valid; 
    9295        Display*        _display; 
    93         GLXPbuffer      _pbuffer; 
     96        Pbuffer         _pbuffer; 
    9497        XVisualInfo*    _visualInfo; 
    95         GLXContext      _glxContext; 
     98        Context         _context; 
    9699 
    97100        bool            _initialized; 
  • OpenSceneGraph/trunk/src/osgPlugins/osg/StateSet.cpp

    r10699 r10703  
    77#include <osg/PolygonOffset> 
    88#include <osg/LineStipple> 
     9#include <osg/Light> 
     10#include <osg/ClipPlane> 
     11#include <osg/AlphaFunc> 
     12#include <osg/Point> 
     13#include <osg/Material> 
     14#include <osg/Fog> 
     15#include <osg/GL2Extensions> 
    916 
    1017#include <osgDB/Registry> 
  • OpenSceneGraph/trunk/src/osgPlugins/scale/ReaderWriterSCALE.cpp

    r10504 r10703  
    166166        xform->addChild( node ); 
    167167 
    168         // turn on GL_NORMALIZE to prevent problems with scaled normals 
    169         osg::StateSet* ss = xform->getOrCreateStateSet(); 
    170         ss->setMode( GL_NORMALIZE, osg::StateAttribute::ON ); 
    171  
     168        #ifndef OSG_GLES2_AVAILABLE 
     169            // turn on GL_NORMALIZE to prevent problems with scaled normals 
     170            osg::StateSet* ss = xform->getOrCreateStateSet(); 
     171            ss->setMode( GL_NORMALIZE, osg::StateAttribute::ON ); 
     172        #endif 
     173         
    172174        return xform; 
    173175    } 
  • OpenSceneGraph/trunk/src/osgViewer/CMakeLists.txt

    r10699 r10703  
    109109        ENDIF() 
    110110 
    111         IF(OSG_GLES1_AVAILABLE OR OSG_GLES2_AVAILABLE) 
    112         ELSE() 
    113             SET(LIB_PUBLIC_HEADERS ${LIB_PUBLIC_HEADERS} 
    114                 ${HEADER_PATH}/api/X11/GraphicsWindowX11 
    115                 ${HEADER_PATH}/api/X11/PixelBufferX11 
    116             ) 
     111        SET(LIB_PUBLIC_HEADERS ${LIB_PUBLIC_HEADERS} 
     112            ${HEADER_PATH}/api/X11/GraphicsWindowX11 
     113            ${HEADER_PATH}/api/X11/PixelBufferX11 
     114        ) 
    117115 
    118             SET(LIB_COMMON_FILES ${LIB_COMMON_FILES}  
    119                 GraphicsWindowX11.cpp  
    120                 PixelBufferX11.cpp 
    121             ) 
    122         ENDIF() 
     116        SET(LIB_COMMON_FILES ${LIB_COMMON_FILES}  
     117            GraphicsWindowX11.cpp  
     118            PixelBufferX11.cpp 
     119        ) 
    123120 
    124121        IF(OSGVIEWER_USE_XRANDR) 
  • OpenSceneGraph/trunk/src/osgViewer/GraphicsWindowX11.cpp

    r10544 r10703  
    277277    else 
    278278    { 
     279    #ifdef OSG_USE_EGL 
     280 
     281        _visualInfo = new XVisualInfo; 
     282        int depth = DefaultDepth( _display, _traits->screenNum ); 
     283        if (XMatchVisualInfo( _display, _traits->screenNum, depth, TrueColor, _visualInfo )==0) 
     284        { 
     285            osg::notify(osg::NOTICE)<<"GraphicsWindowX11::createVisualInfo() failed."<<std::endl; 
     286            return false; 
     287        } 
     288 
     289    #else 
    279290 
    280291        typedef std::vector<int> Attributes; 
     
    298309        if (_traits->stencil) { attributes.push_back(GLX_STENCIL_SIZE); attributes.push_back(_traits->stencil); } 
    299310     
    300     #if defined(GLX_SAMPLE_BUFFERS) && defined (GLX_SAMPLES) 
    301      
    302         if (_traits->sampleBuffers) { attributes.push_back(GLX_SAMPLE_BUFFERS); attributes.push_back(_traits->sampleBuffers); } 
    303         if (_traits->sampleBuffers) { attributes.push_back(GLX_SAMPLES); attributes.push_back(_traits->samples); } 
    304      
    305     #endif 
     311        #if defined(GLX_SAMPLE_BUFFERS) && defined (GLX_SAMPLES) 
     312         
     313            if (_traits->sampleBuffers) { attributes.push_back(GLX_SAMPLE_BUFFERS); attributes.push_back(_traits->sampleBuffers); } 
     314            if (_traits->sampleBuffers) { attributes.push_back(GLX_SAMPLES); attributes.push_back(_traits->samples); } 
     315         
     316        #endif 
    306317        // TODO 
    307318        //  GLX_AUX_BUFFERS 
     
    314325         
    315326        _visualInfo = glXChooseVisual( _display, _traits->screenNum, &(attributes.front()) ); 
     327    #endif 
    316328    } 
    317329 
     
    603615    _ownsWindow = windowHandle == 0; 
    604616 
    605  
    606  
    607617    _display = XOpenDisplay(_traits->displayName().c_str()); 
    608618 
     
    614624    } 
    615625 
    616     // Query for GLX extension 
    617     int errorBase, eventBase; 
    618     if( glXQueryExtension( _display, &errorBase, &eventBase)  == False ) 
    619     { 
    620         osg::notify(osg::NOTICE)<<"Error: " << XDisplayName(_traits->displayName().c_str()) <<" has no GLX extension." << std::endl; 
    621  
    622         XCloseDisplay( _display ); 
    623         _display = 0; 
    624         _valid = false; 
    625         return; 
    626     } 
    627  
     626    #ifdef OSG_USE_EGL 
     627 
     628        EGLDisplay eglDisplay = eglGetDisplay((EGLNativeDisplayType)_display); 
     629 
     630        EGLint eglMajorVersion, eglMinorVersion; 
     631        if (!eglInitialize(eglDisplay, &eglMajorVersion, &eglMinorVersion)) 
     632        { 
     633            osg::notify(osg::NOTICE)<<"GraphicsWindowX11::init() - eglInitialize() failed."<<std::endl; 
     634 
     635            XCloseDisplay( _display ); 
     636            _display = 0; 
     637            _valid = false; 
     638            return; 
     639        } 
     640 
     641        osg::notify(osg::NOTICE)<<"GraphicsWindowX11::init() - eglInitialize() succeded eglMajorVersion="<<eglMajorVersion<<" iMinorVersion="<<eglMinorVersion<<std::endl; 
     642 
     643   #else 
     644        // Query for GLX extension 
     645        int errorBase, eventBase; 
     646        if( glXQueryExtension( _display, &errorBase, &eventBase)  == False ) 
     647        { 
     648            osg::notify(osg::NOTICE)<<"Error: " << XDisplayName(_traits->displayName().c_str()) <<" has no GLX extension." << std::endl; 
     649 
     650            XCloseDisplay( _display ); 
     651            _display = 0; 
     652            _valid = false; 
     653            return; 
     654        } 
     655    #endif 
     656     
    628657    // osg::notify(osg::NOTICE)<<"GLX extension, errorBase="<<errorBase<<" eventBase="<<eventBase<<std::endl; 
    629658 
     
    648677    } 
    649678 
    650     GLXContext sharedContextGLX = NULL; 
     679    Context sharedContextGLX = NULL; 
    651680 
    652681    // get any shared GLX contexts     
     
    654683    if (graphicsWindowX11)  
    655684    { 
    656         sharedContextGLX = graphicsWindowX11->getGLXContext(); 
     685        sharedContextGLX = graphicsWindowX11->getContext(); 
    657686    } 
    658687    else 
     
    661690        if (pixelBufferX11 && pixelBufferX11->valid()) 
    662691        { 
    663             sharedContextGLX = pixelBufferX11->getGLXContext(); 
    664         } 
    665     } 
    666      
    667     _glxContext = glXCreateContext( _display, _visualInfo, sharedContextGLX, True ); 
    668      
    669     if (!_glxContext) 
    670     { 
    671         osg::notify(osg::NOTICE)<<"Error: Unable to create OpenGL graphics context."<<std::endl; 
    672         XCloseDisplay( _display ); 
    673         _display = 0; 
    674         _valid = false; 
    675         return; 
    676     } 
    677  
    678     _initialized = _ownsWindow ? createWindow() : setWindow(windowHandle); 
    679     _valid = _initialized; 
    680  
     692            sharedContextGLX = pixelBufferX11->getContext(); 
     693        } 
     694    } 
     695 
     696    #ifdef OSG_USE_EGL 
     697 
     698        _valid = _ownsWindow ? createWindow() : setWindow(windowHandle); 
     699 
     700        if (!_valid)  
     701        { 
     702            XCloseDisplay( _display ); 
     703            _display = 0; 
     704            return; 
     705        } 
     706         
     707        osg::notify(osg::NOTICE)<<"GraphicsWindowX11::init() - window created ="<<_valid<<std::endl; 
     708 
     709        EGLConfig eglConfig = 0; 
     710         
     711        #if defined(OSG_GLES1_AVAILABLE) 
     712            EGLint configAttribs[3]; 
     713            configAttribs[0] = EGL_SURFACE_TYPE; 
     714            configAttribs[1] = EGL_WINDOW_BIT; 
     715            configAttribs[2] = EGL_NONE; 
     716        #else 
     717            EGLint configAttribs[5]; 
     718            configAttribs[0] = EGL_SURFACE_TYPE; 
     719            configAttribs[1] = EGL_WINDOW_BIT; 
     720            configAttribs[2] = EGL_RENDERABLE_TYPE; 
     721            configAttribs[3] = EGL_OPENGL_ES2_BIT;       
     722            configAttribs[4] = EGL_NONE; 
     723        #endif 
     724 
     725        int numConfigs; 
     726        if (!eglChooseConfig(eglDisplay, configAttribs, &eglConfig, 1, &numConfigs) || (numConfigs != 1)) 
     727        { 
     728            osg::notify(osg::NOTICE)<<"GraphicsWindowX11::init() - eglChooseConfig() failed."<<std::endl; 
     729            XCloseDisplay( _display ); 
     730            _valid = false; 
     731            _display = 0; 
     732            return; 
     733        } 
     734 
     735        _surface = eglCreateWindowSurface(eglDisplay, eglConfig, (EGLNativeWindowType)_window, NULL); 
     736        if (_surface == EGL_NO_SURFACE) 
     737        { 
     738            osg::notify(osg::NOTICE)<<"GraphicsWindowX11::init() - eglCreateWindowSurface(..) failed."<<std::endl; 
     739            XCloseDisplay( _display ); 
     740            _valid = false; 
     741            _display = 0; 
     742            return; 
     743        } 
     744 
     745        #if defined(OSG_GLES1_AVAILABLE) 
     746            EGLint* contextAttribs = 0; 
     747        #else 
     748            EGLint contextAttribs[3]; 
     749            pi32ContextAttribs[0] = EGL_CONTEXT_CLIENT_VERSION; 
     750            pi32ContextAttribs[1] = 2; 
     751            pi32ContextAttribs[2] = EGL_NONE; 
     752        #endif 
     753 
     754        _context = eglCreateContext(eglDisplay, eglConfig, NULL, contextAttribs); 
     755        if (_context == EGL_NO_CONTEXT) 
     756        { 
     757            osg::notify(osg::NOTICE)<<"GraphicsWindowX11::init() - eglCreateContext(..) failed."<<std::endl; 
     758            XCloseDisplay( _display ); 
     759            _valid = false; 
     760            _display = 0; 
     761            return; 
     762        } 
     763 
     764        _initialized = true; 
     765             
     766    #else 
     767         
     768        _context = glXCreateContext( _display, _visualInfo, sharedContextGLX, True ); 
     769     
     770        if (!_context) 
     771        { 
     772            osg::notify(osg::NOTICE)<<"Error: Unable to create OpenGL graphics context."<<std::endl; 
     773            XCloseDisplay( _display ); 
     774            _display = 0; 
     775            _valid = false; 
     776            return; 
     777        } 
     778 
     779        _initialized = _ownsWindow ? createWindow() : setWindow(windowHandle); 
     780        _valid = _initialized; 
     781 
     782    #endif 
     783     
    681784    if (_valid == false) 
    682785    { 
     
    724827    { 
    725828        osg::notify(osg::NOTICE)<<"Error: Unable to create Window."<<std::endl; 
    726         _glxContext = 0; 
     829        _context = 0; 
    727830        return false; 
    728831    } 
     
    850953    } 
    851954 
    852     // osg::notify(osg::NOTICE)<<"GraphicsWindowX11::makeCurrentImplementation "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<std::endl; 
    853     // osg::notify(osg::NOTICE)<<"   glXMakeCurrent ("<<_display<<","<<_window<<","<<_glxContext<<std::endl; 
    854  
    855     return glXMakeCurrent( _display, _window, _glxContext )==True; 
     955    #ifdef OSG_USE_EGL 
     956        EGLDisplay eglDisplay = eglGetDisplay((EGLNativeDisplayType)_display); 
     957        bool result = eglMakeCurrent(eglDisplay, _surface, _surface, _context)==EGL_TRUE; 
     958         
     959        osg::notify(osg::NOTICE)<<"GraphicsWindowX11::makeCurrentImplementation "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<" _surface="<<_surface<<" _context="<<_context<<" result="<<result<<std::endl; 
     960         
     961        return result; 
     962    #else 
     963        return glXMakeCurrent( _display, _window, _context )==True; 
     964    #endif 
    856965} 
    857966 
     
    864973    } 
    865974 
    866     // osg::notify(osg::NOTICE)<<"GraphicsWindowX11::releaseContextImplementation() "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<std::endl; 
    867     // osg::notify(osg::NOTICE)<<"   glXMakeCurrent ("<<_display<<std::endl; 
    868  
    869     return glXMakeCurrent( _display, None, NULL )==True; 
     975    osg::notify(osg::NOTICE)<<"GraphicsWindowX11::releaseContextImplementation() "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<std::endl; 
     976 
     977    #ifdef OSG_USE_EGL 
     978        EGLDisplay eglDisplay = eglGetDisplay((EGLNativeDisplayType)_display); 
     979        return eglMakeCurrent( eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT )==EGL_TRUE; 
     980    #else 
     981        return glXMakeCurrent( _display, None, NULL )==True; 
     982    #endif 
    870983} 
    871984 
     
    883996    if (_display) 
    884997    { 
    885         if (_glxContext) 
    886         { 
    887             glXDestroyContext(_display, _glxContext ); 
     998        if (_context) 
     999        { 
     1000        #ifdef OSG_USE_EGL 
     1001            EGLDisplay eglDisplay = eglGetDisplay((EGLNativeDisplayType)_display); 
     1002            eglDestroyContext( eglDisplay, _context ); 
     1003        #else 
     1004            glXDestroyContext( _display, _context ); 
     1005        #endif 
    8881006        } 
    8891007     
     
    8991017    _window = 0; 
    9001018    _parent = 0; 
    901     _glxContext = 0; 
     1019    _context = 0; 
    9021020 
    9031021    if (_visualInfo) 
    9041022    { 
    905         XFree(_visualInfo); 
     1023        #ifdef OSG_USE_EGL 
     1024            delete _visualInfo; 
     1025        #else         
     1026            XFree(_visualInfo); 
     1027        #endif 
    9061028        _visualInfo = 0; 
    9071029    } 
     
    9251047    // osg::notify(osg::NOTICE)<<"swapBuffersImplementation "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<std::endl; 
    9261048 
    927     glXSwapBuffers(_display, _window); 
     1049    #ifdef OSG_USE_EGL 
     1050        EGLDisplay eglDisplay = eglGetDisplay((EGLNativeDisplayType)_display); 
     1051        eglSwapBuffers( eglDisplay, _surface ); 
     1052    #else 
     1053        glXSwapBuffers( _display, _window ); 
     1054    #endif 
    9281055 
    9291056    while( XPending(_display) ) 
  • OpenSceneGraph/trunk/src/osgViewer/PixelBufferX11.cpp

    r8362 r10703  
    3232    _pbuffer(0), 
    3333    _visualInfo(0), 
    34     _glxContext(0), 
     34    _context(0), 
    3535    _initialized(false), 
    3636    _realized(false), 
     
    235235    } 
    236236     
    237     _glxContext = glXCreateContext( _display, _visualInfo, sharedContextGLX, True ); 
    238  
    239     if (!_glxContext) 
     237    _context = glXCreateContext( _display, _visualInfo, sharedContextGLX, True ); 
     238 
     239    if (!_context) 
    240240    { 
    241241        osg::notify(osg::NOTICE)<<"Error: Unable to create OpenGL graphics context."<<std::endl; 
     
    295295        XCloseDisplay( _display ); 
    296296        _display = 0; 
    297         _glxContext = 0; 
     297        _context = 0; 
    298298        _valid = false; 
    299299        return; 
     
    313313    if (_display) 
    314314    { 
    315         if (_glxContext) 
    316         { 
    317             glXDestroyContext(_display, _glxContext ); 
     315        if (_context) 
     316        { 
     317            glXDestroyContext(_display, _context ); 
    318318        } 
    319319     
     
    339339     
    340340    _pbuffer = 0; 
    341     _glxContext = 0; 
     341    _context = 0; 
    342342 
    343343    if (_visualInfo) 
     
    375375    // osg::notify(osg::NOTICE)<<"Closing PixelBufferX11"<<std::endl; 
    376376    _pbuffer = 0; 
    377     _glxContext = 0; 
     377    _context = 0; 
    378378    _initialized = false; 
    379379    _realized = false; 
     
    409409 
    410410    // osg::notify(osg::NOTICE)<<"PixelBufferX11::makeCurrentImplementation "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<std::endl; 
    411     // osg::notify(osg::NOTICE)<<"   glXMakeCurrent ("<<_display<<","<<_pbuffer<<","<<_glxContext<<std::endl; 
    412  
    413     return glXMakeCurrent( _display, _pbuffer, _glxContext )==True; 
     411 
     412    #ifdef OSG_USE_EGL 
     413        return eglMakeCurrent(_display, _pbuffer, _pbuffer, _context)==EGL_TRUE; 
     414    #else 
     415        return glXMakeCurrent( _display, _pbuffer, _context )==True; 
     416    #endif 
    414417} 
    415418 
     
    430433 
    431434    // osg::notify(osg::NOTICE)<<"PixelBufferX11::releaseContextImplementation() "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<std::endl; 
    432     // osg::notify(osg::NOTICE)<<"   glXMakeCurrent ("<<_display<<std::endl; 
    433  
    434     return glXMakeCurrent( _display, None, NULL )==True; 
     435 
     436    #ifdef OSG_USE_EGL 
     437        return eglMakeCurrent( _display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT )==EGL_TRUE; 
     438    #else 
     439        return glXMakeCurrent( _display, None, NULL )==True; 
     440    #endif 
    435441} 
    436442 
     
    447453    // osg::notify(osg::NOTICE)<<"PixelBufferX11::swapBuffersImplementation "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<std::endl; 
    448454 
    449     glXSwapBuffers(_display, _pbuffer); 
    450 } 
     455    #ifdef OSG_USE_EGL 
     456        eglSwapBuffers( _display, _pbuffer ); 
     457    #else 
     458        glXSwapBuffers( _display, _pbuffer ); 
     459    #endif 
     460}