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