dlls/winex11.drv/opengl.c

   1 /*
   2  * X11DRV OpenGL functions
   3  *
   4  * Copyright 2000 Lionel Ulmer
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include "x11drv.h"
  28 #include "wine/library.h"
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(wgl);
  32 WINE_DECLARE_DEBUG_CHANNEL(opengl);
  33
  34 #if defined(HAVE_GL_GL_H) && defined(HAVE_GL_GLX_H)
  35
  36 #undef APIENTRY
  37 #undef CALLBACK
  38 #undef WINAPI
  39
  40 #ifdef HAVE_GL_GL_H
  41 # include <GL/gl.h>
  42 #endif
  43 #ifdef HAVE_GL_GLX_H
  44 # include <GL/glx.h>
  45 #endif
  46 #ifdef HAVE_GL_GLEXT_H
  47 # include <GL/glext.h>
  48 #endif
  49
  50 #undef APIENTRY
  51 #undef CALLBACK
  52 #undef WINAPI
  53
  54 /* Redefines the constants */
  55 #define CALLBACK    __stdcall
  56 #define WINAPI      __stdcall
  57 #define APIENTRY    WINAPI
  58
  59
  60 static void dump_PIXELFORMATDESCRIPTOR(const PIXELFORMATDESCRIPTOR *ppfd) {
  61   TRACE("  - size / version : %d / %d\n", ppfd->nSize, ppfd->nVersion);
  62   TRACE("  - dwFlags : ");
  63 #define TEST_AND_DUMP(t,tv) if ((t) & (tv)) TRACE(#tv " ")
  64   TEST_AND_DUMP(ppfd->dwFlags, PFD_DEPTH_DONTCARE);
  65   TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER);
  66   TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER_DONTCARE);
  67   TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_WINDOW);
  68   TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_BITMAP);
  69   TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_ACCELERATED);
  70   TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_FORMAT);
  71   TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_PALETTE);
  72   TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_SYSTEM_PALETTE);
  73   TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO);
  74   TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO_DONTCARE);
  75   TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_GDI);
  76   TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_OPENGL);
  77   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_COPY);
  78   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_EXCHANGE);
  79   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_LAYER_BUFFERS);
  80 #undef TEST_AND_DUMP
  81   TRACE("\n");
  82
  83   TRACE("  - iPixelType : ");
  84   switch (ppfd->iPixelType) {
  85   case PFD_TYPE_RGBA: TRACE("PFD_TYPE_RGBA"); break;
  86   case PFD_TYPE_COLORINDEX: TRACE("PFD_TYPE_COLORINDEX"); break;
  87   }
  88   TRACE("\n");
  89
  90   TRACE("  - Color   : %d\n", ppfd->cColorBits);
  91   TRACE("  - Red     : %d\n", ppfd->cRedBits);
  92   TRACE("  - Green   : %d\n", ppfd->cGreenBits);
  93   TRACE("  - Blue    : %d\n", ppfd->cBlueBits);
  94   TRACE("  - Alpha   : %d\n", ppfd->cAlphaBits);
  95   TRACE("  - Accum   : %d\n", ppfd->cAccumBits);
  96   TRACE("  - Depth   : %d\n", ppfd->cDepthBits);
  97   TRACE("  - Stencil : %d\n", ppfd->cStencilBits);
  98   TRACE("  - Aux     : %d\n", ppfd->cAuxBuffers);
  99
 100   TRACE("  - iLayerType : ");
 101   switch (ppfd->iLayerType) {
 102   case PFD_MAIN_PLANE: TRACE("PFD_MAIN_PLANE"); break;
 103   case PFD_OVERLAY_PLANE: TRACE("PFD_OVERLAY_PLANE"); break;
 104   case (BYTE)PFD_UNDERLAY_PLANE: TRACE("PFD_UNDERLAY_PLANE"); break;
 105   }
 106   TRACE("\n");
 107 }
 108
 109 /* No need to load any other libraries as according to the ABI, libGL should be self-sufficient and
 110    include all dependencies
 111 */
 112 #ifndef SONAME_LIBGL
 113 #define SONAME_LIBGL "libGL.so"
 114 #endif
 115
 116 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
 117 MAKE_FUNCPTR(glGetError)
 118 MAKE_FUNCPTR(glXChooseVisual)
 119 MAKE_FUNCPTR(glXGetConfig)
 120 MAKE_FUNCPTR(glXSwapBuffers)
 121 MAKE_FUNCPTR(glXQueryExtension)
 122
 123 MAKE_FUNCPTR(glXGetFBConfigs)
 124 MAKE_FUNCPTR(glXChooseFBConfig)
 125 MAKE_FUNCPTR(glXGetFBConfigAttrib)
 126 MAKE_FUNCPTR(glXCreateGLXPixmap)
 127 MAKE_FUNCPTR(glXDestroyGLXPixmap)
 128 /* MAKE_FUNCPTR(glXQueryDrawable) */
 129 #undef MAKE_FUNCPTR
 130
 131 static BOOL has_opengl(void)
 132 {
 133     static int init_done;
 134     static void *opengl_handle;
 135
 136     int error_base, event_base;
 137
 138     if (init_done) return (opengl_handle != NULL);
 139     init_done = 1;
 140
 141     opengl_handle = wine_dlopen(SONAME_LIBGL, RTLD_NOW|RTLD_GLOBAL, NULL, 0);
 142     if (opengl_handle == NULL) return FALSE;
 143
 144 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(RTLD_DEFAULT, #f, NULL, 0)) == NULL) goto sym_not_found;
 145 LOAD_FUNCPTR(glGetError)
 146 LOAD_FUNCPTR(glXChooseVisual)
 147 LOAD_FUNCPTR(glXGetConfig)
 148 LOAD_FUNCPTR(glXSwapBuffers)
 149 LOAD_FUNCPTR(glXQueryExtension)
 150
 151 LOAD_FUNCPTR(glXGetFBConfigs)
 152 LOAD_FUNCPTR(glXChooseFBConfig)
 153 LOAD_FUNCPTR(glXGetFBConfigAttrib)
 154 LOAD_FUNCPTR(glXCreateGLXPixmap)
 155 LOAD_FUNCPTR(glXDestroyGLXPixmap)
 156 #undef LOAD_FUNCPTR
 157
 158     wine_tsx11_lock();
 159     if (pglXQueryExtension(gdi_display, &event_base, &error_base) == True) {
 160         TRACE("GLX is up and running error_base = %d\n", error_base);
 161     } else {
 162         wine_dlclose(opengl_handle, NULL, 0);
 163         opengl_handle = NULL;
 164     }
 165     wine_tsx11_unlock();
 166     return (opengl_handle != NULL);
 167
 168 sym_not_found:
 169     wine_dlclose(opengl_handle, NULL, 0);
 170     opengl_handle = NULL;
 171     return FALSE;
 172 }
 173
 174 #define TEST_AND_ADD1(t,a) if (t) att_list[att_pos++] = (a)
 175 #define TEST_AND_ADD2(t,a,b) if (t) { att_list[att_pos++] = (a); att_list[att_pos++] = (b); }
 176 #define NULL_TEST_AND_ADD2(tv,a,b) att_list[att_pos++] = (a); att_list[att_pos++] = ((tv) == 0 ? 0 : (b))
 177 #define ADD2(a,b) att_list[att_pos++] = (a); att_list[att_pos++] = (b)
 178
 179 /**
 180  * X11DRV_ChoosePixelFormat
 181  *
 182  * Equivalent of glXChooseVisual
 183  */
 184 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
 185                              const PIXELFORMATDESCRIPTOR *ppfd) {
 186   int att_list[64];
 187   int att_pos = 0;
 188   int att_pos_fac = 0;
 189   GLXFBConfig* cfgs = NULL;
 190   int ret = 0;
 191
 192   if (!has_opengl()) {
 193     ERR("No libGL on this box - disabling OpenGL support !\n");
 194     return 0;
 195   }
 196
 197   if (TRACE_ON(opengl)) {
 198     TRACE("(%p,%p)\n", physDev, ppfd);
 199
 200     dump_PIXELFORMATDESCRIPTOR((const PIXELFORMATDESCRIPTOR *) ppfd);
 201   }
 202
 203   /* Now, build the request to GLX */
 204
 205   if (ppfd->iPixelType == PFD_TYPE_COLORINDEX) {
 206     ADD2(GLX_BUFFER_SIZE, ppfd->cColorBits);
 207   }
 208   if (ppfd->iPixelType == PFD_TYPE_RGBA) {
 209     ADD2(GLX_RENDER_TYPE, GLX_RGBA_BIT);
 210     if (ppfd->dwFlags & PFD_DEPTH_DONTCARE) {
 211       ADD2(GLX_DEPTH_SIZE, GLX_DONT_CARE);
 212     } else {
 213       if (32 == ppfd->cDepthBits) {
 214         /**
 215          * for 32 bpp depth buffers force to use 24.
 216          * needed as some drivers don't support 32bpp
 217          */
 218         TEST_AND_ADD2(ppfd->cDepthBits, GLX_DEPTH_SIZE, 24);
 219       } else {
 220         TEST_AND_ADD2(ppfd->cDepthBits, GLX_DEPTH_SIZE, ppfd->cDepthBits);
 221       }
 222     }
 223     if (32 == ppfd->cColorBits) {
 224       ADD2(GLX_RED_SIZE,   8);
 225       ADD2(GLX_GREEN_SIZE, 8);
 226       ADD2(GLX_BLUE_SIZE,  8);
 227       ADD2(GLX_ALPHA_SIZE, 8);
 228     } else {
 229       ADD2(GLX_BUFFER_SIZE, ppfd->cColorBits);
 230       /* Some broken apps try to ask for more than 8 bits of alpha */
 231       TEST_AND_ADD2(ppfd->cAlphaBits, GLX_ALPHA_SIZE, min(ppfd->cAlphaBits,8));
 232     }
 233   }
 234   TEST_AND_ADD2(ppfd->cStencilBits, GLX_STENCIL_SIZE, ppfd->cStencilBits);
 235   TEST_AND_ADD2(ppfd->cAuxBuffers,  GLX_AUX_BUFFERS,  ppfd->cAuxBuffers);
 236
 237   /* These flags are not supported yet...
 238   ADD2(GLX_ACCUM_SIZE, ppfd->cAccumBits);
 239   */
 240
 241   /** facultative flags now */
 242   att_pos_fac = att_pos;
 243   if (ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) {
 244     ADD2(GLX_DOUBLEBUFFER, GLX_DONT_CARE);
 245   } else {
 246     ADD2(GLX_DOUBLEBUFFER, (ppfd->dwFlags & PFD_DOUBLEBUFFER) ? TRUE : FALSE);
 247   }
 248   if (ppfd->dwFlags & PFD_STEREO_DONTCARE) {
 249     ADD2(GLX_STEREO, GLX_DONT_CARE);
 250   } else {
 251     ADD2(GLX_STEREO, (ppfd->dwFlags & PFD_STEREO) ? TRUE : FALSE);
 252   }
 253
 254   /** Attributes List End */
 255   att_list[att_pos] = None;
 256
 257   wine_tsx11_lock();
 258   {
 259     int nCfgs = 0;
 260     int gl_test = 0;
 261     int fmt_id;
 262
 263     GLXFBConfig* cfgs_fmt = NULL;
 264     int nCfgs_fmt = 0;
 265     int tmp_fmt_id;
 266     UINT it_fmt;
 267
 268     cfgs = pglXChooseFBConfig(gdi_display, DefaultScreen(gdi_display), att_list, &nCfgs);
 269     /**
 270      * if we have facultative flags and we failed, try without
 271      *  as MSDN said
 272      *
 273      * see http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/ntopnglr_2qb8.asp
 274      */
 275     if ((NULL == cfgs || 0 == nCfgs) && att_pos > att_pos_fac) {
 276       att_list[att_pos_fac] = None;
 277       cfgs = pglXChooseFBConfig(gdi_display, DefaultScreen(gdi_display), att_list, &nCfgs);
 278     }
 279
 280     if (NULL == cfgs || 0 == nCfgs) {
 281       ERR("glXChooseFBConfig returns NULL (glError: %d)\n", pglGetError());
 282       ret = 0;
 283       goto choose_exit;
 284     }
 285
 286     gl_test = pglXGetFBConfigAttrib(gdi_display, cfgs[0], GLX_FBCONFIG_ID, &fmt_id);
 287     if (gl_test) {
 288       ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
 289       ret = 0;
 290       goto choose_exit;
 291     }
 292
 293     cfgs_fmt = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs_fmt);
 294     if (NULL == cfgs_fmt) {
 295       ERR("Failed to get All FB Configs\n");
 296       ret = 0;
 297       goto choose_exit;
 298     }
 299
 300     for (it_fmt = 0; it_fmt < nCfgs_fmt; ++it_fmt) {
 301       gl_test = pglXGetFBConfigAttrib(gdi_display, cfgs_fmt[it_fmt], GLX_FBCONFIG_ID, &tmp_fmt_id);
 302       if (gl_test) {
 303         ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
 304         XFree(cfgs_fmt);
 305         ret = 0;
 306         goto choose_exit;
 307       }
 308       if (fmt_id == tmp_fmt_id) {
 309         ret = it_fmt + 1;
 310         break ;
 311       }
 312     }
 313     if (it_fmt == nCfgs_fmt) {
 314       ERR("Failed to get valid fmt for FBCONFIG_ID(%d)\n", fmt_id);
 315       ret = 0;
 316     }
 317     XFree(cfgs_fmt);
 318   }
 319
 320 choose_exit:
 321   if (NULL != cfgs) XFree(cfgs);
 322   wine_tsx11_unlock();
 323   return ret;
 324 }
 325
 326 /**
 327  * X11DRV_DescribePixelFormat
 328  *
 329  * Get the pixel-format descriptor associated to the given id
 330  */
 331 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
 332                                int iPixelFormat,
 333                                UINT nBytes,
 334                                PIXELFORMATDESCRIPTOR *ppfd) {
 335   /*XVisualInfo *vis;*/
 336   int value;
 337   int rb,gb,bb,ab;
 338
 339   GLXFBConfig* cfgs = NULL;
 340   GLXFBConfig cur;
 341   int nCfgs = 0;
 342   int ret = 0;
 343
 344   if (!has_opengl()) {
 345     ERR("No libGL on this box - disabling OpenGL support !\n");
 346     return 0;
 347   }
 348
 349   TRACE("(%p,%d,%d,%p)\n", physDev, iPixelFormat, nBytes, ppfd);
 350
 351   wine_tsx11_lock();
 352   cfgs = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs);
 353   wine_tsx11_unlock();
 354
 355   if (NULL == cfgs || 0 == nCfgs) {
 356     ERR("unexpected iPixelFormat(%d), returns NULL\n", iPixelFormat);
 357     return 0; /* unespected error */
 358   }
 359
 360   if (ppfd == NULL) {
 361     /* The application is only querying the number of visuals */
 362     wine_tsx11_lock();
 363     if (NULL != cfgs) XFree(cfgs);
 364     wine_tsx11_unlock();
 365     return nCfgs;
 366   }
 367
 368   if (nBytes < sizeof(PIXELFORMATDESCRIPTOR)) {
 369     ERR("Wrong structure size !\n");
 370     /* Should set error */
 371     return 0;
 372   }
 373
 374   if (nCfgs < iPixelFormat || 1 > iPixelFormat) {
 375     WARN("unexpected iPixelFormat(%d): not >=1 and <=nFormats(%d), returning NULL\n", iPixelFormat, nCfgs);
 376     return 0;
 377   }
 378
 379   ret = nCfgs;
 380   cur = cfgs[iPixelFormat - 1];
 381
 382   memset(ppfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
 383   ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
 384   ppfd->nVersion = 1;
 385
 386   /* These flags are always the same... */
 387   ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
 388   /* Now the flags extracted from the Visual */
 389
 390   wine_tsx11_lock();
 391
 392   pglXGetFBConfigAttrib(gdi_display, cur, GLX_CONFIG_CAVEAT, &value);
 393   if(value == GLX_SLOW_CONFIG)
 394       ppfd->dwFlags |= PFD_GENERIC_ACCELERATED;
 395
 396   pglXGetFBConfigAttrib(gdi_display, cur, GLX_DOUBLEBUFFER, &value); if (value) ppfd->dwFlags |= PFD_DOUBLEBUFFER;
 397   pglXGetFBConfigAttrib(gdi_display, cur, GLX_STEREO, &value); if (value) ppfd->dwFlags |= PFD_STEREO;
 398
 399   /* Pixel type */
 400   pglXGetFBConfigAttrib(gdi_display, cur, GLX_RENDER_TYPE, &value);
 401   if (value & GLX_RGBA_BIT)
 402     ppfd->iPixelType = PFD_TYPE_RGBA;
 403   else
 404     ppfd->iPixelType = PFD_TYPE_COLORINDEX;
 405
 406   /* Color bits */
 407   pglXGetFBConfigAttrib(gdi_display, cur, GLX_BUFFER_SIZE, &value);
 408   ppfd->cColorBits = value;
 409
 410   /* Red, green, blue and alpha bits / shifts */
 411   if (ppfd->iPixelType == PFD_TYPE_RGBA) {
 412     pglXGetFBConfigAttrib(gdi_display, cur, GLX_RED_SIZE, &rb);
 413     pglXGetFBConfigAttrib(gdi_display, cur, GLX_GREEN_SIZE, &gb);
 414     pglXGetFBConfigAttrib(gdi_display, cur, GLX_BLUE_SIZE, &bb);
 415     pglXGetFBConfigAttrib(gdi_display, cur, GLX_ALPHA_SIZE, &ab);
 416
 417     ppfd->cRedBits = rb;
 418     ppfd->cRedShift = gb + bb + ab;
 419     ppfd->cBlueBits = bb;
 420     ppfd->cBlueShift = ab;
 421     ppfd->cGreenBits = gb;
 422     ppfd->cGreenShift = bb + ab;
 423     ppfd->cAlphaBits = ab;
 424     ppfd->cAlphaShift = 0;
 425   } else {
 426     ppfd->cRedBits = 0;
 427     ppfd->cRedShift = 0;
 428     ppfd->cBlueBits = 0;
 429     ppfd->cBlueShift = 0;
 430     ppfd->cGreenBits = 0;
 431     ppfd->cGreenShift = 0;
 432     ppfd->cAlphaBits = 0;
 433     ppfd->cAlphaShift = 0;
 434   }
 435   /* Accums : to do ... */
 436
 437   /* Depth bits */
 438   pglXGetFBConfigAttrib(gdi_display, cur, GLX_DEPTH_SIZE, &value);
 439   ppfd->cDepthBits = value;
 440
 441   /* stencil bits */
 442   pglXGetFBConfigAttrib(gdi_display, cur, GLX_STENCIL_SIZE, &value);
 443   ppfd->cStencilBits = value;
 444
 445   wine_tsx11_unlock();
 446
 447   /* Aux : to do ... */
 448
 449   ppfd->iLayerType = PFD_MAIN_PLANE;
 450
 451   if (TRACE_ON(opengl)) {
 452     dump_PIXELFORMATDESCRIPTOR(ppfd);
 453   }
 454
 455   wine_tsx11_lock();
 456   if (NULL != cfgs) XFree(cfgs);
 457   wine_tsx11_unlock();
 458
 459   return ret;
 460 }
 461
 462 /**
 463  * X11DRV_GetPixelFormat
 464  *
 465  * Get the pixel-format id used by this DC
 466  */
 467 int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
 468   TRACE("(%p): returns %d\n", physDev, physDev->current_pf);
 469
 470   return physDev->current_pf;
 471 }
 472
 473 /**
 474  * X11DRV_SetPixelFormat
 475  *
 476  * Set the pixel-format id used by this DC
 477  */
 478 BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
 479                            int iPixelFormat,
 480                            const PIXELFORMATDESCRIPTOR *ppfd) {
 481   TRACE("(%p,%d,%p)\n", physDev, iPixelFormat, ppfd);
 482
 483   physDev->current_pf = iPixelFormat;
 484
 485   if (TRACE_ON(opengl)) {
 486     int nCfgs_fmt = 0;
 487     GLXFBConfig* cfgs_fmt = NULL;
 488     GLXFBConfig cur_cfg;
 489     int value;
 490     int gl_test = 0;
 491
 492     /*
 493      * How to test if hdc current drawable is compatible (visual/FBConfig) ?
 494      *
 495      * in case of root window created HDCs we crash here :(
 496      *
 497     Drawable drawable =  get_drawable( physDev->hdc );
 498     TRACE(" drawable (%p,%p) have :\n", drawable, root_window);
 499     pglXQueryDrawable(gdi_display, drawable, GLX_FBCONFIG_ID, (unsigned int*) &value);
 500     TRACE(" - FBCONFIG_ID as 0x%x\n", tmp);
 501     pglXQueryDrawable(gdi_display, drawable, GLX_VISUAL_ID, (unsigned int*) &value);
 502     TRACE(" - VISUAL_ID as 0x%x\n", tmp);
 503     pglXQueryDrawable(gdi_display, drawable, GLX_WIDTH, (unsigned int*) &value);
 504     TRACE(" - WIDTH as %d\n", tmp);
 505     pglXQueryDrawable(gdi_display, drawable, GLX_HEIGHT, (unsigned int*) &value);
 506     TRACE(" - HEIGHT as %d\n", tmp);
 507     */
 508     cfgs_fmt = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs_fmt);
 509     cur_cfg = cfgs_fmt[iPixelFormat - 1];
 510     gl_test = pglXGetFBConfigAttrib(gdi_display, cur_cfg, GLX_FBCONFIG_ID, &value);
 511     if (gl_test) {
 512       ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
 513     } else {
 514       TRACE(" FBConfig have :\n");
 515       TRACE(" - FBCONFIG_ID   0x%x\n", value);
 516       pglXGetFBConfigAttrib(gdi_display, cur_cfg, GLX_VISUAL_ID, &value);
 517       TRACE(" - VISUAL_ID     0x%x\n", value);
 518       pglXGetFBConfigAttrib(gdi_display, cur_cfg, GLX_DRAWABLE_TYPE, &value);
 519       TRACE(" - DRAWABLE_TYPE 0x%x\n", value);
 520     }
 521     XFree(cfgs_fmt);
 522   }
 523   return TRUE;
 524 }
 525
 526 /**
 527  * X11DRV_SwapBuffers
 528  *
 529  * Swap the buffers of this DC
 530  */
 531 BOOL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev) {
 532   if (!has_opengl()) {
 533     ERR("No libGL on this box - disabling OpenGL support !\n");
 534     return 0;
 535   }
 536
 537   TRACE_(opengl)("(%p)\n", physDev);
 538
 539   wine_tsx11_lock();
 540   pglXSwapBuffers(gdi_display, physDev->drawable);
 541   wine_tsx11_unlock();
 542
 543   return TRUE;
 544 }
 545
 546 /***********************************************************************
 547  *              X11DRV_setup_opengl_visual
 548  *
 549  * Setup the default visual used for OpenGL and Direct3D, and the desktop
 550  * window (if it exists).  If OpenGL isn't available, the visual is simply
 551  * set to the default visual for the display
 552  */
 553 XVisualInfo *X11DRV_setup_opengl_visual( Display *display )
 554 {
 555     XVisualInfo *visual = NULL;
 556     /* In order to support OpenGL or D3D, we require a double-buffered visual and stencil buffer support, */
 557     int dblBuf[] = {GLX_RGBA,GLX_DEPTH_SIZE, 24, GLX_STENCIL_SIZE, 8, GLX_ALPHA_SIZE, 8, GLX_DOUBLEBUFFER, None};
 558     if (!has_opengl()) return NULL;
 559
 560     wine_tsx11_lock();
 561     visual = pglXChooseVisual(display, DefaultScreen(display), dblBuf);
 562     wine_tsx11_unlock();
 563     if (visual == NULL) {
 564         /* fallback to 16 bits depth, no alpha */
 565         int dblBuf2[] = {GLX_RGBA,GLX_DEPTH_SIZE, 16, GLX_STENCIL_SIZE, 8, GLX_DOUBLEBUFFER, None};
 566         WARN("Failed to get a visual with at least 24 bits depth\n");
 567
 568         wine_tsx11_lock();
 569         visual = pglXChooseVisual(display, DefaultScreen(display), dblBuf2);
 570         wine_tsx11_unlock();
 571         if (visual == NULL) {
 572             /* fallback to no stencil */
 573             int dblBuf2[] = {GLX_RGBA,GLX_DEPTH_SIZE, 16, GLX_DOUBLEBUFFER, None};
 574             WARN("Failed to get a visual with at least 8 bits of stencil\n");
 575
 576             wine_tsx11_lock();
 577             visual = pglXChooseVisual(display, DefaultScreen(display), dblBuf2);
 578             wine_tsx11_unlock();
 579             if (visual == NULL) {
 580                 /* This should only happen if we cannot find a match with a depth size 16 */
 581                 FIXME("Failed to find a suitable visual\n");
 582                 return visual;
 583             }
 584         }
 585     }
 586     TRACE("Visual ID %lx Chosen\n",visual->visualid);
 587     return visual;
 588 }
 589
 590 XID create_glxpixmap(X11DRV_PDEVICE *physDev)
 591 {
 592     GLXPixmap ret;
 593     XVisualInfo *vis;
 594     XVisualInfo template;
 595     int num;
 596     GLXFBConfig *cfgs;
 597
 598     wine_tsx11_lock();
 599     cfgs = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &num);
 600     pglXGetFBConfigAttrib(gdi_display, cfgs[physDev->current_pf - 1], GLX_VISUAL_ID, (int *)&template.visualid);
 601
 602     vis = XGetVisualInfo(gdi_display, VisualIDMask, &template, &num);
 603
 604     ret = pglXCreateGLXPixmap(gdi_display, vis, physDev->bitmap->pixmap);
 605     XFree(vis);
 606     XFree(cfgs);
 607     wine_tsx11_unlock();
 608     TRACE("return %lx\n", ret);
 609     return ret;
 610 }
 611
 612 BOOL destroy_glxpixmap(XID glxpixmap)
 613 {
 614     wine_tsx11_lock();
 615     pglXDestroyGLXPixmap(gdi_display, glxpixmap);
 616     wine_tsx11_unlock();
 617     return TRUE;
 618 }
 619
 620 #else  /* no OpenGL includes */
 621
 622 void X11DRV_OpenGL_Init(Display *display)
 623 {
 624 }
 625
 626 /***********************************************************************
 627  *              ChoosePixelFormat (X11DRV.@)
 628  */
 629 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
 630                              const PIXELFORMATDESCRIPTOR *ppfd) {
 631   ERR("No OpenGL support compiled in.\n");
 632
 633   return 0;
 634 }
 635
 636 /***********************************************************************
 637  *              DescribePixelFormat (X11DRV.@)
 638  */
 639 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
 640                                int iPixelFormat,
 641                                UINT nBytes,
 642                                PIXELFORMATDESCRIPTOR *ppfd) {
 643   ERR("No OpenGL support compiled in.\n");
 644
 645   return 0;
 646 }
 647
 648 /***********************************************************************
 649  *              GetPixelFormat (X11DRV.@)
 650  */
 651 int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
 652   ERR("No OpenGL support compiled in.\n");
 653
 654   return 0;
 655 }
 656
 657 /***********************************************************************
 658  *              SetPixelFormat (X11DRV.@)
 659  */
 660 BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
 661                            int iPixelFormat,
 662                            const PIXELFORMATDESCRIPTOR *ppfd) {
 663   ERR("No OpenGL support compiled in.\n");
 664
 665   return FALSE;
 666 }
 667
 668 /***********************************************************************
 669  *              SwapBuffers (X11DRV.@)
 670  */
 671 BOOL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev) {
 672   ERR_(opengl)("No OpenGL support compiled in.\n");
 673
 674   return FALSE;
 675 }
 676
 677 XVisualInfo *X11DRV_setup_opengl_visual( Display *display )
 678 {
 679   return NULL;
 680 }
 681
 682 XID create_glxpixmap(X11DRV_PDEVICE *physDev)
 683 {
 684     return 0;
 685 }
 686
 687 BOOL destroy_glxpixmap(XID glxpixmap)
 688 {
 689     return FALSE;
 690 }
 691
 692 #endif /* defined(HAVE_OPENGL) */