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-2009 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 #ifdef HAVE_SYS_SOCKET_H
  33 #include <sys/socket.h>
  34 #endif
  35 #ifdef HAVE_SYS_UN_H
  36 #include <sys/un.h>
  37 #endif
  38
  39 #include "x11drv.h"
  40 #include "winternl.h"
  41 #include "wine/library.h"
  42 #include "wine/debug.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(wgl);
  45 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  46
  47 #ifdef SONAME_LIBGL
  48
  49 #undef APIENTRY
  50 #undef CALLBACK
  51 #undef WINAPI
  52
  53 #ifdef HAVE_GL_GL_H
  54 # include <GL/gl.h>
  55 #endif
  56 #ifdef HAVE_GL_GLX_H
  57 # include <GL/glx.h>
  58 #endif
  59
  60 #include "wine/wgl.h"
  61
  62 #undef APIENTRY
  63 #undef CALLBACK
  64 #undef WINAPI
  65
  66 /* Redefines the constants */
  67 #define CALLBACK    __stdcall
  68 #define WINAPI      __stdcall
  69 #define APIENTRY    WINAPI
  70
  71
  72 WINE_DECLARE_DEBUG_CHANNEL(fps);
  73
  74 typedef struct wine_glextension {
  75     const char *extName;
  76     struct {
  77         const char *funcName;
  78         void *funcAddress;
  79     } extEntryPoints[9];
  80 } WineGLExtension;
  81
  82 struct WineGLInfo {
  83     const char *glVersion;
  84     char *glExtensions;
  85
  86     int glxVersion[2];
  87
  88     const char *glxServerVersion;
  89     const char *glxServerVendor;
  90     const char *glxServerExtensions;
  91
  92     const char *glxClientVersion;
  93     const char *glxClientVendor;
  94     const char *glxClientExtensions;
  95
  96     const char *glxExtensions;
  97
  98     BOOL glxDirect;
  99     char wglExtensions[4096];
 100 };
 101
 102 typedef struct wine_glpixelformat {
 103     int         iPixelFormat;
 104     GLXFBConfig fbconfig;
 105     int         fmt_id;
 106     int         render_type;
 107     BOOL        offscreenOnly;
 108     DWORD       dwFlags; /* We store some PFD_* flags in here for emulated bitmap formats */
 109 } WineGLPixelFormat;
 110
 111 typedef struct wine_glcontext {
 112     HDC hdc;
 113     BOOL do_escape;
 114     BOOL has_been_current;
 115     BOOL sharing;
 116     DWORD tid;
 117     BOOL gl3_context;
 118     XVisualInfo *vis;
 119     WineGLPixelFormat *fmt;
 120     int numAttribs; /* This is needed for delaying wglCreateContextAttribsARB */
 121     int attribList[16]; /* This is needed for delaying wglCreateContextAttribsARB */
 122     GLXContext ctx;
 123     HDC read_hdc;
 124     Drawable drawables[2];
 125     BOOL refresh_drawables;
 126     struct wine_glcontext *next;
 127     struct wine_glcontext *prev;
 128 } Wine_GLContext;
 129
 130 typedef struct wine_glpbuffer {
 131     Drawable   drawable;
 132     Display*   display;
 133     WineGLPixelFormat* fmt;
 134     int        width;
 135     int        height;
 136     int*       attribList;
 137     HDC        hdc;
 138
 139     int        use_render_texture; /* This is also the internal texture format */
 140     int        texture_bind_target;
 141     int        texture_bpp;
 142     GLint      texture_format;
 143     GLuint     texture_target;
 144     GLenum     texture_type;
 145     GLuint     texture;
 146     int        texture_level;
 147 } Wine_GLPBuffer;
 148
 149 static Wine_GLContext *context_list;
 150 static struct WineGLInfo WineGLInfo = { 0 };
 151 static int use_render_texture_emulation = 1;
 152 static int use_render_texture_ati = 0;
 153 static int swap_interval = 1;
 154
 155 #define MAX_EXTENSIONS 16
 156 static const WineGLExtension *WineGLExtensionList[MAX_EXTENSIONS];
 157 static int WineGLExtensionListSize;
 158
 159 static void X11DRV_WineGL_LoadExtensions(void);
 160 static WineGLPixelFormat* ConvertPixelFormatWGLtoGLX(Display *display, int iPixelFormat, BOOL AllowOffscreen, int *fmt_count);
 161 static BOOL glxRequireVersion(int requiredVersion);
 162 static BOOL glxRequireExtension(const char *requiredExtension);
 163
 164 static void dump_PIXELFORMATDESCRIPTOR(const PIXELFORMATDESCRIPTOR *ppfd) {
 165   TRACE("  - size / version : %d / %d\n", ppfd->nSize, ppfd->nVersion);
 166   TRACE("  - dwFlags : ");
 167 #define TEST_AND_DUMP(t,tv) if ((t) & (tv)) TRACE(#tv " ")
 168   TEST_AND_DUMP(ppfd->dwFlags, PFD_DEPTH_DONTCARE);
 169   TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER);
 170   TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER_DONTCARE);
 171   TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_WINDOW);
 172   TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_BITMAP);
 173   TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_ACCELERATED);
 174   TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_FORMAT);
 175   TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_PALETTE);
 176   TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_SYSTEM_PALETTE);
 177   TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO);
 178   TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO_DONTCARE);
 179   TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_GDI);
 180   TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_OPENGL);
 181   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_COPY);
 182   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_EXCHANGE);
 183   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_LAYER_BUFFERS);
 184   /* PFD_SUPPORT_COMPOSITION is new in Vista, it is similar to composition
 185    * under X e.g. COMPOSITE + GLX_EXT_TEXTURE_FROM_PIXMAP. */
 186   TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_COMPOSITION);
 187 #undef TEST_AND_DUMP
 188   TRACE("\n");
 189
 190   TRACE("  - iPixelType : ");
 191   switch (ppfd->iPixelType) {
 192   case PFD_TYPE_RGBA: TRACE("PFD_TYPE_RGBA"); break;
 193   case PFD_TYPE_COLORINDEX: TRACE("PFD_TYPE_COLORINDEX"); break;
 194   }
 195   TRACE("\n");
 196
 197   TRACE("  - Color   : %d\n", ppfd->cColorBits);
 198   TRACE("  - Red     : %d\n", ppfd->cRedBits);
 199   TRACE("  - Green   : %d\n", ppfd->cGreenBits);
 200   TRACE("  - Blue    : %d\n", ppfd->cBlueBits);
 201   TRACE("  - Alpha   : %d\n", ppfd->cAlphaBits);
 202   TRACE("  - Accum   : %d\n", ppfd->cAccumBits);
 203   TRACE("  - Depth   : %d\n", ppfd->cDepthBits);
 204   TRACE("  - Stencil : %d\n", ppfd->cStencilBits);
 205   TRACE("  - Aux     : %d\n", ppfd->cAuxBuffers);
 206
 207   TRACE("  - iLayerType : ");
 208   switch (ppfd->iLayerType) {
 209   case PFD_MAIN_PLANE: TRACE("PFD_MAIN_PLANE"); break;
 210   case PFD_OVERLAY_PLANE: TRACE("PFD_OVERLAY_PLANE"); break;
 211   case (BYTE)PFD_UNDERLAY_PLANE: TRACE("PFD_UNDERLAY_PLANE"); break;
 212   }
 213   TRACE("\n");
 214 }
 215
 216 #define PUSH1(attribs,att)        do { attribs[nAttribs++] = (att); } while (0)
 217 #define PUSH2(attribs,att,value)  do { attribs[nAttribs++] = (att); attribs[nAttribs++] = (value); } while(0)
 218
 219 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
 220 /* GLX 1.0 */
 221 MAKE_FUNCPTR(glXChooseVisual)
 222 MAKE_FUNCPTR(glXCopyContext)
 223 MAKE_FUNCPTR(glXCreateContext)
 224 MAKE_FUNCPTR(glXCreateGLXPixmap)
 225 MAKE_FUNCPTR(glXGetCurrentContext)
 226 MAKE_FUNCPTR(glXGetCurrentDrawable)
 227 MAKE_FUNCPTR(glXDestroyContext)
 228 MAKE_FUNCPTR(glXDestroyGLXPixmap)
 229 MAKE_FUNCPTR(glXGetConfig)
 230 MAKE_FUNCPTR(glXIsDirect)
 231 MAKE_FUNCPTR(glXMakeCurrent)
 232 MAKE_FUNCPTR(glXSwapBuffers)
 233 MAKE_FUNCPTR(glXQueryExtension)
 234 MAKE_FUNCPTR(glXQueryVersion)
 235 MAKE_FUNCPTR(glXUseXFont)
 236
 237 /* GLX 1.1 */
 238 MAKE_FUNCPTR(glXGetClientString)
 239 MAKE_FUNCPTR(glXQueryExtensionsString)
 240 MAKE_FUNCPTR(glXQueryServerString)
 241
 242 /* GLX 1.3 */
 243 MAKE_FUNCPTR(glXGetFBConfigs)
 244 MAKE_FUNCPTR(glXChooseFBConfig)
 245 MAKE_FUNCPTR(glXCreatePbuffer)
 246 MAKE_FUNCPTR(glXCreateNewContext)
 247 MAKE_FUNCPTR(glXDestroyPbuffer)
 248 MAKE_FUNCPTR(glXGetFBConfigAttrib)
 249 MAKE_FUNCPTR(glXGetVisualFromFBConfig)
 250 MAKE_FUNCPTR(glXMakeContextCurrent)
 251 MAKE_FUNCPTR(glXQueryDrawable)
 252 MAKE_FUNCPTR(glXGetCurrentReadDrawable)
 253
 254 /* GLX Extensions */
 255 static GLXContext (*pglXCreateContextAttribsARB)(Display *dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list);
 256 static void* (*pglXGetProcAddressARB)(const GLubyte *);
 257 static int   (*pglXSwapIntervalSGI)(int);
 258
 259 /* ATI GLX Extensions */
 260 static BOOL  (*pglXBindTexImageATI)(Display *dpy, GLXPbuffer pbuffer, int buffer);
 261 static BOOL  (*pglXReleaseTexImageATI)(Display *dpy, GLXPbuffer pbuffer, int buffer);
 262 static BOOL  (*pglXDrawableAttribATI)(Display *dpy, GLXDrawable draw, const int *attribList);
 263
 264 /* NV GLX Extension */
 265 static void* (*pglXAllocateMemoryNV)(GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority);
 266 static void  (*pglXFreeMemoryNV)(GLvoid *pointer);
 267
 268 /* MESA GLX Extensions */
 269 static void (*pglXCopySubBufferMESA)(Display *dpy, GLXDrawable drawable, int x, int y, int width, int height);
 270
 271 /* Standard OpenGL */
 272 MAKE_FUNCPTR(glBindTexture)
 273 MAKE_FUNCPTR(glBitmap)
 274 MAKE_FUNCPTR(glCopyTexSubImage1D)
 275 MAKE_FUNCPTR(glCopyTexImage2D)
 276 MAKE_FUNCPTR(glCopyTexSubImage2D)
 277 MAKE_FUNCPTR(glDrawBuffer)
 278 MAKE_FUNCPTR(glEndList)
 279 MAKE_FUNCPTR(glGetError)
 280 MAKE_FUNCPTR(glGetIntegerv)
 281 MAKE_FUNCPTR(glGetString)
 282 MAKE_FUNCPTR(glNewList)
 283 MAKE_FUNCPTR(glPixelStorei)
 284 MAKE_FUNCPTR(glReadPixels)
 285 MAKE_FUNCPTR(glTexImage2D)
 286 MAKE_FUNCPTR(glFinish)
 287 MAKE_FUNCPTR(glFlush)
 288 #undef MAKE_FUNCPTR
 289
 290 static int GLXErrorHandler(Display *dpy, XErrorEvent *event, void *arg)
 291 {
 292     /* In the future we might want to find the exact X or GLX error to report back to the app */
 293     return 1;
 294 }
 295
 296 static BOOL infoInitialized = FALSE;
 297 static BOOL X11DRV_WineGL_InitOpenglInfo(void)
 298 {
 299     int screen = DefaultScreen(gdi_display);
 300     Window win = 0, root = 0;
 301     const char* str;
 302     XVisualInfo *vis;
 303     GLXContext ctx = NULL;
 304     XSetWindowAttributes attr;
 305     BOOL ret = FALSE;
 306     int attribList[] = {GLX_RGBA, GLX_DOUBLEBUFFER, None};
 307
 308     if (infoInitialized)
 309         return TRUE;
 310     infoInitialized = TRUE;
 311
 312     attr.override_redirect = True;
 313     attr.colormap = None;
 314     attr.border_pixel = 0;
 315
 316     wine_tsx11_lock();
 317
 318     vis = pglXChooseVisual(gdi_display, screen, attribList);
 319     if (vis) {
 320 #ifdef __i386__
 321         WORD old_fs = wine_get_fs();
 322         /* Create a GLX Context. Without one we can't query GL information */
 323         ctx = pglXCreateContext(gdi_display, vis, None, GL_TRUE);
 324         if (wine_get_fs() != old_fs)
 325         {
 326             wine_set_fs( old_fs );
 327             ERR( "%%fs register corrupted, probably broken ATI driver, disabling OpenGL.\n" );
 328             ERR( "You need to set the \"UseFastTls\" option to \"2\" in your X config file.\n" );
 329             goto done;
 330         }
 331 #else
 332         ctx = pglXCreateContext(gdi_display, vis, None, GL_TRUE);
 333 #endif
 334     }
 335     if (!ctx) goto done;
 336
 337     root = RootWindow( gdi_display, vis->screen );
 338     if (vis->visual != DefaultVisual( gdi_display, vis->screen ))
 339         attr.colormap = XCreateColormap( gdi_display, root, vis->visual, AllocNone );
 340     if ((win = XCreateWindow( gdi_display, root, -1, -1, 1, 1, 0, vis->depth, InputOutput,
 341                               vis->visual, CWBorderPixel | CWOverrideRedirect | CWColormap, &attr )))
 342         XMapWindow( gdi_display, win );
 343     else
 344         win = root;
 345
 346     pglXMakeCurrent(gdi_display, win, ctx);
 347
 348     WineGLInfo.glVersion = (const char *) pglGetString(GL_VERSION);
 349     str = (const char *) pglGetString(GL_EXTENSIONS);
 350     WineGLInfo.glExtensions = HeapAlloc(GetProcessHeap(), 0, strlen(str)+1);
 351     strcpy(WineGLInfo.glExtensions, str);
 352
 353     /* Get the common GLX version supported by GLX client and server ( major/minor) */
 354     pglXQueryVersion(gdi_display, &WineGLInfo.glxVersion[0], &WineGLInfo.glxVersion[1]);
 355
 356     WineGLInfo.glxServerVersion = pglXQueryServerString(gdi_display, screen, GLX_VERSION);
 357     WineGLInfo.glxServerVendor = pglXQueryServerString(gdi_display, screen, GLX_VENDOR);
 358     WineGLInfo.glxServerExtensions = pglXQueryServerString(gdi_display, screen, GLX_EXTENSIONS);
 359
 360     WineGLInfo.glxClientVersion = pglXGetClientString(gdi_display, GLX_VERSION);
 361     WineGLInfo.glxClientVendor = pglXGetClientString(gdi_display, GLX_VENDOR);
 362     WineGLInfo.glxClientExtensions = pglXGetClientString(gdi_display, GLX_EXTENSIONS);
 363
 364     WineGLInfo.glxExtensions = pglXQueryExtensionsString(gdi_display, screen);
 365     WineGLInfo.glxDirect = pglXIsDirect(gdi_display, ctx);
 366
 367     TRACE("GL version             : %s.\n", WineGLInfo.glVersion);
 368     TRACE("GL renderer            : %s.\n", pglGetString(GL_RENDERER));
 369     TRACE("GLX version            : %d.%d.\n", WineGLInfo.glxVersion[0], WineGLInfo.glxVersion[1]);
 370     TRACE("Server GLX version     : %s.\n", WineGLInfo.glxServerVersion);
 371     TRACE("Server GLX vendor:     : %s.\n", WineGLInfo.glxServerVendor);
 372     TRACE("Client GLX version     : %s.\n", WineGLInfo.glxClientVersion);
 373     TRACE("Client GLX vendor:     : %s.\n", WineGLInfo.glxClientVendor);
 374     TRACE("Direct rendering enabled: %s\n", WineGLInfo.glxDirect ? "True" : "False");
 375
 376     if(!WineGLInfo.glxDirect)
 377     {
 378         int fd = ConnectionNumber(gdi_display);
 379         struct sockaddr_un uaddr;
 380         unsigned int uaddrlen = sizeof(struct sockaddr_un);
 381
 382         /* In general indirect rendering on a local X11 server indicates a driver problem.
 383          * Detect a local X11 server by checking whether the X11 socket is a Unix socket.
 384          */
 385         if(!getsockname(fd, (struct sockaddr *)&uaddr, &uaddrlen) && uaddr.sun_family == AF_UNIX)
 386             ERR_(winediag)("Direct rendering is disabled, most likely your OpenGL drivers haven't been installed correctly\n");
 387     }
 388     else
 389     {
 390         /* In general you would expect that if direct rendering is returned, that you receive hardware
 391          * accelerated OpenGL rendering. The definition of direct rendering is that rendering is performed
 392          * client side without sending all GL commands to X using the GLX protocol. When Mesa falls back to
 393          * software rendering, it shows direct rendering.
 394          *
 395          * Depending on the cause of software rendering a different rendering string is shown. In case Mesa fails
 396          * to load a DRI module 'Software Rasterizer' is returned. When Mesa is compiled as a OpenGL reference driver
 397          * it shows 'Mesa X11'.
 398          */
 399         const char *gl_renderer = (const char *)pglGetString(GL_RENDERER);
 400         if(!strcmp(gl_renderer, "Software Rasterizer") || !strcmp(gl_renderer, "Mesa X11"))
 401             ERR_(winediag)("The Mesa OpenGL driver is using software rendering, most likely your OpenGL drivers haven't been installed correctly\n");
 402     }
 403     ret = TRUE;
 404
 405 done:
 406     if(vis) XFree(vis);
 407     if(ctx) {
 408         pglXMakeCurrent(gdi_display, None, NULL);
 409         pglXDestroyContext(gdi_display, ctx);
 410     }
 411     if (win != root) XDestroyWindow( gdi_display, win );
 412     if (attr.colormap) XFreeColormap( gdi_display, attr.colormap );
 413     wine_tsx11_unlock();
 414     if (!ret) ERR(" couldn't initialize OpenGL, expect problems\n");
 415     return ret;
 416 }
 417
 418 void X11DRV_OpenGL_Cleanup(void)
 419 {
 420     HeapFree(GetProcessHeap(), 0, WineGLInfo.glExtensions);
 421     infoInitialized = FALSE;
 422 }
 423
 424 static BOOL has_opengl(void)
 425 {
 426     static int init_done;
 427     static void *opengl_handle;
 428
 429     char buffer[200];
 430     int error_base, event_base;
 431
 432     if (init_done) return (opengl_handle != NULL);
 433     init_done = 1;
 434
 435     /* No need to load any other libraries as according to the ABI, libGL should be self-sufficient
 436        and include all dependencies */
 437     opengl_handle = wine_dlopen(SONAME_LIBGL, RTLD_NOW|RTLD_GLOBAL, buffer, sizeof(buffer));
 438     if (opengl_handle == NULL)
 439     {
 440         ERR( "Failed to load libGL: %s\n", buffer );
 441         ERR( "OpenGL support is disabled.\n");
 442         return FALSE;
 443     }
 444
 445     pglXGetProcAddressARB = wine_dlsym(opengl_handle, "glXGetProcAddressARB", NULL, 0);
 446     if (pglXGetProcAddressARB == NULL) {
 447         ERR("Could not find glXGetProcAddressARB in libGL, disabling OpenGL.\n");
 448         goto failed;
 449     }
 450
 451 #define LOAD_FUNCPTR(f) do if((p##f = (void*)pglXGetProcAddressARB((const unsigned char*)#f)) == NULL) \
 452     { \
 453         ERR( "%s not found in libGL, disabling OpenGL.\n", #f ); \
 454         goto failed; \
 455     } while(0)
 456
 457     /* GLX 1.0 */
 458     LOAD_FUNCPTR(glXChooseVisual);
 459     LOAD_FUNCPTR(glXCopyContext);
 460     LOAD_FUNCPTR(glXCreateContext);
 461     LOAD_FUNCPTR(glXCreateGLXPixmap);
 462     LOAD_FUNCPTR(glXGetCurrentContext);
 463     LOAD_FUNCPTR(glXGetCurrentDrawable);
 464     LOAD_FUNCPTR(glXDestroyContext);
 465     LOAD_FUNCPTR(glXDestroyGLXPixmap);
 466     LOAD_FUNCPTR(glXGetConfig);
 467     LOAD_FUNCPTR(glXIsDirect);
 468     LOAD_FUNCPTR(glXMakeCurrent);
 469     LOAD_FUNCPTR(glXSwapBuffers);
 470     LOAD_FUNCPTR(glXQueryExtension);
 471     LOAD_FUNCPTR(glXQueryVersion);
 472     LOAD_FUNCPTR(glXUseXFont);
 473
 474     /* GLX 1.1 */
 475     LOAD_FUNCPTR(glXGetClientString);
 476     LOAD_FUNCPTR(glXQueryExtensionsString);
 477     LOAD_FUNCPTR(glXQueryServerString);
 478
 479     /* GLX 1.3 */
 480     LOAD_FUNCPTR(glXCreatePbuffer);
 481     LOAD_FUNCPTR(glXCreateNewContext);
 482     LOAD_FUNCPTR(glXDestroyPbuffer);
 483     LOAD_FUNCPTR(glXMakeContextCurrent);
 484     LOAD_FUNCPTR(glXGetCurrentReadDrawable);
 485     LOAD_FUNCPTR(glXGetFBConfigs);
 486
 487     /* Standard OpenGL calls */
 488     LOAD_FUNCPTR(glBindTexture);
 489     LOAD_FUNCPTR(glBitmap);
 490     LOAD_FUNCPTR(glCopyTexSubImage1D);
 491     LOAD_FUNCPTR(glCopyTexImage2D);
 492     LOAD_FUNCPTR(glCopyTexSubImage2D);
 493     LOAD_FUNCPTR(glDrawBuffer);
 494     LOAD_FUNCPTR(glEndList);
 495     LOAD_FUNCPTR(glGetError);
 496     LOAD_FUNCPTR(glGetIntegerv);
 497     LOAD_FUNCPTR(glGetString);
 498     LOAD_FUNCPTR(glNewList);
 499     LOAD_FUNCPTR(glPixelStorei);
 500     LOAD_FUNCPTR(glReadPixels);
 501     LOAD_FUNCPTR(glTexImage2D);
 502     LOAD_FUNCPTR(glFinish);
 503     LOAD_FUNCPTR(glFlush);
 504 #undef LOAD_FUNCPTR
 505
 506 /* It doesn't matter if these fail. They'll only be used if the driver reports
 507    the associated extension is available (and if a driver reports the extension
 508    is available but fails to provide the functions, it's quite broken) */
 509 #define LOAD_FUNCPTR(f) p##f = pglXGetProcAddressARB((const GLubyte *)#f)
 510     /* ARB GLX Extension */
 511     LOAD_FUNCPTR(glXCreateContextAttribsARB);
 512     /* SGI GLX Extension */
 513     LOAD_FUNCPTR(glXSwapIntervalSGI);
 514     /* NV GLX Extension */
 515     LOAD_FUNCPTR(glXAllocateMemoryNV);
 516     LOAD_FUNCPTR(glXFreeMemoryNV);
 517 #undef LOAD_FUNCPTR
 518
 519     if(!X11DRV_WineGL_InitOpenglInfo()) goto failed;
 520
 521     wine_tsx11_lock();
 522     if (pglXQueryExtension(gdi_display, &error_base, &event_base)) {
 523         TRACE("GLX is up and running error_base = %d\n", error_base);
 524     } else {
 525         wine_tsx11_unlock();
 526         ERR( "GLX extension is missing, disabling OpenGL.\n" );
 527         goto failed;
 528     }
 529
 530     /* In case of GLX you have direct and indirect rendering. Most of the time direct rendering is used
 531      * as in general only that is hardware accelerated. In some cases like in case of remote X indirect
 532      * rendering is used.
 533      *
 534      * The main problem for our OpenGL code is that we need certain GLX calls but their presence
 535      * depends on the reported GLX client / server version and on the client / server extension list.
 536      * Those don't have to be the same.
 537      *
 538      * In general the server GLX information lists the capabilities in case of indirect rendering.
 539      * When direct rendering is used, the OpenGL client library is responsible for which GLX calls are
 540      * available and in that case the client GLX informat can be used.
 541      * OpenGL programs should use the 'intersection' of both sets of information which is advertised
 542      * in the GLX version/extension list. When a program does this it works for certain for both
 543      * direct and indirect rendering.
 544      *
 545      * The problem we are having in this area is that ATI's Linux drivers are broken. For some reason
 546      * they haven't added some very important GLX extensions like GLX_SGIX_fbconfig to their client
 547      * extension list which causes this extension not to be listed. (Wine requires this extension).
 548      * ATI advertises a GLX client version of 1.3 which implies that this fbconfig extension among
 549      * pbuffers is around.
 550      *
 551      * In order to provide users of Ati's proprietary drivers with OpenGL support, we need to detect
 552      * the ATI drivers and from then on use GLX client information for them.
 553      */
 554
 555     if(glxRequireVersion(3)) {
 556         pglXChooseFBConfig = pglXGetProcAddressARB((const GLubyte *) "glXChooseFBConfig");
 557         pglXGetFBConfigAttrib = pglXGetProcAddressARB((const GLubyte *) "glXGetFBConfigAttrib");
 558         pglXGetVisualFromFBConfig = pglXGetProcAddressARB((const GLubyte *) "glXGetVisualFromFBConfig");
 559         pglXQueryDrawable = pglXGetProcAddressARB((const GLubyte *) "glXQueryDrawable");
 560     } else if(glxRequireExtension("GLX_SGIX_fbconfig")) {
 561         pglXChooseFBConfig = pglXGetProcAddressARB((const GLubyte *) "glXChooseFBConfigSGIX");
 562         pglXGetFBConfigAttrib = pglXGetProcAddressARB((const GLubyte *) "glXGetFBConfigAttribSGIX");
 563         pglXGetVisualFromFBConfig = pglXGetProcAddressARB((const GLubyte *) "glXGetVisualFromFBConfigSGIX");
 564
 565         /* The mesa libGL client library seems to forward glXQueryDrawable to the Xserver, so only
 566          * enable this function when the Xserver understand GLX 1.3 or newer
 567          */
 568         pglXQueryDrawable = NULL;
 569      } else if(strcmp("ATI", WineGLInfo.glxClientVendor) == 0) {
 570         TRACE("Overriding ATI GLX capabilities!\n");
 571         pglXChooseFBConfig = pglXGetProcAddressARB((const GLubyte *) "glXChooseFBConfig");
 572         pglXGetFBConfigAttrib = pglXGetProcAddressARB((const GLubyte *) "glXGetFBConfigAttrib");
 573         pglXGetVisualFromFBConfig = pglXGetProcAddressARB((const GLubyte *) "glXGetVisualFromFBConfig");
 574         pglXQueryDrawable = pglXGetProcAddressARB((const GLubyte *) "glXQueryDrawable");
 575
 576         /* Use client GLX information in case of the ATI drivers. We override the
 577          * capabilities over here and not somewhere else as ATI might better their
 578          * life in the future. In case they release proper drivers this block of
 579          * code won't be called. */
 580         WineGLInfo.glxExtensions = WineGLInfo.glxClientExtensions;
 581     } else {
 582          ERR(" glx_version is %s and GLX_SGIX_fbconfig extension is unsupported. Expect problems.\n", WineGLInfo.glxServerVersion);
 583     }
 584
 585     if(glxRequireExtension("GLX_ATI_render_texture")) {
 586         use_render_texture_ati = 1;
 587         pglXBindTexImageATI = pglXGetProcAddressARB((const GLubyte *) "glXBindTexImageATI");
 588         pglXReleaseTexImageATI = pglXGetProcAddressARB((const GLubyte *) "glXReleaseTexImageATI");
 589         pglXDrawableAttribATI = pglXGetProcAddressARB((const GLubyte *) "glXDrawableAttribATI");
 590     }
 591
 592     if(glxRequireExtension("GLX_MESA_copy_sub_buffer")) {
 593         pglXCopySubBufferMESA = pglXGetProcAddressARB((const GLubyte *) "glXCopySubBufferMESA");
 594     }
 595
 596     X11DRV_WineGL_LoadExtensions();
 597
 598     wine_tsx11_unlock();
 599     return TRUE;
 600
 601 failed:
 602     wine_dlclose(opengl_handle, NULL, 0);
 603     opengl_handle = NULL;
 604     return FALSE;
 605 }
 606
 607 static inline Wine_GLContext *alloc_context(void)
 608 {
 609     Wine_GLContext *ret;
 610
 611     if ((ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(Wine_GLContext))))
 612     {
 613         ret->next = context_list;
 614         if (context_list) context_list->prev = ret;
 615         context_list = ret;
 616     }
 617     return ret;
 618 }
 619
 620 static inline void free_context(Wine_GLContext *context)
 621 {
 622     if (context->next != NULL) context->next->prev = context->prev;
 623     if (context->prev != NULL) context->prev->next = context->next;
 624     else context_list = context->next;
 625
 626     if (context->vis) XFree(context->vis);
 627     HeapFree(GetProcessHeap(), 0, context);
 628 }
 629
 630 static inline BOOL is_valid_context( Wine_GLContext *ctx )
 631 {
 632     Wine_GLContext *ptr;
 633     for (ptr = context_list; ptr; ptr = ptr->next) if (ptr == ctx) break;
 634     return (ptr != NULL);
 635 }
 636
 637 static int describeContext(Wine_GLContext* ctx) {
 638     int tmp;
 639     int ctx_vis_id;
 640     TRACE(" Context %p have (vis:%p):\n", ctx, ctx->vis);
 641     pglXGetFBConfigAttrib(gdi_display, ctx->fmt->fbconfig, GLX_FBCONFIG_ID, &tmp);
 642     TRACE(" - FBCONFIG_ID 0x%x\n", tmp);
 643     pglXGetFBConfigAttrib(gdi_display, ctx->fmt->fbconfig, GLX_VISUAL_ID, &tmp);
 644     TRACE(" - VISUAL_ID 0x%x\n", tmp);
 645     ctx_vis_id = tmp;
 646     return ctx_vis_id;
 647 }
 648
 649 static BOOL describeDrawable(X11DRV_PDEVICE *physDev) {
 650     int tmp;
 651     WineGLPixelFormat *fmt;
 652     int fmt_count = 0;
 653
 654     fmt = ConvertPixelFormatWGLtoGLX(gdi_display, physDev->current_pf, TRUE /* Offscreen */, &fmt_count);
 655     if(!fmt) return FALSE;
 656
 657     TRACE(" HDC %p has:\n", physDev->hdc);
 658     TRACE(" - iPixelFormat %d\n", fmt->iPixelFormat);
 659     TRACE(" - Drawable %p\n", (void*) get_glxdrawable(physDev));
 660     TRACE(" - FBCONFIG_ID 0x%x\n", fmt->fmt_id);
 661
 662     pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_VISUAL_ID, &tmp);
 663     TRACE(" - VISUAL_ID 0x%x\n", tmp);
 664
 665     return TRUE;
 666 }
 667
 668 static int ConvertAttribWGLtoGLX(const int* iWGLAttr, int* oGLXAttr, Wine_GLPBuffer* pbuf) {
 669   int nAttribs = 0;
 670   unsigned cur = 0;
 671   int pop;
 672   int drawattrib = 0;
 673   int nvfloatattrib = GLX_DONT_CARE;
 674   int pixelattrib = ~0;
 675
 676   /* The list of WGL attributes is allowed to be NULL. We don't return here for NULL
 677    * because we need to do fixups for GLX_DRAWABLE_TYPE/GLX_RENDER_TYPE/GLX_FLOAT_COMPONENTS_NV. */
 678   while (iWGLAttr && 0 != iWGLAttr[cur]) {
 679     TRACE("pAttr[%d] = %x\n", cur, iWGLAttr[cur]);
 680
 681     switch (iWGLAttr[cur]) {
 682     case WGL_AUX_BUFFERS_ARB:
 683       pop = iWGLAttr[++cur];
 684       PUSH2(oGLXAttr, GLX_AUX_BUFFERS, pop);
 685       TRACE("pAttr[%d] = GLX_AUX_BUFFERS: %d\n", cur, pop);
 686       break;
 687     case WGL_COLOR_BITS_ARB:
 688       pop = iWGLAttr[++cur];
 689       PUSH2(oGLXAttr, GLX_BUFFER_SIZE, pop);
 690       TRACE("pAttr[%d] = GLX_BUFFER_SIZE: %d\n", cur, pop);
 691       break;
 692     case WGL_BLUE_BITS_ARB:
 693       pop = iWGLAttr[++cur];
 694       PUSH2(oGLXAttr, GLX_BLUE_SIZE, pop);
 695       TRACE("pAttr[%d] = GLX_BLUE_SIZE: %d\n", cur, pop);
 696       break;
 697     case WGL_RED_BITS_ARB:
 698       pop = iWGLAttr[++cur];
 699       PUSH2(oGLXAttr, GLX_RED_SIZE, pop);
 700       TRACE("pAttr[%d] = GLX_RED_SIZE: %d\n", cur, pop);
 701       break;
 702     case WGL_GREEN_BITS_ARB:
 703       pop = iWGLAttr[++cur];
 704       PUSH2(oGLXAttr, GLX_GREEN_SIZE, pop);
 705       TRACE("pAttr[%d] = GLX_GREEN_SIZE: %d\n", cur, pop);
 706       break;
 707     case WGL_ALPHA_BITS_ARB:
 708       pop = iWGLAttr[++cur];
 709       PUSH2(oGLXAttr, GLX_ALPHA_SIZE, pop);
 710       TRACE("pAttr[%d] = GLX_ALPHA_SIZE: %d\n", cur, pop);
 711       break;
 712     case WGL_DEPTH_BITS_ARB:
 713       pop = iWGLAttr[++cur];
 714       PUSH2(oGLXAttr, GLX_DEPTH_SIZE, pop);
 715       TRACE("pAttr[%d] = GLX_DEPTH_SIZE: %d\n", cur, pop);
 716       break;
 717     case WGL_STENCIL_BITS_ARB:
 718       pop = iWGLAttr[++cur];
 719       PUSH2(oGLXAttr, GLX_STENCIL_SIZE, pop);
 720       TRACE("pAttr[%d] = GLX_STENCIL_SIZE: %d\n", cur, pop);
 721       break;
 722     case WGL_DOUBLE_BUFFER_ARB:
 723       pop = iWGLAttr[++cur];
 724       PUSH2(oGLXAttr, GLX_DOUBLEBUFFER, pop);
 725       TRACE("pAttr[%d] = GLX_DOUBLEBUFFER: %d\n", cur, pop);
 726       break;
 727     case WGL_STEREO_ARB:
 728       pop = iWGLAttr[++cur];
 729       PUSH2(oGLXAttr, GLX_STEREO, pop);
 730       TRACE("pAttr[%d] = GLX_STEREO: %d\n", cur, pop);
 731       break;
 732
 733     case WGL_PIXEL_TYPE_ARB:
 734       pop = iWGLAttr[++cur];
 735       TRACE("pAttr[%d] = WGL_PIXEL_TYPE_ARB: %d\n", cur, pop);
 736       switch (pop) {
 737       case WGL_TYPE_COLORINDEX_ARB: pixelattrib = GLX_COLOR_INDEX_BIT; break ;
 738       case WGL_TYPE_RGBA_ARB: pixelattrib = GLX_RGBA_BIT; break ;
 739       /* This is the same as WGL_TYPE_RGBA_FLOAT_ATI but the GLX constants differ, only the ARB GLX one is widely supported so use that */
 740       case WGL_TYPE_RGBA_FLOAT_ATI: pixelattrib = GLX_RGBA_FLOAT_BIT; break ;
 741       case WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT: pixelattrib = GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT; break ;
 742       default:
 743         ERR("unexpected PixelType(%x)\n", pop);
 744         pop = 0;
 745       }
 746       break;
 747
 748     case WGL_SUPPORT_GDI_ARB:
 749       /* This flag is set in a WineGLPixelFormat */
 750       pop = iWGLAttr[++cur];
 751       TRACE("pAttr[%d] = WGL_SUPPORT_GDI_ARB: %d\n", cur, pop);
 752       break;
 753
 754     case WGL_DRAW_TO_BITMAP_ARB:
 755       /* This flag is set in a WineGLPixelFormat */
 756       pop = iWGLAttr[++cur];
 757       TRACE("pAttr[%d] = WGL_DRAW_TO_BITMAP_ARB: %d\n", cur, pop);
 758       break;
 759
 760     case WGL_DRAW_TO_WINDOW_ARB:
 761       pop = iWGLAttr[++cur];
 762       TRACE("pAttr[%d] = WGL_DRAW_TO_WINDOW_ARB: %d\n", cur, pop);
 763       /* GLX_DRAWABLE_TYPE flags need to be OR'd together. See below. */
 764       if (pop) {
 765         drawattrib |= GLX_WINDOW_BIT;
 766       }
 767       break;
 768
 769     case WGL_DRAW_TO_PBUFFER_ARB:
 770       pop = iWGLAttr[++cur];
 771       TRACE("pAttr[%d] = WGL_DRAW_TO_PBUFFER_ARB: %d\n", cur, pop);
 772       /* GLX_DRAWABLE_TYPE flags need to be OR'd together. See below. */
 773       if (pop) {
 774         drawattrib |= GLX_PBUFFER_BIT;
 775       }
 776       break;
 777
 778     case WGL_ACCELERATION_ARB:
 779       /* This flag is set in a WineGLPixelFormat */
 780       pop = iWGLAttr[++cur];
 781       TRACE("pAttr[%d] = WGL_ACCELERATION_ARB: %d\n", cur, pop);
 782       break;
 783
 784     case WGL_SUPPORT_OPENGL_ARB:
 785       pop = iWGLAttr[++cur];
 786       /** nothing to do, if we are here, supposing support Accelerated OpenGL */
 787       TRACE("pAttr[%d] = WGL_SUPPORT_OPENGL_ARB: %d\n", cur, pop);
 788       break;
 789
 790     case WGL_SWAP_METHOD_ARB:
 791       pop = iWGLAttr[++cur];
 792       /* For now we ignore this and just return SWAP_EXCHANGE */
 793       TRACE("pAttr[%d] = WGL_SWAP_METHOD_ARB: %#x\n", cur, pop);
 794       break;
 795
 796     case WGL_PBUFFER_LARGEST_ARB:
 797       pop = iWGLAttr[++cur];
 798       PUSH2(oGLXAttr, GLX_LARGEST_PBUFFER, pop);
 799       TRACE("pAttr[%d] = GLX_LARGEST_PBUFFER: %x\n", cur, pop);
 800       break;
 801
 802     case WGL_SAMPLE_BUFFERS_ARB:
 803       pop = iWGLAttr[++cur];
 804       PUSH2(oGLXAttr, GLX_SAMPLE_BUFFERS_ARB, pop);
 805       TRACE("pAttr[%d] = GLX_SAMPLE_BUFFERS_ARB: %x\n", cur, pop);
 806       break;
 807
 808     case WGL_SAMPLES_ARB:
 809       pop = iWGLAttr[++cur];
 810       PUSH2(oGLXAttr, GLX_SAMPLES_ARB, pop);
 811       TRACE("pAttr[%d] = GLX_SAMPLES_ARB: %x\n", cur, pop);
 812       break;
 813
 814     case WGL_TEXTURE_FORMAT_ARB:
 815     case WGL_TEXTURE_TARGET_ARB:
 816     case WGL_MIPMAP_TEXTURE_ARB:
 817       TRACE("WGL_render_texture Attributes: %x as %x\n", iWGLAttr[cur], iWGLAttr[cur + 1]);
 818       pop = iWGLAttr[++cur];
 819       if (NULL == pbuf) {
 820         ERR("trying to use GLX_Pbuffer Attributes without Pbuffer (was %x)\n", iWGLAttr[cur]);
 821       }
 822       if (use_render_texture_ati) {
 823         /** nothing to do here */
 824       }
 825       else if (!use_render_texture_emulation) {
 826         if (WGL_NO_TEXTURE_ARB != pop) {
 827           ERR("trying to use WGL_render_texture Attributes without support (was %x)\n", iWGLAttr[cur]);
 828           return -1; /** error: don't support it */
 829         } else {
 830           drawattrib |= GLX_PBUFFER_BIT;
 831         }
 832       }
 833       break ;
 834     case WGL_FLOAT_COMPONENTS_NV:
 835       nvfloatattrib = iWGLAttr[++cur];
 836       TRACE("pAttr[%d] = WGL_FLOAT_COMPONENTS_NV: %x\n", cur, nvfloatattrib);
 837       break ;
 838     case WGL_BIND_TO_TEXTURE_DEPTH_NV:
 839     case WGL_BIND_TO_TEXTURE_RGB_ARB:
 840     case WGL_BIND_TO_TEXTURE_RGBA_ARB:
 841     case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV:
 842     case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV:
 843     case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV:
 844     case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV:
 845       pop = iWGLAttr[++cur];
 846       /** cannot be converted, see direct handling on
 847        *   - wglGetPixelFormatAttribivARB
 848        *  TODO: wglChoosePixelFormat
 849        */
 850       break ;
 851     case WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT:
 852       pop = iWGLAttr[++cur];
 853       PUSH2(oGLXAttr, GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT, pop);
 854       TRACE("pAttr[%d] = GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT: %x\n", cur, pop);
 855       break ;
 856
 857     case WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT:
 858       pop = iWGLAttr[++cur];
 859       PUSH2(oGLXAttr, GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT, pop);
 860       TRACE("pAttr[%d] = GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT: %x\n", cur, pop);
 861       break ;
 862     default:
 863       FIXME("unsupported %x WGL Attribute\n", iWGLAttr[cur]);
 864       break;
 865     }
 866     ++cur;
 867   }
 868
 869   /* By default glXChooseFBConfig defaults to GLX_WINDOW_BIT. wglChoosePixelFormatARB searches through
 870    * all formats. Unless drawattrib is set to a non-zero value override it with ~0, so that pixmap and pbuffer
 871    * formats appear as well. */
 872   if(!drawattrib) drawattrib = ~0;
 873   PUSH2(oGLXAttr, GLX_DRAWABLE_TYPE, drawattrib);
 874   TRACE("pAttr[?] = GLX_DRAWABLE_TYPE: %#x\n", drawattrib);
 875
 876   /* By default glXChooseFBConfig uses GLX_RGBA_BIT as the default value. Since wglChoosePixelFormatARB
 877    * searches in all formats we have to do the same. For this reason we set GLX_RENDER_TYPE to ~0 unless
 878    * it is overridden. */
 879   PUSH2(oGLXAttr, GLX_RENDER_TYPE, pixelattrib);
 880   TRACE("pAttr[?] = GLX_RENDER_TYPE: %#x\n", pixelattrib);
 881
 882   /* Set GLX_FLOAT_COMPONENTS_NV all the time */
 883   if(strstr(WineGLInfo.glxExtensions, "GLX_NV_float_buffer")) {
 884     PUSH2(oGLXAttr, GLX_FLOAT_COMPONENTS_NV, nvfloatattrib);
 885     TRACE("pAttr[?] = GLX_FLOAT_COMPONENTS_NV: %#x\n", nvfloatattrib);
 886   }
 887
 888   return nAttribs;
 889 }
 890
 891 static int get_render_type_from_fbconfig(Display *display, GLXFBConfig fbconfig)
 892 {
 893     int render_type=0, render_type_bit;
 894     pglXGetFBConfigAttrib(display, fbconfig, GLX_RENDER_TYPE, &render_type_bit);
 895     switch(render_type_bit)
 896     {
 897         case GLX_RGBA_BIT:
 898             render_type = GLX_RGBA_TYPE;
 899             break;
 900         case GLX_COLOR_INDEX_BIT:
 901             render_type = GLX_COLOR_INDEX_TYPE;
 902             break;
 903         case GLX_RGBA_FLOAT_BIT:
 904             render_type = GLX_RGBA_FLOAT_TYPE;
 905             break;
 906         case GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT:
 907             render_type = GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT;
 908             break;
 909         default:
 910             ERR("Unknown render_type: %x\n", render_type_bit);
 911     }
 912     return render_type;
 913 }
 914
 915 /* Check whether a fbconfig is suitable for Windows-style bitmap rendering */
 916 static BOOL check_fbconfig_bitmap_capability(Display *display, GLXFBConfig fbconfig)
 917 {
 918     int dbuf, value;
 919     pglXGetFBConfigAttrib(display, fbconfig, GLX_DOUBLEBUFFER, &dbuf);
 920     pglXGetFBConfigAttrib(gdi_display, fbconfig, GLX_DRAWABLE_TYPE, &value);
 921
 922     /* Windows only supports bitmap rendering on single buffered formats, further the fbconfig needs to have
 923      * the GLX_PIXMAP_BIT set. */
 924     return !dbuf && (value & GLX_PIXMAP_BIT);
 925 }
 926
 927 static WineGLPixelFormat *get_formats(Display *display, int *size_ret, int *onscreen_size_ret)
 928 {
 929     static WineGLPixelFormat *list;
 930     static int size, onscreen_size;
 931
 932     int fmt_id, nCfgs, i, run, bmp_formats;
 933     GLXFBConfig* cfgs;
 934     XVisualInfo *visinfo;
 935
 936     wine_tsx11_lock();
 937     if (list) goto done;
 938
 939     cfgs = pglXGetFBConfigs(display, DefaultScreen(display), &nCfgs);
 940     if (NULL == cfgs || 0 == nCfgs) {
 941         if(cfgs != NULL) XFree(cfgs);
 942         wine_tsx11_unlock();
 943         ERR("glXChooseFBConfig returns NULL\n");
 944         return NULL;
 945     }
 946
 947     /* Bitmap rendering on Windows implies the use of the Microsoft GDI software renderer.
 948      * Further most GLX drivers only offer pixmap rendering using indirect rendering (except for modern drivers which support 'AIGLX' / composite).
 949      * Indirect rendering can indicate software rendering (on Nvidia it is hw accelerated)
 950      * Since bitmap rendering implies the use of software rendering we can safely use indirect rendering for bitmaps.
 951      *
 952      * Below we count the number of formats which are suitable for bitmap rendering. Windows restricts bitmap rendering to single buffered formats.
 953      */
 954     for(i=0, bmp_formats=0; i<nCfgs; i++)
 955     {
 956         if(check_fbconfig_bitmap_capability(display, cfgs[i]))
 957             bmp_formats++;
 958     }
 959     TRACE("Found %d bitmap capable fbconfigs\n", bmp_formats);
 960
 961     list = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (nCfgs + bmp_formats)*sizeof(WineGLPixelFormat));
 962
 963     /* Fill the pixel format list. Put onscreen formats at the top and offscreen ones at the bottom.
 964      * Do this as GLX doesn't guarantee that the list is sorted */
 965     for(run=0; run < 2; run++)
 966     {
 967         for(i=0; i<nCfgs; i++) {
 968             pglXGetFBConfigAttrib(display, cfgs[i], GLX_FBCONFIG_ID, &fmt_id);
 969             visinfo = pglXGetVisualFromFBConfig(display, cfgs[i]);
 970
 971             /* The first run we only add onscreen formats (ones which have an associated X Visual).
 972              * The second run we only set offscreen formats. */
 973             if(!run && visinfo)
 974             {
 975                 /* We implement child window rendering using offscreen buffers (using composite or an XPixmap).
 976                  * The contents is copied to the destination using XCopyArea. For the copying to work
 977                  * the depth of the source and destination window should be the same. In general this should
 978                  * not be a problem for OpenGL as drivers only advertise formats with a similar depth (or no depth).
 979                  * As of the introduction of composition managers at least Nvidia now also offers ARGB visuals
 980                  * with a depth of 32 in addition to the default 24 bit. In order to prevent BadMatch errors we only
 981                  * list formats with the same depth. */
 982                 if(visinfo->depth != screen_depth)
 983                 {
 984                     XFree(visinfo);
 985                     continue;
 986                 }
 987
 988                 TRACE("Found onscreen format FBCONFIG_ID 0x%x corresponding to iPixelFormat %d at GLX index %d\n", fmt_id, size+1, i);
 989                 list[size].iPixelFormat = size+1; /* The index starts at 1 */
 990                 list[size].fbconfig = cfgs[i];
 991                 list[size].fmt_id = fmt_id;
 992                 list[size].render_type = get_render_type_from_fbconfig(display, cfgs[i]);
 993                 list[size].offscreenOnly = FALSE;
 994                 list[size].dwFlags = 0;
 995                 size++;
 996                 onscreen_size++;
 997
 998                 /* Clone a format if it is bitmap capable for indirect rendering to bitmaps */
 999                 if(check_fbconfig_bitmap_capability(display, cfgs[i]))
1000                 {
1001                     TRACE("Found bitmap capable format FBCONFIG_ID 0x%x corresponding to iPixelFormat %d at GLX index %d\n", fmt_id, size+1, i);
1002                     list[size].iPixelFormat = size+1; /* The index starts at 1 */
1003                     list[size].fbconfig = cfgs[i];
1004                     list[size].fmt_id = fmt_id;
1005                     list[size].render_type = get_render_type_from_fbconfig(display, cfgs[i]);
1006                     list[size].offscreenOnly = FALSE;
1007                     list[size].dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_GDI | PFD_GENERIC_FORMAT;
1008                     size++;
1009                     onscreen_size++;
1010                 }
1011             } else if(run && !visinfo) {
1012                 int window_drawable=0;
1013                 pglXGetFBConfigAttrib(gdi_display, cfgs[i], GLX_DRAWABLE_TYPE, &window_drawable);
1014
1015                 /* Recent Nvidia drivers and DRI drivers offer window drawable formats without a visual.
1016                  * This are formats like 16-bit rgb on a 24-bit desktop. In order to support these formats
1017                  * onscreen we would have to use glXCreateWindow instead of XCreateWindow. Further it will
1018                  * likely make our child window opengl rendering more complicated since likely you can't use
1019                  * XCopyArea on a GLX Window.
1020                  * For now ignore fbconfigs which are window drawable but lack a visual. */
1021                 if(window_drawable & GLX_WINDOW_BIT)
1022                 {
1023                     TRACE("Skipping FBCONFIG_ID 0x%x as an offscreen format because it is window_drawable\n", fmt_id);
1024                     continue;
1025                 }
1026
1027                 TRACE("Found offscreen format FBCONFIG_ID 0x%x corresponding to iPixelFormat %d at GLX index %d\n", fmt_id, size+1, i);
1028                 list[size].iPixelFormat = size+1; /* The index starts at 1 */
1029                 list[size].fbconfig = cfgs[i];
1030                 list[size].fmt_id = fmt_id;
1031                 list[size].render_type = get_render_type_from_fbconfig(display, cfgs[i]);
1032                 list[size].offscreenOnly = TRUE;
1033                 list[size].dwFlags = 0;
1034                 size++;
1035             }
1036
1037             if (visinfo) XFree(visinfo);
1038         }
1039     }
1040
1041     XFree(cfgs);
1042
1043 done:
1044     if (size_ret) *size_ret = size;
1045     if (onscreen_size_ret) *onscreen_size_ret = onscreen_size;
1046     wine_tsx11_unlock();
1047     return list;
1048 }
1049
1050 /* GLX can advertise dozens of different pixelformats including offscreen and onscreen ones.
1051  * In our WGL implementation we only support a subset of these formats namely the format of
1052  * Wine's main visual and offscreen formats (if they are available).
1053  * This function converts a WGL format to its corresponding GLX one. It returns a WineGLPixelFormat
1054  * and it returns the number of supported WGL formats in fmt_count.
1055  */
1056 static WineGLPixelFormat* ConvertPixelFormatWGLtoGLX(Display *display, int iPixelFormat, BOOL AllowOffscreen, int *fmt_count)
1057 {
1058     WineGLPixelFormat *list, *res = NULL;
1059     int size, onscreen_size;
1060
1061     if (!(list = get_formats(display, &size, &onscreen_size ))) return NULL;
1062
1063     /* Check if the pixelformat is valid. Note that it is legal to pass an invalid
1064      * iPixelFormat in case of probing the number of pixelformats.
1065      */
1066     if((iPixelFormat > 0) && (iPixelFormat <= size) &&
1067        (!list[iPixelFormat-1].offscreenOnly || AllowOffscreen)) {
1068         res = &list[iPixelFormat-1];
1069         TRACE("Returning fmt_id=%#x for iPixelFormat=%d\n", res->fmt_id, iPixelFormat);
1070     }
1071
1072     if(AllowOffscreen)
1073         *fmt_count = size;
1074     else
1075         *fmt_count = onscreen_size;
1076
1077     TRACE("Number of returned pixelformats=%d\n", *fmt_count);
1078
1079     return res;
1080 }
1081
1082 /* Search our internal pixelformat list for the WGL format corresponding to the given fbconfig */
1083 static WineGLPixelFormat* ConvertPixelFormatGLXtoWGL(Display *display, int fmt_id, DWORD dwFlags)
1084 {
1085     WineGLPixelFormat *list;
1086     int i, size;
1087
1088     if (!(list = get_formats(display, &size, NULL ))) return NULL;
1089
1090     for(i=0; i<size; i++) {
1091         /* A GLX format can appear multiple times in the pixel format list due to fake formats for bitmap rendering.
1092          * Fake formats might get selected when the user passes the proper flags using the dwFlags parameter. */
1093         if( (list[i].fmt_id == fmt_id) && ((list[i].dwFlags & dwFlags) == dwFlags) ) {
1094             TRACE("Returning iPixelFormat %d for fmt_id 0x%x\n", list[i].iPixelFormat, fmt_id);
1095             return &list[i];
1096         }
1097     }
1098     TRACE("No compatible format found for fmt_id 0x%x\n", fmt_id);
1099     return NULL;
1100 }
1101
1102 int pixelformat_from_fbconfig_id(XID fbconfig_id)
1103 {
1104     WineGLPixelFormat *fmt;
1105
1106     if (!fbconfig_id) return 0;
1107
1108     fmt = ConvertPixelFormatGLXtoWGL(gdi_display, fbconfig_id, 0 /* no flags */);
1109     if(fmt)
1110         return fmt->iPixelFormat;
1111     /* This will happen on hwnds without a pixel format set; it's ok */
1112     return 0;
1113 }
1114
1115
1116 /* Mark any allocated context using the glx drawable 'old' to use 'new' */
1117 void mark_drawable_dirty(Drawable old, Drawable new)
1118 {
1119     Wine_GLContext *ctx;
1120     for (ctx = context_list; ctx; ctx = ctx->next) {
1121         if (old == ctx->drawables[0]) {
1122             ctx->drawables[0] = new;
1123             ctx->refresh_drawables = TRUE;
1124         }
1125         if (old == ctx->drawables[1]) {
1126             ctx->drawables[1] = new;
1127             ctx->refresh_drawables = TRUE;
1128         }
1129     }
1130 }
1131
1132 /* Given the current context, make sure its drawable is sync'd */
1133 static inline void sync_context(Wine_GLContext *context)
1134 {
1135     if(context && context->refresh_drawables) {
1136         if (glxRequireVersion(3))
1137             pglXMakeContextCurrent(gdi_display, context->drawables[0],
1138                                    context->drawables[1], context->ctx);
1139         else
1140             pglXMakeCurrent(gdi_display, context->drawables[0], context->ctx);
1141         context->refresh_drawables = FALSE;
1142     }
1143 }
1144
1145
1146 static GLXContext create_glxcontext(Display *display, Wine_GLContext *context, GLXContext shareList)
1147 {
1148     GLXContext ctx;
1149
1150     /* We use indirect rendering for rendering to bitmaps. See get_formats for a comment about this. */
1151     BOOL indirect = (context->fmt->dwFlags & PFD_DRAW_TO_BITMAP) ? FALSE : TRUE;
1152
1153     if(context->gl3_context)
1154     {
1155         if(context->numAttribs)
1156             ctx = pglXCreateContextAttribsARB(gdi_display, context->fmt->fbconfig, shareList, indirect, context->attribList);
1157         else
1158             ctx = pglXCreateContextAttribsARB(gdi_display, context->fmt->fbconfig, shareList, indirect, NULL);
1159     }
1160     else if(context->vis)
1161         ctx = pglXCreateContext(gdi_display, context->vis, shareList, indirect);
1162     else /* Create a GLX Context for a pbuffer */
1163         ctx = pglXCreateNewContext(gdi_display, context->fmt->fbconfig, context->fmt->render_type, shareList, TRUE);
1164
1165     return ctx;
1166 }
1167
1168
1169 Drawable create_glxpixmap(Display *display, XVisualInfo *vis, Pixmap parent)
1170 {
1171     return pglXCreateGLXPixmap(display, vis, parent);
1172 }
1173
1174
1175 static XID create_bitmap_glxpixmap(X11DRV_PDEVICE *physDev, WineGLPixelFormat *fmt)
1176 {
1177     GLXPixmap ret = 0;
1178     XVisualInfo *vis;
1179
1180     wine_tsx11_lock();
1181
1182     vis = pglXGetVisualFromFBConfig(gdi_display, fmt->fbconfig);
1183     if(vis) {
1184         if(vis->depth == physDev->bitmap->pixmap_depth)
1185             ret = pglXCreateGLXPixmap(gdi_display, vis, physDev->bitmap->pixmap);
1186         XFree(vis);
1187     }
1188     wine_tsx11_unlock();
1189     TRACE("return %lx\n", ret);
1190     return ret;
1191 }
1192
1193 /**
1194  * X11DRV_ChoosePixelFormat
1195  *
1196  * Equivalent to glXChooseVisual.
1197  */
1198 int CDECL X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
1199                              const PIXELFORMATDESCRIPTOR *ppfd) {
1200     WineGLPixelFormat *list;
1201     int onscreen_size;
1202     int ret = 0;
1203     int value = 0;
1204     int i = 0;
1205     int bestFormat = -1;
1206     int bestDBuffer = -1;
1207     int bestStereo = -1;
1208     int bestColor = -1;
1209     int bestAlpha = -1;
1210     int bestDepth = -1;
1211     int bestStencil = -1;
1212     int bestAux = -1;
1213
1214     if (!has_opengl()) return 0;
1215
1216     if (TRACE_ON(wgl)) {
1217         TRACE("(%p,%p)\n", physDev, ppfd);
1218
1219         dump_PIXELFORMATDESCRIPTOR(ppfd);
1220     }
1221
1222     if (!(list = get_formats(gdi_display, NULL, &onscreen_size ))) return 0;
1223
1224     wine_tsx11_lock();
1225     for(i=0; i<onscreen_size; i++)
1226     {
1227         int dwFlags = 0;
1228         int iPixelType = 0;
1229         int alpha=0, color=0, depth=0, stencil=0, aux=0;
1230         WineGLPixelFormat *fmt = &list[i];
1231
1232         /* Pixel type */
1233         pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_RENDER_TYPE, &value);
1234         if (value & GLX_RGBA_BIT)
1235             iPixelType = PFD_TYPE_RGBA;
1236         else
1237             iPixelType = PFD_TYPE_COLORINDEX;
1238
1239         if (ppfd->iPixelType != iPixelType)
1240         {
1241             TRACE("pixel type mismatch for iPixelFormat=%d\n", i+1);
1242             continue;
1243         }
1244
1245         /* Only use bitmap capable for formats for bitmap rendering.
1246          * See get_formats for more info. */
1247         if( (ppfd->dwFlags & PFD_DRAW_TO_BITMAP) != (fmt->dwFlags & PFD_DRAW_TO_BITMAP))
1248         {
1249             TRACE("PFD_DRAW_TO_BITMAP mismatch for iPixelFormat=%d\n", i+1);
1250             continue;
1251         }
1252
1253         pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DOUBLEBUFFER, &value);
1254         if (value) dwFlags |= PFD_DOUBLEBUFFER;
1255         pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STEREO, &value);
1256         if (value) dwFlags |= PFD_STEREO;
1257         pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_BUFFER_SIZE, &color); /* cColorBits */
1258         pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ALPHA_SIZE, &alpha); /* cAlphaBits */
1259         pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DEPTH_SIZE, &depth); /* cDepthBits */
1260         pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STENCIL_SIZE, &stencil); /* cStencilBits */
1261         pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_AUX_BUFFERS, &aux); /* cAuxBuffers */
1262
1263         /* The behavior of PDF_STEREO/PFD_STEREO_DONTCARE and PFD_DOUBLEBUFFER / PFD_DOUBLEBUFFER_DONTCARE
1264          * is not very clear on MSDN. They specify that ChoosePixelFormat tries to match pixel formats
1265          * with the flag (PFD_STEREO / PFD_DOUBLEBUFFERING) set. Otherwise it says that it tries to match
1266          * formats without the given flag set.
1267          * A test on Windows using a Radeon 9500pro on WinXP (the driver doesn't support Stereo)
1268          * has indicated that a format without stereo is returned when stereo is unavailable.
1269          * So in case PFD_STEREO is set, formats that support it should have priority above formats
1270          * without. In case PFD_STEREO_DONTCARE is set, stereo is ignored.
1271          *
1272          * To summarize the following is most likely the correct behavior:
1273          * stereo not set -> prefer no-stereo formats, else also accept stereo formats
1274          * stereo set -> prefer stereo formats, else also accept no-stereo formats
1275          * stereo don't care -> it doesn't matter whether we get stereo or not
1276          *
1277          * In Wine we will treat no-stereo the same way as don't care because it makes
1278          * format selection even more complicated and second drivers with Stereo advertise
1279          * each format twice anyway.
1280          */
1281
1282         /* Doublebuffer, see the comments above */
1283         if( !(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) ) {
1284             if( ((ppfd->dwFlags & PFD_DOUBLEBUFFER) != bestDBuffer) &&
1285                 ((dwFlags & PFD_DOUBLEBUFFER) == (ppfd->dwFlags & PFD_DOUBLEBUFFER)) )
1286             {
1287                 bestDBuffer = dwFlags & PFD_DOUBLEBUFFER;
1288                 bestStereo = dwFlags & PFD_STEREO;
1289                 bestAlpha = alpha;
1290                 bestColor = color;
1291                 bestDepth = depth;
1292                 bestStencil = stencil;
1293                 bestAux = aux;
1294                 bestFormat = i;
1295                 continue;
1296             }
1297             if(bestDBuffer != -1 && (dwFlags & PFD_DOUBLEBUFFER) != bestDBuffer)
1298                 continue;
1299         }
1300
1301         /* Stereo, see the comments above. */
1302         if( !(ppfd->dwFlags & PFD_STEREO_DONTCARE) ) {
1303             if( ((ppfd->dwFlags & PFD_STEREO) != bestStereo) &&
1304                 ((dwFlags & PFD_STEREO) == (ppfd->dwFlags & PFD_STEREO)) )
1305             {
1306                 bestDBuffer = dwFlags & PFD_DOUBLEBUFFER;
1307                 bestStereo = dwFlags & PFD_STEREO;
1308                 bestAlpha = alpha;
1309                 bestColor = color;
1310                 bestDepth = depth;
1311                 bestStencil = stencil;
1312                 bestAux = aux;
1313                 bestFormat = i;
1314                 continue;
1315             }
1316             if(bestStereo != -1 && (dwFlags & PFD_STEREO) != bestStereo)
1317                 continue;
1318         }
1319
1320         /* Below we will do a number of checks to select the 'best' pixelformat.
1321          * We assume the precedence cColorBits > cAlphaBits > cDepthBits > cStencilBits -> cAuxBuffers.
1322          * The code works by trying to match the most important options as close as possible.
1323          * When a reasonable format is found, we will try to match more options.
1324          * It appears (see the opengl32 test) that Windows opengl drivers ignore options
1325          * like cColorBits, cAlphaBits and friends if they are set to 0, so they are considered
1326          * as DONTCARE. At least Serious Sam TSE relies on this behavior. */
1327
1328         /* Color bits */
1329         if(ppfd->cColorBits) {
1330             if( ((ppfd->cColorBits > bestColor) && (color > bestColor)) ||
1331                 ((color >= ppfd->cColorBits) && (color < bestColor)) )
1332             {
1333                 bestDBuffer = dwFlags & PFD_DOUBLEBUFFER;
1334                 bestStereo = dwFlags & PFD_STEREO;
1335                 bestAlpha = alpha;
1336                 bestColor = color;
1337                 bestDepth = depth;
1338                 bestStencil = stencil;
1339                 bestAux = aux;
1340                 bestFormat = i;
1341                 continue;
1342             } else if(bestColor != color) {  /* Do further checks if the format is compatible */
1343                 TRACE("color mismatch for iPixelFormat=%d\n", i+1);
1344                 continue;
1345             }
1346         }
1347
1348         /* Alpha bits */
1349         if(ppfd->cAlphaBits) {
1350             if( ((ppfd->cAlphaBits > bestAlpha) && (alpha > bestAlpha)) ||
1351                 ((alpha >= ppfd->cAlphaBits) && (alpha < bestAlpha)) )
1352             {
1353                 bestDBuffer = dwFlags & PFD_DOUBLEBUFFER;
1354                 bestStereo = dwFlags & PFD_STEREO;
1355                 bestAlpha = alpha;
1356                 bestColor = color;
1357                 bestDepth = depth;
1358                 bestStencil = stencil;
1359                 bestAux = aux;
1360                 bestFormat = i;
1361                 continue;
1362             } else if(bestAlpha != alpha) {
1363                 TRACE("alpha mismatch for iPixelFormat=%d\n", i+1);
1364                 continue;
1365             }
1366         }
1367
1368         /* Depth bits */
1369         if(ppfd->cDepthBits) {
1370             if( ((ppfd->cDepthBits > bestDepth) && (depth > bestDepth)) ||
1371                 ((depth >= ppfd->cDepthBits) && (depth < bestDepth)) )
1372             {
1373                 bestDBuffer = dwFlags & PFD_DOUBLEBUFFER;
1374                 bestStereo = dwFlags & PFD_STEREO;
1375                 bestAlpha = alpha;
1376                 bestColor = color;
1377                 bestDepth = depth;
1378                 bestStencil = stencil;
1379                 bestAux = aux;
1380                 bestFormat = i;
1381                 continue;
1382             } else if(bestDepth != depth) {
1383                 TRACE("depth mismatch for iPixelFormat=%d\n", i+1);
1384                 continue;
1385             }
1386         }
1387
1388         /* Stencil bits */
1389         if(ppfd->cStencilBits) {
1390             if( ((ppfd->cStencilBits > bestStencil) && (stencil > bestStencil)) ||
1391                 ((stencil >= ppfd->cStencilBits) && (stencil < bestStencil)) )
1392             {
1393                 bestDBuffer = dwFlags & PFD_DOUBLEBUFFER;
1394                 bestStereo = dwFlags & PFD_STEREO;
1395                 bestAlpha = alpha;
1396                 bestColor = color;
1397                 bestDepth = depth;
1398                 bestStencil = stencil;
1399                 bestAux = aux;
1400                 bestFormat = i;
1401                 continue;
1402             } else if(bestStencil != stencil) {
1403                 TRACE("stencil mismatch for iPixelFormat=%d\n", i+1);
1404                 continue;
1405             }
1406         }
1407
1408         /* Aux buffers */
1409         if(ppfd->cAuxBuffers) {
1410             if( ((ppfd->cAuxBuffers > bestAux) && (aux > bestAux)) ||
1411                 ((aux >= ppfd->cAuxBuffers) && (aux < bestAux)) )
1412             {
1413                 bestDBuffer = dwFlags & PFD_DOUBLEBUFFER;
1414                 bestStereo = dwFlags & PFD_STEREO;
1415                 bestAlpha = alpha;
1416                 bestColor = color;
1417                 bestDepth = depth;
1418                 bestStencil = stencil;
1419                 bestAux = aux;
1420                 bestFormat = i;
1421                 continue;
1422             } else if(bestAux != aux) {
1423                 TRACE("aux mismatch for iPixelFormat=%d\n", i+1);
1424                 continue;
1425             }
1426         }
1427     }
1428
1429     if(bestFormat == -1) {
1430         TRACE("No matching mode was found returning 0\n");
1431         ret = 0;
1432     }
1433     else {
1434         ret = bestFormat+1; /* the return value should be a 1-based index */
1435         TRACE("Successfully found a matching mode, returning index: %d %x\n", ret, list[bestFormat].fmt_id);
1436     }
1437
1438     wine_tsx11_unlock();
1439
1440     return ret;
1441 }
1442 /**
1443  * X11DRV_DescribePixelFormat
1444  *
1445  * Get the pixel-format descriptor associated to the given id
1446  */
1447 int CDECL X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
1448                                int iPixelFormat,
1449                                UINT nBytes,
1450                                PIXELFORMATDESCRIPTOR *ppfd) {
1451   /*XVisualInfo *vis;*/
1452   int value;
1453   int rb,gb,bb,ab;
1454   WineGLPixelFormat *fmt;
1455   int ret = 0;
1456   int fmt_count = 0;
1457
1458   if (!has_opengl()) return 0;
1459
1460   TRACE("(%p,%d,%d,%p)\n", physDev, iPixelFormat, nBytes, ppfd);
1461
1462   /* 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 */
1463   fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, FALSE /* Offscreen */, &fmt_count);
1464   if (ppfd == NULL) {
1465       /* The application is only querying the number of pixelformats */
1466       return fmt_count;
1467   } else if(fmt == NULL) {
1468       WARN("unexpected iPixelFormat(%d): not >=1 and <=nFormats(%d), returning NULL!\n", iPixelFormat, fmt_count);
1469       return 0;
1470   }
1471
1472   if (nBytes < sizeof(PIXELFORMATDESCRIPTOR)) {
1473     ERR("Wrong structure size !\n");
1474     /* Should set error */
1475     return 0;
1476   }
1477
1478   ret = fmt_count;
1479
1480   memset(ppfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
1481   ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
1482   ppfd->nVersion = 1;
1483
1484   /* These flags are always the same... */
1485   ppfd->dwFlags = PFD_SUPPORT_OPENGL;
1486   /* Now the flags extracted from the Visual */
1487
1488   wine_tsx11_lock();
1489
1490   pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &value);
1491   if(value & GLX_WINDOW_BIT)
1492       ppfd->dwFlags |= PFD_DRAW_TO_WINDOW;
1493
1494   /* On Windows bitmap rendering is only offered using the GDI Software renderer. We reserve some formats (see get_formats for more info)
1495    * for bitmap rendering since we require indirect rendering for this. Further pixel format logs of a GeforceFX, Geforce8800GT, Radeon HD3400 and a
1496    * Radeon 9000 indicated that all bitmap formats have PFD_SUPPORT_GDI. Except for 2 formats on the Radeon 9000 none of the hw accelerated formats
1497    * offered the GDI bit either. */
1498   ppfd->dwFlags |= fmt->dwFlags & (PFD_DRAW_TO_BITMAP | PFD_SUPPORT_GDI);
1499
1500   /* PFD_GENERIC_FORMAT - gdi software rendering
1501    * PFD_GENERIC_ACCELERATED - some parts are accelerated by a display driver (MCD e.g. 3dfx minigl)
1502    * none set - full hardware accelerated by a ICD
1503    *
1504    * We only set PFD_GENERIC_FORMAT on bitmap formats (see get_formats) as that's what ATI and Nvidia Windows drivers do  */
1505   ppfd->dwFlags |= fmt->dwFlags & (PFD_GENERIC_FORMAT | PFD_GENERIC_ACCELERATED);
1506
1507   pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DOUBLEBUFFER, &value);
1508   if (value) {
1509       ppfd->dwFlags |= PFD_DOUBLEBUFFER;
1510       ppfd->dwFlags &= ~PFD_SUPPORT_GDI;
1511   }
1512   pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STEREO, &value); if (value) ppfd->dwFlags |= PFD_STEREO;
1513
1514   /* Pixel type */
1515   pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_RENDER_TYPE, &value);
1516   if (value & GLX_RGBA_BIT)
1517     ppfd->iPixelType = PFD_TYPE_RGBA;
1518   else
1519     ppfd->iPixelType = PFD_TYPE_COLORINDEX;
1520
1521   /* Color bits */
1522   pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_BUFFER_SIZE, &value);
1523   ppfd->cColorBits = value;
1524
1525   /* Red, green, blue and alpha bits / shifts */
1526   if (ppfd->iPixelType == PFD_TYPE_RGBA) {
1527     pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_RED_SIZE, &rb);
1528     pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_GREEN_SIZE, &gb);
1529     pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_BLUE_SIZE, &bb);
1530     pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ALPHA_SIZE, &ab);
1531
1532     ppfd->cRedBits = rb;
1533     ppfd->cRedShift = gb + bb + ab;
1534     ppfd->cBlueBits = bb;
1535     ppfd->cBlueShift = ab;
1536     ppfd->cGreenBits = gb;
1537     ppfd->cGreenShift = bb + ab;
1538     ppfd->cAlphaBits = ab;
1539     ppfd->cAlphaShift = 0;
1540   } else {
1541     ppfd->cRedBits = 0;
1542     ppfd->cRedShift = 0;
1543     ppfd->cBlueBits = 0;
1544     ppfd->cBlueShift = 0;
1545     ppfd->cGreenBits = 0;
1546     ppfd->cGreenShift = 0;
1547     ppfd->cAlphaBits = 0;
1548     ppfd->cAlphaShift = 0;
1549   }
1550
1551   /* Accum RGBA bits */
1552   pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_RED_SIZE, &rb);
1553   pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_GREEN_SIZE, &gb);
1554   pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_BLUE_SIZE, &bb);
1555   pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_ALPHA_SIZE, &ab);
1556
1557   ppfd->cAccumBits = rb+gb+bb+ab;
1558   ppfd->cAccumRedBits = rb;
1559   ppfd->cAccumGreenBits = gb;
1560   ppfd->cAccumBlueBits = bb;
1561   ppfd->cAccumAlphaBits = ab;
1562
1563   /* Aux bits */
1564   pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_AUX_BUFFERS, &value);
1565   ppfd->cAuxBuffers = value;
1566
1567   /* Depth bits */
1568   pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DEPTH_SIZE, &value);
1569   ppfd->cDepthBits = value;
1570
1571   /* stencil bits */
1572   pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STENCIL_SIZE, &value);
1573   ppfd->cStencilBits = value;
1574
1575   wine_tsx11_unlock();
1576
1577   ppfd->iLayerType = PFD_MAIN_PLANE;
1578
1579   if (TRACE_ON(wgl)) {
1580     dump_PIXELFORMATDESCRIPTOR(ppfd);
1581   }
1582
1583   return ret;
1584 }
1585
1586 /**
1587  * X11DRV_GetPixelFormat
1588  *
1589  * Get the pixel-format id used by this DC
1590  */
1591 int CDECL X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
1592   WineGLPixelFormat *fmt;
1593   int tmp;
1594   TRACE("(%p)\n", physDev);
1595
1596   if (!physDev->current_pf) return 0;  /* not set yet */
1597
1598   fmt = ConvertPixelFormatWGLtoGLX(gdi_display, physDev->current_pf, TRUE, &tmp);
1599   if(!fmt)
1600   {
1601     ERR("Unable to find a WineGLPixelFormat for iPixelFormat=%d\n", physDev->current_pf);
1602     return 0;
1603   }
1604   else if(fmt->offscreenOnly)
1605   {
1606     /* Offscreen formats can't be used with traditional WGL calls.
1607      * As has been verified on Windows GetPixelFormat doesn't fail but returns iPixelFormat=1. */
1608      TRACE("Returning iPixelFormat=1 for offscreen format: %d\n", fmt->iPixelFormat);
1609     return 1;
1610   }
1611
1612   TRACE("(%p): returns %d\n", physDev, physDev->current_pf);
1613   return physDev->current_pf;
1614 }
1615
1616 /* This function is the core of X11DRV_SetPixelFormat and X11DRV_SetPixelFormatWINE.
1617  * Both functions are the same except that X11DRV_SetPixelFormatWINE allows you to
1618  * set the pixel format multiple times. */
1619 static BOOL internal_SetPixelFormat(X11DRV_PDEVICE *physDev,
1620                            int iPixelFormat,
1621                            const PIXELFORMATDESCRIPTOR *ppfd) {
1622     WineGLPixelFormat *fmt;
1623     int value;
1624     HWND hwnd;
1625
1626     /* SetPixelFormat is not allowed on the X root_window e.g. GetDC(0) */
1627     if(get_glxdrawable(physDev) == root_window)
1628     {
1629         ERR("Invalid operation on root_window\n");
1630         return FALSE;
1631     }
1632
1633     /* Check if iPixelFormat is in our list of supported formats to see if it is supported. */
1634     fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, FALSE /* Offscreen */, &value);
1635     if(!fmt) {
1636         ERR("Invalid iPixelFormat: %d\n", iPixelFormat);
1637         return FALSE;
1638     }
1639
1640     wine_tsx11_lock();
1641     pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &value);
1642     wine_tsx11_unlock();
1643
1644     hwnd = WindowFromDC(physDev->hdc);
1645     if(hwnd) {
1646         if(!(value&GLX_WINDOW_BIT)) {
1647             WARN("Pixel format %d is not compatible for window rendering\n", iPixelFormat);
1648             return FALSE;
1649         }
1650
1651         if(!SendMessageW(hwnd, WM_X11DRV_SET_WIN_FORMAT, fmt->fmt_id, 0)) {
1652             ERR("Couldn't set format of the window, returning failure\n");
1653             return FALSE;
1654         }
1655     }
1656     else if(physDev->bitmap) {
1657         if(!(value&GLX_PIXMAP_BIT)) {
1658             WARN("Pixel format %d is not compatible for bitmap rendering\n", iPixelFormat);
1659             return FALSE;
1660         }
1661
1662         physDev->bitmap->glxpixmap = create_bitmap_glxpixmap(physDev, fmt);
1663         if(!physDev->bitmap->glxpixmap) {
1664             WARN("Couldn't create glxpixmap for pixel format %d\n", iPixelFormat);
1665             return FALSE;
1666         }
1667     }
1668     else {
1669         FIXME("called on a non-window, non-bitmap object?\n");
1670     }
1671
1672     physDev->current_pf = iPixelFormat;
1673
1674     if (TRACE_ON(wgl)) {
1675         int gl_test = 0;
1676
1677         wine_tsx11_lock();
1678         gl_test = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_FBCONFIG_ID, &value);
1679         if (gl_test) {
1680            ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
1681         } else {
1682             TRACE(" FBConfig have :\n");
1683             TRACE(" - FBCONFIG_ID   0x%x\n", value);
1684             pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_VISUAL_ID, &value);
1685             TRACE(" - VISUAL_ID     0x%x\n", value);
1686             pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &value);
1687             TRACE(" - DRAWABLE_TYPE 0x%x\n", value);
1688         }
1689         wine_tsx11_unlock();
1690     }
1691     return TRUE;
1692 }
1693
1694
1695 /**
1696  * X11DRV_SetPixelFormat
1697  *
1698  * Set the pixel-format id used by this DC
1699  */
1700 BOOL CDECL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
1701                            int iPixelFormat,
1702                            const PIXELFORMATDESCRIPTOR *ppfd) {
1703     TRACE("(%p,%d,%p)\n", physDev, iPixelFormat, ppfd);
1704
1705     if (!has_opengl()) return FALSE;
1706
1707     if(physDev->current_pf)  /* cannot change it if already set */
1708         return (physDev->current_pf == iPixelFormat);
1709
1710     return internal_SetPixelFormat(physDev, iPixelFormat, ppfd);
1711 }
1712
1713 /**
1714  * X11DRV_wglCopyContext
1715  *
1716  * For OpenGL32 wglCopyContext.
1717  */
1718 BOOL CDECL X11DRV_wglCopyContext(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask) {
1719     Wine_GLContext *src = (Wine_GLContext*)hglrcSrc;
1720     Wine_GLContext *dst = (Wine_GLContext*)hglrcDst;
1721
1722     TRACE("hglrcSrc: (%p), hglrcDst: (%p), mask: %#x\n", hglrcSrc, hglrcDst, mask);
1723
1724     wine_tsx11_lock();
1725     pglXCopyContext(gdi_display, src->ctx, dst->ctx, mask);
1726     wine_tsx11_unlock();
1727
1728     /* As opposed to wglCopyContext, glXCopyContext doesn't return anything, so hopefully we passed */
1729     return TRUE;
1730 }
1731
1732 /**
1733  * X11DRV_wglCreateContext
1734  *
1735  * For OpenGL32 wglCreateContext.
1736  */
1737 HGLRC CDECL X11DRV_wglCreateContext(X11DRV_PDEVICE *physDev)
1738 {
1739     Wine_GLContext *ret;
1740     WineGLPixelFormat *fmt;
1741     int hdcPF = physDev->current_pf;
1742     int fmt_count = 0;
1743     HDC hdc = physDev->hdc;
1744
1745     TRACE("(%p)->(PF:%d)\n", hdc, hdcPF);
1746
1747     if (!has_opengl()) return 0;
1748
1749     fmt = ConvertPixelFormatWGLtoGLX(gdi_display, hdcPF, TRUE /* Offscreen */, &fmt_count);
1750     /* We can render using the iPixelFormat (1) of Wine's Main visual AND using some offscreen formats.
1751      * Note that standard WGL-calls don't recognize offscreen-only formats. For that reason pbuffers
1752      * use a sort of 'proxy' HDC (wglGetPbufferDCARB).
1753      * If this fails something is very wrong on the system. */
1754     if(!fmt) {
1755         ERR("Cannot get FB Config for iPixelFormat %d, expect problems!\n", hdcPF);
1756         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1757         return NULL;
1758     }
1759
1760     wine_tsx11_lock();
1761     ret = alloc_context();
1762     ret->hdc = hdc;
1763     ret->fmt = fmt;
1764     ret->has_been_current = FALSE;
1765     ret->sharing = FALSE;
1766
1767     ret->vis = pglXGetVisualFromFBConfig(gdi_display, fmt->fbconfig);
1768     ret->ctx = create_glxcontext(gdi_display, ret, NULL);
1769     wine_tsx11_unlock();
1770
1771     TRACE(" creating context %p (GL context creation delayed)\n", ret);
1772     return (HGLRC) ret;
1773 }
1774
1775 /**
1776  * X11DRV_wglDeleteContext
1777  *
1778  * For OpenGL32 wglDeleteContext.
1779  */
1780 BOOL CDECL X11DRV_wglDeleteContext(HGLRC hglrc)
1781 {
1782     Wine_GLContext *ctx = (Wine_GLContext *) hglrc;
1783
1784     TRACE("(%p)\n", hglrc);
1785
1786     if (!has_opengl()) return 0;
1787
1788     if (!is_valid_context(ctx))
1789     {
1790         WARN("Error deleting context !\n");
1791         SetLastError(ERROR_INVALID_HANDLE);
1792         return FALSE;
1793     }
1794
1795     /* WGL doesn't allow deletion of a context which is current in another thread */
1796     if (ctx->tid != 0 && ctx->tid != GetCurrentThreadId())
1797     {
1798         TRACE("Cannot delete context=%p because it is current in another thread.\n", ctx);
1799         SetLastError(ERROR_BUSY);
1800         return FALSE;
1801     }
1802
1803     /* WGL makes a context not current if it is active before deletion. GLX waits until the context is not current. */
1804     if (ctx == NtCurrentTeb()->glContext)
1805         wglMakeCurrent(ctx->hdc, NULL);
1806
1807     if (ctx->ctx)
1808     {
1809         wine_tsx11_lock();
1810         pglXDestroyContext(gdi_display, ctx->ctx);
1811         wine_tsx11_unlock();
1812     }
1813
1814     free_context(ctx);
1815     return TRUE;
1816 }
1817
1818 /**
1819  * X11DRV_wglGetCurrentReadDCARB
1820  *
1821  * For OpenGL32 wglGetCurrentReadDCARB.
1822  */
1823 static HDC WINAPI X11DRV_wglGetCurrentReadDCARB(void)
1824 {
1825     HDC ret = 0;
1826     Wine_GLContext *ctx = NtCurrentTeb()->glContext;
1827
1828     if (ctx) ret = ctx->read_hdc;
1829
1830     TRACE(" returning %p (GL drawable %lu)\n", ret, ctx ? ctx->drawables[1] : 0);
1831     return ret;
1832 }
1833
1834 /**
1835  * X11DRV_wglGetProcAddress
1836  *
1837  * For OpenGL32 wglGetProcAddress.
1838  */
1839 PROC CDECL X11DRV_wglGetProcAddress(LPCSTR lpszProc)
1840 {
1841     int i, j;
1842     const WineGLExtension *ext;
1843
1844     int padding = 32 - strlen(lpszProc);
1845     if (padding < 0)
1846         padding = 0;
1847
1848     if (!has_opengl()) return NULL;
1849
1850     /* Check the table of WGL extensions to see if we need to return a WGL extension
1851      * or a function pointer to a native OpenGL function. */
1852     if(strncmp(lpszProc, "wgl", 3) != 0) {
1853         return pglXGetProcAddressARB((const GLubyte*)lpszProc);
1854     } else {
1855         TRACE("('%s'):%*s", lpszProc, padding, " ");
1856         for (i = 0; i < WineGLExtensionListSize; ++i) {
1857             ext = WineGLExtensionList[i];
1858             for (j = 0; ext->extEntryPoints[j].funcName; ++j) {
1859                 if (strcmp(ext->extEntryPoints[j].funcName, lpszProc) == 0) {
1860                     TRACE("(%p) - WineGL\n", ext->extEntryPoints[j].funcAddress);
1861                     return ext->extEntryPoints[j].funcAddress;
1862                 }
1863             }
1864         }
1865     }
1866
1867     WARN("(%s) - not found\n", lpszProc);
1868     return NULL;
1869 }
1870
1871 /**
1872  * X11DRV_wglMakeCurrent
1873  *
1874  * For OpenGL32 wglMakeCurrent.
1875  */
1876 BOOL CDECL X11DRV_wglMakeCurrent(X11DRV_PDEVICE *physDev, HGLRC hglrc) {
1877     BOOL ret;
1878     HDC hdc = physDev->hdc;
1879     DWORD type = GetObjectType(hdc);
1880     Wine_GLContext *ctx = (Wine_GLContext *) hglrc;
1881
1882     TRACE("(%p,%p)\n", hdc, hglrc);
1883
1884     if (!has_opengl()) return FALSE;
1885
1886     wine_tsx11_lock();
1887     if (hglrc == NULL)
1888     {
1889         Wine_GLContext *prev_ctx = NtCurrentTeb()->glContext;
1890         if (prev_ctx) prev_ctx->tid = 0;
1891
1892         ret = pglXMakeCurrent(gdi_display, None, NULL);
1893         NtCurrentTeb()->glContext = NULL;
1894     }
1895     else if (ctx->fmt->iPixelFormat != physDev->current_pf)
1896     {
1897         WARN( "mismatched pixel format hdc %p %u ctx %p %u\n",
1898               hdc, physDev->current_pf, ctx, ctx->fmt->iPixelFormat );
1899         SetLastError( ERROR_INVALID_PIXEL_FORMAT );
1900         ret = FALSE;
1901     }
1902     else
1903     {
1904         Drawable drawable = get_glxdrawable(physDev);
1905         Wine_GLContext *prev_ctx = NtCurrentTeb()->glContext;
1906         if (prev_ctx) prev_ctx->tid = 0;
1907
1908         /* The describe lines below are for debugging purposes only */
1909         if (TRACE_ON(wgl)) {
1910             describeDrawable(physDev);
1911             describeContext(ctx);
1912         }
1913
1914         TRACE(" make current for dis %p, drawable %p, ctx %p\n", gdi_display, (void*) drawable, ctx->ctx);
1915         ret = pglXMakeCurrent(gdi_display, drawable, ctx->ctx);
1916         NtCurrentTeb()->glContext = ctx;
1917
1918         if(ret)
1919         {
1920             ctx->has_been_current = TRUE;
1921             ctx->tid = GetCurrentThreadId();
1922             ctx->hdc = hdc;
1923             ctx->read_hdc = hdc;
1924             ctx->drawables[0] = drawable;
1925             ctx->drawables[1] = drawable;
1926             ctx->refresh_drawables = FALSE;
1927
1928             if (type == OBJ_MEMDC)
1929             {
1930                 ctx->do_escape = TRUE;
1931                 pglDrawBuffer(GL_FRONT_LEFT);
1932             }
1933         }
1934     }
1935     wine_tsx11_unlock();
1936     TRACE(" returning %s\n", (ret ? "True" : "False"));
1937     return ret;
1938 }
1939
1940 /**
1941  * X11DRV_wglMakeContextCurrentARB
1942  *
1943  * For OpenGL32 wglMakeContextCurrentARB
1944  */
1945 BOOL CDECL X11DRV_wglMakeContextCurrentARB(X11DRV_PDEVICE* pDrawDev, X11DRV_PDEVICE* pReadDev, HGLRC hglrc)
1946 {
1947     BOOL ret;
1948
1949     TRACE("(%p,%p,%p)\n", pDrawDev, pReadDev, hglrc);
1950
1951     if (!has_opengl()) return 0;
1952
1953     wine_tsx11_lock();
1954     if (hglrc == NULL)
1955     {
1956         Wine_GLContext *prev_ctx = NtCurrentTeb()->glContext;
1957         if (prev_ctx) prev_ctx->tid = 0;
1958
1959         ret = pglXMakeCurrent(gdi_display, None, NULL);
1960         NtCurrentTeb()->glContext = NULL;
1961     }
1962     else
1963     {
1964         if (NULL == pglXMakeContextCurrent) {
1965             ret = FALSE;
1966         } else {
1967             Wine_GLContext *prev_ctx = NtCurrentTeb()->glContext;
1968             Wine_GLContext *ctx = (Wine_GLContext *) hglrc;
1969             Drawable d_draw = get_glxdrawable(pDrawDev);
1970             Drawable d_read = get_glxdrawable(pReadDev);
1971
1972             if (prev_ctx) prev_ctx->tid = 0;
1973
1974             ctx->has_been_current = TRUE;
1975             ctx->tid = GetCurrentThreadId();
1976             ctx->hdc = pDrawDev->hdc;
1977             ctx->read_hdc = pReadDev->hdc;
1978             ctx->drawables[0] = d_draw;
1979             ctx->drawables[1] = d_read;
1980             ctx->refresh_drawables = FALSE;
1981             ret = pglXMakeContextCurrent(gdi_display, d_draw, d_read, ctx->ctx);
1982             NtCurrentTeb()->glContext = ctx;
1983         }
1984     }
1985     wine_tsx11_unlock();
1986
1987     TRACE(" returning %s\n", (ret ? "True" : "False"));
1988     return ret;
1989 }
1990
1991 /**
1992  * X11DRV_wglShareLists
1993  *
1994  * For OpenGL32 wglShareLists.
1995  */
1996 BOOL CDECL X11DRV_wglShareLists(HGLRC hglrc1, HGLRC hglrc2) {
1997     Wine_GLContext *org  = (Wine_GLContext *) hglrc1;
1998     Wine_GLContext *dest = (Wine_GLContext *) hglrc2;
1999
2000     TRACE("(%p, %p)\n", org, dest);
2001
2002     if (!has_opengl()) return FALSE;
2003
2004     /* Sharing of display lists works differently in GLX and WGL. In case of GLX it is done
2005      * at context creation time but in case of WGL it is done using wglShareLists.
2006      * In the past we tried to emulate wglShareLists by delaying GLX context creation until
2007      * either a wglMakeCurrent or wglShareLists. This worked fine for most apps but it causes
2008      * issues for OpenGL 3 because there wglCreateContextAttribsARB can fail in a lot of cases,
2009      * so there delaying context creation doesn't work.
2010      *
2011      * The new approach is to create a GLX context in wglCreateContext / wglCreateContextAttribsARB
2012      * and when a program requests sharing we recreate the destination context if it hasn't been made
2013      * current or when it hasn't shared display lists before.
2014      */
2015
2016     if((org->has_been_current && dest->has_been_current) || dest->has_been_current)
2017     {
2018         ERR("Could not share display lists, one of the contexts has been current already !\n");
2019         return FALSE;
2020     }
2021     else if(dest->sharing)
2022     {
2023         ERR("Could not share display lists because hglrc2 has already shared lists before\n");
2024         return FALSE;
2025     }
2026     else
2027     {
2028         if((GetObjectType(org->hdc) == OBJ_MEMDC) ^ (GetObjectType(dest->hdc) == OBJ_MEMDC))
2029         {
2030             WARN("Attempting to share a context between a direct and indirect rendering context, expect issues!\n");
2031         }
2032
2033         wine_tsx11_lock();
2034         describeContext(org);
2035         describeContext(dest);
2036
2037         /* Re-create the GLX context and share display lists */
2038         pglXDestroyContext(gdi_display, dest->ctx);
2039         dest->ctx = create_glxcontext(gdi_display, dest, org->ctx);
2040         wine_tsx11_unlock();
2041         TRACE(" re-created an OpenGL context (%p) for Wine context %p sharing lists with OpenGL ctx %p\n", dest->ctx, dest, org->ctx);
2042
2043         org->sharing = TRUE;
2044         dest->sharing = TRUE;
2045         return TRUE;
2046     }
2047     return FALSE;
2048 }
2049
2050 static BOOL internal_wglUseFontBitmaps(HDC hdc, DWORD first, DWORD count, DWORD listBase, DWORD (WINAPI *GetGlyphOutline_ptr)(HDC,UINT,UINT,LPGLYPHMETRICS,DWORD,LPVOID,const MAT2*))
2051 {
2052      /* We are running using client-side rendering fonts... */
2053      GLYPHMETRICS gm;
2054      unsigned int glyph, size = 0;
2055      void *bitmap = NULL, *gl_bitmap = NULL;
2056      int org_alignment;
2057
2058      wine_tsx11_lock();
2059      pglGetIntegerv(GL_UNPACK_ALIGNMENT, &org_alignment);
2060      pglPixelStorei(GL_UNPACK_ALIGNMENT, 4);
2061      wine_tsx11_unlock();
2062
2063      for (glyph = first; glyph < first + count; glyph++) {
2064          static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
2065          unsigned int needed_size = GetGlyphOutline_ptr(hdc, glyph, GGO_BITMAP, &gm, 0, NULL, &identity);
2066          unsigned int height, width_int;
2067
2068          TRACE("Glyph : %3d / List : %d\n", glyph, listBase);
2069          if (needed_size == GDI_ERROR) {
2070              TRACE("  - needed size : %d (GDI_ERROR)\n", needed_size);
2071              goto error;
2072          } else {
2073              TRACE("  - needed size : %d\n", needed_size);
2074          }
2075
2076          if (needed_size > size) {
2077              size = needed_size;
2078              HeapFree(GetProcessHeap(), 0, bitmap);
2079              HeapFree(GetProcessHeap(), 0, gl_bitmap);
2080              bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
2081              gl_bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
2082          }
2083          if (GetGlyphOutline_ptr(hdc, glyph, GGO_BITMAP, &gm, size, bitmap, &identity) == GDI_ERROR)
2084              goto error;
2085          if (TRACE_ON(wgl)) {
2086              unsigned int height, width, bitmask;
2087              unsigned char *bitmap_ = bitmap;
2088
2089              TRACE("  - bbox : %d x %d\n", gm.gmBlackBoxX, gm.gmBlackBoxY);
2090              TRACE("  - origin : (%d , %d)\n", gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
2091              TRACE("  - increment : %d - %d\n", gm.gmCellIncX, gm.gmCellIncY);
2092              if (needed_size != 0) {
2093                  TRACE("  - bitmap :\n");
2094                  for (height = 0; height < gm.gmBlackBoxY; height++) {
2095                      TRACE("      ");
2096                      for (width = 0, bitmask = 0x80; width < gm.gmBlackBoxX; width++, bitmask >>= 1) {
2097                          if (bitmask == 0) {
2098                              bitmap_ += 1;
2099                              bitmask = 0x80;
2100                          }
2101                          if (*bitmap_ & bitmask)
2102                              TRACE("*");
2103                          else
2104                              TRACE(" ");
2105                      }
2106                      bitmap_ += (4 - ((UINT_PTR)bitmap_ & 0x03));
2107                      TRACE("\n");
2108                  }
2109              }
2110          }
2111
2112          /* In OpenGL, the bitmap is drawn from the bottom to the top... So we need to invert the
2113          * glyph for it to be drawn properly.
2114          */
2115          if (needed_size != 0) {
2116              width_int = (gm.gmBlackBoxX + 31) / 32;
2117              for (height = 0; height < gm.gmBlackBoxY; height++) {
2118                  unsigned int width;
2119                  for (width = 0; width < width_int; width++) {
2120                      ((int *) gl_bitmap)[(gm.gmBlackBoxY - height - 1) * width_int + width] =
2121                      ((int *) bitmap)[height * width_int + width];
2122                  }
2123              }
2124          }
2125
2126          wine_tsx11_lock();
2127          pglNewList(listBase++, GL_COMPILE);
2128          if (needed_size != 0) {
2129              pglBitmap(gm.gmBlackBoxX, gm.gmBlackBoxY,
2130                      0 - gm.gmptGlyphOrigin.x, (int) gm.gmBlackBoxY - gm.gmptGlyphOrigin.y,
2131                      gm.gmCellIncX, gm.gmCellIncY,
2132                      gl_bitmap);
2133          } else {
2134              /* This is the case of 'empty' glyphs like the space character */
2135              pglBitmap(0, 0, 0, 0, gm.gmCellIncX, gm.gmCellIncY, NULL);
2136          }
2137          pglEndList();
2138          wine_tsx11_unlock();
2139      }
2140
2141      wine_tsx11_lock();
2142      pglPixelStorei(GL_UNPACK_ALIGNMENT, org_alignment);
2143      wine_tsx11_unlock();
2144
2145      HeapFree(GetProcessHeap(), 0, bitmap);
2146      HeapFree(GetProcessHeap(), 0, gl_bitmap);
2147      return TRUE;
2148
2149   error:
2150      wine_tsx11_lock();
2151      pglPixelStorei(GL_UNPACK_ALIGNMENT, org_alignment);
2152      wine_tsx11_unlock();
2153
2154      HeapFree(GetProcessHeap(), 0, bitmap);
2155      HeapFree(GetProcessHeap(), 0, gl_bitmap);
2156      return FALSE;
2157 }
2158
2159 /**
2160  * X11DRV_wglUseFontBitmapsA
2161  *
2162  * For OpenGL32 wglUseFontBitmapsA.
2163  */
2164 BOOL CDECL X11DRV_wglUseFontBitmapsA(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
2165 {
2166      Font fid = physDev->font;
2167
2168      TRACE("(%p, %d, %d, %d) using font %ld\n", physDev->hdc, first, count, listBase, fid);
2169
2170      if (!has_opengl()) return FALSE;
2171
2172      if (fid == 0) {
2173          return internal_wglUseFontBitmaps(physDev->hdc, first, count, listBase, GetGlyphOutlineA);
2174      }
2175
2176      wine_tsx11_lock();
2177      /* I assume that the glyphs are at the same position for X and for Windows */
2178      pglXUseXFont(fid, first, count, listBase);
2179      wine_tsx11_unlock();
2180      return TRUE;
2181 }
2182
2183 /**
2184  * X11DRV_wglUseFontBitmapsW
2185  *
2186  * For OpenGL32 wglUseFontBitmapsW.
2187  */
2188 BOOL CDECL X11DRV_wglUseFontBitmapsW(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
2189 {
2190      Font fid = physDev->font;
2191
2192      TRACE("(%p, %d, %d, %d) using font %ld\n", physDev->hdc, first, count, listBase, fid);
2193
2194      if (!has_opengl()) return FALSE;
2195
2196      if (fid == 0) {
2197          return internal_wglUseFontBitmaps(physDev->hdc, first, count, listBase, GetGlyphOutlineW);
2198      }
2199
2200      WARN("Using the glX API for the WCHAR variant - some characters may come out incorrectly !\n");
2201
2202      wine_tsx11_lock();
2203      /* I assume that the glyphs are at the same position for X and for Windows */
2204      pglXUseXFont(fid, first, count, listBase);
2205      wine_tsx11_unlock();
2206      return TRUE;
2207 }
2208
2209 /* WGL helper function which handles differences in glGetIntegerv from WGL and GLX */
2210 static void WINAPI X11DRV_wglGetIntegerv(GLenum pname, GLint* params)
2211 {
2212     wine_tsx11_lock();
2213     switch(pname)
2214     {
2215     case GL_DEPTH_BITS:
2216         {
2217             Wine_GLContext *ctx = NtCurrentTeb()->glContext;
2218
2219             pglGetIntegerv(pname, params);
2220             /**
2221              * if we cannot find a Wine Context
2222              * we only have the default wine desktop context,
2223              * so if we have only a 24 depth say we have 32
2224              */
2225             if (!ctx && *params == 24) {
2226                 *params = 32;
2227             }
2228             TRACE("returns GL_DEPTH_BITS as '%d'\n", *params);
2229             break;
2230         }
2231     case GL_ALPHA_BITS:
2232         {
2233             Wine_GLContext *ctx = NtCurrentTeb()->glContext;
2234
2235             pglXGetFBConfigAttrib(gdi_display, ctx->fmt->fbconfig, GLX_ALPHA_SIZE, params);
2236             TRACE("returns GL_ALPHA_BITS as '%d'\n", *params);
2237             break;
2238         }
2239     default:
2240         pglGetIntegerv(pname, params);
2241         break;
2242     }
2243     wine_tsx11_unlock();
2244 }
2245
2246 void flush_gl_drawable(X11DRV_PDEVICE *physDev)
2247 {
2248     int w, h;
2249
2250     if (!physDev->gl_copy)
2251         return;
2252
2253     w = physDev->dc_rect.right - physDev->dc_rect.left;
2254     h = physDev->dc_rect.bottom - physDev->dc_rect.top;
2255
2256     if(w > 0 && h > 0) {
2257         Drawable src = physDev->pixmap;
2258         if(!src) src = physDev->gl_drawable;
2259
2260         /* The GL drawable may be lagged behind if we don't flush first, so
2261          * flush the display make sure we copy up-to-date data */
2262         wine_tsx11_lock();
2263         XFlush(gdi_display);
2264         XSetFunction(gdi_display, physDev->gc, GXcopy);
2265         XCopyArea(gdi_display, src, physDev->drawable, physDev->gc, 0, 0, w, h,
2266                   physDev->dc_rect.left, physDev->dc_rect.top);
2267         wine_tsx11_unlock();
2268     }
2269 }
2270
2271
2272 static void WINAPI X11DRV_wglFinish(void)
2273 {
2274     Wine_GLContext *ctx = NtCurrentTeb()->glContext;
2275     enum x11drv_escape_codes code = X11DRV_FLUSH_GL_DRAWABLE;
2276
2277     wine_tsx11_lock();
2278     sync_context(ctx);
2279     pglFinish();
2280     wine_tsx11_unlock();
2281     if (ctx) ExtEscape(ctx->hdc, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, 0, NULL );
2282 }
2283
2284 static void WINAPI X11DRV_wglFlush(void)
2285 {
2286     Wine_GLContext *ctx = NtCurrentTeb()->glContext;
2287     enum x11drv_escape_codes code = X11DRV_FLUSH_GL_DRAWABLE;
2288
2289     wine_tsx11_lock();
2290     sync_context(ctx);
2291     pglFlush();
2292     wine_tsx11_unlock();
2293     if (ctx) ExtEscape(ctx->hdc, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, 0, NULL );
2294 }
2295
2296 /**
2297  * X11DRV_wglCreateContextAttribsARB
2298  *
2299  * WGL_ARB_create_context: wglCreateContextAttribsARB
2300  */
2301 HGLRC CDECL X11DRV_wglCreateContextAttribsARB(X11DRV_PDEVICE *physDev, HGLRC hShareContext, const int* attribList)
2302 {
2303     Wine_GLContext *ret;
2304     WineGLPixelFormat *fmt;
2305     int hdcPF = physDev->current_pf;
2306     int fmt_count = 0;
2307
2308     TRACE("(%p %p %p)\n", physDev, hShareContext, attribList);
2309
2310     if (!has_opengl()) return 0;
2311
2312     fmt = ConvertPixelFormatWGLtoGLX(gdi_display, hdcPF, TRUE /* Offscreen */, &fmt_count);
2313     /* wglCreateContextAttribsARB supports ALL pixel formats, so also offscreen ones.
2314      * If this fails something is very wrong on the system. */
2315     if(!fmt)
2316     {
2317         ERR("Cannot get FB Config for iPixelFormat %d, expect problems!\n", hdcPF);
2318         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
2319         return NULL;
2320     }
2321
2322     wine_tsx11_lock();
2323     ret = alloc_context();
2324     wine_tsx11_unlock();
2325     ret->hdc = physDev->hdc;
2326     ret->fmt = fmt;
2327     ret->vis = NULL; /* glXCreateContextAttribsARB requires a fbconfig instead of a visual */
2328     ret->gl3_context = TRUE;
2329
2330     ret->numAttribs = 0;
2331     if(attribList)
2332     {
2333         int *pAttribList = (int*)attribList;
2334         int *pContextAttribList = &ret->attribList[0];
2335         /* attribList consists of pairs {token, value] terminated with 0 */
2336         while(pAttribList[0] != 0)
2337         {
2338             TRACE("%#x %#x\n", pAttribList[0], pAttribList[1]);
2339             switch(pAttribList[0])
2340             {
2341                 case WGL_CONTEXT_MAJOR_VERSION_ARB:
2342                     pContextAttribList[0] = GLX_CONTEXT_MAJOR_VERSION_ARB;
2343                     pContextAttribList[1] = pAttribList[1];
2344                     break;
2345                 case WGL_CONTEXT_MINOR_VERSION_ARB:
2346                     pContextAttribList[0] = GLX_CONTEXT_MINOR_VERSION_ARB;
2347                     pContextAttribList[1] = pAttribList[1];
2348                     break;
2349                 case WGL_CONTEXT_LAYER_PLANE_ARB:
2350                     break;
2351                 case WGL_CONTEXT_FLAGS_ARB:
2352                     pContextAttribList[0] = GLX_CONTEXT_FLAGS_ARB;
2353                     pContextAttribList[1] = pAttribList[1];
2354                     break;
2355                 case WGL_CONTEXT_PROFILE_MASK_ARB:
2356                     pContextAttribList[0] = GLX_CONTEXT_PROFILE_MASK_ARB;
2357                     pContextAttribList[1] = pAttribList[1];
2358                     break;
2359                 default:
2360                     ERR("Unhandled attribList pair: %#x %#x\n", pAttribList[0], pAttribList[1]);
2361             }
2362
2363             ret->numAttribs++;
2364             pAttribList += 2;
2365             pContextAttribList += 2;
2366         }
2367     }
2368
2369     wine_tsx11_lock();
2370     X11DRV_expect_error(gdi_display, GLXErrorHandler, NULL);
2371     ret->ctx = create_glxcontext(gdi_display, ret, NULL);
2372
2373     XSync(gdi_display, False);
2374     if(X11DRV_check_error() || !ret->ctx)
2375     {
2376         /* In the future we should convert the GLX error to a win32 one here if needed */
2377         ERR("Context creation failed\n");
2378         free_context(ret);
2379         wine_tsx11_unlock();
2380         return NULL;
2381     }
2382
2383     wine_tsx11_unlock();
2384     TRACE(" creating context %p\n", ret);
2385     return (HGLRC) ret;
2386 }
2387
2388 /**
2389  * X11DRV_wglGetExtensionsStringARB
2390  *
2391  * WGL_ARB_extensions_string: wglGetExtensionsStringARB
2392  */
2393 static const char * WINAPI X11DRV_wglGetExtensionsStringARB(HDC hdc) {
2394     TRACE("() returning \"%s\"\n", WineGLInfo.wglExtensions);
2395     return WineGLInfo.wglExtensions;
2396 }
2397
2398 /**
2399  * X11DRV_wglCreatePbufferARB
2400  *
2401  * WGL_ARB_pbuffer: wglCreatePbufferARB
2402  */
2403 static HPBUFFERARB WINAPI X11DRV_wglCreatePbufferARB(HDC hdc, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList)
2404 {
2405     Wine_GLPBuffer* object = NULL;
2406     WineGLPixelFormat *fmt = NULL;
2407     int nCfgs = 0;
2408     int attribs[256];
2409     int nAttribs = 0;
2410
2411     TRACE("(%p, %d, %d, %d, %p)\n", hdc, iPixelFormat, iWidth, iHeight, piAttribList);
2412
2413     if (0 >= iPixelFormat) {
2414         ERR("(%p): unexpected iPixelFormat(%d) <= 0, returns NULL\n", hdc, iPixelFormat);
2415         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
2416         return NULL; /* unexpected error */
2417     }
2418
2419     /* Convert the WGL pixelformat to a GLX format, if it fails then the format is invalid */
2420     fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, TRUE /* Offscreen */, &nCfgs);
2421     if(!fmt) {
2422         ERR("(%p): unexpected iPixelFormat(%d) > nFormats(%d), returns NULL\n", hdc, iPixelFormat, nCfgs);
2423         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
2424         goto create_failed; /* unexpected error */
2425     }
2426
2427     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(Wine_GLPBuffer));
2428     if (NULL == object) {
2429         SetLastError(ERROR_NO_SYSTEM_RESOURCES);
2430         goto create_failed; /* unexpected error */
2431     }
2432     object->hdc = hdc;
2433     object->display = gdi_display;
2434     object->width = iWidth;
2435     object->height = iHeight;
2436     object->fmt = fmt;
2437
2438     PUSH2(attribs, GLX_PBUFFER_WIDTH,  iWidth);
2439     PUSH2(attribs, GLX_PBUFFER_HEIGHT, iHeight);
2440     while (piAttribList && 0 != *piAttribList) {
2441         int attr_v;
2442         switch (*piAttribList) {
2443             case WGL_PBUFFER_LARGEST_ARB: {
2444                 ++piAttribList;
2445                 attr_v = *piAttribList;
2446                 TRACE("WGL_LARGEST_PBUFFER_ARB = %d\n", attr_v);
2447                 PUSH2(attribs, GLX_LARGEST_PBUFFER, attr_v);
2448                 break;
2449             }
2450
2451             case WGL_TEXTURE_FORMAT_ARB: {
2452                 ++piAttribList;
2453                 attr_v = *piAttribList;
2454                 TRACE("WGL_render_texture Attribute: WGL_TEXTURE_FORMAT_ARB as %x\n", attr_v);
2455                 if (use_render_texture_ati) {
2456                     int type = 0;
2457                     switch (attr_v) {
2458                         case WGL_NO_TEXTURE_ARB: type = GLX_NO_TEXTURE_ATI; break ;
2459                         case WGL_TEXTURE_RGB_ARB: type = GLX_TEXTURE_RGB_ATI; break ;
2460                         case WGL_TEXTURE_RGBA_ARB: type = GLX_TEXTURE_RGBA_ATI; break ;
2461                         default:
2462                             SetLastError(ERROR_INVALID_DATA);
2463                             goto create_failed;
2464                     }
2465                     object->use_render_texture = 1;
2466                     PUSH2(attribs, GLX_TEXTURE_FORMAT_ATI, type);
2467                 } else {
2468                     if (WGL_NO_TEXTURE_ARB == attr_v) {
2469                         object->use_render_texture = 0;
2470                     } else {
2471                         if (!use_render_texture_emulation) {
2472                             SetLastError(ERROR_INVALID_DATA);
2473                             goto create_failed;
2474                         }
2475                         switch (attr_v) {
2476                             case WGL_TEXTURE_RGB_ARB:
2477                                 object->use_render_texture = GL_RGB;
2478                                 object->texture_bpp = 3;
2479                                 object->texture_format = GL_RGB;
2480                                 object->texture_type = GL_UNSIGNED_BYTE;
2481                                 break;
2482                             case WGL_TEXTURE_RGBA_ARB:
2483                                 object->use_render_texture = GL_RGBA;
2484                                 object->texture_bpp = 4;
2485                                 object->texture_format = GL_RGBA;
2486                                 object->texture_type = GL_UNSIGNED_BYTE;
2487                                 break;
2488
2489                             /* WGL_FLOAT_COMPONENTS_NV */
2490                             case WGL_TEXTURE_FLOAT_R_NV:
2491                                 object->use_render_texture = GL_FLOAT_R_NV;
2492                                 object->texture_bpp = 4;
2493                                 object->texture_format = GL_RED;
2494                                 object->texture_type = GL_FLOAT;
2495                                 break;
2496                             case WGL_TEXTURE_FLOAT_RG_NV:
2497                                 object->use_render_texture = GL_FLOAT_RG_NV;
2498                                 object->texture_bpp = 8;
2499                                 object->texture_format = GL_LUMINANCE_ALPHA;
2500                                 object->texture_type = GL_FLOAT;
2501                                 break;
2502                             case WGL_TEXTURE_FLOAT_RGB_NV:
2503                                 object->use_render_texture = GL_FLOAT_RGB_NV;
2504                                 object->texture_bpp = 12;
2505                                 object->texture_format = GL_RGB;
2506                                 object->texture_type = GL_FLOAT;
2507                                 break;
2508                             case WGL_TEXTURE_FLOAT_RGBA_NV:
2509                                 object->use_render_texture = GL_FLOAT_RGBA_NV;
2510                                 object->texture_bpp = 16;
2511                                 object->texture_format = GL_RGBA;
2512                                 object->texture_type = GL_FLOAT;
2513                                 break;
2514                             default:
2515                                 ERR("Unknown texture format: %x\n", attr_v);
2516                                 SetLastError(ERROR_INVALID_DATA);
2517                                 goto create_failed;
2518                         }
2519                     }
2520                 }
2521                 break;
2522             }
2523
2524             case WGL_TEXTURE_TARGET_ARB: {
2525                 ++piAttribList;
2526                 attr_v = *piAttribList;
2527                 TRACE("WGL_render_texture Attribute: WGL_TEXTURE_TARGET_ARB as %x\n", attr_v);
2528                 if (use_render_texture_ati) {
2529                     int type = 0;
2530                     switch (attr_v) {
2531                         case WGL_NO_TEXTURE_ARB: type = GLX_NO_TEXTURE_ATI; break ;
2532                         case WGL_TEXTURE_CUBE_MAP_ARB: type = GLX_TEXTURE_CUBE_MAP_ATI; break ;
2533                         case WGL_TEXTURE_1D_ARB: type = GLX_TEXTURE_1D_ATI; break ;
2534                         case WGL_TEXTURE_2D_ARB: type = GLX_TEXTURE_2D_ATI; break ;
2535                         default:
2536                             SetLastError(ERROR_INVALID_DATA);
2537                             goto create_failed;
2538                     }
2539                     PUSH2(attribs, GLX_TEXTURE_TARGET_ATI, type);
2540                 } else {
2541                     if (WGL_NO_TEXTURE_ARB == attr_v) {
2542                         object->texture_target = 0;
2543                     } else {
2544                         if (!use_render_texture_emulation) {
2545                             SetLastError(ERROR_INVALID_DATA);
2546                             goto create_failed;
2547                         }
2548                         switch (attr_v) {
2549                             case WGL_TEXTURE_CUBE_MAP_ARB: {
2550                                 if (iWidth != iHeight) {
2551                                     SetLastError(ERROR_INVALID_DATA);
2552                                     goto create_failed;
2553                                 }
2554                                 object->texture_target = GL_TEXTURE_CUBE_MAP;
2555                                 object->texture_bind_target = GL_TEXTURE_BINDING_CUBE_MAP;
2556                                break;
2557                             }
2558                             case WGL_TEXTURE_1D_ARB: {
2559                                 if (1 != iHeight) {
2560                                     SetLastError(ERROR_INVALID_DATA);
2561                                     goto create_failed;
2562                                 }
2563                                 object->texture_target = GL_TEXTURE_1D;
2564                                 object->texture_bind_target = GL_TEXTURE_BINDING_1D;
2565                                 break;
2566                             }
2567                             case WGL_TEXTURE_2D_ARB: {
2568                                 object->texture_target = GL_TEXTURE_2D;
2569                                 object->texture_bind_target = GL_TEXTURE_BINDING_2D;
2570                                 break;
2571                             }
2572                             case WGL_TEXTURE_RECTANGLE_NV: {
2573                                 object->texture_target = GL_TEXTURE_RECTANGLE_NV;
2574                                 object->texture_bind_target = GL_TEXTURE_BINDING_RECTANGLE_NV;
2575                                 break;
2576                             }
2577                             default:
2578                                 ERR("Unknown texture target: %x\n", attr_v);
2579                                 SetLastError(ERROR_INVALID_DATA);
2580                                 goto create_failed;
2581                         }
2582                     }
2583                 }
2584                 break;
2585             }
2586
2587             case WGL_MIPMAP_TEXTURE_ARB: {
2588                 ++piAttribList;
2589                 attr_v = *piAttribList;
2590                 TRACE("WGL_render_texture Attribute: WGL_MIPMAP_TEXTURE_ARB as %x\n", attr_v);
2591                 if (use_render_texture_ati) {
2592                     PUSH2(attribs, GLX_MIPMAP_TEXTURE_ATI, attr_v);
2593                 } else {
2594                     if (!use_render_texture_emulation) {
2595                         SetLastError(ERROR_INVALID_DATA);
2596                         goto create_failed;
2597                     }
2598                 }
2599                 break;
2600             }
2601         }
2602         ++piAttribList;
2603     }
2604
2605     PUSH1(attribs, None);
2606     wine_tsx11_lock();
2607     object->drawable = pglXCreatePbuffer(gdi_display, fmt->fbconfig, attribs);
2608     wine_tsx11_unlock();
2609     TRACE("new Pbuffer drawable as %p\n", (void*) object->drawable);
2610     if (!object->drawable) {
2611         SetLastError(ERROR_NO_SYSTEM_RESOURCES);
2612         goto create_failed; /* unexpected error */
2613     }
2614     TRACE("->(%p)\n", object);
2615     return object;
2616
2617 create_failed:
2618     HeapFree(GetProcessHeap(), 0, object);
2619     TRACE("->(FAILED)\n");
2620     return NULL;
2621 }
2622
2623 /**
2624  * X11DRV_wglDestroyPbufferARB
2625  *
2626  * WGL_ARB_pbuffer: wglDestroyPbufferARB
2627  */
2628 static GLboolean WINAPI X11DRV_wglDestroyPbufferARB(HPBUFFERARB hPbuffer)
2629 {
2630     Wine_GLPBuffer* object = hPbuffer;
2631     TRACE("(%p)\n", hPbuffer);
2632     if (NULL == object) {
2633         SetLastError(ERROR_INVALID_HANDLE);
2634         return GL_FALSE;
2635     }
2636     wine_tsx11_lock();
2637     pglXDestroyPbuffer(object->display, object->drawable);
2638     wine_tsx11_unlock();
2639     HeapFree(GetProcessHeap(), 0, object);
2640     return GL_TRUE;
2641 }
2642
2643 /**
2644  * X11DRV_wglGetPbufferDCARB
2645  *
2646  * WGL_ARB_pbuffer: wglGetPbufferDCARB
2647  * The function wglGetPbufferDCARB returns a device context for a pbuffer.
2648  * Gdi32 implements the part of this function which creates a device context.
2649  * This part associates the physDev with the X drawable of the pbuffer.
2650  */
2651 HDC CDECL X11DRV_wglGetPbufferDCARB(X11DRV_PDEVICE *physDev, HPBUFFERARB hPbuffer)
2652 {
2653     Wine_GLPBuffer* object = hPbuffer;
2654     if (NULL == object) {
2655         SetLastError(ERROR_INVALID_HANDLE);
2656         return NULL;
2657     }
2658
2659     /* The function wglGetPbufferDCARB returns a DC to which the pbuffer can be connected.
2660      * All formats in our pixelformat list are compatible with each other and the main drawable. */
2661     physDev->current_pf = object->fmt->iPixelFormat;
2662     physDev->drawable = object->drawable;
2663     SetRect( &physDev->drawable_rect, 0, 0, object->width, object->height );
2664     physDev->dc_rect = physDev->drawable_rect;
2665
2666     TRACE("(%p)->(%p)\n", hPbuffer, physDev->hdc);
2667     return physDev->hdc;
2668 }
2669
2670 /**
2671  * X11DRV_wglQueryPbufferARB
2672  *
2673  * WGL_ARB_pbuffer: wglQueryPbufferARB
2674  */
2675 static GLboolean WINAPI X11DRV_wglQueryPbufferARB(HPBUFFERARB hPbuffer, int iAttribute, int *piValue)
2676 {
2677     Wine_GLPBuffer* object = hPbuffer;
2678     TRACE("(%p, 0x%x, %p)\n", hPbuffer, iAttribute, piValue);
2679     if (NULL == object) {
2680         SetLastError(ERROR_INVALID_HANDLE);
2681         return GL_FALSE;
2682     }
2683     switch (iAttribute) {
2684         case WGL_PBUFFER_WIDTH_ARB:
2685             wine_tsx11_lock();
2686             pglXQueryDrawable(object->display, object->drawable, GLX_WIDTH, (unsigned int*) piValue);
2687             wine_tsx11_unlock();
2688             break;
2689         case WGL_PBUFFER_HEIGHT_ARB:
2690             wine_tsx11_lock();
2691             pglXQueryDrawable(object->display, object->drawable, GLX_HEIGHT, (unsigned int*) piValue);
2692             wine_tsx11_unlock();
2693             break;
2694
2695         case WGL_PBUFFER_LOST_ARB:
2696             /* GLX Pbuffers cannot be lost by default. We can support this by
2697              * setting GLX_PRESERVED_CONTENTS to False and using glXSelectEvent
2698              * to receive pixel buffer clobber events, however that may or may
2699              * not give any benefit */
2700             *piValue = GL_FALSE;
2701             break;
2702
2703         case WGL_TEXTURE_FORMAT_ARB:
2704             if (use_render_texture_ati) {
2705                 unsigned int tmp;
2706                 int type = WGL_NO_TEXTURE_ARB;
2707                 wine_tsx11_lock();
2708                 pglXQueryDrawable(object->display, object->drawable, GLX_TEXTURE_FORMAT_ATI, &tmp);
2709                 wine_tsx11_unlock();
2710                 switch (tmp) {
2711                     case GLX_NO_TEXTURE_ATI: type = WGL_NO_TEXTURE_ARB; break ;
2712                     case GLX_TEXTURE_RGB_ATI: type = WGL_TEXTURE_RGB_ARB; break ;
2713                     case GLX_TEXTURE_RGBA_ATI: type = WGL_TEXTURE_RGBA_ARB; break ;
2714                 }
2715                 *piValue = type;
2716             } else {
2717                 if (!object->use_render_texture) {
2718                     *piValue = WGL_NO_TEXTURE_ARB;
2719                 } else {
2720                     if (!use_render_texture_emulation) {
2721                         SetLastError(ERROR_INVALID_HANDLE);
2722                         return GL_FALSE;
2723                     }
2724                     switch(object->use_render_texture) {
2725                         case GL_RGB:
2726                             *piValue = WGL_TEXTURE_RGB_ARB;
2727                             break;
2728                         case GL_RGBA:
2729                             *piValue = WGL_TEXTURE_RGBA_ARB;
2730                             break;
2731                         /* WGL_FLOAT_COMPONENTS_NV */
2732                         case GL_FLOAT_R_NV:
2733                             *piValue = WGL_TEXTURE_FLOAT_R_NV;
2734                             break;
2735                         case GL_FLOAT_RG_NV:
2736                             *piValue = WGL_TEXTURE_FLOAT_RG_NV;
2737                             break;
2738                         case GL_FLOAT_RGB_NV:
2739                             *piValue = WGL_TEXTURE_FLOAT_RGB_NV;
2740                             break;
2741                         case GL_FLOAT_RGBA_NV:
2742                             *piValue = WGL_TEXTURE_FLOAT_RGBA_NV;
2743                             break;
2744                         default:
2745                             ERR("Unknown texture format: %x\n", object->use_render_texture);
2746                     }
2747                 }
2748             }
2749             break;
2750
2751         case WGL_TEXTURE_TARGET_ARB:
2752             if (use_render_texture_ati) {
2753                 unsigned int tmp;
2754                 int type = WGL_NO_TEXTURE_ARB;
2755                 wine_tsx11_lock();
2756                 pglXQueryDrawable(object->display, object->drawable, GLX_TEXTURE_TARGET_ATI, &tmp);
2757                 wine_tsx11_unlock();
2758                 switch (tmp) {
2759                     case GLX_NO_TEXTURE_ATI: type = WGL_NO_TEXTURE_ARB; break ;
2760                     case GLX_TEXTURE_CUBE_MAP_ATI: type = WGL_TEXTURE_CUBE_MAP_ARB; break ;
2761                     case GLX_TEXTURE_1D_ATI: type = WGL_TEXTURE_1D_ARB; break ;
2762                     case GLX_TEXTURE_2D_ATI: type = WGL_TEXTURE_2D_ARB; break ;
2763                 }
2764                 *piValue = type;
2765             } else {
2766             if (!object->texture_target) {
2767                 *piValue = WGL_NO_TEXTURE_ARB;
2768             } else {
2769                 if (!use_render_texture_emulation) {
2770                     SetLastError(ERROR_INVALID_DATA);
2771                     return GL_FALSE;
2772                 }
2773                 switch (object->texture_target) {
2774                     case GL_TEXTURE_1D:       *piValue = WGL_TEXTURE_1D_ARB; break;
2775                     case GL_TEXTURE_2D:       *piValue = WGL_TEXTURE_2D_ARB; break;
2776                     case GL_TEXTURE_CUBE_MAP: *piValue = WGL_TEXTURE_CUBE_MAP_ARB; break;
2777                     case GL_TEXTURE_RECTANGLE_NV: *piValue = WGL_TEXTURE_RECTANGLE_NV; break;
2778                 }
2779             }
2780         }
2781         break;
2782
2783     case WGL_MIPMAP_TEXTURE_ARB:
2784         if (use_render_texture_ati) {
2785             wine_tsx11_lock();
2786             pglXQueryDrawable(object->display, object->drawable, GLX_MIPMAP_TEXTURE_ATI, (unsigned int*) piValue);
2787             wine_tsx11_unlock();
2788         } else {
2789             *piValue = GL_FALSE; /** don't support that */
2790             FIXME("unsupported WGL_ARB_render_texture attribute query for 0x%x\n", iAttribute);
2791         }
2792         break;
2793
2794     default:
2795         FIXME("unexpected attribute %x\n", iAttribute);
2796         break;
2797     }
2798
2799     return GL_TRUE;
2800 }
2801
2802 /**
2803  * X11DRV_wglReleasePbufferDCARB
2804  *
2805  * WGL_ARB_pbuffer: wglReleasePbufferDCARB
2806  */
2807 static int WINAPI X11DRV_wglReleasePbufferDCARB(HPBUFFERARB hPbuffer, HDC hdc)
2808 {
2809     TRACE("(%p, %p)\n", hPbuffer, hdc);
2810     return DeleteDC(hdc);
2811 }
2812
2813 /**
2814  * X11DRV_wglSetPbufferAttribARB
2815  *
2816  * WGL_ARB_pbuffer: wglSetPbufferAttribARB
2817  */
2818 static GLboolean WINAPI X11DRV_wglSetPbufferAttribARB(HPBUFFERARB hPbuffer, const int *piAttribList)
2819 {
2820     Wine_GLPBuffer* object = hPbuffer;
2821     GLboolean ret = GL_FALSE;
2822
2823     WARN("(%p, %p): alpha-testing, report any problem\n", hPbuffer, piAttribList);
2824     if (NULL == object) {
2825         SetLastError(ERROR_INVALID_HANDLE);
2826         return GL_FALSE;
2827     }
2828     if (!object->use_render_texture) {
2829         SetLastError(ERROR_INVALID_HANDLE);
2830         return GL_FALSE;
2831     }
2832     if (!use_render_texture_ati && 1 == use_render_texture_emulation) {
2833         return GL_TRUE;
2834     }
2835     if (NULL != pglXDrawableAttribATI) {
2836         if (use_render_texture_ati) {
2837             FIXME("Need conversion for GLX_ATI_render_texture\n");
2838         }
2839         wine_tsx11_lock();
2840         ret = pglXDrawableAttribATI(object->display, object->drawable, piAttribList);
2841         wine_tsx11_unlock();
2842     }
2843     return ret;
2844 }
2845
2846 /**
2847  * X11DRV_wglChoosePixelFormatARB
2848  *
2849  * WGL_ARB_pixel_format: wglChoosePixelFormatARB
2850  */
2851 static GLboolean WINAPI X11DRV_wglChoosePixelFormatARB(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats)
2852 {
2853     int gl_test = 0;
2854     int attribs[256];
2855     int nAttribs = 0;
2856     GLXFBConfig* cfgs = NULL;
2857     int nCfgs = 0;
2858     int it;
2859     int fmt_id;
2860     WineGLPixelFormat *fmt;
2861     UINT pfmt_it = 0;
2862     int run;
2863     int i;
2864     DWORD dwFlags = 0;
2865
2866     TRACE("(%p, %p, %p, %d, %p, %p): hackish\n", hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
2867     if (NULL != pfAttribFList) {
2868         FIXME("unused pfAttribFList\n");
2869     }
2870
2871     nAttribs = ConvertAttribWGLtoGLX(piAttribIList, attribs, NULL);
2872     if (-1 == nAttribs) {
2873         WARN("Cannot convert WGL to GLX attributes\n");
2874         return GL_FALSE;
2875     }
2876     PUSH1(attribs, None);
2877
2878     /* There is no 1:1 mapping between GLX and WGL formats because we duplicate some GLX formats for bitmap rendering (see get_formats).
2879      * Flags like PFD_SUPPORT_GDI, PFD_DRAW_TO_BITMAP and others are a property of the WineGLPixelFormat. We don't query these attributes
2880      * using glXChooseFBConfig but we filter the result of glXChooseFBConfig later on by passing a dwFlags to 'ConvertPixelFormatGLXtoWGL'. */
2881     for(i=0; piAttribIList[i] != 0; i+=2)
2882     {
2883         switch(piAttribIList[i])
2884         {
2885             case WGL_DRAW_TO_BITMAP_ARB:
2886                 if(piAttribIList[i+1])
2887                     dwFlags |= PFD_DRAW_TO_BITMAP;
2888                 break;
2889             case WGL_ACCELERATION_ARB:
2890                 switch(piAttribIList[i+1])
2891                 {
2892                     case WGL_NO_ACCELERATION_ARB:
2893                         dwFlags |= PFD_GENERIC_FORMAT;
2894                         break;
2895                     case WGL_GENERIC_ACCELERATION_ARB:
2896                         dwFlags |= PFD_GENERIC_ACCELERATED;
2897                         break;
2898                     case WGL_FULL_ACCELERATION_ARB:
2899                         /* Nothing to do */
2900                         break;
2901                 }
2902                 break;
2903             case WGL_SUPPORT_GDI_ARB:
2904                 if(piAttribIList[i+1])
2905                     dwFlags |= PFD_SUPPORT_GDI;
2906                 break;
2907         }
2908     }
2909
2910     /* Search for FB configurations matching the requirements in attribs */
2911     wine_tsx11_lock();
2912     cfgs = pglXChooseFBConfig(gdi_display, DefaultScreen(gdi_display), attribs, &nCfgs);
2913     if (NULL == cfgs) {
2914         wine_tsx11_unlock();
2915         WARN("Compatible Pixel Format not found\n");
2916         return GL_FALSE;
2917     }
2918
2919     /* Loop through all matching formats and check if they are suitable.
2920     * Note that this function should at max return nMaxFormats different formats */
2921     for(run=0; run < 2; run++)
2922     {
2923         for (it = 0; it < nCfgs; ++it) {
2924             gl_test = pglXGetFBConfigAttrib(gdi_display, cfgs[it], GLX_FBCONFIG_ID, &fmt_id);
2925             if (gl_test) {
2926                 ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
2927                 continue;
2928             }
2929
2930             /* Search for the format in our list of compatible formats */
2931             fmt = ConvertPixelFormatGLXtoWGL(gdi_display, fmt_id, dwFlags);
2932             if(!fmt)
2933                 continue;
2934
2935             /* During the first run we only want onscreen formats and during the second only offscreen 'XOR' */
2936             if( ((run == 0) && fmt->offscreenOnly) || ((run == 1) && !fmt->offscreenOnly) )
2937                 continue;
2938
2939             if(pfmt_it < nMaxFormats) {
2940                 piFormats[pfmt_it] = fmt->iPixelFormat;
2941                 TRACE("at %d/%d found FBCONFIG_ID 0x%x (%d)\n", it + 1, nCfgs, fmt_id, piFormats[pfmt_it]);
2942             }
2943             pfmt_it++;
2944         }
2945     }
2946
2947     *nNumFormats = pfmt_it;
2948     /** free list */
2949     XFree(cfgs);
2950     wine_tsx11_unlock();
2951     return GL_TRUE;
2952 }
2953
2954 /**
2955  * X11DRV_wglGetPixelFormatAttribivARB
2956  *
2957  * WGL_ARB_pixel_format: wglGetPixelFormatAttribivARB
2958  */
2959 static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues)
2960 {
2961     UINT i;
2962     WineGLPixelFormat *fmt = NULL;
2963     int hTest;
2964     int tmp;
2965     int curGLXAttr = 0;
2966     int nWGLFormats = 0;
2967
2968     TRACE("(%p, %d, %d, %d, %p, %p)\n", hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
2969
2970     if (0 < iLayerPlane) {
2971         FIXME("unsupported iLayerPlane(%d) > 0, returns FALSE\n", iLayerPlane);
2972         return GL_FALSE;
2973     }
2974
2975     /* Convert the WGL pixelformat to a GLX one, if this fails then most likely the iPixelFormat isn't supported.
2976     * We don't have to fail yet as a program can specify an invalid iPixelFormat (lets say 0) if it wants to query
2977     * the number of supported WGL formats. Whether the iPixelFormat is valid is handled in the for-loop below. */
2978     fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, TRUE /* Offscreen */, &nWGLFormats);
2979     if(!fmt) {
2980         WARN("Unable to convert iPixelFormat %d to a GLX one!\n", iPixelFormat);
2981     }
2982
2983     wine_tsx11_lock();
2984     for (i = 0; i < nAttributes; ++i) {
2985         const int curWGLAttr = piAttributes[i];
2986         TRACE("pAttr[%d] = %x\n", i, curWGLAttr);
2987
2988         switch (curWGLAttr) {
2989             case WGL_NUMBER_PIXEL_FORMATS_ARB:
2990                 piValues[i] = nWGLFormats;
2991                 continue;
2992
2993             case WGL_SUPPORT_OPENGL_ARB:
2994                 piValues[i] = GL_TRUE;
2995                 continue;
2996
2997             case WGL_ACCELERATION_ARB:
2998                 curGLXAttr = GLX_CONFIG_CAVEAT;
2999                 if (!fmt) goto pix_error;
3000                 if(fmt->dwFlags & PFD_GENERIC_FORMAT)
3001                     piValues[i] = WGL_NO_ACCELERATION_ARB;
3002                 else if(fmt->dwFlags & PFD_GENERIC_ACCELERATED)
3003                     piValues[i] = WGL_GENERIC_ACCELERATION_ARB;
3004                 else
3005                     piValues[i] = WGL_FULL_ACCELERATION_ARB;
3006                 continue;
3007
3008             case WGL_TRANSPARENT_ARB:
3009                 curGLXAttr = GLX_TRANSPARENT_TYPE;
3010                 if (!fmt) goto pix_error;
3011                 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
3012                 if (hTest) goto get_error;
3013                     piValues[i] = GL_FALSE;
3014                 if (GLX_NONE != tmp) piValues[i] = GL_TRUE;
3015                     continue;
3016
3017             case WGL_PIXEL_TYPE_ARB:
3018                 curGLXAttr = GLX_RENDER_TYPE;
3019                 if (!fmt) goto pix_error;
3020                 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
3021                 if (hTest) goto get_error;
3022                 TRACE("WGL_PIXEL_TYPE_ARB: GLX_RENDER_TYPE = 0x%x\n", tmp);
3023                 if      (tmp & GLX_RGBA_BIT)           { piValues[i] = WGL_TYPE_RGBA_ARB; }
3024                 else if (tmp & GLX_COLOR_INDEX_BIT)    { piValues[i] = WGL_TYPE_COLORINDEX_ARB; }
3025                 else if (tmp & GLX_RGBA_FLOAT_BIT)     { piValues[i] = WGL_TYPE_RGBA_FLOAT_ATI; }
3026                 else if (tmp & GLX_RGBA_FLOAT_ATI_BIT) { piValues[i] = WGL_TYPE_RGBA_FLOAT_ATI; }
3027                 else if (tmp & GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT) { piValues[i] = WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT; }
3028                 else {
3029                     ERR("unexpected RenderType(%x)\n", tmp);
3030                     piValues[i] = WGL_TYPE_RGBA_ARB;
3031                 }
3032                 continue;
3033
3034             case WGL_COLOR_BITS_ARB:
3035                 curGLXAttr = GLX_BUFFER_SIZE;
3036                 break;
3037
3038             case WGL_BIND_TO_TEXTURE_RGB_ARB:
3039                 if (use_render_texture_ati) {
3040                     curGLXAttr = GLX_BIND_TO_TEXTURE_RGB_ATI;
3041                     break;
3042                 }
3043             case WGL_BIND_TO_TEXTURE_RGBA_ARB:
3044                 if (use_render_texture_ati) {
3045                     curGLXAttr = GLX_BIND_TO_TEXTURE_RGBA_ATI;
3046                     break;
3047                 }
3048                 if (!use_render_texture_emulation) {
3049                     piValues[i] = GL_FALSE;
3050                     continue;
3051                 }
3052                 curGLXAttr = GLX_RENDER_TYPE;
3053                 if (!fmt) goto pix_error;
3054                 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
3055                 if (hTest) goto get_error;
3056                 if (GLX_COLOR_INDEX_BIT == tmp) {
3057                     piValues[i] = GL_FALSE;
3058                     continue;
3059                 }
3060                 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &tmp);
3061                 if (hTest) goto get_error;
3062                 piValues[i] = (tmp & GLX_PBUFFER_BIT) ? GL_TRUE : GL_FALSE;
3063                 continue;
3064
3065             case WGL_BLUE_BITS_ARB:
3066                 curGLXAttr = GLX_BLUE_SIZE;
3067                 break;
3068             case WGL_RED_BITS_ARB:
3069                 curGLXAttr = GLX_RED_SIZE;
3070                 break;
3071             case WGL_GREEN_BITS_ARB:
3072                 curGLXAttr = GLX_GREEN_SIZE;
3073                 break;
3074             case WGL_ALPHA_BITS_ARB:
3075                 curGLXAttr = GLX_ALPHA_SIZE;
3076                 break;
3077             case WGL_DEPTH_BITS_ARB:
3078                 curGLXAttr = GLX_DEPTH_SIZE;
3079                 break;
3080             case WGL_STENCIL_BITS_ARB:
3081                 curGLXAttr = GLX_STENCIL_SIZE;
3082                 break;
3083             case WGL_DOUBLE_BUFFER_ARB:
3084                 curGLXAttr = GLX_DOUBLEBUFFER;
3085                 break;
3086             case WGL_STEREO_ARB:
3087                 curGLXAttr = GLX_STEREO;
3088                 break;
3089             case WGL_AUX_BUFFERS_ARB:
3090                 curGLXAttr = GLX_AUX_BUFFERS;
3091                 break;
3092
3093             case WGL_SUPPORT_GDI_ARB:
3094                 if (!fmt) goto pix_error;
3095                 piValues[i] = (fmt->dwFlags & PFD_SUPPORT_GDI) ? TRUE : FALSE;
3096                 continue;
3097
3098             case WGL_DRAW_TO_BITMAP_ARB:
3099                 if (!fmt) goto pix_error;
3100                 piValues[i] = (fmt->dwFlags & PFD_DRAW_TO_BITMAP) ? TRUE : FALSE;
3101                 continue;
3102
3103             case WGL_DRAW_TO_WINDOW_ARB:
3104             case WGL_DRAW_TO_PBUFFER_ARB:
3105                 if (!fmt) goto pix_error;
3106                 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &tmp);
3107                 if (hTest) goto get_error;
3108                 if((curWGLAttr == WGL_DRAW_TO_WINDOW_ARB && (tmp&GLX_WINDOW_BIT)) ||
3109                    (curWGLAttr == WGL_DRAW_TO_PBUFFER_ARB && (tmp&GLX_PBUFFER_BIT)))
3110                     piValues[i] = GL_TRUE;
3111                 else
3112                     piValues[i] = GL_FALSE;
3113                 continue;
3114
3115             case WGL_SWAP_METHOD_ARB:
3116                 /* For now return SWAP_EXCHANGE_ARB which is the best type of buffer switch available.
3117                  * Later on we can also use GLX_OML_swap_method on drivers which support this. At this
3118                  * point only ATI offers this.
3119                  */
3120                 piValues[i] = WGL_SWAP_EXCHANGE_ARB;
3121                 break;
3122
3123             case WGL_PBUFFER_LARGEST_ARB:
3124                 curGLXAttr = GLX_LARGEST_PBUFFER;
3125                 break;
3126
3127             case WGL_SAMPLE_BUFFERS_ARB:
3128                 curGLXAttr = GLX_SAMPLE_BUFFERS_ARB;
3129                 break;
3130
3131             case WGL_SAMPLES_ARB:
3132                 curGLXAttr = GLX_SAMPLES_ARB;
3133                 break;
3134
3135             case WGL_FLOAT_COMPONENTS_NV:
3136                 curGLXAttr = GLX_FLOAT_COMPONENTS_NV;
3137                 break;
3138
3139             case WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT:
3140                 curGLXAttr = GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT;
3141                 break;
3142
3143             case WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT:
3144                 curGLXAttr = GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT;
3145                 break;
3146
3147             case WGL_ACCUM_RED_BITS_ARB:
3148                 curGLXAttr = GLX_ACCUM_RED_SIZE;
3149                 break;
3150             case WGL_ACCUM_GREEN_BITS_ARB:
3151                 curGLXAttr = GLX_ACCUM_GREEN_SIZE;
3152                 break;
3153             case WGL_ACCUM_BLUE_BITS_ARB:
3154                 curGLXAttr = GLX_ACCUM_BLUE_SIZE;
3155                 break;
3156             case WGL_ACCUM_ALPHA_BITS_ARB:
3157                 curGLXAttr = GLX_ACCUM_ALPHA_SIZE;
3158                 break;
3159             case WGL_ACCUM_BITS_ARB:
3160                 if (!fmt) goto pix_error;
3161                 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_RED_SIZE, &tmp);
3162                 if (hTest) goto get_error;
3163                 piValues[i] = tmp;
3164                 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_GREEN_SIZE, &tmp);
3165                 if (hTest) goto get_error;
3166                 piValues[i] += tmp;
3167                 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_BLUE_SIZE, &tmp);
3168                 if (hTest) goto get_error;
3169                 piValues[i] += tmp;
3170                 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_ALPHA_SIZE, &tmp);
3171                 if (hTest) goto get_error;
3172                 piValues[i] += tmp;
3173                 continue;
3174
3175             default:
3176                 FIXME("unsupported %x WGL Attribute\n", curWGLAttr);
3177         }
3178
3179         /* Retrieve a GLX FBConfigAttrib when the attribute to query is valid and
3180          * iPixelFormat != 0. When iPixelFormat is 0 the only value which makes
3181          * sense to query is WGL_NUMBER_PIXEL_FORMATS_ARB.
3182          *
3183          * TODO: properly test the behavior of wglGetPixelFormatAttrib*v on Windows
3184          *       and check which options can work using iPixelFormat=0 and which not.
3185          *       A problem would be that this function is an extension. This would
3186          *       mean that the behavior could differ between different vendors (ATI, Nvidia, ..).
3187          */
3188         if (0 != curGLXAttr && iPixelFormat != 0) {
3189             if (!fmt) goto pix_error;
3190             hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, piValues + i);
3191             if (hTest) goto get_error;
3192             curGLXAttr = 0;
3193         } else {
3194             piValues[i] = GL_FALSE;
3195         }
3196     }
3197     wine_tsx11_unlock();
3198     return GL_TRUE;
3199
3200 get_error:
3201     wine_tsx11_unlock();
3202     ERR("(%p): unexpected failure on GetFBConfigAttrib(%x) returns FALSE\n", hdc, curGLXAttr);
3203     return GL_FALSE;
3204
3205 pix_error:
3206     wine_tsx11_unlock();
3207     ERR("(%p): unexpected iPixelFormat(%d) vs nFormats(%d), returns FALSE\n", hdc, iPixelFormat, nWGLFormats);
3208     return GL_FALSE;
3209 }
3210
3211 /**
3212  * X11DRV_wglGetPixelFormatAttribfvARB
3213  *
3214  * WGL_ARB_pixel_format: wglGetPixelFormatAttribfvARB
3215  */
3216 static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribfvARB(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues)
3217 {
3218     int *attr;
3219     int ret;
3220     UINT i;
3221
3222     TRACE("(%p, %d, %d, %d, %p, %p)\n", hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
3223
3224     /* Allocate a temporary array to store integer values */
3225     attr = HeapAlloc(GetProcessHeap(), 0, nAttributes * sizeof(int));
3226     if (!attr) {
3227         ERR("couldn't allocate %d array\n", nAttributes);
3228         return GL_FALSE;
3229     }
3230
3231     /* Piggy-back on wglGetPixelFormatAttribivARB */
3232     ret = X11DRV_wglGetPixelFormatAttribivARB(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, attr);
3233     if (ret) {
3234         /* Convert integer values to float. Should also check for attributes
3235            that can give decimal values here */
3236         for (i=0; i<nAttributes;i++) {
3237             pfValues[i] = attr[i];
3238         }
3239     }
3240
3241     HeapFree(GetProcessHeap(), 0, attr);
3242     return ret;
3243 }
3244
3245 /**
3246  * X11DRV_wglBindTexImageARB
3247  *
3248  * WGL_ARB_render_texture: wglBindTexImageARB
3249  */
3250 static GLboolean WINAPI X11DRV_wglBindTexImageARB(HPBUFFERARB hPbuffer, int iBuffer)
3251 {
3252     Wine_GLPBuffer* object = hPbuffer;
3253     GLboolean ret = GL_FALSE;
3254
3255     TRACE("(%p, %d)\n", hPbuffer, iBuffer);
3256     if (NULL == object) {
3257         SetLastError(ERROR_INVALID_HANDLE);
3258         return GL_FALSE;
3259     }
3260     if (!object->use_render_texture) {
3261         SetLastError(ERROR_INVALID_HANDLE);
3262         return GL_FALSE;
3263     }
3264
3265     if (!use_render_texture_ati && 1 == use_render_texture_emulation) {
3266         static int init = 0;
3267         int prev_binded_texture = 0;
3268         GLXContext prev_context;
3269         Drawable prev_drawable;
3270         GLXContext tmp_context;
3271
3272         wine_tsx11_lock();
3273         prev_context = pglXGetCurrentContext();
3274         prev_drawable = pglXGetCurrentDrawable();
3275
3276         /* Our render_texture emulation is basic and lacks some features (1D/Cube support).
3277            This is mostly due to lack of demos/games using them. Further the use of glReadPixels
3278            isn't ideal performance wise but I wasn't able to get other ways working.
3279         */
3280         if(!init) {
3281             init = 1; /* Only show the FIXME once for performance reasons */
3282             FIXME("partial stub!\n");
3283         }
3284
3285         TRACE("drawable=%p, context=%p\n", (void*)object->drawable, prev_context);
3286         tmp_context = pglXCreateNewContext(gdi_display, object->fmt->fbconfig, object->fmt->render_type, prev_context, True);
3287
3288         pglGetIntegerv(object->texture_bind_target, &prev_binded_texture);
3289
3290         /* Switch to our pbuffer */
3291         pglXMakeCurrent(gdi_display, object->drawable, tmp_context);
3292
3293         /* Make sure that the prev_binded_texture is set as the current texture state isn't shared between contexts.
3294          * After that upload the pbuffer texture data. */
3295         pglBindTexture(object->texture_target, prev_binded_texture);
3296         pglCopyTexImage2D(object->texture_target, 0, object->use_render_texture, 0, 0, object->width, object->height, 0);
3297
3298         /* Switch back to the original drawable and upload the pbuffer-texture */
3299         pglXMakeCurrent(object->display, prev_drawable, prev_context);
3300         pglXDestroyContext(gdi_display, tmp_context);
3301         wine_tsx11_unlock();
3302         return GL_TRUE;
3303     }
3304
3305     if (NULL != pglXBindTexImageATI) {
3306         int buffer;
3307
3308         switch(iBuffer)
3309         {
3310             case WGL_FRONT_LEFT_ARB:
3311                 buffer = GLX_FRONT_LEFT_ATI;
3312                 break;
3313             case WGL_FRONT_RIGHT_ARB:
3314                 buffer = GLX_FRONT_RIGHT_ATI;
3315                 break;
3316             case WGL_BACK_LEFT_ARB:
3317                 buffer = GLX_BACK_LEFT_ATI;
3318                 break;
3319             case WGL_BACK_RIGHT_ARB:
3320                 buffer = GLX_BACK_RIGHT_ATI;
3321                 break;
3322             default:
3323                 ERR("Unknown iBuffer=%#x\n", iBuffer);
3324                 return FALSE;
3325         }
3326
3327         /* In the sample 'ogl_offscreen_rendering_3' from codesampler.net I get garbage on the screen.
3328          * I'm not sure if that's a bug in the ATI extension or in the program. I think that the program
3329          * expected a single buffering format since it didn't ask for double buffering. A buffer swap
3330          * fixed the program. I don't know what the correct behavior is. On the other hand that demo
3331          * works fine using our pbuffer emulation path.
3332          */
3333         wine_tsx11_lock();
3334         ret = pglXBindTexImageATI(object->display, object->drawable, buffer);
3335         wine_tsx11_unlock();
3336     }
3337     return ret;
3338 }
3339
3340 /**
3341  * X11DRV_wglReleaseTexImageARB
3342  *
3343  * WGL_ARB_render_texture: wglReleaseTexImageARB
3344  */
3345 static GLboolean WINAPI X11DRV_wglReleaseTexImageARB(HPBUFFERARB hPbuffer, int iBuffer)
3346 {
3347     Wine_GLPBuffer* object = hPbuffer;
3348     GLboolean ret = GL_FALSE;
3349
3350     TRACE("(%p, %d)\n", hPbuffer, iBuffer);
3351     if (NULL == object) {
3352         SetLastError(ERROR_INVALID_HANDLE);
3353         return GL_FALSE;
3354     }
3355     if (!object->use_render_texture) {
3356         SetLastError(ERROR_INVALID_HANDLE);
3357         return GL_FALSE;
3358     }
3359     if (!use_render_texture_ati && 1 == use_render_texture_emulation) {
3360         return GL_TRUE;
3361     }
3362     if (NULL != pglXReleaseTexImageATI) {
3363         int buffer;
3364
3365         switch(iBuffer)
3366         {
3367             case WGL_FRONT_LEFT_ARB:
3368                 buffer = GLX_FRONT_LEFT_ATI;
3369                 break;
3370             case WGL_FRONT_RIGHT_ARB:
3371                 buffer = GLX_FRONT_RIGHT_ATI;
3372                 break;
3373             case WGL_BACK_LEFT_ARB:
3374                 buffer = GLX_BACK_LEFT_ATI;
3375                 break;
3376             case WGL_BACK_RIGHT_ARB:
3377                 buffer = GLX_BACK_RIGHT_ATI;
3378                 break;
3379             default:
3380                 ERR("Unknown iBuffer=%#x\n", iBuffer);
3381                 return FALSE;
3382         }
3383         wine_tsx11_lock();
3384         ret = pglXReleaseTexImageATI(object->display, object->drawable, buffer);
3385         wine_tsx11_unlock();
3386     }
3387     return ret;
3388 }
3389
3390 /**
3391  * X11DRV_wglGetExtensionsStringEXT
3392  *
3393  * WGL_EXT_extensions_string: wglGetExtensionsStringEXT
3394  */
3395 static const char * WINAPI X11DRV_wglGetExtensionsStringEXT(void) {
3396     TRACE("() returning \"%s\"\n", WineGLInfo.wglExtensions);
3397     return WineGLInfo.wglExtensions;
3398 }
3399
3400 /**
3401  * X11DRV_wglGetSwapIntervalEXT
3402  *
3403  * WGL_EXT_swap_control: wglGetSwapIntervalEXT
3404  */
3405 static int WINAPI X11DRV_wglGetSwapIntervalEXT(VOID) {
3406     /* GLX_SGI_swap_control doesn't have any provisions for getting the swap
3407      * interval, so the swap interval has to be tracked. */
3408     TRACE("()\n");
3409     return swap_interval;
3410 }
3411
3412 /**
3413  * X11DRV_wglSwapIntervalEXT
3414  *
3415  * WGL_EXT_swap_control: wglSwapIntervalEXT
3416  */
3417 static BOOL WINAPI X11DRV_wglSwapIntervalEXT(int interval) {
3418     BOOL ret = TRUE;
3419
3420     TRACE("(%d)\n", interval);
3421
3422     if (interval < 0)
3423     {
3424         SetLastError(ERROR_INVALID_DATA);
3425         return FALSE;
3426     }
3427     else if (interval == 0)
3428     {
3429         /* wglSwapIntervalEXT considers an interval value of zero to mean that
3430          * vsync should be disabled, but glXSwapIntervalSGI considers such a
3431          * value to be an error. Just silently ignore the request for now. */
3432         WARN("Request to disable vertical sync is not handled\n");
3433         swap_interval = 0;
3434     }
3435     else
3436     {
3437         if (pglXSwapIntervalSGI)
3438         {
3439             wine_tsx11_lock();
3440             ret = !pglXSwapIntervalSGI(interval);
3441             wine_tsx11_unlock();
3442         }
3443         else
3444             WARN("GLX_SGI_swap_control extension is not available\n");
3445
3446         if (ret)
3447             swap_interval = interval;
3448         else
3449             SetLastError(ERROR_DC_NOT_FOUND);
3450     }
3451
3452     return ret;
3453 }
3454
3455 /**
3456  * X11DRV_wglAllocateMemoryNV
3457  *
3458  * WGL_NV_vertex_array_range: wglAllocateMemoryNV
3459  */
3460 static void* WINAPI X11DRV_wglAllocateMemoryNV(GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority) {
3461     void *ret = NULL;
3462     TRACE("(%d, %f, %f, %f)\n", size, readfreq, writefreq, priority );
3463
3464     if (pglXAllocateMemoryNV)
3465     {
3466         wine_tsx11_lock();
3467         ret = pglXAllocateMemoryNV(size, readfreq, writefreq, priority);
3468         wine_tsx11_unlock();
3469     }
3470     return ret;
3471 }
3472
3473 /**
3474  * X11DRV_wglFreeMemoryNV
3475  *
3476  * WGL_NV_vertex_array_range: wglFreeMemoryNV
3477  */
3478 static void WINAPI X11DRV_wglFreeMemoryNV(GLvoid* pointer) {
3479     TRACE("(%p)\n", pointer);
3480     if (pglXFreeMemoryNV == NULL)
3481         return;
3482
3483     wine_tsx11_lock();
3484     pglXFreeMemoryNV(pointer);
3485     wine_tsx11_unlock();
3486 }
3487
3488 /**
3489  * X11DRV_wglSetPixelFormatWINE
3490  *
3491  * WGL_WINE_pixel_format_passthrough: wglSetPixelFormatWINE
3492  * This is a WINE-specific wglSetPixelFormat which can set the pixel format multiple times.
3493  */
3494 BOOL CDECL X11DRV_wglSetPixelFormatWINE(X11DRV_PDEVICE *physDev, int iPixelFormat, const PIXELFORMATDESCRIPTOR *ppfd)
3495 {
3496     TRACE("(%p,%d,%p)\n", physDev, iPixelFormat, ppfd);
3497
3498     if (!has_opengl()) return FALSE;
3499
3500     if (physDev->current_pf == iPixelFormat) return TRUE;
3501
3502     /* Relay to the core SetPixelFormat */
3503     TRACE("Changing iPixelFormat from %d to %d\n", physDev->current_pf, iPixelFormat);
3504     return internal_SetPixelFormat(physDev, iPixelFormat, ppfd);
3505 }
3506
3507 /**
3508  * glxRequireVersion (internal)
3509  *
3510  * Check if the supported GLX version matches requiredVersion.
3511  */
3512 static BOOL glxRequireVersion(int requiredVersion)
3513 {
3514     /* Both requiredVersion and glXVersion[1] contains the minor GLX version */
3515     if(requiredVersion <= WineGLInfo.glxVersion[1])
3516         return TRUE;
3517
3518     return FALSE;
3519 }
3520
3521 static BOOL glxRequireExtension(const char *requiredExtension)
3522 {
3523     if (strstr(WineGLInfo.glxExtensions, requiredExtension) == NULL) {
3524         return FALSE;
3525     }
3526
3527     return TRUE;
3528 }
3529
3530 static void register_extension_string(const char *ext)
3531 {
3532     if (WineGLInfo.wglExtensions[0])
3533         strcat(WineGLInfo.wglExtensions, " ");
3534     strcat(WineGLInfo.wglExtensions, ext);
3535
3536     TRACE("'%s'\n", ext);
3537 }
3538
3539 static BOOL register_extension(const WineGLExtension * ext)
3540 {
3541     int i;
3542
3543     assert( WineGLExtensionListSize < MAX_EXTENSIONS );
3544     WineGLExtensionList[WineGLExtensionListSize++] = ext;
3545
3546     register_extension_string(ext->extName);
3547
3548     for (i = 0; ext->extEntryPoints[i].funcName; ++i)
3549         TRACE("    - '%s'\n", ext->extEntryPoints[i].funcName);
3550
3551     return TRUE;
3552 }
3553
3554 static const WineGLExtension WGL_internal_functions =
3555 {
3556   "",
3557   {
3558     { "wglGetIntegerv", X11DRV_wglGetIntegerv },
3559     { "wglFinish", X11DRV_wglFinish },
3560     { "wglFlush", X11DRV_wglFlush },
3561   }
3562 };
3563
3564
3565 static const WineGLExtension WGL_ARB_create_context =
3566 {
3567   "WGL_ARB_create_context",
3568   {
3569     { "wglCreateContextAttribsARB", X11DRV_wglCreateContextAttribsARB },
3570   }
3571 };
3572
3573 static const WineGLExtension WGL_ARB_extensions_string =
3574 {
3575   "WGL_ARB_extensions_string",
3576   {
3577     { "wglGetExtensionsStringARB", X11DRV_wglGetExtensionsStringARB },
3578   }
3579 };
3580
3581 static const WineGLExtension WGL_ARB_make_current_read =
3582 {
3583   "WGL_ARB_make_current_read",
3584   {
3585     { "wglGetCurrentReadDCARB", X11DRV_wglGetCurrentReadDCARB },
3586     { "wglMakeContextCurrentARB", X11DRV_wglMakeContextCurrentARB },
3587   }
3588 };
3589
3590 static const WineGLExtension WGL_ARB_multisample =
3591 {
3592   "WGL_ARB_multisample",
3593 };
3594
3595 static const WineGLExtension WGL_ARB_pbuffer =
3596 {
3597   "WGL_ARB_pbuffer",
3598   {
3599     { "wglCreatePbufferARB", X11DRV_wglCreatePbufferARB },
3600     { "wglDestroyPbufferARB", X11DRV_wglDestroyPbufferARB },
3601     { "wglGetPbufferDCARB", X11DRV_wglGetPbufferDCARB },
3602     { "wglQueryPbufferARB", X11DRV_wglQueryPbufferARB },
3603     { "wglReleasePbufferDCARB", X11DRV_wglReleasePbufferDCARB },
3604     { "wglSetPbufferAttribARB", X11DRV_wglSetPbufferAttribARB },
3605   }
3606 };
3607
3608 static const WineGLExtension WGL_ARB_pixel_format =
3609 {
3610   "WGL_ARB_pixel_format",
3611   {
3612     { "wglChoosePixelFormatARB", X11DRV_wglChoosePixelFormatARB },
3613     { "wglGetPixelFormatAttribfvARB", X11DRV_wglGetPixelFormatAttribfvARB },
3614     { "wglGetPixelFormatAttribivARB", X11DRV_wglGetPixelFormatAttribivARB },
3615   }
3616 };
3617
3618 static const WineGLExtension WGL_ARB_render_texture =
3619 {
3620   "WGL_ARB_render_texture",
3621   {
3622     { "wglBindTexImageARB", X11DRV_wglBindTexImageARB },
3623     { "wglReleaseTexImageARB", X11DRV_wglReleaseTexImageARB },
3624   }
3625 };
3626
3627 static const WineGLExtension WGL_EXT_extensions_string =
3628 {
3629   "WGL_EXT_extensions_string",
3630   {
3631     { "wglGetExtensionsStringEXT", X11DRV_wglGetExtensionsStringEXT },
3632   }
3633 };
3634
3635 static const WineGLExtension WGL_EXT_swap_control =
3636 {
3637   "WGL_EXT_swap_control",
3638   {
3639     { "wglSwapIntervalEXT", X11DRV_wglSwapIntervalEXT },
3640     { "wglGetSwapIntervalEXT", X11DRV_wglGetSwapIntervalEXT },
3641   }
3642 };
3643
3644 static const WineGLExtension WGL_NV_vertex_array_range =
3645 {
3646   "WGL_NV_vertex_array_range",
3647   {
3648     { "wglAllocateMemoryNV", X11DRV_wglAllocateMemoryNV },
3649     { "wglFreeMemoryNV", X11DRV_wglFreeMemoryNV },
3650   }
3651 };
3652
3653 static const WineGLExtension WGL_WINE_pixel_format_passthrough =
3654 {
3655   "WGL_WINE_pixel_format_passthrough",
3656   {
3657     { "wglSetPixelFormatWINE", X11DRV_wglSetPixelFormatWINE },
3658   }
3659 };
3660
3661 /**
3662  * X11DRV_WineGL_LoadExtensions
3663  */
3664 static void X11DRV_WineGL_LoadExtensions(void)
3665 {
3666     WineGLInfo.wglExtensions[0] = 0;
3667
3668     /* Load Wine internal functions */
3669     register_extension(&WGL_internal_functions);
3670
3671     /* ARB Extensions */
3672
3673     if(glxRequireExtension("GLX_ARB_create_context"))
3674     {
3675         register_extension(&WGL_ARB_create_context);
3676
3677         if(glxRequireExtension("GLX_ARB_create_context_profile"))
3678             register_extension_string("WGL_ARB_create_context_profile");
3679     }
3680
3681     if(glxRequireExtension("GLX_ARB_fbconfig_float"))
3682     {
3683         register_extension_string("WGL_ARB_pixel_format_float");
3684         register_extension_string("WGL_ATI_pixel_format_float");
3685     }
3686
3687     register_extension(&WGL_ARB_extensions_string);
3688
3689     if (glxRequireVersion(3))
3690         register_extension(&WGL_ARB_make_current_read);
3691
3692     if (glxRequireExtension("GLX_ARB_multisample"))
3693         register_extension(&WGL_ARB_multisample);
3694
3695     /* In general pbuffer functionality requires support in the X-server. The functionality is
3696      * available either when the GLX_SGIX_pbuffer is present or when the GLX server version is 1.3.
3697      * All display drivers except for Nvidia's use the GLX module from Xfree86/Xorg which only
3698      * supports GLX 1.2. The endresult is that only Nvidia's drivers support pbuffers.
3699      *
3700      * The only other drive which has pbuffer support is Ati's FGLRX driver. They provide clientside GLX 1.3 support
3701      * without support in the X-server (which other Mesa based drivers require).
3702      *
3703      * Support pbuffers when the GLX version is 1.3 and GLX_SGIX_pbuffer is available. Further pbuffers can
3704      * also be supported when GLX_ATI_render_texture is available. This extension depends on pbuffers, so when it
3705      * is available pbuffers must be available too. */
3706     if ( (glxRequireVersion(3) && glxRequireExtension("GLX_SGIX_pbuffer")) || glxRequireExtension("GLX_ATI_render_texture"))
3707         register_extension(&WGL_ARB_pbuffer);
3708
3709     register_extension(&WGL_ARB_pixel_format);
3710
3711     /* Support WGL_ARB_render_texture when there's support or pbuffer based emulation */
3712     if (glxRequireExtension("GLX_ATI_render_texture") ||
3713         glxRequireExtension("GLX_ARB_render_texture") ||
3714         (glxRequireVersion(3) && glxRequireExtension("GLX_SGIX_pbuffer") && use_render_texture_emulation))
3715     {
3716         register_extension(&WGL_ARB_render_texture);
3717
3718         /* The WGL version of GLX_NV_float_buffer requires render_texture */
3719         if(glxRequireExtension("GLX_NV_float_buffer"))
3720             register_extension_string("WGL_NV_float_buffer");
3721
3722         /* Again there's no GLX equivalent for this extension, so depend on the required GL extension */
3723         if(strstr(WineGLInfo.glExtensions, "GL_NV_texture_rectangle") != NULL)
3724             register_extension_string("WGL_NV_texture_rectangle");
3725     }
3726
3727     /* EXT Extensions */
3728
3729     register_extension(&WGL_EXT_extensions_string);
3730
3731     /* Load this extension even when it isn't backed by a GLX extension because it is has been around for ages.
3732      * Games like Call of Duty and K.O.T.O.R. rely on it. Further our emulation is good enough. */
3733     register_extension(&WGL_EXT_swap_control);
3734
3735     if(glxRequireExtension("GLX_EXT_framebuffer_sRGB"))
3736         register_extension_string("WGL_EXT_framebuffer_sRGB");
3737
3738     if(glxRequireExtension("GLX_EXT_fbconfig_packed_float"))
3739         register_extension_string("WGL_EXT_pixel_format_packed_float");
3740
3741     /* The OpenGL extension GL_NV_vertex_array_range adds wgl/glX functions which aren't exported as 'real' wgl/glX extensions. */
3742     if(strstr(WineGLInfo.glExtensions, "GL_NV_vertex_array_range") != NULL)
3743         register_extension(&WGL_NV_vertex_array_range);
3744
3745     /* WINE-specific WGL Extensions */
3746
3747     /* In WineD3D we need the ability to set the pixel format more than once (e.g. after a device reset).
3748      * The default wglSetPixelFormat doesn't allow this, so add our own which allows it.
3749      */
3750     register_extension(&WGL_WINE_pixel_format_passthrough);
3751 }
3752
3753
3754 Drawable get_glxdrawable(X11DRV_PDEVICE *physDev)
3755 {
3756     Drawable ret;
3757
3758     if(physDev->bitmap)
3759     {
3760         if (physDev->bitmap->hbitmap == BITMAP_stock_phys_bitmap.hbitmap)
3761             ret = physDev->drawable; /* PBuffer */
3762         else
3763             ret = physDev->bitmap->glxpixmap;
3764     }
3765     else if(physDev->gl_drawable)
3766         ret = physDev->gl_drawable;
3767     else
3768         ret = physDev->drawable;
3769     return ret;
3770 }
3771
3772 BOOL destroy_glxpixmap(Display *display, XID glxpixmap)
3773 {
3774     wine_tsx11_lock();
3775     pglXDestroyGLXPixmap(display, glxpixmap);
3776     wine_tsx11_unlock();
3777     return TRUE;
3778 }
3779
3780 /**
3781  * X11DRV_SwapBuffers
3782  *
3783  * Swap the buffers of this DC
3784  */
3785 BOOL CDECL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev)
3786 {
3787   GLXDrawable drawable;
3788   Wine_GLContext *ctx = NtCurrentTeb()->glContext;
3789
3790   if (!has_opengl()) return FALSE;
3791
3792   TRACE("(%p)\n", physDev);
3793
3794   drawable = get_glxdrawable(physDev);
3795
3796   wine_tsx11_lock();
3797   sync_context(ctx);
3798   if(physDev->pixmap) {
3799       if(pglXCopySubBufferMESA) {
3800           int w = physDev->dc_rect.right - physDev->dc_rect.left;
3801           int h = physDev->dc_rect.bottom - physDev->dc_rect.top;
3802
3803           /* (glX)SwapBuffers has an implicit glFlush effect, however
3804            * GLX_MESA_copy_sub_buffer doesn't. Make sure GL is flushed before
3805            * copying */
3806           pglFlush();
3807           if(w > 0 && h > 0)
3808               pglXCopySubBufferMESA(gdi_display, drawable, 0, 0, w, h);
3809       }
3810       else
3811           pglXSwapBuffers(gdi_display, drawable);
3812   }
3813   else
3814       pglXSwapBuffers(gdi_display, drawable);
3815
3816   flush_gl_drawable(physDev);
3817   wine_tsx11_unlock();
3818
3819   /* FPS support */
3820   if (TRACE_ON(fps))
3821   {
3822       static long prev_time, start_time;
3823       static unsigned long frames, frames_total;
3824
3825       DWORD time = GetTickCount();
3826       frames++;
3827       frames_total++;
3828       /* every 1.5 seconds */
3829       if (time - prev_time > 1500) {
3830           TRACE_(fps)("@ approx %.2ffps, total %.2ffps\n",
3831                       1000.0*frames/(time - prev_time), 1000.0*frames_total/(time - start_time));
3832           prev_time = time;
3833           frames = 0;
3834           if(start_time == 0) start_time = time;
3835       }
3836   }
3837
3838   return TRUE;
3839 }
3840
3841 XVisualInfo *visual_from_fbconfig_id( XID fbconfig_id )
3842 {
3843     WineGLPixelFormat *fmt;
3844     XVisualInfo *ret;
3845
3846     fmt = ConvertPixelFormatGLXtoWGL(gdi_display, fbconfig_id, 0 /* no flags */);
3847     if(fmt == NULL)
3848         return NULL;
3849
3850     wine_tsx11_lock();
3851     ret = pglXGetVisualFromFBConfig(gdi_display, fmt->fbconfig);
3852     wine_tsx11_unlock();
3853     return ret;
3854 }
3855
3856 #else  /* no OpenGL includes */
3857
3858 void X11DRV_OpenGL_Cleanup(void)
3859 {
3860 }
3861
3862 static inline void opengl_error(void)
3863 {
3864     static int warned;
3865     if (!warned++) ERR("No OpenGL support compiled in.\n");
3866 }
3867
3868 int pixelformat_from_fbconfig_id(XID fbconfig_id)
3869 {
3870     return 0;
3871 }
3872
3873 void mark_drawable_dirty(Drawable old, Drawable new)
3874 {
3875 }
3876
3877 void flush_gl_drawable(X11DRV_PDEVICE *physDev)
3878 {
3879 }
3880
3881 Drawable create_glxpixmap(Display *display, XVisualInfo *vis, Pixmap parent)
3882 {
3883     return 0;
3884 }
3885
3886 /***********************************************************************
3887  *              ChoosePixelFormat (X11DRV.@)
3888  */
3889 int CDECL X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
3890                                      const PIXELFORMATDESCRIPTOR *ppfd) {
3891   opengl_error();
3892   return 0;
3893 }
3894
3895 /***********************************************************************
3896  *              DescribePixelFormat (X11DRV.@)
3897  */
3898 int CDECL X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
3899                                      int iPixelFormat,
3900                                      UINT nBytes,
3901                                      PIXELFORMATDESCRIPTOR *ppfd) {
3902   opengl_error();
3903   return 0;
3904 }
3905
3906 /***********************************************************************
3907  *              GetPixelFormat (X11DRV.@)
3908  */
3909 int CDECL X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
3910   opengl_error();
3911   return 0;
3912 }
3913
3914 /***********************************************************************
3915  *              SetPixelFormat (X11DRV.@)
3916  */
3917 BOOL CDECL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
3918                                    int iPixelFormat,
3919                                    const PIXELFORMATDESCRIPTOR *ppfd) {
3920   opengl_error();
3921   return FALSE;
3922 }
3923
3924 /***********************************************************************
3925  *              SwapBuffers (X11DRV.@)
3926  */
3927 BOOL CDECL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev) {
3928   opengl_error();
3929   return FALSE;
3930 }
3931
3932 /**
3933  * X11DRV_wglCopyContext
3934  *
3935  * For OpenGL32 wglCopyContext.
3936  */
3937 BOOL CDECL X11DRV_wglCopyContext(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask) {
3938     opengl_error();
3939     return FALSE;
3940 }
3941
3942 /**
3943  * X11DRV_wglCreateContext
3944  *
3945  * For OpenGL32 wglCreateContext.
3946  */
3947 HGLRC CDECL X11DRV_wglCreateContext(X11DRV_PDEVICE *physDev) {
3948     opengl_error();
3949     return NULL;
3950 }
3951
3952 /**
3953  * X11DRV_wglCreateContextAttribsARB
3954  *
3955  * WGL_ARB_create_context: wglCreateContextAttribsARB
3956  */
3957 HGLRC CDECL X11DRV_wglCreateContextAttribsARB(X11DRV_PDEVICE *physDev, HGLRC hShareContext, const int* attribList)
3958 {
3959     opengl_error();
3960     return NULL;
3961 }
3962
3963 /**
3964  * X11DRV_wglDeleteContext
3965  *
3966  * For OpenGL32 wglDeleteContext.
3967  */
3968 BOOL CDECL X11DRV_wglDeleteContext(HGLRC hglrc) {
3969     opengl_error();
3970     return FALSE;
3971 }
3972
3973 /**
3974  * X11DRV_wglGetProcAddress
3975  *
3976  * For OpenGL32 wglGetProcAddress.
3977  */
3978 PROC CDECL X11DRV_wglGetProcAddress(LPCSTR lpszProc) {
3979     opengl_error();
3980     return NULL;
3981 }
3982
3983 HDC CDECL X11DRV_wglGetPbufferDCARB(X11DRV_PDEVICE *hDevice, void *hPbuffer)
3984 {
3985     opengl_error();
3986     return NULL;
3987 }
3988
3989 BOOL CDECL X11DRV_wglMakeContextCurrentARB(X11DRV_PDEVICE* hDrawDev, X11DRV_PDEVICE* hReadDev, HGLRC hglrc) {
3990     opengl_error();
3991     return FALSE;
3992 }
3993
3994 /**
3995  * X11DRV_wglMakeCurrent
3996  *
3997  * For OpenGL32 wglMakeCurrent.
3998  */
3999 BOOL CDECL X11DRV_wglMakeCurrent(X11DRV_PDEVICE *physDev, HGLRC hglrc) {
4000     opengl_error();
4001     return FALSE;
4002 }
4003
4004 /**
4005  * X11DRV_wglShareLists
4006  *
4007  * For OpenGL32 wglShareLists.
4008  */
4009 BOOL CDECL X11DRV_wglShareLists(HGLRC hglrc1, HGLRC hglrc2) {
4010     opengl_error();
4011     return FALSE;
4012 }
4013
4014 /**
4015  * X11DRV_wglUseFontBitmapsA
4016  *
4017  * For OpenGL32 wglUseFontBitmapsA.
4018  */
4019 BOOL CDECL X11DRV_wglUseFontBitmapsA(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
4020 {
4021     opengl_error();
4022     return FALSE;
4023 }
4024
4025 /**
4026  * X11DRV_wglUseFontBitmapsW
4027  *
4028  * For OpenGL32 wglUseFontBitmapsW.
4029  */
4030 BOOL CDECL X11DRV_wglUseFontBitmapsW(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
4031 {
4032     opengl_error();
4033     return FALSE;
4034 }
4035
4036 /**
4037  * X11DRV_wglSetPixelFormatWINE
4038  *
4039  * WGL_WINE_pixel_format_passthrough: wglSetPixelFormatWINE
4040  * This is a WINE-specific wglSetPixelFormat which can set the pixel format multiple times.
4041  */
4042 BOOL CDECL X11DRV_wglSetPixelFormatWINE(X11DRV_PDEVICE *physDev, int iPixelFormat, const PIXELFORMATDESCRIPTOR *ppfd)
4043 {
4044     opengl_error();
4045     return FALSE;
4046 }
4047
4048 Drawable get_glxdrawable(X11DRV_PDEVICE *physDev)
4049 {
4050     return 0;
4051 }
4052
4053 BOOL destroy_glxpixmap(Display *display, XID glxpixmap)
4054 {
4055     return FALSE;
4056 }
4057
4058 XVisualInfo *visual_from_fbconfig_id( XID fbconfig_id )
4059 {
4060     return NULL;
4061 }
4062
4063 #endif /* defined(SONAME_LIBGL) */