dlls/opengl32/wgl.c

   1 /* Window-specific OpenGL functions implementation.
   2  *
   3  * Copyright (c) 1999 Lionel Ulmer
   4  * Copyright (c) 2005 Raphael Junqueira
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdarg.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winuser.h"
  31 #include "winreg.h"
  32 #include "wingdi.h"
  33 #include "winternl.h"
  34 #include "winnt.h"
  35
  36 #include "opengl_ext.h"
  37 #ifdef HAVE_GL_GLU_H
  38 #undef far
  39 #undef near
  40 #include <GL/glu.h>
  41 #endif
  42 #include "wine/gdi_driver.h"
  43 #include "wine/library.h"
  44 #include "wine/debug.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(wgl);
  47 WINE_DECLARE_DEBUG_CHANNEL(opengl);
  48
  49 static struct
  50 {
  51     /* internal WGL functions */
  52     void  (WINAPI *p_wglFinish)(void);
  53     void  (WINAPI *p_wglFlush)(void);
  54     void  (WINAPI *p_wglGetIntegerv)(GLenum pname, GLint* params);
  55 } wine_wgl;
  56
  57 #ifdef SONAME_LIBGLU
  58 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
  59 MAKE_FUNCPTR(gluNewTess)
  60 MAKE_FUNCPTR(gluDeleteTess)
  61 MAKE_FUNCPTR(gluTessBeginContour)
  62 MAKE_FUNCPTR(gluTessBeginPolygon)
  63 MAKE_FUNCPTR(gluTessCallback)
  64 MAKE_FUNCPTR(gluTessEndContour)
  65 MAKE_FUNCPTR(gluTessEndPolygon)
  66 MAKE_FUNCPTR(gluTessVertex)
  67 #undef MAKE_FUNCPTR
  68 #endif /* SONAME_LIBGLU */
  69
  70 static HMODULE opengl32_handle;
  71 static void* libglu_handle = NULL;
  72
  73 const GLubyte * WINAPI wine_glGetString( GLenum name );
  74
  75 /* internal GDI functions */
  76 extern INT WINAPI GdiDescribePixelFormat( HDC hdc, INT fmt, UINT size, PIXELFORMATDESCRIPTOR *pfd );
  77 extern BOOL WINAPI GdiSetPixelFormat( HDC hdc, INT fmt, const PIXELFORMATDESCRIPTOR *pfd );
  78 extern BOOL WINAPI GdiSwapBuffers( HDC hdc );
  79
  80 /* handle management */
  81
  82 #define MAX_WGL_HANDLES 1024
  83
  84 struct wgl_handle
  85 {
  86     UINT                    handle;
  87     DWORD                   tid;
  88     struct wgl_context *    context;
  89     const struct wgl_funcs *funcs;
  90 };
  91
  92 static struct wgl_handle wgl_handles[MAX_WGL_HANDLES];
  93 static struct wgl_handle *next_free;
  94 static unsigned int handle_count;
  95
  96 static CRITICAL_SECTION wgl_section;
  97 static CRITICAL_SECTION_DEBUG critsect_debug =
  98 {
  99     0, 0, &wgl_section,
 100     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 101       0, 0, { (DWORD_PTR)(__FILE__ ": wgl_section") }
 102 };
 103 static CRITICAL_SECTION wgl_section = { &critsect_debug, -1, 0, 0, 0, 0 };
 104
 105 static inline const struct wgl_funcs *get_dc_funcs( HDC hdc )
 106 {
 107     return __wine_get_wgl_driver( hdc, WINE_GDI_DRIVER_VERSION );
 108 }
 109
 110 static inline HGLRC next_handle( struct wgl_handle *ptr )
 111 {
 112     WORD generation = HIWORD( ptr->handle ) + 1;
 113     if (!generation) generation++;
 114     ptr->handle = MAKELONG( ptr - wgl_handles, generation );
 115     return ULongToHandle( ptr->handle );
 116 }
 117
 118 /* the current handle is assumed valid and doesn't need locking */
 119 static inline struct wgl_handle *get_current_handle_ptr(void)
 120 {
 121     if (!NtCurrentTeb()->glCurrentRC) return NULL;
 122     return &wgl_handles[LOWORD(NtCurrentTeb()->glCurrentRC)];
 123 }
 124
 125 static struct wgl_handle *get_handle_ptr( HGLRC handle )
 126 {
 127     unsigned int index = LOWORD( handle );
 128
 129     EnterCriticalSection( &wgl_section );
 130     if (index < handle_count && ULongToHandle(wgl_handles[index].handle) == handle)
 131         return &wgl_handles[index];
 132
 133     LeaveCriticalSection( &wgl_section );
 134     SetLastError( ERROR_INVALID_HANDLE );
 135     return NULL;
 136 }
 137
 138 static void release_handle_ptr( struct wgl_handle *ptr )
 139 {
 140     if (ptr) LeaveCriticalSection( &wgl_section );
 141 }
 142
 143 static HGLRC alloc_handle( struct wgl_context *context, const struct wgl_funcs *funcs )
 144 {
 145     HGLRC handle = 0;
 146     struct wgl_handle *ptr = NULL;
 147
 148     EnterCriticalSection( &wgl_section );
 149     if ((ptr = next_free))
 150         next_free = (struct wgl_handle *)next_free->context;
 151     else if (handle_count < MAX_WGL_HANDLES)
 152         ptr = &wgl_handles[handle_count++];
 153
 154     if (ptr)
 155     {
 156         ptr->context = context;
 157         ptr->funcs = funcs;
 158         handle = next_handle( ptr );
 159     }
 160     else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 161     LeaveCriticalSection( &wgl_section );
 162     return handle;
 163 }
 164
 165 static void free_handle_ptr( struct wgl_handle *ptr )
 166 {
 167     ptr->handle &= ~0xffff;
 168     ptr->context = (struct wgl_context *)next_free;
 169     ptr->funcs = NULL;
 170     next_free = ptr;
 171     LeaveCriticalSection( &wgl_section );
 172 }
 173
 174 /***********************************************************************
 175  *               wglSetPixelFormat(OPENGL32.@)
 176  */
 177 BOOL WINAPI wglSetPixelFormat( HDC hdc, INT iPixelFormat,
 178                                const PIXELFORMATDESCRIPTOR *ppfd)
 179 {
 180     return GdiSetPixelFormat(hdc, iPixelFormat, ppfd);
 181 }
 182
 183 /***********************************************************************
 184  *              wglCopyContext (OPENGL32.@)
 185  */
 186 BOOL WINAPI wglCopyContext(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask)
 187 {
 188     struct wgl_handle *src, *dst;
 189     BOOL ret = FALSE;
 190
 191     if (!(src = get_handle_ptr( hglrcSrc ))) return FALSE;
 192     if ((dst = get_handle_ptr( hglrcDst )))
 193     {
 194         if (src->funcs != dst->funcs) SetLastError( ERROR_INVALID_HANDLE );
 195         else ret = src->funcs->p_wglCopyContext( src->context, dst->context, mask );
 196     }
 197     release_handle_ptr( dst );
 198     release_handle_ptr( src );
 199     return ret;
 200 }
 201
 202 /***********************************************************************
 203  *              wglDeleteContext (OPENGL32.@)
 204  */
 205 BOOL WINAPI wglDeleteContext(HGLRC hglrc)
 206 {
 207     struct wgl_handle *ptr = get_handle_ptr( hglrc );
 208
 209     if (!ptr) return FALSE;
 210
 211     if (ptr->tid && ptr->tid != GetCurrentThreadId())
 212     {
 213         SetLastError( ERROR_BUSY );
 214         release_handle_ptr( ptr );
 215         return FALSE;
 216     }
 217     if (hglrc == NtCurrentTeb()->glCurrentRC) wglMakeCurrent( 0, 0 );
 218     ptr->funcs->p_wglDeleteContext( ptr->context );
 219     free_handle_ptr( ptr );
 220     return TRUE;
 221 }
 222
 223 /***********************************************************************
 224  *              wglMakeCurrent (OPENGL32.@)
 225  */
 226 BOOL WINAPI wglMakeCurrent(HDC hdc, HGLRC hglrc)
 227 {
 228     BOOL ret = TRUE;
 229     struct wgl_handle *ptr, *prev = get_current_handle_ptr();
 230
 231     if (hglrc)
 232     {
 233         if (!(ptr = get_handle_ptr( hglrc ))) return FALSE;
 234         if (!ptr->tid || ptr->tid == GetCurrentThreadId())
 235         {
 236             ret = ptr->funcs->p_wglMakeCurrent( hdc, ptr->context );
 237             if (ret)
 238             {
 239                 if (prev) prev->tid = 0;
 240                 ptr->tid = GetCurrentThreadId();
 241                 NtCurrentTeb()->glCurrentRC = hglrc;
 242             }
 243         }
 244         else
 245         {
 246             SetLastError( ERROR_BUSY );
 247             ret = FALSE;
 248         }
 249         release_handle_ptr( ptr );
 250     }
 251     else if (prev)
 252     {
 253         if (!prev->funcs->p_wglMakeCurrent( 0, NULL )) return FALSE;
 254         prev->tid = 0;
 255         NtCurrentTeb()->glCurrentRC = 0;
 256     }
 257     else if (!hdc)
 258     {
 259         SetLastError( ERROR_INVALID_HANDLE );
 260         ret = FALSE;
 261     }
 262     return ret;
 263 }
 264
 265 /***********************************************************************
 266  *              wglCreateContextAttribsARB  (wrapper for the extension function returned by the driver)
 267  */
 268 static HGLRC WINAPI wglCreateContextAttribsARB( HDC hdc, HGLRC share, const int *attribs )
 269 {
 270     HGLRC ret = 0;
 271     struct wgl_context *context;
 272     struct wgl_handle *share_ptr = NULL;
 273     const struct wgl_funcs *funcs = get_dc_funcs( hdc );
 274
 275     if (!funcs) return 0;
 276     if (share && !(share_ptr = get_handle_ptr( share ))) return 0;
 277     if ((context = funcs->p_wglCreateContextAttribsARB( hdc, share_ptr ? share_ptr->context : NULL,
 278                                                         attribs )))
 279     {
 280         ret = alloc_handle( context, funcs );
 281         if (!ret) funcs->p_wglDeleteContext( context );
 282     }
 283     release_handle_ptr( share_ptr );
 284     return ret;
 285
 286 }
 287
 288 /***********************************************************************
 289  *              wglMakeContextCurrentARB  (wrapper for the extension function returned by the driver)
 290  */
 291 static BOOL WINAPI wglMakeContextCurrentARB( HDC draw_hdc, HDC read_hdc, HGLRC hglrc )
 292 {
 293     BOOL ret = TRUE;
 294     struct wgl_handle *ptr, *prev = get_current_handle_ptr();
 295
 296     if (hglrc)
 297     {
 298         if (!(ptr = get_handle_ptr( hglrc ))) return FALSE;
 299         if (!ptr->tid || ptr->tid == GetCurrentThreadId())
 300         {
 301             ret = ptr->funcs->p_wglMakeContextCurrentARB( draw_hdc, read_hdc, ptr->context );
 302             if (ret)
 303             {
 304                 if (prev) prev->tid = 0;
 305                 ptr->tid = GetCurrentThreadId();
 306                 NtCurrentTeb()->glCurrentRC = hglrc;
 307             }
 308         }
 309         else
 310         {
 311             SetLastError( ERROR_BUSY );
 312             ret = FALSE;
 313         }
 314         release_handle_ptr( ptr );
 315     }
 316     else if (prev)
 317     {
 318         if (!prev->funcs->p_wglMakeCurrent( 0, NULL )) return FALSE;
 319         prev->tid = 0;
 320         NtCurrentTeb()->glCurrentRC = 0;
 321     }
 322     return ret;
 323 }
 324
 325 /***********************************************************************
 326  *              wglShareLists (OPENGL32.@)
 327  */
 328 BOOL WINAPI wglShareLists(HGLRC hglrcSrc, HGLRC hglrcDst)
 329 {
 330     BOOL ret = FALSE;
 331     struct wgl_handle *src, *dst;
 332
 333     if (!(src = get_handle_ptr( hglrcSrc ))) return FALSE;
 334     if ((dst = get_handle_ptr( hglrcDst )))
 335     {
 336         if (src->funcs != dst->funcs) SetLastError( ERROR_INVALID_HANDLE );
 337         else ret = src->funcs->p_wglShareLists( src->context, dst->context );
 338     }
 339     release_handle_ptr( dst );
 340     release_handle_ptr( src );
 341     return ret;
 342 }
 343
 344 /***********************************************************************
 345  *              wglGetCurrentDC (OPENGL32.@)
 346  */
 347 HDC WINAPI wglGetCurrentDC(void)
 348 {
 349     struct wgl_handle *context = get_current_handle_ptr();
 350     if (!context) return 0;
 351     return context->funcs->p_wglGetCurrentDC( context->context );
 352 }
 353
 354 /***********************************************************************
 355  *              wglCreateContext (OPENGL32.@)
 356  */
 357 HGLRC WINAPI wglCreateContext(HDC hdc)
 358 {
 359     HGLRC ret = 0;
 360     struct wgl_context *context;
 361     const struct wgl_funcs *funcs = get_dc_funcs( hdc );
 362
 363     if (!funcs) return 0;
 364     if (!(context = funcs->p_wglCreateContext( hdc ))) return 0;
 365     ret = alloc_handle( context, funcs );
 366     if (!ret) funcs->p_wglDeleteContext( context );
 367     return ret;
 368 }
 369
 370 /***********************************************************************
 371  *              wglGetCurrentContext (OPENGL32.@)
 372  */
 373 HGLRC WINAPI wglGetCurrentContext(void)
 374 {
 375     return NtCurrentTeb()->glCurrentRC;
 376 }
 377
 378 /***********************************************************************
 379  *              wglChoosePixelFormat (OPENGL32.@)
 380  */
 381 INT WINAPI wglChoosePixelFormat(HDC hdc, const PIXELFORMATDESCRIPTOR* ppfd)
 382 {
 383     PIXELFORMATDESCRIPTOR format, best;
 384     int i, count, best_format;
 385     int bestDBuffer = -1, bestStereo = -1;
 386
 387     TRACE_(wgl)( "%p %p: size %u version %u flags %u type %u color %u %u,%u,%u,%u "
 388                  "accum %u depth %u stencil %u aux %u\n",
 389                  hdc, ppfd, ppfd->nSize, ppfd->nVersion, ppfd->dwFlags, ppfd->iPixelType,
 390                  ppfd->cColorBits, ppfd->cRedBits, ppfd->cGreenBits, ppfd->cBlueBits, ppfd->cAlphaBits,
 391                  ppfd->cAccumBits, ppfd->cDepthBits, ppfd->cStencilBits, ppfd->cAuxBuffers );
 392
 393     count = GdiDescribePixelFormat( hdc, 0, 0, NULL );
 394     if (!count) return 0;
 395
 396     best_format = 0;
 397     best.dwFlags = 0;
 398     best.cAlphaBits = -1;
 399     best.cColorBits = -1;
 400     best.cDepthBits = -1;
 401     best.cStencilBits = -1;
 402     best.cAuxBuffers = -1;
 403
 404     for (i = 1; i <= count; i++)
 405     {
 406         if (!GdiDescribePixelFormat( hdc, i, sizeof(format), &format )) continue;
 407
 408         if (ppfd->iPixelType != format.iPixelType)
 409         {
 410             TRACE( "pixel type mismatch for iPixelFormat=%d\n", i );
 411             continue;
 412         }
 413
 414         /* only use bitmap capable for formats for bitmap rendering */
 415         if( (ppfd->dwFlags & PFD_DRAW_TO_BITMAP) != (format.dwFlags & PFD_DRAW_TO_BITMAP))
 416         {
 417             TRACE( "PFD_DRAW_TO_BITMAP mismatch for iPixelFormat=%d\n", i );
 418             continue;
 419         }
 420
 421         /* The behavior of PDF_STEREO/PFD_STEREO_DONTCARE and PFD_DOUBLEBUFFER / PFD_DOUBLEBUFFER_DONTCARE
 422          * is not very clear on MSDN. They specify that ChoosePixelFormat tries to match pixel formats
 423          * with the flag (PFD_STEREO / PFD_DOUBLEBUFFERING) set. Otherwise it says that it tries to match
 424          * formats without the given flag set.
 425          * A test on Windows using a Radeon 9500pro on WinXP (the driver doesn't support Stereo)
 426          * has indicated that a format without stereo is returned when stereo is unavailable.
 427          * So in case PFD_STEREO is set, formats that support it should have priority above formats
 428          * without. In case PFD_STEREO_DONTCARE is set, stereo is ignored.
 429          *
 430          * To summarize the following is most likely the correct behavior:
 431          * stereo not set -> prefer non-stereo formats, but also accept stereo formats
 432          * stereo set -> prefer stereo formats, but also accept non-stereo formats
 433          * stereo don't care -> it doesn't matter whether we get stereo or not
 434          *
 435          * In Wine we will treat non-stereo the same way as don't care because it makes
 436          * format selection even more complicated and second drivers with Stereo advertise
 437          * each format twice anyway.
 438          */
 439
 440         /* Doublebuffer, see the comments above */
 441         if (!(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE))
 442         {
 443             if (((ppfd->dwFlags & PFD_DOUBLEBUFFER) != bestDBuffer) &&
 444                 ((format.dwFlags & PFD_DOUBLEBUFFER) == (ppfd->dwFlags & PFD_DOUBLEBUFFER)))
 445                 goto found;
 446
 447             if (bestDBuffer != -1 && (format.dwFlags & PFD_DOUBLEBUFFER) != bestDBuffer) continue;
 448         }
 449
 450         /* Stereo, see the comments above. */
 451         if (!(ppfd->dwFlags & PFD_STEREO_DONTCARE))
 452         {
 453             if (((ppfd->dwFlags & PFD_STEREO) != bestStereo) &&
 454                 ((format.dwFlags & PFD_STEREO) == (ppfd->dwFlags & PFD_STEREO)))
 455                 goto found;
 456
 457             if (bestStereo != -1 && (format.dwFlags & PFD_STEREO) != bestStereo) continue;
 458         }
 459
 460         /* Below we will do a number of checks to select the 'best' pixelformat.
 461          * We assume the precedence cColorBits > cAlphaBits > cDepthBits > cStencilBits -> cAuxBuffers.
 462          * The code works by trying to match the most important options as close as possible.
 463          * When a reasonable format is found, we will try to match more options.
 464          * It appears (see the opengl32 test) that Windows opengl drivers ignore options
 465          * like cColorBits, cAlphaBits and friends if they are set to 0, so they are considered
 466          * as DONTCARE. At least Serious Sam TSE relies on this behavior. */
 467
 468         if (ppfd->cColorBits)
 469         {
 470             if (((ppfd->cColorBits > best.cColorBits) && (format.cColorBits > best.cColorBits)) ||
 471                 ((format.cColorBits >= ppfd->cColorBits) && (format.cColorBits < best.cColorBits)))
 472                 goto found;
 473
 474             if (best.cColorBits != format.cColorBits)  /* Do further checks if the format is compatible */
 475             {
 476                 TRACE( "color mismatch for iPixelFormat=%d\n", i );
 477                 continue;
 478             }
 479         }
 480         if (ppfd->cAlphaBits)
 481         {
 482             if (((ppfd->cAlphaBits > best.cAlphaBits) && (format.cAlphaBits > best.cAlphaBits)) ||
 483                 ((format.cAlphaBits >= ppfd->cAlphaBits) && (format.cAlphaBits < best.cAlphaBits)))
 484                 goto found;
 485
 486             if (best.cAlphaBits != format.cAlphaBits)
 487             {
 488                 TRACE( "alpha mismatch for iPixelFormat=%d\n", i );
 489                 continue;
 490             }
 491         }
 492         if (ppfd->cDepthBits)
 493         {
 494             if (((ppfd->cDepthBits > best.cDepthBits) && (format.cDepthBits > best.cDepthBits)) ||
 495                 ((format.cDepthBits >= ppfd->cDepthBits) && (format.cDepthBits < best.cDepthBits)))
 496                 goto found;
 497
 498             if (best.cDepthBits != format.cDepthBits)
 499             {
 500                 TRACE( "depth mismatch for iPixelFormat=%d\n", i );
 501                 continue;
 502             }
 503         }
 504         if (ppfd->cStencilBits)
 505         {
 506             if (((ppfd->cStencilBits > best.cStencilBits) && (format.cStencilBits > best.cStencilBits)) ||
 507                 ((format.cStencilBits >= ppfd->cStencilBits) && (format.cStencilBits < best.cStencilBits)))
 508                 goto found;
 509
 510             if (best.cStencilBits != format.cStencilBits)
 511             {
 512                 TRACE( "stencil mismatch for iPixelFormat=%d\n", i );
 513                 continue;
 514             }
 515         }
 516         if (ppfd->cAuxBuffers)
 517         {
 518             if (((ppfd->cAuxBuffers > best.cAuxBuffers) && (format.cAuxBuffers > best.cAuxBuffers)) ||
 519                 ((format.cAuxBuffers >= ppfd->cAuxBuffers) && (format.cAuxBuffers < best.cAuxBuffers)))
 520                 goto found;
 521
 522             if (best.cAuxBuffers != format.cAuxBuffers)
 523             {
 524                 TRACE( "aux mismatch for iPixelFormat=%d\n", i );
 525                 continue;
 526             }
 527         }
 528         continue;
 529
 530     found:
 531         best_format = i;
 532         best = format;
 533         bestDBuffer = format.dwFlags & PFD_DOUBLEBUFFER;
 534         bestStereo = format.dwFlags & PFD_STEREO;
 535     }
 536
 537     TRACE( "returning %u\n", best_format );
 538     return best_format;
 539 }
 540
 541 /***********************************************************************
 542  *              wglDescribePixelFormat (OPENGL32.@)
 543  */
 544 INT WINAPI wglDescribePixelFormat(HDC hdc, INT iPixelFormat, UINT nBytes,
 545                                 LPPIXELFORMATDESCRIPTOR ppfd)
 546 {
 547   return GdiDescribePixelFormat(hdc, iPixelFormat, nBytes, ppfd);
 548 }
 549
 550 /***********************************************************************
 551  *              wglGetPixelFormat (OPENGL32.@)
 552  */
 553 INT WINAPI wglGetPixelFormat(HDC hdc)
 554 {
 555     const struct wgl_funcs *funcs = get_dc_funcs( hdc );
 556     if (!funcs) return 0;
 557     return funcs->p_GetPixelFormat( hdc );
 558 }
 559
 560 /***********************************************************************
 561  *              wglCreateLayerContext (OPENGL32.@)
 562  */
 563 HGLRC WINAPI wglCreateLayerContext(HDC hdc,
 564                                    int iLayerPlane) {
 565   TRACE("(%p,%d)\n", hdc, iLayerPlane);
 566
 567   if (iLayerPlane == 0) {
 568       return wglCreateContext(hdc);
 569   }
 570   FIXME("no handler for layer %d\n", iLayerPlane);
 571
 572   return NULL;
 573 }
 574
 575 /***********************************************************************
 576  *              wglDescribeLayerPlane (OPENGL32.@)
 577  */
 578 BOOL WINAPI wglDescribeLayerPlane(HDC hdc,
 579                                   int iPixelFormat,
 580                                   int iLayerPlane,
 581                                   UINT nBytes,
 582                                   LPLAYERPLANEDESCRIPTOR plpd) {
 583   FIXME("(%p,%d,%d,%d,%p)\n", hdc, iPixelFormat, iLayerPlane, nBytes, plpd);
 584
 585   return FALSE;
 586 }
 587
 588 /***********************************************************************
 589  *              wglGetLayerPaletteEntries (OPENGL32.@)
 590  */
 591 int WINAPI wglGetLayerPaletteEntries(HDC hdc,
 592                                      int iLayerPlane,
 593                                      int iStart,
 594                                      int cEntries,
 595                                      const COLORREF *pcr) {
 596   FIXME("(): stub!\n");
 597
 598   return 0;
 599 }
 600
 601 /* check if the extension is present in the list */
 602 static BOOL has_extension( const char *list, const char *ext )
 603 {
 604     size_t len = strlen( ext );
 605
 606     while (list)
 607     {
 608         while (*list == ' ') list++;
 609         if (!strncmp( list, ext, len ) && (!list[len] || list[len] == ' ')) return TRUE;
 610         list = strchr( list, ' ' );
 611     }
 612     return FALSE;
 613 }
 614
 615 static int compar(const void *elt_a, const void *elt_b) {
 616   return strcmp(((const OpenGL_extension *) elt_a)->name,
 617                 ((const OpenGL_extension *) elt_b)->name);
 618 }
 619
 620 /* Check if a GL extension is supported */
 621 static BOOL is_extension_supported(const char* extension)
 622 {
 623     const char *gl_ext_string = (const char*)wine_glGetString(GL_EXTENSIONS);
 624
 625     TRACE("Checking for extension '%s'\n", extension);
 626
 627     if(!gl_ext_string) {
 628         ERR("No OpenGL extensions found, check if your OpenGL setup is correct!\n");
 629         return FALSE;
 630     }
 631
 632     /* We use the GetProcAddress function from the display driver to retrieve function pointers
 633      * for OpenGL and WGL extensions. In case of winex11.drv the OpenGL extension lookup is done
 634      * using glXGetProcAddress. This function is quite unreliable in the sense that its specs don't
 635      * require the function to return NULL when an extension isn't found. For this reason we check
 636      * if the OpenGL extension required for the function we are looking up is supported. */
 637
 638     /* Check if the extension is part of the GL extension string to see if it is supported. */
 639     if (has_extension(gl_ext_string, extension))
 640         return TRUE;
 641
 642     /* In general an OpenGL function starts as an ARB/EXT extension and at some stage
 643      * it becomes part of the core OpenGL library and can be reached without the ARB/EXT
 644      * suffix as well. In the extension table, these functions contain GL_VERSION_major_minor.
 645      * Check if we are searching for a core GL function */
 646     if(strncmp(extension, "GL_VERSION_", 11) == 0)
 647     {
 648         const GLubyte *gl_version = glGetString(GL_VERSION);
 649         const char *version = extension + 11; /* Move past 'GL_VERSION_' */
 650
 651         if(!gl_version) {
 652             ERR("No OpenGL version found!\n");
 653             return FALSE;
 654         }
 655
 656         /* Compare the major/minor version numbers of the native OpenGL library and what is required by the function.
 657          * The gl_version string is guaranteed to have at least a major/minor and sometimes it has a release number as well. */
 658         if( (gl_version[0] >= version[0]) || ((gl_version[0] == version[0]) && (gl_version[2] >= version[2])) ) {
 659             return TRUE;
 660         }
 661         WARN("The function requires OpenGL version '%c.%c' while your drivers only provide '%c.%c'\n", version[0], version[2], gl_version[0], gl_version[2]);
 662     }
 663
 664     return FALSE;
 665 }
 666
 667 static const OpenGL_extension wgl_extensions[] =
 668 {
 669     { "wglCreateContextAttribsARB", "WGL_ARB_create_context", wglCreateContextAttribsARB },
 670     { "wglMakeContextCurrentARB", "WGL_ARB_make_current_read", wglMakeContextCurrentARB },
 671 };
 672
 673 /***********************************************************************
 674  *              wglGetProcAddress (OPENGL32.@)
 675  */
 676 PROC WINAPI wglGetProcAddress(LPCSTR  lpszProc) {
 677   void *local_func;
 678   OpenGL_extension  ext;
 679   const OpenGL_extension *ext_ret;
 680   struct wgl_handle *context = get_current_handle_ptr();
 681
 682   TRACE("(%s)\n", lpszProc);
 683
 684   if (lpszProc == NULL)
 685     return NULL;
 686
 687   /* Without an active context opengl32 doesn't know to what
 688    * driver it has to dispatch wglGetProcAddress.
 689    */
 690   if (!context)
 691   {
 692     WARN("No active WGL context found\n");
 693     return NULL;
 694   }
 695
 696   /* Search in the thunks to find the real name of the extension */
 697   ext.name = lpszProc;
 698   ext_ret = bsearch(&ext, extension_registry, extension_registry_size,
 699                     sizeof(OpenGL_extension), compar);
 700
 701   /* If nothing was found, we are looking for a WGL extension or an unknown GL extension. */
 702   if (ext_ret == NULL) {
 703     /* If the function name starts with a 'w', it is a WGL extension */
 704     if(lpszProc[0] == 'w')
 705     {
 706         local_func = context->funcs->p_wglGetProcAddress( lpszProc );
 707         if (local_func == (void *)1)  /* special function that needs a wrapper */
 708         {
 709             ext_ret = bsearch( &ext, wgl_extensions, sizeof(wgl_extensions)/sizeof(wgl_extensions[0]),
 710                                sizeof(OpenGL_extension), compar );
 711             if (ext_ret) return ext_ret->func;
 712
 713             FIXME( "wrapper missing for %s\n", lpszProc );
 714             return NULL;
 715         }
 716         return local_func;
 717     }
 718
 719     /* We are dealing with an unknown GL extension */
 720     WARN("Extension '%s' not defined in opengl32.dll's function table!\n", lpszProc);
 721     return NULL;
 722   } else { /* We are looking for an OpenGL extension */
 723
 724     /* Check if the GL extension required by the function is available */
 725     if(!is_extension_supported(ext_ret->extension)) {
 726         WARN("Extension '%s' required by function '%s' not supported!\n", ext_ret->extension, lpszProc);
 727     }
 728
 729     local_func = context->funcs->p_wglGetProcAddress( ext_ret->name );
 730
 731     /* After that, look at the extensions defined in the Linux OpenGL library */
 732     if (local_func == NULL) {
 733       char buf[256];
 734       void *ret = NULL;
 735
 736       /* Remove the last 3 letters (EXT, ARB, ...).
 737
 738          I know that some extensions have more than 3 letters (MESA, NV,
 739          INTEL, ...), but this is only a stop-gap measure to fix buggy
 740          OpenGL drivers (moreover, it is only useful for old 1.0 apps
 741          that query the glBindTextureEXT extension).
 742       */
 743       memcpy(buf, ext_ret->name, strlen(ext_ret->name) - 3);
 744       buf[strlen(ext_ret->name) - 3] = '\0';
 745       TRACE("Extension not found in the Linux OpenGL library, checking against libGL bug with %s..\n", buf);
 746
 747       ret = GetProcAddress(opengl32_handle, buf);
 748       if (ret != NULL) {
 749         TRACE("Found function in main OpenGL library (%p)!\n", ret);
 750       } else {
 751         WARN("Did not find function %s (%s) in your OpenGL library!\n", lpszProc, ext_ret->name);
 752       }
 753
 754       return ret;
 755     } else {
 756       TRACE("returning function (%p)\n", ext_ret->func);
 757       extension_funcs[ext_ret - extension_registry] = local_func;
 758
 759       return ext_ret->func;
 760     }
 761   }
 762 }
 763
 764 /***********************************************************************
 765  *              wglRealizeLayerPalette (OPENGL32.@)
 766  */
 767 BOOL WINAPI wglRealizeLayerPalette(HDC hdc,
 768                                    int iLayerPlane,
 769                                    BOOL bRealize) {
 770   FIXME("()\n");
 771
 772   return FALSE;
 773 }
 774
 775 /***********************************************************************
 776  *              wglSetLayerPaletteEntries (OPENGL32.@)
 777  */
 778 int WINAPI wglSetLayerPaletteEntries(HDC hdc,
 779                                      int iLayerPlane,
 780                                      int iStart,
 781                                      int cEntries,
 782                                      const COLORREF *pcr) {
 783   FIXME("(): stub!\n");
 784
 785   return 0;
 786 }
 787
 788 /***********************************************************************
 789  *              wglSwapLayerBuffers (OPENGL32.@)
 790  */
 791 BOOL WINAPI wglSwapLayerBuffers(HDC hdc,
 792                                 UINT fuPlanes) {
 793   TRACE_(opengl)("(%p, %08x)\n", hdc, fuPlanes);
 794
 795   if (fuPlanes & WGL_SWAP_MAIN_PLANE) {
 796     if (!GdiSwapBuffers(hdc)) return FALSE;
 797     fuPlanes &= ~WGL_SWAP_MAIN_PLANE;
 798   }
 799
 800   if (fuPlanes) {
 801     WARN("Following layers unhandled: %08x\n", fuPlanes);
 802   }
 803
 804   return TRUE;
 805 }
 806
 807 /***********************************************************************
 808  *              wglUseFontBitmaps_common
 809  */
 810 static BOOL wglUseFontBitmaps_common( HDC hdc, DWORD first, DWORD count, DWORD listBase, BOOL unicode )
 811 {
 812      GLYPHMETRICS gm;
 813      unsigned int glyph, size = 0;
 814      void *bitmap = NULL, *gl_bitmap = NULL;
 815      int org_alignment;
 816      BOOL ret = TRUE;
 817
 818      glGetIntegerv(GL_UNPACK_ALIGNMENT, &org_alignment);
 819      glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
 820
 821      for (glyph = first; glyph < first + count; glyph++) {
 822          static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
 823          unsigned int needed_size, height, width, width_int;
 824
 825          if (unicode)
 826              needed_size = GetGlyphOutlineW(hdc, glyph, GGO_BITMAP, &gm, 0, NULL, &identity);
 827          else
 828              needed_size = GetGlyphOutlineA(hdc, glyph, GGO_BITMAP, &gm, 0, NULL, &identity);
 829
 830          TRACE("Glyph: %3d / List: %d size %d\n", glyph, listBase, needed_size);
 831          if (needed_size == GDI_ERROR) {
 832              ret = FALSE;
 833              break;
 834          }
 835
 836          if (needed_size > size) {
 837              size = needed_size;
 838              HeapFree(GetProcessHeap(), 0, bitmap);
 839              HeapFree(GetProcessHeap(), 0, gl_bitmap);
 840              bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 841              gl_bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 842          }
 843          if (unicode)
 844              ret = (GetGlyphOutlineW(hdc, glyph, GGO_BITMAP, &gm, size, bitmap, &identity) != GDI_ERROR);
 845          else
 846              ret = (GetGlyphOutlineA(hdc, glyph, GGO_BITMAP, &gm, size, bitmap, &identity) != GDI_ERROR);
 847          if (!ret) break;
 848
 849          if (TRACE_ON(wgl)) {
 850              unsigned int bitmask;
 851              unsigned char *bitmap_ = bitmap;
 852
 853              TRACE("  - bbox: %d x %d\n", gm.gmBlackBoxX, gm.gmBlackBoxY);
 854              TRACE("  - origin: (%d, %d)\n", gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
 855              TRACE("  - increment: %d - %d\n", gm.gmCellIncX, gm.gmCellIncY);
 856              if (needed_size != 0) {
 857                  TRACE("  - bitmap:\n");
 858                  for (height = 0; height < gm.gmBlackBoxY; height++) {
 859                      TRACE("      ");
 860                      for (width = 0, bitmask = 0x80; width < gm.gmBlackBoxX; width++, bitmask >>= 1) {
 861                          if (bitmask == 0) {
 862                              bitmap_ += 1;
 863                              bitmask = 0x80;
 864                          }
 865                          if (*bitmap_ & bitmask)
 866                              TRACE("*");
 867                          else
 868                              TRACE(" ");
 869                      }
 870                      bitmap_ += (4 - ((UINT_PTR)bitmap_ & 0x03));
 871                      TRACE("\n");
 872                  }
 873              }
 874          }
 875
 876          /* In OpenGL, the bitmap is drawn from the bottom to the top... So we need to invert the
 877          * glyph for it to be drawn properly.
 878          */
 879          if (needed_size != 0) {
 880              width_int = (gm.gmBlackBoxX + 31) / 32;
 881              for (height = 0; height < gm.gmBlackBoxY; height++) {
 882                  for (width = 0; width < width_int; width++) {
 883                      ((int *) gl_bitmap)[(gm.gmBlackBoxY - height - 1) * width_int + width] =
 884                      ((int *) bitmap)[height * width_int + width];
 885                  }
 886              }
 887          }
 888
 889          glNewList(listBase++, GL_COMPILE);
 890          if (needed_size != 0) {
 891              glBitmap(gm.gmBlackBoxX, gm.gmBlackBoxY,
 892                      0 - gm.gmptGlyphOrigin.x, (int) gm.gmBlackBoxY - gm.gmptGlyphOrigin.y,
 893                      gm.gmCellIncX, gm.gmCellIncY,
 894                      gl_bitmap);
 895          } else {
 896              /* This is the case of 'empty' glyphs like the space character */
 897              glBitmap(0, 0, 0, 0, gm.gmCellIncX, gm.gmCellIncY, NULL);
 898          }
 899          glEndList();
 900      }
 901
 902      glPixelStorei(GL_UNPACK_ALIGNMENT, org_alignment);
 903      HeapFree(GetProcessHeap(), 0, bitmap);
 904      HeapFree(GetProcessHeap(), 0, gl_bitmap);
 905      return ret;
 906 }
 907
 908 /***********************************************************************
 909  *              wglUseFontBitmapsA (OPENGL32.@)
 910  */
 911 BOOL WINAPI wglUseFontBitmapsA(HDC hdc, DWORD first, DWORD count, DWORD listBase)
 912 {
 913     return wglUseFontBitmaps_common( hdc, first, count, listBase, FALSE );
 914 }
 915
 916 /***********************************************************************
 917  *              wglUseFontBitmapsW (OPENGL32.@)
 918  */
 919 BOOL WINAPI wglUseFontBitmapsW(HDC hdc, DWORD first, DWORD count, DWORD listBase)
 920 {
 921     return wglUseFontBitmaps_common( hdc, first, count, listBase, TRUE );
 922 }
 923
 924 #ifdef SONAME_LIBGLU
 925
 926 static void *load_libglu(void)
 927 {
 928     static int already_loaded;
 929     void *handle;
 930
 931     if (already_loaded) return libglu_handle;
 932     already_loaded = 1;
 933
 934     TRACE("Trying to load GLU library: %s\n", SONAME_LIBGLU);
 935     handle = wine_dlopen(SONAME_LIBGLU, RTLD_NOW, NULL, 0);
 936     if (!handle)
 937     {
 938         WARN("Failed to load %s\n", SONAME_LIBGLU);
 939         return NULL;
 940     }
 941
 942 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(handle, #f, NULL, 0)) == NULL) goto sym_not_found;
 943 LOAD_FUNCPTR(gluNewTess)
 944 LOAD_FUNCPTR(gluDeleteTess)
 945 LOAD_FUNCPTR(gluTessBeginContour)
 946 LOAD_FUNCPTR(gluTessBeginPolygon)
 947 LOAD_FUNCPTR(gluTessCallback)
 948 LOAD_FUNCPTR(gluTessEndContour)
 949 LOAD_FUNCPTR(gluTessEndPolygon)
 950 LOAD_FUNCPTR(gluTessVertex)
 951 #undef LOAD_FUNCPTR
 952     libglu_handle = handle;
 953     return handle;
 954
 955 sym_not_found:
 956     WARN("Unable to load function ptrs from libGLU\n");
 957     /* Close the library as we won't use it */
 958     wine_dlclose(handle, NULL, 0);
 959     return NULL;
 960 }
 961
 962 static void fixed_to_double(POINTFX fixed, UINT em_size, GLdouble vertex[3])
 963 {
 964     vertex[0] = (fixed.x.value + (GLdouble)fixed.x.fract / (1 << 16)) / em_size;
 965     vertex[1] = (fixed.y.value + (GLdouble)fixed.y.fract / (1 << 16)) / em_size;
 966     vertex[2] = 0.0;
 967 }
 968
 969 static void tess_callback_vertex(GLvoid *vertex)
 970 {
 971     GLdouble *dbl = vertex;
 972     TRACE("%f, %f, %f\n", dbl[0], dbl[1], dbl[2]);
 973     glVertex3dv(vertex);
 974 }
 975
 976 static void tess_callback_begin(GLenum which)
 977 {
 978     TRACE("%d\n", which);
 979     glBegin(which);
 980 }
 981
 982 static void tess_callback_end(void)
 983 {
 984     TRACE("\n");
 985     glEnd();
 986 }
 987
 988 /***********************************************************************
 989  *              wglUseFontOutlines_common
 990  */
 991 static BOOL wglUseFontOutlines_common(HDC hdc,
 992                                       DWORD first,
 993                                       DWORD count,
 994                                       DWORD listBase,
 995                                       FLOAT deviation,
 996                                       FLOAT extrusion,
 997                                       int format,
 998                                       LPGLYPHMETRICSFLOAT lpgmf,
 999                                       BOOL unicode)
1000 {
1001     UINT glyph;
1002     const MAT2 identity = {{0,1},{0,0},{0,0},{0,1}};
1003     GLUtesselator *tess;
1004     LOGFONTW lf;
1005     HFONT old_font, unscaled_font;
1006     UINT em_size = 1024;
1007     RECT rc;
1008
1009     TRACE("(%p, %d, %d, %d, %f, %f, %d, %p, %s)\n", hdc, first, count,
1010           listBase, deviation, extrusion, format, lpgmf, unicode ? "W" : "A");
1011
1012     if (!load_libglu())
1013     {
1014         ERR("libGLU is required for this function but isn't loaded\n");
1015         return FALSE;
1016     }
1017
1018     tess = pgluNewTess();
1019     if(!tess) return FALSE;
1020     pgluTessCallback(tess, GLU_TESS_VERTEX, (_GLUfuncptr)tess_callback_vertex);
1021     pgluTessCallback(tess, GLU_TESS_BEGIN, (_GLUfuncptr)tess_callback_begin);
1022     pgluTessCallback(tess, GLU_TESS_END, tess_callback_end);
1023
1024     GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), &lf);
1025     rc.left = rc.right = rc.bottom = 0;
1026     rc.top = em_size;
1027     DPtoLP(hdc, (POINT*)&rc, 2);
1028     lf.lfHeight = -abs(rc.top - rc.bottom);
1029     lf.lfOrientation = lf.lfEscapement = 0;
1030     unscaled_font = CreateFontIndirectW(&lf);
1031     old_font = SelectObject(hdc, unscaled_font);
1032
1033     for (glyph = first; glyph < first + count; glyph++)
1034     {
1035         DWORD needed;
1036         GLYPHMETRICS gm;
1037         BYTE *buf;
1038         TTPOLYGONHEADER *pph;
1039         TTPOLYCURVE *ppc;
1040         GLdouble *vertices;
1041
1042         if(unicode)
1043             needed = GetGlyphOutlineW(hdc, glyph, GGO_NATIVE, &gm, 0, NULL, &identity);
1044         else
1045             needed = GetGlyphOutlineA(hdc, glyph, GGO_NATIVE, &gm, 0, NULL, &identity);
1046
1047         if(needed == GDI_ERROR)
1048             goto error;
1049
1050         buf = HeapAlloc(GetProcessHeap(), 0, needed);
1051         vertices = HeapAlloc(GetProcessHeap(), 0, needed / sizeof(POINTFX) * 3 * sizeof(GLdouble));
1052
1053         if(unicode)
1054             GetGlyphOutlineW(hdc, glyph, GGO_NATIVE, &gm, needed, buf, &identity);
1055         else
1056             GetGlyphOutlineA(hdc, glyph, GGO_NATIVE, &gm, needed, buf, &identity);
1057
1058         TRACE("glyph %d\n", glyph);
1059
1060         if(lpgmf)
1061         {
1062             lpgmf->gmfBlackBoxX = (float)gm.gmBlackBoxX / em_size;
1063             lpgmf->gmfBlackBoxY = (float)gm.gmBlackBoxY / em_size;
1064             lpgmf->gmfptGlyphOrigin.x = (float)gm.gmptGlyphOrigin.x / em_size;
1065             lpgmf->gmfptGlyphOrigin.y = (float)gm.gmptGlyphOrigin.y / em_size;
1066             lpgmf->gmfCellIncX = (float)gm.gmCellIncX / em_size;
1067             lpgmf->gmfCellIncY = (float)gm.gmCellIncY / em_size;
1068
1069             TRACE("%fx%f at %f,%f inc %f,%f\n", lpgmf->gmfBlackBoxX, lpgmf->gmfBlackBoxY,
1070                   lpgmf->gmfptGlyphOrigin.x, lpgmf->gmfptGlyphOrigin.y, lpgmf->gmfCellIncX, lpgmf->gmfCellIncY);
1071             lpgmf++;
1072         }
1073
1074         glNewList(listBase++, GL_COMPILE);
1075         pgluTessBeginPolygon(tess, NULL);
1076
1077         pph = (TTPOLYGONHEADER*)buf;
1078         while((BYTE*)pph < buf + needed)
1079         {
1080             TRACE("\tstart %d, %d\n", pph->pfxStart.x.value, pph->pfxStart.y.value);
1081
1082             pgluTessBeginContour(tess);
1083
1084             fixed_to_double(pph->pfxStart, em_size, vertices);
1085             pgluTessVertex(tess, vertices, vertices);
1086             vertices += 3;
1087
1088             ppc = (TTPOLYCURVE*)((char*)pph + sizeof(*pph));
1089             while((char*)ppc < (char*)pph + pph->cb)
1090             {
1091                 int i;
1092
1093                 switch(ppc->wType) {
1094                 case TT_PRIM_LINE:
1095                     for(i = 0; i < ppc->cpfx; i++)
1096                     {
1097                         TRACE("\t\tline to %d, %d\n", ppc->apfx[i].x.value, ppc->apfx[i].y.value);
1098                         fixed_to_double(ppc->apfx[i], em_size, vertices);
1099                         pgluTessVertex(tess, vertices, vertices);
1100                         vertices += 3;
1101                     }
1102                     break;
1103
1104                 case TT_PRIM_QSPLINE:
1105                     for(i = 0; i < ppc->cpfx/2; i++)
1106                     {
1107                         /* FIXME: just connecting the control points for now */
1108                         TRACE("\t\tcurve  %d,%d %d,%d\n",
1109                               ppc->apfx[i * 2].x.value,     ppc->apfx[i * 3].y.value,
1110                               ppc->apfx[i * 2 + 1].x.value, ppc->apfx[i * 3 + 1].y.value);
1111                         fixed_to_double(ppc->apfx[i * 2], em_size, vertices);
1112                         pgluTessVertex(tess, vertices, vertices);
1113                         vertices += 3;
1114                         fixed_to_double(ppc->apfx[i * 2 + 1], em_size, vertices);
1115                         pgluTessVertex(tess, vertices, vertices);
1116                         vertices += 3;
1117                     }
1118                     break;
1119                 default:
1120                     ERR("\t\tcurve type = %d\n", ppc->wType);
1121                     pgluTessEndContour(tess);
1122                     goto error_in_list;
1123                 }
1124
1125                 ppc = (TTPOLYCURVE*)((char*)ppc + sizeof(*ppc) +
1126                                      (ppc->cpfx - 1) * sizeof(POINTFX));
1127             }
1128             pgluTessEndContour(tess);
1129             pph = (TTPOLYGONHEADER*)((char*)pph + pph->cb);
1130         }
1131
1132 error_in_list:
1133         pgluTessEndPolygon(tess);
1134         glTranslated((GLdouble)gm.gmCellIncX / em_size, (GLdouble)gm.gmCellIncY / em_size, 0.0);
1135         glEndList();
1136         HeapFree(GetProcessHeap(), 0, buf);
1137         HeapFree(GetProcessHeap(), 0, vertices);
1138     }
1139
1140  error:
1141     DeleteObject(SelectObject(hdc, old_font));
1142     pgluDeleteTess(tess);
1143     return TRUE;
1144
1145 }
1146
1147 #else /* SONAME_LIBGLU */
1148
1149 static BOOL wglUseFontOutlines_common(HDC hdc,
1150                                       DWORD first,
1151                                       DWORD count,
1152                                       DWORD listBase,
1153                                       FLOAT deviation,
1154                                       FLOAT extrusion,
1155                                       int format,
1156                                       LPGLYPHMETRICSFLOAT lpgmf,
1157                                       BOOL unicode)
1158 {
1159     FIXME("Unable to compile in wglUseFontOutlines support without GL/glu.h\n");
1160     return FALSE;
1161 }
1162
1163 #endif /* SONAME_LIBGLU */
1164
1165 /***********************************************************************
1166  *              wglUseFontOutlinesA (OPENGL32.@)
1167  */
1168 BOOL WINAPI wglUseFontOutlinesA(HDC hdc,
1169                                 DWORD first,
1170                                 DWORD count,
1171                                 DWORD listBase,
1172                                 FLOAT deviation,
1173                                 FLOAT extrusion,
1174                                 int format,
1175                                 LPGLYPHMETRICSFLOAT lpgmf)
1176 {
1177     return wglUseFontOutlines_common(hdc, first, count, listBase, deviation, extrusion, format, lpgmf, FALSE);
1178 }
1179
1180 /***********************************************************************
1181  *              wglUseFontOutlinesW (OPENGL32.@)
1182  */
1183 BOOL WINAPI wglUseFontOutlinesW(HDC hdc,
1184                                 DWORD first,
1185                                 DWORD count,
1186                                 DWORD listBase,
1187                                 FLOAT deviation,
1188                                 FLOAT extrusion,
1189                                 int format,
1190                                 LPGLYPHMETRICSFLOAT lpgmf)
1191 {
1192     return wglUseFontOutlines_common(hdc, first, count, listBase, deviation, extrusion, format, lpgmf, TRUE);
1193 }
1194
1195 /***********************************************************************
1196  *              glDebugEntry (OPENGL32.@)
1197  */
1198 GLint WINAPI wine_glDebugEntry( GLint unknown1, GLint unknown2 )
1199 {
1200     return 0;
1201 }
1202
1203 /***********************************************************************
1204  *              glFinish (OPENGL32.@)
1205  */
1206 void WINAPI wine_glFinish( void )
1207 {
1208     TRACE("()\n");
1209     wine_wgl.p_wglFinish();
1210 }
1211
1212 /***********************************************************************
1213  *              glFlush (OPENGL32.@)
1214  */
1215 void WINAPI wine_glFlush( void )
1216 {
1217     TRACE("()\n");
1218     wine_wgl.p_wglFlush();
1219 }
1220
1221 /* build the extension string by filtering out the disabled extensions */
1222 static char *build_gl_extensions( const char *extensions )
1223 {
1224     char *p, *str, *disabled = NULL;
1225     const char *end;
1226     HKEY hkey;
1227
1228     TRACE( "GL_EXTENSIONS:\n" );
1229
1230     if (!extensions) extensions = "";
1231
1232     /* @@ Wine registry key: HKCU\Software\Wine\OpenGL */
1233     if (!RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\OpenGL", &hkey ))
1234     {
1235         DWORD size, ret = RegQueryValueExA( hkey, "DisabledExtensions", 0, NULL, NULL, &size );
1236         if (!ret && (disabled = HeapAlloc( GetProcessHeap(), 0, size )))
1237             ret = RegQueryValueExA( hkey, "DisabledExtensions", 0, NULL, (BYTE *)disabled, &size );
1238         RegCloseKey( hkey );
1239         if (ret) *disabled = 0;
1240     }
1241
1242     if ((str = HeapAlloc( GetProcessHeap(), 0, strlen(extensions) + 2 )))
1243     {
1244         p = str;
1245         for (;;)
1246         {
1247             while (*extensions == ' ') extensions++;
1248             if (!*extensions) break;
1249             if (!(end = strchr( extensions, ' ' ))) end = extensions + strlen( extensions );
1250             memcpy( p, extensions, end - extensions );
1251             p[end - extensions] = 0;
1252             if (!has_extension( disabled, p ))
1253             {
1254                 TRACE("++ %s\n", p );
1255                 p += end - extensions;
1256                 *p++ = ' ';
1257             }
1258             else TRACE("-- %s (disabled by config)\n", p );
1259             extensions = end;
1260         }
1261         *p = 0;
1262     }
1263     HeapFree( GetProcessHeap(), 0, disabled );
1264     return str;
1265 }
1266
1267 /***********************************************************************
1268  *              glGetString (OPENGL32.@)
1269  */
1270 const GLubyte * WINAPI wine_glGetString( GLenum name )
1271 {
1272   static const GLubyte *gl_extensions;
1273
1274   /* this is for buggy nvidia driver, crashing if called from a different
1275      thread with no context */
1276   if(wglGetCurrentContext() == NULL)
1277     return NULL;
1278
1279   if (name != GL_EXTENSIONS) return glGetString(name);
1280
1281   if (!gl_extensions)
1282   {
1283       const char *orig_ext = (const char *)glGetString(GL_EXTENSIONS);
1284       char *new_ext = build_gl_extensions( orig_ext );
1285       if (InterlockedCompareExchangePointer( (void **)&gl_extensions, new_ext, NULL ))
1286           HeapFree( GetProcessHeap(), 0, new_ext );
1287   }
1288   return gl_extensions;
1289 }
1290
1291 /***********************************************************************
1292  *              glGetIntegerv (OPENGL32.@)
1293  */
1294 void WINAPI wine_glGetIntegerv( GLenum pname, GLint* params )
1295 {
1296     wine_wgl.p_wglGetIntegerv(pname, params);
1297 }
1298
1299 /***********************************************************************
1300  *              wglSwapBuffers (OPENGL32.@)
1301  */
1302 BOOL WINAPI DECLSPEC_HOTPATCH wglSwapBuffers( HDC hdc )
1303 {
1304     return GdiSwapBuffers(hdc);
1305 }
1306
1307 /* This is for brain-dead applications that use OpenGL functions before even
1308    creating a rendering context.... */
1309 static BOOL process_attach(void)
1310 {
1311   HDC hdc = GetDC( 0 );
1312   const struct wgl_funcs *funcs = get_dc_funcs( hdc );
1313
1314   ReleaseDC( 0, hdc );
1315
1316   /* internal WGL functions */
1317   wine_wgl.p_wglFinish = (void *)funcs->p_wglGetProcAddress("wglFinish");
1318   wine_wgl.p_wglFlush = (void *)funcs->p_wglGetProcAddress("wglFlush");
1319   wine_wgl.p_wglGetIntegerv = (void *)funcs->p_wglGetProcAddress("wglGetIntegerv");
1320   return TRUE;
1321 }
1322
1323
1324 /**********************************************************************/
1325
1326 static void process_detach(void)
1327 {
1328   if (libglu_handle) wine_dlclose(libglu_handle, NULL, 0);
1329 }
1330
1331 /***********************************************************************
1332  *           OpenGL initialisation routine
1333  */
1334 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
1335 {
1336     switch(reason)
1337     {
1338     case DLL_PROCESS_ATTACH:
1339         opengl32_handle = hinst;
1340         DisableThreadLibraryCalls(hinst);
1341         return process_attach();
1342     case DLL_PROCESS_DETACH:
1343         process_detach();
1344         break;
1345     }
1346     return TRUE;
1347 }