git.oblomov.eu Git - wine/blob - dlls/opengl32/tests/opengl.c

   1 /*
   2  * Some tests for OpenGL functions
   3  *
   4  * Copyright (C) 2007-2008 Roderick Colenbrander
   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 <windows.h>
  22 #include <wingdi.h>
  23 #include "wine/test.h"
  24
  25 void WINAPI glClearColor(float red, float green, float blue, float alpha);
  26 void WINAPI glClear(unsigned int mask);
  27 #define GL_COLOR 0x1800
  28 typedef unsigned int GLenum;
  29 typedef int GLint;
  30 void WINAPI glCopyPixels(int x, int y, int width, int height, GLenum type);
  31 void WINAPI glFinish(void);
  32 #define GL_NO_ERROR 0x0
  33 #define GL_INVALID_OPERATION 0x502
  34 GLenum WINAPI glGetError(void);
  35 #define GL_COLOR_BUFFER_BIT 0x00004000
  36 const unsigned char * WINAPI glGetString(unsigned int);
  37 #define GL_VENDOR 0x1F00
  38 #define GL_RENDERER 0x1F01
  39 #define GL_VERSION 0x1F02
  40 #define GL_EXTENSIONS 0x1F03
  41
  42 #define GL_VIEWPORT 0x0ba2
  43 void WINAPI glGetIntegerv(GLenum pname, GLint *params);
  44
  45 #define MAX_FORMATS 256
  46 typedef void* HPBUFFERARB;
  47
  48 /* WGL_ARB_create_context */
  49 static HGLRC (WINAPI *pwglCreateContextAttribsARB)(HDC hDC, HGLRC hShareContext, const int *attribList);
  50 /* GetLastError */
  51 #define ERROR_INVALID_VERSION_ARB 0x2095
  52 #define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091
  53 #define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092
  54 #define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093
  55 #define WGL_CONTEXT_FLAGS_ARB 0x2094
  56 /* Flags for WGL_CONTEXT_FLAGS_ARB */
  57 #define WGL_CONTEXT_DEBUG_BIT_ARB 0x0001
  58 #define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB  0x0002
  59
  60 /* WGL_ARB_extensions_string */
  61 static const char* (WINAPI *pwglGetExtensionsStringARB)(HDC);
  62 static int (WINAPI *pwglReleasePbufferDCARB)(HPBUFFERARB, HDC);
  63
  64 /* WGL_ARB_make_current_read */
  65 static BOOL (WINAPI *pwglMakeContextCurrentARB)(HDC hdraw, HDC hread, HGLRC hglrc);
  66 static HDC (WINAPI *pwglGetCurrentReadDCARB)(void);
  67
  68 /* WGL_ARB_pixel_format */
  69 #define WGL_ACCELERATION_ARB 0x2003
  70 #define WGL_COLOR_BITS_ARB 0x2014
  71 #define WGL_RED_BITS_ARB   0x2015
  72 #define WGL_GREEN_BITS_ARB 0x2017
  73 #define WGL_BLUE_BITS_ARB  0x2019
  74 #define WGL_ALPHA_BITS_ARB 0x201B
  75 #define WGL_SUPPORT_GDI_ARB   0x200F
  76 #define WGL_DOUBLE_BUFFER_ARB 0x2011
  77 #define WGL_NO_ACCELERATION_ARB        0x2025
  78 #define WGL_GENERIC_ACCELERATION_ARB   0x2026
  79 #define WGL_FULL_ACCELERATION_ARB      0x2027
  80
  81 static BOOL (WINAPI *pwglChoosePixelFormatARB)(HDC, const int *, const FLOAT *, UINT, int *, UINT *);
  82 static BOOL (WINAPI *pwglGetPixelFormatAttribivARB)(HDC, int, int, UINT, const int *, int *);
  83
  84 /* WGL_ARB_pbuffer */
  85 #define WGL_DRAW_TO_PBUFFER_ARB 0x202D
  86 static HPBUFFERARB* (WINAPI *pwglCreatePbufferARB)(HDC, int, int, int, const int *);
  87 static HDC (WINAPI *pwglGetPbufferDCARB)(HPBUFFERARB);
  88
  89 static const char* wgl_extensions = NULL;
  90
  91 static void init_functions(void)
  92 {
  93 #define GET_PROC(func) \
  94     p ## func = (void*)wglGetProcAddress(#func); \
  95     if(!p ## func) \
  96       trace("wglGetProcAddress(%s) failed\n", #func);
  97
  98     /* WGL_ARB_create_context */
  99     GET_PROC(wglCreateContextAttribsARB);
 100
 101     /* WGL_ARB_extensions_string */
 102     GET_PROC(wglGetExtensionsStringARB)
 103
 104     /* WGL_ARB_make_current_read */
 105     GET_PROC(wglMakeContextCurrentARB);
 106     GET_PROC(wglGetCurrentReadDCARB);
 107
 108     /* WGL_ARB_pixel_format */
 109     GET_PROC(wglChoosePixelFormatARB)
 110     GET_PROC(wglGetPixelFormatAttribivARB)
 111
 112     /* WGL_ARB_pbuffer */
 113     GET_PROC(wglCreatePbufferARB)
 114     GET_PROC(wglGetPbufferDCARB)
 115     GET_PROC(wglReleasePbufferDCARB)
 116
 117 #undef GET_PROC
 118 }
 119
 120 static BOOL gl_extension_supported(const char *extensions, const char *extension_string)
 121 {
 122     size_t ext_str_len = strlen(extension_string);
 123
 124     while (*extensions)
 125     {
 126         const char *start;
 127         size_t len;
 128
 129         while (isspace(*extensions))
 130             ++extensions;
 131         start = extensions;
 132         while (!isspace(*extensions) && *extensions)
 133             ++extensions;
 134
 135         len = extensions - start;
 136         if (!len)
 137             continue;
 138
 139         if (len == ext_str_len && !memcmp(start, extension_string, ext_str_len))
 140         {
 141             return TRUE;
 142         }
 143     }
 144     return FALSE;
 145 }
 146
 147 static void test_pbuffers(HDC hdc)
 148 {
 149     const int iAttribList[] = { WGL_DRAW_TO_PBUFFER_ARB, 1, /* Request pbuffer support */
 150                                 0 };
 151     int iFormats[MAX_FORMATS];
 152     unsigned int nOnscreenFormats;
 153     unsigned int nFormats;
 154     int i, res;
 155     int iPixelFormat = 0;
 156
 157     nOnscreenFormats = DescribePixelFormat(hdc, 0, 0, NULL);
 158
 159     /* When you want to render to a pbuffer you need to call wglGetPbufferDCARB which
 160      * returns a 'magic' HDC which you can then pass to wglMakeCurrent to switch rendering
 161      * to the pbuffer. Below some tests are performed on what happens if you use standard WGL calls
 162      * on this 'magic' HDC for both a pixelformat that support onscreen and offscreen rendering
 163      * and a pixelformat that's only available for offscreen rendering (this means that only
 164      * wglChoosePixelFormatARB and friends know about the format.
 165      *
 166      * The first thing we need are pixelformats with pbuffer capabilities.
 167      */
 168     res = pwglChoosePixelFormatARB(hdc, iAttribList, NULL, MAX_FORMATS, iFormats, &nFormats);
 169     if(res <= 0)
 170     {
 171         skip("No pbuffer compatible formats found while WGL_ARB_pbuffer is supported\n");
 172         return;
 173     }
 174     trace("nOnscreenFormats: %d\n", nOnscreenFormats);
 175     trace("Total number of pbuffer capable pixelformats: %d\n", nFormats);
 176
 177     /* Try to select an onscreen pixelformat out of the list */
 178     for(i=0; i < nFormats; i++)
 179     {
 180         /* Check if the format is onscreen, if it is choose it */
 181         if(iFormats[i] <= nOnscreenFormats)
 182         {
 183             iPixelFormat = iFormats[i];
 184             trace("Selected iPixelFormat=%d\n", iPixelFormat);
 185             break;
 186         }
 187     }
 188
 189     /* A video driver supports a large number of onscreen and offscreen pixelformats.
 190      * The traditional WGL calls only see a subset of the whole pixelformat list. First
 191      * of all they only see the onscreen formats (the offscreen formats are at the end of the
 192      * pixelformat list) and second extended pixelformat capabilities are hidden from the
 193      * standard WGL calls. Only functions that depend on WGL_ARB_pixel_format can see them.
 194      *
 195      * Below we check if the pixelformat is also supported onscreen.
 196      */
 197     if(iPixelFormat != 0)
 198     {
 199         HDC pbuffer_hdc;
 200         HPBUFFERARB pbuffer = pwglCreatePbufferARB(hdc, iPixelFormat, 640 /* width */, 480 /* height */, NULL);
 201         if(!pbuffer)
 202             skip("Pbuffer creation failed!\n");
 203
 204         /* Test the pixelformat returned by GetPixelFormat on a pbuffer as the behavior is not clear */
 205         pbuffer_hdc = pwglGetPbufferDCARB(pbuffer);
 206         res = GetPixelFormat(pbuffer_hdc);
 207         ok(res == iPixelFormat, "Unexpected iPixelFormat=%d returned by GetPixelFormat for format %d\n", res, iPixelFormat);
 208         trace("iPixelFormat returned by GetPixelFormat: %d\n", res);
 209         trace("PixelFormat from wglChoosePixelFormatARB: %d\n", iPixelFormat);
 210
 211         pwglReleasePbufferDCARB(pbuffer, hdc);
 212     }
 213     else skip("Pbuffer test for onscreen pixelformat skipped as no onscreen format with pbuffer capabilities have been found\n");
 214
 215     /* Search for a real offscreen format */
 216     for(i=0, iPixelFormat=0; i<nFormats; i++)
 217     {
 218         if(iFormats[i] > nOnscreenFormats)
 219         {
 220             iPixelFormat = iFormats[i];
 221             trace("Selected iPixelFormat: %d\n", iPixelFormat);
 222             break;
 223         }
 224     }
 225
 226     if(iPixelFormat != 0)
 227     {
 228         HDC pbuffer_hdc;
 229         HPBUFFERARB pbuffer = pwglCreatePbufferARB(hdc, iPixelFormat, 640 /* width */, 480 /* height */, NULL);
 230         if(!pbuffer)
 231             skip("Pbuffer creation failed!\n");
 232
 233         /* Test the pixelformat returned by GetPixelFormat on a pbuffer as the behavior is not clear */
 234         pbuffer_hdc = pwglGetPbufferDCARB(pbuffer);
 235         res = GetPixelFormat(pbuffer_hdc);
 236
 237         ok(res == 1, "Unexpected iPixelFormat=%d (1 expected) returned by GetPixelFormat for offscreen format %d\n", res, iPixelFormat);
 238         trace("iPixelFormat returned by GetPixelFormat: %d\n", res);
 239         trace("PixelFormat from wglChoosePixelFormatARB: %d\n", iPixelFormat);
 240         pwglReleasePbufferDCARB(pbuffer, hdc);
 241     }
 242     else skip("Pbuffer test for offscreen pixelformat skipped as no offscreen-only format with pbuffer capabilities has been found\n");
 243 }
 244
 245 static void test_setpixelformat(HDC winhdc)
 246 {
 247     int res = 0;
 248     int nCfgs;
 249     int pf;
 250     int i;
 251     HWND hwnd;
 252     PIXELFORMATDESCRIPTOR pfd = {
 253         sizeof(PIXELFORMATDESCRIPTOR),
 254         1,                     /* version */
 255         PFD_DRAW_TO_WINDOW |
 256         PFD_SUPPORT_OPENGL |
 257         PFD_DOUBLEBUFFER,
 258         PFD_TYPE_RGBA,
 259         24,                    /* 24-bit color depth */
 260         0, 0, 0, 0, 0, 0,      /* color bits */
 261         0,                     /* alpha buffer */
 262         0,                     /* shift bit */
 263         0,                     /* accumulation buffer */
 264         0, 0, 0, 0,            /* accum bits */
 265         32,                    /* z-buffer */
 266         0,                     /* stencil buffer */
 267         0,                     /* auxiliary buffer */
 268         PFD_MAIN_PLANE,        /* main layer */
 269         0,                     /* reserved */
 270         0, 0, 0                /* layer masks */
 271     };
 272
 273     HDC hdc = GetDC(0);
 274     ok(hdc != 0, "GetDC(0) failed!\n");
 275
 276     /* This should pass even on the main device context */
 277     pf = ChoosePixelFormat(hdc, &pfd);
 278     ok(pf != 0, "ChoosePixelFormat failed on main device context\n");
 279
 280     /* SetPixelFormat on the main device context 'X root window' should fail,
 281      * but some broken drivers allow it
 282      */
 283     res = SetPixelFormat(hdc, pf, &pfd);
 284     trace("SetPixelFormat on main device context %s\n", res ? "succeeded" : "failed");
 285
 286     /* Setting the same format that was set on the HDC is allowed; other
 287        formats fail */
 288     nCfgs = DescribePixelFormat(winhdc, 0, 0, NULL);
 289     pf = GetPixelFormat(winhdc);
 290     for(i = 1;i <= nCfgs;i++)
 291     {
 292         int res = SetPixelFormat(winhdc, i, NULL);
 293         if(i == pf) ok(res, "Failed to set the same pixel format\n");
 294         else ok(!res, "Unexpectedly set an alternate pixel format\n");
 295     }
 296
 297     hwnd = CreateWindow("static", "Title", WS_OVERLAPPEDWINDOW,
 298                         10, 10, 200, 200, NULL, NULL, NULL, NULL);
 299     ok(hwnd != NULL, "err: %d\n", GetLastError());
 300     if (hwnd)
 301     {
 302         HDC hdc = GetDC( hwnd );
 303         pf = ChoosePixelFormat( hdc, &pfd );
 304         ok( pf != 0, "ChoosePixelFormat failed\n" );
 305         res = SetPixelFormat( hdc, pf, &pfd );
 306         ok( res != 0, "SetPixelFormat failed\n" );
 307         i = GetPixelFormat( hdc );
 308         ok( i == pf, "GetPixelFormat returned wrong format %d/%d\n", i, pf );
 309         ReleaseDC( hwnd, hdc );
 310         hdc = GetWindowDC( hwnd );
 311         i = GetPixelFormat( hdc );
 312         ok( i == pf, "GetPixelFormat returned wrong format %d/%d\n", i, pf );
 313         ReleaseDC( hwnd, hdc );
 314         DestroyWindow( hwnd );
 315     }
 316
 317     hwnd = CreateWindow("static", "Title", WS_OVERLAPPEDWINDOW,
 318                         10, 10, 200, 200, NULL, NULL, NULL, NULL);
 319     ok(hwnd != NULL, "err: %d\n", GetLastError());
 320     if (hwnd)
 321     {
 322         HDC hdc = GetWindowDC( hwnd );
 323         pf = ChoosePixelFormat( hdc, &pfd );
 324         ok( pf != 0, "ChoosePixelFormat failed\n" );
 325         res = SetPixelFormat( hdc, pf, &pfd );
 326         ok( res != 0, "SetPixelFormat failed\n" );
 327         i = GetPixelFormat( hdc );
 328         ok( i == pf, "GetPixelFormat returned wrong format %d/%d\n", i, pf );
 329         ReleaseDC( hwnd, hdc );
 330         DestroyWindow( hwnd );
 331     }
 332 }
 333
 334 static void test_sharelists(HDC winhdc)
 335 {
 336     HGLRC hglrc1, hglrc2, hglrc3;
 337     int res;
 338
 339     hglrc1 = wglCreateContext(winhdc);
 340     res = wglShareLists(0, 0);
 341     ok(res == FALSE, "Sharing display lists for no contexts passed!\n");
 342
 343     /* Test 1: Create a context and just share lists without doing anything special */
 344     hglrc2 = wglCreateContext(winhdc);
 345     if(hglrc2)
 346     {
 347         res = wglShareLists(hglrc1, hglrc2);
 348         ok(res, "Sharing of display lists failed\n");
 349         wglDeleteContext(hglrc2);
 350     }
 351
 352     /* Test 2: Share display lists with a 'destination' context which has been made current */
 353     hglrc2 = wglCreateContext(winhdc);
 354     if(hglrc2)
 355     {
 356         res = wglMakeCurrent(winhdc, hglrc2);
 357         ok(res, "Make current failed\n");
 358         res = wglShareLists(hglrc1, hglrc2);
 359         todo_wine ok(res, "Sharing display lists with a destination context which has been made current failed\n");
 360         wglMakeCurrent(0, 0);
 361         wglDeleteContext(hglrc2);
 362     }
 363
 364     /* Test 3: Share display lists with a context which already shares display lists with another context.
 365      * According to MSDN the second parameter cannot share any display lists but some buggy drivers might allow it */
 366     hglrc3 = wglCreateContext(winhdc);
 367     if(hglrc3)
 368     {
 369         res = wglShareLists(hglrc3, hglrc1);
 370         ok(res == FALSE, "Sharing of display lists passed for a context which already shared lists before\n");
 371         wglDeleteContext(hglrc3);
 372     }
 373
 374     /* Test 4: Share display lists with a 'source' context which has been made current */
 375     hglrc2 = wglCreateContext(winhdc);
 376     if(hglrc2)
 377     {
 378         res = wglMakeCurrent(winhdc, hglrc1);
 379         ok(res, "Make current failed\n");
 380         res = wglShareLists(hglrc1, hglrc2);
 381         ok(res, "Sharing display lists with a source context which has been made current failed\n");
 382         wglMakeCurrent(0, 0);
 383         wglDeleteContext(hglrc2);
 384     }
 385 }
 386
 387 static void test_makecurrent(HDC winhdc)
 388 {
 389     BOOL ret;
 390     HGLRC hglrc;
 391
 392     hglrc = wglCreateContext(winhdc);
 393     ok( hglrc != 0, "wglCreateContext failed\n" );
 394
 395     ret = wglMakeCurrent( winhdc, hglrc );
 396     ok( ret, "wglMakeCurrent failed\n" );
 397
 398     ok( wglGetCurrentContext() == hglrc, "wrong context\n" );
 399
 400     /* set the same context again */
 401     ret = wglMakeCurrent( winhdc, hglrc );
 402     ok( ret, "wglMakeCurrent failed\n" );
 403
 404     /* check wglMakeCurrent(x, y) after another call to wglMakeCurrent(x, y) */
 405     ret = wglMakeCurrent( winhdc, NULL );
 406     ok( ret, "wglMakeCurrent failed\n" );
 407
 408     ret = wglMakeCurrent( winhdc, NULL );
 409     ok( ret, "wglMakeCurrent failed\n" );
 410
 411     SetLastError( 0xdeadbeef );
 412     ret = wglMakeCurrent( NULL, NULL );
 413     ok( !ret || broken(ret) /* nt4 */, "wglMakeCurrent succeeded\n" );
 414     if (!ret) ok( GetLastError() == ERROR_INVALID_HANDLE,
 415                   "Expected ERROR_INVALID_HANDLE, got error=%x\n", GetLastError() );
 416
 417     ret = wglMakeCurrent( winhdc, NULL );
 418     ok( ret, "wglMakeCurrent failed\n" );
 419
 420     ret = wglMakeCurrent( winhdc, hglrc );
 421     ok( ret, "wglMakeCurrent failed\n" );
 422
 423     ret = wglMakeCurrent( NULL, NULL );
 424     ok( ret, "wglMakeCurrent failed\n" );
 425
 426     ok( wglGetCurrentContext() == NULL, "wrong context\n" );
 427
 428     SetLastError( 0xdeadbeef );
 429     ret = wglMakeCurrent( NULL, NULL );
 430     ok( !ret || broken(ret) /* nt4 */, "wglMakeCurrent succeeded\n" );
 431     if (!ret) ok( GetLastError() == ERROR_INVALID_HANDLE,
 432                   "Expected ERROR_INVALID_HANDLE, got error=%x\n", GetLastError() );
 433
 434     ret = wglMakeCurrent( winhdc, hglrc );
 435     ok( ret, "wglMakeCurrent failed\n" );
 436 }
 437
 438 static void test_colorbits(HDC hdc)
 439 {
 440     const int iAttribList[] = { WGL_COLOR_BITS_ARB, WGL_RED_BITS_ARB, WGL_GREEN_BITS_ARB,
 441                                 WGL_BLUE_BITS_ARB, WGL_ALPHA_BITS_ARB };
 442     int iAttribRet[sizeof(iAttribList)/sizeof(iAttribList[0])];
 443     const int iAttribs[] = { WGL_ALPHA_BITS_ARB, 1, 0 };
 444     unsigned int nFormats;
 445     int res;
 446     int iPixelFormat = 0;
 447
 448     if (!pwglChoosePixelFormatARB)
 449     {
 450         win_skip("wglChoosePixelFormatARB is not available\n");
 451         return;
 452     }
 453
 454     /* We need a pixel format with at least one bit of alpha */
 455     res = pwglChoosePixelFormatARB(hdc, iAttribs, NULL, 1, &iPixelFormat, &nFormats);
 456     if(res == FALSE || nFormats == 0)
 457     {
 458         skip("No suitable pixel formats found\n");
 459         return;
 460     }
 461
 462     res = pwglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0,
 463               sizeof(iAttribList)/sizeof(iAttribList[0]), iAttribList, iAttribRet);
 464     if(res == FALSE)
 465     {
 466         skip("wglGetPixelFormatAttribivARB failed\n");
 467         return;
 468     }
 469     iAttribRet[1] += iAttribRet[2]+iAttribRet[3]+iAttribRet[4];
 470     ok(iAttribRet[0] == iAttribRet[1], "WGL_COLOR_BITS_ARB (%d) does not equal R+G+B+A (%d)!\n",
 471                                        iAttribRet[0], iAttribRet[1]);
 472 }
 473
 474 static void test_gdi_dbuf(HDC hdc)
 475 {
 476     const int iAttribList[] = { WGL_SUPPORT_GDI_ARB, WGL_DOUBLE_BUFFER_ARB };
 477     int iAttribRet[sizeof(iAttribList)/sizeof(iAttribList[0])];
 478     unsigned int nFormats;
 479     int iPixelFormat;
 480     int res;
 481
 482     if (!pwglGetPixelFormatAttribivARB)
 483     {
 484         win_skip("wglGetPixelFormatAttribivARB is not available\n");
 485         return;
 486     }
 487
 488     nFormats = DescribePixelFormat(hdc, 0, 0, NULL);
 489     for(iPixelFormat = 1;iPixelFormat <= nFormats;iPixelFormat++)
 490     {
 491         res = pwglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0,
 492                   sizeof(iAttribList)/sizeof(iAttribList[0]), iAttribList,
 493                   iAttribRet);
 494         ok(res!=FALSE, "wglGetPixelFormatAttribivARB failed for pixel format %d\n", iPixelFormat);
 495         if(res == FALSE)
 496             continue;
 497
 498         ok(!(iAttribRet[0] && iAttribRet[1]), "GDI support and double buffering on pixel format %d\n", iPixelFormat);
 499     }
 500 }
 501
 502 static void test_acceleration(HDC hdc)
 503 {
 504     const int iAttribList[] = { WGL_ACCELERATION_ARB };
 505     int iAttribRet[sizeof(iAttribList)/sizeof(iAttribList[0])];
 506     unsigned int nFormats;
 507     int iPixelFormat;
 508     int res;
 509     PIXELFORMATDESCRIPTOR pfd;
 510
 511     if (!pwglGetPixelFormatAttribivARB)
 512     {
 513         win_skip("wglGetPixelFormatAttribivARB is not available\n");
 514         return;
 515     }
 516
 517     nFormats = DescribePixelFormat(hdc, 0, 0, NULL);
 518     for(iPixelFormat = 1; iPixelFormat <= nFormats; iPixelFormat++)
 519     {
 520         res = pwglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0,
 521                   sizeof(iAttribList)/sizeof(iAttribList[0]), iAttribList,
 522                   iAttribRet);
 523         ok(res!=FALSE, "wglGetPixelFormatAttribivARB failed for pixel format %d\n", iPixelFormat);
 524         if(res == FALSE)
 525             continue;
 526
 527         memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
 528         DescribePixelFormat(hdc, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
 529
 530         switch(iAttribRet[0])
 531         {
 532             case WGL_NO_ACCELERATION_ARB:
 533                 ok( (pfd.dwFlags & (PFD_GENERIC_FORMAT | PFD_GENERIC_ACCELERATED)) == PFD_GENERIC_FORMAT , "Expected only PFD_GENERIC_FORMAT to be set for WGL_NO_ACCELERATION_ARB!: iPixelFormat=%d, dwFlags=%x!\n", iPixelFormat, pfd.dwFlags);
 534                 break;
 535             case WGL_GENERIC_ACCELERATION_ARB:
 536                 ok( (pfd.dwFlags & (PFD_GENERIC_FORMAT | PFD_GENERIC_ACCELERATED)) == (PFD_GENERIC_FORMAT | PFD_GENERIC_ACCELERATED), "Expected both PFD_GENERIC_FORMAT and PFD_GENERIC_ACCELERATION to be set for WGL_GENERIC_ACCELERATION_ARB: iPixelFormat=%d, dwFlags=%x!\n", iPixelFormat, pfd.dwFlags);
 537                 break;
 538             case WGL_FULL_ACCELERATION_ARB:
 539                 ok( (pfd.dwFlags & (PFD_GENERIC_FORMAT | PFD_GENERIC_ACCELERATED)) == 0, "Expected no PFD_GENERIC_FORMAT/_ACCELERATION to be set for WGL_FULL_ACCELERATION_ARB: iPixelFormat=%d, dwFlags=%x!\n", iPixelFormat, pfd.dwFlags);
 540                 break;
 541         }
 542     }
 543 }
 544
 545 static void test_bitmap_rendering( BOOL use_dib )
 546 {
 547     PIXELFORMATDESCRIPTOR pfd;
 548     int i, ret, bpp, iPixelFormat=0;
 549     unsigned int nFormats;
 550     HGLRC hglrc, hglrc2;
 551     BITMAPINFO biDst;
 552     HBITMAP bmpDst, oldDst, bmp2;
 553     HDC hdcDst, hdcScreen;
 554     UINT *dstBuffer = NULL;
 555
 556     hdcScreen = CreateCompatibleDC(0);
 557     hdcDst = CreateCompatibleDC(0);
 558
 559     if (use_dib)
 560     {
 561         bpp = 32;
 562         memset(&biDst, 0, sizeof(BITMAPINFO));
 563         biDst.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 564         biDst.bmiHeader.biWidth = 4;
 565         biDst.bmiHeader.biHeight = -4;
 566         biDst.bmiHeader.biPlanes = 1;
 567         biDst.bmiHeader.biBitCount = 32;
 568         biDst.bmiHeader.biCompression = BI_RGB;
 569
 570         bmpDst = CreateDIBSection(0, &biDst, DIB_RGB_COLORS, (void**)&dstBuffer, NULL, 0);
 571
 572         biDst.bmiHeader.biWidth = 12;
 573         biDst.bmiHeader.biHeight = -12;
 574         biDst.bmiHeader.biBitCount = 16;
 575         bmp2 = CreateDIBSection(0, &biDst, DIB_RGB_COLORS, NULL, NULL, 0);
 576     }
 577     else
 578     {
 579         bpp = GetDeviceCaps( hdcScreen, BITSPIXEL );
 580         bmpDst = CreateBitmap( 4, 4, 1, bpp, NULL );
 581         bmp2 = CreateBitmap( 12, 12, 1, bpp, NULL );
 582     }
 583
 584     oldDst = SelectObject(hdcDst, bmpDst);
 585
 586     trace( "testing on %s\n", use_dib ? "DIB" : "DDB" );
 587
 588     /* Pick a pixel format by hand because ChoosePixelFormat is unreliable */
 589     nFormats = DescribePixelFormat(hdcDst, 0, 0, NULL);
 590     for(i=1; i<=nFormats; i++)
 591     {
 592         memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
 593         DescribePixelFormat(hdcDst, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
 594
 595         if((pfd.dwFlags & PFD_DRAW_TO_BITMAP) &&
 596            (pfd.dwFlags & PFD_SUPPORT_OPENGL) &&
 597            (pfd.cColorBits == bpp) &&
 598            (pfd.cAlphaBits == 8) )
 599         {
 600             iPixelFormat = i;
 601             break;
 602         }
 603     }
 604
 605     if(!iPixelFormat)
 606     {
 607         skip("Unable to find a suitable pixel format\n");
 608     }
 609     else
 610     {
 611         ret = SetPixelFormat(hdcDst, iPixelFormat, &pfd);
 612         ok( ret, "SetPixelFormat failed\n" );
 613         ret = GetPixelFormat( hdcDst );
 614         ok( ret == iPixelFormat, "GetPixelFormat returned %d/%d\n", ret, iPixelFormat );
 615         ret = SetPixelFormat(hdcDst, iPixelFormat + 1, &pfd);
 616         ok( !ret, "SetPixelFormat succeeded\n" );
 617         hglrc = wglCreateContext(hdcDst);
 618         ok(hglrc != NULL, "Unable to create a context\n");
 619
 620         if(hglrc)
 621         {
 622             GLint viewport[4];
 623             wglMakeCurrent(hdcDst, hglrc);
 624             hglrc2 = wglCreateContext(hdcDst);
 625             ok(hglrc2 != NULL, "Unable to create a context\n");
 626
 627             /* Note this is RGBA but we read ARGB back */
 628             glClearColor((float)0x22/0xff, (float)0x33/0xff, (float)0x44/0xff, (float)0x11/0xff);
 629             glClear(GL_COLOR_BUFFER_BIT);
 630             glGetIntegerv( GL_VIEWPORT, viewport );
 631             glFinish();
 632
 633             ok( viewport[0] == 0 && viewport[1] == 0 && viewport[2] == 4 && viewport[3] == 4,
 634                 "wrong viewport %d,%d,%d,%d\n", viewport[0], viewport[1], viewport[2], viewport[3] );
 635             /* Note apparently the alpha channel is not supported by the software renderer (bitmap only works using software) */
 636             if (dstBuffer)
 637                 for (i = 0; i < 16; i++)
 638                     ok(dstBuffer[i] == 0x223344 || dstBuffer[i] == 0x11223344, "Received color=%x at %u\n",
 639                        dstBuffer[i], i);
 640
 641             SelectObject(hdcDst, bmp2);
 642             ret = GetPixelFormat( hdcDst );
 643             ok( ret == iPixelFormat, "GetPixelFormat returned %d/%d\n", ret, iPixelFormat );
 644             ret = SetPixelFormat(hdcDst, iPixelFormat + 1, &pfd);
 645             ok( !ret, "SetPixelFormat succeeded\n" );
 646
 647             /* context still uses the old pixel format and viewport */
 648             glClearColor((float)0x44/0xff, (float)0x33/0xff, (float)0x22/0xff, (float)0x11/0xff);
 649             glClear(GL_COLOR_BUFFER_BIT);
 650             glFinish();
 651             glGetIntegerv( GL_VIEWPORT, viewport );
 652             ok( viewport[0] == 0 && viewport[1] == 0 && viewport[2] == 4 && viewport[3] == 4,
 653                 "wrong viewport %d,%d,%d,%d\n", viewport[0], viewport[1], viewport[2], viewport[3] );
 654
 655             wglMakeCurrent(NULL, NULL);
 656             wglMakeCurrent(hdcDst, hglrc);
 657             glClearColor((float)0x44/0xff, (float)0x55/0xff, (float)0x66/0xff, (float)0x11/0xff);
 658             glClear(GL_COLOR_BUFFER_BIT);
 659             glFinish();
 660             glGetIntegerv( GL_VIEWPORT, viewport );
 661             ok( viewport[0] == 0 && viewport[1] == 0 && viewport[2] == 4 && viewport[3] == 4,
 662                 "wrong viewport %d,%d,%d,%d\n", viewport[0], viewport[1], viewport[2], viewport[3] );
 663
 664             wglMakeCurrent(hdcDst, hglrc2);
 665             glGetIntegerv( GL_VIEWPORT, viewport );
 666             ok( viewport[0] == 0 && viewport[1] == 0 && viewport[2] == 12 && viewport[3] == 12,
 667                 "wrong viewport %d,%d,%d,%d\n", viewport[0], viewport[1], viewport[2], viewport[3] );
 668
 669             wglMakeCurrent(hdcDst, hglrc);
 670             glGetIntegerv( GL_VIEWPORT, viewport );
 671             ok( viewport[0] == 0 && viewport[1] == 0 && viewport[2] == 4 && viewport[3] == 4,
 672                 "wrong viewport %d,%d,%d,%d\n", viewport[0], viewport[1], viewport[2], viewport[3] );
 673
 674             SelectObject(hdcDst, bmpDst);
 675             ret = GetPixelFormat( hdcDst );
 676             ok( ret == iPixelFormat, "GetPixelFormat returned %d/%d\n", ret, iPixelFormat );
 677             ret = SetPixelFormat(hdcDst, iPixelFormat + 1, &pfd);
 678             ok( !ret, "SetPixelFormat succeeded\n" );
 679             wglMakeCurrent(hdcDst, hglrc2);
 680             glGetIntegerv( GL_VIEWPORT, viewport );
 681             ok( viewport[0] == 0 && viewport[1] == 0 && viewport[2] == 12 && viewport[3] == 12,
 682                 "wrong viewport %d,%d,%d,%d\n", viewport[0], viewport[1], viewport[2], viewport[3] );
 683         }
 684     }
 685
 686     SelectObject(hdcDst, oldDst);
 687     DeleteObject(bmp2);
 688     DeleteObject(bmpDst);
 689     DeleteDC(hdcDst);
 690     DeleteDC(hdcScreen);
 691 }
 692
 693 struct wgl_thread_param
 694 {
 695     HANDLE test_finished;
 696     HWND hwnd;
 697     HGLRC hglrc;
 698     BOOL make_current;
 699     BOOL make_current_error;
 700     BOOL deleted;
 701     DWORD deleted_error;
 702 };
 703
 704 static DWORD WINAPI wgl_thread(void *param)
 705 {
 706     struct wgl_thread_param *p = param;
 707     HDC hdc = GetDC( p->hwnd );
 708
 709     SetLastError(0xdeadbeef);
 710     p->make_current = wglMakeCurrent(hdc, p->hglrc);
 711     p->make_current_error = GetLastError();
 712     p->deleted = wglDeleteContext(p->hglrc);
 713     p->deleted_error = GetLastError();
 714     ReleaseDC( p->hwnd, hdc );
 715     SetEvent(p->test_finished);
 716     return 0;
 717 }
 718
 719 static void test_deletecontext(HWND hwnd, HDC hdc)
 720 {
 721     struct wgl_thread_param thread_params;
 722     HGLRC hglrc = wglCreateContext(hdc);
 723     HANDLE thread_handle;
 724     DWORD res, tid;
 725
 726     SetLastError(0xdeadbeef);
 727     res = wglDeleteContext(NULL);
 728     ok(res == FALSE, "wglDeleteContext succeeded\n");
 729     ok(GetLastError() == ERROR_INVALID_HANDLE, "Expected last error to be ERROR_INVALID_HANDLE, got %u\n", GetLastError());
 730
 731     if(!hglrc)
 732     {
 733         skip("wglCreateContext failed!\n");
 734         return;
 735     }
 736
 737     res = wglMakeCurrent(hdc, hglrc);
 738     if(!res)
 739     {
 740         skip("wglMakeCurrent failed!\n");
 741         return;
 742     }
 743
 744     /* WGL doesn't allow you to delete a context from a different thread than the one in which it is current.
 745      * This differs from GLX which does allow it but it delays actual deletion until the context becomes not current.
 746      */
 747     thread_params.hglrc = hglrc;
 748     thread_params.hwnd  = hwnd;
 749     thread_params.test_finished = CreateEvent(NULL, FALSE, FALSE, NULL);
 750     thread_handle = CreateThread(NULL, 0, wgl_thread, &thread_params, 0, &tid);
 751     ok(!!thread_handle, "Failed to create thread, last error %#x.\n", GetLastError());
 752     if(thread_handle)
 753     {
 754         WaitForSingleObject(thread_handle, INFINITE);
 755         ok(!thread_params.make_current, "Attempt to make WGL context from another thread passed\n");
 756         ok(thread_params.make_current_error == ERROR_BUSY, "Expected last error to be ERROR_BUSY, got %u\n", thread_params.make_current_error);
 757         ok(!thread_params.deleted, "Attempt to delete WGL context from another thread passed\n");
 758         ok(thread_params.deleted_error == ERROR_BUSY, "Expected last error to be ERROR_BUSY, got %u\n", thread_params.deleted_error);
 759     }
 760     CloseHandle(thread_params.test_finished);
 761
 762     res = wglDeleteContext(hglrc);
 763     ok(res == TRUE, "wglDeleteContext failed\n");
 764
 765     /* Attempting to delete the same context twice should fail. */
 766     SetLastError(0xdeadbeef);
 767     res = wglDeleteContext(hglrc);
 768     ok(res == FALSE, "wglDeleteContext succeeded\n");
 769     ok(GetLastError() == ERROR_INVALID_HANDLE, "Expected last error to be ERROR_INVALID_HANDLE, got %u\n", GetLastError());
 770
 771     /* WGL makes a context not current when deleting it. This differs from GLX behavior where
 772      * deletion takes place when the thread becomes not current. */
 773     hglrc = wglGetCurrentContext();
 774     ok(hglrc == NULL, "A WGL context is active while none was expected\n");
 775 }
 776
 777
 778 static void test_getprocaddress(HDC hdc)
 779 {
 780     const char *extensions = (const char*)glGetString(GL_EXTENSIONS);
 781     PROC func = NULL;
 782     HGLRC ctx = wglGetCurrentContext();
 783
 784     if (!extensions)
 785     {
 786         skip("skipping wglGetProcAddress tests because no GL extensions supported\n");
 787         return;
 788     }
 789
 790     /* Core GL 1.0/1.1 functions should not be loadable through wglGetProcAddress.
 791      * Try to load the function with and without a context.
 792      */
 793     func = wglGetProcAddress("glEnable");
 794     ok(func == NULL, "Lookup of function glEnable with a context passed, expected a failure\n");
 795     wglMakeCurrent(hdc, NULL);
 796     func = wglGetProcAddress("glEnable");
 797     ok(func == NULL, "Lookup of function glEnable without a context passed, expected a failure\n");
 798     wglMakeCurrent(hdc, ctx);
 799
 800     /* The goal of the test will be to test behavior of wglGetProcAddress when
 801      * no WGL context is active. Before the test we pick an extension (GL_ARB_multitexture)
 802      * which any GL >=1.2.1 implementation supports. Unfortunately the GDI renderer doesn't
 803      * support it. There aren't any extensions we can use for this test which are supported by
 804      * both GDI and real drivers.
 805      * Note GDI only has GL_EXT_bgra, GL_EXT_paletted_texture and GL_WIN_swap_hint.
 806      */
 807     if (!gl_extension_supported(extensions, "GL_ARB_multitexture"))
 808     {
 809         skip("skipping test because lack of GL_ARB_multitexture support\n");
 810         return;
 811     }
 812
 813     func = wglGetProcAddress("glActiveTextureARB");
 814     ok(func != NULL, "Unable to lookup glActiveTextureARB, last error %#x\n", GetLastError());
 815
 816     /* Temporarily disable the context, so we can see that we can't retrieve functions now. */
 817     wglMakeCurrent(hdc, NULL);
 818     func = wglGetProcAddress("glActiveTextureARB");
 819     ok(func == NULL, "Function lookup without a context passed, expected a failure; last error %#x\n", GetLastError());
 820     wglMakeCurrent(hdc, ctx);
 821 }
 822
 823 static void test_make_current_read(HDC hdc)
 824 {
 825     int res;
 826     HDC hread;
 827     HGLRC hglrc = wglCreateContext(hdc);
 828
 829     if(!hglrc)
 830     {
 831         skip("wglCreateContext failed!\n");
 832         return;
 833     }
 834
 835     res = wglMakeCurrent(hdc, hglrc);
 836     if(!res)
 837     {
 838         skip("wglMakeCurrent failed!\n");
 839         return;
 840     }
 841
 842     /* Test what wglGetCurrentReadDCARB does for wglMakeCurrent as the spec doesn't mention it */
 843     hread = pwglGetCurrentReadDCARB();
 844     trace("hread %p, hdc %p\n", hread, hdc);
 845     ok(hread == hdc, "wglGetCurrentReadDCARB failed for standard wglMakeCurrent\n");
 846
 847     pwglMakeContextCurrentARB(hdc, hdc, hglrc);
 848     hread = pwglGetCurrentReadDCARB();
 849     ok(hread == hdc, "wglGetCurrentReadDCARB failed for wglMakeContextCurrent\n");
 850 }
 851
 852 static void test_dc(HWND hwnd, HDC hdc)
 853 {
 854     int pf1, pf2;
 855     HDC hdc2;
 856
 857     /* Get another DC and make sure it has the same pixel format */
 858     hdc2 = GetDC(hwnd);
 859     if(hdc != hdc2)
 860     {
 861         pf1 = GetPixelFormat(hdc);
 862         pf2 = GetPixelFormat(hdc2);
 863         ok(pf1 == pf2, "Second DC does not have the same format (%d != %d)\n", pf1, pf2);
 864     }
 865     else
 866         skip("Could not get a different DC for the window\n");
 867
 868     if(hdc2)
 869     {
 870         ReleaseDC(hwnd, hdc2);
 871         hdc2 = NULL;
 872     }
 873 }
 874
 875 /* Nvidia converts win32 error codes to (0xc007 << 16) | win32_error_code */
 876 #define NVIDIA_HRESULT_FROM_WIN32(x) (HRESULT_FROM_WIN32(x) | 0x40000000)
 877 static void test_opengl3(HDC hdc)
 878 {
 879     /* Try to create a context compatible with OpenGL 1.x; 1.0-2.1 is allowed */
 880     {
 881         HGLRC gl3Ctx;
 882         int attribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 1, 0};
 883
 884         gl3Ctx = pwglCreateContextAttribsARB(hdc, 0, attribs);
 885         ok(gl3Ctx != 0, "pwglCreateContextAttribsARB for a 1.x context failed!\n");
 886         wglDeleteContext(gl3Ctx);
 887     }
 888
 889     /* Try to pass an invalid HDC */
 890     {
 891         HGLRC gl3Ctx;
 892         DWORD error;
 893         gl3Ctx = pwglCreateContextAttribsARB((HDC)0xdeadbeef, 0, 0);
 894         ok(gl3Ctx == 0, "pwglCreateContextAttribsARB using an invalid HDC passed\n");
 895         error = GetLastError();
 896         todo_wine ok(error == ERROR_DC_NOT_FOUND ||
 897                      broken(error == NVIDIA_HRESULT_FROM_WIN32(ERROR_INVALID_DATA)), /* Nvidia Vista + Win7 */
 898                      "Expected ERROR_DC_NOT_FOUND, got error=%x\n", error);
 899         wglDeleteContext(gl3Ctx);
 900     }
 901
 902     /* Try to pass an invalid shareList */
 903     {
 904         HGLRC gl3Ctx;
 905         DWORD error;
 906         gl3Ctx = pwglCreateContextAttribsARB(hdc, (HGLRC)0xdeadbeef, 0);
 907         ok(gl3Ctx == 0, "pwglCreateContextAttribsARB using an invalid shareList passed\n");
 908         error = GetLastError();
 909         /* The Nvidia implementation seems to return hresults instead of win32 error codes */
 910         todo_wine ok(error == ERROR_INVALID_OPERATION ||
 911                      error == NVIDIA_HRESULT_FROM_WIN32(ERROR_INVALID_OPERATION), "Expected ERROR_INVALID_OPERATION, got error=%x\n", error);
 912         wglDeleteContext(gl3Ctx);
 913     }
 914
 915     /* Try to create an OpenGL 3.0 context */
 916     {
 917         int attribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 0, 0};
 918         HGLRC gl3Ctx = pwglCreateContextAttribsARB(hdc, 0, attribs);
 919
 920         if(gl3Ctx == NULL)
 921         {
 922             skip("Skipping the rest of the WGL_ARB_create_context test due to lack of OpenGL 3.0\n");
 923             return;
 924         }
 925
 926         wglDeleteContext(gl3Ctx);
 927     }
 928
 929     /* Test matching an OpenGL 3.0 context with an older one, OpenGL 3.0 should allow it until the new object model is introduced in a future revision */
 930     {
 931         HGLRC glCtx = wglCreateContext(hdc);
 932
 933         int attribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 0, 0};
 934         int attribs_future[] = {WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 0, 0};
 935
 936         HGLRC gl3Ctx = pwglCreateContextAttribsARB(hdc, glCtx, attribs);
 937         ok(gl3Ctx != NULL, "Sharing of a display list between OpenGL 3.0 and OpenGL 1.x/2.x failed!\n");
 938         if(gl3Ctx)
 939             wglDeleteContext(gl3Ctx);
 940
 941         gl3Ctx = pwglCreateContextAttribsARB(hdc, glCtx, attribs_future);
 942         ok(gl3Ctx != NULL, "Sharing of a display list between a forward compatible OpenGL 3.0 context and OpenGL 1.x/2.x failed!\n");
 943         if(gl3Ctx)
 944             wglDeleteContext(gl3Ctx);
 945
 946         if(glCtx)
 947             wglDeleteContext(glCtx);
 948     }
 949
 950     /* Try to create an OpenGL 3.0 context and test windowless rendering */
 951     {
 952         HGLRC gl3Ctx;
 953         int attribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 0, 0};
 954         BOOL res;
 955
 956         gl3Ctx = pwglCreateContextAttribsARB(hdc, 0, attribs);
 957         ok(gl3Ctx != 0, "pwglCreateContextAttribsARB for a 3.0 context failed!\n");
 958
 959         /* OpenGL 3.0 allows offscreen rendering WITHOUT a drawable
 960          * Neither AMD or Nvidia support it at this point. The WGL_ARB_create_context specs also say that
 961          * it is hard because drivers use the HDC to enter the display driver and it sounds like they don't
 962          * expect drivers to ever offer it.
 963          */
 964         res = wglMakeCurrent(0, gl3Ctx);
 965         ok(res == FALSE, "Wow, OpenGL 3.0 windowless rendering passed while it was expected not to!\n");
 966         if(res)
 967             wglMakeCurrent(0, 0);
 968
 969         if(gl3Ctx)
 970             wglDeleteContext(gl3Ctx);
 971     }
 972 }
 973
 974 static void test_minimized(void)
 975 {
 976     PIXELFORMATDESCRIPTOR pf_desc =
 977     {
 978         sizeof(PIXELFORMATDESCRIPTOR),
 979         1,                     /* version */
 980         PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
 981         PFD_TYPE_RGBA,
 982         24,                    /* 24-bit color depth */
 983         0, 0, 0, 0, 0, 0,      /* color bits */
 984         0,                     /* alpha buffer */
 985         0,                     /* shift bit */
 986         0,                     /* accumulation buffer */
 987         0, 0, 0, 0,            /* accum bits */
 988         32,                    /* z-buffer */
 989         0,                     /* stencil buffer */
 990         0,                     /* auxiliary buffer */
 991         PFD_MAIN_PLANE,        /* main layer */
 992         0,                     /* reserved */
 993         0, 0, 0                /* layer masks */
 994     };
 995     int pixel_format;
 996     HWND window;
 997     LONG style;
 998     HGLRC ctx;
 999     BOOL ret;
1000     HDC dc;
1001
1002     window = CreateWindowA("static", "opengl32_test",
1003             WS_POPUP | WS_MINIMIZE, 0, 0, 640, 480, 0, 0, 0, 0);
1004     ok(!!window, "Failed to create window, last error %#x.\n", GetLastError());
1005
1006     dc = GetDC(window);
1007     ok(!!dc, "Failed to get DC.\n");
1008
1009     pixel_format = ChoosePixelFormat(dc, &pf_desc);
1010     if (!pixel_format)
1011     {
1012         win_skip("Failed to find pixel format.\n");
1013         ReleaseDC(window, dc);
1014         DestroyWindow(window);
1015         return;
1016     }
1017
1018     ret = SetPixelFormat(dc, pixel_format, &pf_desc);
1019     ok(ret, "Failed to set pixel format, last error %#x.\n", GetLastError());
1020
1021     style = GetWindowLongA(window, GWL_STYLE);
1022     ok(style & WS_MINIMIZE, "Window should be minimized, got style %#x.\n", style);
1023
1024     ctx = wglCreateContext(dc);
1025     ok(!!ctx, "Failed to create GL context, last error %#x.\n", GetLastError());
1026
1027     ret = wglMakeCurrent(dc, ctx);
1028     ok(ret, "Failed to make context current, last error %#x.\n", GetLastError());
1029
1030     style = GetWindowLongA(window, GWL_STYLE);
1031     ok(style & WS_MINIMIZE, "window should be minimized, got style %#x.\n", style);
1032
1033     ret = wglMakeCurrent(NULL, NULL);
1034     ok(ret, "Failed to clear current context, last error %#x.\n", GetLastError());
1035
1036     ret = wglDeleteContext(ctx);
1037     ok(ret, "Failed to delete GL context, last error %#x.\n", GetLastError());
1038
1039     ReleaseDC(window, dc);
1040     DestroyWindow(window);
1041 }
1042
1043 static void test_window_dc(void)
1044 {
1045     PIXELFORMATDESCRIPTOR pf_desc =
1046     {
1047         sizeof(PIXELFORMATDESCRIPTOR),
1048         1,                     /* version */
1049         PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
1050         PFD_TYPE_RGBA,
1051         24,                    /* 24-bit color depth */
1052         0, 0, 0, 0, 0, 0,      /* color bits */
1053         0,                     /* alpha buffer */
1054         0,                     /* shift bit */
1055         0,                     /* accumulation buffer */
1056         0, 0, 0, 0,            /* accum bits */
1057         32,                    /* z-buffer */
1058         0,                     /* stencil buffer */
1059         0,                     /* auxiliary buffer */
1060         PFD_MAIN_PLANE,        /* main layer */
1061         0,                     /* reserved */
1062         0, 0, 0                /* layer masks */
1063     };
1064     int pixel_format;
1065     HWND window;
1066     RECT vp, r;
1067     HGLRC ctx;
1068     BOOL ret;
1069     HDC dc;
1070
1071     window = CreateWindowA("static", "opengl32_test",
1072             WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0, 0, 0);
1073     ok(!!window, "Failed to create window, last error %#x.\n", GetLastError());
1074
1075     ShowWindow(window, SW_SHOW);
1076
1077     dc = GetWindowDC(window);
1078     ok(!!dc, "Failed to get DC.\n");
1079
1080     pixel_format = ChoosePixelFormat(dc, &pf_desc);
1081     if (!pixel_format)
1082     {
1083         win_skip("Failed to find pixel format.\n");
1084         ReleaseDC(window, dc);
1085         DestroyWindow(window);
1086         return;
1087     }
1088
1089     ret = SetPixelFormat(dc, pixel_format, &pf_desc);
1090     ok(ret, "Failed to set pixel format, last error %#x.\n", GetLastError());
1091
1092     ctx = wglCreateContext(dc);
1093     ok(!!ctx, "Failed to create GL context, last error %#x.\n", GetLastError());
1094
1095     ret = wglMakeCurrent(dc, ctx);
1096     ok(ret, "Failed to make context current, last error %#x.\n", GetLastError());
1097
1098     GetClientRect(window, &r);
1099     glGetIntegerv(GL_VIEWPORT, (GLint *)&vp);
1100     ok(EqualRect(&r, &vp), "Viewport not equal to client rect.\n");
1101
1102     ret = wglMakeCurrent(NULL, NULL);
1103     ok(ret, "Failed to clear current context, last error %#x.\n", GetLastError());
1104
1105     ret = wglDeleteContext(ctx);
1106     ok(ret, "Failed to delete GL context, last error %#x.\n", GetLastError());
1107
1108     ReleaseDC(window, dc);
1109     DestroyWindow(window);
1110 }
1111
1112 static void test_destroy(HDC oldhdc)
1113 {
1114     PIXELFORMATDESCRIPTOR pf_desc =
1115     {
1116         sizeof(PIXELFORMATDESCRIPTOR),
1117         1,                     /* version */
1118         PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
1119         PFD_TYPE_RGBA,
1120         24,                    /* 24-bit color depth */
1121         0, 0, 0, 0, 0, 0,      /* color bits */
1122         0,                     /* alpha buffer */
1123         0,                     /* shift bit */
1124         0,                     /* accumulation buffer */
1125         0, 0, 0, 0,            /* accum bits */
1126         32,                    /* z-buffer */
1127         0,                     /* stencil buffer */
1128         0,                     /* auxiliary buffer */
1129         PFD_MAIN_PLANE,        /* main layer */
1130         0,                     /* reserved */
1131         0, 0, 0                /* layer masks */
1132     };
1133     int pixel_format;
1134     HWND window;
1135     HGLRC ctx;
1136     BOOL ret;
1137     HDC dc;
1138     GLenum glerr;
1139     DWORD err;
1140     HGLRC oldctx = wglGetCurrentContext();
1141
1142     ok(!!oldctx, "Expected to find a valid current context.\n");
1143
1144     window = CreateWindowA("static", "opengl32_test",
1145             WS_POPUP, 0, 0, 640, 480, 0, 0, 0, 0);
1146     ok(!!window, "Failed to create window, last error %#x.\n", GetLastError());
1147
1148     dc = GetDC(window);
1149     ok(!!dc, "Failed to get DC.\n");
1150
1151     pixel_format = ChoosePixelFormat(dc, &pf_desc);
1152     if (!pixel_format)
1153     {
1154         win_skip("Failed to find pixel format.\n");
1155         ReleaseDC(window, dc);
1156         DestroyWindow(window);
1157         return;
1158     }
1159
1160     ret = SetPixelFormat(dc, pixel_format, &pf_desc);
1161     ok(ret, "Failed to set pixel format, last error %#x.\n", GetLastError());
1162
1163     ctx = wglCreateContext(dc);
1164     ok(!!ctx, "Failed to create GL context, last error %#x.\n", GetLastError());
1165
1166     ret = wglMakeCurrent(dc, ctx);
1167     ok(ret, "Failed to make context current, last error %#x.\n", GetLastError());
1168
1169     glClear(GL_COLOR_BUFFER_BIT);
1170     glFinish();
1171     glerr = glGetError();
1172     ok(glerr == GL_NO_ERROR, "Failed glClear, error %#x.\n", glerr);
1173     ret = SwapBuffers(dc);
1174     ok(ret, "Failed SwapBuffers, error %#x.\n", GetLastError());
1175
1176     ret = DestroyWindow(window);
1177     ok(ret, "Failed to destroy window, last error %#x.\n", GetLastError());
1178
1179     ok(wglGetCurrentContext() == ctx, "Wrong current context.\n");
1180
1181     SetLastError(0xdeadbeef);
1182     ret = wglMakeCurrent(dc, ctx);
1183     err = GetLastError();
1184     ok(!ret && err == ERROR_INVALID_HANDLE,
1185             "Unexpected behavior when making context current, ret %d, last error %#x.\n", ret, err);
1186     SetLastError(0xdeadbeef);
1187     ret = SwapBuffers(dc);
1188     err = GetLastError();
1189     ok(!ret && err == ERROR_INVALID_HANDLE, "Unexpected behavior with SwapBuffer, last error %#x.\n", err);
1190
1191     ok(wglGetCurrentContext() == ctx, "Wrong current context.\n");
1192
1193     glClear(GL_COLOR_BUFFER_BIT);
1194     glFinish();
1195     glerr = glGetError();
1196     ok(glerr == GL_NO_ERROR, "Failed glClear, error %#x.\n", glerr);
1197     SetLastError(0xdeadbeef);
1198     ret = SwapBuffers(dc);
1199     err = GetLastError();
1200     ok(!ret && err == ERROR_INVALID_HANDLE, "Unexpected behavior with SwapBuffer, last error %#x.\n", err);
1201
1202     ret = wglMakeCurrent(NULL, NULL);
1203     ok(ret, "Failed to clear current context, last error %#x.\n", GetLastError());
1204
1205     glClear(GL_COLOR_BUFFER_BIT);
1206     glFinish();
1207     glerr = glGetError();
1208     ok(glerr == GL_INVALID_OPERATION, "Failed glClear, error %#x.\n", glerr);
1209     SetLastError(0xdeadbeef);
1210     ret = SwapBuffers(dc);
1211     err = GetLastError();
1212     ok(!ret && err == ERROR_INVALID_HANDLE, "Unexpected behavior with SwapBuffer, last error %#x.\n", err);
1213
1214     SetLastError(0xdeadbeef);
1215     ret = wglMakeCurrent(dc, ctx);
1216     err = GetLastError();
1217     ok(!ret && err == ERROR_INVALID_HANDLE,
1218             "Unexpected behavior when making context current, ret %d, last error %#x.\n", ret, err);
1219
1220     ok(wglGetCurrentContext() == NULL, "Wrong current context.\n");
1221
1222     ret = wglMakeCurrent(oldhdc, oldctx);
1223     ok(ret, "Failed to make context current, last error %#x.\n", GetLastError());
1224     ok(wglGetCurrentContext() == oldctx, "Wrong current context.\n");
1225
1226     SetLastError(0xdeadbeef);
1227     ret = wglMakeCurrent(dc, ctx);
1228     err = GetLastError();
1229     ok(!ret && err == ERROR_INVALID_HANDLE,
1230             "Unexpected behavior when making context current, ret %d, last error %#x.\n", ret, err);
1231
1232     ok(wglGetCurrentContext() == oldctx, "Wrong current context.\n");
1233
1234     ret = wglDeleteContext(ctx);
1235     ok(ret, "Failed to delete GL context, last error %#x.\n", GetLastError());
1236
1237     ReleaseDC(window, dc);
1238
1239     ret = wglMakeCurrent(oldhdc, oldctx);
1240     ok(ret, "Failed to make context current, last error %#x.\n", GetLastError());
1241 }
1242
1243 static void test_destroy_read(HDC oldhdc)
1244 {
1245     PIXELFORMATDESCRIPTOR pf_desc =
1246     {
1247         sizeof(PIXELFORMATDESCRIPTOR),
1248         1,                     /* version */
1249         PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
1250         PFD_TYPE_RGBA,
1251         24,                    /* 24-bit color depth */
1252         0, 0, 0, 0, 0, 0,      /* color bits */
1253         0,                     /* alpha buffer */
1254         0,                     /* shift bit */
1255         0,                     /* accumulation buffer */
1256         0, 0, 0, 0,            /* accum bits */
1257         32,                    /* z-buffer */
1258         0,                     /* stencil buffer */
1259         0,                     /* auxiliary buffer */
1260         PFD_MAIN_PLANE,        /* main layer */
1261         0,                     /* reserved */
1262         0, 0, 0                /* layer masks */
1263     };
1264     int pixel_format;
1265     HWND draw_window, read_window;
1266     HGLRC ctx;
1267     BOOL ret;
1268     HDC read_dc, draw_dc;
1269     GLenum glerr;
1270     DWORD err;
1271     HGLRC oldctx = wglGetCurrentContext();
1272
1273     ok(!!oldctx, "Expected to find a valid current context\n");
1274
1275     draw_window = CreateWindowA("static", "opengl32_test",
1276             WS_POPUP, 0, 0, 640, 480, 0, 0, 0, 0);
1277     ok(!!draw_window, "Failed to create window, last error %#x.\n", GetLastError());
1278
1279     draw_dc = GetDC(draw_window);
1280     ok(!!draw_dc, "Failed to get DC.\n");
1281
1282     pixel_format = ChoosePixelFormat(draw_dc, &pf_desc);
1283     if (!pixel_format)
1284     {
1285         win_skip("Failed to find pixel format.\n");
1286         ReleaseDC(draw_window, draw_dc);
1287         DestroyWindow(draw_window);
1288         return;
1289     }
1290
1291     ret = SetPixelFormat(draw_dc, pixel_format, &pf_desc);
1292     ok(ret, "Failed to set pixel format, last error %#x.\n", GetLastError());
1293
1294     read_window = CreateWindowA("static", "opengl32_test",
1295             WS_POPUP, 0, 0, 640, 480, 0, 0, 0, 0);
1296     ok(!!read_window, "Failed to create window, last error %#x.\n", GetLastError());
1297
1298     read_dc = GetDC(read_window);
1299     ok(!!draw_dc, "Failed to get DC.\n");
1300
1301     pixel_format = ChoosePixelFormat(read_dc, &pf_desc);
1302     if (!pixel_format)
1303     {
1304         win_skip("Failed to find pixel format.\n");
1305         ReleaseDC(read_window, read_dc);
1306         DestroyWindow(read_window);
1307         ReleaseDC(draw_window, draw_dc);
1308         DestroyWindow(draw_window);
1309         return;
1310     }
1311
1312     ret = SetPixelFormat(read_dc, pixel_format, &pf_desc);
1313     ok(ret, "Failed to set pixel format, last error %#x.\n", GetLastError());
1314
1315     ctx = wglCreateContext(draw_dc);
1316     ok(!!ctx, "Failed to create GL context, last error %#x.\n", GetLastError());
1317
1318     ret = pwglMakeContextCurrentARB(draw_dc, read_dc, ctx);
1319     ok(ret, "Failed to make context current, last error %#x.\n", GetLastError());
1320
1321     glCopyPixels(0, 0, 640, 480, GL_COLOR);
1322     glFinish();
1323     glerr = glGetError();
1324     ok(glerr == GL_NO_ERROR, "Failed glCopyPixel, error %#x.\n", glerr);
1325     ret = SwapBuffers(draw_dc);
1326     ok(ret, "Failed SwapBuffers, error %#x.\n", GetLastError());
1327
1328     ret = DestroyWindow(read_window);
1329     ok(ret, "Failed to destroy window, last error %#x.\n", GetLastError());
1330
1331     ok(wglGetCurrentContext() == ctx, "Wrong current context.\n");
1332
1333     if (0) /* Crashes on AMD on Windows */
1334     {
1335         glCopyPixels(0, 0, 640, 480, GL_COLOR);
1336         glFinish();
1337         glerr = glGetError();
1338         ok(glerr == GL_NO_ERROR, "Failed glCopyPixel, error %#x.\n", glerr);
1339     }
1340
1341     glClear(GL_COLOR_BUFFER_BIT);
1342     glFinish();
1343     glerr = glGetError();
1344     ok(glerr == GL_NO_ERROR, "Failed glClear, error %#x.\n", glerr);
1345     ret = SwapBuffers(draw_dc);
1346     ok(ret, "Failed SwapBuffers, error %#x.\n", GetLastError());
1347
1348     ret = wglMakeCurrent(NULL, NULL);
1349     ok(ret, "Failed to clear current context, last error %#x.\n", GetLastError());
1350
1351     if (0) /* This crashes with Nvidia drivers on Windows. */
1352     {
1353         SetLastError(0xdeadbeef);
1354         ret = pwglMakeContextCurrentARB(draw_dc, read_dc, ctx);
1355         err = GetLastError();
1356         ok(!ret && err == ERROR_INVALID_HANDLE,
1357                 "Unexpected behavior when making context current, ret %d, last error %#x.\n", ret, err);
1358     }
1359
1360     ret = DestroyWindow(draw_window);
1361     ok(ret, "Failed to destroy window, last error %#x.\n", GetLastError());
1362
1363     glClear(GL_COLOR_BUFFER_BIT);
1364     glFinish();
1365     glerr = glGetError();
1366     ok(glerr == GL_INVALID_OPERATION, "Failed glClear, error %#x.\n", glerr);
1367     SetLastError(0xdeadbeef);
1368     ret = SwapBuffers(draw_dc);
1369     err = GetLastError();
1370     ok(!ret && err == ERROR_INVALID_HANDLE, "Unexpected behavior with SwapBuffer, last error %#x.\n", err);
1371
1372     SetLastError(0xdeadbeef);
1373     ret = pwglMakeContextCurrentARB(draw_dc, read_dc, ctx);
1374     err = GetLastError();
1375     ok(!ret && (err == ERROR_INVALID_HANDLE || err == 0xc0070006),
1376             "Unexpected behavior when making context current, ret %d, last error %#x.\n", ret, err);
1377
1378     ok(wglGetCurrentContext() == NULL, "Wrong current context.\n");
1379
1380     wglMakeCurrent(NULL, NULL);
1381
1382     wglMakeCurrent(oldhdc, oldctx);
1383     ok(wglGetCurrentContext() == oldctx, "Wrong current context.\n");
1384
1385     SetLastError(0xdeadbeef);
1386     ret = pwglMakeContextCurrentARB(draw_dc, read_dc, ctx);
1387     err = GetLastError();
1388     ok(!ret && (err == ERROR_INVALID_HANDLE || err == 0xc0070006),
1389             "Unexpected behavior when making context current, last error %#x.\n", err);
1390
1391     ok(wglGetCurrentContext() == oldctx, "Wrong current context.\n");
1392
1393     ret = wglDeleteContext(ctx);
1394     ok(ret, "Failed to delete GL context, last error %#x.\n", GetLastError());
1395
1396     ReleaseDC(read_window, read_dc);
1397     ReleaseDC(draw_window, draw_dc);
1398
1399     wglMakeCurrent(oldhdc, oldctx);
1400 }
1401
1402 START_TEST(opengl)
1403 {
1404     HWND hwnd;
1405     PIXELFORMATDESCRIPTOR pfd = {
1406         sizeof(PIXELFORMATDESCRIPTOR),
1407         1,                     /* version */
1408         PFD_DRAW_TO_WINDOW |
1409         PFD_SUPPORT_OPENGL |
1410         PFD_DOUBLEBUFFER,
1411         PFD_TYPE_RGBA,
1412         24,                    /* 24-bit color depth */
1413         0, 0, 0, 0, 0, 0,      /* color bits */
1414         0,                     /* alpha buffer */
1415         0,                     /* shift bit */
1416         0,                     /* accumulation buffer */
1417         0, 0, 0, 0,            /* accum bits */
1418         32,                    /* z-buffer */
1419         0,                     /* stencil buffer */
1420         0,                     /* auxiliary buffer */
1421         PFD_MAIN_PLANE,        /* main layer */
1422         0,                     /* reserved */
1423         0, 0, 0                /* layer masks */
1424     };
1425
1426     hwnd = CreateWindow("static", "Title", WS_OVERLAPPEDWINDOW,
1427                         10, 10, 200, 200, NULL, NULL, NULL, NULL);
1428     ok(hwnd != NULL, "err: %d\n", GetLastError());
1429     if (hwnd)
1430     {
1431         HDC hdc;
1432         int iPixelFormat, res;
1433         HGLRC hglrc;
1434         DWORD error;
1435         ShowWindow(hwnd, SW_SHOW);
1436
1437         hdc = GetDC(hwnd);
1438
1439         iPixelFormat = ChoosePixelFormat(hdc, &pfd);
1440         if(iPixelFormat == 0)
1441         {
1442             /* This should never happen as ChoosePixelFormat always returns a closest match, but currently this fails in Wine if we don't have glX */
1443             win_skip("Unable to find pixel format.\n");
1444             goto cleanup;
1445         }
1446
1447         /* We shouldn't be able to create a context from a hdc which doesn't have a pixel format set */
1448         hglrc = wglCreateContext(hdc);
1449         ok(hglrc == NULL, "wglCreateContext should fail when no pixel format has been set, but it passed\n");
1450         error = GetLastError();
1451         ok(error == ERROR_INVALID_PIXEL_FORMAT, "expected ERROR_INVALID_PIXEL_FORMAT for wglCreateContext without a pixelformat set, but received %#x\n", error);
1452
1453         res = SetPixelFormat(hdc, iPixelFormat, &pfd);
1454         ok(res, "SetPixelformat failed: %x\n", GetLastError());
1455
1456         test_bitmap_rendering( TRUE );
1457         test_bitmap_rendering( FALSE );
1458         test_minimized();
1459         test_window_dc();
1460         test_dc(hwnd, hdc);
1461
1462         hglrc = wglCreateContext(hdc);
1463         res = wglMakeCurrent(hdc, hglrc);
1464         ok(res, "wglMakeCurrent failed!\n");
1465         if(res)
1466         {
1467             trace("OpenGL renderer: %s\n", glGetString(GL_RENDERER));
1468             trace("OpenGL driver version: %s\n", glGetString(GL_VERSION));
1469             trace("OpenGL vendor: %s\n", glGetString(GL_VENDOR));
1470         }
1471         else
1472         {
1473             skip("Skipping OpenGL tests without a current context\n");
1474             return;
1475         }
1476
1477         /* Initialisation of WGL functions depends on an implicit WGL context. For this reason we can't load them before making
1478          * any WGL call :( On Wine this would work but not on real Windows because there can be different implementations (software, ICD, MCD).
1479          */
1480         init_functions();
1481         test_getprocaddress(hdc);
1482         test_deletecontext(hwnd, hdc);
1483         test_makecurrent(hdc);
1484
1485         /* The lack of wglGetExtensionsStringARB in general means broken software rendering or the lack of decent OpenGL support, skip tests in such cases */
1486         if (!pwglGetExtensionsStringARB)
1487         {
1488             win_skip("wglGetExtensionsStringARB is not available\n");
1489             return;
1490         }
1491
1492         test_setpixelformat(hdc);
1493         test_destroy(hdc);
1494         test_sharelists(hdc);
1495         test_colorbits(hdc);
1496         test_gdi_dbuf(hdc);
1497         test_acceleration(hdc);
1498
1499         wgl_extensions = pwglGetExtensionsStringARB(hdc);
1500         if(wgl_extensions == NULL) skip("Skipping opengl32 tests because this OpenGL implementation doesn't support WGL extensions!\n");
1501
1502         if(strstr(wgl_extensions, "WGL_ARB_create_context"))
1503             test_opengl3(hdc);
1504
1505         if(strstr(wgl_extensions, "WGL_ARB_make_current_read"))
1506         {
1507             test_make_current_read(hdc);
1508             test_destroy_read(hdc);
1509         }
1510         else
1511             skip("WGL_ARB_make_current_read not supported, skipping test\n");
1512
1513         if(strstr(wgl_extensions, "WGL_ARB_pbuffer"))
1514             test_pbuffers(hdc);
1515         else
1516             skip("WGL_ARB_pbuffer not supported, skipping pbuffer test\n");
1517
1518 cleanup:
1519         ReleaseDC(hwnd, hdc);
1520         DestroyWindow(hwnd);
1521     }
1522 }