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 const unsigned char * WINAPI glGetString(unsigned int);
  26 #define GL_VENDOR 0x1F00
  27 #define GL_RENDERER 0x1F01
  28 #define GL_VERSION 0x1F02
  29
  30 #define MAX_FORMATS 256
  31 typedef void* HPBUFFERARB;
  32
  33 /* WGL_ARB_create_context */
  34 HGLRC (WINAPI *pwglCreateContextAttribsARB)(HDC hDC, HGLRC hShareContext, const int *attribList);
  35 /* GetLastError */
  36 #define ERROR_INVALID_VERSION_ARB 0x2095
  37 #define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091
  38 #define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092
  39 #define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093
  40 #define WGL_CONTEXT_FLAGS_ARB 0x2094
  41 /* Flags for WGL_CONTEXT_FLAGS_ARB */
  42 #define WGL_CONTEXT_DEBUG_BIT_ARB 0x0001
  43 #define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB  0x0002
  44
  45 /* WGL_ARB_extensions_string */
  46 static const char* (WINAPI *pwglGetExtensionsStringARB)(HDC);
  47 static int (WINAPI *pwglReleasePbufferDCARB)(HPBUFFERARB, HDC);
  48
  49 /* WGL_ARB_make_current_read */
  50 static BOOL (WINAPI *pwglMakeContextCurrentARB)(HDC hdraw, HDC hread, HGLRC hglrc);
  51 static HDC (WINAPI *pwglGetCurrentReadDCARB)();
  52
  53 /* WGL_ARB_pixel_format */
  54 #define WGL_COLOR_BITS_ARB 0x2014
  55 #define WGL_RED_BITS_ARB   0x2015
  56 #define WGL_GREEN_BITS_ARB 0x2017
  57 #define WGL_BLUE_BITS_ARB  0x2019
  58 #define WGL_ALPHA_BITS_ARB 0x201B
  59 #define WGL_SUPPORT_GDI_ARB   0x200F
  60 #define WGL_DOUBLE_BUFFER_ARB 0x2011
  61
  62 static BOOL (WINAPI *pwglChoosePixelFormatARB)(HDC, const int *, const FLOAT *, UINT, int *, UINT *);
  63 static BOOL (WINAPI *pwglGetPixelFormatAttribivARB)(HDC, int, int, UINT, const int *, int *);
  64
  65 /* WGL_ARB_pbuffer */
  66 #define WGL_DRAW_TO_PBUFFER_ARB 0x202D
  67 static HPBUFFERARB* (WINAPI *pwglCreatePbufferARB)(HDC, int, int, int, const int *);
  68 static HDC (WINAPI *pwglGetPbufferDCARB)(HPBUFFERARB);
  69
  70 static const char* wgl_extensions = NULL;
  71
  72 static void init_functions(void)
  73 {
  74 #define GET_PROC(func) \
  75     p ## func = (void*)wglGetProcAddress(#func); \
  76     if(!p ## func) \
  77       trace("wglGetProcAddress(%s) failed\n", #func);
  78
  79     /* WGL_ARB_create_context */
  80     GET_PROC(wglCreateContextAttribsARB);
  81
  82     /* WGL_ARB_extensions_string */
  83     GET_PROC(wglGetExtensionsStringARB)
  84
  85     /* WGL_ARB_make_current_read */
  86     GET_PROC(wglMakeContextCurrentARB);
  87     GET_PROC(wglGetCurrentReadDCARB);
  88
  89     /* WGL_ARB_pixel_format */
  90     GET_PROC(wglChoosePixelFormatARB)
  91     GET_PROC(wglGetPixelFormatAttribivARB)
  92
  93     /* WGL_ARB_pbuffer */
  94     GET_PROC(wglCreatePbufferARB)
  95     GET_PROC(wglGetPbufferDCARB)
  96     GET_PROC(wglReleasePbufferDCARB)
  97
  98 #undef GET_PROC
  99 }
 100
 101 static void test_pbuffers(HDC hdc)
 102 {
 103     const int iAttribList[] = { WGL_DRAW_TO_PBUFFER_ARB, 1, /* Request pbuffer support */
 104                                 0 };
 105     int iFormats[MAX_FORMATS];
 106     unsigned int nOnscreenFormats;
 107     unsigned int nFormats;
 108     int i, res;
 109     int iPixelFormat = 0;
 110
 111     nOnscreenFormats = DescribePixelFormat(hdc, 0, 0, NULL);
 112
 113     /* When you want to render to a pbuffer you need to call wglGetPbufferDCARB which
 114      * returns a 'magic' HDC which you can then pass to wglMakeCurrent to switch rendering
 115      * to the pbuffer. Below some tests are performed on what happens if you use standard WGL calls
 116      * on this 'magic' HDC for both a pixelformat that support onscreen and offscreen rendering
 117      * and a pixelformat that's only available for offscreen rendering (this means that only
 118      * wglChoosePixelFormatARB and friends know about the format.
 119      *
 120      * The first thing we need are pixelformats with pbuffer capabilities.
 121      */
 122     res = pwglChoosePixelFormatARB(hdc, iAttribList, NULL, MAX_FORMATS, iFormats, &nFormats);
 123     if(res <= 0)
 124     {
 125         skip("No pbuffer compatible formats found while WGL_ARB_pbuffer is supported\n");
 126         return;
 127     }
 128     trace("nOnscreenFormats: %d\n", nOnscreenFormats);
 129     trace("Total number of pbuffer capable pixelformats: %d\n", nFormats);
 130
 131     /* Try to select an onscreen pixelformat out of the list */
 132     for(i=0; i < nFormats; i++)
 133     {
 134         /* Check if the format is onscreen, if it is choose it */
 135         if(iFormats[i] <= nOnscreenFormats)
 136         {
 137             iPixelFormat = iFormats[i];
 138             trace("Selected iPixelFormat=%d\n", iPixelFormat);
 139             break;
 140         }
 141     }
 142
 143     /* A video driver supports a large number of onscreen and offscreen pixelformats.
 144      * The traditional WGL calls only see a subset of the whole pixelformat list. First
 145      * of all they only see the onscreen formats (the offscreen formats are at the end of the
 146      * pixelformat list) and second extended pixelformat capabilities are hidden from the
 147      * standard WGL calls. Only functions that depend on WGL_ARB_pixel_format can see them.
 148      *
 149      * Below we check if the pixelformat is also supported onscreen.
 150      */
 151     if(iPixelFormat != 0)
 152     {
 153         HDC pbuffer_hdc;
 154         HPBUFFERARB pbuffer = pwglCreatePbufferARB(hdc, iPixelFormat, 640 /* width */, 480 /* height */, NULL);
 155         if(!pbuffer)
 156             skip("Pbuffer creation failed!\n");
 157
 158         /* Test the pixelformat returned by GetPixelFormat on a pbuffer as the behavior is not clear */
 159         pbuffer_hdc = pwglGetPbufferDCARB(pbuffer);
 160         res = GetPixelFormat(pbuffer_hdc);
 161         ok(res == iPixelFormat, "Unexpected iPixelFormat=%d returned by GetPixelFormat for format %d\n", res, iPixelFormat);
 162         trace("iPixelFormat returned by GetPixelFormat: %d\n", res);
 163         trace("PixelFormat from wglChoosePixelFormatARB: %d\n", iPixelFormat);
 164
 165         pwglReleasePbufferDCARB(pbuffer, hdc);
 166     }
 167     else skip("Pbuffer test for onscreen pixelformat skipped as no onscreen format with pbuffer capabilities have been found\n");
 168
 169     /* Search for a real offscreen format */
 170     for(i=0, iPixelFormat=0; i<nFormats; i++)
 171     {
 172         if(iFormats[i] > nOnscreenFormats)
 173         {
 174             iPixelFormat = iFormats[i];
 175             trace("Selected iPixelFormat: %d\n", iPixelFormat);
 176             break;
 177         }
 178     }
 179
 180     if(iPixelFormat != 0)
 181     {
 182         HDC pbuffer_hdc;
 183         HPBUFFERARB pbuffer = pwglCreatePbufferARB(hdc, iPixelFormat, 640 /* width */, 480 /* height */, NULL);
 184         if(!pbuffer)
 185             skip("Pbuffer creation failed!\n");
 186
 187         /* Test the pixelformat returned by GetPixelFormat on a pbuffer as the behavior is not clear */
 188         pbuffer_hdc = pwglGetPbufferDCARB(pbuffer);
 189         res = GetPixelFormat(pbuffer_hdc);
 190
 191         ok(res == 1, "Unexpected iPixelFormat=%d (1 expected) returned by GetPixelFormat for offscreen format %d\n", res, iPixelFormat);
 192         trace("iPixelFormat returned by GetPixelFormat: %d\n", res);
 193         trace("PixelFormat from wglChoosePixelFormatARB: %d\n", iPixelFormat);
 194         pwglReleasePbufferDCARB(pbuffer, hdc);
 195     }
 196     else skip("Pbuffer test for offscreen pixelformat skipped as no offscreen-only format with pbuffer capabilities has been found\n");
 197 }
 198
 199 static void test_setpixelformat(HDC winhdc)
 200 {
 201     int res = 0;
 202     int nCfgs;
 203     int pf;
 204     int i;
 205     HWND hwnd;
 206     PIXELFORMATDESCRIPTOR pfd = {
 207         sizeof(PIXELFORMATDESCRIPTOR),
 208         1,                     /* version */
 209         PFD_DRAW_TO_WINDOW |
 210         PFD_SUPPORT_OPENGL |
 211         PFD_DOUBLEBUFFER,
 212         PFD_TYPE_RGBA,
 213         24,                    /* 24-bit color depth */
 214         0, 0, 0, 0, 0, 0,      /* color bits */
 215         0,                     /* alpha buffer */
 216         0,                     /* shift bit */
 217         0,                     /* accumulation buffer */
 218         0, 0, 0, 0,            /* accum bits */
 219         32,                    /* z-buffer */
 220         0,                     /* stencil buffer */
 221         0,                     /* auxiliary buffer */
 222         PFD_MAIN_PLANE,        /* main layer */
 223         0,                     /* reserved */
 224         0, 0, 0                /* layer masks */
 225     };
 226
 227     HDC hdc = GetDC(0);
 228     ok(hdc != 0, "GetDC(0) failed!\n");
 229
 230     /* This should pass even on the main device context */
 231     pf = ChoosePixelFormat(hdc, &pfd);
 232     ok(pf != 0, "ChoosePixelFormat failed on main device context\n");
 233
 234     /* SetPixelFormat on the main device context 'X root window' should fail,
 235      * but some broken drivers allow it
 236      */
 237     res = SetPixelFormat(hdc, pf, &pfd);
 238     trace("SetPixelFormat on main device context %s\n", res ? "succeeded" : "failed");
 239
 240     /* Setting the same format that was set on the HDC is allowed; other
 241        formats fail */
 242     nCfgs = DescribePixelFormat(winhdc, 0, 0, NULL);
 243     pf = GetPixelFormat(winhdc);
 244     for(i = 1;i <= nCfgs;i++)
 245     {
 246         int res = SetPixelFormat(winhdc, i, NULL);
 247         if(i == pf) ok(res, "Failed to set the same pixel format\n");
 248         else ok(!res, "Unexpectedly set an alternate pixel format\n");
 249     }
 250
 251     hwnd = CreateWindow("static", "Title", WS_OVERLAPPEDWINDOW,
 252                         10, 10, 200, 200, NULL, NULL, NULL, NULL);
 253     ok(hwnd != NULL, "err: %d\n", GetLastError());
 254     if (hwnd)
 255     {
 256         HDC hdc = GetDC( hwnd );
 257         pf = ChoosePixelFormat( hdc, &pfd );
 258         ok( pf != 0, "ChoosePixelFormat failed\n" );
 259         res = SetPixelFormat( hdc, pf, &pfd );
 260         ok( res != 0, "SetPixelFormat failed\n" );
 261         i = GetPixelFormat( hdc );
 262         ok( i == pf, "GetPixelFormat returned wrong format %d/%d\n", i, pf );
 263         ReleaseDC( hwnd, hdc );
 264         hdc = GetWindowDC( hwnd );
 265         i = GetPixelFormat( hdc );
 266         ok( i == pf, "GetPixelFormat returned wrong format %d/%d\n", i, pf );
 267         ReleaseDC( hwnd, hdc );
 268         DestroyWindow( hwnd );
 269     }
 270
 271     hwnd = CreateWindow("static", "Title", WS_OVERLAPPEDWINDOW,
 272                         10, 10, 200, 200, NULL, NULL, NULL, NULL);
 273     ok(hwnd != NULL, "err: %d\n", GetLastError());
 274     if (hwnd)
 275     {
 276         HDC hdc = GetWindowDC( hwnd );
 277         pf = ChoosePixelFormat( hdc, &pfd );
 278         ok( pf != 0, "ChoosePixelFormat failed\n" );
 279         res = SetPixelFormat( hdc, pf, &pfd );
 280         ok( res != 0, "SetPixelFormat failed\n" );
 281         i = GetPixelFormat( hdc );
 282         ok( i == pf, "GetPixelFormat returned wrong format %d/%d\n", i, pf );
 283         ReleaseDC( hwnd, hdc );
 284         DestroyWindow( hwnd );
 285     }
 286 }
 287
 288 static void test_sharelists(HDC winhdc)
 289 {
 290     HGLRC hglrc1, hglrc2, hglrc3;
 291     int res;
 292
 293     hglrc1 = wglCreateContext(winhdc);
 294     res = wglShareLists(0, 0);
 295     ok(res == FALSE, "Sharing display lists for no contexts passed!\n");
 296
 297     /* Test 1: Create a context and just share lists without doing anything special */
 298     hglrc2 = wglCreateContext(winhdc);
 299     if(hglrc2)
 300     {
 301         res = wglShareLists(hglrc1, hglrc2);
 302         ok(res, "Sharing of display lists failed\n");
 303         wglDeleteContext(hglrc2);
 304     }
 305
 306     /* Test 2: Share display lists with a 'destination' context which has been made current */
 307     hglrc2 = wglCreateContext(winhdc);
 308     if(hglrc2)
 309     {
 310         res = wglMakeCurrent(winhdc, hglrc2);
 311         ok(res, "Make current failed\n");
 312         res = wglShareLists(hglrc1, hglrc2);
 313         todo_wine ok(res, "Sharing display lists with a destination context which has been made current passed\n");
 314         wglMakeCurrent(0, 0);
 315         wglDeleteContext(hglrc2);
 316     }
 317
 318     /* Test 3: Share display lists with a context which already shares display lists with another context.
 319      * According to MSDN the second paramater can't share any display lists but some buggy drivers might allow it */
 320     hglrc3 = wglCreateContext(winhdc);
 321     if(hglrc3)
 322     {
 323         res = wglShareLists(hglrc3, hglrc1);
 324         ok(res == FALSE, "Sharing of display lists failed for a context which already shared lists before\n");
 325         wglDeleteContext(hglrc3);
 326     }
 327
 328     /* Test 4: Share display lists with a 'source' context which has been made current */
 329     hglrc2 = wglCreateContext(winhdc);
 330     if(hglrc2)
 331     {
 332         res = wglMakeCurrent(winhdc, hglrc1);
 333         ok(res, "Make current failed\n");
 334         res = wglShareLists(hglrc1, hglrc2);
 335         ok(res, "Sharing display lists with a source context which has been made current passed\n");
 336         wglMakeCurrent(0, 0);
 337         wglDeleteContext(hglrc2);
 338     }
 339 }
 340
 341 static void test_makecurrent(HDC winhdc)
 342 {
 343     BOOL ret;
 344     HGLRC hglrc;
 345
 346     hglrc = wglCreateContext(winhdc);
 347     ok( hglrc != 0, "wglCreateContext failed\n" );
 348
 349     ret = wglMakeCurrent( winhdc, hglrc );
 350     ok( ret, "wglMakeCurrent failed\n" );
 351
 352     ok( wglGetCurrentContext() == hglrc, "wrong context\n" );
 353 }
 354
 355 static void test_colorbits(HDC hdc)
 356 {
 357     const int iAttribList[] = { WGL_COLOR_BITS_ARB, WGL_RED_BITS_ARB, WGL_GREEN_BITS_ARB,
 358                                 WGL_BLUE_BITS_ARB, WGL_ALPHA_BITS_ARB };
 359     int iAttribRet[sizeof(iAttribList)/sizeof(iAttribList[0])];
 360     const int iAttribs[] = { WGL_ALPHA_BITS_ARB, 1, 0 };
 361     unsigned int nFormats;
 362     int res;
 363     int iPixelFormat = 0;
 364
 365     if (!pwglChoosePixelFormatARB)
 366     {
 367         win_skip("wglChoosePixelFormatARB is not available\n");
 368         return;
 369     }
 370
 371     /* We need a pixel format with at least one bit of alpha */
 372     res = pwglChoosePixelFormatARB(hdc, iAttribs, NULL, 1, &iPixelFormat, &nFormats);
 373     if(res == FALSE || nFormats == 0)
 374     {
 375         skip("No suitable pixel formats found\n");
 376         return;
 377     }
 378
 379     res = pwglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0,
 380               sizeof(iAttribList)/sizeof(iAttribList[0]), iAttribList, iAttribRet);
 381     if(res == FALSE)
 382     {
 383         skip("wglGetPixelFormatAttribivARB failed\n");
 384         return;
 385     }
 386     iAttribRet[1] += iAttribRet[2]+iAttribRet[3]+iAttribRet[4];
 387     ok(iAttribRet[0] == iAttribRet[1], "WGL_COLOR_BITS_ARB (%d) does not equal R+G+B+A (%d)!\n",
 388                                        iAttribRet[0], iAttribRet[1]);
 389 }
 390
 391 static void test_gdi_dbuf(HDC hdc)
 392 {
 393     const int iAttribList[] = { WGL_SUPPORT_GDI_ARB, WGL_DOUBLE_BUFFER_ARB };
 394     int iAttribRet[sizeof(iAttribList)/sizeof(iAttribList[0])];
 395     unsigned int nFormats;
 396     int iPixelFormat;
 397     int res;
 398
 399     if (!pwglGetPixelFormatAttribivARB)
 400     {
 401         win_skip("wglGetPixelFormatAttribivARB is not available\n");
 402         return;
 403     }
 404
 405     nFormats = DescribePixelFormat(hdc, 0, 0, NULL);
 406     for(iPixelFormat = 1;iPixelFormat <= nFormats;iPixelFormat++)
 407     {
 408         res = pwglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0,
 409                   sizeof(iAttribList)/sizeof(iAttribList[0]), iAttribList,
 410                   iAttribRet);
 411         ok(res!=FALSE, "wglGetPixelFormatAttribivARB failed for pixel format %d\n", iPixelFormat);
 412         if(res == FALSE)
 413             continue;
 414
 415         ok(!(iAttribRet[0] && iAttribRet[1]), "GDI support and double buffering on pixel format %d\n", iPixelFormat);
 416     }
 417 }
 418
 419 static void test_make_current_read(HDC hdc)
 420 {
 421     int res;
 422     HDC hread;
 423     HGLRC hglrc = wglCreateContext(hdc);
 424
 425     if(!hglrc)
 426     {
 427         skip("wglCreateContext failed!\n");
 428         return;
 429     }
 430
 431     res = wglMakeCurrent(hdc, hglrc);
 432     if(!res)
 433     {
 434         skip("wglMakeCurrent failed!\n");
 435         return;
 436     }
 437
 438     /* Test what wglGetCurrentReadDCARB does for wglMakeCurrent as the spec doesn't mention it */
 439     hread = pwglGetCurrentReadDCARB();
 440     trace("hread %p, hdc %p\n", hread, hdc);
 441     ok(hread == hdc, "wglGetCurrentReadDCARB failed for standard wglMakeCurrent\n");
 442
 443     pwglMakeContextCurrentARB(hdc, hdc, hglrc);
 444     hread = pwglGetCurrentReadDCARB();
 445     ok(hread == hdc, "wglGetCurrentReadDCARB failed for wglMakeContextCurrent\n");
 446 }
 447
 448 static void test_dc(HWND hwnd, HDC hdc)
 449 {
 450     int pf1, pf2;
 451     HDC hdc2;
 452
 453     /* Get another DC and make sure it has the same pixel format */
 454     hdc2 = GetDC(hwnd);
 455     if(hdc != hdc2)
 456     {
 457         pf1 = GetPixelFormat(hdc);
 458         pf2 = GetPixelFormat(hdc2);
 459         ok(pf1 == pf2, "Second DC does not have the same format (%d != %d)\n", pf1, pf2);
 460     }
 461     else
 462         skip("Could not get a different DC for the window\n");
 463
 464     if(hdc2)
 465     {
 466         ReleaseDC(hwnd, hdc2);
 467         hdc2 = NULL;
 468     }
 469 }
 470
 471 static void test_opengl3(HDC hdc)
 472 {
 473     /* Try to create a context using an invalid OpenGL version namely 0.x */
 474     {
 475         HGLRC gl3Ctx;
 476         int attribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 0, 0};
 477
 478         gl3Ctx = pwglCreateContextAttribsARB(hdc, 0, attribs);
 479         ok(gl3Ctx == 0, "wglCreateContextAttribs with major version=0 should fail!\n");
 480
 481         if(gl3Ctx)
 482             wglDeleteContext(gl3Ctx);
 483     }
 484
 485     /* Try to create a context compatible with OpenGL 1.x; 1.0-2.1 is allowed */
 486     {
 487         HGLRC gl3Ctx;
 488         int attribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 1, 0};
 489
 490         gl3Ctx = pwglCreateContextAttribsARB(hdc, 0, attribs);
 491         ok(gl3Ctx != 0, "pwglCreateContextAttribsARB for a 1.x context failed!\n");
 492         wglDeleteContext(gl3Ctx);
 493     }
 494
 495     /* Try to pass an invalid HDC */
 496     {
 497         HGLRC gl3Ctx;
 498         DWORD error;
 499         gl3Ctx = pwglCreateContextAttribsARB((HDC)0xdeadbeef, 0, 0);
 500         ok(gl3Ctx == 0, "pwglCreateContextAttribsARB using an invalid HDC passed\n");
 501         error = GetLastError();
 502         todo_wine ok(error == ERROR_DC_NOT_FOUND, "Expected ERROR_DC_NOT_FOUND, got error=%x\n", error);
 503         wglDeleteContext(gl3Ctx);
 504     }
 505
 506     /* Try to pass an invalid shareList */
 507     {
 508         HGLRC gl3Ctx;
 509         DWORD error;
 510         gl3Ctx = pwglCreateContextAttribsARB(hdc, (HGLRC)0xdeadbeef, 0);
 511         ok(gl3Ctx == 0, "pwglCreateContextAttribsARB using an invalid shareList passed\n");
 512         error = GetLastError();
 513         todo_wine ok(error == ERROR_INVALID_OPERATION, "Expected ERROR_INVALID_OPERATION, got error=%x\n", error);
 514         wglDeleteContext(gl3Ctx);
 515     }
 516
 517     /* Try to create an OpenGL 3.0 context */
 518     {
 519         int attribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 0, 0};
 520         HGLRC gl3Ctx = pwglCreateContextAttribsARB(hdc, 0, attribs);
 521
 522         if(gl3Ctx == NULL)
 523         {
 524             skip("Skipping the rest of the WGL_ARB_create_context test due to lack of OpenGL 3.0\n");
 525             return;
 526         }
 527
 528         wglDeleteContext(gl3Ctx);
 529     }
 530
 531     /* 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 */
 532     {
 533         HGLRC glCtx = wglCreateContext(hdc);
 534
 535         int attribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 0, 0};
 536         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};
 537
 538         HGLRC gl3Ctx = pwglCreateContextAttribsARB(hdc, glCtx, attribs);
 539         ok(gl3Ctx != NULL, "Sharing of a display list between OpenGL 3.0 and OpenGL 1.x/2.x failed!\n");
 540         if(gl3Ctx)
 541             wglDeleteContext(gl3Ctx);
 542
 543         gl3Ctx = pwglCreateContextAttribsARB(hdc, glCtx, attribs_future);
 544         ok(gl3Ctx != NULL, "Sharing of a display list between a forward compatible OpenGL 3.0 context and OpenGL 1.x/2.x failed!\n");
 545         if(gl3Ctx)
 546             wglDeleteContext(gl3Ctx);
 547
 548         if(glCtx)
 549             wglDeleteContext(glCtx);
 550     }
 551
 552     /* Try to create an OpenGL 3.0 context and test windowless rendering */
 553     {
 554         HGLRC gl3Ctx;
 555         int attribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 0, 0};
 556         BOOL res;
 557
 558         gl3Ctx = pwglCreateContextAttribsARB(hdc, 0, attribs);
 559         ok(gl3Ctx != 0, "pwglCreateContextAttribsARB for a 3.0 context failed!\n");
 560
 561         /* OpenGL 3.0 allows offscreen rendering WITHOUT a drawable */
 562         /* NOTE: Nvidia's 177.89 beta drivers don't allow this yet */
 563         res = wglMakeCurrent(0, gl3Ctx);
 564         todo_wine ok(res == TRUE, "OpenGL 3.0 should allow windowless rendering, but the test failed!\n");
 565         if(res)
 566             wglMakeCurrent(0, 0);
 567
 568         if(gl3Ctx)
 569             wglDeleteContext(gl3Ctx);
 570     }
 571 }
 572
 573 START_TEST(opengl)
 574 {
 575     HWND hwnd;
 576     PIXELFORMATDESCRIPTOR pfd = {
 577         sizeof(PIXELFORMATDESCRIPTOR),
 578         1,                     /* version */
 579         PFD_DRAW_TO_WINDOW |
 580         PFD_SUPPORT_OPENGL |
 581         PFD_DOUBLEBUFFER,
 582         PFD_TYPE_RGBA,
 583         24,                    /* 24-bit color depth */
 584         0, 0, 0, 0, 0, 0,      /* color bits */
 585         0,                     /* alpha buffer */
 586         0,                     /* shift bit */
 587         0,                     /* accumulation buffer */
 588         0, 0, 0, 0,            /* accum bits */
 589         32,                    /* z-buffer */
 590         0,                     /* stencil buffer */
 591         0,                     /* auxiliary buffer */
 592         PFD_MAIN_PLANE,        /* main layer */
 593         0,                     /* reserved */
 594         0, 0, 0                /* layer masks */
 595     };
 596
 597     hwnd = CreateWindow("static", "Title", WS_OVERLAPPEDWINDOW,
 598                         10, 10, 200, 200, NULL, NULL, NULL, NULL);
 599     ok(hwnd != NULL, "err: %d\n", GetLastError());
 600     if (hwnd)
 601     {
 602         HDC hdc;
 603         int iPixelFormat, res;
 604         HGLRC hglrc;
 605         DWORD error;
 606         ShowWindow(hwnd, SW_SHOW);
 607
 608         hdc = GetDC(hwnd);
 609
 610         iPixelFormat = ChoosePixelFormat(hdc, &pfd);
 611         if(iPixelFormat == 0)
 612         {
 613             /* This should never happen as ChoosePixelFormat always returns a closest match, but currently this fails in Wine if we don't have glX */
 614             win_skip("Unable to find pixel format.\n");
 615             goto cleanup;
 616         }
 617
 618         /* We shouldn't be able to create a context from a hdc which doesn't have a pixel format set */
 619         hglrc = wglCreateContext(hdc);
 620         ok(hglrc == NULL, "wglCreateContext should fail when no pixel format has been set, but it passed\n");
 621         error = GetLastError();
 622         ok(error == ERROR_INVALID_PIXEL_FORMAT, "expected ERROR_INVALID_PIXEL_FORMAT for wglCreateContext without a pixelformat set, but received %#x\n", error);
 623
 624         res = SetPixelFormat(hdc, iPixelFormat, &pfd);
 625         ok(res, "SetPixelformat failed: %x\n", GetLastError());
 626
 627         test_dc(hwnd, hdc);
 628
 629         hglrc = wglCreateContext(hdc);
 630         res = wglMakeCurrent(hdc, hglrc);
 631         ok(res, "wglMakeCurrent failed!\n");
 632         if(res)
 633         {
 634             trace("OpenGL renderer: %s\n", glGetString(GL_RENDERER));
 635             trace("OpenGL driver version: %s\n", glGetString(GL_VERSION));
 636             trace("OpenGL vendor: %s\n", glGetString(GL_VENDOR));
 637         }
 638         else
 639         {
 640             skip("Skipping OpenGL tests without a current context\n");
 641             return;
 642         }
 643
 644         /* Initialisation of WGL functions depends on an implicit WGL context. For this reason we can't load them before making
 645          * any WGL call :( On Wine this would work but not on real Windows because there can be different implementations (software, ICD, MCD).
 646          */
 647         init_functions();
 648         /* The lack of wglGetExtensionsStringARB in general means broken software rendering or the lack of decent OpenGL support, skip tests in such cases */
 649         if (!pwglGetExtensionsStringARB)
 650         {
 651             win_skip("wglGetExtensionsStringARB is not available\n");
 652             return;
 653         }
 654
 655         test_makecurrent(hdc);
 656         test_setpixelformat(hdc);
 657         test_sharelists(hdc);
 658         test_colorbits(hdc);
 659         test_gdi_dbuf(hdc);
 660
 661         wgl_extensions = pwglGetExtensionsStringARB(hdc);
 662         if(wgl_extensions == NULL) skip("Skipping opengl32 tests because this OpenGL implementation doesn't support WGL extensions!\n");
 663
 664         if(strstr(wgl_extensions, "WGL_ARB_create_context"))
 665             test_opengl3(hdc);
 666
 667         if(strstr(wgl_extensions, "WGL_ARB_make_current_read"))
 668             test_make_current_read(hdc);
 669         else
 670             skip("WGL_ARB_make_current_read not supported, skipping test\n");
 671
 672         if(strstr(wgl_extensions, "WGL_ARB_pbuffer"))
 673             test_pbuffers(hdc);
 674         else
 675             skip("WGL_ARB_pbuffer not supported, skipping pbuffer test\n");
 676
 677 cleanup:
 678         ReleaseDC(hwnd, hdc);
 679         DestroyWindow(hwnd);
 680     }
 681 }