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