src/unix/glx11.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/univ/glx11.cpp
   3 // Purpose:     code common to all X11-based wxGLCanvas implementations
   4 // Author:      Vadim Zeitlin
   5 // Created:     2007-04-15
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2007 Vadim Zeitlin <vadim@wxwindows.org>
   8 // Licence:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 // ============================================================================
  12 // declarations
  13 // ============================================================================
  14
  15 // ----------------------------------------------------------------------------
  16 // headers
  17 // ----------------------------------------------------------------------------
  18
  19 // for compilers that support precompilation, includes "wx.h".
  20 #include "wx/wxprec.h"
  21
  22 #if wxUSE_GLCANVAS
  23
  24 #ifndef WX_PRECOMP
  25     #include "wx/log.h"
  26 #endif //WX_PRECOMP
  27
  28 #include "wx/glcanvas.h"
  29
  30 // IRIX headers call this differently
  31 #ifdef __SGI__
  32     #ifndef GLX_SAMPLE_BUFFERS_ARB
  33         #define GLX_SAMPLE_BUFFERS_ARB GLX_SAMPLE_BUFFERS_SGIS
  34     #endif
  35     #ifndef GLX_SAMPLES_ARB
  36         #define GLX_SAMPLES_ARB GLX_SAMPLES_SGIS
  37     #endif
  38 #endif // __SGI__
  39
  40 // ============================================================================
  41 // wxGLContext implementation
  42 // ============================================================================
  43
  44 IMPLEMENT_CLASS(wxGLContext, wxObject)
  45
  46 wxGLContext::wxGLContext(wxGLCanvas *gc, const wxGLContext *other)
  47 {
  48     if ( wxGLCanvas::GetGLXVersion() >= 13 )
  49     {
  50         GLXFBConfig *fbc = gc->GetGLXFBConfig();
  51         wxCHECK_RET( fbc, wxT("invalid GLXFBConfig for OpenGL") );
  52
  53         m_glContext = glXCreateNewContext( wxGetX11Display(), fbc[0], GLX_RGBA_TYPE,
  54                                            other ? other->m_glContext : None,
  55                                            GL_TRUE );
  56     }
  57     else // GLX <= 1.2
  58     {
  59         XVisualInfo *vi = gc->GetXVisualInfo();
  60         wxCHECK_RET( vi, wxT("invalid visual for OpenGL") );
  61
  62         m_glContext = glXCreateContext( wxGetX11Display(), vi,
  63                                         other ? other->m_glContext : None,
  64                                         GL_TRUE );
  65     }
  66
  67     wxASSERT_MSG( m_glContext, wxT("Couldn't create OpenGL context") );
  68 }
  69
  70 wxGLContext::~wxGLContext()
  71 {
  72     if ( !m_glContext )
  73         return;
  74
  75     if ( m_glContext == glXGetCurrentContext() )
  76         MakeCurrent(None, NULL);
  77
  78     glXDestroyContext( wxGetX11Display(), m_glContext );
  79 }
  80
  81 bool wxGLContext::SetCurrent(const wxGLCanvas& win) const
  82 {
  83     if ( !m_glContext )
  84         return false;
  85
  86     const Window xid = win.GetXWindow();
  87     wxCHECK2_MSG( xid, return false, wxT("window must be shown") );
  88
  89     return MakeCurrent(xid, m_glContext);
  90 }
  91
  92 // wrapper around glXMakeContextCurrent/glXMakeCurrent depending on GLX
  93 // version
  94 /* static */
  95 bool wxGLContext::MakeCurrent(GLXDrawable drawable, GLXContext context)
  96 {
  97     if (wxGLCanvas::GetGLXVersion() >= 13)
  98         return glXMakeContextCurrent( wxGetX11Display(), drawable, drawable, context);
  99     else // GLX <= 1.2 doesn't have glXMakeContextCurrent()
 100         return glXMakeCurrent( wxGetX11Display(), drawable, context);
 101 }
 102
 103 // ============================================================================
 104 // wxGLCanvasX11 implementation
 105 // ============================================================================
 106
 107 // ----------------------------------------------------------------------------
 108 // initialization methods and dtor
 109 // ----------------------------------------------------------------------------
 110
 111 wxGLCanvasX11::wxGLCanvasX11()
 112 {
 113     m_fbc = NULL;
 114     m_vi = NULL;
 115 }
 116
 117 bool wxGLCanvasX11::InitVisual(const int *attribList)
 118 {
 119     return InitXVisualInfo(attribList, &m_fbc, &m_vi);
 120 }
 121
 122 wxGLCanvasX11::~wxGLCanvasX11()
 123 {
 124     if ( m_fbc && m_fbc != ms_glFBCInfo )
 125         XFree(m_fbc);
 126
 127     if ( m_vi && m_vi != ms_glVisualInfo )
 128         XFree(m_vi);
 129 }
 130
 131 // ----------------------------------------------------------------------------
 132 // working with GL attributes
 133 // ----------------------------------------------------------------------------
 134
 135 /* static */
 136 bool wxGLCanvasBase::IsExtensionSupported(const char *extension)
 137 {
 138     Display * const dpy = wxGetX11Display();
 139
 140     return IsExtensionInList(glXQueryExtensionsString(dpy, DefaultScreen(dpy)),
 141                              extension);
 142 }
 143
 144
 145 /* static */
 146 bool wxGLCanvasX11::IsGLXMultiSampleAvailable()
 147 {
 148     static int s_isMultiSampleAvailable = -1;
 149     if ( s_isMultiSampleAvailable == -1 )
 150         s_isMultiSampleAvailable = IsExtensionSupported("GLX_ARB_multisample");
 151
 152     return s_isMultiSampleAvailable != 0;
 153 }
 154
 155 bool
 156 wxGLCanvasX11::ConvertWXAttrsToGL(const int *wxattrs, int *glattrs, size_t n)
 157 {
 158     wxCHECK_MSG( n >= 16, false, wxT("GL attributes buffer too small") );
 159
 160     /*
 161        Different versions of GLX API use rather different attributes lists, see
 162        the following URLs:
 163
 164         - <= 1.2: http://www.opengl.org/sdk/docs/man/xhtml/glXChooseVisual.xml
 165         - >= 1.3: http://www.opengl.org/sdk/docs/man/xhtml/glXChooseFBConfig.xml
 166
 167        Notice in particular that
 168         - GLX_RGBA is boolean attribute in the old version of the API but a
 169           value of GLX_RENDER_TYPE in the new one
 170         - Boolean attributes such as GLX_DOUBLEBUFFER don't take values in the
 171           old version but must be followed by True or False in the new one.
 172      */
 173
 174     if ( !wxattrs )
 175     {
 176         size_t i = 0;
 177
 178         // use double-buffered true colour by default
 179         glattrs[i++] = GLX_DOUBLEBUFFER;
 180
 181         if ( GetGLXVersion() < 13 )
 182         {
 183             // default settings if attriblist = 0
 184             glattrs[i++] = GLX_RGBA;
 185             glattrs[i++] = GLX_DEPTH_SIZE;   glattrs[i++] = 1;
 186             glattrs[i++] = GLX_RED_SIZE;     glattrs[i++] = 1;
 187             glattrs[i++] = GLX_GREEN_SIZE;   glattrs[i++] = 1;
 188             glattrs[i++] = GLX_BLUE_SIZE;    glattrs[i++] = 1;
 189             glattrs[i++] = GLX_ALPHA_SIZE;   glattrs[i++] = 0;
 190         }
 191         else // recent GLX can choose the defaults on its own just fine
 192         {
 193             // we just need to have a value after GLX_DOUBLEBUFFER
 194             glattrs[i++] = True;
 195         }
 196
 197         glattrs[i] = None;
 198
 199         wxASSERT_MSG( i < n, wxT("GL attributes buffer too small") );
 200     }
 201     else // have non-default attributes
 202     {
 203         size_t p = 0;
 204         for ( int arg = 0; wxattrs[arg] != 0; )
 205         {
 206             // check if we have any space left, knowing that we may insert 2
 207             // more elements during this loop iteration and we always need to
 208             // terminate the list with None (hence -3)
 209             if ( p > n - 3 )
 210                 return false;
 211
 212             // indicates whether we have a boolean attribute
 213             bool isBoolAttr = false;
 214
 215             switch ( wxattrs[arg++] )
 216             {
 217                 case WX_GL_BUFFER_SIZE:
 218                     glattrs[p++] = GLX_BUFFER_SIZE;
 219                     break;
 220
 221                 case WX_GL_LEVEL:
 222                     glattrs[p++] = GLX_LEVEL;
 223                     break;
 224
 225                 case WX_GL_RGBA:
 226                     if ( GetGLXVersion() >= 13 )
 227                     {
 228                         // this is the default GLX_RENDER_TYPE anyhow
 229                         continue;
 230                     }
 231
 232                     glattrs[p++] = GLX_RGBA;
 233                     isBoolAttr = true;
 234                     break;
 235
 236                 case WX_GL_DOUBLEBUFFER:
 237                     glattrs[p++] = GLX_DOUBLEBUFFER;
 238                     isBoolAttr = true;
 239                     break;
 240
 241                 case WX_GL_STEREO:
 242                     glattrs[p++] = GLX_STEREO;
 243                     isBoolAttr = true;
 244                     break;
 245
 246                 case WX_GL_AUX_BUFFERS:
 247                     glattrs[p++] = GLX_AUX_BUFFERS;
 248                     break;
 249
 250                 case WX_GL_MIN_RED:
 251                     glattrs[p++] = GLX_RED_SIZE;
 252                     break;
 253
 254                 case WX_GL_MIN_GREEN:
 255                     glattrs[p++] = GLX_GREEN_SIZE;
 256                     break;
 257
 258                 case WX_GL_MIN_BLUE:
 259                     glattrs[p++] = GLX_BLUE_SIZE;
 260                     break;
 261
 262                 case WX_GL_MIN_ALPHA:
 263                     glattrs[p++] = GLX_ALPHA_SIZE;
 264                     break;
 265
 266                 case WX_GL_DEPTH_SIZE:
 267                     glattrs[p++] = GLX_DEPTH_SIZE;
 268                     break;
 269
 270                 case WX_GL_STENCIL_SIZE:
 271                     glattrs[p++] = GLX_STENCIL_SIZE;
 272                     break;
 273
 274                 case WX_GL_MIN_ACCUM_RED:
 275                     glattrs[p++] = GLX_ACCUM_RED_SIZE;
 276                     break;
 277
 278                 case WX_GL_MIN_ACCUM_GREEN:
 279                     glattrs[p++] = GLX_ACCUM_GREEN_SIZE;
 280                     break;
 281
 282                 case WX_GL_MIN_ACCUM_BLUE:
 283                     glattrs[p++] = GLX_ACCUM_BLUE_SIZE;
 284                     break;
 285
 286                 case WX_GL_MIN_ACCUM_ALPHA:
 287                     glattrs[p++] = GLX_ACCUM_ALPHA_SIZE;
 288                     break;
 289
 290                 case WX_GL_SAMPLE_BUFFERS:
 291 #ifdef GLX_SAMPLE_BUFFERS_ARB
 292                     if ( IsGLXMultiSampleAvailable() )
 293                     {
 294                         glattrs[p++] = GLX_SAMPLE_BUFFERS_ARB;
 295                         break;
 296                     }
 297 #endif // GLX_SAMPLE_BUFFERS_ARB
 298                     // if it was specified just to disable it, no problem
 299                     if ( !wxattrs[arg++] )
 300                         continue;
 301
 302                     // otherwise indicate that it's not supported
 303                     return false;
 304
 305                 case WX_GL_SAMPLES:
 306 #ifdef GLX_SAMPLES_ARB
 307                     if ( IsGLXMultiSampleAvailable() )
 308                     {
 309                         glattrs[p++] = GLX_SAMPLES_ARB;
 310                         break;
 311                     }
 312 #endif // GLX_SAMPLES_ARB
 313
 314                     if ( !wxattrs[arg++] )
 315                         continue;
 316
 317                     return false;
 318
 319                 default:
 320                     wxLogDebug(wxT("Unsupported OpenGL attribute %d"),
 321                                wxattrs[arg - 1]);
 322                     continue;
 323             }
 324
 325             if ( isBoolAttr )
 326             {
 327                 // as explained above, for pre 1.3 API the attribute just needs
 328                 // to be present so we only add its value when using the new API
 329                 if ( GetGLXVersion() >= 13 )
 330                     glattrs[p++] = True;
 331             }
 332             else // attribute with real (non-boolean) value
 333             {
 334                 // copy attribute value as is
 335                 glattrs[p++] = wxattrs[arg++];
 336             }
 337         }
 338
 339         glattrs[p] = None;
 340     }
 341
 342     return true;
 343 }
 344
 345 /* static */
 346 bool
 347 wxGLCanvasX11::InitXVisualInfo(const int *attribList,
 348                                GLXFBConfig **pFBC,
 349                                XVisualInfo **pXVisual)
 350 {
 351     int data[512];
 352     if ( !ConvertWXAttrsToGL(attribList, data, WXSIZEOF(data)) )
 353         return false;
 354
 355     Display * const dpy = wxGetX11Display();
 356
 357     if ( GetGLXVersion() >= 13 )
 358     {
 359         int returned;
 360         *pFBC = glXChooseFBConfig(dpy, DefaultScreen(dpy), data, &returned);
 361
 362         if ( *pFBC )
 363         {
 364             *pXVisual = glXGetVisualFromFBConfig(wxGetX11Display(), **pFBC);
 365             if ( !*pXVisual )
 366             {
 367                 XFree(*pFBC);
 368                 *pFBC = NULL;
 369             }
 370         }
 371     }
 372     else // GLX <= 1.2
 373     {
 374         *pFBC = NULL;
 375         *pXVisual = glXChooseVisual(dpy, DefaultScreen(dpy), data);
 376     }
 377
 378     return *pXVisual != NULL;
 379 }
 380
 381 /* static */
 382 bool
 383 wxGLCanvasBase::IsDisplaySupported(const int *attribList)
 384 {
 385     GLXFBConfig *fbc = NULL;
 386     XVisualInfo *vi = NULL;
 387
 388     const bool
 389         isSupported = wxGLCanvasX11::InitXVisualInfo(attribList, &fbc, &vi);
 390
 391     if ( fbc )
 392         XFree(fbc);
 393     if ( vi )
 394         XFree(vi);
 395
 396     return isSupported;
 397 }
 398
 399 // ----------------------------------------------------------------------------
 400 // default visual management
 401 // ----------------------------------------------------------------------------
 402
 403 XVisualInfo *wxGLCanvasX11::ms_glVisualInfo = NULL;
 404 GLXFBConfig *wxGLCanvasX11::ms_glFBCInfo = NULL;
 405
 406 /* static */
 407 bool wxGLCanvasX11::InitDefaultVisualInfo(const int *attribList)
 408 {
 409     FreeDefaultVisualInfo();
 410
 411     return InitXVisualInfo(attribList, &ms_glFBCInfo, &ms_glVisualInfo);
 412 }
 413
 414 /* static */
 415 void wxGLCanvasX11::FreeDefaultVisualInfo()
 416 {
 417     if ( ms_glFBCInfo )
 418     {
 419         XFree(ms_glFBCInfo);
 420         ms_glFBCInfo = NULL;
 421     }
 422
 423     if ( ms_glVisualInfo )
 424     {
 425         XFree(ms_glVisualInfo);
 426         ms_glVisualInfo = NULL;
 427     }
 428 }
 429
 430 // ----------------------------------------------------------------------------
 431 // other GL methods
 432 // ----------------------------------------------------------------------------
 433
 434 /* static */
 435 int wxGLCanvasX11::GetGLXVersion()
 436 {
 437     static int s_glxVersion = 0;
 438     if ( s_glxVersion == 0 )
 439     {
 440         // check the GLX version
 441         int glxMajorVer, glxMinorVer;
 442         bool ok = glXQueryVersion(wxGetX11Display(), &glxMajorVer, &glxMinorVer);
 443         wxASSERT_MSG( ok, wxT("GLX version not found") );
 444         if (!ok)
 445             s_glxVersion = 10; // 1.0 by default
 446         else
 447             s_glxVersion = glxMajorVer*10 + glxMinorVer;
 448     }
 449
 450     return s_glxVersion;
 451 }
 452
 453 bool wxGLCanvasX11::SwapBuffers()
 454 {
 455     const Window xid = GetXWindow();
 456     wxCHECK2_MSG( xid, return false, wxT("window must be shown") );
 457
 458     glXSwapBuffers(wxGetX11Display(), xid);
 459     return true;
 460 }
 461
 462 bool wxGLCanvasX11::IsShownOnScreen() const
 463 {
 464     return GetXWindow() && wxGLCanvasBase::IsShownOnScreen();
 465 }
 466
 467 #endif // wxUSE_GLCANVAS
 468