Changeset 10813

Show
Ignore:
Timestamp:
11/21/09 17:41:02 (4 years ago)
Author:
robert
Message:

From Colin MacDonald?, "In my application I have a custom graphics context class, derived from
osg::GraphicsContext?, in order to give good integration with the
application's GUI toolkit. This works really well.

However, I need to share OpenGL texture resources with the standard
osgViewer GraphicsContext? implementations, in particular the
PixelBuffers?. This is essential for my application to conserve graphics
memory on low-end hardware. Currently the standard osg implementations
will not share resources with another derived osg::GraphicsContext?,
other than the pre-defined osgViewer classes e.g. PixelBufferX11 is
hardcoded to only share resources with GraphicsWindowX11 and
PixelBufferX11 objects, and no other osg::GraphicsContext? object.

To address this in the cleanest way I could think of, I have moved the
OpenGL handle variables for each platform into a small utility class,
e.g. GraphicsHandleX11 for unix. Then GraphicsWindowX11, PixelBufferX11
and any other derived osg::GraphicsContext? class can inherit from
GraphicsHandleX11 to share OpenGL resources.

I have updated the X11, Win32 and Carbon implementations to use this.
The changes are minor. I haven't touched the Cocoa implmentation as
I'm not familiar with it at all and couldn't test it - it will work
unchanged.

Without this I had some horrible hacks in my application, this greatly
simplifies things for me. It also simplifies the osgViewer
implementations slightly. Perhaps it may help with other users'
desires to share resources with external graphics contexts, as was
discussed on the user list recently."

Notes from Robert Osfield, adapted Colin's submission to work with the new EGL related changes.

Location:
OpenSceneGraph/trunk
Files:
3 added
14 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/include/osgViewer/api/Carbon/GraphicsWindowCarbon

    r9904 r10813  
    2323 
    2424#include <osgViewer/GraphicsWindow> 
    25 #include <Carbon/Carbon.h> 
    26 #include <AGL/agl.h> 
     25#include <osgViewer/api/Carbon/GraphicsHandleCarbon> 
     26 
    2727namespace osgViewer 
    2828{ 
    2929 
    30 class GraphicsWindowCarbon : public osgViewer::GraphicsWindow 
     30class GraphicsWindowCarbon : public osgViewer::GraphicsWindow, public osgViewer::GraphicsHandleCarbon 
    3131{ 
    3232    public: 
     
    138138        void installEventHandler(); 
    139139         
    140         /// get the AGL context 
    141         AGLContext getAGLContext() { return _context; } 
    142          
    143140        // get the pixelformat 
    144141        AGLPixelFormat getAGLPixelFormat() { return _pixelFormat; } 
     
    160157        bool            _ownsWindow; 
    161158        WindowRef       _window; 
    162         AGLContext      _context; 
    163159        AGLPixelFormat  _pixelFormat; 
    164160         
  • OpenSceneGraph/trunk/include/osgViewer/api/Carbon/PixelBufferCarbon

    r9904 r10813  
    2020 
    2121#include <osg/GraphicsContext> 
    22 #include <osgViewer/Export> 
    23  
    24 #include <Carbon/Carbon.h> 
    25 #include <AGL/agl.h> 
     22#include <osgViewer/api/Carbon/GraphicsHandleCarbon> 
    2623 
    2724 
     
    2926{ 
    3027 
    31 class OSGVIEWER_EXPORT PixelBufferCarbon : public osg::GraphicsContext 
     28class OSGVIEWER_EXPORT PixelBufferCarbon : public osg::GraphicsContext, public osgViewer::GraphicsHandleCarbon 
    3229{ 
    3330    public: 
     
    3835            _realized(false), 
    3936            _pixelformat(0), 
    40             _pbuffer(0), 
    41             _context(0) 
     37            _pbuffer(0) 
    4238        { 
    4339            _traits = traits; 
     
    9288        /** Swap the front and back buffers.*/ 
    9389        virtual void swapBuffersImplementation(); 
    94          
     90        
    9591        static AGLPixelFormat createPixelFormat(osg::GraphicsContext::Traits* traits); 
    96          
    97         AGLContext getAGLContext() { return _context; } 
    9892 
    9993    public: 
     
    113107         
    114108        AGLPixelFormat    _pixelformat; 
    115         AGLPbuffer        _pbuffer; 
    116         AGLContext        _context; 
    117          
     109        AGLPbuffer        _pbuffer;         
    118110}; 
    119111 
  • OpenSceneGraph/trunk/include/osgViewer/api/Win32/GraphicsWindowWin32

    r10748 r10813  
    2121 
    2222#include <osgViewer/GraphicsWindow> 
    23  
    24 #ifndef _WIN32_WINNT 
    25 #define _WIN32_WINNT    0x0500 
    26 #endif 
    27 #include <windows.h> 
     23#include <osgViewer/api/Win32/GraphicsHandleWin32> 
    2824 
    2925namespace osgViewer 
    3026{ 
    3127 
    32 class OSGVIEWER_EXPORT GraphicsWindowWin32 : public osgViewer::GraphicsWindow 
     28class OSGVIEWER_EXPORT GraphicsWindowWin32 : public osgViewer::GraphicsWindow, public osgViewer::GraphicsHandleWin32 
    3329{ 
    3430    public: 
     
    104100            bool   _installEventHandler; 
    105101        }; 
    106  
    107         /** Get native window.*/         
    108         HWND getHWND() const { return _hwnd; } 
    109  
    110         HDC getHDC() const { return _hdc; } 
    111  
    112         /** Get native OpenGL graphics context.*/         
    113         HGLRC getWGLContext() const { return _hglrc; } 
    114102         
    115103    protected: 
     
    140128         
    141129        bool setPixelFormat(); 
    142         HGLRC createContextImplementation(); 
    143  
     130         
    144131        void adaptKey( WPARAM wParam, LPARAM lParam, int& keySymbol, unsigned int& modifierMask ); 
    145132                 
     
    150137        HCURSOR getOrCreateCursor(MouseCursor mouseShape); 
    151138         
    152         HWND            _hwnd; 
    153         HDC             _hdc; 
    154         HGLRC           _hglrc; 
    155139        HCURSOR         _currentCursor; 
    156140         
  • OpenSceneGraph/trunk/include/osgViewer/api/Win32/PixelBufferWin32

    r7914 r10813  
    2020#define OSGVIEWER_PIXELBUFFERWIN32 1 
    2121 
    22 #include <osgViewer/GraphicsWindow> 
    23  
    24 #ifndef _WIN32_WINNT 
    25 #define _WIN32_WINNT    0x0500 
    26 #endif 
    27  
    28 #include <windows.h> 
     22#include <osg/GraphicsContext> 
     23#include <osgViewer/api/Win32/GraphicsHandleWin32> 
    2924 
    3025namespace osgViewer 
    3126{ 
    3227 
    33 class OSGVIEWER_EXPORT PixelBufferWin32 : public osg::GraphicsContext 
     28class OSGVIEWER_EXPORT PixelBufferWin32 : public osg::GraphicsContext, public osgViewer::GraphicsHandleWin32 
    3429{ 
    3530    public: 
     
    6358        /** Swap the front and back buffers.*/ 
    6459        virtual void swapBuffersImplementation(); 
    65  
    66         /** Get native window.*/         
    67         HWND getHWND() const { return _hwnd; } 
    68  
    69         HDC getHDC() const { return _hdc; } 
    70  
    71         /** Get native OpenGL graphics context.*/         
    72         HGLRC getWGLContext() const { return _hglrc; } 
    73          
     60        
    7461        virtual void bindPBufferToTextureImplementation( GLenum /*buffer*/ ); 
    7562         
     
    7764     
    7865        void init(); 
    79          
    80         HWND            _hwnd; 
    81         HDC             _hdc; 
    82         HGLRC           _hglrc; 
    8366 
    8467        bool            _initialized; 
  • OpenSceneGraph/trunk/include/osgViewer/api/X11/GraphicsWindowX11

    r10706 r10813  
    2121 
    2222#include <osgViewer/GraphicsWindow> 
    23  
    24 #define GLX_GLXEXT_PROTOTYPES  1 
    25  
    26 #include <X11/X.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  
     23#include <osgViewer/api/X11/GraphicsHandleX11> 
    3724 
    3825#include <string.h> 
     
    4128{ 
    4229 
    43 class OSGVIEWER_EXPORT GraphicsWindowX11 : public osgViewer::GraphicsWindow 
     30class OSGVIEWER_EXPORT GraphicsWindowX11 : public osgViewer::GraphicsWindow, public osgViewer::GraphicsHandleX11 
    4431{ 
    4532    public: 
     
    4734        GraphicsWindowX11(osg::GraphicsContext::Traits* traits): 
    4835            _valid(false), 
    49             _display(0), 
    5036            _eventDisplay(0), 
    5137            _parent(0), 
    5238            _window(0), 
    5339            _visualInfo(0), 
    54             _context(0), 
    5540            #ifdef OSG_USE_EGL 
    5641            _eglDisplay(0), 
     
    152137        // X11 specific aces functions 
    153138 
    154         Display* getDisplay() const { return _display; } 
    155139        Display* getEventDisplay() const { return _eventDisplay; } 
    156140        Display* getDisplayToUse() const ; 
     
    159143        Window& getParent() { return _parent; } 
    160144        Window& getWindow() { return _window; } 
    161  
    162  
    163         #ifdef OSG_USE_EGL 
    164         typedef EGLContext Context; 
    165         #else 
    166         typedef GLXContext Context; 
    167         #endif 
    168  
    169         Context& getContext() { return _context; } 
    170145 
    171146        Cursor getCurrentCursor() { return _currentCursor; } 
     
    198173         
    199174        bool            _valid; 
    200         Display*        _display; 
    201175        Display*        _eventDisplay; 
    202176        Window          _parent; 
    203177        Window          _window; 
    204178        XVisualInfo*    _visualInfo; 
    205         Context         _context; 
    206179 
    207180        #ifdef OSG_USE_EGL 
  • OpenSceneGraph/trunk/include/osgViewer/api/X11/PixelBufferX11

    r10703 r10813  
    2020#define OSGVIEWER_PIXELBUFFERX11 1 
    2121 
    22 #include <osgViewer/api/X11/GraphicsWindowX11> 
    23  
    24 #ifndef OSG_USE_EGL 
    25     #ifndef GLX_VERSION_1_3 
    26         typedef XID GLXPbuffer; 
    27     #endif 
    28 #endif 
     22#include <osg/GraphicsContext> 
     23#include <osgViewer/api/X11/GraphicsHandleX11> 
    2924 
    3025namespace osgViewer 
    3126{ 
    3227 
    33 class OSGVIEWER_EXPORT PixelBufferX11 : public osg::GraphicsContext 
     28class OSGVIEWER_EXPORT PixelBufferX11 : public osg::GraphicsContext, public osgViewer::GraphicsHandleX11 
    3429{ 
    3530    public: 
     
    7065     
    7166        // X11 specific aces functions 
    72  
    73         Display* getDisplay() const { return _display; } 
    7467         
    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  
    8368        Pbuffer& getPbuffer() { return _pbuffer; } 
    84         Context& getContext() { return _context; } 
    8569 
    8670    protected: 
     
    9377 
    9478        bool            _valid; 
    95         Display*        _display; 
    9679        Pbuffer         _pbuffer; 
    9780        XVisualInfo*    _visualInfo; 
    98         Context         _context; 
    9981 
    10082        bool            _initialized; 
  • OpenSceneGraph/trunk/src/osgViewer/CMakeLists.txt

    r10703 r10813  
    5454 
    5555    SET(LIB_PUBLIC_HEADERS ${LIB_PUBLIC_HEADERS} 
     56        ${HEADER_PATH}/api/Win32/GraphicsHandleWin32 
    5657        ${HEADER_PATH}/api/Win32/GraphicsWindowWin32 
    5758        ${HEADER_PATH}/api/Win32/PixelBufferWin32 
     
    8586        ADD_DEFINITIONS(-DUSE_DARWIN_CARBON_IMPLEMENTATION) 
    8687        SET(LIB_PUBLIC_HEADERS ${LIB_PUBLIC_HEADERS}  
     88            ${HEADER_PATH}/api/Carbon/GraphicsHandleCarbon 
    8789            ${HEADER_PATH}/api/Carbon/GraphicsWindowCarbon 
    8890            ${HEADER_PATH}/api/Carbon/PixelBufferCarbon 
     
    110112 
    111113        SET(LIB_PUBLIC_HEADERS ${LIB_PUBLIC_HEADERS} 
     114            ${HEADER_PATH}/api/X11/GraphicsHandleX11 
    112115            ${HEADER_PATH}/api/X11/GraphicsWindowX11 
    113116            ${HEADER_PATH}/api/X11/PixelBufferX11 
     
    118121            PixelBufferX11.cpp 
    119122        ) 
    120  
     123         
    121124        IF(OSGVIEWER_USE_XRANDR) 
    122125            ADD_DEFINITIONS(-DOSGVIEWER_USE_XRANDR) 
  • OpenSceneGraph/trunk/src/osgViewer/GraphicsWindowCarbon.cpp

    r9894 r10813  
    399399    AGLContext sharedContextCarbon = NULL; 
    400400     
    401     GraphicsWindowCarbon* graphicsWindowCarbon = dynamic_cast<GraphicsWindowCarbon*>(_traits->sharedContext); 
    402     if (graphicsWindowCarbon)  
    403     { 
    404         sharedContextCarbon = graphicsWindowCarbon->getAGLContext(); 
    405     } 
    406     else 
    407     { 
    408         PixelBufferCarbon* pixelbuffer = dynamic_cast<PixelBufferCarbon*>(_traits->sharedContext); 
    409         if (pixelbuffer) { 
    410             sharedContextCarbon = pixelbuffer->getAGLContext(); 
    411         } 
    412     } 
     401    GraphicsHandleCarbon* graphicsHandleCarbon = dynamic_cast<GraphicsHandleCarbon*>(_traits->sharedContext); 
     402    if (graphicsHandleCarbon)  
     403    { 
     404        sharedContextCarbon = graphicsHandleCarbon->getAGLContext(); 
     405    } 
     406 
    413407    _context = aglCreateContext (_pixelFormat, sharedContextCarbon); 
    414408 
  • OpenSceneGraph/trunk/src/osgViewer/GraphicsWindowWin32.cpp

    r10748 r10813  
    10301030 
    10311031GraphicsWindowWin32::GraphicsWindowWin32( osg::GraphicsContext::Traits* traits ) 
    1032 : _hwnd(0), 
    1033   _hdc(0), 
    1034   _hglrc(0), 
    1035   _currentCursor(0), 
     1032: _currentCursor(0), 
    10361033  _windowProcedure(0), 
    10371034  _timeOfLastCheckEvents(-1.0), 
     
    17841781        if (_traits.valid() && _traits->sharedContext) 
    17851782        { 
    1786             GraphicsWindowWin32* sharedContextWin32 = dynamic_cast<GraphicsWindowWin32*>(_traits->sharedContext); 
    1787             if (sharedContextWin32) 
     1783            GraphicsHandleWin32* graphicsHandleWin32 = dynamic_cast<GraphicsHandleWin32*>(_traits->sharedContext); 
     1784            if (graphicsHandleWin32) 
    17881785            { 
    17891786                struct RestoreContext 
     
    18051802                    HGLRC    _hglrc; 
    18061803                } restoreContext; 
    1807  
     1804                 
    18081805                _realized = true; 
    18091806                bool result = makeCurrent(); 
     
    18141811                    return false;         
    18151812                } 
    1816                 if (!wglShareLists(sharedContextWin32->getWGLContext(), getWGLContext())) 
     1813                if (!wglShareLists(graphicsHandleWin32->getWGLContext(), getWGLContext())) 
    18171814                { 
    18181815                    reportErrorForScreen("GraphicsWindowWin32::realizeImplementation() - Unable to share OpenGL context", _traits->screenNum, ::GetLastError()); 
  • OpenSceneGraph/trunk/src/osgViewer/GraphicsWindowX11.cpp

    r10803 r10813  
    694694    } 
    695695 
    696     Context sharedContextGLX = NULL; 
    697  
    698     // get any shared GLX contexts     
    699     GraphicsWindowX11* graphicsWindowX11 = dynamic_cast<GraphicsWindowX11*>(_traits->sharedContext); 
    700     if (graphicsWindowX11)  
    701     { 
    702         sharedContextGLX = graphicsWindowX11->getContext(); 
    703     } 
    704     else 
    705     { 
    706         PixelBufferX11* pixelBufferX11 = dynamic_cast<PixelBufferX11*>(_traits->sharedContext); 
    707         if (pixelBufferX11 && pixelBufferX11->valid()) 
    708         { 
    709             sharedContextGLX = pixelBufferX11->getContext(); 
    710         } 
    711     } 
     696    // get any shared GLX contexts 
     697    GraphicsHandleX11* graphicsHandleX11 = dynamic_cast<GraphicsHandleX11*>(_traits->sharedContext); 
     698    Context sharedContext = graphicsHandleX11 ? graphicsHandleX11->getContext() : 0; 
    712699 
    713700    #ifdef OSG_USE_EGL 
     
    775762        #endif 
    776763 
    777         _context = eglCreateContext(_eglDisplay, eglConfig, NULL, contextAttribs); 
     764        _context = eglCreateContext(_eglDisplay, eglConfig, sharedContext, contextAttribs); 
    778765        if (_context == EGL_NO_CONTEXT) 
    779766        { 
     
    791778    #else 
    792779         
    793         _context = glXCreateContext( _display, _visualInfo, sharedContextGLX, True ); 
     780        _context = glXCreateContext( _display, _visualInfo, sharedContext, True ); 
    794781     
    795782        if (!_context) 
     
    990977        bool result = eglMakeCurrent(_eglDisplay, _eglSurface, _eglSurface, _context)==EGL_TRUE; 
    991978        checkEGLError("after eglMakeCurrent()"); 
    992  
    993979        return result; 
    994980    #else 
     
    1006992 
    1007993    #ifdef OSG_USE_EGL 
    1008         return eglMakeCurrent( _eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT )==EGL_TRUE; 
     994        bool result = eglMakeCurrent( _eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT )==EGL_TRUE; 
    1009995        checkEGLError("after eglMakeCurrent() release"); 
     996        return result; 
    1010997    #else 
    1011998        return glXMakeCurrent( _display, None, NULL )==True; 
  • OpenSceneGraph/trunk/src/osgViewer/PixelBufferCarbon.cpp

    r10006 r10813  
    8181    AGLContext sharedContext = NULL; 
    8282 
    83     // get any shared GLX contexts     
    84     GraphicsWindowCarbon* graphicsWindowCarbon = dynamic_cast<GraphicsWindowCarbon*>(_traits->sharedContext); 
    85     if (graphicsWindowCarbon)  
     83    // get any shared AGL contexts     
     84    GraphicsHandleCarbon* graphicsHandleCarbon = dynamic_cast<GraphicsHandleCarbon*>(_traits->sharedContext); 
     85    if (graphicsHandleCarbon)  
    8686    { 
    87         sharedContext = graphicsWindowCarbon->getAGLContext(); 
    88     } 
    89     else 
    90     { 
    91         PixelBufferCarbon* pixelBufferCarbon = dynamic_cast<PixelBufferCarbon*>(_traits->sharedContext); 
    92         if (pixelBufferCarbon) 
    93         { 
    94             sharedContext = pixelBufferCarbon->getAGLContext(); 
    95         } 
     87        sharedContext = graphicsHandleCarbon->getAGLContext(); 
    9688    } 
    9789     
  • OpenSceneGraph/trunk/src/osgViewer/PixelBufferWin32.cpp

    r9630 r10813  
    446446 
    447447PixelBufferWin32::PixelBufferWin32( osg::GraphicsContext::Traits* traits ): 
    448   _hwnd(0), 
    449   _hdc(0), 
    450   _hglrc(0), 
    451448  _initialized(false), 
    452449  _valid(false), 
     
    658655    makeCurrentImplementation(); 
    659656 
    660     if (_traits->sharedContext) 
    661     { 
    662         HGLRC hglrc = 0; 
    663  
    664         GraphicsWindowWin32* graphicsWindowWin32 = dynamic_cast<GraphicsWindowWin32*>(_traits->sharedContext); 
    665         if (graphicsWindowWin32)  
    666         { 
    667             hglrc = graphicsWindowWin32->getWGLContext(); 
    668         } 
    669         else 
    670         { 
    671             PixelBufferWin32* pixelBufferWin32 = dynamic_cast<PixelBufferWin32*>(_traits->sharedContext); 
    672             if (pixelBufferWin32) 
     657    if ( _traits->sharedContext ) 
     658    { 
     659        GraphicsHandleWin32* graphicsHandleWin32 = dynamic_cast<GraphicsHandleWin32*>(_traits->sharedContext); 
     660        if (graphicsHandleWin32)  
     661        { 
     662            if ( !wglShareLists(graphicsHandleWin32->getWGLContext(), _hglrc) ) 
    673663            { 
    674                 hglrc = pixelBufferWin32->getWGLContext(); 
     664            osg::notify(osg::NOTICE) << "PixelBufferWin32::realizeImplementation, wglShareLists error: " << sysError() << std::endl; 
    675665            } 
    676         } 
    677  
    678         if ( !wglShareLists(hglrc, _hglrc) ) 
    679         { 
    680             osg::notify(osg::NOTICE) << "PixelBufferWin32::realizeImplementation, wglShareLists error: " << sysError() << std::endl; 
    681666        } 
    682667    } 
     
    758743    } 
    759744 
    760     GraphicsWindowWin32* graphicsWindowWin32 = dynamic_cast<GraphicsWindowWin32*>(readContext); 
    761     if (graphicsWindowWin32)  
    762     { 
    763         return wgle->wglMakeContextCurrentARB(_hdc, graphicsWindowWin32->getHDC(), _hglrc); 
    764     } 
    765     PixelBufferWin32* pixelBufferWin32 = dynamic_cast<PixelBufferWin32*>(_traits->sharedContext); 
    766     if (pixelBufferWin32) 
    767     { 
    768         return wgle->wglMakeContextCurrentARB(_hdc, pixelBufferWin32->getHDC(), _hglrc); 
     745    GraphicsHandleWin32* graphicsHandleWin32 = dynamic_cast<GraphicsHandleWin32*>(readContext); 
     746    if (graphicsHandleWin32)  
     747    { 
     748        return wgle->wglMakeContextCurrentARB(_hdc, graphicsHandleWin32->getHDC(), _hglrc); 
    769749    } 
    770750    return false; 
  • OpenSceneGraph/trunk/src/osgViewer/PixelBufferX11.cpp

    r10705 r10813  
    2929PixelBufferX11::PixelBufferX11(osg::GraphicsContext::Traits* traits) 
    3030  : _valid(false), 
    31     _display(0), 
    3231    _pbuffer(0), 
    3332    _visualInfo(0), 
    34     _context(0), 
    3533    _initialized(false), 
    3634    _realized(false), 
     
    218216    } 
    219217     
    220     GLXContext sharedContextGLX = NULL; 
    221  
    222     // get any shared GLX contexts     
    223     GraphicsWindowX11* graphicsWindowX11 = dynamic_cast<GraphicsWindowX11*>(_traits->sharedContext); 
    224     if (graphicsWindowX11)  
    225     { 
    226         sharedContextGLX = graphicsWindowX11->getContext(); 
    227     } 
    228     else 
    229     { 
    230         PixelBufferX11* pixelBufferX11 = dynamic_cast<PixelBufferX11*>(_traits->sharedContext); 
    231         if (pixelBufferX11) 
    232         { 
    233             sharedContextGLX = pixelBufferX11->getContext(); 
    234         } 
    235     } 
    236      
    237     _context = glXCreateContext( _display, _visualInfo, sharedContextGLX, True ); 
     218    // get any shared GLX contexts 
     219    GraphicsHandleX11* graphicsHandleX11 = dynamic_cast<GraphicsHandleX11*>(_traits->sharedContext); 
     220    Context sharedContext = graphicsHandleX11 ? graphicsHandleX11->getContext() : 0; 
     221 
     222    _context = glXCreateContext( _display, _visualInfo, sharedContext, True ); 
    238223 
    239224    if (!_context) 
  • OpenSceneGraph/trunk/src/osgViewer/ScreenCaptureHandler.cpp

    r10782 r10813  
    491491void WindowCaptureCallback::operator () (osg::RenderInfo& renderInfo) const 
    492492{ 
     493#if !defined(OSG_GLES1_AVAILABLE) && !defined(OSG_GLES2_AVAILABLE) 
    493494    glReadBuffer(_readBuffer); 
     495#endif 
    494496 
    495497    osg::GraphicsContext* gc = renderInfo.getState()->getGraphicsContext();