git.oblomov.eu Git - wine/blob - dlls/winex11.drv/opengl.c

   1 /*
   2  * X11DRV OpenGL functions
   3  *
   4  * Copyright 2000 Lionel Ulmer
   5  * Copyright 2005 Alex Woods
   6  * Copyright 2005 Raphael Junqueira
   7  * Copyright 2006 Roderick Colenbrander
   8  * Copyright 2006 Tomas Carnecky
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include "config.h"
  26 #include "wine/port.h"
  27
  28 #include <assert.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include "x11drv.h"
  33 #include "winternl.h"
  34 #include "wine/library.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(wgl);
  38 WINE_DECLARE_DEBUG_CHANNEL(opengl);
  39
  40 #if defined(HAVE_GL_GL_H) && defined(HAVE_GL_GLX_H)
  41
  42 #undef APIENTRY
  43 #undef CALLBACK
  44 #undef WINAPI
  45
  46 #ifdef HAVE_GL_GL_H
  47 # include <GL/gl.h>
  48 #endif
  49 #ifdef HAVE_GL_GLX_H
  50 # include <GL/glx.h>
  51 #endif
  52 #ifdef HAVE_GL_GLEXT_H
  53 # include <GL/glext.h>
  54 #endif
  55
  56 #include "wine/wgl.h"
  57
  58 #undef APIENTRY
  59 #undef CALLBACK
  60 #undef WINAPI
  61
  62 /* Redefines the constants */
  63 #define CALLBACK    __stdcall
  64 #define WINAPI      __stdcall
  65 #define APIENTRY    WINAPI
  66
  67
  68 WINE_DECLARE_DEBUG_CHANNEL(fps);
  69
  70 typedef struct wine_glcontext {
  71     HDC hdc;
  72     Display *display;
  73     XVisualInfo *vis;
  74     GLXFBConfig fb_conf;
  75     GLXContext ctx;
  76     BOOL do_escape;
  77     struct wine_glcontext *next;
  78     struct wine_glcontext *prev;
  79 } Wine_GLContext;
  80
  81 typedef struct wine_glpbuffer {
  82     Drawable   drawable;
  83     Display*   display;
  84     int        pixelFormat;
  85     int        width;
  86     int        height;
  87     int*       attribList;
  88     HDC        hdc;
  89
  90     int        use_render_texture;
  91     GLuint     texture_target;
  92     GLuint     texture_bind_target;
  93     GLuint     texture;
  94     int        texture_level;
  95     HDC        prev_hdc;
  96     HGLRC      prev_ctx;
  97     HDC        render_hdc;
  98     HGLRC      render_ctx;
  99 } Wine_GLPBuffer;
 100
 101 typedef struct wine_glextension {
 102     const char *extName;
 103     struct {
 104         const char *funcName;
 105         void *funcAddress;
 106     } extEntryPoints[8];
 107 } WineGLExtension;
 108
 109 struct WineGLInfo {
 110     const char *glVersion;
 111     const char *glExtensions;
 112
 113     int glxVersion[2];
 114
 115     const char *glxServerVersion;
 116     const char *glxServerExtensions;
 117
 118     const char *glxClientVersion;
 119     const char *glxClientExtensions;
 120
 121     const char *glxExtensions;
 122
 123     BOOL glxDirect;
 124     char wglExtensions[4096];
 125 };
 126
 127 typedef struct wine_glpixelformat {
 128     int iPixelFormat;
 129     int fbconfig;
 130     int fmt_index;
 131 } WineGLPixelFormat;
 132
 133 static Wine_GLContext *context_list;
 134 static struct WineGLInfo WineGLInfo = { 0 };
 135 static int use_render_texture_emulation = 0;
 136 static int use_render_texture_ati = 0;
 137 static int swap_interval = 1;
 138
 139 #define MAX_EXTENSIONS 16
 140 static const WineGLExtension *WineGLExtensionList[MAX_EXTENSIONS];
 141 static int WineGLExtensionListSize;
 142
 143 #define MAX_GLPIXELFORMATS 32
 144 static WineGLPixelFormat WineGLPixelFormatList[MAX_GLPIXELFORMATS];
 145 static int WineGLPixelFormatListSize = 0;
 146
 147 static void X11DRV_WineGL_LoadExtensions(void);
 148
 149 static void dump_PIXELFORMATDESCRIPTOR(const PIXELFORMATDESCRIPTOR *ppfd) {
 150   TRACE("  - size / version : %d / %d\n", ppfd->nSize, ppfd->nVersion);
 151   TRACE("  - dwFlags : ");
 152 #define TEST_AND_DUMP(t,tv) if ((t) & (tv)) TRACE(#tv " ")
 153   TEST_AND_DUMP(ppfd->dwFlags, PFD_DEPTH_DONTCARE);
 154   TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER);
 155   TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER_DONTCARE);
 156   TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_WINDOW);
 157   TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_BITMAP);
 158   TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_ACCELERATED);
 159   TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_FORMAT);
 160   TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_PALETTE);
 161   TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_SYSTEM_PALETTE);
 162   TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO);
 163   TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO_DONTCARE);
 164   TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_GDI);
 165   TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_OPENGL);
 166   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_COPY);
 167   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_EXCHANGE);
 168   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_LAYER_BUFFERS);
 169 #undef TEST_AND_DUMP
 170   TRACE("\n");
 171
 172   TRACE("  - iPixelType : ");
 173   switch (ppfd->iPixelType) {
 174   case PFD_TYPE_RGBA: TRACE("PFD_TYPE_RGBA"); break;
 175   case PFD_TYPE_COLORINDEX: TRACE("PFD_TYPE_COLORINDEX"); break;
 176   }
 177   TRACE("\n");
 178
 179   TRACE("  - Color   : %d\n", ppfd->cColorBits);
 180   TRACE("  - Red     : %d\n", ppfd->cRedBits);
 181   TRACE("  - Green   : %d\n", ppfd->cGreenBits);
 182   TRACE("  - Blue    : %d\n", ppfd->cBlueBits);
 183   TRACE("  - Alpha   : %d\n", ppfd->cAlphaBits);
 184   TRACE("  - Accum   : %d\n", ppfd->cAccumBits);
 185   TRACE("  - Depth   : %d\n", ppfd->cDepthBits);
 186   TRACE("  - Stencil : %d\n", ppfd->cStencilBits);
 187   TRACE("  - Aux     : %d\n", ppfd->cAuxBuffers);
 188
 189   TRACE("  - iLayerType : ");
 190   switch (ppfd->iLayerType) {
 191   case PFD_MAIN_PLANE: TRACE("PFD_MAIN_PLANE"); break;
 192   case PFD_OVERLAY_PLANE: TRACE("PFD_OVERLAY_PLANE"); break;
 193   case (BYTE)PFD_UNDERLAY_PLANE: TRACE("PFD_UNDERLAY_PLANE"); break;
 194   }
 195   TRACE("\n");
 196 }
 197
 198 /* No need to load any other libraries as according to the ABI, libGL should be self-sufficient and
 199    include all dependencies
 200 */
 201 #ifndef SONAME_LIBGL
 202 #define SONAME_LIBGL "libGL.so"
 203 #endif
 204
 205 #define PUSH1(attribs,att)        do { attribs[nAttribs++] = (att); } while (0)
 206 #define PUSH2(attribs,att,value)  do { attribs[nAttribs++] = (att); attribs[nAttribs++] = (value); } while(0)
 207
 208 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
 209 /* GLX 1.0 */
 210 MAKE_FUNCPTR(glXChooseVisual)
 211 MAKE_FUNCPTR(glXCreateContext)
 212 MAKE_FUNCPTR(glXCreateGLXPixmap)
 213 MAKE_FUNCPTR(glXGetCurrentContext)
 214 MAKE_FUNCPTR(glXDestroyContext)
 215 MAKE_FUNCPTR(glXDestroyGLXPixmap)
 216 MAKE_FUNCPTR(glXGetConfig)
 217 MAKE_FUNCPTR(glXIsDirect)
 218 MAKE_FUNCPTR(glXMakeCurrent)
 219 MAKE_FUNCPTR(glXSwapBuffers)
 220 MAKE_FUNCPTR(glXQueryExtension)
 221 MAKE_FUNCPTR(glXQueryVersion)
 222 MAKE_FUNCPTR(glXUseXFont)
 223
 224 /* GLX 1.1 */
 225 MAKE_FUNCPTR(glXGetClientString)
 226 MAKE_FUNCPTR(glXQueryExtensionsString)
 227 MAKE_FUNCPTR(glXQueryServerString)
 228
 229 /* GLX 1.3 */
 230 MAKE_FUNCPTR(glXGetFBConfigs)
 231 MAKE_FUNCPTR(glXChooseFBConfig)
 232 MAKE_FUNCPTR(glXCreatePbuffer)
 233 MAKE_FUNCPTR(glXDestroyPbuffer)
 234 MAKE_FUNCPTR(glXGetFBConfigAttrib)
 235 MAKE_FUNCPTR(glXGetVisualFromFBConfig)
 236 MAKE_FUNCPTR(glXMakeContextCurrent)
 237 MAKE_FUNCPTR(glXQueryDrawable)
 238 MAKE_FUNCPTR(glXGetCurrentReadDrawable)
 239
 240 /* GLX Extensions */
 241 static void* (*pglXGetProcAddressARB)(const GLubyte *);
 242 static BOOL  (*pglXBindTexImageARB)(Display *dpy, GLXPbuffer pbuffer, int buffer);
 243 static BOOL  (*pglXReleaseTexImageARB)(Display *dpy, GLXPbuffer pbuffer, int buffer);
 244 static BOOL  (*pglXDrawableAttribARB)(Display *dpy, GLXDrawable draw, const int *attribList);
 245 static int   (*pglXSwapIntervalSGI)(int);
 246
 247 /* NV GLX Extension */
 248 static void* (*pglXAllocateMemoryNV)(GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority);
 249 static void  (*pglXFreeMemoryNV)(GLvoid *pointer);
 250
 251 /* Standard OpenGL */
 252 MAKE_FUNCPTR(glBindTexture)
 253 MAKE_FUNCPTR(glBitmap)
 254 MAKE_FUNCPTR(glCopyTexSubImage1D)
 255 MAKE_FUNCPTR(glCopyTexSubImage2D)
 256 MAKE_FUNCPTR(glDrawBuffer)
 257 MAKE_FUNCPTR(glEndList)
 258 MAKE_FUNCPTR(glGetError)
 259 MAKE_FUNCPTR(glGetIntegerv)
 260 MAKE_FUNCPTR(glGetString)
 261 MAKE_FUNCPTR(glNewList)
 262 MAKE_FUNCPTR(glPixelStorei)
 263 #undef MAKE_FUNCPTR
 264
 265 static BOOL X11DRV_WineGL_InitOpenglInfo(void)
 266 {
 267     static BOOL infoInitialized = FALSE;
 268
 269     int screen = DefaultScreen(gdi_display);
 270     Window win = RootWindow(gdi_display, screen);
 271     Visual *visual;
 272     XVisualInfo template;
 273     XVisualInfo *vis;
 274     int num;
 275     GLXContext ctx = NULL;
 276
 277     if (infoInitialized)
 278         return TRUE;
 279     infoInitialized = TRUE;
 280
 281     wine_tsx11_lock();
 282
 283     visual = DefaultVisual(gdi_display, screen);
 284     template.visualid = XVisualIDFromVisual(visual);
 285     vis = XGetVisualInfo(gdi_display, VisualIDMask, &template, &num);
 286     if (vis) {
 287         /* Create a GLX Context. Without one we can't query GL information */
 288         ctx = pglXCreateContext(gdi_display, vis, None, GL_TRUE);
 289     }
 290
 291     if (ctx) {
 292         pglXMakeCurrent(gdi_display, win, ctx);
 293     } else {
 294         ERR(" couldn't initialize OpenGL, expect problems\n");
 295         wine_tsx11_unlock();
 296         return FALSE;
 297     }
 298
 299     WineGLInfo.glVersion = (const char *) pglGetString(GL_VERSION);
 300     WineGLInfo.glExtensions = (const char *) pglGetString(GL_EXTENSIONS);
 301
 302     /* Get the common GLX version supported by GLX client and server ( major/minor) */
 303     pglXQueryVersion(gdi_display, &WineGLInfo.glxVersion[0], &WineGLInfo.glxVersion[1]);
 304
 305     WineGLInfo.glxServerVersion = pglXQueryServerString(gdi_display, screen, GLX_VERSION);
 306     WineGLInfo.glxServerExtensions = pglXQueryServerString(gdi_display, screen, GLX_EXTENSIONS);
 307
 308     WineGLInfo.glxClientVersion = pglXGetClientString(gdi_display, GLX_VERSION);
 309     WineGLInfo.glxClientExtensions = pglXGetClientString(gdi_display, GLX_EXTENSIONS);
 310
 311     WineGLInfo.glxExtensions = pglXQueryExtensionsString(gdi_display, screen);
 312     WineGLInfo.glxDirect = pglXIsDirect(gdi_display, ctx);
 313
 314     TRACE("GL version             : %s.\n", WineGLInfo.glVersion);
 315     TRACE("GLX version            : %d.%d.\n", WineGLInfo.glxVersion[0], WineGLInfo.glxVersion[1]);
 316     TRACE("Server GLX version     : %s.\n", WineGLInfo.glxServerVersion);
 317     TRACE("Client GLX version     : %s.\n", WineGLInfo.glxClientVersion);
 318     TRACE("Direct rendering enabled: %s\n", WineGLInfo.glxDirect ? "True" : "False");
 319
 320     if(vis) XFree(vis);
 321     if(ctx) {
 322         pglXMakeCurrent(gdi_display, None, NULL);
 323         pglXDestroyContext(gdi_display, ctx);
 324     }
 325     wine_tsx11_unlock();
 326     return TRUE;
 327 }
 328
 329 static BOOL has_opengl(void)
 330 {
 331     static int init_done;
 332     static void *opengl_handle;
 333     const char *glx_extensions;
 334
 335     int error_base, event_base;
 336
 337     if (init_done) return (opengl_handle != NULL);
 338     init_done = 1;
 339
 340     opengl_handle = wine_dlopen(SONAME_LIBGL, RTLD_NOW|RTLD_GLOBAL, NULL, 0);
 341     if (opengl_handle == NULL) return FALSE;
 342
 343     pglXGetProcAddressARB = wine_dlsym(opengl_handle, "glXGetProcAddressARB", NULL, 0);
 344     if (pglXGetProcAddressARB == NULL) {
 345         ERR("could not find glXGetProcAddressARB in libGL.\n");
 346         return FALSE;
 347     }
 348
 349 #define LOAD_FUNCPTR(f) if((p##f = (void*)pglXGetProcAddressARB((const unsigned char*)#f)) == NULL) goto sym_not_found;
 350 /* GLX 1.0 */
 351 LOAD_FUNCPTR(glXChooseVisual)
 352 LOAD_FUNCPTR(glXCreateContext)
 353 LOAD_FUNCPTR(glXCreateGLXPixmap)
 354 LOAD_FUNCPTR(glXGetCurrentContext)
 355 LOAD_FUNCPTR(glXDestroyContext)
 356 LOAD_FUNCPTR(glXDestroyGLXPixmap)
 357 LOAD_FUNCPTR(glXGetConfig)
 358 LOAD_FUNCPTR(glXIsDirect)
 359 LOAD_FUNCPTR(glXMakeCurrent)
 360 LOAD_FUNCPTR(glXSwapBuffers)
 361 LOAD_FUNCPTR(glXQueryExtension)
 362 LOAD_FUNCPTR(glXQueryVersion)
 363 LOAD_FUNCPTR(glXUseXFont)
 364
 365 /* GLX 1.1 */
 366 LOAD_FUNCPTR(glXGetClientString)
 367 LOAD_FUNCPTR(glXQueryExtensionsString)
 368 LOAD_FUNCPTR(glXQueryServerString)
 369
 370 /* GLX 1.3 */
 371 LOAD_FUNCPTR(glXCreatePbuffer)
 372 LOAD_FUNCPTR(glXDestroyPbuffer)
 373 LOAD_FUNCPTR(glXMakeContextCurrent)
 374 LOAD_FUNCPTR(glXGetCurrentReadDrawable)
 375 LOAD_FUNCPTR(glXGetFBConfigs)
 376
 377 /* Standard OpenGL calls */
 378 LOAD_FUNCPTR(glBindTexture)
 379 LOAD_FUNCPTR(glBitmap)
 380 LOAD_FUNCPTR(glEndList)
 381 LOAD_FUNCPTR(glCopyTexSubImage1D)
 382 LOAD_FUNCPTR(glCopyTexSubImage2D)
 383 LOAD_FUNCPTR(glDrawBuffer)
 384 LOAD_FUNCPTR(glGetError)
 385 LOAD_FUNCPTR(glGetIntegerv)
 386 LOAD_FUNCPTR(glGetString)
 387 LOAD_FUNCPTR(glNewList)
 388 LOAD_FUNCPTR(glPixelStorei)
 389 #undef LOAD_FUNCPTR
 390
 391 /* It doesn't matter if these fail. They'll only be used if the driver reports
 392    the associated extension is available (and if a driver reports the extension
 393    is available but fails to provide the functions, it's quite broken) */
 394 #define LOAD_FUNCPTR(f) p##f = (void*)pglXGetProcAddressARB((const unsigned char*)#f);
 395 /* NV GLX Extension */
 396 LOAD_FUNCPTR(glXAllocateMemoryNV)
 397 LOAD_FUNCPTR(glXFreeMemoryNV)
 398 #undef LOAD_FUNCPTR
 399
 400     if(!X11DRV_WineGL_InitOpenglInfo()) {
 401         ERR("Intialization of OpenGL info failed, disabling OpenGL!\n");
 402         wine_dlclose(opengl_handle, NULL, 0);
 403         opengl_handle = NULL;
 404         return FALSE;
 405     }
 406
 407     wine_tsx11_lock();
 408     if (pglXQueryExtension(gdi_display, &error_base, &event_base) == True) {
 409         TRACE("GLX is up and running error_base = %d\n", error_base);
 410     } else {
 411         wine_dlclose(opengl_handle, NULL, 0);
 412         opengl_handle = NULL;
 413     }
 414
 415     /* In case of GLX you have direct and indirect rendering. Most of the time direct rendering is used
 416      * as in general only that is hardware accelerated. In some cases like in case of remote X indirect
 417      * rendering is used.
 418      *
 419      * The main problem for our OpenGL code is that we need certain GLX calls but their presence
 420      * depends on the reported GLX client / server version and on the client / server extension list.
 421      * Those don't have to be the same.
 422      *
 423      * In general the server GLX information should be used in case of indirect rendering. When direct
 424      * rendering is used, the OpenGL client library is responsible for which GLX calls are available.
 425      * Nvidia's OpenGL drivers are the best in terms of GLX features. At the moment of writing their
 426      * 8762 drivers support 1.3 for the server and 1.4 for the client and they support lots of extensions.
 427      * Unfortunately it is much more complicated for Mesa/DRI-based drivers and ATI's drivers.
 428      * Both sets of drivers report a server version of 1.2 and the client version can be 1.3 or 1.4.
 429      * Further, in case of at least ATI's drivers, one crucial extension needed for our pixel format code
 430      * is only available in the list of server extensions and not in the client list.
 431      *
 432      * The versioning checks below try to take into account the comments from above.
 433      */
 434
 435     /* Depending on the use of direct or indirect rendering we need either the list of extensions
 436      * exported by the client or by the server.
 437      */
 438     if(WineGLInfo.glxDirect)
 439         glx_extensions = WineGLInfo.glxClientExtensions;
 440     else
 441         glx_extensions = WineGLInfo.glxServerExtensions;
 442
 443     /* Based on the default opengl context we decide whether direct or indirect rendering is used.
 444      * In case of indirect rendering we check if the GLX version of the server is 1.2 and else
 445      * the client version is checked.
 446      */
 447     if ((!WineGLInfo.glxDirect && !strcmp("1.2", WineGLInfo.glxServerVersion)) ||
 448         (WineGLInfo.glxDirect && !strcmp("1.2", WineGLInfo.glxClientVersion)))
 449     {
 450         if (NULL != strstr(glx_extensions, "GLX_SGIX_fbconfig")) {
 451             pglXChooseFBConfig = (void*)pglXGetProcAddressARB((const GLubyte *) "glXChooseFBConfigSGIX");
 452             pglXGetFBConfigAttrib = (void*)pglXGetProcAddressARB((const GLubyte *) "glXGetFBConfigAttribSGIX");
 453             pglXGetVisualFromFBConfig = (void*)pglXGetProcAddressARB((const GLubyte *) "glXGetVisualFromFBConfigSGIX");
 454         } else {
 455             ERR(" glx_version is %s and GLX_SGIX_fbconfig extension is unsupported. Expect problems.\n", WineGLInfo.glxClientVersion);
 456         }
 457     } else {
 458         pglXChooseFBConfig = (void*)pglXGetProcAddressARB((const GLubyte *) "glXChooseFBConfig");
 459         pglXGetFBConfigAttrib = (void*)pglXGetProcAddressARB((const GLubyte *) "glXGetFBConfigAttrib");
 460         pglXGetVisualFromFBConfig = (void*)pglXGetProcAddressARB((const GLubyte *) "glXGetVisualFromFBConfig");
 461     }
 462
 463     /* The mesa libGL client library seems to forward glXQueryDrawable to the Xserver, so only
 464      * enable this function when the Xserver understand GLX 1.3 or newer
 465      */
 466     if (!strcmp("1.2", WineGLInfo.glxServerVersion))
 467         pglXQueryDrawable = NULL;
 468     else
 469         pglXQueryDrawable = wine_dlsym(RTLD_DEFAULT, "glXQueryDrawable", NULL, 0);
 470
 471     if (NULL != strstr(glx_extensions, "GLX_ATI_render_texture")) {
 472         pglXBindTexImageARB = (void*)pglXGetProcAddressARB((const GLubyte *) "glXBindTexImageARB");
 473         pglXReleaseTexImageARB = (void*)pglXGetProcAddressARB((const GLubyte *) "glXReleaseTexImageARB");
 474         pglXDrawableAttribARB = (void*)pglXGetProcAddressARB((const GLubyte *) "glXDrawableAttribARB");
 475     }
 476
 477     X11DRV_WineGL_LoadExtensions();
 478
 479     wine_tsx11_unlock();
 480     return (opengl_handle != NULL);
 481
 482 sym_not_found:
 483     wine_dlclose(opengl_handle, NULL, 0);
 484     opengl_handle = NULL;
 485     return FALSE;
 486 }
 487
 488 static inline Wine_GLContext *alloc_context(void)
 489 {
 490     Wine_GLContext *ret;
 491
 492     if ((ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(Wine_GLContext))))
 493     {
 494         ret->next = context_list;
 495         if (context_list) context_list->prev = ret;
 496         context_list = ret;
 497     }
 498     return ret;
 499 }
 500
 501 static inline void free_context(Wine_GLContext *context)
 502 {
 503     if (context->next != NULL) context->next->prev = context->prev;
 504     if (context->prev != NULL) context->prev->next = context->next;
 505     else context_list = context->next;
 506
 507     HeapFree(GetProcessHeap(), 0, context);
 508 }
 509
 510 static inline Wine_GLContext *get_context_from_GLXContext(GLXContext ctx)
 511 {
 512     Wine_GLContext *ret;
 513     if (!ctx) return NULL;
 514     for (ret = context_list; ret; ret = ret->next) if (ctx == ret->ctx) break;
 515     return ret;
 516 }
 517
 518 /**
 519  * get_drawable (internal)
 520  *
 521  * Retrieve the GLX drawable to use on a given DC.
 522  */
 523 inline static Drawable get_drawable( HDC hdc )
 524 {
 525     GLXDrawable drawable;
 526     enum x11drv_escape_codes escape = X11DRV_GET_GLX_DRAWABLE;
 527
 528     if (!ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPCSTR)&escape,
 529                     sizeof(drawable), (LPSTR)&drawable )) drawable = 0;
 530     return drawable;
 531 }
 532
 533 inline static void set_drawable( HDC hdc, Drawable drawable )
 534 {
 535     struct x11drv_escape_set_drawable escape;
 536
 537     escape.code = X11DRV_SET_DRAWABLE;
 538     escape.drawable = drawable;
 539     escape.mode = IncludeInferiors;
 540     escape.org.x = escape.org.y = 0;
 541     escape.drawable_org.x = escape.drawable_org.y = 0;
 542
 543     ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPCSTR)&escape, 0, NULL );
 544 }
 545
 546 /**
 547  * get_hdc_from_Drawable (internal)
 548  *
 549  * For use by wglGetCurrentReadDCARB.
 550  */
 551 inline static HDC get_hdc_from_Drawable(GLXDrawable d)
 552 {
 553     Wine_GLContext *ret;
 554     for (ret = context_list; ret; ret = ret->next) {
 555         if (d == get_drawable( ret->hdc )) {
 556             return ret->hdc;
 557         }
 558     }
 559     return NULL;
 560 }
 561
 562 inline static BOOL is_valid_context( Wine_GLContext *ctx )
 563 {
 564     Wine_GLContext *ptr;
 565     for (ptr = context_list; ptr; ptr = ptr->next) if (ptr == ctx) break;
 566     return (ptr != NULL);
 567 }
 568
 569 static int describeContext(Wine_GLContext* ctx) {
 570     int tmp;
 571     int ctx_vis_id;
 572     TRACE(" Context %p have (vis:%p):\n", ctx, ctx->vis);
 573     pglXGetFBConfigAttrib(ctx->display, ctx->fb_conf, GLX_FBCONFIG_ID, &tmp);
 574     TRACE(" - FBCONFIG_ID 0x%x\n", tmp);
 575     pglXGetFBConfigAttrib(ctx->display, ctx->fb_conf, GLX_VISUAL_ID, &tmp);
 576     TRACE(" - VISUAL_ID 0x%x\n", tmp);
 577     ctx_vis_id = tmp;
 578     return ctx_vis_id;
 579 }
 580
 581 static int describeDrawable(Wine_GLContext* ctx, Drawable drawable) {
 582     int tmp;
 583     int nElements;
 584     int attribList[3] = { GLX_FBCONFIG_ID, 0, None };
 585     GLXFBConfig *fbCfgs;
 586
 587     if (pglXQueryDrawable == NULL)  {
 588         /** glXQueryDrawable not available so returns not supported */
 589         return -1;
 590     }
 591
 592     TRACE(" Drawable %p have :\n", (void*) drawable);
 593     pglXQueryDrawable(ctx->display, drawable, GLX_WIDTH, (unsigned int*) &tmp);
 594     TRACE(" - WIDTH as %d\n", tmp);
 595     pglXQueryDrawable(ctx->display, drawable, GLX_HEIGHT, (unsigned int*) &tmp);
 596     TRACE(" - HEIGHT as %d\n", tmp);
 597     pglXQueryDrawable(ctx->display, drawable, GLX_FBCONFIG_ID, (unsigned int*) &tmp);
 598     TRACE(" - FBCONFIG_ID as 0x%x\n", tmp);
 599
 600     attribList[1] = tmp;
 601     fbCfgs = pglXChooseFBConfig(ctx->display, DefaultScreen(ctx->display), attribList, &nElements);
 602     if (fbCfgs == NULL) {
 603         return -1;
 604     }
 605
 606     pglXGetFBConfigAttrib(ctx->display, fbCfgs[0], GLX_VISUAL_ID, &tmp);
 607     TRACE(" - VISUAL_ID as 0x%x\n", tmp);
 608
 609     XFree(fbCfgs);
 610
 611     return tmp;
 612 }
 613
 614 static int ConvertAttribWGLtoGLX(const int* iWGLAttr, int* oGLXAttr, Wine_GLPBuffer* pbuf) {
 615   int nAttribs = 0;
 616   unsigned cur = 0;
 617   int pop;
 618   int drawattrib = 0;
 619   int isColor = 0;
 620   int wantColorBits = 0;
 621   int sz_alpha = 0;
 622
 623   while (0 != iWGLAttr[cur]) {
 624     TRACE("pAttr[%d] = %x\n", cur, iWGLAttr[cur]);
 625
 626     switch (iWGLAttr[cur]) {
 627     case WGL_COLOR_BITS_ARB:
 628       pop = iWGLAttr[++cur];
 629       wantColorBits = pop; /** see end */
 630       break;
 631     case WGL_BLUE_BITS_ARB:
 632       pop = iWGLAttr[++cur];
 633       PUSH2(oGLXAttr, GLX_BLUE_SIZE, pop);
 634       TRACE("pAttr[%d] = GLX_BLUE_SIZE: %d\n", cur, pop);
 635       break;
 636     case WGL_RED_BITS_ARB:
 637       pop = iWGLAttr[++cur];
 638       PUSH2(oGLXAttr, GLX_RED_SIZE, pop);
 639       TRACE("pAttr[%d] = GLX_RED_SIZE: %d\n", cur, pop);
 640       break;
 641     case WGL_GREEN_BITS_ARB:
 642       pop = iWGLAttr[++cur];
 643       PUSH2(oGLXAttr, GLX_GREEN_SIZE, pop);
 644       TRACE("pAttr[%d] = GLX_GREEN_SIZE: %d\n", cur, pop);
 645       break;
 646     case WGL_ALPHA_BITS_ARB:
 647       pop = iWGLAttr[++cur];
 648       sz_alpha = pop;
 649       PUSH2(oGLXAttr, GLX_ALPHA_SIZE, pop);
 650       TRACE("pAttr[%d] = GLX_ALPHA_SIZE: %d\n", cur, pop);
 651       break;
 652     case WGL_DEPTH_BITS_ARB:
 653       pop = iWGLAttr[++cur];
 654       PUSH2(oGLXAttr, GLX_DEPTH_SIZE, pop);
 655       TRACE("pAttr[%d] = GLX_DEPTH_SIZE: %d\n", cur, pop);
 656       break;
 657     case WGL_STENCIL_BITS_ARB:
 658       pop = iWGLAttr[++cur];
 659       PUSH2(oGLXAttr, GLX_STENCIL_SIZE, pop);
 660       TRACE("pAttr[%d] = GLX_STENCIL_SIZE: %d\n", cur, pop);
 661       break;
 662     case WGL_DOUBLE_BUFFER_ARB:
 663       pop = iWGLAttr[++cur];
 664       PUSH2(oGLXAttr, GLX_DOUBLEBUFFER, pop);
 665       TRACE("pAttr[%d] = GLX_DOUBLEBUFFER: %d\n", cur, pop);
 666       break;
 667
 668     case WGL_PIXEL_TYPE_ARB:
 669       pop = iWGLAttr[++cur];
 670       switch (pop) {
 671       case WGL_TYPE_COLORINDEX_ARB: pop = GLX_COLOR_INDEX_BIT; isColor = 1; break ;
 672       case WGL_TYPE_RGBA_ARB: pop = GLX_RGBA_BIT; break ;
 673       case WGL_TYPE_RGBA_FLOAT_ATI: pop = GLX_RGBA_FLOAT_ATI_BIT; break ;
 674       default:
 675         ERR("unexpected PixelType(%x)\n", pop);
 676         pop = 0;
 677       }
 678       PUSH2(oGLXAttr, GLX_RENDER_TYPE, pop);
 679       TRACE("pAttr[%d] = GLX_RENDER_TYPE: %d\n", cur, pop);
 680       break;
 681
 682     case WGL_SUPPORT_GDI_ARB:
 683       pop = iWGLAttr[++cur];
 684       /* We only support a limited number of formats which are all renderable by X (similar to GDI).
 685        * Ignore this attribute to prevent us from not finding a match due to the limited
 686        * amount of formats supported right now. This option could be matched to GLX_X_RENDERABLE
 687        * but the issue is that when a program asks for no GDI support, there's no format we can return
 688        * as all our supported formats are renderable by X.
 689        */
 690       TRACE("pAttr[%d] = WGL_SUPPORT_GDI_ARB: %d\n", cur, pop);
 691       break;
 692
 693     case WGL_DRAW_TO_BITMAP_ARB:
 694       pop = iWGLAttr[++cur];
 695       TRACE("pAttr[%d] = WGL_DRAW_TO_BITMAP_ARB: %d\n", cur, pop);
 696       /* GLX_DRAWABLE_TYPE flags need to be OR'd together. See below. */
 697       if (pop) {
 698         drawattrib |= GLX_PIXMAP_BIT;
 699       }
 700       break;
 701
 702     case WGL_DRAW_TO_WINDOW_ARB:
 703       pop = iWGLAttr[++cur];
 704       TRACE("pAttr[%d] = WGL_DRAW_TO_WINDOW_ARB: %d\n", cur, pop);
 705       /* GLX_DRAWABLE_TYPE flags need to be OR'd together. See below. */
 706       if (pop) {
 707         drawattrib |= GLX_WINDOW_BIT;
 708       }
 709       break;
 710
 711     case WGL_DRAW_TO_PBUFFER_ARB:
 712       pop = iWGLAttr[++cur];
 713       TRACE("pAttr[%d] = WGL_DRAW_TO_PBUFFER_ARB: %d\n", cur, pop);
 714       /* GLX_DRAWABLE_TYPE flags need to be OR'd together. See below. */
 715       if (pop) {
 716         drawattrib |= GLX_PBUFFER_BIT;
 717       }
 718       break;
 719
 720     case WGL_ACCELERATION_ARB:
 721     case WGL_SUPPORT_OPENGL_ARB:
 722       pop = iWGLAttr[++cur];
 723       /** nothing to do, if we are here, supposing support Accelerated OpenGL */
 724       TRACE("pAttr[%d] = WGL_SUPPORT_OPENGL_ARB: %d\n", cur, pop);
 725       break;
 726
 727     case WGL_PBUFFER_LARGEST_ARB:
 728       pop = iWGLAttr[++cur];
 729       PUSH2(oGLXAttr, GLX_LARGEST_PBUFFER, pop);
 730       TRACE("pAttr[%d] = GLX_LARGEST_PBUFFER: %x\n", cur, pop);
 731       break;
 732
 733     case WGL_SAMPLE_BUFFERS_ARB:
 734       pop = iWGLAttr[++cur];
 735       PUSH2(oGLXAttr, GLX_SAMPLE_BUFFERS_ARB, pop);
 736       TRACE("pAttr[%d] = GLX_SAMPLE_BUFFERS_ARB: %x\n", cur, pop);
 737       break;
 738
 739     case WGL_SAMPLES_ARB:
 740       pop = iWGLAttr[++cur];
 741       PUSH2(oGLXAttr, GLX_SAMPLES_ARB, pop);
 742       TRACE("pAttr[%d] = GLX_SAMPLES_ARB: %x\n", cur, pop);
 743       break;
 744
 745     case WGL_TEXTURE_FORMAT_ARB:
 746     case WGL_TEXTURE_TARGET_ARB:
 747     case WGL_MIPMAP_TEXTURE_ARB:
 748       TRACE("WGL_render_texture Attributes: %x as %x\n", iWGLAttr[cur], iWGLAttr[cur + 1]);
 749       pop = iWGLAttr[++cur];
 750       if (NULL == pbuf) {
 751         ERR("trying to use GLX_Pbuffer Attributes without Pbuffer (was %x)\n", iWGLAttr[cur]);
 752       }
 753       if (use_render_texture_ati) {
 754         /** nothing to do here */
 755       }
 756       else if (!use_render_texture_emulation) {
 757         if (WGL_NO_TEXTURE_ARB != pop) {
 758           ERR("trying to use WGL_render_texture Attributes without support (was %x)\n", iWGLAttr[cur]);
 759           return -1; /** error: don't support it */
 760         } else {
 761           PUSH2(oGLXAttr, GLX_X_RENDERABLE, pop);
 762           drawattrib |= GLX_PBUFFER_BIT;
 763         }
 764       }
 765       break ;
 766
 767     case WGL_BIND_TO_TEXTURE_RGB_ARB:
 768     case WGL_BIND_TO_TEXTURE_RGBA_ARB:
 769       pop = iWGLAttr[++cur];
 770       /** cannot be converted, see direct handling on
 771        *   - wglGetPixelFormatAttribivARB
 772        *  TODO: wglChoosePixelFormat
 773        */
 774       break ;
 775
 776     default:
 777       FIXME("unsupported %x WGL Attribute\n", iWGLAttr[cur]);
 778       break;
 779     }
 780     ++cur;
 781   }
 782
 783   /**
 784    * Trick as WGL_COLOR_BITS_ARB != GLX_BUFFER_SIZE
 785    *    WGL_COLOR_BITS_ARB + WGL_ALPHA_BITS_ARB == GLX_BUFFER_SIZE
 786    *
 787    *  WGL_COLOR_BITS_ARB
 788    *     The number of color bitplanes in each color buffer. For RGBA
 789    *     pixel types, it is the size of the color buffer, excluding the
 790    *     alpha bitplanes. For color-index pixels, it is the size of the
 791    *     color index buffer.
 792    *
 793    *  GLX_BUFFER_SIZE
 794    *     This attribute defines the number of bits per color buffer.
 795    *     For GLX FBConfigs that correspond to a PseudoColor or StaticColor visual,
 796    *     this is equal to the depth value reported in the X11 visual.
 797    *     For GLX FBConfigs that correspond to TrueColor or DirectColor visual,
 798    *     this is the sum of GLX_RED_SIZE, GLX_GREEN_SIZE, GLX_BLUE_SIZE, and GLX_ALPHA_SIZE.
 799    *
 800    */
 801   if (0 < wantColorBits) {
 802     if (!isColor) {
 803       wantColorBits += sz_alpha;
 804     }
 805     if (32 < wantColorBits) {
 806       ERR("buggy %d GLX_BUFFER_SIZE default to 32\n", wantColorBits);
 807       wantColorBits = 32;
 808     }
 809     PUSH2(oGLXAttr, GLX_BUFFER_SIZE, wantColorBits);
 810     TRACE("pAttr[%d] = WGL_COLOR_BITS_ARB: %d\n", cur, wantColorBits);
 811   }
 812
 813   /* Apply the OR'd drawable type bitmask now. */
 814   if (drawattrib) {
 815     PUSH2(oGLXAttr, GLX_DRAWABLE_TYPE, drawattrib);
 816     TRACE("pAttr[?] = GLX_DRAWABLE_TYPE: %#x\n", drawattrib);
 817   }
 818
 819   return nAttribs;
 820 }
 821
 822 BOOL get_fbconfig_from_visualid(Display *display, Visual *visual, int *fmt_id, int *fmt_index)
 823 {
 824     GLXFBConfig* cfgs = NULL;
 825     int i;
 826     int nCfgs;
 827     int tmp_fmt_id;
 828     int tmp_vis_id;
 829     VisualID visualid;
 830
 831     if(!display || !display) {
 832         ERR("Invalid display or visual\n");
 833     }
 834     visualid = XVisualIDFromVisual(visual);
 835
 836     /* Get a list of all available framebuffer configurations */
 837     cfgs = pglXGetFBConfigs(display, DefaultScreen(display), &nCfgs);
 838     if (NULL == cfgs || 0 == nCfgs) {
 839         ERR("glXChooseFBConfig returns NULL\n");
 840         if(cfgs != NULL) XFree(cfgs);
 841             return 0;
 842     }
 843
 844     /* Find the requested offscreen format and count the number of offscreen formats */
 845     for(i=0; i<nCfgs; i++) {
 846         pglXGetFBConfigAttrib(display, cfgs[i], GLX_VISUAL_ID, &tmp_vis_id);
 847         pglXGetFBConfigAttrib(display, cfgs[i], GLX_FBCONFIG_ID, &tmp_fmt_id);
 848
 849         /* We are looking up the GLX index of our main visual and have found it :) */
 850         if(visualid == tmp_vis_id) {
 851             TRACE("Found FBCONFIG_ID 0x%x at index %d for VISUAL_ID 0x%x\n", tmp_fmt_id, i, tmp_vis_id);
 852             XFree(cfgs);
 853             *fmt_id = tmp_fmt_id;
 854             *fmt_index = i;
 855             return TRUE;
 856         }
 857     }
 858
 859     ERR("No fbconfig found for Wine's main visual (0x%lx), expect problems!\n", visualid);
 860     XFree(cfgs);
 861     return FALSE;
 862 }
 863
 864 static BOOL init_formats(Display *display, int screen, Visual *visual)
 865 {
 866     int fmt_id, fmt_index;
 867
 868     /* Locate the fbconfig correspondig to our main visual */
 869     if(!get_fbconfig_from_visualid(display, visual, &fmt_id, &fmt_index)) {
 870         ERR("Can't get the FBCONFIG_ID for the main visual, expect problems!\n");
 871         return FALSE;
 872     }
 873
 874     /* Put Wine's internal format at the first index */
 875     WineGLPixelFormatList[0].iPixelFormat = 1;
 876     WineGLPixelFormatList[0].fbconfig = fmt_id;
 877     WineGLPixelFormatList[0].fmt_index = fmt_index;
 878     WineGLPixelFormatListSize = 1;
 879
 880     /* In the future test for compatible formats here */
 881
 882     return TRUE;
 883 }
 884
 885 /* GLX can advertise dozens of different pixelformats including offscreen and onscreen ones.
 886  * In our WGL implementation we only support a subset of these formats namely the format of
 887  * Wine's main visual and offscreen formats (if they are available).
 888  * This function converts a WGL format to its corresponding GLX one. It returns the index (zero-based)
 889  * into the GLX FB config table and it returns the number of supported WGL formats in fmt_count.
 890  */
 891 static BOOL ConvertPixelFormatWGLtoGLX(Display *display, int iPixelFormat, int *fmt_index, int *fmt_count)
 892 {
 893     int ret;
 894
 895     /* Init the list of pixel formats when we need it */
 896     if(!WineGLPixelFormatListSize)
 897         init_formats(display, DefaultScreen(display), visual);
 898
 899     if((iPixelFormat <= 0) || (iPixelFormat > WineGLPixelFormatListSize)) {
 900         ERR("invalid iPixelFormat %d\n", iPixelFormat);
 901         ret = FALSE;
 902         *fmt_index = -1;
 903     }
 904     else {
 905         ret = TRUE;
 906         *fmt_index = WineGLPixelFormatList[iPixelFormat-1].fmt_index;
 907     }
 908
 909     *fmt_count = WineGLPixelFormatListSize;
 910     TRACE("Returning fmt_index=%d, fmt_count=%d for iPixelFormat=%d\n", *fmt_index, *fmt_count, iPixelFormat);
 911
 912     return ret;
 913 }
 914
 915 /* Search our internal pixelformat list for the WGL format corresponding to the given fbconfig */
 916 static int ConvertPixelFormatGLXtoWGL(Display *display, int fbconfig)
 917 {
 918     int i;
 919
 920     /* Init the list of pixel formats when we need it */
 921     if(!WineGLPixelFormatListSize)
 922         init_formats(display, DefaultScreen(display), visual);
 923
 924     for(i=0; i<WineGLPixelFormatListSize; i++) {
 925         if(WineGLPixelFormatList[i].fbconfig == fbconfig) {
 926             TRACE("Returning iPixelFormat %d for fbconfig 0x%x\n", WineGLPixelFormatList[i].iPixelFormat, fbconfig);
 927             return WineGLPixelFormatList[i].iPixelFormat;
 928         }
 929     }
 930     TRACE("No compatible format found for FBCONFIG_ID=0x%x\n", fbconfig);
 931     return 0;
 932 }
 933
 934 /**
 935  * X11DRV_ChoosePixelFormat
 936  *
 937  * Equivalent to glXChooseVisual.
 938  */
 939 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
 940                              const PIXELFORMATDESCRIPTOR *ppfd) {
 941   GLXFBConfig* cfgs = NULL;
 942   int ret = 0;
 943   int nCfgs = 0;
 944   int value = 0;
 945   int fmt_index = 0;
 946
 947   if (!has_opengl()) {
 948     ERR("No libGL on this box - disabling OpenGL support !\n");
 949     return 0;
 950   }
 951
 952   if (TRACE_ON(opengl)) {
 953     TRACE("(%p,%p)\n", physDev, ppfd);
 954
 955     dump_PIXELFORMATDESCRIPTOR((const PIXELFORMATDESCRIPTOR *) ppfd);
 956   }
 957
 958   wine_tsx11_lock();
 959   if(!visual) {
 960     ERR("Can't get an opengl visual!\n");
 961     goto choose_exit;
 962   }
 963
 964   /* Get a list containing all supported FB configurations */
 965   cfgs = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs);
 966   if (NULL == cfgs || 0 == nCfgs) {
 967     ERR("glXGetFBConfigs returns NULL (glError: %d)\n", pglGetError());
 968     goto choose_exit;
 969   }
 970
 971   /* In case an fbconfig was found, check if it matches to the requirements of the ppfd */
 972   if(!ConvertPixelFormatWGLtoGLX(gdi_display, 1 /* main visual */, &fmt_index, &value)) {
 973     ERR("Can't find a matching FBCONFIG_ID for VISUAL_ID 0x%lx!\n", visual->visualid);
 974   } else {
 975     int dwFlags = 0;
 976     int iPixelType = 0;
 977     int value = 0;
 978
 979     /* Pixel type */
 980     pglXGetFBConfigAttrib(gdi_display, cfgs[fmt_index], GLX_RENDER_TYPE, &value);
 981     if (value & GLX_RGBA_BIT)
 982       iPixelType = PFD_TYPE_RGBA;
 983     else
 984       iPixelType = PFD_TYPE_COLORINDEX;
 985
 986     if (ppfd->iPixelType != iPixelType) {
 987       TRACE("pixel type mismatch\n");
 988       goto choose_exit;
 989     }
 990
 991     /* Doublebuffer */
 992     pglXGetFBConfigAttrib(gdi_display, cfgs[fmt_index], GLX_DOUBLEBUFFER, &value); if (value) dwFlags |= PFD_DOUBLEBUFFER;
 993     if (!(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) && (ppfd->dwFlags & PFD_DOUBLEBUFFER)) {
 994       if (!(dwFlags & PFD_DOUBLEBUFFER)) {
 995         TRACE("dbl buffer mismatch\n");
 996         goto choose_exit;
 997       }
 998     }
 999
1000     /* Stereo */
1001     pglXGetFBConfigAttrib(gdi_display, cfgs[fmt_index], GLX_STEREO, &value); if (value) dwFlags |= PFD_STEREO;
1002     if (!(ppfd->dwFlags & PFD_STEREO_DONTCARE) && (ppfd->dwFlags & PFD_STEREO)) {
1003       if (!(dwFlags & PFD_STEREO)) {
1004         TRACE("stereo mismatch\n");
1005         goto choose_exit;
1006       }
1007     }
1008
1009     /* Alpha bits */
1010     pglXGetFBConfigAttrib(gdi_display, cfgs[fmt_index], GLX_ALPHA_SIZE, &value);
1011     if (ppfd->iPixelType==PFD_TYPE_RGBA && ppfd->cAlphaBits && !value) {
1012       TRACE("alpha mismatch\n");
1013       goto choose_exit;
1014     }
1015
1016     /* Depth bits */
1017     pglXGetFBConfigAttrib(gdi_display, cfgs[fmt_index], GLX_DEPTH_SIZE, &value);
1018     if (ppfd->cDepthBits && !value) {
1019       TRACE("depth mismatch\n");
1020       goto choose_exit;
1021     }
1022
1023     /* Stencil bits */
1024     pglXGetFBConfigAttrib(gdi_display, cfgs[fmt_index], GLX_STENCIL_SIZE, &value);
1025     if (ppfd->cStencilBits && !value) {
1026       TRACE("stencil mismatch\n");
1027       goto choose_exit;
1028     }
1029
1030     /* Aux buffers */
1031     pglXGetFBConfigAttrib(gdi_display, cfgs[fmt_index], GLX_AUX_BUFFERS, &value);
1032     if (ppfd->cAuxBuffers && !value) {
1033       TRACE("aux mismatch\n");
1034       goto choose_exit;
1035     }
1036
1037     /* When we pass all the checks we have found a matching format :) */
1038     ret = 1;
1039     TRACE("Successfully found a matching mode, returning index: %d\n", ret);
1040   }
1041
1042 choose_exit:
1043   if(!ret)
1044     TRACE("No matching mode was found returning 0\n");
1045
1046   if (NULL != cfgs) XFree(cfgs);
1047   wine_tsx11_unlock();
1048   return ret;
1049 }
1050
1051 /**
1052  * X11DRV_DescribePixelFormat
1053  *
1054  * Get the pixel-format descriptor associated to the given id
1055  */
1056 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
1057                                int iPixelFormat,
1058                                UINT nBytes,
1059                                PIXELFORMATDESCRIPTOR *ppfd) {
1060   /*XVisualInfo *vis;*/
1061   int value;
1062   int rb,gb,bb,ab;
1063
1064   GLXFBConfig* cfgs = NULL;
1065   GLXFBConfig cur;
1066   int nCfgs = 0;
1067   int ret = 0;
1068   int fmt_count = 0;
1069   int fmt_index = 0;
1070   BOOL res = FALSE;
1071
1072   if (!has_opengl()) {
1073     ERR("No libGL on this box - disabling OpenGL support !\n");
1074     return 0;
1075   }
1076
1077   TRACE("(%p,%d,%d,%p)\n", physDev, iPixelFormat, nBytes, ppfd);
1078
1079   wine_tsx11_lock();
1080   cfgs = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs);
1081   wine_tsx11_unlock();
1082
1083   if (NULL == cfgs || 0 == nCfgs) {
1084     ERR("unexpected iPixelFormat(%d), returns NULL\n", iPixelFormat);
1085     return 0; /* unespected error */
1086   }
1087
1088   /* Look for the iPixelFormat in our list of supported formats. If it is supported we get the index in the FBConfig table and the number of supported formats back */
1089   res = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, &fmt_index, &fmt_count);
1090
1091   if (ppfd == NULL) {
1092       /* The application is only querying the number of visuals */
1093       wine_tsx11_lock();
1094       if (NULL != cfgs) XFree(cfgs);
1095       wine_tsx11_unlock();
1096       return fmt_count;
1097   } else if(res == FALSE) {
1098       WARN("unexpected iPixelFormat(%d): not >=1 and <=nFormats(%d), returning NULL!\n", iPixelFormat, fmt_count);
1099       wine_tsx11_lock();
1100       if (NULL != cfgs) XFree(cfgs);
1101       wine_tsx11_unlock();
1102       return 0;
1103   }
1104
1105   if (nBytes < sizeof(PIXELFORMATDESCRIPTOR)) {
1106     ERR("Wrong structure size !\n");
1107     /* Should set error */
1108     return 0;
1109   }
1110
1111   ret = fmt_count;
1112   cur = cfgs[fmt_index];
1113
1114   memset(ppfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
1115   ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
1116   ppfd->nVersion = 1;
1117
1118   /* These flags are always the same... */
1119   ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
1120   /* Now the flags extracted from the Visual */
1121
1122   wine_tsx11_lock();
1123
1124   pglXGetFBConfigAttrib(gdi_display, cur, GLX_CONFIG_CAVEAT, &value);
1125   if(value == GLX_SLOW_CONFIG)
1126       ppfd->dwFlags |= PFD_GENERIC_ACCELERATED;
1127
1128   pglXGetFBConfigAttrib(gdi_display, cur, GLX_DOUBLEBUFFER, &value); if (value) ppfd->dwFlags |= PFD_DOUBLEBUFFER;
1129   pglXGetFBConfigAttrib(gdi_display, cur, GLX_STEREO, &value); if (value) ppfd->dwFlags |= PFD_STEREO;
1130
1131   /* Pixel type */
1132   pglXGetFBConfigAttrib(gdi_display, cur, GLX_RENDER_TYPE, &value);
1133   if (value & GLX_RGBA_BIT)
1134     ppfd->iPixelType = PFD_TYPE_RGBA;
1135   else
1136     ppfd->iPixelType = PFD_TYPE_COLORINDEX;
1137
1138   /* Color bits */
1139   pglXGetFBConfigAttrib(gdi_display, cur, GLX_BUFFER_SIZE, &value);
1140   ppfd->cColorBits = value;
1141
1142   /* Red, green, blue and alpha bits / shifts */
1143   if (ppfd->iPixelType == PFD_TYPE_RGBA) {
1144     pglXGetFBConfigAttrib(gdi_display, cur, GLX_RED_SIZE, &rb);
1145     pglXGetFBConfigAttrib(gdi_display, cur, GLX_GREEN_SIZE, &gb);
1146     pglXGetFBConfigAttrib(gdi_display, cur, GLX_BLUE_SIZE, &bb);
1147     pglXGetFBConfigAttrib(gdi_display, cur, GLX_ALPHA_SIZE, &ab);
1148
1149     ppfd->cRedBits = rb;
1150     ppfd->cRedShift = gb + bb + ab;
1151     ppfd->cBlueBits = bb;
1152     ppfd->cBlueShift = ab;
1153     ppfd->cGreenBits = gb;
1154     ppfd->cGreenShift = bb + ab;
1155     ppfd->cAlphaBits = ab;
1156     ppfd->cAlphaShift = 0;
1157   } else {
1158     ppfd->cRedBits = 0;
1159     ppfd->cRedShift = 0;
1160     ppfd->cBlueBits = 0;
1161     ppfd->cBlueShift = 0;
1162     ppfd->cGreenBits = 0;
1163     ppfd->cGreenShift = 0;
1164     ppfd->cAlphaBits = 0;
1165     ppfd->cAlphaShift = 0;
1166   }
1167   /* Accums : to do ... */
1168
1169   /* Depth bits */
1170   pglXGetFBConfigAttrib(gdi_display, cur, GLX_DEPTH_SIZE, &value);
1171   ppfd->cDepthBits = value;
1172
1173   /* stencil bits */
1174   pglXGetFBConfigAttrib(gdi_display, cur, GLX_STENCIL_SIZE, &value);
1175   ppfd->cStencilBits = value;
1176
1177   wine_tsx11_unlock();
1178
1179   /* Aux : to do ... */
1180
1181   ppfd->iLayerType = PFD_MAIN_PLANE;
1182
1183   if (TRACE_ON(opengl)) {
1184     dump_PIXELFORMATDESCRIPTOR(ppfd);
1185   }
1186
1187   wine_tsx11_lock();
1188   if (NULL != cfgs) XFree(cfgs);
1189   wine_tsx11_unlock();
1190
1191   return ret;
1192 }
1193
1194 /**
1195  * X11DRV_GetPixelFormat
1196  *
1197  * Get the pixel-format id used by this DC
1198  */
1199 int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
1200   TRACE("(%p): returns %d\n", physDev, physDev->current_pf);
1201
1202   return physDev->current_pf;
1203 }
1204
1205 /**
1206  * X11DRV_SetPixelFormat
1207  *
1208  * Set the pixel-format id used by this DC
1209  */
1210 BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
1211                            int iPixelFormat,
1212                            const PIXELFORMATDESCRIPTOR *ppfd) {
1213   int fmt_index = 0;
1214   int value;
1215
1216   TRACE("(%p,%d,%p)\n", physDev, iPixelFormat, ppfd);
1217
1218   if (!has_opengl()) {
1219     ERR("No libGL on this box - disabling OpenGL support !\n");
1220     return 0;
1221   }
1222
1223   /* Check if iPixelFormat is in our list of supported formats to see if it is supported. */
1224   if(!ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, &fmt_index, &value)) {
1225     ERR("Invalid iPixelFormat: %d\n", iPixelFormat);
1226     return 0;
1227   }
1228
1229   physDev->current_pf = iPixelFormat;
1230
1231   if (TRACE_ON(opengl)) {
1232     int nCfgs_fmt = 0;
1233     GLXFBConfig* cfgs_fmt = NULL;
1234     GLXFBConfig cur_cfg;
1235     int gl_test = 0;
1236
1237     /*
1238      * How to test if hdc current drawable is compatible (visual/FBConfig) ?
1239      *
1240      * in case of root window created HDCs we crash here :(
1241      *
1242     Drawable drawable =  get_drawable( physDev->hdc );
1243     TRACE(" drawable (%p,%p) have :\n", drawable, root_window);
1244     pglXQueryDrawable(gdi_display, drawable, GLX_FBCONFIG_ID, (unsigned int*) &value);
1245     TRACE(" - FBCONFIG_ID as 0x%x\n", tmp);
1246     pglXQueryDrawable(gdi_display, drawable, GLX_VISUAL_ID, (unsigned int*) &value);
1247     TRACE(" - VISUAL_ID as 0x%x\n", tmp);
1248     pglXQueryDrawable(gdi_display, drawable, GLX_WIDTH, (unsigned int*) &value);
1249     TRACE(" - WIDTH as %d\n", tmp);
1250     pglXQueryDrawable(gdi_display, drawable, GLX_HEIGHT, (unsigned int*) &value);
1251     TRACE(" - HEIGHT as %d\n", tmp);
1252     */
1253     cfgs_fmt = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs_fmt);
1254     cur_cfg = cfgs_fmt[fmt_index];
1255     gl_test = pglXGetFBConfigAttrib(gdi_display, cur_cfg, GLX_FBCONFIG_ID, &value);
1256     if (gl_test) {
1257       ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
1258     } else {
1259       TRACE(" FBConfig have :\n");
1260       TRACE(" - FBCONFIG_ID   0x%x\n", value);
1261       pglXGetFBConfigAttrib(gdi_display, cur_cfg, GLX_VISUAL_ID, &value);
1262       TRACE(" - VISUAL_ID     0x%x\n", value);
1263       pglXGetFBConfigAttrib(gdi_display, cur_cfg, GLX_DRAWABLE_TYPE, &value);
1264       TRACE(" - DRAWABLE_TYPE 0x%x\n", value);
1265     }
1266     XFree(cfgs_fmt);
1267   }
1268   return TRUE;
1269 }
1270
1271 /**
1272  * X11DRV_wglCreateContext
1273  *
1274  * For OpenGL32 wglCreateContext.
1275  */
1276 HGLRC X11DRV_wglCreateContext(X11DRV_PDEVICE *physDev)
1277 {
1278     Wine_GLContext *ret;
1279     GLXFBConfig* cfgs_fmt = NULL;
1280     GLXFBConfig cur_cfg;
1281     int hdcPF = physDev->current_pf;
1282     int fmt_count = 0;
1283     int fmt_index = 0;
1284     int nCfgs_fmt = 0;
1285     int value = 0;
1286     int gl_test = 0;
1287     HDC hdc = physDev->hdc;
1288
1289     TRACE("(%p)->(PF:%d)\n", hdc, hdcPF);
1290
1291     if (!has_opengl()) {
1292         ERR("No libGL on this box - disabling OpenGL support !\n");
1293         return 0;
1294     }
1295
1296     /* First, get the visual in use by the X11DRV */
1297     if (!gdi_display) return 0;
1298
1299     /* We can only render using the iPixelFormat (1) of Wine's Main visual, we need to get the corresponding GLX format.
1300     * If this fails something is very wrong on the system. */
1301     if(!ConvertPixelFormatWGLtoGLX(gdi_display, hdcPF, &fmt_index, &fmt_count)) {
1302         ERR("Cannot get FB Config for main iPixelFormat 1, expect problems!\n");
1303         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1304         return NULL;
1305     }
1306
1307     cfgs_fmt = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs_fmt);
1308     if (NULL == cfgs_fmt || 0 == nCfgs_fmt) {
1309         ERR("Cannot get FB Configs, expect problems.\n");
1310         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1311         return NULL;
1312     }
1313
1314     if (fmt_count < hdcPF) {
1315         ERR("(%p): unexpected pixelFormat(%d) > nFormats(%d), returns NULL\n", hdc, hdcPF, fmt_count);
1316         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1317         return NULL;
1318     }
1319
1320     cur_cfg = cfgs_fmt[fmt_index];
1321     gl_test = pglXGetFBConfigAttrib(gdi_display, cur_cfg, GLX_FBCONFIG_ID, &value);
1322     if (gl_test) {
1323         ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
1324         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1325         return NULL;
1326     }
1327     XFree(cfgs_fmt);
1328
1329     /* The context will be allocated in the wglMakeCurrent call */
1330     wine_tsx11_lock();
1331     ret = alloc_context();
1332     wine_tsx11_unlock();
1333     ret->hdc = hdc;
1334     ret->display = gdi_display;
1335     ret->fb_conf = cur_cfg;
1336     /*ret->vis = vis;*/
1337     ret->vis = pglXGetVisualFromFBConfig(gdi_display, cur_cfg);
1338
1339     TRACE(" creating context %p (GL context creation delayed)\n", ret);
1340     return (HGLRC) ret;
1341 }
1342
1343 /**
1344  * X11DRV_wglDeleteContext
1345  *
1346  * For OpenGL32 wglDeleteContext.
1347  */
1348 BOOL X11DRV_wglDeleteContext(HGLRC hglrc)
1349 {
1350     Wine_GLContext *ctx = (Wine_GLContext *) hglrc;
1351     BOOL ret = TRUE;
1352
1353     TRACE("(%p)\n", hglrc);
1354
1355     if (!has_opengl()) {
1356         ERR("No libGL on this box - disabling OpenGL support !\n");
1357         return 0;
1358     }
1359
1360     wine_tsx11_lock();
1361     /* A game (Half Life not to name it) deletes twice the same context,
1362     * so make sure it is valid first */
1363     if (is_valid_context( ctx ))
1364     {
1365         if (ctx->ctx) pglXDestroyContext(ctx->display, ctx->ctx);
1366         free_context(ctx);
1367     }
1368     else
1369     {
1370         WARN("Error deleting context !\n");
1371         SetLastError(ERROR_INVALID_HANDLE);
1372         ret = FALSE;
1373     }
1374     wine_tsx11_unlock();
1375
1376     return ret;
1377 }
1378
1379 /**
1380  * X11DRV_wglGetCurrentReadDCARB
1381  *
1382  * For OpenGL32 wglGetCurrentReadDCARB.
1383  */
1384 static HDC WINAPI X11DRV_wglGetCurrentReadDCARB(void)
1385 {
1386     GLXDrawable gl_d;
1387     HDC ret;
1388
1389     TRACE("()\n");
1390
1391     wine_tsx11_lock();
1392     gl_d = pglXGetCurrentReadDrawable();
1393     ret = get_hdc_from_Drawable(gl_d);
1394     wine_tsx11_unlock();
1395
1396     TRACE(" returning %p (GL drawable %lu)\n", ret, gl_d);
1397     return ret;
1398 }
1399
1400 /**
1401  * X11DRV_wglGetProcAddress
1402  *
1403  * For OpenGL32 wglGetProcAddress.
1404  */
1405 PROC X11DRV_wglGetProcAddress(LPCSTR lpszProc)
1406 {
1407     int i, j;
1408     const WineGLExtension *ext;
1409
1410     int padding = 32 - strlen(lpszProc);
1411     if (padding < 0)
1412         padding = 0;
1413
1414     if (!has_opengl()) {
1415         ERR("No libGL on this box - disabling OpenGL support !\n");
1416         return 0;
1417     }
1418
1419     /* Check the table of WGL extensions to see if we need to return a WGL extension
1420      * or a function pointer to a native OpenGL function. */
1421     if(strncmp(lpszProc, "wgl", 3) != 0) {
1422         return pglXGetProcAddressARB((const GLubyte*)lpszProc);
1423     } else {
1424         TRACE("('%s'):%*s", lpszProc, padding, " ");
1425         for (i = 0; i < WineGLExtensionListSize; ++i) {
1426             ext = WineGLExtensionList[i];
1427             for (j = 0; ext->extEntryPoints[j].funcName; ++j) {
1428                 if (strcmp(ext->extEntryPoints[j].funcName, lpszProc) == 0) {
1429                     TRACE("(%p) - WineGL\n", ext->extEntryPoints[j].funcAddress);
1430                     return ext->extEntryPoints[j].funcAddress;
1431                 }
1432             }
1433         }
1434     }
1435
1436     ERR("(%s) - not found\n", lpszProc);
1437     return NULL;
1438 }
1439
1440
1441 /**
1442  * X11DRV_wglMakeCurrent
1443  *
1444  * For OpenGL32 wglMakeCurrent.
1445  */
1446 BOOL X11DRV_wglMakeCurrent(X11DRV_PDEVICE *physDev, HGLRC hglrc) {
1447     BOOL ret;
1448     HDC hdc = physDev->hdc;
1449     DWORD type = GetObjectType(hdc);
1450
1451     TRACE("(%p,%p)\n", hdc, hglrc);
1452
1453     if (!has_opengl()) {
1454         ERR("No libGL on this box - disabling OpenGL support !\n");
1455         return 0;
1456     }
1457
1458     wine_tsx11_lock();
1459     if (hglrc == NULL) {
1460         ret = pglXMakeCurrent(gdi_display, None, NULL);
1461         NtCurrentTeb()->glContext = NULL;
1462     } else {
1463         Wine_GLContext *ctx = (Wine_GLContext *) hglrc;
1464         Drawable drawable = physDev->drawable;
1465         if (ctx->ctx == NULL) {
1466             /* The describe lines below are for debugging purposes only */
1467             if (TRACE_ON(wgl)) {
1468                 describeDrawable(ctx, drawable);
1469                 describeContext(ctx);
1470             }
1471
1472             /* Create a GLX context using the same visual as chosen earlier in wglCreateContext.
1473              * We are certain that the drawable and context are compatible as we only allow compatible formats.
1474              */
1475             TRACE(" Creating GLX Context\n");
1476             ctx->ctx = pglXCreateContext(ctx->display, ctx->vis, NULL, type == OBJ_MEMDC ? False : True);
1477             TRACE(" created a delayed OpenGL context (%p)\n", ctx->ctx);
1478         }
1479         TRACE(" make current for dis %p, drawable %p, ctx %p\n", ctx->display, (void*) drawable, ctx->ctx);
1480         ret = pglXMakeCurrent(ctx->display, drawable, ctx->ctx);
1481         NtCurrentTeb()->glContext = ctx;
1482         if(ret && type == OBJ_MEMDC)
1483         {
1484             ctx->do_escape = TRUE;
1485             pglDrawBuffer(GL_FRONT_LEFT);
1486         }
1487     }
1488     wine_tsx11_unlock();
1489     TRACE(" returning %s\n", (ret ? "True" : "False"));
1490     return ret;
1491 }
1492
1493 /**
1494  * X11DRV_wglMakeContextCurrentARB
1495  *
1496  * For OpenGL32 wglMakeContextCurrentARB
1497  */
1498 BOOL X11DRV_wglMakeContextCurrentARB(X11DRV_PDEVICE* hDrawDev, X11DRV_PDEVICE* hReadDev, HGLRC hglrc)
1499 {
1500     BOOL ret;
1501     TRACE("(%p,%p,%p)\n", hDrawDev, hReadDev, hglrc);
1502
1503     if (!has_opengl()) {
1504         ERR("No libGL on this box - disabling OpenGL support !\n");
1505         return 0;
1506     }
1507
1508     wine_tsx11_lock();
1509     if (hglrc == NULL) {
1510         ret = pglXMakeCurrent(gdi_display, None, NULL);
1511         NtCurrentTeb()->glContext = NULL;
1512     } else {
1513         if (NULL == pglXMakeContextCurrent) {
1514             ret = FALSE;
1515         } else {
1516             Wine_GLContext *ctx = (Wine_GLContext *) hglrc;
1517             Drawable d_draw = get_glxdrawable(hDrawDev);
1518             Drawable d_read = get_glxdrawable(hReadDev);
1519
1520             if (ctx->ctx == NULL) {
1521                 ctx->ctx = pglXCreateContext(ctx->display, ctx->vis, NULL, GetObjectType(hDrawDev->hdc) == OBJ_MEMDC ? False : True);
1522                 TRACE(" created a delayed OpenGL context (%p)\n", ctx->ctx);
1523             }
1524             ret = pglXMakeContextCurrent(ctx->display, d_draw, d_read, ctx->ctx);
1525             NtCurrentTeb()->glContext = ctx;
1526         }
1527     }
1528     wine_tsx11_unlock();
1529
1530     TRACE(" returning %s\n", (ret ? "True" : "False"));
1531     return ret;
1532 }
1533
1534 /**
1535  * X11DRV_wglShareLists
1536  *
1537  * For OpenGL32 wglShaderLists.
1538  */
1539 BOOL X11DRV_wglShareLists(HGLRC hglrc1, HGLRC hglrc2) {
1540     Wine_GLContext *org  = (Wine_GLContext *) hglrc1;
1541     Wine_GLContext *dest = (Wine_GLContext *) hglrc2;
1542
1543     TRACE("(%p, %p)\n", org, dest);
1544
1545     if (!has_opengl()) {
1546         ERR("No libGL on this box - disabling OpenGL support !\n");
1547         return 0;
1548     }
1549
1550     if (NULL != dest && dest->ctx != NULL) {
1551         ERR("Could not share display lists, context already created !\n");
1552         return FALSE;
1553     } else {
1554         if (org->ctx == NULL) {
1555             wine_tsx11_lock();
1556             describeContext(org);
1557             org->ctx = pglXCreateContext(org->display, org->vis, NULL, GetObjectType(org->hdc) == OBJ_MEMDC ? False : True);
1558             wine_tsx11_unlock();
1559             TRACE(" created a delayed OpenGL context (%p) for Wine context %p\n", org->ctx, org);
1560         }
1561         if (NULL != dest) {
1562             wine_tsx11_lock();
1563             describeContext(dest);
1564             /* Create the destination context with display lists shared */
1565             dest->ctx = pglXCreateContext(org->display, dest->vis, org->ctx, GetObjectType(org->hdc) == OBJ_MEMDC ? False : True);
1566             wine_tsx11_unlock();
1567             TRACE(" created a delayed OpenGL context (%p) for Wine context %p sharing lists with OpenGL ctx %p\n", dest->ctx, dest, org->ctx);
1568             return TRUE;
1569         }
1570     }
1571     return FALSE;
1572 }
1573
1574 static BOOL internal_wglUseFontBitmaps(HDC hdc, DWORD first, DWORD count, DWORD listBase, DWORD (WINAPI *GetGlyphOutline_ptr)(HDC,UINT,UINT,LPGLYPHMETRICS,DWORD,LPVOID,const MAT2*))
1575 {
1576      /* We are running using client-side rendering fonts... */
1577      GLYPHMETRICS gm;
1578      unsigned int glyph;
1579      int size = 0;
1580      void *bitmap = NULL, *gl_bitmap = NULL;
1581      int org_alignment;
1582
1583      wine_tsx11_lock();
1584      pglGetIntegerv(GL_UNPACK_ALIGNMENT, &org_alignment);
1585      pglPixelStorei(GL_UNPACK_ALIGNMENT, 4);
1586      wine_tsx11_unlock();
1587
1588      for (glyph = first; glyph < first + count; glyph++) {
1589          unsigned int needed_size = GetGlyphOutline_ptr(hdc, glyph, GGO_BITMAP, &gm, 0, NULL, NULL);
1590          int height, width_int;
1591
1592          TRACE("Glyph : %3d / List : %d\n", glyph, listBase);
1593          if (needed_size == GDI_ERROR) {
1594              TRACE("  - needed size : %d (GDI_ERROR)\n", needed_size);
1595              goto error;
1596          } else {
1597              TRACE("  - needed size : %d\n", needed_size);
1598          }
1599
1600          if (needed_size > size) {
1601              size = needed_size;
1602              HeapFree(GetProcessHeap(), 0, bitmap);
1603              HeapFree(GetProcessHeap(), 0, gl_bitmap);
1604              bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
1605              gl_bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
1606          }
1607          if (GetGlyphOutline_ptr(hdc, glyph, GGO_BITMAP, &gm, size, bitmap, NULL) == GDI_ERROR) goto error;
1608          if (TRACE_ON(opengl)) {
1609              unsigned int height, width, bitmask;
1610              unsigned char *bitmap_ = (unsigned char *) bitmap;
1611
1612              TRACE("  - bbox : %d x %d\n", gm.gmBlackBoxX, gm.gmBlackBoxY);
1613              TRACE("  - origin : (%d , %d)\n", gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
1614              TRACE("  - increment : %d - %d\n", gm.gmCellIncX, gm.gmCellIncY);
1615              if (needed_size != 0) {
1616                  TRACE("  - bitmap :\n");
1617                  for (height = 0; height < gm.gmBlackBoxY; height++) {
1618                      TRACE("      ");
1619                      for (width = 0, bitmask = 0x80; width < gm.gmBlackBoxX; width++, bitmask >>= 1) {
1620                          if (bitmask == 0) {
1621                              bitmap_ += 1;
1622                              bitmask = 0x80;
1623                          }
1624                          if (*bitmap_ & bitmask)
1625                              TRACE("*");
1626                          else
1627                              TRACE(" ");
1628                      }
1629                      bitmap_ += (4 - ((UINT_PTR)bitmap_ & 0x03));
1630                      TRACE("\n");
1631                  }
1632              }
1633          }
1634
1635          /* In OpenGL, the bitmap is drawn from the bottom to the top... So we need to invert the
1636          * glyph for it to be drawn properly.
1637          */
1638          if (needed_size != 0) {
1639              width_int = (gm.gmBlackBoxX + 31) / 32;
1640              for (height = 0; height < gm.gmBlackBoxY; height++) {
1641                  int width;
1642                  for (width = 0; width < width_int; width++) {
1643                      ((int *) gl_bitmap)[(gm.gmBlackBoxY - height - 1) * width_int + width] =
1644                      ((int *) bitmap)[height * width_int + width];
1645                  }
1646              }
1647          }
1648
1649          wine_tsx11_lock();
1650          pglNewList(listBase++, GL_COMPILE);
1651          if (needed_size != 0) {
1652              pglBitmap(gm.gmBlackBoxX, gm.gmBlackBoxY,
1653                      0 - (int) gm.gmptGlyphOrigin.x, (int) gm.gmBlackBoxY - (int) gm.gmptGlyphOrigin.y,
1654                      gm.gmCellIncX, gm.gmCellIncY,
1655                      gl_bitmap);
1656          } else {
1657              /* This is the case of 'empty' glyphs like the space character */
1658              pglBitmap(0, 0, 0, 0, gm.gmCellIncX, gm.gmCellIncY, NULL);
1659          }
1660          pglEndList();
1661          wine_tsx11_unlock();
1662      }
1663
1664      wine_tsx11_lock();
1665      pglPixelStorei(GL_UNPACK_ALIGNMENT, org_alignment);
1666      wine_tsx11_unlock();
1667
1668      HeapFree(GetProcessHeap(), 0, bitmap);
1669      HeapFree(GetProcessHeap(), 0, gl_bitmap);
1670      return TRUE;
1671
1672   error:
1673      wine_tsx11_lock();
1674      pglPixelStorei(GL_UNPACK_ALIGNMENT, org_alignment);
1675      wine_tsx11_unlock();
1676
1677      HeapFree(GetProcessHeap(), 0, bitmap);
1678      HeapFree(GetProcessHeap(), 0, gl_bitmap);
1679      return FALSE;
1680 }
1681
1682 /**
1683  * X11DRV_wglUseFontBitmapsA
1684  *
1685  * For OpenGL32 wglUseFontBitmapsA.
1686  */
1687 BOOL X11DRV_wglUseFontBitmapsA(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
1688 {
1689      Font fid = physDev->font;
1690
1691      TRACE("(%p, %d, %d, %d) using font %ld\n", physDev->hdc, first, count, listBase, fid);
1692
1693      if (!has_opengl()) {
1694         ERR("No libGL on this box - disabling OpenGL support !\n");
1695         return 0;
1696      }
1697
1698      if (fid == 0) {
1699          return internal_wglUseFontBitmaps(physDev->hdc, first, count, listBase, GetGlyphOutlineA);
1700      }
1701
1702      wine_tsx11_lock();
1703      /* I assume that the glyphs are at the same position for X and for Windows */
1704      pglXUseXFont(fid, first, count, listBase);
1705      wine_tsx11_unlock();
1706      return TRUE;
1707 }
1708
1709 /**
1710  * X11DRV_wglUseFontBitmapsW
1711  *
1712  * For OpenGL32 wglUseFontBitmapsW.
1713  */
1714 BOOL X11DRV_wglUseFontBitmapsW(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
1715 {
1716      Font fid = physDev->font;
1717
1718      TRACE("(%p, %d, %d, %d) using font %ld\n", physDev->hdc, first, count, listBase, fid);
1719
1720      if (!has_opengl()) {
1721         ERR("No libGL on this box - disabling OpenGL support !\n");
1722         return 0;
1723      }
1724
1725      if (fid == 0) {
1726          return internal_wglUseFontBitmaps(physDev->hdc, first, count, listBase, GetGlyphOutlineW);
1727      }
1728
1729      WARN("Using the glX API for the WCHAR variant - some characters may come out incorrectly !\n");
1730
1731      wine_tsx11_lock();
1732      /* I assume that the glyphs are at the same position for X and for Windows */
1733      pglXUseXFont(fid, first, count, listBase);
1734      wine_tsx11_unlock();
1735      return TRUE;
1736 }
1737
1738 /* WGL helper function which handles differences in glGetIntegerv from WGL and GLX */
1739 static void WINAPI X11DRV_wglGetIntegerv(GLenum pname, GLint* params) {
1740     TRACE("pname: 0x%x, params: %p\n", pname, params);
1741     if (pname == GL_DEPTH_BITS) {
1742         GLXContext gl_ctx = pglXGetCurrentContext();
1743         Wine_GLContext* ret = get_context_from_GLXContext(gl_ctx);
1744         /*TRACE("returns Wine Ctx as %p\n", ret);*/
1745         /**
1746         * if we cannot find a Wine Context
1747         * we only have the default wine desktop context,
1748         * so if we have only a 24 depth say we have 32
1749         */
1750         if (NULL == ret && 24 == *params) {
1751             *params = 32;
1752         }
1753         TRACE("returns GL_DEPTH_BITS as '%d'\n", *params);
1754     }
1755     if (pname == GL_ALPHA_BITS) {
1756         GLint tmp;
1757         GLXContext gl_ctx = pglXGetCurrentContext();
1758         Wine_GLContext* ret = get_context_from_GLXContext(gl_ctx);
1759         pglXGetFBConfigAttrib(ret->display, ret->fb_conf, GLX_ALPHA_SIZE, &tmp);
1760         TRACE("returns GL_ALPHA_BITS as '%d'\n", tmp);
1761         *params = tmp;
1762     }
1763 }
1764
1765 /**
1766  * X11DRV_wglGetExtensionsStringARB
1767  *
1768  * WGL_ARB_extensions_string: wglGetExtensionsStringARB
1769  */
1770 static const char * WINAPI X11DRV_wglGetExtensionsStringARB(HDC hdc) {
1771     TRACE("() returning \"%s\"\n", WineGLInfo.wglExtensions);
1772     return WineGLInfo.wglExtensions;
1773 }
1774
1775 /**
1776  * X11DRV_wglCreatePbufferARB
1777  *
1778  * WGL_ARB_pbuffer: wglCreatePbufferARB
1779  */
1780 static HPBUFFERARB WINAPI X11DRV_wglCreatePbufferARB(HDC hdc, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList)
1781 {
1782     Wine_GLPBuffer* object = NULL;
1783     GLXFBConfig* cfgs = NULL;
1784     int nCfgs = 0;
1785     int attribs[256];
1786     unsigned nAttribs = 0;
1787     int fmt_index = 0;
1788
1789     TRACE("(%p, %d, %d, %d, %p)\n", hdc, iPixelFormat, iWidth, iHeight, piAttribList);
1790
1791     if (0 >= iPixelFormat) {
1792         ERR("(%p): unexpected iPixelFormat(%d) <= 0, returns NULL\n", hdc, iPixelFormat);
1793         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1794         return NULL; /* unexpected error */
1795     }
1796
1797     cfgs = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs);
1798
1799     if (NULL == cfgs || 0 == nCfgs) {
1800         ERR("(%p): Cannot get FB Configs for iPixelFormat(%d), returns NULL\n", hdc, iPixelFormat);
1801         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1802         return NULL; /* unexpected error */
1803     }
1804
1805     /* Convert the WGL pixelformat to a GLX format, if it fails then the format is invalid */
1806     if(!ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, &fmt_index, &nCfgs)) {
1807         ERR("(%p): unexpected iPixelFormat(%d) > nFormats(%d), returns NULL\n", hdc, iPixelFormat, nCfgs);
1808         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1809         goto create_failed; /* unexpected error */
1810     }
1811
1812     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(Wine_GLPBuffer));
1813     if (NULL == object) {
1814         SetLastError(ERROR_NO_SYSTEM_RESOURCES);
1815         goto create_failed; /* unexpected error */
1816     }
1817     object->hdc = hdc;
1818     object->display = gdi_display;
1819     object->width = iWidth;
1820     object->height = iHeight;
1821     object->pixelFormat = iPixelFormat;
1822
1823     nAttribs = ConvertAttribWGLtoGLX(piAttribList, attribs, object);
1824     if (-1 == nAttribs) {
1825         WARN("Cannot convert WGL to GLX attributes\n");
1826         goto create_failed;
1827     }
1828     PUSH2(attribs, GLX_PBUFFER_WIDTH,  iWidth);
1829     PUSH2(attribs, GLX_PBUFFER_HEIGHT, iHeight);
1830     while (0 != *piAttribList) {
1831         int attr_v;
1832         switch (*piAttribList) {
1833             case WGL_TEXTURE_FORMAT_ARB: {
1834                 ++piAttribList;
1835                 attr_v = *piAttribList;
1836                 TRACE("WGL_render_texture Attribute: WGL_TEXTURE_FORMAT_ARB as %x\n", attr_v);
1837                 if (use_render_texture_ati) {
1838                     int type = 0;
1839                     switch (attr_v) {
1840                         case WGL_NO_TEXTURE_ARB: type = GLX_NO_TEXTURE_ATI; break ;
1841                         case WGL_TEXTURE_RGB_ARB: type = GLX_TEXTURE_RGB_ATI; break ;
1842                         case WGL_TEXTURE_RGBA_ARB: type = GLX_TEXTURE_RGBA_ATI; break ;
1843                         default:
1844                             SetLastError(ERROR_INVALID_DATA);
1845                             goto create_failed;
1846                     }
1847                     object->use_render_texture = 1;
1848                     PUSH2(attribs, GLX_TEXTURE_FORMAT_ATI, type);
1849                 } else {
1850                     if (WGL_NO_TEXTURE_ARB == attr_v) {
1851                         object->use_render_texture = 0;
1852                     } else {
1853                         if (!use_render_texture_emulation) {
1854                             SetLastError(ERROR_INVALID_DATA);
1855                             goto create_failed;
1856                         }
1857                         switch (attr_v) {
1858                             case WGL_TEXTURE_RGB_ARB:
1859                                 object->use_render_texture = GL_RGB;
1860                                 break;
1861                             case WGL_TEXTURE_RGBA_ARB:
1862                                 object->use_render_texture = GL_RGBA;
1863                                 break;
1864                             default:
1865                                 SetLastError(ERROR_INVALID_DATA);
1866                                 goto create_failed;
1867                         }
1868                     }
1869                 }
1870                 break;
1871             }
1872
1873             case WGL_TEXTURE_TARGET_ARB: {
1874                 ++piAttribList;
1875                 attr_v = *piAttribList;
1876                 TRACE("WGL_render_texture Attribute: WGL_TEXTURE_TARGET_ARB as %x\n", attr_v);
1877                 if (use_render_texture_ati) {
1878                     int type = 0;
1879                     switch (attr_v) {
1880                         case WGL_NO_TEXTURE_ARB: type = GLX_NO_TEXTURE_ATI; break ;
1881                         case WGL_TEXTURE_CUBE_MAP_ARB: type = GLX_TEXTURE_CUBE_MAP_ATI; break ;
1882                         case WGL_TEXTURE_1D_ARB: type = GLX_TEXTURE_1D_ATI; break ;
1883                         case WGL_TEXTURE_2D_ARB: type = GLX_TEXTURE_2D_ATI; break ;
1884                         default:
1885                             SetLastError(ERROR_INVALID_DATA);
1886                             goto create_failed;
1887                     }
1888                     PUSH2(attribs, GLX_TEXTURE_TARGET_ATI, type);
1889                 } else {
1890                     if (WGL_NO_TEXTURE_ARB == attr_v) {
1891                         object->texture_target = 0;
1892                     } else {
1893                         if (!use_render_texture_emulation) {
1894                             SetLastError(ERROR_INVALID_DATA);
1895                             goto create_failed;
1896                         }
1897                         switch (attr_v) {
1898                             case WGL_TEXTURE_CUBE_MAP_ARB: {
1899                                 if (iWidth != iHeight) {
1900                                     SetLastError(ERROR_INVALID_DATA);
1901                                     goto create_failed;
1902                                 }
1903                                 object->texture_target = GL_TEXTURE_CUBE_MAP;
1904                                 object->texture_bind_target = GL_TEXTURE_CUBE_MAP;
1905                                break;
1906                             }
1907                             case WGL_TEXTURE_1D_ARB: {
1908                                 if (1 != iHeight) {
1909                                     SetLastError(ERROR_INVALID_DATA);
1910                                     goto create_failed;
1911                                 }
1912                                 object->texture_target = GL_TEXTURE_1D;
1913                                 object->texture_bind_target = GL_TEXTURE_1D;
1914                                 break;
1915                             }
1916                             case WGL_TEXTURE_2D_ARB: {
1917                                 object->texture_target = GL_TEXTURE_2D;
1918                                 object->texture_bind_target = GL_TEXTURE_2D;
1919                                 break;
1920                             }
1921                             default:
1922                                 SetLastError(ERROR_INVALID_DATA);
1923                                 goto create_failed;
1924                         }
1925                     }
1926                 }
1927                 break;
1928             }
1929
1930             case WGL_MIPMAP_TEXTURE_ARB: {
1931                 ++piAttribList;
1932                 attr_v = *piAttribList;
1933                 TRACE("WGL_render_texture Attribute: WGL_MIPMAP_TEXTURE_ARB as %x\n", attr_v);
1934                 if (use_render_texture_ati) {
1935                     PUSH2(attribs, GLX_MIPMAP_TEXTURE_ATI, attr_v);
1936                 } else {
1937                     if (!use_render_texture_emulation) {
1938                         SetLastError(ERROR_INVALID_DATA);
1939                         goto create_failed;
1940                     }
1941                 }
1942                 break;
1943             }
1944         }
1945         ++piAttribList;
1946     }
1947
1948     PUSH1(attribs, None);
1949     object->drawable = pglXCreatePbuffer(gdi_display, cfgs[fmt_index], attribs);
1950     TRACE("new Pbuffer drawable as %p\n", (void*) object->drawable);
1951     if (!object->drawable) {
1952         SetLastError(ERROR_NO_SYSTEM_RESOURCES);
1953         goto create_failed; /* unexpected error */
1954     }
1955     TRACE("->(%p)\n", object);
1956
1957     /** free list */
1958     XFree(cfgs);
1959     return (HPBUFFERARB) object;
1960
1961 create_failed:
1962     if (NULL != cfgs) XFree(cfgs);
1963     HeapFree(GetProcessHeap(), 0, object);
1964     TRACE("->(FAILED)\n");
1965     return (HPBUFFERARB) NULL;
1966 }
1967
1968 /**
1969  * X11DRV_wglDestroyPbufferARB
1970  *
1971  * WGL_ARB_pbuffer: wglDestroyPbufferARB
1972  */
1973 static GLboolean WINAPI X11DRV_wglDestroyPbufferARB(HPBUFFERARB hPbuffer)
1974 {
1975     Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
1976     TRACE("(%p)\n", hPbuffer);
1977     if (NULL == object) {
1978         SetLastError(ERROR_INVALID_HANDLE);
1979         return GL_FALSE;
1980     }
1981     pglXDestroyPbuffer(object->display, object->drawable);
1982     HeapFree(GetProcessHeap(), 0, object);
1983     return GL_TRUE;
1984 }
1985
1986 /**
1987  * X11DRV_wglGetPbufferDCARB
1988  *
1989  * WGL_ARB_pbuffer: wglGetPbufferDCARB
1990  * The function wglGetPbufferDCARB returns a device context for a pbuffer.
1991  * Gdi32 implements the part of this function which creates a device context.
1992  * This part associates the physDev with the X drawable of the pbuffer.
1993  */
1994 HDC X11DRV_wglGetPbufferDCARB(X11DRV_PDEVICE *physDev, HPBUFFERARB hPbuffer)
1995 {
1996     Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
1997     if (NULL == object) {
1998         SetLastError(ERROR_INVALID_HANDLE);
1999         return NULL;
2000     }
2001
2002     /* The function wglGetPbufferDCARB returns a DC to which the pbuffer can be connected.
2003      * All formats in our pixelformat list are compatible with each other and the main drawable. */
2004     physDev->current_pf = object->pixelFormat;
2005     physDev->drawable = object->drawable;
2006
2007     TRACE("(%p)->(%p)\n", hPbuffer, physDev->hdc);
2008     return physDev->hdc;
2009 }
2010
2011 /**
2012  * X11DRV_wglQueryPbufferARB
2013  *
2014  * WGL_ARB_pbuffer: wglQueryPbufferARB
2015  */
2016 static GLboolean WINAPI X11DRV_wglQueryPbufferARB(HPBUFFERARB hPbuffer, int iAttribute, int *piValue)
2017 {
2018     Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2019     TRACE("(%p, 0x%x, %p)\n", hPbuffer, iAttribute, piValue);
2020     if (NULL == object) {
2021         SetLastError(ERROR_INVALID_HANDLE);
2022         return GL_FALSE;
2023     }
2024     switch (iAttribute) {
2025         case WGL_PBUFFER_WIDTH_ARB:
2026             pglXQueryDrawable(object->display, object->drawable, GLX_WIDTH, (unsigned int*) piValue);
2027             break;
2028         case WGL_PBUFFER_HEIGHT_ARB:
2029             pglXQueryDrawable(object->display, object->drawable, GLX_HEIGHT, (unsigned int*) piValue);
2030             break;
2031
2032         case WGL_PBUFFER_LOST_ARB:
2033             FIXME("unsupported WGL_PBUFFER_LOST_ARB (need glXSelectEvent/GLX_DAMAGED work)\n");
2034             break;
2035
2036         case WGL_TEXTURE_FORMAT_ARB:
2037             if (use_render_texture_ati) {
2038                 unsigned int tmp;
2039                 int type = WGL_NO_TEXTURE_ARB;
2040                 pglXQueryDrawable(object->display, object->drawable, GLX_TEXTURE_FORMAT_ATI, &tmp);
2041                 switch (tmp) {
2042                     case GLX_NO_TEXTURE_ATI: type = WGL_NO_TEXTURE_ARB; break ;
2043                     case GLX_TEXTURE_RGB_ATI: type = WGL_TEXTURE_RGB_ARB; break ;
2044                     case GLX_TEXTURE_RGBA_ATI: type = WGL_TEXTURE_RGBA_ARB; break ;
2045                 }
2046                 *piValue = type;
2047             } else {
2048                 if (!object->use_render_texture) {
2049                     *piValue = WGL_NO_TEXTURE_ARB;
2050                 } else {
2051                     if (!use_render_texture_emulation) {
2052                         SetLastError(ERROR_INVALID_HANDLE);
2053                         return GL_FALSE;
2054                     }
2055                     if (GL_RGBA == object->use_render_texture) {
2056                         *piValue = WGL_TEXTURE_RGBA_ARB;
2057                     } else {
2058                         *piValue = WGL_TEXTURE_RGB_ARB;
2059                     }
2060                 }
2061             }
2062             break;
2063
2064         case WGL_TEXTURE_TARGET_ARB:
2065             if (use_render_texture_ati) {
2066                 unsigned int tmp;
2067                 int type = WGL_NO_TEXTURE_ARB;
2068                 pglXQueryDrawable(object->display, object->drawable, GLX_TEXTURE_TARGET_ATI, &tmp);
2069                 switch (tmp) {
2070                     case GLX_NO_TEXTURE_ATI: type = WGL_NO_TEXTURE_ARB; break ;
2071                     case GLX_TEXTURE_CUBE_MAP_ATI: type = WGL_TEXTURE_CUBE_MAP_ARB; break ;
2072                     case GLX_TEXTURE_1D_ATI: type = WGL_TEXTURE_1D_ARB; break ;
2073                     case GLX_TEXTURE_2D_ATI: type = WGL_TEXTURE_2D_ARB; break ;
2074                 }
2075                 *piValue = type;
2076             } else {
2077             if (!object->texture_target) {
2078                 *piValue = WGL_NO_TEXTURE_ARB;
2079             } else {
2080                 if (!use_render_texture_emulation) {
2081                     SetLastError(ERROR_INVALID_DATA);
2082                     return GL_FALSE;
2083                 }
2084                 switch (object->texture_target) {
2085                     case GL_TEXTURE_1D:       *piValue = WGL_TEXTURE_CUBE_MAP_ARB; break;
2086                     case GL_TEXTURE_2D:       *piValue = WGL_TEXTURE_1D_ARB; break;
2087                     case GL_TEXTURE_CUBE_MAP: *piValue = WGL_TEXTURE_2D_ARB; break;
2088                 }
2089             }
2090         }
2091         break;
2092
2093     case WGL_MIPMAP_TEXTURE_ARB:
2094         if (use_render_texture_ati) {
2095             pglXQueryDrawable(object->display, object->drawable, GLX_MIPMAP_TEXTURE_ATI, (unsigned int*) piValue);
2096         } else {
2097             *piValue = GL_FALSE; /** don't support that */
2098             FIXME("unsupported WGL_ARB_render_texture attribute query for 0x%x\n", iAttribute);
2099         }
2100         break;
2101
2102     default:
2103         FIXME("unexpected attribute %x\n", iAttribute);
2104         break;
2105     }
2106
2107     return GL_TRUE;
2108 }
2109
2110 /**
2111  * X11DRV_wglReleasePbufferDCARB
2112  *
2113  * WGL_ARB_pbuffer: wglReleasePbufferDCARB
2114  */
2115 static int WINAPI X11DRV_wglReleasePbufferDCARB(HPBUFFERARB hPbuffer, HDC hdc)
2116 {
2117     TRACE("(%p, %p)\n", hPbuffer, hdc);
2118     DeleteDC(hdc);
2119     return 0;
2120 }
2121
2122 /**
2123  * X11DRV_wglSetPbufferAttribARB
2124  *
2125  * WGL_ARB_pbuffer: wglSetPbufferAttribARB
2126  */
2127 static GLboolean WINAPI X11DRV_wglSetPbufferAttribARB(HPBUFFERARB hPbuffer, const int *piAttribList)
2128 {
2129     Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2130     WARN("(%p, %p): alpha-testing, report any problem\n", hPbuffer, piAttribList);
2131     if (NULL == object) {
2132         SetLastError(ERROR_INVALID_HANDLE);
2133         return GL_FALSE;
2134     }
2135     if (!object->use_render_texture) {
2136         SetLastError(ERROR_INVALID_HANDLE);
2137         return GL_FALSE;
2138     }
2139     if (!use_render_texture_ati && 1 == use_render_texture_emulation) {
2140         return GL_TRUE;
2141     }
2142     if (NULL != pglXDrawableAttribARB) {
2143         if (use_render_texture_ati) {
2144             FIXME("Need conversion for GLX_ATI_render_texture\n");
2145         }
2146         return pglXDrawableAttribARB(object->display, object->drawable, piAttribList);
2147     }
2148     return GL_FALSE;
2149 }
2150
2151 /**
2152  * X11DRV_wglChoosePixelFormatARB
2153  *
2154  * WGL_ARB_pixel_format: wglChoosePixelFormatARB
2155  */
2156 static GLboolean WINAPI X11DRV_wglChoosePixelFormatARB(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats)
2157 {
2158     int gl_test = 0;
2159     int attribs[256];
2160     int nAttribs = 0;
2161     GLXFBConfig* cfgs = NULL;
2162     int nCfgs = 0;
2163     UINT it;
2164     int fmt_id;
2165
2166     GLXFBConfig* cfgs_fmt = NULL;
2167     int nCfgs_fmt = 0;
2168
2169     int fmt = 0;
2170     int pfmt_it = 0;
2171
2172     TRACE("(%p, %p, %p, %d, %p, %p): hackish\n", hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
2173     if (NULL != pfAttribFList) {
2174         FIXME("unused pfAttribFList\n");
2175     }
2176
2177     nAttribs = ConvertAttribWGLtoGLX(piAttribIList, attribs, NULL);
2178     if (-1 == nAttribs) {
2179         WARN("Cannot convert WGL to GLX attributes\n");
2180         return GL_FALSE;
2181     }
2182     PUSH1(attribs, None);
2183
2184     /* Search for FB configurations matching the requirements in attribs */
2185     cfgs = pglXChooseFBConfig(gdi_display, DefaultScreen(gdi_display), attribs, &nCfgs);
2186     if (NULL == cfgs) {
2187         WARN("Compatible Pixel Format not found\n");
2188         return GL_FALSE;
2189     }
2190
2191     /* Get a list of all FB configurations */
2192     cfgs_fmt = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs_fmt);
2193     if (NULL == cfgs_fmt) {
2194         ERR("Failed to get All FB Configs\n");
2195         XFree(cfgs);
2196         return GL_FALSE;
2197     }
2198
2199     /* Loop through all matching formats and check if they are suitable.
2200     * Note that this function should at max return nMaxFormats different formats */
2201     for (it = 0; pfmt_it < nMaxFormats && it < nCfgs; ++it) {
2202         gl_test = pglXGetFBConfigAttrib(gdi_display, cfgs[it], GLX_FBCONFIG_ID, &fmt_id);
2203         if (gl_test) {
2204             ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
2205             continue;
2206         }
2207
2208         /* Search for the format in our list of compatible formats */
2209         fmt = ConvertPixelFormatGLXtoWGL(gdi_display, fmt_id);
2210         if(!fmt)
2211             continue;
2212
2213         piFormats[pfmt_it] = fmt;
2214         TRACE("at %d/%d found FBCONFIG_ID 0x%x (%d/%d)\n", it + 1, nCfgs, fmt_id, piFormats[pfmt_it], nCfgs_fmt);
2215         pfmt_it++;
2216     }
2217
2218     *nNumFormats = pfmt_it;
2219     /** free list */
2220     XFree(cfgs);
2221     XFree(cfgs_fmt);
2222     return GL_TRUE;
2223 }
2224
2225 /**
2226  * X11DRV_wglGetPixelFormatAttribivARB
2227  *
2228  * WGL_ARB_pixel_format: wglGetPixelFormatAttribivARB
2229  */
2230 static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues)
2231 {
2232     UINT i;
2233     GLXFBConfig* cfgs = NULL;
2234     GLXFBConfig  curCfg = NULL;
2235     int nCfgs = 0;
2236     int hTest;
2237     int tmp;
2238     int curGLXAttr = 0;
2239     int nWGLFormats = 0;
2240     int fmt_index = 0;
2241
2242     TRACE("(%p, %d, %d, %d, %p, %p)\n", hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
2243
2244     if (0 < iLayerPlane) {
2245         FIXME("unsupported iLayerPlane(%d) > 0, returns FALSE\n", iLayerPlane);
2246         return GL_FALSE;
2247     }
2248
2249     cfgs = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs);
2250     if (NULL == cfgs) {
2251         ERR("no FB Configs found for display(%p)\n", gdi_display);
2252         return GL_FALSE;
2253     }
2254
2255     /* Convert the WGL pixelformat to a GLX one, if this fails then most likely the iPixelFormat isn't supoprted.
2256     * We don't have to fail yet as a program can specify an invaled iPixelFormat (lets say 0) if it wants to query
2257     * the number of supported WGL formats. Whether the iPixelFormat is valid is handled in the for-loop below. */
2258     if(!ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, &fmt_index, &nWGLFormats)) {
2259         WARN("Unable to convert iPixelFormat %d to a GLX one!\n", iPixelFormat);
2260     }
2261
2262     for (i = 0; i < nAttributes; ++i) {
2263         const int curWGLAttr = piAttributes[i];
2264         TRACE("pAttr[%d] = %x\n", i, curWGLAttr);
2265
2266         switch (curWGLAttr) {
2267             case WGL_NUMBER_PIXEL_FORMATS_ARB:
2268                 piValues[i] = nWGLFormats;
2269                 continue;
2270
2271             case WGL_SUPPORT_OPENGL_ARB:
2272                 piValues[i] = GL_TRUE;
2273                 continue;
2274
2275             case WGL_ACCELERATION_ARB:
2276                 curGLXAttr = GLX_CONFIG_CAVEAT;
2277
2278                 if (nCfgs < iPixelFormat || 0 >= iPixelFormat) goto pix_error;
2279                     curCfg = cfgs[iPixelFormat - 1];
2280
2281                 hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, curGLXAttr, &tmp);
2282                 if (hTest) goto get_error;
2283                 switch (tmp) {
2284                     case GLX_NONE: piValues[i] = WGL_FULL_ACCELERATION_ARB; break;
2285                     case GLX_SLOW_CONFIG: piValues[i] = WGL_NO_ACCELERATION_ARB; break;
2286                     case GLX_NON_CONFORMANT_CONFIG: piValues[i] = WGL_FULL_ACCELERATION_ARB; break;
2287                     default:
2288                         ERR("unexpected Config Caveat(%x)\n", tmp);
2289                         piValues[i] = WGL_NO_ACCELERATION_ARB;
2290                 }
2291                 continue;
2292
2293             case WGL_TRANSPARENT_ARB:
2294                 curGLXAttr = GLX_TRANSPARENT_TYPE;
2295                     /* Check if the format is supported by checking if iPixelFormat isn't larger than the max number of
2296                      * supported WGLFormats and also check if the GLX fmt_index is valid. */
2297                 if((iPixelFormat > nWGLFormats) || (fmt_index > nCfgs)) goto pix_error;
2298                     curCfg = cfgs[fmt_index];
2299                 hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, curGLXAttr, &tmp);
2300                 if (hTest) goto get_error;
2301                     piValues[i] = GL_FALSE;
2302                 if (GLX_NONE != tmp) piValues[i] = GL_TRUE;
2303                     continue;
2304
2305             case WGL_PIXEL_TYPE_ARB:
2306                 curGLXAttr = GLX_RENDER_TYPE;
2307                 /* Check if the format is supported by checking if iPixelFormat isn't larger than the max number of
2308                 * supported WGLFormats and also check if the GLX fmt_index is valid. */
2309                 if((iPixelFormat > nWGLFormats) || (fmt_index > nCfgs)) goto pix_error;
2310                     curCfg = cfgs[fmt_index];
2311                 hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, curGLXAttr, &tmp);
2312                 if (hTest) goto get_error;
2313                 TRACE("WGL_PIXEL_TYPE_ARB: GLX_RENDER_TYPE = 0x%x\n", tmp);
2314                 if      (tmp & GLX_RGBA_BIT)           { piValues[i] = WGL_TYPE_RGBA_ARB; }
2315                 else if (tmp & GLX_COLOR_INDEX_BIT)    { piValues[i] = WGL_TYPE_COLORINDEX_ARB; }
2316                 else if (tmp & GLX_RGBA_FLOAT_BIT)     { piValues[i] = WGL_TYPE_RGBA_FLOAT_ATI; }
2317                 else if (tmp & GLX_RGBA_FLOAT_ATI_BIT) { piValues[i] = WGL_TYPE_RGBA_FLOAT_ATI; }
2318                 else {
2319                     ERR("unexpected RenderType(%x)\n", tmp);
2320                     piValues[i] = WGL_TYPE_RGBA_ARB;
2321                 }
2322                 continue;
2323
2324             case WGL_COLOR_BITS_ARB:
2325                 /** see ConvertAttribWGLtoGLX for explain */
2326                 /* Check if the format is supported by checking if iPixelFormat isn't larger than the max number of
2327                 * supported WGLFormats and also check if the GLX fmt_index is valid. */
2328                 if((iPixelFormat > nWGLFormats) || (fmt_index > nCfgs)) goto pix_error;
2329                     curCfg = cfgs[fmt_index];
2330                 hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, GLX_BUFFER_SIZE, piValues + i);
2331                 if (hTest) goto get_error;
2332                 TRACE("WGL_COLOR_BITS_ARB: GLX_BUFFER_SIZE = %d\n", piValues[i]);
2333                 hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, GLX_ALPHA_SIZE, &tmp);
2334                 if (hTest) goto get_error;
2335                 TRACE("WGL_COLOR_BITS_ARB: GLX_ALPHA_SIZE = %d\n", tmp);
2336                 piValues[i] = piValues[i] - tmp;
2337                 continue;
2338
2339             case WGL_BIND_TO_TEXTURE_RGB_ARB:
2340                 if (use_render_texture_ati) {
2341                     curGLXAttr = GLX_BIND_TO_TEXTURE_RGB_ATI;
2342                     break;
2343                 }
2344             case WGL_BIND_TO_TEXTURE_RGBA_ARB:
2345                 if (use_render_texture_ati) {
2346                     curGLXAttr = GLX_BIND_TO_TEXTURE_RGBA_ATI;
2347                     break;
2348                 }
2349                 if (!use_render_texture_emulation) {
2350                     piValues[i] = GL_FALSE;
2351                     continue;
2352                 }
2353                 curGLXAttr = GLX_RENDER_TYPE;
2354                 /* Check if the format is supported by checking if iPixelFormat isn't larger than the max number of
2355                  * supported WGLFormats and also check if the GLX fmt_index is valid. */
2356                 if((iPixelFormat > nWGLFormats) || (fmt_index > nCfgs)) goto pix_error;
2357                     curCfg = cfgs[fmt_index];
2358                 hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, curGLXAttr, &tmp);
2359                 if (hTest) goto get_error;
2360                 if (GLX_COLOR_INDEX_BIT == tmp) {
2361                     piValues[i] = GL_FALSE;
2362                     continue;
2363                 }
2364                 hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, GLX_DRAWABLE_TYPE, &tmp);
2365                 if (hTest) goto get_error;
2366                     piValues[i] = (tmp & GLX_PBUFFER_BIT) ? GL_TRUE : GL_FALSE;
2367                 continue;
2368
2369             case WGL_BLUE_BITS_ARB:
2370                 curGLXAttr = GLX_BLUE_SIZE;
2371                 break;
2372             case WGL_RED_BITS_ARB:
2373                 curGLXAttr = GLX_RED_SIZE;
2374                 break;
2375             case WGL_GREEN_BITS_ARB:
2376                 curGLXAttr = GLX_GREEN_SIZE;
2377                 break;
2378             case WGL_ALPHA_BITS_ARB:
2379                 curGLXAttr = GLX_ALPHA_SIZE;
2380                 break;
2381             case WGL_DEPTH_BITS_ARB:
2382                 curGLXAttr = GLX_DEPTH_SIZE;
2383                 break;
2384             case WGL_STENCIL_BITS_ARB:
2385                 curGLXAttr = GLX_STENCIL_SIZE;
2386                 break;
2387             case WGL_DOUBLE_BUFFER_ARB:
2388                 curGLXAttr = GLX_DOUBLEBUFFER;
2389                 break;
2390             case WGL_STEREO_ARB:
2391                 curGLXAttr = GLX_STEREO;
2392                 break;
2393             case WGL_AUX_BUFFERS_ARB:
2394                 curGLXAttr = GLX_AUX_BUFFERS;
2395                 break;
2396             case WGL_SUPPORT_GDI_ARB:
2397             case WGL_DRAW_TO_WINDOW_ARB:
2398             case WGL_DRAW_TO_BITMAP_ARB:
2399                 /* We only supported a limited number of formats right now which are all renderable by X 'GLX_X_RENDERABLE' */
2400                 piValues[i] = GL_TRUE;
2401                 continue;
2402             case WGL_DRAW_TO_PBUFFER_ARB:
2403                 hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, GLX_DRAWABLE_TYPE, &tmp);
2404                 if (hTest) goto get_error;
2405                     piValues[i] = (tmp & GLX_PBUFFER_BIT) ? GL_TRUE : GL_FALSE;
2406                 continue;
2407
2408             case WGL_PBUFFER_LARGEST_ARB:
2409                 curGLXAttr = GLX_LARGEST_PBUFFER;
2410                 break;
2411
2412             case WGL_SAMPLE_BUFFERS_ARB:
2413                 curGLXAttr = GLX_SAMPLE_BUFFERS_ARB;
2414                 break;
2415
2416             case WGL_SAMPLES_ARB:
2417                 curGLXAttr = GLX_SAMPLES_ARB;
2418                 break;
2419
2420             default:
2421                 FIXME("unsupported %x WGL Attribute\n", curWGLAttr);
2422         }
2423
2424         if (0 != curGLXAttr) {
2425             /* Check if the format is supported by checking if iPixelFormat isn't larger than the max number of
2426             * supported WGLFormats and also check if the GLX fmt_index is valid. */
2427             if((iPixelFormat > 0) && ((iPixelFormat > nWGLFormats) || (fmt_index > nCfgs))) goto pix_error;
2428                 curCfg = cfgs[fmt_index];
2429             hTest = pglXGetFBConfigAttrib(gdi_display, curCfg, curGLXAttr, piValues + i);
2430             if (hTest) goto get_error;
2431             curGLXAttr = 0;
2432         } else {
2433             piValues[i] = GL_FALSE;
2434         }
2435     }
2436     return GL_TRUE;
2437
2438 get_error:
2439     ERR("(%p): unexpected failure on GetFBConfigAttrib(%x) returns FALSE\n", hdc, curGLXAttr);
2440     XFree(cfgs);
2441     return GL_FALSE;
2442
2443 pix_error:
2444     ERR("(%p): unexpected iPixelFormat(%d) vs nFormats(%d), returns FALSE\n", hdc, iPixelFormat, nCfgs);
2445     XFree(cfgs);
2446     return GL_FALSE;
2447 }
2448
2449 /**
2450  * X11DRV_wglGetPixelFormatAttribfvARB
2451  *
2452  * WGL_ARB_pixel_format: wglGetPixelFormatAttribfvARB
2453  */
2454 static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribfvARB(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues)
2455 {
2456     int *attr;
2457     int ret;
2458     int i;
2459
2460     TRACE("(%p, %d, %d, %d, %p, %p)\n", hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
2461
2462     /* Allocate a temporary array to store integer values */
2463     attr = HeapAlloc(GetProcessHeap(), 0, nAttributes * sizeof(int));
2464     if (!attr) {
2465         ERR("couldn't allocate %d array\n", nAttributes);
2466         return GL_FALSE;
2467     }
2468
2469     /* Piggy-back on wglGetPixelFormatAttribivARB */
2470     ret = X11DRV_wglGetPixelFormatAttribivARB(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, attr);
2471     if (ret) {
2472         /* Convert integer values to float. Should also check for attributes
2473            that can give decimal values here */
2474         for (i=0; i<nAttributes;i++) {
2475             pfValues[i] = attr[i];
2476         }
2477     }
2478
2479     HeapFree(GetProcessHeap(), 0, attr);
2480     return ret;
2481 }
2482
2483 /**
2484  * X11DRV_wglBindTexImageARB
2485  *
2486  * WGL_ARB_render_texture: wglBindTexImageARB
2487  */
2488 static GLboolean WINAPI X11DRV_wglBindTexImageARB(HPBUFFERARB hPbuffer, int iBuffer)
2489 {
2490     Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2491     TRACE("(%p, %d)\n", hPbuffer, iBuffer);
2492     if (NULL == object) {
2493         SetLastError(ERROR_INVALID_HANDLE);
2494         return GL_FALSE;
2495     }
2496     if (!object->use_render_texture) {
2497         SetLastError(ERROR_INVALID_HANDLE);
2498         return GL_FALSE;
2499     }
2500 /* Disable WGL_ARB_render_texture support until it is implemented properly
2501  * using pbuffers or FBOs */
2502 #if 0
2503     if (!use_render_texture_ati && 1 == use_render_texture_emulation) {
2504         int do_init = 0;
2505         GLint prev_binded_tex;
2506         pglGetIntegerv(object->texture_target, &prev_binded_tex);
2507         if (NULL == object->render_ctx) {
2508             object->render_hdc = X11DRV_wglGetPbufferDCARB(hPbuffer);
2509             /* FIXME: This is routed through gdi32.dll to winex11.drv, replace this with GLX calls */
2510             object->render_ctx = wglCreateContext(object->render_hdc);
2511             do_init = 1;
2512         }
2513         object->prev_hdc = wglGetCurrentDC();
2514         object->prev_ctx = wglGetCurrentContext();
2515         /* FIXME: This is routed through gdi32.dll to winex11.drv, replace this with GLX calls */
2516         wglMakeCurrent(object->render_hdc, object->render_ctx);
2517         /*
2518         if (do_init) {
2519             glBindTexture(object->texture_target, object->texture);
2520             if (GL_RGBA == object->use_render_texture) {
2521                 glTexImage2D(object->texture_target, 0, GL_RGBA8, object->width, object->height, 0, GL_RGBA, GL_FLOAT, NULL);
2522             } else {
2523                 glTexImage2D(object->texture_target, 0, GL_RGB8, object->width, object->height, 0, GL_RGB, GL_FLOAT, NULL);
2524             }
2525         }
2526         */
2527         object->texture = prev_binded_tex;
2528         return GL_TRUE;
2529     }
2530 #endif
2531     if (NULL != pglXBindTexImageARB) {
2532         return pglXBindTexImageARB(object->display, object->drawable, iBuffer);
2533     }
2534     return GL_FALSE;
2535 }
2536
2537 /**
2538  * X11DRV_wglReleaseTexImageARB
2539  *
2540  * WGL_ARB_render_texture: wglReleaseTexImageARB
2541  */
2542 static GLboolean WINAPI X11DRV_wglReleaseTexImageARB(HPBUFFERARB hPbuffer, int iBuffer)
2543 {
2544     Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2545     TRACE("(%p, %d)\n", hPbuffer, iBuffer);
2546     if (NULL == object) {
2547         SetLastError(ERROR_INVALID_HANDLE);
2548         return GL_FALSE;
2549     }
2550     if (!object->use_render_texture) {
2551         SetLastError(ERROR_INVALID_HANDLE);
2552         return GL_FALSE;
2553     }
2554     if (!use_render_texture_ati && 1 == use_render_texture_emulation) {
2555     /*
2556         GLint prev_binded_tex;
2557         glGetIntegerv(object->texture_target, &prev_binded_tex);
2558         if (GL_TEXTURE_1D == object->texture_target) {
2559             glCopyTexSubImage1D(object->texture_target, object->texture_level, 0, 0, 0, object->width);
2560         } else {
2561             glCopyTexSubImage2D(object->texture_target, object->texture_level, 0, 0, 0, 0, object->width,       object->height);
2562         }
2563         glBindTexture(object->texture_target, prev_binded_tex);
2564         SwapBuffers(object->render_hdc);
2565         */
2566         pglBindTexture(object->texture_target, object->texture);
2567         if (GL_TEXTURE_1D == object->texture_target) {
2568             pglCopyTexSubImage1D(object->texture_target, object->texture_level, 0, 0, 0, object->width);
2569         } else {
2570             pglCopyTexSubImage2D(object->texture_target, object->texture_level, 0, 0, 0, 0, object->width, object->height);
2571         }
2572
2573         /* FIXME: This is routed through gdi32.dll to winex11.drv, replace this with GLX calls */
2574         wglMakeCurrent(object->prev_hdc, object->prev_ctx);
2575         return GL_TRUE;
2576     }
2577     if (NULL != pglXReleaseTexImageARB) {
2578         return pglXReleaseTexImageARB(object->display, object->drawable, iBuffer);
2579     }
2580     return GL_FALSE;
2581 }
2582
2583 /**
2584  * X11DRV_wglGetExtensionsStringEXT
2585  *
2586  * WGL_EXT_extensions_string: wglGetExtensionsStringEXT
2587  */
2588 static const char * WINAPI X11DRV_wglGetExtensionsStringEXT(void) {
2589     TRACE("() returning \"%s\"\n", WineGLInfo.wglExtensions);
2590     return WineGLInfo.wglExtensions;
2591 }
2592
2593 /**
2594  * X11DRV_wglGetSwapIntervalEXT
2595  *
2596  * WGL_EXT_swap_control: wglGetSwapIntervalEXT
2597  */
2598 static int WINAPI X11DRV_wglGetSwapIntervalEXT(VOID) {
2599     FIXME("(),stub!\n");
2600     return swap_interval;
2601 }
2602
2603 /**
2604  * X11DRV_wglSwapIntervalEXT
2605  *
2606  * WGL_EXT_swap_control: wglSwapIntervalEXT
2607  */
2608 static BOOL WINAPI X11DRV_wglSwapIntervalEXT(int interval) {
2609     TRACE("(%d)\n", interval);
2610     swap_interval = interval;
2611     if (NULL != pglXSwapIntervalSGI) {
2612         return 0 == pglXSwapIntervalSGI(interval);
2613     }
2614     WARN("(): GLX_SGI_swap_control extension seems not supported\n");
2615     return TRUE;
2616 }
2617
2618 /**
2619  * X11DRV_wglAllocateMemoryNV
2620  *
2621  * WGL_NV_vertex_array_range: wglAllocateMemoryNV
2622  */
2623 static void* WINAPI X11DRV_wglAllocateMemoryNV(GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority) {
2624     TRACE("(%d, %f, %f, %f)\n", size, readfreq, writefreq, priority );
2625     if (pglXAllocateMemoryNV == NULL)
2626         return NULL;
2627
2628     return pglXAllocateMemoryNV(size, readfreq, writefreq, priority);
2629 }
2630
2631 /**
2632  * X11DRV_wglFreeMemoryNV
2633  *
2634  * WGL_NV_vertex_array_range: wglFreeMemoryNV
2635  */
2636 static void WINAPI X11DRV_wglFreeMemoryNV(GLvoid* pointer) {
2637     TRACE("(%p)\n", pointer);
2638     if (pglXFreeMemoryNV == NULL)
2639         return;
2640
2641     pglXFreeMemoryNV(pointer);
2642 }
2643
2644 /**
2645  * glxRequireVersion (internal)
2646  *
2647  * Check if the supported GLX version matches requiredVersion.
2648  */
2649 static BOOL glxRequireVersion(int requiredVersion)
2650 {
2651     /* Both requiredVersion and glXVersion[1] contains the minor GLX version */
2652     if(requiredVersion <= WineGLInfo.glxVersion[1])
2653         return TRUE;
2654
2655     return FALSE;
2656 }
2657
2658 static BOOL glxRequireExtension(const char *requiredExtension)
2659 {
2660     if (strstr(WineGLInfo.glxClientExtensions, requiredExtension) == NULL) {
2661         return FALSE;
2662     }
2663
2664     return TRUE;
2665 }
2666
2667 static BOOL register_extension(const WineGLExtension * ext)
2668 {
2669     int i;
2670
2671     assert( WineGLExtensionListSize < MAX_EXTENSIONS );
2672     WineGLExtensionList[WineGLExtensionListSize++] = ext;
2673
2674     strcat(WineGLInfo.wglExtensions, " ");
2675     strcat(WineGLInfo.wglExtensions, ext->extName);
2676
2677     TRACE("'%s'\n", ext->extName);
2678
2679     for (i = 0; ext->extEntryPoints[i].funcName; ++i)
2680         TRACE("    - '%s'\n", ext->extEntryPoints[i].funcName);
2681
2682     return TRUE;
2683 }
2684
2685 static const WineGLExtension WGL_internal_functions =
2686 {
2687   "",
2688   {
2689     { "wglGetIntegerv", X11DRV_wglGetIntegerv },
2690   }
2691 };
2692
2693
2694 static const WineGLExtension WGL_ARB_extensions_string =
2695 {
2696   "WGL_ARB_extensions_string",
2697   {
2698     { "wglGetExtensionsStringARB", X11DRV_wglGetExtensionsStringARB },
2699   }
2700 };
2701
2702 static const WineGLExtension WGL_ARB_make_current_read =
2703 {
2704   "WGL_ARB_make_current_read",
2705   {
2706     { "wglGetCurrentReadDCARB", X11DRV_wglGetCurrentReadDCARB },
2707     { "wglMakeContextCurrentARB", X11DRV_wglMakeContextCurrentARB },
2708   }
2709 };
2710
2711 static const WineGLExtension WGL_ARB_multisample =
2712 {
2713   "WGL_ARB_multisample",
2714 };
2715
2716 static const WineGLExtension WGL_ARB_pbuffer =
2717 {
2718   "WGL_ARB_pbuffer",
2719   {
2720     { "wglCreatePbufferARB", X11DRV_wglCreatePbufferARB },
2721     { "wglDestroyPbufferARB", X11DRV_wglDestroyPbufferARB },
2722     { "wglGetPbufferDCARB", X11DRV_wglGetPbufferDCARB },
2723     { "wglQueryPbufferARB", X11DRV_wglQueryPbufferARB },
2724     { "wglReleasePbufferDCARB", X11DRV_wglReleasePbufferDCARB },
2725     { "wglSetPbufferAttribARB", X11DRV_wglSetPbufferAttribARB },
2726   }
2727 };
2728
2729 static const WineGLExtension WGL_ARB_pixel_format =
2730 {
2731   "WGL_ARB_pixel_format",
2732   {
2733     { "wglChoosePixelFormatARB", X11DRV_wglChoosePixelFormatARB },
2734     { "wglGetPixelFormatAttribfvARB", X11DRV_wglGetPixelFormatAttribfvARB },
2735     { "wglGetPixelFormatAttribivARB", X11DRV_wglGetPixelFormatAttribivARB },
2736   }
2737 };
2738
2739 static const WineGLExtension WGL_ARB_render_texture =
2740 {
2741   "WGL_ARB_render_texture",
2742   {
2743     { "wglBindTexImageARB", X11DRV_wglBindTexImageARB },
2744     { "wglReleaseTexImageARB", X11DRV_wglReleaseTexImageARB },
2745   }
2746 };
2747
2748 static const WineGLExtension WGL_EXT_extensions_string =
2749 {
2750   "WGL_EXT_extensions_string",
2751   {
2752     { "wglGetExtensionsStringEXT", X11DRV_wglGetExtensionsStringEXT },
2753   }
2754 };
2755
2756 static const WineGLExtension WGL_EXT_swap_control =
2757 {
2758   "WGL_EXT_swap_control",
2759   {
2760     { "wglSwapIntervalEXT", X11DRV_wglSwapIntervalEXT },
2761     { "wglGetSwapIntervalEXT", X11DRV_wglGetSwapIntervalEXT },
2762   }
2763 };
2764
2765 static const WineGLExtension WGL_NV_vertex_array_range =
2766 {
2767   "WGL_NV_vertex_array_range",
2768   {
2769     { "wglAllocateMemoryNV", X11DRV_wglAllocateMemoryNV },
2770     { "wglFreeMemoryNV", X11DRV_wglFreeMemoryNV },
2771   }
2772 };
2773
2774 /**
2775  * X11DRV_WineGL_LoadExtensions
2776  */
2777 static void X11DRV_WineGL_LoadExtensions(void)
2778 {
2779     WineGLInfo.wglExtensions[0] = 0;
2780
2781     /* Load Wine internal functions */
2782     register_extension(&WGL_internal_functions);
2783
2784     /* ARB Extensions */
2785
2786     register_extension(&WGL_ARB_extensions_string);
2787
2788     if (glxRequireVersion(3))
2789         register_extension(&WGL_ARB_make_current_read);
2790
2791     if (glxRequireExtension("GLX_ARB_multisample"))
2792         register_extension(&WGL_ARB_multisample);
2793
2794     if (glxRequireVersion(3) && glxRequireExtension("GLX_SGIX_pbuffer"))
2795         register_extension(&WGL_ARB_pbuffer);
2796
2797     register_extension(&WGL_ARB_pixel_format);
2798
2799     if (glxRequireExtension("GLX_ATI_render_texture") ||
2800         glxRequireExtension("GLX_ARB_render_texture"))
2801         register_extension(&WGL_ARB_render_texture);
2802
2803     /* EXT Extensions */
2804
2805     register_extension(&WGL_EXT_extensions_string);
2806
2807     if (glxRequireExtension("GLX_SGI_swap_control"))
2808         register_extension(&WGL_EXT_swap_control);
2809
2810     /* The OpenGL extension GL_NV_vertex_array_range adds wgl/glX functions which aren't exported as 'real' wgl/glX extensions. */
2811     if(strstr(WineGLInfo.glExtensions, "GL_NV_vertex_array_range") != NULL)
2812         register_extension(&WGL_NV_vertex_array_range);
2813 }
2814
2815
2816 static XID create_glxpixmap(X11DRV_PDEVICE *physDev)
2817 {
2818     GLXPixmap ret;
2819     XVisualInfo *vis;
2820     XVisualInfo template;
2821     int num;
2822
2823     wine_tsx11_lock();
2824
2825     /* Retrieve the visualid from our main visual which is the only visual we can use */
2826     template.visualid =  XVisualIDFromVisual(visual);
2827     vis = XGetVisualInfo(gdi_display, VisualIDMask, &template, &num);
2828
2829     ret = pglXCreateGLXPixmap(gdi_display, vis, physDev->bitmap->pixmap);
2830     XFree(vis);
2831     wine_tsx11_unlock();
2832     TRACE("return %lx\n", ret);
2833     return ret;
2834 }
2835
2836 Drawable get_glxdrawable(X11DRV_PDEVICE *physDev)
2837 {
2838     Drawable ret;
2839
2840     if(physDev->bitmap)
2841     {
2842         if (physDev->bitmap->hbitmap == BITMAP_stock_phys_bitmap.hbitmap)
2843             ret = physDev->drawable; /* PBuffer */
2844         else
2845         {
2846             if(!physDev->bitmap->glxpixmap)
2847                 physDev->bitmap->glxpixmap = create_glxpixmap(physDev);
2848             ret = physDev->bitmap->glxpixmap;
2849         }
2850     }
2851     else
2852         ret = physDev->drawable;
2853     return ret;
2854 }
2855
2856 BOOL destroy_glxpixmap(XID glxpixmap)
2857 {
2858     wine_tsx11_lock();
2859     pglXDestroyGLXPixmap(gdi_display, glxpixmap);
2860     wine_tsx11_unlock();
2861     return TRUE;
2862 }
2863
2864 /**
2865  * X11DRV_SwapBuffers
2866  *
2867  * Swap the buffers of this DC
2868  */
2869 BOOL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev)
2870 {
2871   GLXDrawable drawable;
2872   if (!has_opengl()) {
2873     ERR("No libGL on this box - disabling OpenGL support !\n");
2874     return 0;
2875   }
2876
2877   TRACE_(opengl)("(%p)\n", physDev);
2878
2879   drawable = get_glxdrawable(physDev);
2880   wine_tsx11_lock();
2881   pglXSwapBuffers(gdi_display, drawable);
2882   wine_tsx11_unlock();
2883
2884   /* FPS support */
2885   if (TRACE_ON(fps))
2886   {
2887       static long prev_time, frames;
2888
2889       DWORD time = GetTickCount();
2890       frames++;
2891       /* every 1.5 seconds */
2892       if (time - prev_time > 1500) {
2893           TRACE_(fps)("@ approx %.2ffps\n", 1000.0*frames/(time - prev_time));
2894           prev_time = time;
2895           frames = 0;
2896       }
2897   }
2898
2899   return TRUE;
2900 }
2901
2902 /***********************************************************************
2903  *              X11DRV_setup_opengl_visual
2904  *
2905  * Setup the default visual used for OpenGL and Direct3D, and the desktop
2906  * window (if it exists).  If OpenGL isn't available, the visual is simply
2907  * set to the default visual for the display
2908  */
2909 XVisualInfo *X11DRV_setup_opengl_visual( Display *display )
2910 {
2911     XVisualInfo *visual = NULL;
2912     /* In order to support OpenGL or D3D, we require a double-buffered visual and stencil buffer support, */
2913     int dblBuf[] = {GLX_RGBA,GLX_DEPTH_SIZE, 24, GLX_STENCIL_SIZE, 8, GLX_ALPHA_SIZE, 8, GLX_DOUBLEBUFFER, None};
2914     if (!has_opengl()) return NULL;
2915
2916     wine_tsx11_lock();
2917     visual = pglXChooseVisual(display, DefaultScreen(display), dblBuf);
2918     wine_tsx11_unlock();
2919     if (visual == NULL) {
2920         /* fallback to 16 bits depth, no alpha */
2921         int dblBuf2[] = {GLX_RGBA,GLX_DEPTH_SIZE, 16, GLX_STENCIL_SIZE, 8, GLX_DOUBLEBUFFER, None};
2922         WARN("Failed to get a visual with at least 24 bits depth\n");
2923
2924         wine_tsx11_lock();
2925         visual = pglXChooseVisual(display, DefaultScreen(display), dblBuf2);
2926         wine_tsx11_unlock();
2927         if (visual == NULL) {
2928             /* fallback to no stencil */
2929             int dblBuf2[] = {GLX_RGBA,GLX_DEPTH_SIZE, 16, GLX_DOUBLEBUFFER, None};
2930             WARN("Failed to get a visual with at least 8 bits of stencil\n");
2931
2932             wine_tsx11_lock();
2933             visual = pglXChooseVisual(display, DefaultScreen(display), dblBuf2);
2934             wine_tsx11_unlock();
2935             if (visual == NULL) {
2936                 /* This should only happen if we cannot find a match with a depth size 16 */
2937                 FIXME("Failed to find a suitable visual\n");
2938                 return visual;
2939             }
2940         }
2941     }
2942     TRACE("Visual ID %lx Chosen\n",visual->visualid);
2943     return visual;
2944 }
2945
2946 #else  /* no OpenGL includes */
2947
2948 /***********************************************************************
2949  *              ChoosePixelFormat (X11DRV.@)
2950  */
2951 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
2952                              const PIXELFORMATDESCRIPTOR *ppfd) {
2953   ERR("No OpenGL support compiled in.\n");
2954
2955   return 0;
2956 }
2957
2958 /***********************************************************************
2959  *              DescribePixelFormat (X11DRV.@)
2960  */
2961 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
2962                                int iPixelFormat,
2963                                UINT nBytes,
2964                                PIXELFORMATDESCRIPTOR *ppfd) {
2965   ERR("No OpenGL support compiled in.\n");
2966
2967   return 0;
2968 }
2969
2970 /***********************************************************************
2971  *              GetPixelFormat (X11DRV.@)
2972  */
2973 int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
2974   ERR("No OpenGL support compiled in.\n");
2975
2976   return 0;
2977 }
2978
2979 /***********************************************************************
2980  *              SetPixelFormat (X11DRV.@)
2981  */
2982 BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
2983                            int iPixelFormat,
2984                            const PIXELFORMATDESCRIPTOR *ppfd) {
2985   ERR("No OpenGL support compiled in.\n");
2986
2987   return FALSE;
2988 }
2989
2990 /***********************************************************************
2991  *              SwapBuffers (X11DRV.@)
2992  */
2993 BOOL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev) {
2994   ERR_(opengl)("No OpenGL support compiled in.\n");
2995
2996   return FALSE;
2997 }
2998
2999 /**
3000  * X11DRV_wglCreateContext
3001  *
3002  * For OpenGL32 wglCreateContext.
3003  */
3004 HGLRC X11DRV_wglCreateContext(X11DRV_PDEVICE *physDev) {
3005     ERR_(opengl)("No OpenGL support compiled in.\n");
3006     return NULL;
3007 }
3008
3009 /**
3010  * X11DRV_wglDeleteContext
3011  *
3012  * For OpenGL32 wglDeleteContext.
3013  */
3014 BOOL X11DRV_wglDeleteContext(HGLRC hglrc) {
3015     ERR_(opengl)("No OpenGL support compiled in.\n");
3016     return FALSE;
3017 }
3018
3019 /**
3020  * X11DRV_wglGetProcAddress
3021  *
3022  * For OpenGL32 wglGetProcAddress.
3023  */
3024 PROC X11DRV_wglGetProcAddress(LPCSTR lpszProc) {
3025     ERR_(opengl)("No OpenGL support compiled in.\n");
3026     return NULL;
3027 }
3028
3029 HDC X11DRV_wglGetPbufferDCARB(X11DRV_PDEVICE *hDevice, void *hPbuffer)
3030 {
3031     ERR_(opengl)("No OpenGL support compiled in.\n");
3032     return NULL;
3033 }
3034
3035 BOOL X11DRV_wglMakeContextCurrentARB(X11DRV_PDEVICE* hDrawDev, X11DRV_PDEVICE* hReadDev, HGLRC hglrc) {
3036     ERR_(opengl)("No OpenGL support compiled in.\n");
3037     return FALSE;
3038 }
3039
3040 /**
3041  * X11DRV_wglMakeCurrent
3042  *
3043  * For OpenGL32 wglMakeCurrent.
3044  */
3045 BOOL X11DRV_wglMakeCurrent(X11DRV_PDEVICE *physDev, HGLRC hglrc) {
3046     ERR_(opengl)("No OpenGL support compiled in.\n");
3047     return FALSE;
3048 }
3049
3050 /**
3051  * X11DRV_wglShareLists
3052  *
3053  * For OpenGL32 wglShaderLists.
3054  */
3055 BOOL X11DRV_wglShareLists(HGLRC hglrc1, HGLRC hglrc2) {
3056     ERR_(opengl)("No OpenGL support compiled in.\n");
3057     return FALSE;
3058 }
3059
3060 /**
3061  * X11DRV_wglUseFontBitmapsA
3062  *
3063  * For OpenGL32 wglUseFontBitmapsA.
3064  */
3065 BOOL X11DRV_wglUseFontBitmapsA(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
3066 {
3067     ERR_(opengl)("No OpenGL support compiled in.\n");
3068     return FALSE;
3069 }
3070
3071 /**
3072  * X11DRV_wglUseFontBitmapsW
3073  *
3074  * For OpenGL32 wglUseFontBitmapsW.
3075  */
3076 BOOL X11DRV_wglUseFontBitmapsW(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
3077 {
3078     ERR_(opengl)("No OpenGL support compiled in.\n");
3079     return FALSE;
3080 }
3081
3082 XVisualInfo *X11DRV_setup_opengl_visual( Display *display )
3083 {
3084   return NULL;
3085 }
3086
3087 Drawable get_glxdrawable(X11DRV_PDEVICE *physDev)
3088 {
3089     return 0;
3090 }
3091
3092 BOOL destroy_glxpixmap(XID glxpixmap)
3093 {
3094     return FALSE;
3095 }
3096
3097 #endif /* defined(HAVE_OPENGL) */